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