data_size_unittest.cc (3745B)
1 /* 2 * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "api/units/data_size.h" 12 13 #include <cstdint> 14 #include <limits> 15 16 #include "test/gtest.h" 17 18 namespace webrtc { 19 namespace test { 20 21 TEST(DataSizeTest, ConstExpr) { 22 constexpr int64_t kValue = 12345; 23 constexpr DataSize kDataSizeZero = DataSize::Zero(); 24 constexpr DataSize kDataSizeInf = DataSize::Infinity(); 25 static_assert(DataSize() == kDataSizeZero); 26 static_assert(kDataSizeZero.IsZero(), ""); 27 static_assert(kDataSizeInf.IsInfinite(), ""); 28 static_assert(kDataSizeInf.bytes_or(-1) == -1, ""); 29 static_assert(kDataSizeInf > kDataSizeZero, ""); 30 31 constexpr DataSize kDataSize = DataSize::Bytes(kValue); 32 static_assert(kDataSize.bytes_or(-1) == kValue, ""); 33 34 EXPECT_EQ(kDataSize.bytes(), kValue); 35 } 36 37 TEST(DataSizeTest, GetBackSameValues) { 38 const int64_t kValue = 123 * 8; 39 EXPECT_EQ(DataSize::Bytes(kValue).bytes(), kValue); 40 } 41 42 TEST(DataSizeTest, IdentityChecks) { 43 const int64_t kValue = 3000; 44 EXPECT_TRUE(DataSize::Zero().IsZero()); 45 EXPECT_FALSE(DataSize::Bytes(kValue).IsZero()); 46 47 EXPECT_TRUE(DataSize::Infinity().IsInfinite()); 48 EXPECT_FALSE(DataSize::Zero().IsInfinite()); 49 EXPECT_FALSE(DataSize::Bytes(kValue).IsInfinite()); 50 51 EXPECT_FALSE(DataSize::Infinity().IsFinite()); 52 EXPECT_TRUE(DataSize::Bytes(kValue).IsFinite()); 53 EXPECT_TRUE(DataSize::Zero().IsFinite()); 54 } 55 56 TEST(DataSizeTest, ComparisonOperators) { 57 const int64_t kSmall = 450; 58 const int64_t kLarge = 451; 59 const DataSize small = DataSize::Bytes(kSmall); 60 const DataSize large = DataSize::Bytes(kLarge); 61 62 EXPECT_EQ(DataSize::Zero(), DataSize::Bytes(0)); 63 EXPECT_EQ(DataSize::Infinity(), DataSize::Infinity()); 64 EXPECT_EQ(small, small); 65 EXPECT_LE(small, small); 66 EXPECT_GE(small, small); 67 EXPECT_NE(small, large); 68 EXPECT_LE(small, large); 69 EXPECT_LT(small, large); 70 EXPECT_GE(large, small); 71 EXPECT_GT(large, small); 72 EXPECT_LT(DataSize::Zero(), small); 73 EXPECT_GT(DataSize::Infinity(), large); 74 } 75 76 TEST(DataSizeTest, ConvertsToAndFromDouble) { 77 const int64_t kValue = 128; 78 const double kDoubleValue = static_cast<double>(kValue); 79 80 EXPECT_EQ(DataSize::Bytes(kValue).bytes<double>(), kDoubleValue); 81 EXPECT_EQ(DataSize::Bytes(kDoubleValue).bytes(), kValue); 82 83 const double kInfinity = std::numeric_limits<double>::infinity(); 84 EXPECT_EQ(DataSize::Infinity().bytes<double>(), kInfinity); 85 EXPECT_TRUE(DataSize::Bytes(kInfinity).IsInfinite()); 86 } 87 88 TEST(DataSizeTest, MathOperations) { 89 const int64_t kValueA = 450; 90 const int64_t kValueB = 267; 91 const DataSize size_a = DataSize::Bytes(kValueA); 92 const DataSize size_b = DataSize::Bytes(kValueB); 93 EXPECT_EQ((size_a + size_b).bytes(), kValueA + kValueB); 94 EXPECT_EQ((size_a - size_b).bytes(), kValueA - kValueB); 95 96 const int32_t kInt32Value = 123; 97 const double kFloatValue = 123.0; 98 EXPECT_EQ((size_a * kValueB).bytes(), kValueA * kValueB); 99 EXPECT_EQ((size_a * kInt32Value).bytes(), kValueA * kInt32Value); 100 EXPECT_EQ((size_a * kFloatValue).bytes(), kValueA * kFloatValue); 101 102 EXPECT_EQ((size_a / 10).bytes(), kValueA / 10); 103 EXPECT_EQ(size_a / size_b, static_cast<double>(kValueA) / kValueB); 104 105 DataSize mutable_size = DataSize::Bytes(kValueA); 106 mutable_size += size_b; 107 EXPECT_EQ(mutable_size.bytes(), kValueA + kValueB); 108 mutable_size -= size_a; 109 EXPECT_EQ(mutable_size.bytes(), kValueB); 110 } 111 } // namespace test 112 } // namespace webrtc