// Copyright (c) 2019 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/third_party/quiche/src/quic/core/quic_interval.h"

#include <sstream>
#include <string>
#include <type_traits>
#include <utility>

#include "net/third_party/quiche/src/quic/core/quic_time.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"

namespace quic {
namespace test {
namespace {

template <typename ForwardIterator>
void STLDeleteContainerPointers(ForwardIterator begin, ForwardIterator end) {
  while (begin != end) {
    auto temp = begin;
    ++begin;
    delete *temp;
  }
}

template <typename T>
void STLDeleteElements(T* container) {
  if (!container)
    return;
  STLDeleteContainerPointers(container->begin(), container->end());
  container->clear();
}

class ConstructorListener {
 public:
  ConstructorListener(int* copy_construct_counter, int* move_construct_counter)
      : copy_construct_counter_(copy_construct_counter),
        move_construct_counter_(move_construct_counter) {
    *copy_construct_counter_ = 0;
    *move_construct_counter_ = 0;
  }
  ConstructorListener(const ConstructorListener& other) {
    copy_construct_counter_ = other.copy_construct_counter_;
    move_construct_counter_ = other.move_construct_counter_;
    ++*copy_construct_counter_;
  }
  ConstructorListener(ConstructorListener&& other) {
    copy_construct_counter_ = other.copy_construct_counter_;
    move_construct_counter_ = other.move_construct_counter_;
    ++*move_construct_counter_;
  }
  bool operator<(const ConstructorListener&) { return false; }
  bool operator>(const ConstructorListener&) { return false; }
  bool operator<=(const ConstructorListener&) { return true; }
  bool operator>=(const ConstructorListener&) { return true; }
  bool operator==(const ConstructorListener&) { return true; }

