コード例 #1
0
/**
 * test_server_loop() 関数テスト
 *
 * @return なし
 */
void
test_server_loop(void)
{
    pid_t cpid = 0; /* 子プロセスID */
    pid_t w = 0;    /* wait戻り値 */
    int status = 0; /* wait引数 */
    int retval = 0; /* 戻り値 */
    int count = 1;  /* ループカウント */

    if (set_port_string(port) < 0)
        cut_error("set_port_string");
    ssock = server_sock();

    cpid = fork();
    if (cpid < 0) {
        cut_error("fork(%d)", errno);
        return;
    }

    if (cpid == 0) {
        dbglog("child");

        count = 2;
        g_sig_handled = 1;
        while (count--)
            server_loop(ssock);
        exit(EXIT_SUCCESS);

    } else {
        dbglog("parent: cpid=%d", (int)cpid);

        csock = inet_sock_client();
        if (csock < 0)
            return;

        /* 送信 */
        retval = send_client(csock, expr, sizeof(expr));
        if (retval < 0) {
            cut_error("send_client: csock=%d(%d)", csock, errno);
            return;
        }

        /* 受信 */
        retval = recv_client(csock, readbuf);
        if (retval < 0) {
            cut_error("recv_client: csock=%d(%d)", csock, errno);
            return;
        }

        cut_assert_equal_string((char *)expected, (char *)readbuf);

        w = wait(&status);
        if (w < 0)
            cut_notify("wait(%d)", errno);
        dbglog("w=%d", (int)w);
    }
}
コード例 #2
0
ファイル: test_timer.c プロジェクト: sluchin/calc
/**
 * print_timer() 関数テスト
 *
 * @return なし
 */
void
test_print_timer(void)
{
    unsigned int t = 0, time = 0; /* タイマ用変数 */
    int fd = -1;                  /* ファイルディスクリプタ */
    int retval = 0;               /* 戻り値 */
    char actual[BUF_SIZE] = {0};  /* 実際の文字列 */
    const char expected[] =       /* 期待する文字列 */
        "time of time: [0-9]+\\.[0-9]+\\[msec\\]";

    start_timer(&t);
    time = stop_timer(&t);
    fd = pipe_fd(STDERR_FILENO);
    if (fd < 0) {
        cut_error("pipe_fd=%d(%d)", fd, errno);
        return;
    }

    print_timer(time);

    retval = read(fd, actual, sizeof(actual));
    if (retval < 0) {
        cut_fail("read=%d(%d)", fd, errno);
        goto error_handler;
    }
    dbglog("actual=%s", actual);

    cut_assert_match(expected, actual,
                     cut_message("expected=%s actual=%s",
                                 expected, actual));

error_handler:
    close_fd(&fd, NULL);
}
コード例 #3
0
/**
 * test_server_sock() 関数テスト
 *
 * @return なし
 */
void
test_server_sock(void)
{
    dbglog("start");

    if (set_port_string(port) < 0)
        cut_error("set_port_string");
    ssock = server_sock();
    dbglog("server_sock=%d", ssock);

    cut_assert_not_equal_int(EX_NG, ssock);

    csock = inet_sock_client();
    if (csock < 0)
        cut_error("inet_sock_client");

}
コード例 #4
0
static void
stub_error_iterated_test (gconstpointer data)
{
    cut_assert_true(TRUE, cut_message("always pass"));
    if (GPOINTER_TO_INT(data) == 2)
        MARK_FAIL(cut_error("ERROR!"));
    cut_assert_true(TRUE, cut_message("always pass if come here"));
}
コード例 #5
0
static void
stub_error_in_data_setup_iterated_data (void)
{
    cut_add_data("First", GINT_TO_POINTER(1), NULL,
		 NULL);
    cut_add_data("Second", GINT_TO_POINTER(2), NULL,
		 NULL);
    cut_error("error in data setup");
    cut_add_data("Third", GINT_TO_POINTER(3), NULL,
                 NULL);
}
コード例 #6
0
ファイル: test-hash.c プロジェクト: hayamiz/groonga
static void
not_uint32_size_key_increment(grn_test_data *test_data)
{
  gchar *string = test_data->key;
  gint i;

  for (i = 0; i < not_uint32_key_size; i++) {
    if (string[i] < '~') {
      string[i]++;
      return;
    }
  }
  cut_error("can't increment more!: %s", string);
}
コード例 #7
0
ファイル: test-string.c プロジェクト: mooz/groonga
void
test_aton(gconstpointer data)
{
  const gchar *input, *input_end, *rest;
  grn_builtin_type type;
  grn_rc rc;

  type = gcut_data_get_int(data, "type");
  input = gcut_data_get_string(data, "input");
  input_end = strchr(input, '\0');
  rc = grn_aton(&context, input, input_end, &rest, &buffer);
  grn_test_assert(rc);
  cut_assert_equal_string(input_end, rest);
  cut_assert_equal_int(type, buffer.header.domain);
  switch (type) {
  case GRN_DB_INT32 :
    cut_assert_equal_int(gcut_data_get_int(data, "expected"),
                         GRN_INT32_VALUE(&buffer));
    break;
  case GRN_DB_UINT32 :
    cut_assert_equal_uint(gcut_data_get_uint(data, "expected"),
                          GRN_UINT32_VALUE(&buffer));
    break;
  case GRN_DB_INT64 :
    gcut_assert_equal_int64(gcut_data_get_int64(data, "expected"),
                            GRN_INT64_VALUE(&buffer));
    break;
  case GRN_DB_UINT64 :
    gcut_assert_equal_uint64(gcut_data_get_uint64(data, "expected"),
                             GRN_UINT64_VALUE(&buffer));
    break;
  case GRN_DB_FLOAT :
    cut_assert_equal_double(gcut_data_get_double(data, "expected"),
                            0.000001,
                            GRN_FLOAT_VALUE(&buffer));
    break;
  default :
    cut_error("unknown type: %d", type);
    break;
  }
}
コード例 #8
0
/**
 * test_server_proc() 関数テスト
 *
 * @return なし
 */
