Remove QUIC's Interval::difference.

net/quic/core/interval_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.
 //
 // ----------------------------------------------------------------------
 //
 // Unittest for the Interval class.
 //
 // Author: Will Neveitt (wneveitt@google.com)
 // ----------------------------------------------------------------------
 
 #include "net/quic/core/interval.h"
 
 #include "base/logging.h"
-#include "base/stl_util.h"
 #include "net/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::pair;
 using std::string;
 using std::vector;
 
 namespace net {
 namespace test {
 namespace {
@@ skipping 172 matching lines @@
   EXPECT_TRUE(d.Contains(d7) && !d7.Contains(d));
   EXPECT_TRUE(!d.Contains(d8) && d8.Contains(d));
 
   EXPECT_TRUE(d.Contains(100));
   EXPECT_TRUE(!d.Contains(200));
   EXPECT_TRUE(d.Contains(150));
   EXPECT_TRUE(!d.Contains(99));
   EXPECT_TRUE(!d.Contains(201));
 
   // Difference:
-  vector<Interval<int64_t>*> diff;
-
-  EXPECT_TRUE(!d.Difference(empty, &diff));
-  EXPECT_EQ(1u, diff.size());
-  EXPECT_EQ(100u, diff[0]->min());
-  EXPECT_EQ(200u, diff[0]->max());
-  base::STLDeleteElements(&diff);
-  EXPECT_TRUE(!empty.Difference(d, &diff) && diff.empty());
-
-  EXPECT_TRUE(d.Difference(d, &diff) && diff.empty());
-  EXPECT_TRUE(!d.Difference(d1, &diff));
-  EXPECT_EQ(1u, diff.size());
-  EXPECT_EQ(100u, diff[0]->min());
-  EXPECT_EQ(200u, diff[0]->max());
-  base::STLDeleteElements(&diff);
-
   Interval<int64_t> lo;
   Interval<int64_t> hi;
 
   EXPECT_TRUE(d.Difference(d2, &lo, &hi));
   EXPECT_TRUE(lo.Empty());
   EXPECT_EQ(110u, hi.min());
   EXPECT_EQ(200u, hi.max());
-  EXPECT_TRUE(d.Difference(d2, &diff));
-  EXPECT_EQ(1u, diff.size());
-  EXPECT_EQ(110u, diff[0]->min());
-  EXPECT_EQ(200u, diff[0]->max());
-  base::STLDeleteElements(&diff);
 
   EXPECT_TRUE(d.Difference(d3, &lo, &hi));
   EXPECT_EQ(100u, lo.min());
   EXPECT_EQ(110u, lo.max());
   EXPECT_EQ(180u, hi.min());
   EXPECT_EQ(200u, hi.max());
-  EXPECT_TRUE(d.Difference(d3, &diff));
-  EXPECT_EQ(2u, diff.size());
-  EXPECT_EQ(100u, diff[0]->min());
-  EXPECT_EQ(110u, diff[0]->max());
-  EXPECT_EQ(180u, diff[1]->min());
-  EXPECT_EQ(200u, diff[1]->max());
-  base::STLDeleteElements(&diff);
 
   EXPECT_TRUE(d.Difference(d4, &lo, &hi));
   EXPECT_EQ(100u, lo.min());
   EXPECT_EQ(180u, lo.max());
   EXPECT_TRUE(hi.Empty());
-  EXPECT_TRUE(d.Difference(d4, &diff));
-  EXPECT_EQ(1u, diff.size());
-  EXPECT_EQ(100u, diff[0]->min());
-  EXPECT_EQ(180u, diff[0]->max());
-  base::STLDeleteElements(&diff);
 
   EXPECT_FALSE(d.Difference(d5, &lo, &hi));
   EXPECT_EQ(100u, lo.min());
   EXPECT_EQ(200u, lo.max());
   EXPECT_TRUE(hi.Empty());
-  EXPECT_FALSE(d.Difference(d5, &diff));
-  EXPECT_EQ(1u, diff.size());
-  EXPECT_EQ(100u, diff[0]->min());
-  EXPECT_EQ(200u, diff[0]->max());
-  base::STLDeleteElements(&diff);
 
   EXPECT_TRUE(d.Difference(d6, &lo, &hi));
   EXPECT_TRUE(lo.Empty());
   EXPECT_EQ(150u, hi.min());
   EXPECT_EQ(200u, hi.max());
-  EXPECT_TRUE(d.Difference(d6, &diff));
-  EXPECT_EQ(1u, diff.size());
-  EXPECT_EQ(150u, diff[0]->min());
-  EXPECT_EQ(200u, diff[0]->max());
-  base::STLDeleteElements(&diff);
 
   EXPECT_TRUE(d.Difference(d7, &lo, &hi));
   EXPECT_EQ(100u, lo.min());
   EXPECT_EQ(150u, lo.max());
   EXPECT_TRUE(hi.Empty());
-  EXPECT_TRUE(d.Difference(d7, &diff));
-  EXPECT_EQ(1u, diff.size());
-  EXPECT_EQ(100u, diff[0]->min());
-  EXPECT_EQ(150u, diff[0]->max());
-  base::STLDeleteElements(&diff);
 
   EXPECT_TRUE(d.Difference(d8, &lo, &hi));
   EXPECT_TRUE(lo.Empty());
   EXPECT_TRUE(hi.Empty());
-  EXPECT_TRUE(d.Difference(d8, &diff) && diff.empty());
 }
 
 TEST_F(IntervalTest, Length) {
   const Interval<int> empty1;
   const Interval<int> empty2(1, 1);
   const Interval<int> empty3(1, 0);
   const Interval<base::TimeDelta> empty4(
       base::TimeDelta() + base::TimeDelta::FromSeconds(1), base::TimeDelta());
   const Interval<int> d1(1, 2);
   const Interval<int> d2(0, 50);
@@ skipping 20 matching lines @@
   const Interval<pair<int, int>> d2({1, 2}, {4, 3});
   EXPECT_EQ("a", d1.min());
   EXPECT_EQ("b", d1.max());
   EXPECT_EQ(std::make_pair(1, 2), d2.min());
   EXPECT_EQ(std::make_pair(4, 3), d2.max());
 }
 
 }  // unnamed namespace
 }  // namespace test
 }  // namespace net