webrtc/system_wrappers/source/stl_util_unittest.cc - Issue 2570833002: Delete stl_util.h. Unused since cl https://codereview.webrtc.org/2447103002

Side by Side Diff: webrtc/system_wrappers/source/stl_util_unittest.cc

Issue 2570833002: Delete stl_util.h. Unused since cl https://codereview.webrtc.org/2447103002 (Closed)

Patch Set: Created 4 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
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/include/stl_util.h"

13

14 #include <set>

15

16 #include "webrtc/test/gtest.h"

17

18 namespace {

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.

22 class 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

40 namespace webrtc {

41 namespace {

42

43 TEST(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

73 TEST(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

118 TEST(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

181 TEST(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

224 TEST(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

OLD	NEW

« no previous file with comments | « webrtc/system_wrappers/include/stl_util.h ('k') | no next file » | no next file with comments »