C++ (Cpp) kaa_list_get_sizeの例

コード例 #1

ファイル: test_kaa_list.c プロジェクト: nthevu/kaa

void test_list_push_front()
{
    KAA_TRACE_IN(logger);

    kaa_list_t *list = kaa_list_create();
    ASSERT_NOT_NULL(list);

    int32_t *number;
    int node_number = 2;
    for (int i = 0; i < node_number; ++i) {
        number = (int32_t *)KAA_MALLOC(sizeof(int32_t *));
        ASSERT_NOT_NULL(number);
        *number = rand();
        kaa_list_push_front(list, number);
    }

    ASSERT_EQUAL(kaa_list_get_size(list), node_number);

    ASSERT_NOT_NULL(kaa_list_begin(list));
    ASSERT_NULL(kaa_list_prev(kaa_list_begin(list)));

    ASSERT_EQUAL((*(int32_t *)kaa_list_get_data(kaa_list_begin(list))), *number);

    kaa_list_destroy(list, NULL);

    KAA_TRACE_OUT(logger);
}

コード例 #2

ファイル: test_kaa_list.c プロジェクト: Acarus/kaa

static void test_list_sort()
{
    kaa_list_t *list = kaa_list_create();
    ASSERT_NOT_NULL(list);

    uint64_t node_number = 100;
    for (uint64_t i = 0; i < node_number; ++i) {
        test_list_node_t *node = KAA_MALLOC(sizeof(test_list_node_t));
        ASSERT_NOT_NULL(node);
        node->id = (uint64_t) rand();
        kaa_list_push_back(list, node);
    }

    ASSERT_EQUAL(kaa_list_get_size(list), node_number);

    kaa_list_sort(list,&test_kaa_list_predicate);
    kaa_list_node_t *it,*next;
    it = kaa_list_begin(list);
    next = kaa_list_next(it);
    while (it && next) {
        ASSERT_TRUE(((test_list_node_t*)kaa_list_get_data(it))->id <=
                ((test_list_node_t*)kaa_list_get_data(next))->id);
        it = next;
        next = kaa_list_next(it);
    }
    kaa_list_destroy(list, NULL);
}

コード例 #3

ファイル: test_kaa_notification.c プロジェクト: henrylv206/kaa

void test_retrieving_topic_list(void)
{
    KAA_TRACE_IN(context->logger);
    err = kaa_get_topics(context->notification_manager, &topics);
    ASSERT_EQUAL(err, KAA_ERR_NONE);

    size_t topics_size = kaa_list_get_size(topics);
    ASSERT_EQUAL(topics_size, 1);

    KAA_TRACE_OUT(context->logger);
}

コード例 #4

ファイル: test_kaa_list.c プロジェクト: Acarus/kaa

static void test_list_create()
{
    kaa_list_t *list = kaa_list_create();
    ASSERT_NOT_NULL(list);

    ASSERT_EQUAL(kaa_list_get_size(list), 0);
    ASSERT_NULL(kaa_list_begin(list));
    ASSERT_NULL(kaa_list_back(list));

    kaa_list_destroy(list, NULL);
}

コード例 #5

ファイル: test_kaa_list.c プロジェクト: nthevu/kaa

void test_list_create()
{
    KAA_TRACE_IN(logger);

    kaa_list_t *list = kaa_list_create();
    ASSERT_NOT_NULL(list);

    ASSERT_EQUAL(kaa_list_get_size(list), 0);
    ASSERT_NULL(kaa_list_begin(list));
    ASSERT_NULL(kaa_list_back(list));

    kaa_list_destroy(list, NULL);

    KAA_TRACE_OUT(logger);
}

コード例 #6

ファイル: test_kaa_list.c プロジェクト: Acarus/kaa

static void test_list_push_back()
{
    kaa_list_t *list = kaa_list_create();
    ASSERT_NOT_NULL(list);

    int32_t *number;
    int node_number = 2;
    for (int i = 0; i < node_number; ++i) {
        number = KAA_MALLOC(sizeof(int32_t *));
        ASSERT_NOT_NULL(number);
        *number = rand();
        kaa_list_push_back(list, number);
    }

    ASSERT_EQUAL(kaa_list_get_size(list), node_number);
    ASSERT_EQUAL((*(int32_t *)kaa_list_get_data(kaa_list_back(list))), *number);

    kaa_list_destroy(list, NULL);
}

コード例 #7

ファイル: test_kaa_common_schema.c プロジェクト: Kirill380/kaa

