Пример #1
0
void
grn_test_assert_error_helper (grn_rc expected_rc, const gchar *expected_message,
                              grn_ctx *context, const gchar *expression)
{
  if (!context) {
    cut_test_with_user_message(
      cut_assert_null_helper(context, expression),
      cut_message("context should not NULL"));
  } else if (context->rc == expected_rc &&
             cut_equal_string(expected_message, context->errbuf)) {
    cut_test_pass();
  } else {
    cut_test_fail(cut_take_printf("<%s>\n"
                                  "expected: <%s>(%s)\n"
                                  "  actual: <%s>(%s)\n"
                                  "%s:%d: %s():",
                                  expression,
                                  expected_message,
                                  grn_rc_to_string(expected_rc),
                                  context->errbuf,
                                  grn_rc_to_string(context->rc),
                                  context->errfile, context->errline,
                                  context->errfunc));
  }
}
void
milter_assert_equal_list_string_with_sort_helper (GList *expected,
                                                  GList *actual,
                                                  const gchar  *expression_expected,
                                                  const gchar  *expression_actual)
{
    GList *sorted_expected, *sorted_actual;
    sorted_expected = g_list_sort(expected, (GCompareFunc)strcmp);
    sorted_actual = g_list_sort(actual, (GCompareFunc)strcmp);

    if (gcut_list_equal_string(sorted_expected, sorted_actual)) {
        cut_test_pass();
    } else {
        const gchar *message;
        const gchar *inspected_expected, *inspected_actual;

        inspected_expected = cut_take_string(gcut_list_inspect_string(sorted_expected));
        inspected_actual = cut_take_string(gcut_list_inspect_string(sorted_actual));

        message = cut_take_printf("<%s == %s>\n"
                "expected: <%s>\n"
                "  actual: <%s>",
                expression_expected, expression_actual,
                inspected_expected,
                inspected_actual);
        message = cut_append_diff(message, inspected_expected, inspected_actual);
        cut_test_fail(message);
    }
}
void
milter_assert_equal_symbols_table_helper (GHashTable *expected,
                                          GHashTable *actual,
                                          const gchar *expression_expected,
                                          const gchar *expression_actual)
{
    if (milter_test_equal_symbols_table(expected, actual)) {
        cut_test_pass();
    } else {
        gchar *inspected_expected, *inspected_actual;
        const gchar *message;

        inspected_expected = milter_test_inspect_symbols_table(expected);
        inspected_actual = milter_test_inspect_symbols_table(actual);
        message = cut_take_printf("<%s> == <%s>\n"
                                  "expected: <%s>\n"
                                  "  actual: <%s>",
                                  expression_expected, expression_actual,
                                  inspected_expected,
                                  inspected_actual);
        if (expected && actual)
            message = cut_append_diff(message,
                                      inspected_expected, inspected_actual);
        g_free(inspected_expected);
        g_free(inspected_actual);
        cut_test_fail(message);
    }
}
void
soupcut_client_assert_equal_body_helper (const gchar   *expected,
                                         SoupCutClient *client,
                                         const gchar   *expression_expected,
                                         const gchar   *expression_client)
{
    const gchar *body;
    SoupMessage *message;

    message = soupcut_client_get_latest_message(client);
    if (!message) {
        soupcut_test_fail_null_message(client, expression_client);
    }

    body = message->response_body->data;
    if (cut_utils_equal_string(expected, body)) {
        cut_test_pass();
    } else {
        cut_set_expected(cut_take_inspect_string(expected));
        cut_set_actual(cut_take_inspect_string(body));
        cut_test_fail(
            cut_take_printf("<%s == latest_message(%s)[response][body]>",
                            expression_expected,
                            expression_client));
    }
}
void
soupcut_client_assert_match_body_helper (const gchar   *pattern,
                                         SoupCutClient *client,
                                         const gchar   *expression_pattern,
                                         const gchar   *expression_client)
{
    const gchar *body;
    SoupMessage *message;

    message = soupcut_client_get_latest_message(client);
    if (!message) {
        soupcut_test_fail_null_message(client, expression_client);
    }

    body = message->response_body->data;
    if (cut_utils_regex_match(pattern, body)) {
        cut_test_pass();
    } else {
        cut_set_actual(cut_take_inspect_string(body));
        cut_test_fail(
            cut_take_printf("<%s> =~ <latest_message(%s)[response][body]>\n"
                            " pattern: <%s>",
                            expression_pattern,
                            expression_client,
                            cut_take_inspect_string(pattern)));
    }
}
void
milter_assert_equal_option_helper (MilterOption *expected,
                                   MilterOption *actual,
                                   const gchar  *expression_expected,
                                   const gchar  *expression_actual)
{
    if (gcut_object_equal(G_OBJECT(expected), G_OBJECT(actual),
                          (GEqualFunc)milter_option_equal)) {
        cut_test_pass();
    } else {
        gchar *inspected_expected, *inspected_actual;
        const gchar *message;

        inspected_expected = gcut_object_inspect(G_OBJECT(expected));
        inspected_actual = gcut_object_inspect(G_OBJECT(actual));
        message = cut_take_printf("<%s> == <%s>\n"
                                  "expected: <%s>\n"
                                  "  actual: <%s>",
                                  expression_expected, expression_actual,
                                  inspected_expected, inspected_actual);
        message = cut_append_diff(message,
                                  inspected_expected, inspected_actual);
        cut_test_fail(message);
    }
}
void
soupcut_client_assert_equal_content_type_helper (const gchar *expected,
                                                 SoupCutClient *client,
                                                 const gchar *expression_expected,
                                                 const gchar *expression_client)
{
    const gchar *content_type;
    SoupMessage *message;

    message = soupcut_client_get_latest_message(client);
    if (!message) {
        soupcut_test_fail_null_message(client, expression_client);
    }

    content_type = soupcut_message_get_content_type(message);
    if (cut_utils_equal_string(expected, content_type)) {
        cut_test_pass();
    } else {
        cut_set_expected(cut_take_inspect_string(expected));
        cut_set_actual(cut_take_inspect_string(content_type));
        cut_test_fail(
            cut_take_printf("<%s == latest_message(%s)[response][content-type]>",
                            expression_expected,
                            expression_client));
    }
}
Пример #8
0
void
grn_test_assert_not_nil_helper(grn_id id, const gchar *expression)
{
  if (id != GRN_ID_NIL) {
    cut_test_pass();
  } else {
    cut_test_fail(cut_take_printf("<%s> != <GRN_ID_NIL>\n"
                                  "expected: <%u> is not <%u>",
                                  expression, id, GRN_ID_NIL));
  }
}
Пример #9
0
void
grn_test_assert_not_null_helper (grn_ctx *context,
                                 grn_obj *object, const gchar *expression)
{
  if (object) {
    cut_test_pass();
  } else {
    cut_test_fail(cut_take_printf("expected: <%s> is not NULL",
                                  expression));
  }
}
void
grn_test_memcached_assert_helper(memcached_return rc, const gchar *expression)
{
  if (rc == MEMCACHED_SUCCESS) {
    cut_test_pass();
  } else {
    cut_test_fail(cut_take_printf("expected: <%s> == MEMCACHED_SUCCESS\n"
                                  " but was: <%s>",
                                  expression,
                                  grn_memcached_rc_to_string(rc)));
  }
}
Пример #11
0
void
grn_test_assert_helper(grn_rc rc, const gchar *expression)
{
  if (rc == GRN_SUCCESS) {
    cut_test_pass();
  } else {
    cut_test_fail(cut_take_printf("expected: <%s> == grn_success\n"
                                  " but was: <%s>",
                                  expression,
                                  grn_rc_to_string(rc)));
  }
}
Пример #12
0
void
grn_test_assert_nil_helper(grn_id id, const gchar *expression)
{
  if (id == GRN_ID_NIL) {
    cut_test_pass();
  } else {
    cut_test_fail(cut_take_printf("<%s> == <GRN_ID_NIL>\n"
                                  "expected: <%u>\n"
                                  " but was: <%u>",
                                  expression,
                                  GRN_ID_NIL, id));
  }
}
Пример #13
0
void
grn_test_assert_equal_rc_helper(grn_rc expected, grn_rc actual,
                                const gchar *expression_expected,
                                const gchar *expression_actual)
{
  if (expected == actual) {
    cut_test_pass();
  } else {
    cut_test_fail(cut_take_printf("<%s> == <%s>\n"
                                  "expected: <%s>\n"
                                  " but was: <%s>",
                                  expression_expected,
                                  expression_actual,
                                  grn_rc_to_string(expected),
                                  grn_rc_to_string(actual)));
  }
}
void
soupcut_message_assert_equal_content_type_helper (const gchar *expected,
                                                  SoupMessage *message,
                                                  const gchar *expression_expected,
                                                  const gchar *expression_message)
{
    const gchar *content_type;

    content_type = soupcut_message_get_content_type(message);
    if (cut_utils_equal_string(expected, content_type)) {
        cut_test_pass();
    } else {
        cut_set_expected(cut_take_inspect_string(expected));
        cut_set_actual(cut_take_inspect_string(content_type));
        cut_test_fail(cut_take_printf("<%s == %s[response][content-type]>",
                                       expression_expected,
                                       expression_message));
    }
}
static void
soupcut_test_fail_null_message (SoupCutClient *client,
                                const gchar *expression_client)
{
    GString *message;
    const gchar *fail_message;
    const gchar *inspected_client;

    message = g_string_new(NULL);
    g_string_append_printf(message,
                           "<latest_message(%s) != NULL>\n",
                           expression_client);
    inspected_client = gcut_object_inspect(G_OBJECT(client));
    g_string_append_printf(message,
                           "    client: <%s>",
                           inspected_client);
    fail_message = cut_take_string(g_string_free(message, FALSE));
    cut_test_fail(fail_message);
}
Пример #16
0
CPPCUT_DECL void
cut::assert_equal_reference<std::type_info>(const std::type_info& expected,
                                            const std::type_info& actual,
                                            const char *expression_expected,
                                            const char *expression_actual)
{
    if (expected == actual) {
        cut_test_pass();
    } else {
        std::ostringstream message;

        cut_set_expected(expected.name());
        cut_set_actual(actual.name());

        message << "<" << expression_expected << " == ";
        message << expression_actual << ">";
        cut_test_fail(message.str().c_str());
    }
}
Пример #17
0
void
grn_test_assert_null_helper (grn_ctx *context,
                             grn_obj *object, const gchar *expression)
{
  if (!object) {
    cut_test_pass();
  } else {
    GString *inspected;
    const gchar *taken_inspected;

    inspected = g_string_new(NULL);
    grn_test_object_inspect(inspected, context, object);
    taken_inspected = cut_take_string(inspected->str);
    cut_test_fail(cut_take_printf("expected: <%s> is NULL\n"
                                  "  actual: <%s>",
                                  expression,
                                  taken_inspected));
  }
}
Пример #18
0
void
grn_test_assert_context_helper (grn_ctx *context, const gchar *expression)
{
  if (!context) {
    cut_set_message("context should not NULL");
    cut_assert_null_helper(context, expression);
  } else if (context->rc == GRN_SUCCESS) {
    cut_test_pass();
  } else {
    cut_test_fail(cut_take_printf("<(%s)->rc> != <GRN_SUCCESS>\n"
                                  "expected: <%s> is <%s>\n"
                                  "%s:%d: %s(): %s",
                                  expression,
                                  grn_rc_to_string(context->rc),
                                  grn_rc_to_string(GRN_SUCCESS),
                                  context->errfile, context->errline,
                                  context->errfunc, context->errbuf));
  }
}
Пример #19
0
void
grn_test_assert_equal_id_helper(grn_ctx *context,
                                grn_id expected, grn_id actual,
                                const gchar *expression_context,
                                const gchar *expression_expected,
                                const gchar *expression_actual)
{
  if (expected == actual) {
    cut_test_pass();
  } else {
    grn_obj *expected_object, *actual_object;
    grn_obj inspected_expected_object, inspected_actual_object;

    expected_object = grn_ctx_at(context, expected);
    actual_object = grn_ctx_at(context, actual);
    GRN_TEXT_INIT(&inspected_expected_object, 0);
    GRN_TEXT_INIT(&inspected_actual_object, 0);
    grn_inspect(context, &inspected_expected_object, expected_object);
    grn_inspect(context, &inspected_actual_object, actual_object);
    cut_set_expected(
      cut_take_printf("%d: <%.*s>",
                      expected,
                      (int)GRN_TEXT_LEN(&inspected_expected_object),
                      GRN_TEXT_VALUE(&inspected_expected_object)));
    cut_set_actual(
      cut_take_printf("%d: <%.*s>",
                      actual,
                      (int)GRN_TEXT_LEN(&inspected_actual_object),
                      GRN_TEXT_VALUE(&inspected_actual_object)));
    grn_obj_unlink(context, &inspected_expected_object);
    grn_obj_unlink(context, &inspected_actual_object);
    grn_obj_unlink(context, expected_object);
    grn_obj_unlink(context, actual_object);
    cut_test_fail(cut_take_printf("<%s> == <%s> (%s)\n"
                                  " context: <%p>",
                                  expression_expected,
                                  expression_actual,
                                  expression_context,
                                  context));
  }
}
Пример #20
0
void
grn_test_assert_send_command_error_helper (grn_ctx     *context,
                                           grn_rc       expected_rc,
                                           const gchar *expected_message,
                                           const gchar *command,
                                           const gchar *expected_rc_expression,
                                           const gchar *expected_message_expression,
                                           const gchar *command_expression)
{
  const gchar **lines;

  lines = cut_take_string_array(g_strsplit(command, "\n", 0));
  for (; *lines; lines++) {
    grn_ctx_send(context, *lines, strlen(*lines), 0);
    if (context->rc) {
      break;
    }
  }

  if (context->rc == expected_rc &&
      cut_equal_string(expected_message, context->errbuf)) {
    gchar *command_result;
    unsigned int command_result_length;
    int flags = 0;

    cut_test_pass();
    grn_ctx_recv(context, &command_result, &command_result_length, &flags);
  } else {
    cut_set_expected(cut_take_printf("<%s>(%s)",
                                     expected_message,
                                     grn_rc_to_string(expected_rc)));
    cut_set_actual(cut_take_printf("<%s>(%s)",
                                   context->errbuf,
                                   grn_rc_to_string(context->rc)));
    cut_test_fail(cut_take_printf("<send(\"%s\")>\n"
                                  "%s:%d: %s():",
                                  command_expression,
                                  context->errfile, context->errline,
                                  context->errfunc));
  }
}
void soupcut_client_assert_response_helper (SoupCutClient *client,
                                            const gchar   *expression_client)
{
    SoupMessage *message;

    message = soupcut_client_get_latest_message(client);
    if (!message) {
        soupcut_test_fail_null_message(client, expression_client);
    }

    if (200 <= message->status_code && message->status_code < 300) {
        cut_test_pass();
    } else {
        cut_set_expected("2XX");
        cut_set_actual(cut_take_printf("%u(%s)",
                                       message->status_code,
                                       message->reason_phrase));
        cut_test_fail(
            cut_take_printf("<latest_message(%s)[response][status] == 2XX>",
                            expression_client));
    }
}
Пример #22
0
void
grn_test_assert_equal_type_helper(grn_ctx *context,
                                  unsigned char expected,
                                  unsigned char actual,
                                  const gchar *expression_context,
                                  const gchar *expression_expected,
                                  const gchar *expression_actual)
{
  if (expected == actual) {
    cut_test_pass();
  } else {
    grn_obj inspected_expected, inspected_actual;

    GRN_TEXT_INIT(&inspected_expected, 0);
    GRN_TEXT_INIT(&inspected_actual, 0);
    grn_inspect_type(context, &inspected_expected, expected);
    grn_inspect_type(context, &inspected_actual, actual);
    cut_set_expected(
      cut_take_printf("%x: <%.*s>",
                      expected,
                      (int)GRN_TEXT_LEN(&inspected_expected),
                      GRN_TEXT_VALUE(&inspected_expected)));
    cut_set_actual(
      cut_take_printf("%x: <%.*s>",
                      actual,
                      (int)GRN_TEXT_LEN(&inspected_actual),
                      GRN_TEXT_VALUE(&inspected_actual)));
    grn_obj_unlink(context, &inspected_expected);
    grn_obj_unlink(context, &inspected_actual);
    cut_test_fail(cut_take_printf("<%s> == <%s> (%s)\n"
                                  " context: <%p>",
                                  expression_expected,
                                  expression_actual,
                                  expression_context,
                                  context));
  }
}
Пример #23
0
void
grn_test_assert_equal_record_id_helper(grn_ctx *context, grn_obj *table,
                                       grn_id expected, grn_id actual,
                                       const gchar *expression_context,
                                       const gchar *expression_table,
                                       const gchar *expression_expected,
                                       const gchar *expression_actual)
{
  if (expected == actual) {
    cut_test_pass();
  } else {
    gchar key[GRN_TABLE_MAX_KEY_SIZE];
    int key_size;
    const gchar *message;
    grn_obj inspected_table;

    key_size = grn_table_get_key(context, table, expected, key, sizeof(key));
    cut_set_expected(cut_take_printf("%d: <%.*s>", expected, key_size, key));
    key_size = grn_table_get_key(context, table, actual, key, sizeof(key));
    cut_set_actual(cut_take_printf("%d: <%.*s>", actual, key_size, key));

    GRN_TEXT_INIT(&inspected_table, 0);
    grn_inspect(context, &inspected_table, table);
    message = cut_take_printf("<%s> == <%s> (context: <%s>, table: <%s>)\n"
                              " context: <%p>\n"
                              "   table: <%.*s>",
                              expression_expected,
                              expression_actual,
                              expression_context,
                              expression_table,
                              context,
                              (int)GRN_TEXT_LEN(&inspected_table),
                              GRN_TEXT_VALUE(&inspected_table));
    grn_obj_unlink(context, &inspected_table);
    cut_test_fail(message);
  }
}