Repo created
This commit is contained in:
parent
81b91f4139
commit
f8c34fa5ee
22732 changed files with 4815320 additions and 2 deletions
237
TMessagesProj/jni/voip/webrtc/api/units/time_delta_unittest.cc
Normal file
237
TMessagesProj/jni/voip/webrtc/api/units/time_delta_unittest.cc
Normal file
|
|
@ -0,0 +1,237 @@
|
|||
/*
|
||||
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#include "api/units/time_delta.h"
|
||||
|
||||
#include <limits>
|
||||
|
||||
#include "test/gtest.h"
|
||||
|
||||
namespace webrtc {
|
||||
namespace test {
|
||||
TEST(TimeDeltaTest, ConstExpr) {
|
||||
constexpr int64_t kValue = -12345;
|
||||
constexpr TimeDelta kTimeDeltaZero = TimeDelta::Zero();
|
||||
constexpr TimeDelta kTimeDeltaPlusInf = TimeDelta::PlusInfinity();
|
||||
constexpr TimeDelta kTimeDeltaMinusInf = TimeDelta::MinusInfinity();
|
||||
static_assert(kTimeDeltaZero.IsZero(), "");
|
||||
static_assert(kTimeDeltaPlusInf.IsPlusInfinity(), "");
|
||||
static_assert(kTimeDeltaMinusInf.IsMinusInfinity(), "");
|
||||
static_assert(kTimeDeltaPlusInf.ms_or(-1) == -1, "");
|
||||
|
||||
static_assert(kTimeDeltaPlusInf > kTimeDeltaZero, "");
|
||||
|
||||
constexpr TimeDelta kTimeDeltaMinutes = TimeDelta::Minutes(kValue);
|
||||
constexpr TimeDelta kTimeDeltaSeconds = TimeDelta::Seconds(kValue);
|
||||
constexpr TimeDelta kTimeDeltaMs = TimeDelta::Millis(kValue);
|
||||
constexpr TimeDelta kTimeDeltaUs = TimeDelta::Micros(kValue);
|
||||
|
||||
static_assert(kTimeDeltaMinutes.seconds_or(0) == kValue * 60, "");
|
||||
static_assert(kTimeDeltaSeconds.seconds_or(0) == kValue, "");
|
||||
static_assert(kTimeDeltaMs.ms_or(0) == kValue, "");
|
||||
static_assert(kTimeDeltaUs.us_or(0) == kValue, "");
|
||||
}
|
||||
|
||||
TEST(TimeDeltaTest, GetBackSameValues) {
|
||||
const int64_t kValue = 499;
|
||||
for (int sign = -1; sign <= 1; ++sign) {
|
||||
int64_t value = kValue * sign;
|
||||
EXPECT_EQ(TimeDelta::Millis(value).ms(), value);
|
||||
EXPECT_EQ(TimeDelta::Micros(value).us(), value);
|
||||
EXPECT_EQ(TimeDelta::Seconds(value).seconds(), value);
|
||||
EXPECT_EQ(TimeDelta::Seconds(value).seconds(), value);
|
||||
}
|
||||
EXPECT_EQ(TimeDelta::Zero().us(), 0);
|
||||
}
|
||||
|
||||
TEST(TimeDeltaTest, GetDifferentPrefix) {
|
||||
const int64_t kValue = 3000000;
|
||||
EXPECT_EQ(TimeDelta::Micros(kValue).seconds(), kValue / 1000000);
|
||||
EXPECT_EQ(TimeDelta::Millis(kValue).seconds(), kValue / 1000);
|
||||
EXPECT_EQ(TimeDelta::Micros(kValue).ms(), kValue / 1000);
|
||||
EXPECT_EQ(TimeDelta::Minutes(kValue / 60).seconds(), kValue);
|
||||
|
||||
EXPECT_EQ(TimeDelta::Millis(kValue).us(), kValue * 1000);
|
||||
EXPECT_EQ(TimeDelta::Seconds(kValue).ms(), kValue * 1000);
|
||||
EXPECT_EQ(TimeDelta::Seconds(kValue).us(), kValue * 1000000);
|
||||
EXPECT_EQ(TimeDelta::Minutes(kValue / 60).seconds(), kValue);
|
||||
}
|
||||
|
||||
TEST(TimeDeltaTest, IdentityChecks) {
|
||||
const int64_t kValue = 3000;
|
||||
EXPECT_TRUE(TimeDelta::Zero().IsZero());
|
||||
EXPECT_FALSE(TimeDelta::Millis(kValue).IsZero());
|
||||
|
||||
EXPECT_TRUE(TimeDelta::PlusInfinity().IsInfinite());
|
||||
EXPECT_TRUE(TimeDelta::MinusInfinity().IsInfinite());
|
||||
EXPECT_FALSE(TimeDelta::Zero().IsInfinite());
|
||||
EXPECT_FALSE(TimeDelta::Millis(-kValue).IsInfinite());
|
||||
EXPECT_FALSE(TimeDelta::Millis(kValue).IsInfinite());
|
||||
|
||||
EXPECT_FALSE(TimeDelta::PlusInfinity().IsFinite());
|
||||
EXPECT_FALSE(TimeDelta::MinusInfinity().IsFinite());
|
||||
EXPECT_TRUE(TimeDelta::Millis(-kValue).IsFinite());
|
||||
EXPECT_TRUE(TimeDelta::Millis(kValue).IsFinite());
|
||||
EXPECT_TRUE(TimeDelta::Zero().IsFinite());
|
||||
|
||||
EXPECT_TRUE(TimeDelta::PlusInfinity().IsPlusInfinity());
|
||||
EXPECT_FALSE(TimeDelta::MinusInfinity().IsPlusInfinity());
|
||||
|
||||
EXPECT_TRUE(TimeDelta::MinusInfinity().IsMinusInfinity());
|
||||
EXPECT_FALSE(TimeDelta::PlusInfinity().IsMinusInfinity());
|
||||
}
|
||||
|
||||
TEST(TimeDeltaTest, ComparisonOperators) {
|
||||
const int64_t kSmall = 450;
|
||||
const int64_t kLarge = 451;
|
||||
const TimeDelta small = TimeDelta::Millis(kSmall);
|
||||
const TimeDelta large = TimeDelta::Millis(kLarge);
|
||||
|
||||
EXPECT_EQ(TimeDelta::Zero(), TimeDelta::Millis(0));
|
||||
EXPECT_EQ(TimeDelta::PlusInfinity(), TimeDelta::PlusInfinity());
|
||||
EXPECT_EQ(small, TimeDelta::Millis(kSmall));
|
||||
EXPECT_LE(small, TimeDelta::Millis(kSmall));
|
||||
EXPECT_GE(small, TimeDelta::Millis(kSmall));
|
||||
EXPECT_NE(small, TimeDelta::Millis(kLarge));
|
||||
EXPECT_LE(small, TimeDelta::Millis(kLarge));
|
||||
EXPECT_LT(small, TimeDelta::Millis(kLarge));
|
||||
EXPECT_GE(large, TimeDelta::Millis(kSmall));
|
||||
EXPECT_GT(large, TimeDelta::Millis(kSmall));
|
||||
EXPECT_LT(TimeDelta::Zero(), small);
|
||||
EXPECT_GT(TimeDelta::Zero(), TimeDelta::Millis(-kSmall));
|
||||
EXPECT_GT(TimeDelta::Zero(), TimeDelta::Millis(-kSmall));
|
||||
|
||||
EXPECT_GT(TimeDelta::PlusInfinity(), large);
|
||||
EXPECT_LT(TimeDelta::MinusInfinity(), TimeDelta::Zero());
|
||||
}
|
||||
|
||||
TEST(TimeDeltaTest, Clamping) {
|
||||
const TimeDelta upper = TimeDelta::Millis(800);
|
||||
const TimeDelta lower = TimeDelta::Millis(100);
|
||||
const TimeDelta under = TimeDelta::Millis(100);
|
||||
const TimeDelta inside = TimeDelta::Millis(500);
|
||||
const TimeDelta over = TimeDelta::Millis(1000);
|
||||
EXPECT_EQ(under.Clamped(lower, upper), lower);
|
||||
EXPECT_EQ(inside.Clamped(lower, upper), inside);
|
||||
EXPECT_EQ(over.Clamped(lower, upper), upper);
|
||||
|
||||
TimeDelta mutable_delta = lower;
|
||||
mutable_delta.Clamp(lower, upper);
|
||||
EXPECT_EQ(mutable_delta, lower);
|
||||
mutable_delta = inside;
|
||||
mutable_delta.Clamp(lower, upper);
|
||||
EXPECT_EQ(mutable_delta, inside);
|
||||
mutable_delta = over;
|
||||
mutable_delta.Clamp(lower, upper);
|
||||
EXPECT_EQ(mutable_delta, upper);
|
||||
}
|
||||
|
||||
TEST(TimeDeltaTest, CanBeInititializedFromLargeInt) {
|
||||
const int kMaxInt = std::numeric_limits<int>::max();
|
||||
EXPECT_EQ(TimeDelta::Seconds(kMaxInt).us(),
|
||||
static_cast<int64_t>(kMaxInt) * 1000000);
|
||||
EXPECT_EQ(TimeDelta::Millis(kMaxInt).us(),
|
||||
static_cast<int64_t>(kMaxInt) * 1000);
|
||||
}
|
||||
|
||||
TEST(TimeDeltaTest, ConvertsToAndFromDouble) {
|
||||
const int64_t kMicros = 17017;
|
||||
const double kNanosDouble = kMicros * 1e3;
|
||||
const double kMicrosDouble = kMicros;
|
||||
const double kMillisDouble = kMicros * 1e-3;
|
||||
const double kSecondsDouble = kMillisDouble * 1e-3;
|
||||
|
||||
EXPECT_EQ(TimeDelta::Micros(kMicros).seconds<double>(), kSecondsDouble);
|
||||
EXPECT_EQ(TimeDelta::Seconds(kSecondsDouble).us(), kMicros);
|
||||
|
||||
EXPECT_EQ(TimeDelta::Micros(kMicros).ms<double>(), kMillisDouble);
|
||||
EXPECT_EQ(TimeDelta::Millis(kMillisDouble).us(), kMicros);
|
||||
|
||||
EXPECT_EQ(TimeDelta::Micros(kMicros).us<double>(), kMicrosDouble);
|
||||
EXPECT_EQ(TimeDelta::Micros(kMicrosDouble).us(), kMicros);
|
||||
|
||||
EXPECT_NEAR(TimeDelta::Micros(kMicros).ns<double>(), kNanosDouble, 1);
|
||||
|
||||
const double kPlusInfinity = std::numeric_limits<double>::infinity();
|
||||
const double kMinusInfinity = -kPlusInfinity;
|
||||
|
||||
EXPECT_EQ(TimeDelta::PlusInfinity().seconds<double>(), kPlusInfinity);
|
||||
EXPECT_EQ(TimeDelta::MinusInfinity().seconds<double>(), kMinusInfinity);
|
||||
EXPECT_EQ(TimeDelta::PlusInfinity().ms<double>(), kPlusInfinity);
|
||||
EXPECT_EQ(TimeDelta::MinusInfinity().ms<double>(), kMinusInfinity);
|
||||
EXPECT_EQ(TimeDelta::PlusInfinity().us<double>(), kPlusInfinity);
|
||||
EXPECT_EQ(TimeDelta::MinusInfinity().us<double>(), kMinusInfinity);
|
||||
EXPECT_EQ(TimeDelta::PlusInfinity().ns<double>(), kPlusInfinity);
|
||||
EXPECT_EQ(TimeDelta::MinusInfinity().ns<double>(), kMinusInfinity);
|
||||
|
||||
EXPECT_TRUE(TimeDelta::Seconds(kPlusInfinity).IsPlusInfinity());
|
||||
EXPECT_TRUE(TimeDelta::Seconds(kMinusInfinity).IsMinusInfinity());
|
||||
EXPECT_TRUE(TimeDelta::Millis(kPlusInfinity).IsPlusInfinity());
|
||||
EXPECT_TRUE(TimeDelta::Millis(kMinusInfinity).IsMinusInfinity());
|
||||
EXPECT_TRUE(TimeDelta::Micros(kPlusInfinity).IsPlusInfinity());
|
||||
EXPECT_TRUE(TimeDelta::Micros(kMinusInfinity).IsMinusInfinity());
|
||||
}
|
||||
|
||||
TEST(TimeDeltaTest, MathOperations) {
|
||||
const int64_t kValueA = 267;
|
||||
const int64_t kValueB = 450;
|
||||
const TimeDelta delta_a = TimeDelta::Millis(kValueA);
|
||||
const TimeDelta delta_b = TimeDelta::Millis(kValueB);
|
||||
EXPECT_EQ((delta_a + delta_b).ms(), kValueA + kValueB);
|
||||
EXPECT_EQ((delta_a - delta_b).ms(), kValueA - kValueB);
|
||||
|
||||
EXPECT_EQ((delta_b / 10).ms(), kValueB / 10);
|
||||
EXPECT_EQ(delta_b / delta_a, static_cast<double>(kValueB) / kValueA);
|
||||
|
||||
EXPECT_EQ(TimeDelta::Micros(-kValueA).Abs().us(), kValueA);
|
||||
EXPECT_EQ(TimeDelta::Micros(kValueA).Abs().us(), kValueA);
|
||||
|
||||
TimeDelta mutable_delta = TimeDelta::Millis(kValueA);
|
||||
mutable_delta += TimeDelta::Millis(kValueB);
|
||||
EXPECT_EQ(mutable_delta, TimeDelta::Millis(kValueA + kValueB));
|
||||
mutable_delta -= TimeDelta::Millis(kValueB);
|
||||
EXPECT_EQ(mutable_delta, TimeDelta::Millis(kValueA));
|
||||
}
|
||||
|
||||
TEST(TimeDeltaTest, MultiplyByScalar) {
|
||||
const TimeDelta kValue = TimeDelta::Micros(267);
|
||||
const int64_t kInt64 = 450;
|
||||
const int32_t kInt32 = 123;
|
||||
const size_t kUnsignedInt = 125;
|
||||
const double kFloat = 123.0;
|
||||
|
||||
EXPECT_EQ((kValue * kInt64).us(), kValue.us() * kInt64);
|
||||
EXPECT_EQ(kValue * kInt64, kInt64 * kValue);
|
||||
|
||||
EXPECT_EQ((kValue * kInt32).us(), kValue.us() * kInt32);
|
||||
EXPECT_EQ(kValue * kInt32, kInt32 * kValue);
|
||||
|
||||
EXPECT_EQ((kValue * kUnsignedInt).us(), kValue.us() * int64_t{kUnsignedInt});
|
||||
EXPECT_EQ(kValue * kUnsignedInt, kUnsignedInt * kValue);
|
||||
|
||||
EXPECT_DOUBLE_EQ((kValue * kFloat).us(), kValue.us() * kFloat);
|
||||
EXPECT_EQ(kValue * kFloat, kFloat * kValue);
|
||||
}
|
||||
|
||||
TEST(TimeDeltaTest, InfinityOperations) {
|
||||
const int64_t kValue = 267;
|
||||
const TimeDelta finite = TimeDelta::Millis(kValue);
|
||||
EXPECT_TRUE((TimeDelta::PlusInfinity() + finite).IsPlusInfinity());
|
||||
EXPECT_TRUE((TimeDelta::PlusInfinity() - finite).IsPlusInfinity());
|
||||
EXPECT_TRUE((finite + TimeDelta::PlusInfinity()).IsPlusInfinity());
|
||||
EXPECT_TRUE((finite - TimeDelta::MinusInfinity()).IsPlusInfinity());
|
||||
|
||||
EXPECT_TRUE((TimeDelta::MinusInfinity() + finite).IsMinusInfinity());
|
||||
EXPECT_TRUE((TimeDelta::MinusInfinity() - finite).IsMinusInfinity());
|
||||
EXPECT_TRUE((finite + TimeDelta::MinusInfinity()).IsMinusInfinity());
|
||||
EXPECT_TRUE((finite - TimeDelta::PlusInfinity()).IsMinusInfinity());
|
||||
}
|
||||
} // namespace test
|
||||
} // namespace webrtc
|
||||
Loading…
Add table
Add a link
Reference in a new issue