it2s-itss-ldm/tests/test_data.c

#include <data.h>
#include <it2s-asn/etsi-its-v2/cam/EI2_CAM.h>
#include <it2s-asn/etsi-its-v2/denm/EI2_DENM.h>
#include <metadata.h>
#include <string.h>
#include <time.h>
#include <unity.h>

void setUp(void) {
    // set stuff up here
}

void tearDown(void) {
    // clean stuff up here
}

static void testDataSingle(void) {
    int rv = 0;
    ldm_data_storage_t storage;
    ldm_data_storage_init(&storage);

    EI2_CAM_t* cam = calloc(1, sizeof(*cam));
    asn_random_fill(&asn_DEF_EI2_CAM, (void**)&cam, 1000);
    uint32_t id = ldm_data_storage_add(&storage, ldm_data_type_CAM, cam);
    TEST_ASSERT_MESSAGE(id != 0, "Data object was not added to the database");
    TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].count == 1, "Data object count is not correct");

    ldm_data_type_t type;
    rv = ldm_data_storage_get_type(&storage, id, &type);
    TEST_ASSERT_MESSAGE(rv == 0, "Data object type was not retrieved correctly");
    TEST_ASSERT_MESSAGE(type == ldm_data_type_CAM, "Data object type is not correct");

    void* array[10];
    uint32_t count = ldm_data_storage_query(&storage, ldm_data_type_CAM, NULL, NULL, array, 10);
    TEST_ASSERT_MESSAGE(count == 1, "Data object count is not correct");
    TEST_ASSERT_MESSAGE(array[0] != NULL, "Received data object is NULL");
    TEST_ASSERT_MESSAGE(array[0] != cam, "Query does not copy the object");

    ASN_STRUCT_FREE(asn_DEF_EI2_CAM, cam);
    ASN_STRUCT_FREE(asn_DEF_EI2_CAM, array[0]);

    cam = calloc(1, sizeof(*cam));
    asn_random_fill(&asn_DEF_EI2_CAM, (void**)&cam, 1000);
    rv = ldm_data_storage_update(&storage, id, ldm_data_type_CAM, cam);
    ASN_STRUCT_FREE(asn_DEF_EI2_CAM, cam);
    TEST_ASSERT_MESSAGE(rv == 0, "Data object was not updated in the database");
    TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].count == 1, "Data object count is not correct");
    TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].head != NULL, "List head is not valid");
    TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].tail != NULL, "List tail is not valid");

    rv = ldm_data_storage_delete(&storage, id);
    TEST_ASSERT_MESSAGE(rv == 0, "Data object was not deleted from the database");

    rv = ldm_data_storage_delete(&storage, id);
    TEST_ASSERT_MESSAGE(rv == 1, "Data object was not deleted from the database");

    TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].count == 0, "Data object count is not correct");
    TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].head == NULL, "Data object list is not correct");
    TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].tail == NULL, "Data object list is not correct");

    count = ldm_data_storage_query(&storage, ldm_data_type_CAM, NULL, NULL, array, 10);
    TEST_ASSERT_MESSAGE(count == 0, "Data object count is not correct");

    ldm_data_storage_exit(&storage);
}

