cmp_mem_access/cmp_mem_access_test.cpp at master · sushiterry/cmp_mem_access · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#include "CppUTest/TestHarness.h"
#include "cmp_mem_access.h"
#include "cmp/cmp.h"

TEST_GROUP(CMPMemAccess)
{
    cmp_mem_access_t ma;
    cmp_ctx_t cmp;
};

TEST(CMPMemAccess, Read)
{
    static char testbuf[] = {'\x93', 0x01, 0x02, 0x03}; // [1, 2, 3]
    cmp_mem_access_init(&cmp, &ma, &testbuf, sizeof(testbuf));
    bool err = false;
    uint32_t arr_size;
    err = !cmp_read_array(&cmp, &arr_size);
    CHECK(!err);
    CHECK_EQUAL(3, arr_size);
    int32_t i;
    err = !cmp_read_int(&cmp, &i);
    CHECK(!err);
    CHECK_EQUAL(1, i);
    err = !cmp_read_int(&cmp, &i);
    CHECK(!err);
    CHECK_EQUAL(2, i);
    err = !cmp_read_int(&cmp, &i);
    CHECK(!err);
    CHECK_EQUAL(3, i);
}

TEST(CMPMemAccess, ReadOverBufferEnd)
{
    static char testbuf[] = {'\x93', 0x01, 0x02, 0x03}; // [1, 2, 3]
    cmp_mem_access_init(&cmp, &ma, &testbuf, sizeof(testbuf)-1);
    bool err = false;
    uint32_t arr_size;
    err = !cmp_read_array(&cmp, &arr_size);
    CHECK(!err);
    CHECK_EQUAL(3, arr_size);
    int32_t i;
    err = !cmp_read_int(&cmp, &i);
    CHECK(!err);
    CHECK_EQUAL(1, i);
    err = !cmp_read_int(&cmp, &i);
    CHECK(!err);
    CHECK_EQUAL(2, i);
    err = !cmp_read_int(&cmp, &i);
    CHECK(err); // error must be set (end of buffer)
}

TEST(CMPMemAccess, Write)
{
    static char testbuf[4] = {0, 0, 0, 0};
    cmp_mem_access_init(&cmp, &ma, &testbuf, sizeof(testbuf));
    bool err = false;
    err = !cmp_write_array(&cmp, 3);
    CHECK(!err);
    err = !cmp_write_sint(&cmp, 1);
    CHECK(!err);
    err = !cmp_write_sint(&cmp, 2);
    CHECK(!err);
    err = !cmp_write_sint(&cmp, 3);
    CHECK(!err);
    CHECK_EQUAL((char)'\x93', testbuf[0]);
    CHECK_EQUAL(1, testbuf[1]);
    CHECK_EQUAL(2, testbuf[2]);
    CHECK_EQUAL(3, testbuf[3]);
}

TEST(CMPMemAccess, WriteOverBufferEnd)
{
    static char testbuf[4] = {0, 0, 0, 0};
    cmp_mem_access_init(&cmp, &ma, &testbuf, sizeof(testbuf) - 1);
    bool err = false;
    err = !cmp_write_array(&cmp, 3);
    CHECK(!err);
    err = !cmp_write_sint(&cmp, 1);
    CHECK(!err);
    err = !cmp_write_sint(&cmp, 2);
    CHECK(!err);
    err = !cmp_write_sint(&cmp, 3);
    CHECK(err); // error must be set (end of buffer)
}

TEST(CMPMemAccess, WriteROFails)
{
    static const char testbuf[4] = {0, 0, 0, 0};
    cmp_mem_access_ro_init(&cmp, &ma, &testbuf, sizeof(testbuf));
    bool err = false;
    err = !cmp_write_array(&cmp, 3);
    CHECK(err);
}

TEST(CMPMemAccess, SetPos)
{
    static char testbuf[4] = {0, 0, 0, 0};
    cmp_mem_access_init(&cmp, &ma, &testbuf, sizeof(testbuf));
    cmp_mem_access_set_pos(&ma, 1);
    CHECK_EQUAL(1, ma.index);
}

TEST(CMPMemAccess, GetPtr)
{
    static char testbuf[4] = {0, 0, 0, 0};
    cmp_mem_access_init(&cmp, &ma, &testbuf, sizeof(testbuf));
    POINTERS_EQUAL(&testbuf[1], cmp_mem_access_get_ptr_at_pos(&ma, 1));
}

TEST(CMPMemAccess, PosValid)
{
    static char testbuf[4] = {0, 0, 0, 0};
    cmp_mem_access_init(&cmp, &ma, &testbuf, sizeof(testbuf));
    CHECK_TRUE(cmp_mem_access_pos_is_valid(&ma, 0))
    CHECK_TRUE(cmp_mem_access_pos_is_valid(&ma, 3))
    CHECK_FALSE(cmp_mem_access_pos_is_valid(&ma, 4))
}