1 // (C) Copyright Andy Tompkins 2007. Permission to copy, use, modify, sell and
2 // distribute this software is granted provided this copyright notice appears
3 // in all copies. This software is provided "as is" without express or implied
4 // warranty, and with no claim as to its suitability for any purpose.
5
6 // Distributed under the Boost Software License, Version 1.0. (See
7 // accompanying file LICENSE_1_0.txt or copy at
8 // https://www.boost.org/LICENSE_1_0.txt)
9
10 // libs/uuid/test/test_uuid.cpp -------------------------------//
11
12 #include <iostream>
13 #include <boost/uuid/uuid.hpp>
14 #include <boost/uuid/uuid_io.hpp>
15 #include <boost/detail/lightweight_test.hpp>
16 #include <boost/functional/hash.hpp>
17 #include <boost/current_function.hpp>
18
test_uuid_equal_array(char const * file,int line,char const * function,boost::uuids::uuid const & lhs,const unsigned char (& rhs)[16])19 void test_uuid_equal_array(char const * file, int line, char const * function,
20 boost::uuids::uuid const& lhs, const unsigned char (&rhs)[16])
21 {
22 for (size_t i=0; i<16; i++) {
23 if ( *(lhs.begin()+i) != rhs[i]) {
24 std::cerr << file << "(" << line << "): uuid " << lhs << " not equal " << "{";
25 for (size_t j=0; j<16; j++) {
26 if (j != 0) {
27 std::cerr << " ";
28 }
29 std::cerr << std::hex << (int)rhs[j];
30 }
31 std::cerr << "} in function '" << function << "'" << std::endl;
32 ++boost::detail::test_errors();
33 return;
34 }
35 }
36 }
37
38
39 #define BOOST_TEST_UUID(lhs, rhs) ( test_uuid_equal_array(__FILE__, __LINE__, BOOST_CURRENT_FUNCTION, lhs, rhs) )
40
main(int,char * [])41 int main(int, char*[])
42 {
43 using namespace boost::uuids;
44
45 // uuid::static_size
46 BOOST_TEST_EQ(uuid::static_size(), 16U);
47
48 { // uuid::operator=()
49 uuid u1 = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}};
50 uuid u2 = u1;
51 BOOST_TEST_EQ(u2, u1);
52 }
53
54 { // uuid::begin(), end()
55 uuid u = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}};
56 unsigned char values[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
57 BOOST_TEST_UUID(u, values);
58 }
59
60 { // uuid::begin() const, end() const
61 const uuid u = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}};
62 unsigned char values[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
63 BOOST_TEST_UUID(u, values);
64 }
65
66 { // uuid::size()
67 uuid u; // uninitialized
68 BOOST_TEST_EQ(u.size(), 16U);
69 }
70
71 { // uuid::is_nil()
72 uuid u1 = {{0}};
73 BOOST_TEST_EQ(u1.is_nil(), true);
74
75 uuid u2 = {{1,0}};
76 BOOST_TEST_EQ(u2.is_nil(), false);
77 }
78
79 { // uuid::variant()
80 struct Test {
81 unsigned char octet7;
82 boost::uuids::uuid::variant_type variant;
83 };
84 const Test tests[] =
85 { { 0x00, boost::uuids::uuid::variant_ncs }
86 , { 0x10, boost::uuids::uuid::variant_ncs }
87 , { 0x20, boost::uuids::uuid::variant_ncs }
88 , { 0x30, boost::uuids::uuid::variant_ncs }
89 , { 0x40, boost::uuids::uuid::variant_ncs }
90 , { 0x50, boost::uuids::uuid::variant_ncs }
91 , { 0x60, boost::uuids::uuid::variant_ncs }
92 , { 0x70, boost::uuids::uuid::variant_ncs }
93 , { 0x80, boost::uuids::uuid::variant_rfc_4122 }
94 , { 0x90, boost::uuids::uuid::variant_rfc_4122 }
95 , { 0xa0, boost::uuids::uuid::variant_rfc_4122 }
96 , { 0xb0, boost::uuids::uuid::variant_rfc_4122 }
97 , { 0xc0, boost::uuids::uuid::variant_microsoft }
98 , { 0xd0, boost::uuids::uuid::variant_microsoft }
99 , { 0xe0, boost::uuids::uuid::variant_future }
100 , { 0xf0, boost::uuids::uuid::variant_future }
101 };
102 for (size_t i=0; i<sizeof(tests)/sizeof(Test); i++) {
103 uuid u = { {} };
104 u.data[8] = tests[i].octet7; // note that octet7 is array index 8
105
106 BOOST_TEST_EQ(u.variant(), tests[i].variant);
107 }
108 }
109
110 { // uuid::version()
111 struct Test {
112 unsigned char octet9;
113 boost::uuids::uuid::version_type version;
114 };
115 const Test tests[] =
116 { { 0x00, boost::uuids::uuid::version_unknown }
117 , { 0x10, boost::uuids::uuid::version_time_based }
118 , { 0x20, boost::uuids::uuid::version_dce_security }
119 , { 0x30, boost::uuids::uuid::version_name_based_md5 }
120 , { 0x40, boost::uuids::uuid::version_random_number_based }
121 , { 0x50, boost::uuids::uuid::version_name_based_sha1 }
122 , { 0x60, boost::uuids::uuid::version_unknown }
123 , { 0x70, boost::uuids::uuid::version_unknown }
124 , { 0x80, boost::uuids::uuid::version_unknown }
125 , { 0x90, boost::uuids::uuid::version_unknown }
126 , { 0xa0, boost::uuids::uuid::version_unknown }
127 , { 0xb0, boost::uuids::uuid::version_unknown }
128 , { 0xc0, boost::uuids::uuid::version_unknown }
129 , { 0xd0, boost::uuids::uuid::version_unknown }
130 , { 0xe0, boost::uuids::uuid::version_unknown }
131 , { 0xf0, boost::uuids::uuid::version_unknown }
132 };
133 for (size_t i=0; i<sizeof(tests)/sizeof(Test); i++) {
134 uuid u = {{0}};
135 u.data[6] = tests[i].octet9; // note that octet9 is array index 8
136
137 BOOST_TEST_EQ(u.version(), tests[i].version);
138 }
139 }
140
141 { // uuid::swap(), swap()
142 uuid u1 = {{0}};
143 uuid u2 = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}};
144 u1.swap(u2);
145
146 unsigned char values1[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
147 unsigned char values2[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
148 BOOST_TEST_UUID(u1, values2);
149 BOOST_TEST_UUID(u2, values1);
150
151 swap(u1, u2);
152 BOOST_TEST_UUID(u1, values1);
153 BOOST_TEST_UUID(u2, values2);
154 }
155
156 { // test comparsion
157 uuid u1 = {{0}};
158 uuid u2 = {{1,0}};
159 uuid u3 = {{255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255}};
160 uuid u4 = {{0,1,0}};
161 uuid u5 = {{0,255,0}};
162
163 BOOST_TEST_EQ(u1, u1);
164
165 BOOST_TEST_NE(u1, u2);
166
167 BOOST_TEST(u1 < u2);
168 BOOST_TEST(u2 < u3);
169 BOOST_TEST(u1 < u4);
170 BOOST_TEST(u1 < u5);
171 BOOST_TEST(u4 < u5);
172 BOOST_TEST(u4 < u2);
173 BOOST_TEST(u5 < u2);
174
175 BOOST_TEST(u1 <= u1);
176 BOOST_TEST(u1 <= u2);
177 BOOST_TEST(u2 <= u3);
178
179 BOOST_TEST(u2 >= u1);
180 BOOST_TEST(u3 >= u1);
181
182 BOOST_TEST(u3 >= u3);
183 BOOST_TEST(u2 >= u1);
184 BOOST_TEST(u3 >= u1);
185 }
186
187 { // ticket 10510
188 // the uuids in the report
189 uuid u6 = {{0x14,0x5c,0xfc,0x95,0x80,0x50,0x45,0x5a,0x83,0x82,0x44,0xca,0x57,0xc1,0x48,0x3b}};
190 uuid u7 = {{0x14,0x5c,0xfc,0x95,0x80,0x50,0x45,0x5a,0x83,0x82,0x44,0xca,0x57,0xc1,0x48,0x3c}};
191
192 // simple uuids to reproduce problem
193 uuid u8 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}};
194 uuid u9 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2}};
195 uuid u10 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254}};
196 uuid u11 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255}};
197
198 // some additional uuids for testing boundary cases
199 uuid u12 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1}};
200 uuid u13 = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,2}};
201 uuid u14 = {{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}};
202 uuid u15 = {{255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255}};
203
204 BOOST_TEST(u6 < u7);
205 BOOST_TEST(!(u7 < u6));
206
207 BOOST_TEST(u8 < u9);
208 BOOST_TEST(!(u9 < u8));
209 BOOST_TEST(u8 < u10);
210 BOOST_TEST(!(u10 < u8));
211 BOOST_TEST(u8 < u11);
212 BOOST_TEST(!(u11 < u8));
213
214 BOOST_TEST(u9 < u10);
215 BOOST_TEST(!(u10 < u9));
216 BOOST_TEST(u9 < u11);
217 BOOST_TEST(!(u11 < u9));
218
219 BOOST_TEST(u10 < u11);
220 BOOST_TEST(!(u11 < u10));
221
222 BOOST_TEST(u12 < u13);
223 BOOST_TEST(!(u13 < u12));
224 BOOST_TEST(u14 < u15);
225 BOOST_TEST(!(u15 < u14));
226 }
227
228 { // test hash
229 uuid u1 = {{0}};
230 uuid u2 = {{1,0}};
231 uuid u3 = {{255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255}};
232
233 boost::hash<uuid> uuid_hasher;
234
235 BOOST_TEST_NE(uuid_hasher(u1), uuid_hasher(u2));
236 BOOST_TEST_NE(uuid_hasher(u1), uuid_hasher(u3));
237 BOOST_TEST_NE(uuid_hasher(u2), uuid_hasher(u3));
238 }
239
240 { // test is_pod
241 BOOST_TEST_EQ(boost::is_pod<uuid>::value, true);
242 }
243
244 return boost::report_errors();
245 }
246