Movatterモバイル変換

[0]ホーム
URL:

Google Git
Sign in
chromium /chromium /src /refs/heads/main /. /base /bits_unittest.cc
blob: 6464844af05981ee5941c29745f9a654ebb8966a [file] [log] [blame]
Avi Drissmane4622aa2022-09-08 20:36:06[diff] [blame]1// Copyright 2009 The Chromium Authors
apatrick@google.com6d1729e2009-11-18 23:08:39[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5// This file contains the unit tests for the bit utilities.
6
7#include"base/bits.h"
primiano32a7f502015-07-24 20:13:32[diff] [blame]8
avi9b6f42932015-12-26 22:15:14[diff] [blame]9#include<stddef.h>
10
primiano32a7f502015-07-24 20:13:32[diff] [blame]11#include<limits>
12
apatrick@google.com6d1729e2009-11-18 23:08:39[diff] [blame]13#include"testing/gtest/include/gtest/gtest.h"
14
Avi Drissman6f303a542023-11-17 15:09:58[diff] [blame]15namespace base::bits{
apatrick@google.com6d1729e2009-11-18 23:08:39[diff] [blame]16
17TEST(BitsTest,Log2Floor){
18 EXPECT_EQ(-1,Log2Floor(0));
19 EXPECT_EQ(0,Log2Floor(1));
20 EXPECT_EQ(1,Log2Floor(2));
21 EXPECT_EQ(1,Log2Floor(3));
22 EXPECT_EQ(2,Log2Floor(4));
23for(int i=3; i<31;++i){
24unsignedint value=1U<< i;
25 EXPECT_EQ(i,Log2Floor(value));
26 EXPECT_EQ(i,Log2Floor(value+1));
27 EXPECT_EQ(i,Log2Floor(value+2));
28 EXPECT_EQ(i-1,Log2Floor(value-1));
29 EXPECT_EQ(i-1,Log2Floor(value-2));
30}
31 EXPECT_EQ(31,Log2Floor(0xffffffffU));
32}
33
34TEST(BitsTest,Log2Ceiling){
35 EXPECT_EQ(-1,Log2Ceiling(0));
36 EXPECT_EQ(0,Log2Ceiling(1));
37 EXPECT_EQ(1,Log2Ceiling(2));
38 EXPECT_EQ(2,Log2Ceiling(3));
39 EXPECT_EQ(2,Log2Ceiling(4));
40for(int i=3; i<31;++i){
41unsignedint value=1U<< i;
42 EXPECT_EQ(i,Log2Ceiling(value));
43 EXPECT_EQ(i+1,Log2Ceiling(value+1));
44 EXPECT_EQ(i+1,Log2Ceiling(value+2));
45 EXPECT_EQ(i,Log2Ceiling(value-1));
46 EXPECT_EQ(i,Log2Ceiling(value-2));
47}
48 EXPECT_EQ(32,Log2Ceiling(0xffffffffU));
49}
50
Benoit Lizec90419f62021-02-02 18:04:25[diff] [blame]51TEST(BitsTest,AlignUp){
Lei Zhang0c010262018-12-11 18:56:09[diff] [blame]52staticconstexprsize_t kSizeTMax= std::numeric_limits<size_t>::max();
Avi Drissmandb766e52023-11-28 22:40:29[diff] [blame]53 EXPECT_EQ(0u,AlignUp(0u,4u));
54 EXPECT_EQ(4u,AlignUp(1u,4u));
55 EXPECT_EQ(4096u,AlignUp(1u,4096u));
56 EXPECT_EQ(4096u,AlignUp(4096u,4096u));
57 EXPECT_EQ(4096u,AlignUp(4095u,4096u));
58 EXPECT_EQ(8192u,AlignUp(4097u,4096u));
Peter Kasting6a4bf14c2022-07-13 14:53:33[diff] [blame]59 EXPECT_EQ(kSizeTMax-31,AlignUp(kSizeTMax-62,size_t{32}));
60 EXPECT_EQ(kSizeTMax/2+1,AlignUp(size_t{1}, kSizeTMax/2+1));
primiano32a7f502015-07-24 20:13:32[diff] [blame]61}
62
Benoit Lizec90419f62021-02-02 18:04:25[diff] [blame]63TEST(BitsTest,AlignUpPointer){
Mike Wittman668debf82020-07-28 03:10:30[diff] [blame]64staticconstexpruintptr_t kUintPtrTMax=
65 std::numeric_limits<uintptr_t>::max();
66 EXPECT_EQ(reinterpret_cast<uint8_t*>(0),
Benoit Lizec90419f62021-02-02 18:04:25[diff] [blame]67AlignUp(reinterpret_cast<uint8_t*>(0),4));
Mike Wittman668debf82020-07-28 03:10:30[diff] [blame]68 EXPECT_EQ(reinterpret_cast<uint8_t*>(4),
Benoit Lizec90419f62021-02-02 18:04:25[diff] [blame]69AlignUp(reinterpret_cast<uint8_t*>(1),4));
Mike Wittman668debf82020-07-28 03:10:30[diff] [blame]70 EXPECT_EQ(reinterpret_cast<uint8_t*>(4096),
Benoit Lizec90419f62021-02-02 18:04:25[diff] [blame]71AlignUp(reinterpret_cast<uint8_t*>(1),4096));
Mike Wittman668debf82020-07-28 03:10:30[diff] [blame]72 EXPECT_EQ(reinterpret_cast<uint8_t*>(4096),
Benoit Lizec90419f62021-02-02 18:04:25[diff] [blame]73AlignUp(reinterpret_cast<uint8_t*>(4096),4096));
Mike Wittman668debf82020-07-28 03:10:30[diff] [blame]74 EXPECT_EQ(reinterpret_cast<uint8_t*>(4096),
Benoit Lizec90419f62021-02-02 18:04:25[diff] [blame]75AlignUp(reinterpret_cast<uint8_t*>(4095),4096));
Mike Wittman668debf82020-07-28 03:10:30[diff] [blame]76 EXPECT_EQ(reinterpret_cast<uint8_t*>(8192),
Benoit Lizec90419f62021-02-02 18:04:25[diff] [blame]77AlignUp(reinterpret_cast<uint8_t*>(4097),4096));
Mike Wittman668debf82020-07-28 03:10:30[diff] [blame]78 EXPECT_EQ(reinterpret_cast<uint8_t*>(kUintPtrTMax-31),
Benoit Lizec90419f62021-02-02 18:04:25[diff] [blame]79AlignUp(reinterpret_cast<uint8_t*>(kUintPtrTMax-62),32));
Mike Wittman668debf82020-07-28 03:10:30[diff] [blame]80 EXPECT_EQ(reinterpret_cast<uint8_t*>(kUintPtrTMax/2+1),
Benoit Lizec90419f62021-02-02 18:04:25[diff] [blame]81AlignUp(reinterpret_cast<uint8_t*>(1), kUintPtrTMax/2+1));
Mike Wittman668debf82020-07-28 03:10:30[diff] [blame]82}
83
Lei Zhang0c010262018-12-11 18:56:09[diff] [blame]84TEST(BitsTest,AlignDown){
85staticconstexprsize_t kSizeTMax= std::numeric_limits<size_t>::max();
Avi Drissmandb766e52023-11-28 22:40:29[diff] [blame]86 EXPECT_EQ(0u,AlignDown(0u,4u));
87 EXPECT_EQ(0u,AlignDown(1u,4u));
88 EXPECT_EQ(0u,AlignDown(1u,4096u));
89 EXPECT_EQ(4096u,AlignDown(4096u,4096u));
90 EXPECT_EQ(0u,AlignDown(4095u,4096u));
91 EXPECT_EQ(4096u,AlignDown(4097u,4096u));
Peter Kasting6a4bf14c2022-07-13 14:53:33[diff] [blame]92 EXPECT_EQ(kSizeTMax-63,AlignDown(kSizeTMax-62,size_t{32}));
93 EXPECT_EQ(kSizeTMax-31,AlignDown(kSizeTMax,size_t{32}));
94 EXPECT_EQ(0ul,AlignDown(size_t{1}, kSizeTMax/2+1));
Lei Zhang0c010262018-12-11 18:56:09[diff] [blame]95}
96
Mike Wittman668debf82020-07-28 03:10:30[diff] [blame]97TEST(BitsTest,AlignDownPointer){
98staticconstexpruintptr_t kUintPtrTMax=
99 std::numeric_limits<uintptr_t>::max();
100 EXPECT_EQ(reinterpret_cast<uint8_t*>(0),
101AlignDown(reinterpret_cast<uint8_t*>(0),4));
102 EXPECT_EQ(reinterpret_cast<uint8_t*>(0),
103AlignDown(reinterpret_cast<uint8_t*>(1),4));
104 EXPECT_EQ(reinterpret_cast<uint8_t*>(0),
105AlignDown(reinterpret_cast<uint8_t*>(1),4096));
106 EXPECT_EQ(reinterpret_cast<uint8_t*>(4096),
107AlignDown(reinterpret_cast<uint8_t*>(4096),4096));
108 EXPECT_EQ(reinterpret_cast<uint8_t*>(0),
109AlignDown(reinterpret_cast<uint8_t*>(4095),4096));
110 EXPECT_EQ(reinterpret_cast<uint8_t*>(4096),
111AlignDown(reinterpret_cast<uint8_t*>(4097),4096));
112 EXPECT_EQ(reinterpret_cast<uint8_t*>(kUintPtrTMax-63),
113AlignDown(reinterpret_cast<uint8_t*>(kUintPtrTMax-62),32));
114 EXPECT_EQ(reinterpret_cast<uint8_t*>(kUintPtrTMax-31),
115AlignDown(reinterpret_cast<uint8_t*>(kUintPtrTMax),32));
116 EXPECT_EQ(reinterpret_cast<uint8_t*>(0),
117AlignDown(reinterpret_cast<uint8_t*>(1), kUintPtrTMax/2+1));
118}
119
OlivierLi02b94c52020-05-29 21:30:56[diff] [blame]120TEST(BitsTest,LeftMostBit){
121// Construction of a signed type from an unsigned one of the same width
Lei Zhangce16fc02023-06-27 17:11:29[diff] [blame]122// preserves all bits. Explicitly confirming this behavior here to illustrate
OlivierLi02b94c52020-05-29 21:30:56[diff] [blame]123// correctness of reusing unsigned literals to test behavior of signed types.
124// Using signed literals does not work with EXPECT_EQ.
125static_assert(int64_t(0xFFFFFFFFFFFFFFFFu)==0xFFFFFFFFFFFFFFFFl,
126"Comparing signed with unsigned literals compares bits.");
127static_assert((0xFFFFFFFFFFFFFFFFu^0xFFFFFFFFFFFFFFFFl)==0,
128"Signed and unsigned literals have the same bits set");
129
130uint64_t unsigned_long_long_value=0x8000000000000000u;
131 EXPECT_EQ(LeftmostBit<uint64_t>(), unsigned_long_long_value);
132 EXPECT_EQ(LeftmostBit<int64_t>(),int64_t(unsigned_long_long_value));
133
134uint32_t unsigned_long_value=0x80000000u;
135 EXPECT_EQ(LeftmostBit<uint32_t>(), unsigned_long_value);
136 EXPECT_EQ(LeftmostBit<int32_t>(),int32_t(unsigned_long_value));
137
138uint16_t unsigned_short_value=0x8000u;
139 EXPECT_EQ(LeftmostBit<uint16_t>(), unsigned_short_value);
140 EXPECT_EQ(LeftmostBit<int16_t>(),int16_t(unsigned_short_value));
141
142uint8_t unsigned_byte_value=0x80u;
143 EXPECT_EQ(LeftmostBit<uint8_t>(), unsigned_byte_value);
144 EXPECT_EQ(LeftmostBit<int8_t>(),int8_t(unsigned_byte_value));
145}
146
Avi Drissman6f303a542023-11-17 15:09:58[diff] [blame]147}// namespace base::bits
[8]ページ先頭
©2009-2025 Movatter.jp