 private:
  int* copy_construct_counter_;
  int* move_construct_counter_;
};

TEST(IntervalConstructorTest, Move) {
  int object1_copy_count, object1_move_count;
  ConstructorListener object1(&object1_copy_count, &object1_move_count);
  int object2_copy_count, object2_move_count;
  ConstructorListener object2(&object2_copy_count, &object2_move_count);

  QuicInterval<ConstructorListener> interval(object1, std::move(object2));
  EXPECT_EQ(1, object1_copy_count);
  EXPECT_EQ(0, object1_move_count);
  EXPECT_EQ(0, object2_copy_count);
  EXPECT_EQ(1, object2_move_count);
}

TEST(IntervalConstructorTest, ImplicitConversion) {
  struct WrappedInt {
    WrappedInt(int value) : value(value) {}
    bool operator<(const WrappedInt& other) { return value < other.value; }
    bool operator>(const WrappedInt& other) { return value > other.value; }
    bool operator<=(const WrappedInt& other) { return value <= other.value; }
    bool operator>=(const WrappedInt& other) { return value >= other.value; }
    bool operator==(const WrappedInt& other) { return value == other.value; }
    int value;
  };

  static_assert(std::is_convertible<int, WrappedInt>::value, "");
  static_assert(
      std::is_constructible<QuicInterval<WrappedInt>, int, int>::value, "");

  QuicInterval<WrappedInt> i(10, 20);
  EXPECT_EQ(10, i.min().value);
  EXPECT_EQ(20, i.max().value);
}

class IntervalTest : public QuicTest {
 protected:
  // Test intersection between the two intervals i1 and i2.  Tries
  // i1.IntersectWith(i2) and vice versa. The intersection should change i1 iff
  // changes_i1 is true, and the same for changes_i2.  The resulting
  // intersection should be result.
  void TestIntersect(const QuicInterval<int64_t>& i1,
                     const QuicInterval<int64_t>& i2,
                     bool changes_i1,
                     bool changes_i2,
                     const QuicInterval<int64_t>& result) {
    QuicInterval<int64_t> i;
    i = i1;
    EXPECT_TRUE(i.IntersectWith(i2) == changes_i1 && i == result);
    i = i2;
    EXPECT_TRUE(i.IntersectWith(i1) == changes_i2 && i == result);
  }
};

TEST_F(IntervalTest, ConstructorsCopyAndClear) {
  QuicInterval<int32_t> empty;
  EXPECT_TRUE(empty.Empty());

  QuicInterval<int32_t> d2(0, 100);
  EXPECT_EQ(0, d2.min());
  EXPECT_EQ(100, d2.max());
  EXPECT_EQ(QuicInterval<int32_t>(0, 100), d2);
  EXPECT_NE(QuicInterval<int32_t>(0, 99), d2);

  empty = d2;
  EXPECT_EQ(0, d2.min());
  EXPECT_EQ(100, d2.max());
  EXPECT_TRUE(empty == d2);
  EXPECT_EQ(empty, d2);
  EXPECT_TRUE(d2 == empty);
  EXPECT_EQ(d2, empty);

  QuicInterval<int32_t> max_less_than_min(40, 20);
  EXPECT_TRUE(max_less_than_min.Empty());
  EXPECT_EQ(40, max_less_than_min.min());
  EXPECT_EQ(20, max_less_than_min.max());

  QuicInterval<int> d3(10, 20);
  d3.Clear();
  EXPECT_TRUE(d3.Empty());
}

TEST_F(IntervalTest, MakeQuicInterval) {
  static_assert(
      std::is_same<QuicInterval<int>, decltype(MakeQuicInterval(0, 3))>::value,
      "Type is deduced incorrectly.");
  static_assert(std::is_same<QuicInterval<double>,
                             decltype(MakeQuicInterval(0., 3.))>::value,
                "Type is deduced incorrectly.");

  EXPECT_EQ(MakeQuicInterval(0., 3.), QuicInterval<double>(0, 3));
}

TEST_F(IntervalTest, GettersSetters) {
  QuicInterval<int32_t> d1(100, 200);

  // SetMin:
  d1.SetMin(30);
  EXPECT_EQ(30, d1.min());
  EXPECT_EQ(200, d1.max());

  // SetMax:
  d1.SetMax(220);
  EXPECT_EQ(30, d1.min());
  EXPECT_EQ(220, d1.max());

  // Set:
  d1.Clear();
  d1.Set(30, 220);
  EXPECT_EQ(30, d1.min());
  EXPECT_EQ(220, d1.max());

  // SpanningUnion:
  QuicInterval<int32_t> d2;
  EXPECT_TRUE(!d1.SpanningUnion(d2));
  EXPECT_EQ(30, d1.min());
  EXPECT_EQ(220, d1.max());

  EXPECT_TRUE(d2.SpanningUnion(d1));
  EXPECT_EQ(30, d2.min());
  EXPECT_EQ(220, d2.max());

  d2.SetMin(40);
  d2.SetMax(100);
  EXPECT_TRUE(!d1.SpanningUnion(d2));
  EXPECT_EQ(30, d1.min());
  EXPECT_EQ(220, d1.max());

  d2.SetMin(20);
  d2.SetMax(100);
  EXPECT_TRUE(d1.SpanningUnion(d2));
  EXPECT_EQ(20, d1.min());
  EXPECT_EQ(220, d1.max());

  d2.SetMin(50);
  d2.SetMax(300);
  EXPECT_TRUE(d1.SpanningUnion(d2));
  EXPECT_EQ(20, d1.min());
  EXPECT_EQ(300, d1.max());

  d2.SetMin(0);
  d2.SetMax(500);
  EXPECT_TRUE(d1.SpanningUnion(d2));
  EXPECT_EQ(0, d1.min());
  EXPECT_EQ(500, d1.max());

  d2.SetMin(100);
  d2.SetMax(0);
  EXPECT_TRUE(!d1.SpanningUnion(d2));
  EXPECT_EQ(0, d1.min());
  EXPECT_EQ(500, d1.max());
  EXPECT_TRUE(d2.SpanningUnion(d1));
  EXPECT_EQ(0, d2.min());
  EXPECT_EQ(500, d2.max());
}

TEST_F(IntervalTest, CoveringOps) {
  const QuicInterval<int64_t> empty;
  const QuicInterval<int64_t> d(100, 200);
  const QuicInterval<int64_t> d1(0, 50);
  const QuicInterval<int64_t> d2(50, 110);
  const QuicInterval<int64_t> d3(110, 180);
  const QuicInterval<int64_t> d4(180, 220);
  const QuicInterval<int64_t> d5(220, 300);
  const QuicInterval<int64_t> d6(100, 150);
  const QuicInterval<int64_t> d7(150, 200);
  const QuicInterval<int64_t> d8(0, 300);

  // Intersection:
  EXPECT_TRUE(d.Intersects(d));
  EXPECT_TRUE(!empty.Intersects(d) && !d.Intersects(empty));
  EXPECT_TRUE(!d.Intersects(d1) && !d1.Intersects(d));
  EXPECT_TRUE(d.Intersects(d2) && d2.Intersects(d));
  EXPECT_TRUE(d.Intersects(d3) && d3.Intersects(d));
  EXPECT_TRUE(d.Intersects(d4) && d4.Intersects(d));
  EXPECT_TRUE(!d.Intersects(d5) && !d5.Intersects(d));
  EXPECT_TRUE(d.Intersects(d6) && d6.Intersects(d));
  EXPECT_TRUE(d.Intersects(d7) && d7.Intersects(d));
  EXPECT_TRUE(d.Intersects(d8) && d8.Intersects(d));

  QuicInterval<int64_t> i;
  EXPECT_TRUE(d.Intersects(d, &i) && d == i);
  EXPECT_TRUE(!empty.Intersects(d, nullptr) && !d.Intersects(empty, nullptr));
  EXPECT_TRUE(!d.Intersects(d1, nullptr) && !d1.Intersects(d, nullptr));
  EXPECT_TRUE(d.Intersects(d2, &i) && i == QuicInterval<int64_t>(100, 110));
  EXPECT_TRUE(d2.Intersects(d, &i) && i == QuicInterval<int64_t>(100, 110));
  EXPECT_TRUE(d.Intersects(d3, &i) && i == d3);
  EXPECT_TRUE(d3.Intersects(d, &i) && i == d3);
  EXPECT_TRUE(d.Intersects(d4, &i) && i == QuicInterval<int64_t>(180, 200));
  EXPECT_TRUE(d4.Intersects(d, &i) && i == QuicInterval<int64_t>(180, 200));
  EXPECT_TRUE(!d.Intersects(d5, nullptr) && !d5.Intersects(d, nullptr));
  EXPECT_TRUE(d.Intersects(d6, &i) && i == d6);
  EXPECT_TRUE(d6.Intersects(d, &i) && i == d6);
  EXPECT_TRUE(d.Intersects(d7, &i) && i == d7);
  EXPECT_TRUE(d7.Intersects(d, &i) && i == d7);
  EXPECT_TRUE(d.Intersects(d8, &i) && i == d);
  EXPECT_TRUE(d8.Intersects(d, &i) && i == d);

  // Test IntersectsWith().
  // Arguments are TestIntersect(i1, i2, changes_i1, changes_i2, result).
  TestIntersect(empty, d, false, true, empty);
  TestIntersect(d, d1, true, true, empty);
  TestIntersect(d1, d2, true, true, empty);
  TestIntersect(d, d2, true, true, QuicInterval<int64_t>(100, 110));
  TestIntersect(d8, d, true, false, d);
  TestIntersect(d8, d1, true, false, d1);
  TestIntersect(d8, d5, true, false, d5);

  // Contains:
  EXPECT_TRUE(!empty.Contains(d) && !d.Contains(empty));
  EXPECT_TRUE(d.Contains(d));
  EXPECT_TRUE(!d.Contains(d1) && !d1.Contains(d));
  EXPECT_TRUE(!d.Contains(d2) && !d2.Contains(d));
  EXPECT_TRUE(d.Contains(d3) && !d3.Contains(d));
  EXPECT_TRUE(!d.Contains(d4) && !d4.Contains(d));
  EXPECT_TRUE(!d.Contains(d5) && !d5.Contains(d));
  EXPECT_TRUE(d.Contains(d6) && !d6.Contains(d));
  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:
  std::vector<QuicInterval<int64_t>*> diff;

  EXPECT_TRUE(!d.Difference(empty, &diff));
  EXPECT_EQ(1, diff.size());
  EXPECT_EQ(100, diff[0]->min());
  EXPECT_EQ(200, diff[0]->max());
  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(1, diff.size());
  EXPECT_EQ(100, diff[0]->min());
  EXPECT_EQ(200, diff[0]->max());
  STLDeleteElements(&diff);

  QuicInterval<int64_t> lo;
  QuicInterval<int64_t> hi;

  EXPECT_TRUE(d.Difference(d2, &lo, &hi));
  EXPECT_TRUE(lo.Empty());
  EXPECT_EQ(110, hi.min());
  EXPECT_EQ(200, hi.max());
  EXPECT_TRUE(d.Difference(d2, &diff));
  EXPECT_EQ(1, diff.size());
  EXPECT_EQ(110, diff[0]->min());
  EXPECT_EQ(200, diff[0]->max());
  STLDeleteElements(&diff);

  EXPECT_TRUE(d.Difference(d3, &lo, &hi));
  EXPECT_EQ(100, lo.min());
  EXPECT_EQ(110, lo.max());
  EXPECT_EQ(180, hi.min());
  EXPECT_EQ(200, hi.max());
  EXPECT_TRUE(d.Difference(d3, &diff));
  EXPECT_EQ(2, diff.size());
  EXPECT_EQ(100, diff[0]->min());
  EXPECT_EQ(110, diff[0]->max());
  EXPECT_EQ(180, diff[1]->min());
  EXPECT_EQ(200, diff[1]->max());
  STLDeleteElements(&diff);

  EXPECT_TRUE(d.Difference(d4, &lo, &hi));
  EXPECT_EQ(100, lo.min());
  EXPECT_EQ(180, lo.max());
  EXPECT_TRUE(hi.Empty());
  EXPECT_TRUE(d.Difference(d4, &diff));
  EXPECT_EQ(1, diff.size());
  EXPECT_EQ(100, diff[0]->min());
  EXPECT_EQ(180, diff[0]->max());
  STLDeleteElements(&diff);

  EXPECT_FALSE(d.Difference(d5, &lo, &hi));
  EXPECT_EQ(100, lo.min());
  EXPECT_EQ(200, lo.max());
  EXPECT_TRUE(hi.Empty());
  EXPECT_FALSE(d.Difference(d5, &diff));
  EXPECT_EQ(1, diff.size());
  EXPECT_EQ(100, diff[0]->min());
  EXPECT_EQ(200, diff[0]->max());
  STLDeleteElements(&diff);

  EXPECT_TRUE(d.Difference(d6, &lo, &hi));
  EXPECT_TRUE(lo.Empty());
  EXPECT_EQ(150, hi.min());
  EXPECT_EQ(200, hi.max());
  EXPECT_TRUE(d.Difference(d6, &diff));
  EXPECT_EQ(1, diff.size());
  EXPECT_EQ(150, diff[0]->min());
  EXPECT_EQ(200, diff[0]->max());
  STLDeleteElements(&diff);

  EXPECT_TRUE(d.Difference(d7, &lo, &hi));
  EXPECT_EQ(100, lo.min());
  EXPECT_EQ(150, lo.max());
  EXPECT_TRUE(hi.Empty());
  EXPECT_TRUE(d.Difference(d7, &diff));
  EXPECT_EQ(1, diff.size());
  EXPECT_EQ(100, diff[0]->min());
  EXPECT_EQ(150, diff[0]->max());
  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 QuicInterval<int> empty1;
  const QuicInterval<int> empty2(1, 1);
  const QuicInterval<int> empty3(1, 0);
  const QuicInterval<QuicTime> empty4(
      QuicTime::Zero() + QuicTime::Delta::FromSeconds(1), QuicTime::Zero());
  const QuicInterval<int> d1(1, 2);
  const QuicInterval<int> d2(0, 50);
  const QuicInterval<QuicTime> d3(
      QuicTime::Zero(), QuicTime::Zero() + QuicTime::Delta::FromSeconds(1));
  const QuicInterval<QuicTime> d4(
      QuicTime::Zero() + QuicTime::Delta::FromSeconds(3600),
      QuicTime::Zero() + QuicTime::Delta::FromSeconds(5400));

  EXPECT_EQ(0, empty1.Length());
  EXPECT_EQ(0, empty2.Length());
  EXPECT_EQ(0, empty3.Length());
  EXPECT_EQ(QuicTime::Delta::Zero(), empty4.Length());
  EXPECT_EQ(1, d1.Length());
  EXPECT_EQ(50, d2.Length());
  EXPECT_EQ(QuicTime::Delta::FromSeconds(1), d3.Length());
  EXPECT_EQ(QuicTime::Delta::FromSeconds(1800), d4.Length());
}

TEST_F(IntervalTest, IntervalOfTypeWithNoOperatorMinus) {
  // QuicInterval<T> should work even if T does not support operator-().  We
  // just can't call QuicInterval<T>::Length() for such types.
  const QuicInterval<string> d1("a", "b");
  const QuicInterval<std::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());
}

struct NoEquals {
  NoEquals(int v) : value(v) {}  // NOLINT
  int value;
  bool operator<(const NoEquals& other) const { return value < other.value; }
};

TEST_F(IntervalTest, OrderedComparisonForTypeWithoutEquals) {
  const QuicInterval<NoEquals> d1(0, 4);
  const QuicInterval<NoEquals> d2(0, 3);
  const QuicInterval<NoEquals> d3(1, 4);
  const QuicInterval<NoEquals> d4(1, 5);
  const QuicInterval<NoEquals> d6(0, 4);
  EXPECT_TRUE(d1 < d2);
  EXPECT_TRUE(d1 < d3);
  EXPECT_TRUE(d1 < d4);
  EXPECT_FALSE(d1 < d6);
}

TEST_F(IntervalTest, OutputReturnsOstreamRef) {
  std::stringstream ss;
  const QuicInterval<int> v(1, 2);
  // If (ss << v) were to return a value, it wouldn't match the signature of
  // return_type_is_a_ref() function.
  auto return_type_is_a_ref = [](std::ostream&) {};
  return_type_is_a_ref(ss << v);
}

struct NotOstreamable {
  bool operator<(const NotOstreamable& other) const { return false; }
  bool operator>=(const NotOstreamable& other) const { return true; }
  bool operator==(const NotOstreamable& other) const { return true; }
};

TEST_F(IntervalTest, IntervalOfTypeWithNoOstreamSupport) {
  const NotOstreamable v;
  const QuicInterval<NotOstreamable> d(v, v);
  // EXPECT_EQ builds a string representation of d. If d::operator<<() would be
  // defined then this test would not compile because NotOstreamable objects
  // lack the operator<<() support.
  EXPECT_EQ(d, d);
}

}  // namespace
}  // namespace test
}  // namespace quic