// Copyright 2016 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 <limits>

#include "base/logging.h"
#include "base/macros.h"
#include "base/numerics/saturated_arithmetic.h"
#include "build/build_config.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace base {

TEST(SaturatedArithmeticTest, Addition) {
  int int_max = std::numeric_limits<int>::max();
  int int_min = std::numeric_limits<int>::min();

  EXPECT_EQ(0, SaturatedAddition(0, 0));
  EXPECT_EQ(1, SaturatedAddition(0, 1));
  EXPECT_EQ(100, SaturatedAddition(0, 100));
  EXPECT_EQ(150, SaturatedAddition(100, 50));

  EXPECT_EQ(-1, SaturatedAddition(0, -1));
  EXPECT_EQ(0, SaturatedAddition(1, -1));
  EXPECT_EQ(50, SaturatedAddition(100, -50));
  EXPECT_EQ(-50, SaturatedAddition(50, -100));

  EXPECT_EQ(int_max - 1, SaturatedAddition(int_max - 1, 0));
  EXPECT_EQ(int_max, SaturatedAddition(int_max - 1, 1));
  EXPECT_EQ(int_max, SaturatedAddition(int_max - 1, 2));
  EXPECT_EQ(int_max - 1, SaturatedAddition(0, int_max - 1));
  EXPECT_EQ(int_max, SaturatedAddition(1, int_max - 1));
  EXPECT_EQ(int_max, SaturatedAddition(2, int_max - 1));
  EXPECT_EQ(int_max, SaturatedAddition(int_max - 1, int_max - 1));
  EXPECT_EQ(int_max, SaturatedAddition(int_max, int_max));

  EXPECT_EQ(int_min, SaturatedAddition(int_min, 0));
  EXPECT_EQ(int_min + 1, SaturatedAddition(int_min + 1, 0));
  EXPECT_EQ(int_min + 2, SaturatedAddition(int_min + 1, 1));
  EXPECT_EQ(int_min + 3, SaturatedAddition(int_min + 1, 2));
  EXPECT_EQ(int_min, SaturatedAddition(int_min + 1, -1));
  EXPECT_EQ(int_min, SaturatedAddition(int_min + 1, -2));
  EXPECT_EQ(int_min + 1, SaturatedAddition(0, int_min + 1));
  EXPECT_EQ(int_min, SaturatedAddition(-1, int_min + 1));
  EXPECT_EQ(int_min, SaturatedAddition(-2, int_min + 1));

  EXPECT_EQ(int_max / 2 + 10000, SaturatedAddition(int_max / 2, 10000));
  EXPECT_EQ(int_max, SaturatedAddition(int_max / 2 + 1, int_max / 2 + 1));
  EXPECT_EQ(-1, SaturatedAddition(int_min, int_max));
}

TEST(SaturatedArithmeticTest, Subtraction) {
  int int_max = std::numeric_limits<int>::max();
  int int_min = std::numeric_limits<int>::min();

  EXPECT_EQ(0, SaturatedSubtraction(0, 0));
  EXPECT_EQ(-1, SaturatedSubtraction(0, 1));
  EXPECT_EQ(-100, SaturatedSubtraction(0, 100));
  EXPECT_EQ(50, SaturatedSubtraction(100, 50));

  EXPECT_EQ(1, SaturatedSubtraction(0, -1));
  EXPECT_EQ(2, SaturatedSubtraction(1, -1));
  EXPECT_EQ(150, SaturatedSubtraction(100, -50));
  EXPECT_EQ(150, SaturatedSubtraction(50, -100));

  EXPECT_EQ(int_max, SaturatedSubtraction(int_max, 0));
  EXPECT_EQ(int_max - 1, SaturatedSubtraction(int_max, 1));
  EXPECT_EQ(int_max - 1, SaturatedSubtraction(int_max - 1, 0));
  EXPECT_EQ(int_max, SaturatedSubtraction(int_max - 1, -1));
  EXPECT_EQ(int_max, SaturatedSubtraction(int_max - 1, -2));
  EXPECT_EQ(-int_max + 1, SaturatedSubtraction(0, int_max - 1));
  EXPECT_EQ(-int_max, SaturatedSubtraction(-1, int_max - 1));
  EXPECT_EQ(-int_max - 1, SaturatedSubtraction(-2, int_max - 1));
  EXPECT_EQ(-int_max - 1, SaturatedSubtraction(-3, int_max - 1));

  EXPECT_EQ(int_min, SaturatedSubtraction(int_min, 0));
  EXPECT_EQ(int_min + 1, SaturatedSubtraction(int_min + 1, 0));
  EXPECT_EQ(int_min, SaturatedSubtraction(int_min + 1, 1));
  EXPECT_EQ(int_min, SaturatedSubtraction(int_min + 1, 2));

  EXPECT_EQ(0, SaturatedSubtraction(int_min, int_min));
  EXPECT_EQ(0, SaturatedSubtraction(int_max, int_max));
  EXPECT_EQ(int_max, SaturatedSubtraction(int_max, int_min));
}

