1/*
2 *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11// Borrowed from Chromium's src/base/stl_util_unittest.cc
12#include "webrtc/system_wrappers/interface/stl_util.h"
13
14#include <set>
15
16#include "testing/gtest/include/gtest/gtest.h"
17
18namespace {
19
20// Used as test case to ensure the various base::STLXxx functions don't require
21// more than operators "<" and "==" on values stored in containers.
22class ComparableValue {
23 public:
24  explicit ComparableValue(int value) : value_(value) {}
25
26  bool operator==(const ComparableValue& rhs) const {
27    return value_ == rhs.value_;
28  }
29
30  bool operator<(const ComparableValue& rhs) const {
31    return value_ < rhs.value_;
32  }
33
34 private:
35  int value_;
36};
37
38}  // namespace
39
40namespace webrtc {
41namespace {
42
43TEST(STLUtilTest, STLIsSorted) {
44  {
45    std::set<int> set;
46    set.insert(24);
47    set.insert(1);
48    set.insert(12);
49    EXPECT_TRUE(STLIsSorted(set));
50  }
51
52  {
53    std::set<ComparableValue> set;
54    set.insert(ComparableValue(24));
55    set.insert(ComparableValue(1));
56    set.insert(ComparableValue(12));
57    EXPECT_TRUE(STLIsSorted(set));
58  }
59
60  {
61    std::vector<int> vector;
62    vector.push_back(1);
63    vector.push_back(1);
64    vector.push_back(4);
65    vector.push_back(64);
66    vector.push_back(12432);
67    EXPECT_TRUE(STLIsSorted(vector));
68    vector.back() = 1;
69    EXPECT_FALSE(STLIsSorted(vector));
70  }
71}
72
73TEST(STLUtilTest, STLSetDifference) {
74  std::set<int> a1;
75  a1.insert(1);
76  a1.insert(2);
77  a1.insert(3);
78  a1.insert(4);
79
80  std::set<int> a2;
81  a2.insert(3);
82  a2.insert(4);
83  a2.insert(5);
84  a2.insert(6);
85  a2.insert(7);
86
87  {
88    std::set<int> difference;
89    difference.insert(1);
90    difference.insert(2);
91    EXPECT_EQ(difference, STLSetDifference<std::set<int> >(a1, a2));
92  }
93
94  {
95    std::set<int> difference;
96    difference.insert(5);
97    difference.insert(6);
98    difference.insert(7);
99    EXPECT_EQ(difference, STLSetDifference<std::set<int> >(a2, a1));
100  }
101
102  {
103    std::vector<int> difference;
104    difference.push_back(1);
105    difference.push_back(2);
106    EXPECT_EQ(difference, STLSetDifference<std::vector<int> >(a1, a2));
107  }
108
109  {
110    std::vector<int> difference;
111    difference.push_back(5);
112    difference.push_back(6);
113    difference.push_back(7);
114    EXPECT_EQ(difference, STLSetDifference<std::vector<int> >(a2, a1));
115  }
116}
117
118TEST(STLUtilTest, STLSetUnion) {
119  std::set<int> a1;
120  a1.insert(1);
121  a1.insert(2);
122  a1.insert(3);
123  a1.insert(4);
124
125  std::set<int> a2;
126  a2.insert(3);
127  a2.insert(4);
128  a2.insert(5);
129  a2.insert(6);
130  a2.insert(7);
131
132  {
133    std::set<int> result;
134    result.insert(1);
135    result.insert(2);
136    result.insert(3);
137    result.insert(4);
138    result.insert(5);
139    result.insert(6);
140    result.insert(7);
141    EXPECT_EQ(result, STLSetUnion<std::set<int> >(a1, a2));
142  }
143
144  {
145    std::set<int> result;
146    result.insert(1);
147    result.insert(2);
148    result.insert(3);
149    result.insert(4);
150    result.insert(5);
151    result.insert(6);
152    result.insert(7);
153    EXPECT_EQ(result, STLSetUnion<std::set<int> >(a2, a1));
154  }
155
156  {
157    std::vector<int> result;
158    result.push_back(1);
159    result.push_back(2);
160    result.push_back(3);
161    result.push_back(4);
162    result.push_back(5);
163    result.push_back(6);
164    result.push_back(7);
165    EXPECT_EQ(result, STLSetUnion<std::vector<int> >(a1, a2));
166  }
167
168  {
169    std::vector<int> result;
170    result.push_back(1);
171    result.push_back(2);
172    result.push_back(3);
173    result.push_back(4);
174    result.push_back(5);
175    result.push_back(6);
176    result.push_back(7);
177    EXPECT_EQ(result, STLSetUnion<std::vector<int> >(a2, a1));
178  }
179}
180
181TEST(STLUtilTest, STLSetIntersection) {
182  std::set<int> a1;
183  a1.insert(1);
184  a1.insert(2);
185  a1.insert(3);
186  a1.insert(4);
187
188  std::set<int> a2;
189  a2.insert(3);
190  a2.insert(4);
191  a2.insert(5);
192  a2.insert(6);
193  a2.insert(7);
194
195  {
196    std::set<int> result;
197    result.insert(3);
198    result.insert(4);
199    EXPECT_EQ(result, STLSetIntersection<std::set<int> >(a1, a2));
200  }
201
202  {
203    std::set<int> result;
204    result.insert(3);
205    result.insert(4);
206    EXPECT_EQ(result, STLSetIntersection<std::set<int> >(a2, a1));
207  }
208
209  {
210    std::vector<int> result;
211    result.push_back(3);
212    result.push_back(4);
213    EXPECT_EQ(result, STLSetIntersection<std::vector<int> >(a1, a2));
214  }
215
216  {
217    std::vector<int> result;
218    result.push_back(3);
219    result.push_back(4);
220    EXPECT_EQ(result, STLSetIntersection<std::vector<int> >(a2, a1));
221  }
222}
223
224TEST(STLUtilTest, STLIncludes) {
225  std::set<int> a1;
226  a1.insert(1);
227  a1.insert(2);
228  a1.insert(3);
229  a1.insert(4);
230
231  std::set<int> a2;
232  a2.insert(3);
233  a2.insert(4);
234
235  std::set<int> a3;
236  a3.insert(3);
237  a3.insert(4);
238  a3.insert(5);
239
240  EXPECT_TRUE(STLIncludes<std::set<int> >(a1, a2));
241  EXPECT_FALSE(STLIncludes<std::set<int> >(a1, a3));
242  EXPECT_FALSE(STLIncludes<std::set<int> >(a2, a1));
243  EXPECT_FALSE(STLIncludes<std::set<int> >(a2, a3));
244  EXPECT_FALSE(STLIncludes<std::set<int> >(a3, a1));
245  EXPECT_TRUE(STLIncludes<std::set<int> >(a3, a2));
246}
247
248}  // namespace
249}  // namespace webrtc
250
251