END_TEST START_TEST(test_delete) { bool s; struct hdfs_object *e = NULL; const char *tf = "/HADOOFUS_TEST_DELETE", *client = "HADOOFUS_CLIENT"; hdfs_create(h, tf, 0644, client, true/*overwrite*/, false/*createparent*/, 1/*replication*/, 64*1024*1024, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); s = hdfs_delete(h, tf, false/*recurse*/, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); ck_assert_msg(s, "delete returned false"); }
END_TEST START_TEST (test_read_string) { FILE *f = fopen ("test_files/test_string_read.scm", "r"); if (f == NULL) ck_abort_msg ("file reading didn't work\n"); object *o = read (f); ck_assert_str_eq (o->data.string.value, "abc"); }
END_TEST START_TEST(test_abandonBlock) { bool s; struct hdfs_object *e = NULL, *lb, *bl; const char *tf = "/HADOOFUS_TEST_ABANDONBLOCK", *client = "HADOOFUS_CLIENT"; // Create the file first hdfs_create(h, tf, 0644, client, true/*overwrite*/, false/*createparent*/, 1/*replication*/, 64*1024*1024, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); mark_point(); // XXX this must be updated to cover v2.0+ (last_block/fileid) lb = hdfs_addBlock(h, tf, client, NULL, NULL, 0, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); ck_assert(!hdfs_object_is_null(lb)); mark_point(); bl = hdfs_block_from_located_block(lb); hdfs_object_free(lb); mark_point(); hdfs_abandonBlock(h, bl, tf, client, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); hdfs_object_free(bl); mark_point(); // Cleanup s = hdfs_delete(h, tf, false/*recurse*/, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); ck_assert_msg(s, "delete returned false"); }
END_TEST START_TEST(test_check_failure_lnos) { int i; int line_no; int passed = 0; int failed; TestResult *tr; /* Create list of line numbers where failures occurred */ rewind(line_num_failures); for (i = 0; i < sub_ntests; i++) { if (master_tests[i].failure_type == CK_PASS) { passed++; continue; } failed = i - passed; ck_assert_msg(i - passed <= sub_nfailed, NULL); tr = tr_fail_array[failed]; ck_assert_msg(tr != NULL, NULL); line_no = get_next_failure_line_num(line_num_failures); if(line_no == -1) { ck_abort_msg("Did not find the %dth failure line number for suite %s, msg %s", (failed+1), tr_tcname(tr), tr_msg(tr)); } if (line_no > 0 && tr_lno(tr) != line_no) { ck_abort_msg("For test %d (failure %d): Expected lno %d, got %d for suite %s, msg %s", i, failed, line_no, tr_lno(tr), tr_tcname(tr), tr_msg(tr)); } } /* At this point, there should be no remaining failures */ line_no = get_next_failure_line_num(line_num_failures); ck_assert_msg(line_no == -1, "No more failure line numbers expected, but found %d", line_no); }
END_TEST START_TEST (test_nested_lambda) { FILE *f = fopen ("test_files/test_nested_lambda.scm", "r"); if (f == NULL) ck_abort_msg ("file reading didn't work\n"); interpret (f, true); }
END_TEST START_TEST(test_renewLease) { struct hdfs_object *e = NULL; hdfs_renewLease(h, "HADOOFUS_CLIENT", &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); }
END_TEST START_TEST(test_path_append_zero) { Node *path = path_append (0.0, 0.0); if (path_current_node(path)->x != 0.0 || path_current_node(path)->y != 0.0) { ck_abort_msg("Zero is a valid value"); } }
END_TEST START_TEST(test_money_create_zero) { Money *m = money_create(0, "USD"); if (money_amount(m) != 0) { ck_abort_msg("Zero is a valid amount of money"); } }
END_TEST START_TEST(test_fork2_pass) { pid_t pid; pid_t pid2; if((pid = check_fork()) < 0) { ck_abort_msg("Failed to fork new process"); } else if (pid > 0) { if((pid2 = check_fork()) < 0) { ck_abort_msg("Failed to fork new process"); } else if (pid2 == 0) { ck_assert_msg(1, NULL); check_waitpid_and_exit(0); } check_waitpid_and_exit(pid2); } check_waitpid_and_exit(pid); }
END_TEST START_TEST (words_with_unknown_letters_should_be_rejected) { int rc = varnam_learn (varnam_instance, "test"); if (rc != VARNAM_ERROR) { ck_abort_msg ("Expected return code to be VARNAM_ERROR"); } ck_assert_str_eq (varnam_get_last_error (varnam_instance), "Can't process 't'. One or more characters in 'test' are not known"); }
END_TEST START_TEST(test_getBlockLocations) { struct hdfs_object *e = NULL, *bls; bls = hdfs_getBlockLocations(h, "/", 0L, 1000L, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); ck_assert_msg(hdfs_object_is_null(bls)); ck_assert_msg(hdfs_null_type(bls) == H_LOCATED_BLOCKS); }
void assert_error (int value) { strbuf *string = NULL; if (value != VARNAM_ERROR) { string = strbuf_init (50); strbuf_addf (string, "Expected VARNAM_ERROR, but got %d. %s", value, varnam_get_last_error (varnam_instance)); ck_abort_msg (strbuf_to_s (string)); } }
void setup(void) { ulcd = ulcd_new(); ulcd_set_baud_rate(ulcd, 115200); strcpy(ulcd->device, "/dev/ttyAMA0"); if (ulcd_open_serial_device(ulcd)) { ck_abort_msg("Could not open serial port."); } ulcd_set_serial_parameters(ulcd); }
END_TEST START_TEST(test_getStats) { struct hdfs_object *e = NULL, *stats; stats = hdfs_getStats(h, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); hdfs_object_free(stats); }
END_TEST START_TEST(test_getServerDefaults) { struct hdfs_object *object, *e = NULL; object = hdfs2_getServerDefaults(h, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); hdfs_object_free(object); }
END_TEST START_TEST(test_fork2_fail) { pid_t pid; pid_t pid2; if((pid = check_fork()) < 0) { ck_abort_msg("Failed to fork new process"); } else if (pid > 0) { if((pid2 = check_fork()) < 0) { ck_abort_msg("Failed to fork new process"); } else if (pid2 == 0) { ck_abort_msg("Expected fail"); check_waitpid_and_exit(0); } check_waitpid_and_exit(pid2); ck_abort_msg("Expected fail"); } check_waitpid_and_exit(pid); }
END_TEST START_TEST(test_atree_random_value) { ATree *at; gint result; gint key; gint data; gint *random; at = a_tree_new(); if (at == NULL) { ck_abort_msg ("Failed to create ATree\n"); } else { key = 1; data = 1; g_rand_set_seed( at->random, 0 ); result = atree_insert( at, GINT_TO_POINTER(&key), GINT_TO_POINTER(&data) ); ck_assert_int_eq( result, 0 ); random = atree_random_value( at ); if (random == NULL) { ck_abort_msg ("random values is NULL\n"); } else { ck_assert_int_eq( *random, data ); } a_tree_destroy( at ); } }
END_TEST START_TEST (test_enq_add_ring) { int err; if ((err = memif_init (control_fd_update, TEST_APP_NAME, NULL, NULL, NULL)) != MEMIF_ERR_SUCCESS) ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err)); memif_connection_t conn; conn.msg_queue = NULL; conn.rx_queues = (memif_queue_t *) malloc (sizeof (memif_queue_t)); conn.tx_queues = (memif_queue_t *) malloc (sizeof (memif_queue_t)); memif_queue_t *mq = conn.tx_queues; uint8_t dir = MEMIF_RING_S2M; mq->int_fd = 5; mq->offset = 0; mq->log2_ring_size = 10; if ((err = memif_msg_enq_add_ring (&conn, 0, dir)) != MEMIF_ERR_SUCCESS) ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err)); memif_msg_queue_elt_t *e = conn.msg_queue; ck_assert_uint_eq (e->msg.type, MEMIF_MSG_TYPE_ADD_RING); ck_assert_int_eq (e->fd, mq->int_fd); memif_msg_add_ring_t *ar = &e->msg.add_ring; ck_assert_uint_eq (ar->index, 0); ck_assert_uint_eq (ar->offset, mq->offset); ck_assert_uint_eq (ar->log2_ring_size, mq->log2_ring_size); ck_assert (ar->flags & MEMIF_MSG_ADD_RING_FLAG_S2M); dir = MEMIF_RING_M2S; if ((err = memif_msg_enq_add_ring (&conn, 0, dir)) != MEMIF_ERR_SUCCESS) ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err)); queue_free (&conn.msg_queue); }
END_TEST START_TEST(test_getBlockLocations2) { struct hdfs_object *e = NULL, *e2 = NULL, *bls; const char *tf = "/HADOOFUS_TEST_GET_BLOCK_LOCATIONS2", *client = "HADOOFUS_CLIENT"; hdfs_create(h, tf, 0644, client, true/*overwrite*/, false/*createparent*/, 1/*replication*/, 64*1024*1024, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); bls = hdfs_getBlockLocations(h, tf, 0L, 1000L, &e); hdfs_delete(h, tf, false/*recurse*/, &e2); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); if (e2) ck_abort_msg("exception: %s", hdfs_exception_get_message(e2)); ck_assert_msg(bls->ob_type == H_LOCATED_BLOCKS); }
END_TEST START_TEST(test_setQuota) { bool s; struct hdfs_object *e = NULL; const char *tf = "/HADOOFUS_TEST_SETQUOTA"; s = hdfs_mkdirs(h, tf, 0755, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); ck_assert_msg(s, "mkdirs returned false"); hdfs_setQuota(h, tf, -1, -1, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); s = hdfs_delete(h, tf, false/*recurse*/, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); ck_assert_msg(s, "delete returned false"); }
END_TEST START_TEST(test_getFileInfo) { struct hdfs_object *e = NULL, *fs; fs = hdfs_getFileInfo(h, "/", &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); ck_assert(!hdfs_object_is_null(fs)); hdfs_object_free(fs); }
END_TEST START_TEST (varnam_export_full) { int rc, pcnt, wcnt, i; float filecnt; strbuf* f; strbuf* error; f = strbuf_init (20); pcnt = execute_query_int (varnam_instance->internal->known_words, "select count(*) from patterns_content;"); wcnt = execute_query_int (varnam_instance->internal->known_words, "select count(*) from words;"); rc = varnam_export_words (varnam_instance, 2, "output/", VARNAM_EXPORT_FULL, NULL); assert_success (rc); filecnt = pcnt / 2; for (i = 0; i < (int) ceil (filecnt); i++) { strbuf_clear (f); strbuf_addf (f, "output/%d.patterns.txt", i); if (!file_exist (strbuf_to_s (f))) { error = strbuf_init (10); strbuf_addf (error, "Failed to find file: %s\n", strbuf_to_s (f)); ck_abort_msg (strbuf_to_s (error)); } } filecnt = wcnt / 2; for (i = 0; i < (int) ceil (filecnt); i++) { strbuf_clear (f); strbuf_addf (f, "output/%d.words.txt", i); if (!file_exist (strbuf_to_s (f))) { error = strbuf_init (10); strbuf_addf (error, "Failed to find file: %s\n", strbuf_to_s (f)); ck_abort_msg (strbuf_to_s (error)); } } strbuf_destroy (f); }
END_TEST START_TEST(test_getListing) { struct hdfs_object *e = NULL, *listing; listing = hdfs_getListing(h, "/", NULL, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); ck_assert(!hdfs_object_is_null(listing)); hdfs_object_free(listing); }
static void write_file(Tox *tox, uint32_t friendnumber, uint32_t filenumber, uint64_t position, const uint8_t *data, size_t length, void *user_data) { if (size_recv != position) { ck_abort_msg("Bad position"); } if (length == 0) { file_recv = 1; return; } VLA(uint8_t, f_data, length); memset(f_data, num, length); ++num; if (memcmp(f_data, data, length) == 0) { size_recv += length; } else { ck_abort_msg("FILE_CORRUPTED"); } }
END_TEST START_TEST(test_distributedUpgradeProgress) { struct hdfs_object *e, *us; e = NULL; us = hdfs_distributedUpgradeProgress(h, HDFS_UPGRADEACTION_STATUS, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); hdfs_object_free(us); us = hdfs_distributedUpgradeProgress(h, HDFS_UPGRADEACTION_DETAILED, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); hdfs_object_free(us); #if 0 us = hdfs_distributedUpgradeProgress(HDFS_UPGRADEACTION_FORCE_PROCEED); #endif }
END_TEST START_TEST(test_setSafeMode) { struct hdfs_object *e; bool b; e = NULL; b = hdfs_setSafeMode(h, HDFS_SAFEMODE_GET, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); b = hdfs_setSafeMode(h, HDFS_SAFEMODE_ENTER, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); b = hdfs_setSafeMode(h, HDFS_SAFEMODE_LEAVE, &e); if (e) ck_abort_msg("exception: %s", hdfs_exception_get_message(e)); (void)b; }
static void remove_library_from_list(const char *library, char **list, size_t list_size) { for (size_t i = 0; i < list_size; ++i) { if (list[i] != NULL && strcmp(library, list[i]) == 0) { /* found library need to be removed from list */ free(list[i]); list[i] = NULL; return; } } ck_abort_msg("Cannot find expected library: %s", library); }
END_TEST START_TEST(test_check_tcnames) { const char *tcname; tcname = tr_tcname(tr_all_array[_i]); if (strcmp(tcname, master_tests[_i].tcname) != 0) { char *emsg = (char *)malloc (MAXSTR); snprintf(emsg, MAXSTR,"Expected %s, got %s", master_tests[_i].tcname, tcname); ck_abort_msg(emsg); free(emsg); } }
static void tox_connection_status(Tox *tox, TOX_CONNECTION connection_status, void *user_data) { if (*((uint32_t *)user_data) != 974536) { return; } if (connected_t1 && !connection_status) { ck_abort_msg("Tox went offline"); } ck_assert_msg(connection_status == TOX_CONNECTION_UDP, "wrong status %u", connection_status); connected_t1 = connection_status; }
void execute_query (sqlite3* db, const char* sql) { int rc; sqlite3_stmt* stmt; strbuf* error; rc = sqlite3_prepare_v2 (db, sql, -1, &stmt, NULL); if (rc != SQLITE_OK) { error = strbuf_init (50); strbuf_addf (error, "Failed to prepare query: %s. Return code was: %d\n", sql, rc); ck_abort_msg (strbuf_to_s (error)); } rc = sqlite3_step (stmt); if (rc != SQLITE_DONE) { error = strbuf_init (50); strbuf_addf (error, "Failed to execute query: %s. Return code was: %d\n", sql, rc); ck_abort_msg (strbuf_to_s (error)); } sqlite3_finalize (stmt); }