static void test_delete_reference_property(gs_grid_storage_t * gs) { char **prop_array = parameters_init(); char *nameRef = test_init(gs, "Ref_params", prop_array); char *deleted_key[] = { prop_array[0], NULL }; char *keys[] = { prop_array[0], prop_array[1], NULL }; gchar **result = NULL; gs_error_t *err = hc_delete_reference_property(gs, nameRef, deleted_key); if (err == NULL) { hc_get_reference_property(gs, nameRef, keys, &result); g_assert_true(result[1] == NULL); g_assert_true(strstr(result[0], prop_array[3]) != NULL); } else g_test_fail(); parameters_delete(prop_array); test_end(gs, nameRef, NULL); }
static void test_set_container_quota(gs_grid_storage_t * gs) { char *nameRef = test_init(gs, "Ref_linked", NULL); char *nameCont = gen_random(7); gs_container_t *container = container_init(gs, nameCont); gs_error_t *err2 = hc_set_container_quota(container, "test"); g_assert_true(err2 == NULL); test_end(gs, nameRef, container); }
void test_train_moves_trailing_car_onto_track(test_train_context* test_ctx, const void* data) { #pragma unused(data) sem_world* world = &(test_ctx->world); sem_train* train = test_ctx->train; sem_track track_E_W; sem_track_set(&track_E_W, SEM_EAST, SEM_WEST); sem_track track_W_S; sem_track_set(&track_W_S, SEM_WEST, SEM_SOUTH); sem_track track_N_S; sem_track_set(&track_N_S, SEM_NORTH, SEM_SOUTH); sem_tile_set_track(sem_tile_at(world, 0, 0), &track_E_W); sem_tile_set_track(sem_tile_at(world, 1, 0), &track_W_S); sem_tile_set_track(sem_tile_at(world, 1, 1), &track_N_S); train->state = MOVING; train->direction = SEM_SOUTH; sem_car car1; sem_coordinate_set(&(car1.position), 1, 0); car1.track = &track_W_S; sem_car car2; sem_coordinate_set(&(car2.position), 0, 0); car2.track = &track_E_W; sem_train_add_car(train, &car1); sem_train_add_car(train, &car2); sem_train_move_outcome outcome; sem_train_move(train, &outcome); g_assert_true(train->head_car->track == &track_N_S); g_assert_true(train->head_car->next->track == &track_W_S); }
void test_dynamic_array_remove_item(sem_dynamic_array* a, const void* data) { #pragma unused(data) char* item1 = "hello"; char* item2 = "world"; sem_dynamic_array_add(a, item1); sem_dynamic_array_add(a, item2); sem_dynamic_array_remove(a, item1); g_assert_cmpuint(a->tail_idx, ==, 1); g_assert_true(a->items[0] == item2); }
static void _adg_behavior_entity(void) { AdgCanvas *canvas; const CpmlExtents *extents; AdgTitleBlock *title_block; canvas = ADG_CANVAS(adg_test_canvas()); adg_entity_arrange(ADG_ENTITY(canvas)); extents = adg_entity_get_extents(ADG_ENTITY(canvas)); g_assert_true(extents->is_defined); adg_assert_isapprox(extents->size.x, 1); adg_assert_isapprox(extents->size.y, 1); adg_entity_invalidate(ADG_ENTITY(canvas)); extents = adg_entity_get_extents(ADG_ENTITY(canvas)); g_assert_false(extents->is_defined); title_block = adg_title_block_new(); adg_canvas_set_title_block(canvas, title_block); adg_entity_arrange(ADG_ENTITY(canvas)); extents = adg_entity_get_extents(ADG_ENTITY(canvas)); g_assert_true(extents->is_defined); g_assert_cmpfloat(extents->size.x, >, 1); g_assert_cmpfloat(extents->size.y, >, 1); g_assert_cmpfloat(extents->size.x, <, 5000); g_assert_cmpfloat(extents->size.y, <, 5000); adg_canvas_set_size_explicit(canvas, 5000, 5000); adg_entity_arrange(ADG_ENTITY(canvas)); extents = adg_entity_get_extents(ADG_ENTITY(canvas)); g_assert_true(extents->is_defined); adg_assert_isapprox(extents->size.x, 5000); adg_assert_isapprox(extents->size.y, 5000); adg_entity_destroy(ADG_ENTITY(canvas)); }
static void _adg_property_has_extension2(void) { AdgADim *adim; gboolean invalid_boolean; gboolean has_extension2; adim = adg_adim_new(); invalid_boolean = (gboolean) 1234; /* Using the public APIs */ adg_adim_switch_extension2(adim, FALSE); has_extension2 = adg_adim_has_extension2(adim); g_assert_false(has_extension2); adg_adim_switch_extension2(adim, invalid_boolean); has_extension2 = adg_adim_has_extension2(adim); g_assert_false(has_extension2); adg_adim_switch_extension2(adim, TRUE); has_extension2 = adg_adim_has_extension2(adim); g_assert_true(has_extension2); /* Using GObject property methods */ g_object_set(adim, "has-extension2", FALSE, NULL); g_object_get(adim, "has-extension2", &has_extension2, NULL); g_assert_false(has_extension2); g_object_set(adim, "has-extension2", invalid_boolean, NULL); g_object_get(adim, "has-extension2", &has_extension2, NULL); g_assert_false(has_extension2); g_object_set(adim, "has-extension2", TRUE, NULL); g_object_get(adim, "has-extension2", &has_extension2, NULL); g_assert_true(has_extension2); adg_entity_destroy(ADG_ENTITY(adim)); }
void test_mod_color(lfFixture *lfFix, gconstpointer data) { lfTestParams *p = (lfTestParams *)data; for(size_t y = 0; y < lfFix->img_height; y++) { T *imgdata = (T *)lfFix->image + (size_t)p->cpp * y * lfFix->img_width; g_assert_true( lfFix->mod->ApplyColorModification( imgdata, 0.0, y, lfFix->img_width, 1, p->comp_role, p->cpp * lfFix->img_width)); } }
char * frida_test_process_backend_filename_of (void * handle) { #ifdef HAVE_QNX g_assert_true (handle == &frida_magic_self_handle); struct dlopen_handle ** _handle = dlopen (NULL, RTLD_LAZY); struct dlopen_handle * p_u = *(_handle); return g_strdup (p_u->p_lm->l_path); #else return g_file_read_link ("/proc/self/exe", NULL); #endif }
static void test_str2bool() { int err; bool value; err = str2bool("yes", &value); g_assert_cmpint(err, ==, 0); g_assert_true(value); err = str2bool("1", &value); g_assert_cmpint(err, ==, 0); g_assert_true(value); err = str2bool("no", &value); g_assert_cmpint(err, ==, 0); g_assert_false(value); err = str2bool("0", &value); g_assert_cmpint(err, ==, 0); g_assert_false(value); err = str2bool("", &value); g_assert_cmpint(err, ==, 0); g_assert_false(value); err = str2bool(NULL, &value); g_assert_cmpint(err, ==, 0); g_assert_false(value); err = str2bool("flower", &value); g_assert_cmpint(err, ==, -1); g_assert_cmpint(errno, ==, EINVAL); err = str2bool("yes", NULL); g_assert_cmpint(err, ==, -1); g_assert_cmpint(errno, ==, EFAULT); }
/* static void test_delete_content_property(gs_grid_storage_t * gs) { gs_error_t **err = NULL; gchar **result = NULL; char *nameRef = test_init(gs, "Ref_linked", NULL); char *nameCont = gen_random(7); gs_container_t *container = container_init(gs, nameCont); hc_ul_content_from_file(gs, nameCont, "Content", "file_test.txt", err); gs_content_t *nameContent = gs_get_content_from_path(container, "Content", err); char *props[] = { "key1=value1", "key2=value2", NULL }; char *propDel[] = { "key1", NULL }; hc_set_content_property(nameContent, props, err); hc_delete_content_property(nameContent, propDel, err); g_assert_true(err == NULL); hc_get_content_properties(nameContent, &result, err); g_assert_true(err == NULL); if (result == NULL) g_test_fail(); else g_assert_true(strcmp(result[0], "key2=value2") == 0); gs_content_free(nameContent); test_end(gs, nameRef, container); } */ static void test_copy_content(gs_grid_storage_t * gs) { gs_error_t **err = NULL; char *nameRef = test_init(gs, "Ref_linked", NULL); char *nameCont = gen_random(7); gs_container_t *container = container_init(gs, nameCont); hc_ul_content_from_file(gs, nameCont, "Content", "file_test.txt", err); gs_content_t *nameContent = gs_get_content_from_path(container, "Content", err); hc_copy_content(container, "Content", "Content_copy", err); g_assert_true(err == NULL); gs_content_t *nameContent2 = gs_get_content_from_path(container, "Content_copy", err); g_assert_true(nameContent != NULL); gs_content_free(nameContent); gs_content_free(nameContent2); test_end(gs, nameRef, container); }
static void test_queue_stalled (void) { struct oio_events_queue_s *q = oio_events_queue_factory__create_agent ("inproc://X", 100); g_assert_nonnull (q); g_assert_false (oio_events_queue__is_stalled (q)); for (guint i=0; i<100 ;++i) oio_events_queue__send (q, g_strdup ("x")); /* XXX(jfs): ugly way to give a chance to the internal thread to consume events and update counters. */ g_thread_yield (); g_usleep (100 * G_TIME_SPAN_MILLISECOND); g_assert_true (oio_events_queue__is_stalled (q)); for (guint i=0; i<1000 ;++i) oio_events_queue__send (q, g_strdup ("x")); g_assert_true (oio_events_queue__is_stalled (q)); oio_events_queue__run_agent (q, immediately_done); oio_events_queue__destroy (q); }
/* The hierarchy looks like this: * /tmp/first_dir/first_child/second_child * /tmp/second_dir * We're copying first_dir to second_dir. */ static void test_copy_second_hierarchy (void) { g_autoptr (GFile) root = NULL; g_autoptr (GFile) first_dir = NULL; g_autoptr (GFile) second_dir = NULL; g_autoptr (GFile) file = NULL; g_autoptr (GFile) result_file = NULL; g_autolist (GFile) files = NULL; create_second_hierarchy ("copy"); root = g_file_new_for_path (g_get_tmp_dir ()); first_dir = g_file_get_child (root, "copy_first_dir"); files = g_list_prepend (files, g_object_ref (first_dir)); g_assert_true (first_dir != NULL); file = g_file_get_child (first_dir, "copy_first_child"); g_assert_true (file != NULL); file = g_file_get_child (file, "copy_second_child"); g_assert_true (file != NULL); second_dir = g_file_get_child (root, "copy_second_dir"); g_assert_true (second_dir != NULL); nautilus_file_operations_copy_sync (files, second_dir); result_file = g_file_get_child (second_dir, "copy_first_dir"); g_assert_true (g_file_query_exists (result_file, NULL)); file = g_file_get_child (result_file, "copy_first_child"); g_assert_true (g_file_query_exists (file, NULL)); file = g_file_get_child (file, "copy_second_child"); g_assert_true (g_file_query_exists (file, NULL)); file = g_file_get_child (result_file, "copy_first_child"); g_assert_true (g_file_query_exists (file, NULL)); file = g_file_get_child (first_dir, "copy_first_child"); file = g_file_get_child (file, "copy_second_child"); file = g_file_get_child (first_dir, "copy_first_child"); empty_directory_by_prefix (root, "copy"); }
void test_mod_color_parallel(lfFixture *lfFix, gconstpointer data) { const lfTestParams *const p = (lfTestParams *)data; #pragma omp parallel for schedule(static) for(size_t y = 0; y < lfFix->img_height; y++) { T *imgdata = (T *)lfFix->image + (size_t)p->cpp * y * lfFix->img_width; g_assert_true( lfFix->mod->ApplyColorModification( imgdata, 0.0, y, lfFix->img_width, 1, p->comp_role, p->cpp * lfFix->img_width)); } }
static void signature_loopback(void) { GBytes *content = read_file("test/openssl-ca/manifest", NULL); GBytes *sig = NULL; g_assert_nonnull(content); sig = cms_sign(content, r_context()->certpath, r_context()->keypath, NULL); g_assert_nonnull(sig); g_assert_true(cms_verify(content, sig, NULL)); ((char *)g_bytes_get_data(content, NULL))[0] = 0x00; g_assert_false(cms_verify(content, sig, NULL)); g_bytes_unref(content); g_bytes_unref(sig); }
void test_train_second_car_occupies_tile(test_train_context* test_ctx, const void* data) { #pragma unused(data) sem_train* train = test_ctx->train; sem_car head_car; sem_coordinate_set(&(head_car.position), 2, 0); sem_train_add_car(train, &head_car); sem_coordinate second_car_position; sem_coordinate_set(&second_car_position, 1, 0); sem_car second_car; second_car.position = second_car_position; sem_train_add_car(train, &second_car); g_assert_true(sem_train_occupies(train, &second_car_position)); }
static void _adg_property_factor(void) { AdgAlignment *alignment; CpmlPair null_factor, identity_factor; const CpmlPair *factor; CpmlPair *factor_dup; alignment = adg_alignment_new(NULL); null_factor.x = 0; null_factor.y = 0; identity_factor.x = 1; identity_factor.y = 1; /* By default, the alignment should be initialized with a null factor */ factor = adg_alignment_get_factor(alignment); g_assert_true(cpml_pair_equal(factor, &null_factor)); /* Using the public APIs */ adg_alignment_set_factor(alignment, &identity_factor); factor = adg_alignment_get_factor(alignment); g_assert_true(cpml_pair_equal(factor, &identity_factor)); adg_alignment_set_factor_explicit(alignment, 0, 0); factor = adg_alignment_get_factor(alignment); g_assert_true(cpml_pair_equal(factor, &null_factor)); adg_alignment_set_factor(alignment, NULL); factor = adg_alignment_get_factor(alignment); g_assert_true(cpml_pair_equal(factor, &null_factor)); /* Using GObject property methods */ g_object_set(alignment, "factor", &identity_factor, NULL); g_object_get(alignment, "factor", &factor_dup, NULL); g_assert_true(cpml_pair_equal(factor_dup, &identity_factor)); g_free(factor_dup); g_object_set(alignment, "factor", NULL, NULL); g_object_get(alignment, "factor", &factor_dup, NULL); g_assert_true(cpml_pair_equal(factor_dup, &identity_factor)); g_free(factor_dup); g_object_set(alignment, "factor", &null_factor, NULL); g_object_get(alignment, "factor", &factor_dup, NULL); g_assert_true(cpml_pair_equal(factor_dup, &null_factor)); g_free(factor_dup); g_object_unref(alignment); }
static void test_engine_ngspice_error_no_such_file_or_directory() { TestEngineNgspiceResources *test_resources = test_engine_ngspice_resources_new(); // make sure that the given file does not exist g_free(test_resources->resources->netlist_file); gint fd = g_file_open_tmp(NULL, &test_resources->resources->netlist_file, NULL); g_close(fd, NULL); g_remove(test_resources->resources->netlist_file); ngspice_watcher_build_and_launch(test_resources->resources); g_main_loop_run(test_resources->loop); g_assert_nonnull(test_resources->log_list); g_assert_true(g_str_has_suffix(test_resources->log_list->data, " No such file or directory\n")); test_engine_ngspice_resources_finalize(test_resources); }
static void test_wildmatch_questionmark(void) { g_assert_true(util_wildmatch("wild?atch", "wildmatch")); g_assert_true(util_wildmatch("wild?atch", "wildBatch")); g_assert_true(util_wildmatch("wild?atch", "wild?atch")); g_assert_true(util_wildmatch("?ild?atch", "MildBatch")); g_assert_true(util_wildmatch("foo\\?bar", "foo?bar")); g_assert_true(util_wildmatch("???", "foo")); g_assert_true(util_wildmatch("???", "bar")); g_assert_false(util_wildmatch("foo\\?bar", "foorbar")); g_assert_false(util_wildmatch("?", "")); g_assert_false(util_wildmatch("b??r", "bar")); /* ? does not match / in contrast to * which does */ g_assert_false(util_wildmatch("user?share", "user/share")); }
static void test_parse_bin(StateWrapper *wrapper, gconstpointer user_data) { guchar buffer[] = { 0x00, 0x06, 0x00, 0x73, 0x6f, 0x6f, 0x73, 0x68, 0x69 }; wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer, sizeof(buffer)); SooshiNode *node = g_new0(SooshiNode, 1); node->type = VAL_BIN; sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value); g_assert_nonnull(node->value); g_assert_true(g_variant_is_of_type(node->value, G_VARIANT_TYPE_BYTESTRING)); const gchar *mem = g_variant_get_bytestring(node->value); g_assert_cmpmem(mem, strlen(mem), buffer + 3, sizeof(buffer) - 3); g_free(node); }
static void _cpml_behavior_browsing(void) { CpmlSegment segment; CpmlPrimitive primitive, primitive_copy; cpml_segment_from_cairo(&segment, (cairo_path_t *) adg_test_path()); cpml_primitive_from_segment(&primitive, &segment); adg_assert_isapprox((primitive.org)->point.x, 0); adg_assert_isapprox((primitive.org)->point.y, 1); g_assert_cmpint((primitive.data)->header.type, ==, CPML_LINE); g_assert_true(cpml_primitive_next(&primitive)); adg_assert_isapprox((primitive.org)->point.x, 3); adg_assert_isapprox((primitive.org)->point.y, 1); g_assert_cmpint((primitive.data)->header.type, ==, CPML_ARC); g_assert_true(cpml_primitive_next(&primitive)); adg_assert_isapprox((primitive.org)->point.x, 6); adg_assert_isapprox((primitive.org)->point.y, 7); g_assert_cmpint((primitive.data)->header.type, ==, CPML_CURVE); g_assert_true(cpml_primitive_next(&primitive)); adg_assert_isapprox((primitive.org)->point.x, -2); adg_assert_isapprox((primitive.org)->point.y, 2); g_assert_cmpint((primitive.data)->header.type, ==, CPML_CLOSE); g_assert_false(cpml_primitive_next(&primitive)); cpml_primitive_reset(&primitive); g_assert_true(cpml_primitive_next(&primitive)); cpml_primitive_reset(&primitive); cpml_primitive_reset(&primitive); g_assert_true(cpml_primitive_next(&primitive)); g_assert_true(cpml_primitive_next(&primitive)); g_assert_true(cpml_primitive_next(&primitive)); g_assert_false(cpml_primitive_next(&primitive)); cpml_primitive_copy(&primitive_copy, &primitive); g_assert_false(cpml_primitive_next(&primitive_copy)); cpml_primitive_reset(&primitive); g_assert_false(cpml_primitive_next(&primitive_copy)); cpml_primitive_reset(&primitive_copy); g_assert_true(cpml_primitive_next(&primitive_copy)); }
static void _round_init (void) { sqlx_repository_t *repo = NULL; GError *err; err = sqlx_repository_init("/tmp", NULL, &repo); g_assert_no_error (err); for (int i=0; i<5 ;i++) sqlx_repository_set_locator (repo, _locator, NULL); for (int i=0; i<5 ;i++) g_assert_true (sqlx_repository_running (repo)); for (int i=0; i<5 ;i++) { err = sqlx_repository_configure_type(repo, type, SCHEMA); g_assert_no_error (err); } sqlx_repository_clean(repo); }
static void check(int a, int b, bool expected) { struct qht_stats stats; int i; for (i = a; i < b; i++) { void *p; uint32_t hash; int32_t val; val = i; hash = i; p = qht_lookup(&ht, is_equal, &val, hash); g_assert_true(!!p == expected); } qht_statistics_init(&ht, &stats); if (stats.used_head_buckets) { g_assert_cmpfloat(qdist_avg(&stats.chain), >=, 1.0); }
char * frida_test_process_backend_filename_of (void * handle) { guint image_count, image_idx; g_assert_true (handle == &frida_magic_self_handle); image_count = _dyld_image_count (); for (image_idx = 0; image_idx != image_count; image_idx++) { const gchar * image_path = _dyld_get_image_name (image_idx); if (g_str_has_suffix (image_path, "/frida-tests")) return g_strdup (image_path); } g_assert_not_reached (); return NULL; }
static void _adg_method_toggle_button_sensitivize(void) { GtkToggleButton *button = (GtkToggleButton *) gtk_toggle_button_new(); GtkWidget *widget = gtk_toggle_button_new(); gtk_toggle_button_set_active(button, FALSE); adg_gtk_toggle_button_sensitivize(button, widget); g_assert_false(gtk_widget_get_sensitive(widget)); gtk_toggle_button_set_active(button, TRUE); adg_gtk_toggle_button_sensitivize(button, widget); g_assert_true(gtk_widget_get_sensitive(widget)); g_object_ref_sink(button); g_object_unref(button); g_object_ref_sink(widget); g_object_unref(widget); }
static void check_new (GAsyncResult *res, GError **expected_error, GIOStream *expected_stream, GSocketAddress *expected_address) { GarilConnection *connection = garil_connection_new_finish (res, expected_error); if (expected_error != NULL) { g_assert_null (connection); g_assert_nonnull (*expected_error); return; } g_assert_true (GARIL_IS_CONNECTION (connection)); check_stream_address_flags (connection, expected_stream, expected_address); g_object_unref (connection); }
static void fu_wac_firmware_parse_func (void) { DfuElement *element; DfuImage *image; gboolean ret; g_autofree gchar *fn = NULL; g_autoptr(DfuFirmware) firmware = dfu_firmware_new (); g_autoptr(GBytes) blob_block = NULL; g_autoptr(GBytes) bytes = NULL; g_autoptr(GError) error = NULL; /* parse the test file */ fn = fu_test_get_filename (TESTDATADIR, "test.wac"); if (fn == NULL) { g_test_skip ("no data file found"); return; } bytes = fu_common_get_contents_bytes (fn, &error); g_assert_no_error (error); g_assert_nonnull (bytes); ret = fu_wac_firmware_parse_data (firmware, bytes, DFU_FIRMWARE_PARSE_FLAG_NONE, &error); g_assert_no_error (error); g_assert_true (ret); /* get image data */ image = dfu_firmware_get_image (firmware, 0); g_assert_nonnull (image); element = dfu_image_get_element_default (image); g_assert_nonnull (element); /* get block */ blob_block = dfu_element_get_contents_chunk (element, 0x8008000, 1024, &error); g_assert_no_error (error); g_assert_nonnull (blob_block); fu_wac_buffer_dump ("IMG", FU_WAC_REPORT_ID_MODULE, g_bytes_get_data (blob_block, NULL), g_bytes_get_size (blob_block)); }
static void test_parse_uint32(StateWrapper *wrapper, gconstpointer user_data) { guchar buffer[] = { 0x00, 0x12, 0x34, 0x56, 0x78 }; wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer, sizeof(buffer)); SooshiNode *node = g_new0(SooshiNode, 1); node->type = VAL_U32; sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value); g_assert_nonnull(node->value); g_assert_true(g_variant_is_of_type(node->value, G_VARIANT_TYPE_UINT32)); g_assert_cmpuint(g_variant_get_uint32(node->value), ==, (guint32) 0x78563412); guchar buffer2[4]; gint length = sooshi_node_value_to_bytes(node, buffer2); g_assert_cmpint(length, ==, sizeof(buffer2)); g_assert_cmpmem(buffer2, length, buffer + 1, sizeof(buffer) - 1); g_free(node); }
static void test_parse_chooser(StateWrapper *wrapper, gconstpointer user_data) { guchar buffer[] = { 0x00, 0x06 }; wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer, sizeof(buffer)); SooshiNode *node = g_new0(SooshiNode, 1); node->type = CHOOSER; sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value); g_assert_nonnull(node->value); g_assert_true(g_variant_is_of_type(node->value, G_VARIANT_TYPE_BYTE)); g_assert_cmpuint(g_variant_get_byte(node->value), ==, 0x06); guchar buffer2[1]; gint length = sooshi_node_value_to_bytes(node, buffer2); g_assert_cmpint(length, ==, sizeof(buffer2)); g_assert_cmpmem(buffer2, length, buffer + 1, sizeof(buffer) - 1); g_free(node); }
static void test_parse_str(StateWrapper *wrapper, gconstpointer user_data) { guchar buffer[] = { 0x00, 0x06, 0x00, 0x73, 0x6f, 0x6f, 0x73, 0x68, 0x69 }; wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer, sizeof(buffer)); SooshiNode *node = g_new0(SooshiNode, 1); node->type = VAL_STR; sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value); g_assert_nonnull(node->value); g_assert_true(g_variant_is_of_type(node->value, G_VARIANT_TYPE_STRING)); g_assert_cmpstr(g_variant_get_string(node->value, NULL), ==, "sooshi"); guchar buffer2[8]; gint length = sooshi_node_value_to_bytes(node, buffer2); g_assert_cmpint(length, ==, sizeof(buffer2)); g_assert_cmpmem(buffer2, length, buffer + 1, sizeof(buffer) - 1); g_free(node); }
static void test_parse_int16(StateWrapper *wrapper, gconstpointer user_data) { guchar buffer[] = { 0x00, 0xAB, 0xCD }; wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer, sizeof(buffer)); SooshiNode *node = g_new0(SooshiNode, 1); node->type = VAL_S16; sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value); g_assert_nonnull(node->value); g_assert_true(g_variant_is_of_type(node->value, G_VARIANT_TYPE_INT16)); g_assert_cmpint(g_variant_get_int16(node->value), ==, (gint16) 0xCDAB); guchar buffer2[2]; gint length = sooshi_node_value_to_bytes(node, buffer2); g_assert_cmpint(length, ==, sizeof(buffer2)); g_assert_cmpmem(buffer2, length, buffer + 1, sizeof(buffer) - 1); g_free(node); }