void
test_server_proc(void)
{
    pid_t cpid = 0;         /* 子プロセスID */
    pid_t w = 0;            /* wait戻り値 */
    int status = 0;         /* wait引数 */
    int retval = 0;         /* 戻り値 */
    thread_data *dt = NULL; /* ソケット情報構造体 */
    void *servret = NULL;   /* テスト関数戻り値 */

    if (set_port_string(port) < 0)
        cut_error("set_port_string");
    ssock = server_sock();

    cpid = fork();
    if (cpid < 0) {
        cut_error("fork(%d)", errno);
        return;
    }

    if (cpid == 0) {
        dbglog("child");

        dt = (thread_data *)malloc(sizeof(thread_data));
        if (!dt) {
            outlog("malloc: size=%zu", sizeof(thread_data));
            exit(EXIT_FAILURE);
        }
        (void)memset(dt, 0, sizeof(thread_data));

        dt->len = (socklen_t)sizeof(dt->addr);
        dt->sock = accept(ssock, (struct sockaddr *)&dt->addr, &dt->len);
        if (dt->sock < 0) {
            outlog("accept: ssock=%d", ssock);
            memfree((void **)&dt, NULL);
            exit(EXIT_FAILURE);
        }
        g_sig_handled = 1;

        /* テスト関数実行 */
        servret = server.server_proc(dt);
        if (servret) {
            outlog("server_proc");
            exit(EXIT_FAILURE);
        }

        exit(EXIT_SUCCESS);

    } else {
        dbglog("parent: cpid=%d", (int)cpid);

        csock = inet_sock_client();
        if (csock < 0)
            return;

        /* 送信 */
        retval = send_client(csock, expr, sizeof(expr));
        if (retval < 0) {
            cut_error("send_client: csock=%d(%d)", csock, errno);
            return;
        }

        /* 受信 */
        retval = recv_client(csock, readbuf);
        if (retval < 0) {
            cut_error("recv_client: csock=%d(%d)", csock, errno);
            return;
        }

        cut_assert_equal_string((char *)expected, (char *)readbuf);

        w = wait(&status);
        if (w < 0)
            cut_notify("wait(%d)", errno);
        dbglog("w=%d", (int)w);
        if (WEXITSTATUS(status))
            cut_error("child failed");
    }
}
コード例 #9
0
static void
stub_error_test (void)
{
    MARK_FAIL(cut_error("This test should error"));
}
コード例 #10
0
ファイル: test_readline.c プロジェクト: sluchin/calc
/**
 * readline() 実行
 *
 * @param[in] data テストデータ
 * @param[in] length バイト数
 * @return 結果文字列
 */
static unsigned char *
exec_readline(char *data, size_t length)
{
    FILE *fp = NULL; /* ファイルポインタ */
    int retval = 0;  /* 戻り値 */
    pid_t cpid = 0;  /* プロセスID */
    pid_t w = 0;     /* wait戻り値 */
    int status = 0;  /* ステイタス */
    ssize_t len = 0; /* writen 戻り値 */

    retval = pipe(pfd);
    if (retval < 0) {
        cut_error("pipe=%d", retval);
        return NULL;
    }

    fp = fdopen(pfd[PIPE_R], "r");
    if (!fp) {
        cut_error("fdopen=%p", fp);
        return NULL;
    }

    cpid = fork();
    if (cpid < 0) {
        cut_error("fork(%d)", errno);
        return NULL;
    }

    if (cpid == 0) { /* 子プロセス */
        dbglog("child");

        close_fd(&pfd[PIPE_R], NULL);

        /* 送信 */
        len = writen(pfd[PIPE_W], data, length);
        if (len < 0) {
            outlog("writen");
            close_fd(&pfd[PIPE_W], NULL);
            exit(EXIT_FAILURE);
        }
        close_fd(&pfd[PIPE_W], NULL);
        exit(EXIT_SUCCESS);

    } else { /* 親プロセス */
        dbglog("parent: cpid=%d", (int)cpid);

        close_fd(&pfd[PIPE_W], NULL);

        /* テスト関数の実行 */
        /* 受信待ち */
        result = _readline(fp);
        dbglog("result=%s", result);

        close_fd(&pfd[PIPE_R], NULL);
        w = waitpid(-1, &status, WNOHANG);
        if (w < 0)
            cut_notify("wait: status=%d(%d)", status, errno);
        dbglog("w=%d", (int)w);
        if (WEXITSTATUS(status)) {
            cut_notify("child error");
            return NULL;
        }
    }
    return result;
}