Switch to standard integer types in net/.

net/quic/interval_set_test.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/interval_set.h"
 
 #include <stdarg.h>
 #include <algorithm>
 #include <iostream>
 #include <iterator>
@@ skipping 399 matching lines @@
   mine.Intersection(theirs);
   EXPECT_TRUE(mine.Empty());
   EXPECT_FALSE(mine.Intersects(theirs));
   EXPECT_FALSE(theirs.Intersects(mine));
 }
 
 // TODO(rtenneti): Implement after suupport for std::initializer_list.
 #if 0
 TEST_F(IntervalSetTest,
        IntervalSetIntersectionTheirsBeforeMineInt64Singletons) {
-  IntervalSet<int64> mine({{10, 15}});
-  IntervalSet<int64> theirs({{-20, -5}});
+  IntervalSet<int64_t> mine({{10, 15}});
+  IntervalSet<int64_t> theirs({{-20, -5}});
   EXPECT_FALSE(mine.Intersects(theirs));
   EXPECT_FALSE(theirs.Intersects(mine));
   mine.Intersection(theirs);
   EXPECT_TRUE(mine.Empty());
   EXPECT_FALSE(mine.Intersects(theirs));
   EXPECT_FALSE(theirs.Intersects(mine));
 }
 
 TEST_F(IntervalSetTest, IntervalSetIntersectionMineBeforeTheirsIntSingletons) {
   IntervalSet<int> mine({{10, 15}});
   IntervalSet<int> theirs({{90, 95}});
   EXPECT_FALSE(mine.Intersects(theirs));
   EXPECT_FALSE(theirs.Intersects(mine));
   mine.Intersection(theirs);
   EXPECT_TRUE(mine.Empty());
   EXPECT_FALSE(mine.Intersects(theirs));
   EXPECT_FALSE(theirs.Intersects(mine));
 }
 
 TEST_F(IntervalSetTest, IntervalSetIntersectionTheirsBetweenMine) {
-  IntervalSet<int64> mine({{0, 5}, {40, 50}});
-  IntervalSet<int64> theirs({{10, 15}});
+  IntervalSet<int64_t> mine({{0, 5}, {40, 50}});
+  IntervalSet<int64_t> theirs({{10, 15}});
   EXPECT_FALSE(mine.Intersects(theirs));
   EXPECT_FALSE(theirs.Intersects(mine));
   mine.Intersection(theirs);
   EXPECT_TRUE(mine.Empty());
   EXPECT_FALSE(mine.Intersects(theirs));
   EXPECT_FALSE(theirs.Intersects(mine));
 }
 
 TEST_F(IntervalSetTest, IntervalSetIntersectionMineBetweenTheirs) {
   IntervalSet<int> mine({{20, 25}});
@@ skipping 28 matching lines @@
 TEST_F(IntervalSetTest,
        IntervalSetIntersectionAdjacentAlternatingNonIntersectingIntervals) {
   // Make sure that intersection with adjacent interval set is empty.
   const IntervalSet<int> x1({{0, 10}});
   const IntervalSet<int> y1({{-50, 0}, {10, 95}});
 
   IntervalSet<int> result1 = x1;
   result1.Intersection(y1);
   EXPECT_TRUE(result1.Empty()) << result1;
 
-  const IntervalSet<int16> x2({{0, 10}, {20, 30}, {40, 90}});
-  const IntervalSet<int16> y2(
+  const IntervalSet<int16_t> x2({{0, 10}, {20, 30}, {40, 90}});
+  const IntervalSet<int16_t> y2(
       {{-50, -40}, {-2, 0}, {10, 20}, {32, 40}, {90, 95}});
 
-  IntervalSet<int16> result2 = x2;
+  IntervalSet<int16_t> result2 = x2;
   result2.Intersection(y2);
   EXPECT_TRUE(result2.Empty()) << result2;
 
-  const IntervalSet<int64> x3({{-1, 5}, {5, 10}});
-  const IntervalSet<int64> y3({{-10, -1}, {10, 95}});
+  const IntervalSet<int64_t> x3({{-1, 5}, {5, 10}});
+  const IntervalSet<int64_t> y3({{-10, -1}, {10, 95}});
 
-  IntervalSet<int64> result3 = x3;
+  IntervalSet<int64_t> result3 = x3;
   result3.Intersection(y3);
   EXPECT_TRUE(result3.Empty()) << result3;
 }
 
 TEST_F(IntervalSetTest,
        IntervalSetIntersectionAlternatingIntersectingIntervals) {
   const IntervalSet<int> x1({{0, 10}});
   const IntervalSet<int> y1({{-50, 1}, {9, 95}});
   const IntervalSet<int> expected_result1({{0, 1}, {9, 10}});
 
   IntervalSet<int> result1 = x1;
   result1.Intersection(y1);
   EXPECT_EQ(result1, expected_result1);
 
-  const IntervalSet<int16> x2({{0, 10}, {20, 30}, {40, 90}});
-  const IntervalSet<int16> y2(
+  const IntervalSet<int16_t> x2({{0, 10}, {20, 30}, {40, 90}});
+  const IntervalSet<int16_t> y2(
       {{-50, -40}, {-2, 2}, {9, 21}, {32, 41}, {85, 95}});
-  const IntervalSet<int16> expected_result2(
+  const IntervalSet<int16_t> expected_result2(
       {{0, 2}, {9, 10}, {20, 21}, {40, 41}, {85, 90}});
 
-  IntervalSet<int16> result2 = x2;
+  IntervalSet<int16_t> result2 = x2;
   result2.Intersection(y2);
   EXPECT_EQ(result2, expected_result2);
 
-  const IntervalSet<int64> x3({{-1, 5}, {5, 10}});
-  const IntervalSet<int64> y3({{-10, 3}, {4, 95}});
-  const IntervalSet<int64> expected_result3({{-1, 3}, {4, 10}});
+  const IntervalSet<int64_t> x3({{-1, 5}, {5, 10}});
+  const IntervalSet<int64_t> y3({{-10, 3}, {4, 95}});
+  const IntervalSet<int64_t> expected_result3({{-1, 3}, {4, 10}});
 
-  IntervalSet<int64> result3 = x3;
+  IntervalSet<int64_t> result3 = x3;
   result3.Intersection(y3);
   EXPECT_EQ(result3, expected_result3);
 }
 
 #endif  // 0
 
 TEST_F(IntervalSetTest, IntervalSetIntersectionIdentical) {
   IntervalSet<int> copy(is);
   EXPECT_TRUE(copy.Intersects(is));
   EXPECT_TRUE(is.Intersects(copy));
@@ skipping 431 matching lines @@
   IntervalSet<int> s{{0, 1}, {2, 3}, {3, 4}};
   s = {{0, 1}, {2, 4}};
   EXPECT_THAT(s, ElementsAreArray(intervals_));
 }
 
 #endif  // 0
 
 }  // namespace
 }  // namespace test
 }  // namespace net