interval_test.cc 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277
  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. #include "net/base/interval.h"
  12. #include "net/test/gtest_util.h"
  13. #include "testing/gtest/include/gtest/gtest.h"
  14. using std::string;
  15. namespace net::test {
  16. namespace {
  17. class IntervalTest : public ::testing::Test {
  18. protected:
  19. // Test intersection between the two intervals i1 and i2. Tries
  20. // i1.IntersectWith(i2) and vice versa. The intersection should change i1 iff
  21. // changes_i1 is true, and the same for changes_i2. The resulting
  22. // intersection should be result.
  23. void TestIntersect(const Interval<int64_t>& i1,
  24. const Interval<int64_t>& i2,
  25. bool changes_i1,
  26. bool changes_i2,
  27. const Interval<int64_t>& result) {
  28. Interval<int64_t> i;
  29. i.CopyFrom(i1);
  30. EXPECT_TRUE(i.IntersectWith(i2) == changes_i1 && i.Equals(result));
  31. i.CopyFrom(i2);
  32. EXPECT_TRUE(i.IntersectWith(i1) == changes_i2 && i.Equals(result));
  33. }
  34. };
  35. TEST_F(IntervalTest, ConstructorsCopyAndClear) {
  36. Interval<int32_t> empty;
  37. EXPECT_TRUE(empty.Empty());
  38. Interval<int32_t> d2(0, 100);
  39. EXPECT_EQ(0, d2.min());
  40. EXPECT_EQ(100, d2.max());
  41. EXPECT_EQ(Interval<int32_t>(0, 100), d2);
  42. EXPECT_NE(Interval<int32_t>(0, 99), d2);
  43. empty.CopyFrom(d2);
  44. EXPECT_EQ(0, d2.min());
  45. EXPECT_EQ(100, d2.max());
  46. EXPECT_TRUE(empty.Equals(d2));
  47. EXPECT_EQ(empty, d2);
  48. EXPECT_TRUE(d2.Equals(empty));
  49. EXPECT_EQ(d2, empty);
  50. Interval<int32_t> max_less_than_min(40, 20);
  51. EXPECT_TRUE(max_less_than_min.Empty());
  52. EXPECT_EQ(40, max_less_than_min.min());
  53. EXPECT_EQ(20, max_less_than_min.max());
  54. Interval<int> d3(10, 20);
  55. d3.Clear();
  56. EXPECT_TRUE(d3.Empty());
  57. }
  58. TEST_F(IntervalTest, GettersSetters) {
  59. Interval<int32_t> d1(100, 200);
  60. // SetMin:
  61. d1.SetMin(30);
  62. EXPECT_EQ(30, d1.min());
  63. EXPECT_EQ(200, d1.max());
  64. // SetMax:
  65. d1.SetMax(220);
  66. EXPECT_EQ(30, d1.min());
  67. EXPECT_EQ(220, d1.max());
  68. // Set:
  69. d1.Clear();
  70. d1.Set(30, 220);
  71. EXPECT_EQ(30, d1.min());
  72. EXPECT_EQ(220, d1.max());
  73. // SpanningUnion:
  74. Interval<int32_t> d2;
  75. EXPECT_TRUE(!d1.SpanningUnion(d2));
  76. EXPECT_EQ(30, d1.min());
  77. EXPECT_EQ(220, d1.max());
  78. EXPECT_TRUE(d2.SpanningUnion(d1));
  79. EXPECT_EQ(30, d2.min());
  80. EXPECT_EQ(220, d2.max());
  81. d2.SetMin(40);
  82. d2.SetMax(100);
  83. EXPECT_TRUE(!d1.SpanningUnion(d2));
  84. EXPECT_EQ(30, d1.min());
  85. EXPECT_EQ(220, d1.max());
  86. d2.SetMin(20);
  87. d2.SetMax(100);
  88. EXPECT_TRUE(d1.SpanningUnion(d2));
  89. EXPECT_EQ(20, d1.min());
  90. EXPECT_EQ(220, d1.max());
  91. d2.SetMin(50);
  92. d2.SetMax(300);
  93. EXPECT_TRUE(d1.SpanningUnion(d2));
  94. EXPECT_EQ(20, d1.min());
  95. EXPECT_EQ(300, d1.max());
  96. d2.SetMin(0);
  97. d2.SetMax(500);
  98. EXPECT_TRUE(d1.SpanningUnion(d2));
  99. EXPECT_EQ(0, d1.min());
  100. EXPECT_EQ(500, d1.max());
  101. d2.SetMin(100);
  102. d2.SetMax(0);
  103. EXPECT_TRUE(!d1.SpanningUnion(d2));
  104. EXPECT_EQ(0, d1.min());
  105. EXPECT_EQ(500, d1.max());
  106. EXPECT_TRUE(d2.SpanningUnion(d1));
  107. EXPECT_EQ(0, d2.min());
  108. EXPECT_EQ(500, d2.max());
  109. }
  110. TEST_F(IntervalTest, CoveringOps) {
  111. const Interval<int64_t> empty;
  112. const Interval<int64_t> d(100, 200);
  113. const Interval<int64_t> d1(0, 50);
  114. const Interval<int64_t> d2(50, 110);
  115. const Interval<int64_t> d3(110, 180);
  116. const Interval<int64_t> d4(180, 220);
  117. const Interval<int64_t> d5(220, 300);
  118. const Interval<int64_t> d6(100, 150);
  119. const Interval<int64_t> d7(150, 200);
  120. const Interval<int64_t> d8(0, 300);
  121. // Intersection:
  122. EXPECT_TRUE(d.Intersects(d));
  123. EXPECT_TRUE(!empty.Intersects(d) && !d.Intersects(empty));
  124. EXPECT_TRUE(!d.Intersects(d1) && !d1.Intersects(d));
  125. EXPECT_TRUE(d.Intersects(d2) && d2.Intersects(d));
  126. EXPECT_TRUE(d.Intersects(d3) && d3.Intersects(d));
  127. EXPECT_TRUE(d.Intersects(d4) && d4.Intersects(d));
  128. EXPECT_TRUE(!d.Intersects(d5) && !d5.Intersects(d));
  129. EXPECT_TRUE(d.Intersects(d6) && d6.Intersects(d));
  130. EXPECT_TRUE(d.Intersects(d7) && d7.Intersects(d));
  131. EXPECT_TRUE(d.Intersects(d8) && d8.Intersects(d));
  132. Interval<int64_t> i;
  133. EXPECT_TRUE(d.Intersects(d, &i) && d.Equals(i));
  134. EXPECT_TRUE(!empty.Intersects(d, nullptr) && !d.Intersects(empty, nullptr));
  135. EXPECT_TRUE(!d.Intersects(d1, nullptr) && !d1.Intersects(d, nullptr));
  136. EXPECT_TRUE(d.Intersects(d2, &i) && i.Equals(Interval<int64_t>(100, 110)));
  137. EXPECT_TRUE(d2.Intersects(d, &i) && i.Equals(Interval<int64_t>(100, 110)));
  138. EXPECT_TRUE(d.Intersects(d3, &i) && i.Equals(d3));
  139. EXPECT_TRUE(d3.Intersects(d, &i) && i.Equals(d3));
  140. EXPECT_TRUE(d.Intersects(d4, &i) && i.Equals(Interval<int64_t>(180, 200)));
  141. EXPECT_TRUE(d4.Intersects(d, &i) && i.Equals(Interval<int64_t>(180, 200)));
  142. EXPECT_TRUE(!d.Intersects(d5, nullptr) && !d5.Intersects(d, nullptr));
  143. EXPECT_TRUE(d.Intersects(d6, &i) && i.Equals(d6));
  144. EXPECT_TRUE(d6.Intersects(d, &i) && i.Equals(d6));
  145. EXPECT_TRUE(d.Intersects(d7, &i) && i.Equals(d7));
  146. EXPECT_TRUE(d7.Intersects(d, &i) && i.Equals(d7));
  147. EXPECT_TRUE(d.Intersects(d8, &i) && i.Equals(d));
  148. EXPECT_TRUE(d8.Intersects(d, &i) && i.Equals(d));
  149. // Test IntersectsWith().
  150. // Arguments are TestIntersect(i1, i2, changes_i1, changes_i2, result).
  151. TestIntersect(empty, d, false, true, empty);
  152. TestIntersect(d, d1, true, true, empty);
  153. TestIntersect(d1, d2, true, true, empty);
  154. TestIntersect(d, d2, true, true, Interval<int64_t>(100, 110));
  155. TestIntersect(d8, d, true, false, d);
  156. TestIntersect(d8, d1, true, false, d1);
  157. TestIntersect(d8, d5, true, false, d5);
  158. // Contains:
  159. EXPECT_TRUE(!empty.Contains(d) && !d.Contains(empty));
  160. EXPECT_TRUE(d.Contains(d));
  161. EXPECT_TRUE(!d.Contains(d1) && !d1.Contains(d));
  162. EXPECT_TRUE(!d.Contains(d2) && !d2.Contains(d));
  163. EXPECT_TRUE(d.Contains(d3) && !d3.Contains(d));
  164. EXPECT_TRUE(!d.Contains(d4) && !d4.Contains(d));
  165. EXPECT_TRUE(!d.Contains(d5) && !d5.Contains(d));
  166. EXPECT_TRUE(d.Contains(d6) && !d6.Contains(d));
  167. EXPECT_TRUE(d.Contains(d7) && !d7.Contains(d));
  168. EXPECT_TRUE(!d.Contains(d8) && d8.Contains(d));
  169. EXPECT_TRUE(d.Contains(100));
  170. EXPECT_TRUE(!d.Contains(200));
  171. EXPECT_TRUE(d.Contains(150));
  172. EXPECT_TRUE(!d.Contains(99));
  173. EXPECT_TRUE(!d.Contains(201));
  174. // Difference:
  175. Interval<int64_t> lo;
  176. Interval<int64_t> hi;
  177. EXPECT_TRUE(d.Difference(d2, &lo, &hi));
  178. EXPECT_TRUE(lo.Empty());
  179. EXPECT_EQ(110u, hi.min());
  180. EXPECT_EQ(200u, hi.max());
  181. EXPECT_TRUE(d.Difference(d3, &lo, &hi));
  182. EXPECT_EQ(100u, lo.min());
  183. EXPECT_EQ(110u, lo.max());
  184. EXPECT_EQ(180u, hi.min());
  185. EXPECT_EQ(200u, hi.max());
  186. EXPECT_TRUE(d.Difference(d4, &lo, &hi));
  187. EXPECT_EQ(100u, lo.min());
  188. EXPECT_EQ(180u, lo.max());
  189. EXPECT_TRUE(hi.Empty());
  190. EXPECT_FALSE(d.Difference(d5, &lo, &hi));
  191. EXPECT_EQ(100u, lo.min());
  192. EXPECT_EQ(200u, lo.max());
  193. EXPECT_TRUE(hi.Empty());
  194. EXPECT_TRUE(d.Difference(d6, &lo, &hi));
  195. EXPECT_TRUE(lo.Empty());
  196. EXPECT_EQ(150u, hi.min());
  197. EXPECT_EQ(200u, hi.max());
  198. EXPECT_TRUE(d.Difference(d7, &lo, &hi));
  199. EXPECT_EQ(100u, lo.min());
  200. EXPECT_EQ(150u, lo.max());
  201. EXPECT_TRUE(hi.Empty());
  202. EXPECT_TRUE(d.Difference(d8, &lo, &hi));
  203. EXPECT_TRUE(lo.Empty());
  204. EXPECT_TRUE(hi.Empty());
  205. }
  206. TEST_F(IntervalTest, Length) {
  207. const Interval<int> empty1;
  208. const Interval<int> empty2(1, 1);
  209. const Interval<int> empty3(1, 0);
  210. const Interval<base::TimeDelta> empty4(base::TimeDelta() + base::Seconds(1),
  211. base::TimeDelta());
  212. const Interval<int> d1(1, 2);
  213. const Interval<int> d2(0, 50);
  214. const Interval<base::TimeDelta> d3(base::TimeDelta(),
  215. base::TimeDelta() + base::Seconds(1));
  216. const Interval<base::TimeDelta> d4(base::TimeDelta() + base::Hours(1),
  217. base::TimeDelta() + base::Minutes(90));
  218. EXPECT_EQ(0, empty1.Length());
  219. EXPECT_EQ(0, empty2.Length());
  220. EXPECT_EQ(0, empty3.Length());
  221. EXPECT_EQ(base::TimeDelta(), empty4.Length());
  222. EXPECT_EQ(1, d1.Length());
  223. EXPECT_EQ(50, d2.Length());
  224. EXPECT_EQ(base::Seconds(1), d3.Length());
  225. EXPECT_EQ(base::Minutes(30), d4.Length());
  226. }
  227. TEST_F(IntervalTest, IntervalOfTypeWithNoOperatorMinus) {
  228. // Interval<T> should work even if T does not support operator-(). We just
  229. // can't call Interval<T>::Length() for such types.
  230. const Interval<string> d1("a", "b");
  231. const Interval<std::pair<int, int>> d2({1, 2}, {4, 3});
  232. EXPECT_EQ("a", d1.min());
  233. EXPECT_EQ("b", d1.max());
  234. EXPECT_EQ(std::make_pair(1, 2), d2.min());
  235. EXPECT_EQ(std::make_pair(4, 3), d2.max());
  236. }
  237. } // unnamed namespace
  238. } // namespace net::test