static void test_hash_speed(const void *opaque) { size_t chunk_size = (size_t)opaque; uint8_t *in = NULL, *out = NULL; size_t out_len = 0; double total = 0.0; struct iovec iov; int ret; in = g_new0(uint8_t, chunk_size); memset(in, g_test_rand_int(), chunk_size); iov.iov_base = (char *)in; iov.iov_len = chunk_size; g_test_timer_start(); do { ret = qcrypto_hash_bytesv(QCRYPTO_HASH_ALG_SHA256, &iov, 1, &out, &out_len, NULL); g_assert(ret == 0); total += chunk_size; } while (g_test_timer_elapsed() < 5.0); total /= MiB; g_print("sha256: "); g_print("Testing chunk_size %zu bytes ", chunk_size); g_print("done: %.2f MB in %.2f secs: ", total, g_test_timer_last()); g_print("%.2f MB/sec\n", total / g_test_timer_last()); g_free(out); g_free(in); }
/** * test_visitor_register_identity: * @fn test_visitor_register_identity * Tests whether compilerkit_visitor_register_identity function works as intended. * @pre None * @param None * @return void */ void test_visitor_register_identity (void) { GObject *symbol; GObject *empty_set; CompilerKitVisitor *visitor; g_test_message ("Testing visitor register identity"); g_test_timer_start (); symbol = compilerkit_symbol_new ('a'); empty_set = compilerkit_empty_set_get_instance (); visitor = compilerkit_visitor_new(); // Register the identity function (it returns whatever GObject* gets as a parameter during the visit) compilerkit_visitor_register_identity (visitor, COMPILERKIT_TYPE_EMPTY_SET); // Since we didn't register the symbol, the visitor should return NULL g_assert (compilerkit_visitor_visit (visitor, symbol) == NULL); // The visitor should produce symbol here, since we registered the identity function for the symbol class. g_assert (compilerkit_visitor_visit (visitor, empty_set) == empty_set); // Decrease the reference count for objects to free them. g_object_unref (symbol); g_object_unref (empty_set); g_object_unref (visitor); // This test shouldn't take too long to run g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
static void test_reorder (void) { guint n = g_test_perf () ? 1000000 : 100; GtkRBTree *tree; GtkRBNode *node; gint *reorder; guint i; double elapsed; reorder = fisher_yates_shuffle (n); tree = create_unsorted_tree (reorder, n); g_test_timer_start (); _gtk_rbtree_reorder (tree, reorder, n); elapsed = g_test_timer_elapsed (); if (g_test_perf ()) g_test_minimized_result (elapsed, "reordering rbtree with %u items: %gsec", n, elapsed); _gtk_rbtree_test (tree); for (node = _gtk_rbtree_first (tree), i = 0; node != NULL; node = _gtk_rbtree_next (tree, node), i++) { g_assert (GTK_RBNODE_GET_HEIGHT (node) == i); } g_assert (i == n); _gtk_rbtree_free (tree); }
void test_creation(GThreadFunc f, sc_int32 count, sc_int thread_count) { int test_count = count / thread_count; g_message("Threads count: %d, Test per thread: %d", thread_count, test_count); tGThreadVector threads; threads.reserve(thread_count); print_storage_statistics(); g_test_timer_start(); for (size_t i = 0; i < thread_count; ++i) { GThread * thread = g_thread_try_new(0, f, GINT_TO_POINTER(test_count), 0); if (thread == 0) continue; threads.push_back(thread); } for (size_t i = 0; i < thread_count; ++i) g_assert(GPOINTER_TO_INT(g_thread_join(threads[i])) == test_count); printf("Time: %lf\n", g_test_timer_elapsed()); print_storage_statistics(); }
/** * test_FSM_state: * @fn test_FSM_state * Tests `compilerkit_FSM_*_state` in CompilerKitFSM struct. * @pre None * @param None * @return void */ void test_FSM_states (void) { CompilerKitFSM *fsm; g_test_message ("Testing FSM state"); g_test_timer_start (); fsm = compilerkit_FSM_new ("zero"); compilerkit_FSM_add_state (fsm, "one"); compilerkit_FSM_add_state (fsm, "two"); compilerkit_FSM_add_state (fsm, "three"); g_assert (compilerkit_FSM_has_state (fsm, "zero")); g_assert (compilerkit_FSM_has_state (fsm, "one")); g_assert (compilerkit_FSM_has_state (fsm, "two")); g_assert (compilerkit_FSM_has_state (fsm, "three")); g_assert (!compilerkit_FSM_has_state (fsm, "four")); g_assert (!compilerkit_FSM_has_state (fsm, NULL)); compilerkit_FSM_add_transition (fsm, "zero", "five", '5'); compilerkit_FSM_add_accepting_state (fsm, "six"); g_assert (compilerkit_FSM_has_state (fsm, "five")); g_assert (compilerkit_FSM_has_state (fsm, "six")); g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); g_object_unref (fsm); }
/** * test_visitor_null_visit: * @fn test_visitor_null_visit * Tests whether compilerkit_visitor_visit produces appropriate results in the CompilerKitVisitor struct. * @pre None * @param None * @return void */ void test_visitor_null_visit(void) { GObject *symbol; GObject *empty_set; CompilerKitVisitor* visitor; g_test_message ("Testing visitor null visits"); g_test_timer_start (); symbol = compilerkit_symbol_new ('a'); empty_set = compilerkit_empty_set_get_instance (); visitor = check_symbol(); // Assert that visitor produces the correct result g_assert(compilerkit_visitor_visit(visitor, symbol) == symbol); // NULL objects will produce NULL g_assert(compilerkit_visitor_visit(visitor, NULL) == NULL); // Nothing registered for empty set, so return NULL g_assert(compilerkit_visitor_visit(visitor, empty_set) == NULL); // Decrease the reference count for objects to free them. g_object_unref (symbol); g_object_unref (empty_set); g_object_unref (visitor); // This test shouldn't take too long to run g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
static void wmem_time_allocators(void) { double simple_time, block_time; g_test_timer_start(); wmem_time_allocator(WMEM_ALLOCATOR_SIMPLE); simple_time = g_test_timer_elapsed(); g_test_timer_start(); wmem_time_allocator(WMEM_ALLOCATOR_BLOCK); block_time = g_test_timer_elapsed(); printf("(simple: %lf; block: %lf) ", simple_time, block_time); g_assert(simple_time > block_time); }
/** * test_symbol_flyweight: * @fn test_symbol_unicode * Tests whether compilerkit_symbol_new in CompilerKitSymbol struct allocates new space only for unique symbols. * @pre None * @param None * @return void */ void test_symbol_flyweight (void) { CompilerKitSymbol *symbol1, *symbol2, *symbol3; g_test_message ("Testing Symbol unicode"); g_test_timer_start (); /** @todo Test here */ symbol1 = COMPILERKIT_SYMBOL (compilerkit_symbol_new('a')); symbol2 = COMPILERKIT_SYMBOL (compilerkit_symbol_new('b')); symbol3 = COMPILERKIT_SYMBOL (compilerkit_symbol_new('a')); /* Symbol b is distinct from Symbol a */ g_assert (symbol2 != symbol3); g_assert (symbol2 != symbol1); /* The pointer to Symbol('a') should equal the pointer to Symbol('a'). This of course, would make Ayn Rand proud ;-) */ g_assert (symbol1 == symbol3); g_object_unref(symbol1); g_object_unref(symbol2); g_object_unref(symbol3); g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
/** * test_alternation_vlist_new: * @fn test_alternation_vlist_new * Tests method compilerkit_alternation_vlist_new in CompilerKitAlternation struct. * @pre None * @param None * @return void */ void test_alternation_vlist_new (void) { GObject* alt; GObject* one; GObject* two; GObject* three; g_test_message ("Testing Alternation vlist new"); g_test_timer_start (); one = compilerkit_symbol_new('a'); two = compilerkit_symbol_new('b'); three = compilerkit_symbol_new('c'); alt = compilerkit_alternation_vlist_new(one, two, three, NULL); g_assert (COMPILERKIT_IS_ALTERNATION(alt)); g_assert (one != two); g_assert (two != three); g_assert (one != three); g_assert (one != alt); g_assert (two != alt); g_assert (three != alt); g_assert (three == compilerkit_alternation_get_right(COMPILERKIT_ALTERNATION(alt))); g_assert (one == compilerkit_alternation_get_left(COMPILERKIT_ALTERNATION(compilerkit_alternation_get_left(COMPILERKIT_ALTERNATION(alt))))); g_assert (two == compilerkit_alternation_get_right(COMPILERKIT_ALTERNATION(compilerkit_alternation_get_left(COMPILERKIT_ALTERNATION(alt))))); g_object_unref (alt); // This will unref one, two and three as well g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
gpointer start_save_threaded(gpointer data) { g_test_timer_start(); sc_memory_save(s_default_ctx); printf("Save time: %lf\n", g_test_timer_elapsed()); return 0; }
/** * test_complement_constructor: * @fn test_complement_constructor * Tests method compilerkit_complement_new in CompilerKitComplement struct. * @pre None * @param None * @return void */ void test_complement_constructor (void) { g_test_message ("Testing Complement method"); g_test_timer_start (); /** @todo Test here */ g_assert(FALSE); g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
/** * test_concatenation_method: * @fn test_concatenation_method * Tests method compilerkit_concatenation_method in CompilerKitConcatenation struct. * @pre None * @param None * @return void */ void test_concatenation_method (void) { g_test_message ("Testing Concatenation method"); g_test_timer_start (); /** @todo Test here */ g_assert(FALSE); g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
/** * test_scanner_method: * @fn test_scanner_method * Tests method compilerkit_scanner_method in CompilerKitScanner struct. * @pre None * @param None * @return void */ void test_scanner_method (void) { g_test_message ("Testing Scanner method"); g_test_timer_start (); /** @todo Test here */ g_assert(FALSE); g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
/** * test_pushdown_automata_method: * @fn test_pushdown_automata_method * Tests method compilerkit_pushdown_automata_method in CompilerKitPushdownAutomata struct. * @pre None * @param None * @return void */ void test_pushdown_automata_method (void) { g_test_message ("Testing PushdownAutomata method"); g_test_timer_start (); /** @todo Test here */ g_assert(FALSE); g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
/** * test_empty_string_method: * @fn test_empty_string_method * Tests method compilerkit_empty_string_method in CompilerKitEmptyString struct. * @pre None * @param None * @return void */ void test_empty_string_method (void) { g_test_message ("Testing EmptyString method"); g_test_timer_start (); /** @todo Test here */ g_assert(FALSE); g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
void perf_002(G_GNUC_UNUSED gpointer *fixture, G_GNUC_UNUSED gconstpointer data) { gint log = 1000000; g_test_timer_start(); for (gint i = 0; i < log; ++i) { log4g_error("%d log this message", i); } gdouble e = g_test_timer_elapsed(); g_test_minimized_result(e, "logged messages, rate=%d/second", (gint)(log / e)); }
void perf_003(G_GNUC_UNUSED gpointer *fixture, G_GNUC_UNUSED gconstpointer data) { gint log = 1000000; FILE *file = fopen("tests/file.txt", "w"); g_test_timer_start(); for (gint i = 0; i < log; ++i) { fprintf(file, "%d log this message\n", i); } gdouble e = g_test_timer_elapsed(); g_test_minimized_result(e, "logged messages, rate=%d/second", (gint)(log / e)); }
void test_g_test_timer() { double ret_time1, ret_time2; g_test_timer_start(); ret_time1 = g_test_timer_elapsed(); ret_time2 = g_test_timer_last(); if(!(ret_time1 == ret_time2)) { std_log(LOG_FILENAME_LINE, "g_test_timer* didnt work as expected"); assert_failed = 1; } }
static void test_immediate_performance_n_tasks(TestFixture *fixture, const void *data, int n_tasks) { int i, j; if (!g_test_perf()) return; /* this has to be set up front of there's a race in using it to * decide to quit mainloop, because task runner starts running * tasks right away, doesn't wait for our local mainloop */ fixture->tasks_started_count = n_tasks; /* start here, to include task creation. Also, immediates can start * running right away, before we block in main loop. */ g_test_timer_start(); for (i = 0; i < n_tasks; ++i) { HrtTask *task; task = hrt_task_runner_create_task(fixture->runner); #define NUM_IMMEDIATES 4 for (j = 0; j < NUM_IMMEDIATES; ++j) { hrt_task_add_immediate(task, on_immediate_for_performance_many_tasks, fixture, on_dnotify_bump_count); } } g_main_loop_run(fixture->loop); g_test_minimized_result(g_test_timer_elapsed(), "Run %d tasks with %d immediates each", n_tasks, NUM_IMMEDIATES); g_assert_cmpint(fixture->tasks_completed_count, ==, n_tasks); g_assert_cmpint(fixture->tasks_completed_count, ==, fixture->tasks_started_count); g_assert_cmpint(fixture->dnotify_count, ==, NUM_IMMEDIATES * n_tasks); #undef NUM_IMMEDIATES }
static void test_echo (Fixture *f, gconstpointer context G_GNUC_UNUSED) { guint count = 2000; guint sent; guint received = 0; double elapsed; if (g_test_perf ()) count = 100000; add_echo_filter (f); g_test_timer_start (); for (sent = 0; sent < count; sent++) { DBusMessage *m = dbus_message_new_method_call ( dbus_bus_get_unique_name (f->right_conn), "/", "com.example", "Spam"); DBusPendingCall *pc; if (m == NULL) g_error ("OOM"); if (!dbus_connection_send_with_reply (f->left_conn, m, &pc, DBUS_TIMEOUT_INFINITE) || pc == NULL) g_error ("OOM"); if (dbus_pending_call_get_completed (pc)) pc_count (pc, &received); else if (!dbus_pending_call_set_notify (pc, pc_count, &received, NULL)) g_error ("OOM"); dbus_pending_call_unref (pc); dbus_message_unref (m); } while (received < count) g_main_context_iteration (NULL, TRUE); elapsed = g_test_timer_elapsed (); g_test_maximized_result (count / elapsed, "%u messages / %f seconds", count, elapsed); }
/** * test_string_builder_visitor: * @fn test_string_builder_visitor * Tests compilerkit_string_builder_visitor. * @pre None * @param None * @return void */ void test_string_builder_case (void) { CompilerKitVisitor *string_builder; g_test_message ("Testing StringBuilder visitor"); g_test_timer_start (); /** @todo Test here */ string_builder = compilerkit_string_builder_visitor(); g_assert(FALSE); g_object_unref (string_builder); // This test shouldn't take too long to run g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
/** * test_production_case: * @fn test_production_case * Tests compilerkit_production_case in CompilerKitProduction struct. * @pre None * @param None * @return void */ void test_production_case (void) { //CompilerKitProduction *obj; g_test_message ("Testing Production case"); g_test_timer_start (); /** @todo Test here */ g_assert(FALSE); //g_object_unref (obj); // This test shouldn't take too long to run g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
/** * test_derivative_visitor: * @fn test_derivative_visitor * Tests compilerkit_derivative_visitor. * @pre None * @param None * @return void */ void test_derivative_case (void) { CompilerKitVisitor *derivative; g_test_message ("Testing Derivative visitor"); g_test_timer_start (); /** @todo Test here */ derivative = compilerkit_derivative_visitor(); g_assert(FALSE); g_object_unref (derivative); // This test shouldn't take too long to run g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
/** * test_FSM_start_state: * @fn test_FSM_set_start_state * Tests `compilerkit_FSM_*_start_state` in CompilerKitFSM struct. * @pre None * @param None * @return void */ void test_FSM_start_state (void) { CompilerKitFSM *fsm; g_test_message ("Testing FSM start_state"); g_test_timer_start (); fsm = compilerkit_FSM_new ("constructor"); g_assert (g_strcmp0 (compilerkit_FSM_get_start_state (fsm), "constructor") == 0); compilerkit_FSM_set_start_state (fsm, "start_state"); g_assert (g_strcmp0 (compilerkit_FSM_get_start_state (fsm), "start_state") == 0); g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); g_object_unref (fsm); }
/** * test_to_grammar_visitor: * @fn test_to_grammar_visitor * Tests compilerkit_to_grammar_visitor. * @pre None * @param None * @return void */ void test_to_grammar_visitor (void) { CompilerKitVisitor *to_grammar; g_test_message ("Testing ToGrammar visitor"); g_test_timer_start (); /** @todo Test here */ to_grammar = compilerkit_to_grammar_visitor(); g_assert(FALSE); g_object_unref (to_grammar); // This test shouldn't take too long to run g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
/** * test_symbol_unicode: * @fn test_symbol_unicode * Tests compilerkit_symbol_new in CompilerKitSymbol struct for the ability to deal with Unicode (specifically, UTF-8). * @pre None * @param None * @return void */ void test_symbol_unicode (void) { CompilerKitSymbol *symbol; g_test_message ("Testing Symbol unicode"); g_test_timer_start (); gunichar ch = g_utf8_get_char("台"); symbol = COMPILERKIT_SYMBOL (compilerkit_symbol_new(ch)); g_assert(compilerkit_symbol_get_symbol (symbol) == ch /*'台'*/ ); g_object_unref(symbol); g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); }
/** * test_FSM_state: * @fn test_FSM_state * Tests `compilerkit_FSM_*_state` in CompilerKitFSM struct. * @pre None * @param None * @return void */ void test_FSM_states (void) { CompilerKitFSM *fsm; g_test_message ("Testing FSM state"); g_test_timer_start (); fsm = compilerkit_FSM_new ("zero"); compilerkit_FSM_add_transition(fsm,"zero","one","a"); compilerkit_FSM_add_transition(fsm,"zero","two","b"); g_assert(compilerkit_FSM_has_state(fsm,"zero")); g_assert(compilerkit_FSM_has_state(fsm,"one")); g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1); g_object_unref (fsm); }
static void perf_lifecycle(void) { Coroutine *coroutine; unsigned int i, max; double duration; max = 1000000; g_test_timer_start(); for (i = 0; i < max; i++) { coroutine = qemu_coroutine_create(empty_coroutine); qemu_coroutine_enter(coroutine, NULL); } duration = g_test_timer_elapsed(); g_test_message("Lifecycle %u iterations: %f s\n", max, duration); }
static void magic_uri_performance (void) { gsize i; g_test_timer_start (); for (i = 0; i < 1000; i++) { magic_uri_uri (); magic_uri_idn (); magic_uri_search (); magic_uri_pseudo (); } g_print ("\nTime needed for URI tests: %f ", g_test_timer_elapsed ()); }
static void perf_yield(void) { unsigned int i, maxcycles; double duration; maxcycles = 100000000; i = maxcycles; Coroutine *coroutine = qemu_coroutine_create(yield_loop); g_test_timer_start(); while (i > 0) { qemu_coroutine_enter(coroutine, &i); } duration = g_test_timer_elapsed(); g_test_message("Yield %u iterations: %f s\n", maxcycles, duration); }