1 /*
2 * Copyright Andrey Semashev 2007 - 2015.
3 * Distributed under the Boost Software License, Version 1.0.
4 * (See accompanying file LICENSE_1_0.txt or copy at
5 * http://www.boost.org/LICENSE_1_0.txt)
6 */
7 /*!
8 * \file attr_attribute_set.cpp
9 * \author Andrey Semashev
10 * \date 24.01.2009
11 *
12 * \brief This header contains tests for the attribute set class.
13 */
14
15 #define BOOST_TEST_MODULE attr_attribute_set
16
17 #include <list>
18 #include <vector>
19 #include <string>
20 #include <utility>
21 #include <iterator>
22 #include <boost/test/unit_test.hpp>
23 #include <boost/log/attributes/constant.hpp>
24 #include <boost/log/attributes/attribute_set.hpp>
25 #include "char_definitions.hpp"
26 #include "attr_comparison.hpp"
27
28 namespace logging = boost::log;
29 namespace attrs = logging::attributes;
30
31 // The test checks construction and assignment
BOOST_AUTO_TEST_CASE(construction)32 BOOST_AUTO_TEST_CASE(construction)
33 {
34 typedef logging::attribute_set attr_set;
35 typedef test_data< char > data;
36
37 attrs::constant< int > attr1(10);
38 attrs::constant< double > attr2(5.5);
39 attrs::constant< std::string > attr3("Hello, world!");
40
41 attr_set set1;
42 BOOST_CHECK(set1.empty());
43 BOOST_CHECK_EQUAL(set1.size(), 0UL);
44
45 attr_set set2 = set1;
46 BOOST_CHECK(set2.empty());
47 BOOST_CHECK_EQUAL(set2.size(), 0UL);
48
49 set2[data::attr1()] = attr1;
50 set2[data::attr2()] = attr2;
51 BOOST_CHECK(set1.empty());
52 BOOST_CHECK_EQUAL(set1.size(), 0UL);
53 BOOST_CHECK(!set2.empty());
54 BOOST_CHECK_EQUAL(set2.size(), 2UL);
55
56 attr_set set3 = set2;
57 BOOST_CHECK(!set3.empty());
58 BOOST_CHECK_EQUAL(set3.size(), 2UL);
59 BOOST_CHECK_EQUAL(set3.count(data::attr1()), 1UL);
60 BOOST_CHECK_EQUAL(set3.count(data::attr2()), 1UL);
61 BOOST_CHECK_EQUAL(set3.count(data::attr3()), 0UL);
62
63 set1[data::attr3()] = attr3;
64 BOOST_CHECK(!set1.empty());
65 BOOST_CHECK_EQUAL(set1.size(), 1UL);
66 BOOST_CHECK_EQUAL(set1.count(data::attr3()), 1UL);
67
68 set2 = set1;
69 BOOST_REQUIRE_EQUAL(set1.size(), set2.size());
70 BOOST_CHECK(std::equal(set1.begin(), set1.end(), set2.begin()));
71 }
72
73 // The test checks lookup methods
BOOST_AUTO_TEST_CASE(lookup)74 BOOST_AUTO_TEST_CASE(lookup)
75 {
76 typedef logging::attribute_set attr_set;
77 typedef test_data< char > data;
78 typedef std::basic_string< char > string;
79
80 attrs::constant< int > attr1(10);
81 attrs::constant< double > attr2(5.5);
82
83 attr_set set1;
84 set1[data::attr1()] = attr1;
85 set1[data::attr2()] = attr2;
86
87 // Traditional find methods
88 attr_set::iterator it = set1.find(data::attr1());
89 BOOST_CHECK(it != set1.end());
90 BOOST_CHECK_EQUAL(it->second, attr1);
91
92 string s1 = data::attr2();
93 it = set1.find(s1);
94 BOOST_CHECK(it != set1.end());
95 BOOST_CHECK_EQUAL(it->second, attr2);
96
97 it = set1.find(data::attr1());
98 BOOST_CHECK(it != set1.end());
99 BOOST_CHECK_EQUAL(it->second, attr1);
100
101 it = set1.find(data::attr3());
102 BOOST_CHECK(it == set1.end());
103
104 // Subscript operator
105 logging::attribute p = set1[data::attr1()];
106 BOOST_CHECK_EQUAL(p, attr1);
107 BOOST_CHECK_EQUAL(set1.size(), 2UL);
108
109 p = set1[s1];
110 BOOST_CHECK_EQUAL(p, attr2);
111 BOOST_CHECK_EQUAL(set1.size(), 2UL);
112
113 p = set1[data::attr1()];
114 BOOST_CHECK_EQUAL(p, attr1);
115 BOOST_CHECK_EQUAL(set1.size(), 2UL);
116
117 p = set1[data::attr3()];
118 BOOST_CHECK(!p);
119 BOOST_CHECK_EQUAL(set1.size(), 2UL);
120
121 // Counting elements
122 BOOST_CHECK_EQUAL(set1.count(data::attr1()), 1UL);
123 BOOST_CHECK_EQUAL(set1.count(s1), 1UL);
124 BOOST_CHECK_EQUAL(set1.count(data::attr1()), 1UL);
125 BOOST_CHECK_EQUAL(set1.count(data::attr3()), 0UL);
126 }
127
128 // The test checks insertion methods
BOOST_AUTO_TEST_CASE(insertion)129 BOOST_AUTO_TEST_CASE(insertion)
130 {
131 typedef logging::attribute_set attr_set;
132 typedef test_data< char > data;
133 typedef std::basic_string< char > string;
134
135 attrs::constant< int > attr1(10);
136 attrs::constant< double > attr2(5.5);
137 attrs::constant< std::string > attr3("Hello, world!");
138
139 attr_set set1;
140
141 // Traditional insert methods
142 std::pair< attr_set::iterator, bool > res = set1.insert(data::attr1(), attr1);
143 BOOST_CHECK(res.second);
144 BOOST_CHECK(res.first != set1.end());
145 BOOST_CHECK(res.first->first == data::attr1());
146 BOOST_CHECK_EQUAL(res.first->second, attr1);
147 BOOST_CHECK(!set1.empty());
148 BOOST_CHECK_EQUAL(set1.size(), 1UL);
149
150 res = set1.insert(std::make_pair(attr_set::key_type(data::attr2()), attr2));
151 BOOST_CHECK(res.second);
152 BOOST_CHECK(res.first != set1.end());
153 BOOST_CHECK(res.first->first == data::attr2());
154 BOOST_CHECK_EQUAL(res.first->second, attr2);
155 BOOST_CHECK(!set1.empty());
156 BOOST_CHECK_EQUAL(set1.size(), 2UL);
157
158 // Insertion attempt of an attribute with the name of an already existing attribute
159 res = set1.insert(std::make_pair(attr_set::key_type(data::attr2()), attr3));
160 BOOST_CHECK(!res.second);
161 BOOST_CHECK(res.first != set1.end());
162 BOOST_CHECK(res.first->first == data::attr2());
163 BOOST_CHECK_EQUAL(res.first->second, attr2);
164 BOOST_CHECK(!set1.empty());
165 BOOST_CHECK_EQUAL(set1.size(), 2UL);
166
167 // Mass insertion
168 typedef attr_set::key_type key_type;
169 std::list< std::pair< key_type, logging::attribute > > elems;
170 elems.push_back(std::make_pair(key_type(data::attr2()), attr2));
171 elems.push_back(std::make_pair(key_type(data::attr1()), attr1));
172 elems.push_back(std::make_pair(key_type(data::attr3()), attr3));
173 // ... with element duplication
174 elems.push_back(std::make_pair(key_type(data::attr1()), attr3));
175
176 attr_set set2;
177 set2.insert(elems.begin(), elems.end());
178 BOOST_CHECK(!set2.empty());
179 BOOST_REQUIRE_EQUAL(set2.size(), 3UL);
180 typedef attr_set::mapped_type mapped_type;
181 BOOST_CHECK_EQUAL(static_cast< mapped_type >(set2[data::attr1()]), attr1);
182 BOOST_CHECK_EQUAL(static_cast< mapped_type >(set2[data::attr2()]), attr2);
183 BOOST_CHECK_EQUAL(static_cast< mapped_type >(set2[data::attr3()]), attr3);
184
185 // The same, but with insertion results collection
186 std::vector< std::pair< attr_set::iterator, bool > > results;
187
188 attr_set set3;
189 set3.insert(elems.begin(), elems.end(), std::back_inserter(results));
190 BOOST_REQUIRE_EQUAL(results.size(), elems.size());
191 BOOST_CHECK(!set3.empty());
192 BOOST_REQUIRE_EQUAL(set3.size(), 3UL);
193 attr_set::iterator it = set3.find(data::attr1());
194 BOOST_REQUIRE(it != set3.end());
195 BOOST_CHECK(it->first == data::attr1());
196 BOOST_CHECK_EQUAL(it->second, attr1);
197 BOOST_CHECK(it == results[1].first);
198 it = set3.find(data::attr2());
199 BOOST_REQUIRE(it != set3.end());
200 BOOST_CHECK(it->first == data::attr2());
201 BOOST_CHECK_EQUAL(it->second, attr2);
202 BOOST_CHECK(it == results[0].first);
203 it = set3.find(data::attr3());
204 BOOST_REQUIRE(it != set3.end());
205 BOOST_CHECK(it->first == data::attr3());
206 BOOST_CHECK_EQUAL(it->second, attr3);
207 BOOST_CHECK(it == results[2].first);
208
209 BOOST_CHECK(results[0].second);
210 BOOST_CHECK(results[1].second);
211 BOOST_CHECK(results[2].second);
212 BOOST_CHECK(!results[3].second);
213
214 // Subscript operator
215 attr_set set4;
216
217 logging::attribute& p1 = (set4[data::attr1()] = attr1);
218 BOOST_CHECK_EQUAL(set4.size(), 1UL);
219 BOOST_CHECK_EQUAL(p1, attr1);
220
221 logging::attribute& p2 = (set4[string(data::attr2())] = attr2);
222 BOOST_CHECK_EQUAL(set4.size(), 2UL);
223 BOOST_CHECK_EQUAL(p2, attr2);
224
225 logging::attribute& p3 = (set4[key_type(data::attr3())] = attr3);
226 BOOST_CHECK_EQUAL(set4.size(), 3UL);
227 BOOST_CHECK_EQUAL(p3, attr3);
228
229 // subscript operator can replace existing elements
230 logging::attribute& p4 = (set4[data::attr3()] = attr1);
231 BOOST_CHECK_EQUAL(set4.size(), 3UL);
232 BOOST_CHECK_EQUAL(p4, attr1);
233 }
234
235 // The test checks erasure methods
BOOST_AUTO_TEST_CASE(erasure)236 BOOST_AUTO_TEST_CASE(erasure)
237 {
238 typedef logging::attribute_set attr_set;
239 typedef test_data< char > data;
240
241 attrs::constant< int > attr1(10);
242 attrs::constant< double > attr2(5.5);
243 attrs::constant< std::string > attr3("Hello, world!");
244
245 attr_set set1;
246 set1[data::attr1()] = attr1;
247 set1[data::attr2()] = attr2;
248 set1[data::attr3()] = attr3;
249
250 attr_set set2 = set1;
251 BOOST_REQUIRE_EQUAL(set2.size(), 3UL);
252
253 BOOST_CHECK_EQUAL(set2.erase(data::attr1()), 1UL);
254 BOOST_CHECK_EQUAL(set2.size(), 2UL);
255 BOOST_CHECK_EQUAL(set2.count(data::attr1()), 0UL);
256
257 BOOST_CHECK_EQUAL(set2.erase(data::attr1()), 0UL);
258 BOOST_CHECK_EQUAL(set2.size(), 2UL);
259
260 set2.erase(set2.begin());
261 BOOST_CHECK_EQUAL(set2.size(), 1UL);
262 BOOST_CHECK_EQUAL(set2.count(data::attr2()), 0UL);
263
264 set2 = set1;
265 BOOST_REQUIRE_EQUAL(set2.size(), 3UL);
266
267 attr_set::iterator it = set2.begin();
268 set2.erase(++it, set2.end());
269 BOOST_CHECK_EQUAL(set2.size(), 1UL);
270 BOOST_CHECK_EQUAL(set2.count(data::attr1()), 1UL);
271 BOOST_CHECK_EQUAL(set2.count(data::attr2()), 0UL);
272 BOOST_CHECK_EQUAL(set2.count(data::attr3()), 0UL);
273
274 set2 = set1;
275 BOOST_REQUIRE_EQUAL(set2.size(), 3UL);
276
277 set2.clear();
278 BOOST_CHECK(set2.empty());
279 BOOST_CHECK_EQUAL(set2.size(), 0UL);
280 }
281