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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
#include "array_fun.h"
#include <cppunit/extensions/HelperMacros.h>
namespace aria2 {
class array_funTest:public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE(array_funTest);
CPPUNIT_TEST(testBit_negate);
CPPUNIT_TEST(testBit_and);
CPPUNIT_TEST(testArray_negate);
CPPUNIT_TEST(testArray_and);
CPPUNIT_TEST(testArrayLength);
CPPUNIT_TEST(testArrayPtr);
CPPUNIT_TEST(testArrayWrapper);
CPPUNIT_TEST_SUITE_END();
public:
void testBit_negate();
void testBit_and();
void testArray_negate();
void testArray_and();
void testArrayLength();
void testArrayPtr();
void testArrayWrapper();
struct X{
int m;
};
};
CPPUNIT_TEST_SUITE_REGISTRATION(array_funTest);
void array_funTest::testBit_negate()
{
unsigned char b = 0xaa;
CPPUNIT_ASSERT_EQUAL((unsigned char)0x55, bit_negate<unsigned char>()(b));
}
void array_funTest::testBit_and()
{
unsigned char b = 0xaa;
CPPUNIT_ASSERT_EQUAL((unsigned char)0x0a, bit_and<unsigned char>()(b, 0x0a));
}
void array_funTest::testArray_negate()
{
unsigned char a[] = { 0xaa, 0x55 };
array_fun<unsigned char> f = array_negate((unsigned char*)a);
CPPUNIT_ASSERT_EQUAL((unsigned char)0x55, f[0]);
CPPUNIT_ASSERT_EQUAL((unsigned char)0xaa, f[1]);
array_fun<unsigned char> ff = array_negate(f);
CPPUNIT_ASSERT_EQUAL((unsigned char)0xaa, ff[0]);
CPPUNIT_ASSERT_EQUAL((unsigned char)0x55, ff[1]);
}
void array_funTest::testArray_and()
{
unsigned char a1[] = { 0xaa, 0x55 };
unsigned char a2[] = { 0x1a, 0x25 };
array_fun<unsigned char> f = array_and((unsigned char*)a1, (unsigned char*)a2);
CPPUNIT_ASSERT_EQUAL((unsigned char)0x0a, f[0]);
CPPUNIT_ASSERT_EQUAL((unsigned char)0x05, f[1]);
array_fun<unsigned char> f2 = array_and((unsigned char*)a1, array_negate(a2));
CPPUNIT_ASSERT_EQUAL((unsigned char)0xa0, f2[0]);
CPPUNIT_ASSERT_EQUAL((unsigned char)0x50, f2[1]);
array_fun<unsigned char> f3 = array_and(array_negate(a2), (unsigned char*)a1);
CPPUNIT_ASSERT_EQUAL((unsigned char)0xa0, f3[0]);
CPPUNIT_ASSERT_EQUAL((unsigned char)0x50, f3[1]);
array_fun<unsigned char> f4 = array_and(array_negate(a1), array_negate(a2));
CPPUNIT_ASSERT_EQUAL((unsigned char)0x45, f4[0]);
CPPUNIT_ASSERT_EQUAL((unsigned char)0x8a, f4[1]);
}
void array_funTest::testArrayLength()
{
int64_t ia[] = { 1, 2, 3, 4, 5 };
int64_t zeroLengthArray[] = {};
CPPUNIT_ASSERT_EQUAL((size_t)5, arrayLength(ia));
CPPUNIT_ASSERT_EQUAL((size_t)0, arrayLength(zeroLengthArray));
}
// Check operator[] in const context.
static void arrayPtrConst(const array_ptr<struct array_funTest::X>& ax)
{
CPPUNIT_ASSERT_EQUAL(100, ax[3].m);
CPPUNIT_ASSERT_EQUAL(99, ax[2].m);
}
static void arrayPtrCast(struct array_funTest::X* x) {}
static void arrayPtrConstCast(const struct array_funTest::X* x) {}
void array_funTest::testArrayPtr()
{
array_ptr<struct X> ax(new struct X[10]);
ax[3].m = 100;
ax[2].m = 99;
CPPUNIT_ASSERT_EQUAL(100, ax[3].m);
CPPUNIT_ASSERT_EQUAL(99, ax[2].m);
arrayPtrConst(ax);
arrayPtrCast(ax);
arrayPtrConstCast(ax);
}
static void arrayWrapperConst(const array_wrapper<int, 10>& array)
{
CPPUNIT_ASSERT_EQUAL(9, array[9]);
}
void array_funTest::testArrayWrapper()
{
array_wrapper<int, 10> a1;
CPPUNIT_ASSERT_EQUAL((size_t)10, a1.size());
for(size_t i = 0; i < a1.size(); ++i) {
a1[i] = i;
}
CPPUNIT_ASSERT_EQUAL(9, a1[9]);
array_wrapper<int, 10> a2 = a1;
CPPUNIT_ASSERT_EQUAL(9, a2[9]);
arrayWrapperConst(a2);
array_wrapper<struct X, 10> x1;
arrayPtrCast(x1);
arrayPtrConstCast(x1);
}
} // namespace aria2
|