TEST(SaturatedArithmeticTest, SetSigned) {
  int int_max = std::numeric_limits<int>::max();
  int int_min = std::numeric_limits<int>::min();

  const int kFractionBits = 6;
  const int kIntMaxForLayoutUnit = int_max >> kFractionBits;
  const int kIntMinForLayoutUnit = int_min >> kFractionBits;

  EXPECT_EQ(0, SaturatedSet<kFractionBits>(0));

  // Internally the max number we can represent (without saturating)
  // is all the (non-sign) bits set except for the bottom n fraction bits
  const int max_internal_representation = int_max ^ ((1 << kFractionBits) - 1);
  EXPECT_EQ(max_internal_representation,
            SaturatedSet<kFractionBits>(kIntMaxForLayoutUnit));

  EXPECT_EQ(GetMaxSaturatedSetResultForTesting(kFractionBits),
            SaturatedSet<kFractionBits>(kIntMaxForLayoutUnit + 100));

  EXPECT_EQ((kIntMaxForLayoutUnit - 100) << kFractionBits,
            SaturatedSet<kFractionBits>(kIntMaxForLayoutUnit - 100));

  EXPECT_EQ(GetMinSaturatedSetResultForTesting(kFractionBits),
            SaturatedSet<kFractionBits>(kIntMinForLayoutUnit));

  EXPECT_EQ(GetMinSaturatedSetResultForTesting(kFractionBits),
            SaturatedSet<kFractionBits>(kIntMinForLayoutUnit - 100));

  // Shifting negative numbers left has undefined behavior, so use
  // multiplication instead of direct shifting here.
  EXPECT_EQ((kIntMinForLayoutUnit + 100) * (1 << kFractionBits),
            SaturatedSet<kFractionBits>(kIntMinForLayoutUnit + 100));
}

TEST(SaturatedArithmeticTest, SetUnsigned) {
  int int_max = std::numeric_limits<int>::max();

  const int kFractionBits = 6;
  const int kIntMaxForLayoutUnit = int_max >> kFractionBits;

  EXPECT_EQ(0, SaturatedSet<kFractionBits>((unsigned)0));

  EXPECT_EQ(GetMaxSaturatedSetResultForTesting(kFractionBits),
            SaturatedSet<kFractionBits>((unsigned)kIntMaxForLayoutUnit));

  const unsigned kOverflowed = kIntMaxForLayoutUnit + 100;
  EXPECT_EQ(GetMaxSaturatedSetResultForTesting(kFractionBits),
            SaturatedSet<kFractionBits>(kOverflowed));

  const unsigned kNotOverflowed = kIntMaxForLayoutUnit - 100;
  EXPECT_EQ((kIntMaxForLayoutUnit - 100) << kFractionBits,
            SaturatedSet<kFractionBits>(kNotOverflowed));
}

}  // namespace base