Google Git
Sign in
chromium / chromium / src / lkgr / . / base / byte_count_unittest.cc
blob: ded1357e80aafe0db68b89d12f3242bd17a80277 [file] [log] [blame]
François Doray714df63e2025-07-04 19:07:20[diff] [blame]1// Copyright 2025 The Chromium Authors
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "base/byte_count.h"
6
7#include "base/test/gtest_util.h"
8#include "testing/gmock/include/gmock/gmock.h"
9#include "testing/gtest/include/gtest/gtest.h"
10
11namespace base {
12
13TEST(ByteCount, ConstructionDefault) {
14 constexpr ByteCount bytes;
15 EXPECT_EQ(0, bytes.InBytes());
16 EXPECT_EQ(0, bytes.InKiB());
17 EXPECT_EQ(0, bytes.InMiB());
18 EXPECT_EQ(0, bytes.InGiB());
19 EXPECT_EQ(0, bytes.InBytesUnsigned());
20}
21
22TEST(ByteCount, ConstructionByteCount) {
23 constexpr ByteCount bytes(1024 * 1024 * 1024);
24 EXPECT_EQ(1024 * 1024 * 1024, bytes.InBytes());
25 EXPECT_EQ(1024 * 1024, bytes.InKiB());
26 EXPECT_EQ(1024, bytes.InMiB());
27 EXPECT_EQ(1, bytes.InGiB());
28 EXPECT_EQ(1024u * 1024 * 1024, bytes.InBytesUnsigned());
29}
30
31TEST(ByteCount, ConstructionUnsigned) {
32 auto bytes = ByteCount::FromUnsigned(5u);
33 EXPECT_EQ(5, bytes.InBytes());
34}
35
36TEST(ByteCount, ConstructionUnsignedInvalid) {
37 BASE_EXPECT_DEATH(
38 { ByteCount::FromUnsigned(std::numeric_limits<uint64_t>::max()); }, "");
39}
40
41TEST(ByteCount, ConstructionOtherUnit) {
42 auto kib5 = KiB(5);
43 EXPECT_EQ(5 * 1024, kib5.InBytes());
44
45 auto mib5 = MiB(5);
46 EXPECT_EQ(5 * 1024 * 1024, mib5.InBytes());
47
48 auto gib5 = GiB(5);
49 EXPECT_EQ(5ll * 1024 * 1024 * 1024, gib5.InBytes());
50}
51
52TEST(ByteCount, ConstructionOtherUnitInvalid) {
53 BASE_EXPECT_DEATH({ KiB(std::numeric_limits<int64_t>::max()); }, "");
54
55 BASE_EXPECT_DEATH({ MiB(std::numeric_limits<int64_t>::max()); }, "");
56
57 BASE_EXPECT_DEATH({ GiB(std::numeric_limits<int64_t>::max()); }, "");
58}
59
60TEST(ByteCount, IsZero) {
61 EXPECT_TRUE(ByteCount(0).is_zero());
62 EXPECT_FALSE(ByteCount(-2).is_zero());
63 EXPECT_FALSE(ByteCount(2).is_zero());
64}
65
66TEST(ByteCount, InFloating) {
67 constexpr ByteCount bytes(3435973836);
68 EXPECT_THAT(bytes.InKiBF(), testing::DoubleEq(3355443.19921875));
69 EXPECT_THAT(bytes.InMiBF(), testing::DoubleEq(3276.7999992370605));
70 EXPECT_THAT(bytes.InGiBF(), testing::DoubleEq(3.1999999992549419));
71}
72
73TEST(ByteCount, InUnsignedInvalid) {
74 ByteCount bytes(-2);
75 BASE_EXPECT_DEATH({ bytes.InBytesUnsigned(); }, "");
76}
77
78TEST(ByteCount, Arithmetic) {
79 ByteCount bytes(42);
80
81 ByteCount add = bytes + ByteCount(10);
82 EXPECT_EQ(52, add.InBytes());
83
84 ByteCount sub = bytes - ByteCount(10);
85 EXPECT_EQ(32, sub.InBytes());
86
87 ByteCount mul = bytes * 10;
88 EXPECT_EQ(420, mul.InBytes());
89
90 ByteCount div = bytes / 2;
91 EXPECT_EQ(21, div.InBytes());
92}
93
94TEST(ByteCount, ArithmeticInvalid) {
95 ByteCount max_bytes(std::numeric_limits<int64_t>::max());
96
97 BASE_EXPECT_DEATH({ max_bytes + max_bytes; }, "");
98
99 BASE_EXPECT_DEATH({ ByteCount() - max_bytes - max_bytes; }, "");
100
101 BASE_EXPECT_DEATH({ max_bytes * 2; }, "");
102
103 BASE_EXPECT_DEATH({ max_bytes / 0; }, "");
104}
105
106TEST(ByteCount, Comparison) {
107 ByteCount a(1);
108 ByteCount b(2);
109 ByteCount c(2);
110
111 EXPECT_TRUE(a < b);
112 EXPECT_FALSE(b < a);
113 EXPECT_FALSE(b < c);
114
115 EXPECT_TRUE(a <= b);
116 EXPECT_FALSE(b <= a);
117 EXPECT_TRUE(b <= c);
118
119 EXPECT_FALSE(a > b);
120 EXPECT_TRUE(b > a);
121 EXPECT_FALSE(b > c);
122
123 EXPECT_FALSE(a >= b);
124 EXPECT_TRUE(b >= a);
125 EXPECT_TRUE(b >= c);
126
127 EXPECT_FALSE(a == b);
128 EXPECT_TRUE(b == c);
129
130 EXPECT_TRUE(a != b);
131 EXPECT_FALSE(b != c);
132}
133
134} // namespace base