| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2015 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 // ---------------------------------------------------------------------- | |
| 6 // | |
| 7 // Unittest for the Interval class. | |
| 8 // | |
| 9 // Author: Will Neveitt (wneveitt@google.com) | |
| 10 // ---------------------------------------------------------------------- | |
| 11 | |
| 12 #include "net/quic/interval.h" | |
| 13 | |
| 14 #include "base/logging.h" | |
| 15 #include "base/stl_util.h" | |
| 16 #include "net/test/gtest_util.h" | |
| 17 #include "testing/gtest/include/gtest/gtest.h" | |
| 18 | |
| 19 using std::pair; | |
| 20 using std::string; | |
| 21 using std::vector; | |
| 22 | |
| 23 namespace net { | |
| 24 namespace test { | |
| 25 namespace { | |
| 26 | |
| 27 class IntervalTest : public ::testing::Test { | |
| 28 protected: | |
| 29 // Test intersection between the two intervals i1 and i2. Tries | |
| 30 // i1.IntersectWith(i2) and vice versa. The intersection should change i1 iff | |
| 31 // changes_i1 is true, and the same for changes_i2. The resulting | |
| 32 // intersection should be result. | |
| 33 void TestIntersect(const Interval<int64_t>& i1, | |
| 34 const Interval<int64_t>& i2, | |
| 35 bool changes_i1, | |
| 36 bool changes_i2, | |
| 37 const Interval<int64_t>& result) { | |
| 38 Interval<int64_t> i; | |
| 39 i.CopyFrom(i1); | |
| 40 EXPECT_TRUE(i.IntersectWith(i2) == changes_i1 && i.Equals(result)); | |
| 41 i.CopyFrom(i2); | |
| 42 EXPECT_TRUE(i.IntersectWith(i1) == changes_i2 && i.Equals(result)); | |
| 43 } | |
| 44 }; | |
| 45 | |
| 46 TEST_F(IntervalTest, ConstructorsCopyAndClear) { | |
| 47 Interval<int32_t> empty; | |
| 48 EXPECT_TRUE(empty.Empty()); | |
| 49 | |
| 50 Interval<int32_t> d2(0, 100); | |
| 51 EXPECT_EQ(0, d2.min()); | |
| 52 EXPECT_EQ(100, d2.max()); | |
| 53 EXPECT_EQ(Interval<int32_t>(0, 100), d2); | |
| 54 EXPECT_NE(Interval<int32_t>(0, 99), d2); | |
| 55 | |
| 56 empty.CopyFrom(d2); | |
| 57 EXPECT_EQ(0, d2.min()); | |
| 58 EXPECT_EQ(100, d2.max()); | |
| 59 EXPECT_TRUE(empty.Equals(d2)); | |
| 60 EXPECT_EQ(empty, d2); | |
| 61 EXPECT_TRUE(d2.Equals(empty)); | |
| 62 EXPECT_EQ(d2, empty); | |
| 63 | |
| 64 Interval<int32_t> max_less_than_min(40, 20); | |
| 65 EXPECT_TRUE(max_less_than_min.Empty()); | |
| 66 EXPECT_EQ(40, max_less_than_min.min()); | |
| 67 EXPECT_EQ(20, max_less_than_min.max()); | |
| 68 | |
| 69 Interval<int> d3(10, 20); | |
| 70 d3.Clear(); | |
| 71 EXPECT_TRUE(d3.Empty()); | |
| 72 } | |
| 73 | |
| 74 TEST_F(IntervalTest, GettersSetters) { | |
| 75 Interval<int32_t> d1(100, 200); | |
| 76 | |
| 77 // SetMin: | |
| 78 d1.SetMin(30); | |
| 79 EXPECT_EQ(30, d1.min()); | |
| 80 EXPECT_EQ(200, d1.max()); | |
| 81 | |
| 82 // SetMax: | |
| 83 d1.SetMax(220); | |
| 84 EXPECT_EQ(30, d1.min()); | |
| 85 EXPECT_EQ(220, d1.max()); | |
| 86 | |
| 87 // Set: | |
| 88 d1.Clear(); | |
| 89 d1.Set(30, 220); | |
| 90 EXPECT_EQ(30, d1.min()); | |
| 91 EXPECT_EQ(220, d1.max()); | |
| 92 | |
| 93 // SpanningUnion: | |
| 94 Interval<int32_t> d2; | |
| 95 EXPECT_TRUE(!d1.SpanningUnion(d2)); | |
| 96 EXPECT_EQ(30, d1.min()); | |
| 97 EXPECT_EQ(220, d1.max()); | |
| 98 | |
| 99 EXPECT_TRUE(d2.SpanningUnion(d1)); | |
| 100 EXPECT_EQ(30, d2.min()); | |
| 101 EXPECT_EQ(220, d2.max()); | |
| 102 | |
| 103 d2.SetMin(40); | |
| 104 d2.SetMax(100); | |
| 105 EXPECT_TRUE(!d1.SpanningUnion(d2)); | |
| 106 EXPECT_EQ(30, d1.min()); | |
| 107 EXPECT_EQ(220, d1.max()); | |
| 108 | |
| 109 d2.SetMin(20); | |
| 110 d2.SetMax(100); | |
| 111 EXPECT_TRUE(d1.SpanningUnion(d2)); | |
| 112 EXPECT_EQ(20, d1.min()); | |
| 113 EXPECT_EQ(220, d1.max()); | |
| 114 | |
| 115 d2.SetMin(50); | |
| 116 d2.SetMax(300); | |
| 117 EXPECT_TRUE(d1.SpanningUnion(d2)); | |
| 118 EXPECT_EQ(20, d1.min()); | |
| 119 EXPECT_EQ(300, d1.max()); | |
| 120 | |
| 121 d2.SetMin(0); | |
| 122 d2.SetMax(500); | |
| 123 EXPECT_TRUE(d1.SpanningUnion(d2)); | |
| 124 EXPECT_EQ(0, d1.min()); | |
| 125 EXPECT_EQ(500, d1.max()); | |
| 126 | |
| 127 d2.SetMin(100); | |
| 128 d2.SetMax(0); | |
| 129 EXPECT_TRUE(!d1.SpanningUnion(d2)); | |
| 130 EXPECT_EQ(0, d1.min()); | |
| 131 EXPECT_EQ(500, d1.max()); | |
| 132 EXPECT_TRUE(d2.SpanningUnion(d1)); | |
| 133 EXPECT_EQ(0, d2.min()); | |
| 134 EXPECT_EQ(500, d2.max()); | |
| 135 } | |
| 136 | |
| 137 TEST_F(IntervalTest, CoveringOps) { | |
| 138 const Interval<int64_t> empty; | |
| 139 const Interval<int64_t> d(100, 200); | |
| 140 const Interval<int64_t> d1(0, 50); | |
| 141 const Interval<int64_t> d2(50, 110); | |
| 142 const Interval<int64_t> d3(110, 180); | |
| 143 const Interval<int64_t> d4(180, 220); | |
| 144 const Interval<int64_t> d5(220, 300); | |
| 145 const Interval<int64_t> d6(100, 150); | |
| 146 const Interval<int64_t> d7(150, 200); | |
| 147 const Interval<int64_t> d8(0, 300); | |
| 148 | |
| 149 // Intersection: | |
| 150 EXPECT_TRUE(d.Intersects(d)); | |
| 151 EXPECT_TRUE(!empty.Intersects(d) && !d.Intersects(empty)); | |
| 152 EXPECT_TRUE(!d.Intersects(d1) && !d1.Intersects(d)); | |
| 153 EXPECT_TRUE(d.Intersects(d2) && d2.Intersects(d)); | |
| 154 EXPECT_TRUE(d.Intersects(d3) && d3.Intersects(d)); | |
| 155 EXPECT_TRUE(d.Intersects(d4) && d4.Intersects(d)); | |
| 156 EXPECT_TRUE(!d.Intersects(d5) && !d5.Intersects(d)); | |
| 157 EXPECT_TRUE(d.Intersects(d6) && d6.Intersects(d)); | |
| 158 EXPECT_TRUE(d.Intersects(d7) && d7.Intersects(d)); | |
| 159 EXPECT_TRUE(d.Intersects(d8) && d8.Intersects(d)); | |
| 160 | |
| 161 Interval<int64_t> i; | |
| 162 EXPECT_TRUE(d.Intersects(d, &i) && d.Equals(i)); | |
| 163 EXPECT_TRUE(!empty.Intersects(d, NULL) && !d.Intersects(empty, NULL)); | |
| 164 EXPECT_TRUE(!d.Intersects(d1, NULL) && !d1.Intersects(d, NULL)); | |
| 165 EXPECT_TRUE(d.Intersects(d2, &i) && i.Equals(Interval<int64_t>(100, 110))); | |
| 166 EXPECT_TRUE(d2.Intersects(d, &i) && i.Equals(Interval<int64_t>(100, 110))); | |
| 167 EXPECT_TRUE(d.Intersects(d3, &i) && i.Equals(d3)); | |
| 168 EXPECT_TRUE(d3.Intersects(d, &i) && i.Equals(d3)); | |
| 169 EXPECT_TRUE(d.Intersects(d4, &i) && i.Equals(Interval<int64_t>(180, 200))); | |
| 170 EXPECT_TRUE(d4.Intersects(d, &i) && i.Equals(Interval<int64_t>(180, 200))); | |
| 171 EXPECT_TRUE(!d.Intersects(d5, NULL) && !d5.Intersects(d, NULL)); | |
| 172 EXPECT_TRUE(d.Intersects(d6, &i) && i.Equals(d6)); | |
| 173 EXPECT_TRUE(d6.Intersects(d, &i) && i.Equals(d6)); | |
| 174 EXPECT_TRUE(d.Intersects(d7, &i) && i.Equals(d7)); | |
| 175 EXPECT_TRUE(d7.Intersects(d, &i) && i.Equals(d7)); | |
| 176 EXPECT_TRUE(d.Intersects(d8, &i) && i.Equals(d)); | |
| 177 EXPECT_TRUE(d8.Intersects(d, &i) && i.Equals(d)); | |
| 178 | |
| 179 // Test IntersectsWith(). | |
| 180 // Arguments are TestIntersect(i1, i2, changes_i1, changes_i2, result). | |
| 181 TestIntersect(empty, d, false, true, empty); | |
| 182 TestIntersect(d, d1, true, true, empty); | |
| 183 TestIntersect(d1, d2, true, true, empty); | |
| 184 TestIntersect(d, d2, true, true, Interval<int64_t>(100, 110)); | |
| 185 TestIntersect(d8, d, true, false, d); | |
| 186 TestIntersect(d8, d1, true, false, d1); | |
| 187 TestIntersect(d8, d5, true, false, d5); | |
| 188 | |
| 189 // Contains: | |
| 190 EXPECT_TRUE(!empty.Contains(d) && !d.Contains(empty)); | |
| 191 EXPECT_TRUE(d.Contains(d)); | |
| 192 EXPECT_TRUE(!d.Contains(d1) && !d1.Contains(d)); | |
| 193 EXPECT_TRUE(!d.Contains(d2) && !d2.Contains(d)); | |
| 194 EXPECT_TRUE(d.Contains(d3) && !d3.Contains(d)); | |
| 195 EXPECT_TRUE(!d.Contains(d4) && !d4.Contains(d)); | |
| 196 EXPECT_TRUE(!d.Contains(d5) && !d5.Contains(d)); | |
| 197 EXPECT_TRUE(d.Contains(d6) && !d6.Contains(d)); | |
| 198 EXPECT_TRUE(d.Contains(d7) && !d7.Contains(d)); | |
| 199 EXPECT_TRUE(!d.Contains(d8) && d8.Contains(d)); | |
| 200 | |
| 201 EXPECT_TRUE(d.Contains(100)); | |
| 202 EXPECT_TRUE(!d.Contains(200)); | |
| 203 EXPECT_TRUE(d.Contains(150)); | |
| 204 EXPECT_TRUE(!d.Contains(99)); | |
| 205 EXPECT_TRUE(!d.Contains(201)); | |
| 206 | |
| 207 // Difference: | |
| 208 vector<Interval<int64_t>*> diff; | |
| 209 | |
| 210 EXPECT_TRUE(!d.Difference(empty, &diff)); | |
| 211 EXPECT_EQ(1u, diff.size()); | |
| 212 EXPECT_EQ(100u, diff[0]->min()); | |
| 213 EXPECT_EQ(200u, diff[0]->max()); | |
| 214 STLDeleteElements(&diff); | |
| 215 EXPECT_TRUE(!empty.Difference(d, &diff) && diff.empty()); | |
| 216 | |
| 217 EXPECT_TRUE(d.Difference(d, &diff) && diff.empty()); | |
| 218 EXPECT_TRUE(!d.Difference(d1, &diff)); | |
| 219 EXPECT_EQ(1u, diff.size()); | |
| 220 EXPECT_EQ(100u, diff[0]->min()); | |
| 221 EXPECT_EQ(200u, diff[0]->max()); | |
| 222 STLDeleteElements(&diff); | |
| 223 | |
| 224 Interval<int64_t> lo; | |
| 225 Interval<int64_t> hi; | |
| 226 | |
| 227 EXPECT_TRUE(d.Difference(d2, &lo, &hi)); | |
| 228 EXPECT_TRUE(lo.Empty()); | |
| 229 EXPECT_EQ(110u, hi.min()); | |
| 230 EXPECT_EQ(200u, hi.max()); | |
| 231 EXPECT_TRUE(d.Difference(d2, &diff)); | |
| 232 EXPECT_EQ(1u, diff.size()); | |
| 233 EXPECT_EQ(110u, diff[0]->min()); | |
| 234 EXPECT_EQ(200u, diff[0]->max()); | |
| 235 STLDeleteElements(&diff); | |
| 236 | |
| 237 EXPECT_TRUE(d.Difference(d3, &lo, &hi)); | |
| 238 EXPECT_EQ(100u, lo.min()); | |
| 239 EXPECT_EQ(110u, lo.max()); | |
| 240 EXPECT_EQ(180u, hi.min()); | |
| 241 EXPECT_EQ(200u, hi.max()); | |
| 242 EXPECT_TRUE(d.Difference(d3, &diff)); | |
| 243 EXPECT_EQ(2u, diff.size()); | |
| 244 EXPECT_EQ(100u, diff[0]->min()); | |
| 245 EXPECT_EQ(110u, diff[0]->max()); | |
| 246 EXPECT_EQ(180u, diff[1]->min()); | |
| 247 EXPECT_EQ(200u, diff[1]->max()); | |
| 248 STLDeleteElements(&diff); | |
| 249 | |
| 250 EXPECT_TRUE(d.Difference(d4, &lo, &hi)); | |
| 251 EXPECT_EQ(100u, lo.min()); | |
| 252 EXPECT_EQ(180u, lo.max()); | |
| 253 EXPECT_TRUE(hi.Empty()); | |
| 254 EXPECT_TRUE(d.Difference(d4, &diff)); | |
| 255 EXPECT_EQ(1u, diff.size()); | |
| 256 EXPECT_EQ(100u, diff[0]->min()); | |
| 257 EXPECT_EQ(180u, diff[0]->max()); | |
| 258 STLDeleteElements(&diff); | |
| 259 | |
| 260 EXPECT_FALSE(d.Difference(d5, &lo, &hi)); | |
| 261 EXPECT_EQ(100u, lo.min()); | |
| 262 EXPECT_EQ(200u, lo.max()); | |
| 263 EXPECT_TRUE(hi.Empty()); | |
| 264 EXPECT_FALSE(d.Difference(d5, &diff)); | |
| 265 EXPECT_EQ(1u, diff.size()); | |
| 266 EXPECT_EQ(100u, diff[0]->min()); | |
| 267 EXPECT_EQ(200u, diff[0]->max()); | |
| 268 STLDeleteElements(&diff); | |
| 269 | |
| 270 EXPECT_TRUE(d.Difference(d6, &lo, &hi)); | |
| 271 EXPECT_TRUE(lo.Empty()); | |
| 272 EXPECT_EQ(150u, hi.min()); | |
| 273 EXPECT_EQ(200u, hi.max()); | |
| 274 EXPECT_TRUE(d.Difference(d6, &diff)); | |
| 275 EXPECT_EQ(1u, diff.size()); | |
| 276 EXPECT_EQ(150u, diff[0]->min()); | |
| 277 EXPECT_EQ(200u, diff[0]->max()); | |
| 278 STLDeleteElements(&diff); | |
| 279 | |
| 280 EXPECT_TRUE(d.Difference(d7, &lo, &hi)); | |
| 281 EXPECT_EQ(100u, lo.min()); | |
| 282 EXPECT_EQ(150u, lo.max()); | |
| 283 EXPECT_TRUE(hi.Empty()); | |
| 284 EXPECT_TRUE(d.Difference(d7, &diff)); | |
| 285 EXPECT_EQ(1u, diff.size()); | |
| 286 EXPECT_EQ(100u, diff[0]->min()); | |
| 287 EXPECT_EQ(150u, diff[0]->max()); | |
| 288 STLDeleteElements(&diff); | |
| 289 | |
| 290 EXPECT_TRUE(d.Difference(d8, &lo, &hi)); | |
| 291 EXPECT_TRUE(lo.Empty()); | |
| 292 EXPECT_TRUE(hi.Empty()); | |
| 293 EXPECT_TRUE(d.Difference(d8, &diff) && diff.empty()); | |
| 294 } | |
| 295 | |
| 296 TEST_F(IntervalTest, Length) { | |
| 297 const Interval<int> empty1; | |
| 298 const Interval<int> empty2(1, 1); | |
| 299 const Interval<int> empty3(1, 0); | |
| 300 const Interval<base::TimeDelta> empty4( | |
| 301 base::TimeDelta() + base::TimeDelta::FromSeconds(1), base::TimeDelta()); | |
| 302 const Interval<int> d1(1, 2); | |
| 303 const Interval<int> d2(0, 50); | |
| 304 const Interval<base::TimeDelta> d3( | |
| 305 base::TimeDelta(), base::TimeDelta() + base::TimeDelta::FromSeconds(1)); | |
| 306 const Interval<base::TimeDelta> d4( | |
| 307 base::TimeDelta() + base::TimeDelta::FromHours(1), | |
| 308 base::TimeDelta() + base::TimeDelta::FromMinutes(90)); | |
| 309 | |
| 310 EXPECT_EQ(0, empty1.Length()); | |
| 311 EXPECT_EQ(0, empty2.Length()); | |
| 312 EXPECT_EQ(0, empty3.Length()); | |
| 313 EXPECT_EQ(base::TimeDelta(), empty4.Length()); | |
| 314 EXPECT_EQ(1, d1.Length()); | |
| 315 EXPECT_EQ(50, d2.Length()); | |
| 316 EXPECT_EQ(base::TimeDelta::FromSeconds(1), d3.Length()); | |
| 317 EXPECT_EQ(base::TimeDelta::FromMinutes(30), d4.Length()); | |
| 318 } | |
| 319 | |
| 320 TEST_F(IntervalTest, IntervalOfTypeWithNoOperatorMinus) { | |
| 321 // Interval<T> should work even if T does not support operator-(). We just | |
| 322 // can't call Interval<T>::Length() for such types. | |
| 323 const Interval<string> d1("a", "b"); | |
| 324 const Interval<pair<int, int>> d2({1, 2}, {4, 3}); | |
| 325 EXPECT_EQ("a", d1.min()); | |
| 326 EXPECT_EQ("b", d1.max()); | |
| 327 EXPECT_EQ(std::make_pair(1, 2), d2.min()); | |
| 328 EXPECT_EQ(std::make_pair(4, 3), d2.max()); | |
| 329 } | |
| 330 | |
| 331 } // unnamed namespace | |
| 332 } // namespace test | |
| 333 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2193073003:
Move shared files in net/quic/ into net/quic/core/ (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master