static void testDataMultiple(void) {
    int rv = 0;
    ldm_data_storage_t storage;
    ldm_data_storage_init(&storage);

    uint32_t cam_ids[ldm_data_storage_map_size * 3] = {0};
    for (uint32_t i = 0; i < ldm_data_storage_map_size * 3; i++) {
        EI2_CAM_t* cam = calloc(1, sizeof(*cam));
        asn_random_fill(&asn_DEF_EI2_CAM, (void**)&cam, 1000);
        cam_ids[i] = ldm_data_storage_add(&storage, ldm_data_type_CAM, cam);
        ASN_STRUCT_FREE(asn_DEF_EI2_CAM, cam);
        TEST_ASSERT_MESSAGE(cam_ids[i] != 0, "Data object was not added to the database");
        TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].count == i + 1, "Data object count is not correct");
        TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].head != NULL, "List head is not valid");
        TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].tail != NULL, "List tail is not valid");
    }

    uint32_t denm_ids[ldm_data_storage_map_size * 3] = {0};
    for (uint32_t i = 0; i < ldm_data_storage_map_size * 3; i++) {
        EI2_DENM_t* denm = calloc(1, sizeof(*denm));
        asn_random_fill(&asn_DEF_EI2_DENM, (void**)&denm, 1000);
        denm_ids[i] = ldm_data_storage_add(&storage, ldm_data_type_DENM, denm);
        ASN_STRUCT_FREE(asn_DEF_EI2_DENM, denm);
        TEST_ASSERT_MESSAGE(denm_ids[i] != 0, "Data object was not added to the database");
        TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_DENM].count == i + 1, "DENM Data object count is not correct");
        TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_DENM].head != NULL, "DENM List head is not valid");
        TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_DENM].tail != NULL, "DENM List tail is not valid");

        TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].count == ldm_data_storage_map_size * 3,
                            "CAM Data object count is not correct");
        TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].head != NULL, "CAM List head is not valid");
        TEST_ASSERT_MESSAGE(storage.lists[ldm_data_type_CAM].tail != NULL, "CAM List tail is not valid");
    }

    for (uint32_t i = 0; i < ldm_data_storage_map_size * 3; i++) {
        for (uint32_t j = i + 1; j < ldm_data_storage_map_size * 3; j++) {
            TEST_ASSERT_MESSAGE(cam_ids[i] != cam_ids[j], "Data object id's should not be the same");
            TEST_ASSERT_MESSAGE(denm_ids[i] != denm_ids[j], "Data object id's should not be the same");
        }
    }

    void* array[ldm_data_storage_map_size * 4];
    uint32_t count = ldm_data_storage_query(&storage, ldm_data_type_CAM, NULL, NULL, array, ldm_data_storage_map_size * 4);
    TEST_ASSERT_MESSAGE(count == ldm_data_storage_map_size * 3, "Data object count is not correct");
    for (uint32_t i = 0; i < ldm_data_storage_map_size * 3; i++) {
        ASN_STRUCT_FREE(asn_DEF_EI2_CAM, array[i]);
    }

    count = ldm_data_storage_query(&storage, ldm_data_type_DENM, NULL, NULL, array, ldm_data_storage_map_size * 4);
    TEST_ASSERT_MESSAGE(count == ldm_data_storage_map_size * 3, "Data object count is not correct");
    for (uint32_t i = 0; i < ldm_data_storage_map_size * 3; i++) {
        ASN_STRUCT_FREE(asn_DEF_EI2_DENM, array[i]);
    }

    EI2_DENM_t* denm = calloc(1, sizeof(*denm));
    rv = ldm_data_storage_update(&storage, cam_ids[0], ldm_data_type_DENM, denm);
    ASN_STRUCT_FREE(asn_DEF_EI2_DENM, denm);
    TEST_ASSERT_MESSAGE(rv == 2, "Data object updated with inconsistent type");

    // update 10 random CAM and DENM objects
    for (int _ = 0; _ < 10; ++_) {
        uint32_t rid = rand() % (ldm_data_storage_map_size * 3);
        EI2_CAM_t* cam = calloc(1, sizeof(*cam));
        asn_random_fill(&asn_DEF_EI2_CAM, (void**)&cam, 1000);
        rv = ldm_data_storage_update(&storage, cam_ids[rid], ldm_data_type_CAM, cam);
        ASN_STRUCT_FREE(asn_DEF_EI2_CAM, cam);
        TEST_ASSERT_MESSAGE(rv == 0, "Data object was not updated in the database");

        rid = rand() % (ldm_data_storage_map_size * 3);
        EI2_DENM_t* denm = calloc(1, sizeof(*denm));
        asn_random_fill(&asn_DEF_EI2_DENM, (void**)&denm, 1000);
        rv = ldm_data_storage_update(&storage, denm_ids[rid], ldm_data_type_DENM, denm);
        ASN_STRUCT_FREE(asn_DEF_EI2_DENM, denm);
        TEST_ASSERT_MESSAGE(rv == 0, "Data object was not updated in the database");
    }

    uint32_t deleted = 0;
    for (uint32_t i = 0; i < ldm_data_storage_map_size * 3; i++) {
        uint32_t rid = rand() % (ldm_data_storage_map_size * 3);
        while (cam_ids[rid] == 0) {
            ++rid;
            if (rid >= ldm_data_storage_map_size * 3) {
                rid = 0;
            }
        }

        ldm_data_type_t type;
        rv = ldm_data_storage_get_type(&storage, cam_ids[rid], &type);
        TEST_ASSERT_MESSAGE(rv == 0, "Data Object type was not retrieved correctly");
        TEST_ASSERT_MESSAGE(type == ldm_data_type_CAM, "Data Object type is not correct");

        rv = ldm_data_storage_delete(&storage, cam_ids[rid]);
        char msg[100];
        sprintf(msg, "CAM Data object was not deleted from the database. Deleted %d", deleted);
        TEST_ASSERT_MESSAGE(rv == 0, msg);
        cam_ids[rid] = 0;
        deleted++;
    }

    for (uint32_t i = 0; i < ldm_data_storage_map_size * 3; i++) {
        uint32_t rid = rand() % (ldm_data_storage_map_size * 3);
        while (denm_ids[rid] == 0) {
            ++rid;
            if (rid >= ldm_data_storage_map_size * 3) {
                rid = 0;
            }
        }

        ldm_data_type_t type;
        rv = ldm_data_storage_get_type(&storage, denm_ids[rid], &type);
        TEST_ASSERT_MESSAGE(rv == 0, "Data Object type was not retrieved correctly");
        TEST_ASSERT_MESSAGE(type == ldm_data_type_DENM, "Data Object type is not correct");

        rv = ldm_data_storage_delete(&storage, denm_ids[rid]);
        TEST_ASSERT_MESSAGE(rv == 0, "DENM Data object was not deleted from the database");
        denm_ids[rid] = 0;
    }

    for (int type = 0; type < ldm_data_type_total; ++type) {
        TEST_ASSERT_MESSAGE(storage.lists[type].count == 0, "Data object count is not correct");
        TEST_ASSERT_MESSAGE(storage.lists[type].head == NULL, "Data object list is not correct");
        TEST_ASSERT_MESSAGE(storage.lists[type].tail == NULL, "Data object list is not correct");
    }
    for (int i = 0; i < ldm_data_storage_map_size; ++i) {
        TEST_ASSERT_MESSAGE(storage.map.array[i] == NULL, "Data object map is not correct");
    }

    ldm_data_storage_exit(&storage);
}

int main(void) {
    // seed rand
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    srand(ts.tv_sec * 1000 + ts.tv_nsec / 1000000);

    UNITY_BEGIN();
    RUN_TEST(testDataSingle);
    RUN_TEST(testDataMultiple);
    return UNITY_END();
}