static void test_array_deserialize_w_ctx(void **state)
{
    (void)state;

    const uint8_t plain_fixed[] = { 0x0, 0x1, 0x2, 0x3, 0x4 };
    size_t plain_fixed_size = sizeof(plain_fixed) / sizeof(char);

    size_t array_size = 1 + rand() % 10;

    kaa_list_t *avro_array1 = kaa_list_create();
    size_t i = 0;
    for (i = 0; i < array_size; ++i) {
        kaa_list_push_back(avro_array1, kaa_fixed_copy_create(plain_fixed, plain_fixed_size));
    }

    size_t buffer_size = kaa_array_get_size(avro_array1, kaa_fixed_get_size);
    char buffer[buffer_size];
    avro_writer_t avro_writer = avro_writer_memory(buffer, buffer_size);

    kaa_array_serialize(avro_writer, avro_array1, kaa_fixed_serialize);

    avro_reader_t avro_reader = avro_reader_memory(buffer, buffer_size);
    kaa_list_t *avro_array2 = kaa_array_deserialize_w_ctx(avro_reader, (deserialize_w_ctx_fn)kaa_fixed_deserialize, &plain_fixed_size);

    ASSERT_NOT_NULL(avro_array2);
    ASSERT_EQUAL(kaa_list_get_size(avro_array2), array_size);

    kaa_list_node_t *it = kaa_list_begin(avro_array2);
    while (it) {
        kaa_bytes_t *fixed = kaa_list_get_data(it);
        ASSERT_NOT_NULL(fixed);
        ASSERT_EQUAL((size_t)fixed->size, plain_fixed_size);
        ASSERT_EQUAL(memcmp(fixed->buffer, plain_fixed, plain_fixed_size), 0);
        it  = kaa_list_next(it);
    }

    kaa_list_destroy(avro_array2, kaa_fixed_destroy);
    avro_reader_free(avro_reader);
    avro_writer_free(avro_writer);
    kaa_list_destroy(avro_array1, kaa_fixed_destroy);
}

コード例 #8

ファイル: test_kaa_list.c プロジェクト: Acarus/kaa

static void test_list_hash()
{
    kaa_list_t *list = kaa_list_create();
    ASSERT_NOT_NULL(list);

    uint64_t node_number = 100;
    for (uint64_t i = 0; i < node_number; ++i) {
        test_list_node_t *node = KAA_MALLOC(sizeof(test_list_node_t));
        ASSERT_NOT_NULL(node);
        node->id = (uint64_t) node_number - i;
        kaa_list_push_back(list, node);
    }

    ASSERT_EQUAL(kaa_list_get_size(list), node_number);

    kaa_list_sort(list,&test_kaa_list_predicate);

    ASSERT_EQUAL(kaa_list_hash(list,&test_kaa_list_hash),-974344717);

    kaa_list_destroy(list, NULL);
}

コード例 #9

ファイル: test_kaa_common_schema.c プロジェクト: Kirill380/kaa

static void test_array_deserialize_wo_ctx(void **state)
{
    (void)state;

    size_t array_size = 1 + rand() % 10;

    kaa_list_t *avro_array1 = kaa_list_create();
    size_t i = 0;
    for (i = 0; i < array_size; ++i) {
        kaa_list_push_back(avro_array1, create_float());
    }

    size_t buffer_size = kaa_array_get_size(avro_array1, kaa_float_get_size);
    char buffer[buffer_size];
    avro_writer_t avro_writer = avro_writer_memory(buffer, buffer_size);

    kaa_array_serialize(avro_writer, avro_array1, kaa_float_serialize);

    avro_reader_t avro_reader = avro_reader_memory(buffer, buffer_size);
    kaa_list_t *avro_array2 = kaa_array_deserialize_wo_ctx(avro_reader, (deserialize_wo_ctx_fn)kaa_float_deserialize);

    ASSERT_NOT_NULL(avro_array2);
    ASSERT_EQUAL(kaa_list_get_size(avro_array2), array_size);

//    /*
//     * Deserialized array has a back order, so reverse the original.
//     */
//    kaa_list_t *reverse_avro_array = NULL;
//    kaa_list_t *it = avro_array1;
//    while (it) {
//        if (reverse_avro_array) {
//            reverse_avro_array = kaa_list_push_front(reverse_avro_array, kaa_list_get_data(it));
//        } else {
//            reverse_avro_array = kaa_list_create(kaa_list_get_data(it));
//        }
//        it  = kaa_list_next(it);
//    }
//
//    kaa_list_destroy(avro_array1, kaa_null_destroy);
//    avro_array1 = reverse_avro_array;

    /*
     * Compare origin and deserialized arrays.
     */
    kaa_list_node_t *it1 = kaa_list_begin(avro_array1);
    kaa_list_node_t *it2 = kaa_list_begin(avro_array2);
    while (it1 && it2) {
        float *float_value1 = kaa_list_get_data(it1);
        float *float_value2 = kaa_list_get_data(it2);

        ASSERT_NOT_NULL(float_value1);
        ASSERT_NOT_NULL(float_value2);
        ASSERT_EQUAL(*float_value2, *float_value1);

        it1  = kaa_list_next(it1);
        it2  = kaa_list_next(it2);
    }

    kaa_list_destroy(avro_array2, kaa_data_destroy);
    avro_reader_free(avro_reader);
    avro_writer_free(avro_writer);
    kaa_list_destroy(avro_array1, kaa_data_destroy);
}