1 /* 2 * Copyright (C) 2018 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "bit_memory_region.h" 18 19 #include "gtest/gtest.h" 20 21 namespace art { 22 23 static void CheckBits(uint8_t* data, 24 size_t size, 25 uint32_t init, 26 size_t offset, 27 size_t length, 28 uint32_t value) { 29 for (size_t i = 0; i < size * kBitsPerByte; i++) { 30 uint8_t expected = (offset <= i && i < offset + length) ? value >> (i - offset) : init; 31 uint8_t actual = data[i / kBitsPerByte] >> (i % kBitsPerByte); 32 EXPECT_EQ(expected & 1, actual & 1); 33 } 34 } 35 36 TEST(BitMemoryRegion, TestVarint) { 37 for (size_t start_bit_offset = 0; start_bit_offset <= 32; start_bit_offset++) { 38 uint32_t values[] = { 0, 1, 11, 12, 15, 16, 255, 256, 1u << 16, 1u << 24, ~1u, ~0u }; 39 for (uint32_t value : values) { 40 std::vector<uint8_t> buffer; 41 BitMemoryWriter<std::vector<uint8_t>> writer(&buffer, start_bit_offset); 42 writer.WriteVarint(value); 43 44 BitMemoryReader reader(buffer.data(), start_bit_offset); 45 uint32_t result = reader.ReadVarint(); 46 uint32_t upper_bound = RoundUp(MinimumBitsToStore(value), kBitsPerByte) + kVarintBits; 47 EXPECT_EQ(writer.NumberOfWrittenBits(), reader.NumberOfReadBits()); 48 EXPECT_EQ(value, result); 49 EXPECT_GE(upper_bound, writer.NumberOfWrittenBits()); 50 } 51 } 52 } 53 54 TEST(BitMemoryRegion, TestBit) { 55 uint8_t data[sizeof(uint32_t) * 2]; 56 for (size_t bit_offset = 0; bit_offset < 2 * sizeof(uint32_t) * kBitsPerByte; ++bit_offset) { 57 for (uint32_t initial_value = 0; initial_value <= 1; initial_value++) { 58 for (uint32_t value = 0; value <= 1; value++) { 59 // Check Store and Load with bit_offset set on the region. 60 std::fill_n(data, sizeof(data), initial_value * 0xFF); 61 BitMemoryRegion bmr1(MemoryRegion(&data, sizeof(data)), bit_offset, 1); 62 bmr1.StoreBit(0, value); 63 EXPECT_EQ(bmr1.LoadBit(0), value); 64 CheckBits(data, sizeof(data), initial_value, bit_offset, 1, value); 65 // Check Store and Load with bit_offset set on the methods. 66 std::fill_n(data, sizeof(data), initial_value * 0xFF); 67 BitMemoryRegion bmr2(MemoryRegion(&data, sizeof(data))); 68 bmr2.StoreBit(bit_offset, value); 69 EXPECT_EQ(bmr2.LoadBit(bit_offset), value); 70 CheckBits(data, sizeof(data), initial_value, bit_offset, 1, value); 71 } 72 } 73 } 74 } 75 76 TEST(BitMemoryRegion, TestBits) { 77 uint8_t data[sizeof(uint32_t) * 4]; 78 for (size_t bit_offset = 0; bit_offset < 3 * sizeof(uint32_t) * kBitsPerByte; ++bit_offset) { 79 uint32_t mask = 0; 80 for (size_t bit_length = 0; bit_length < sizeof(uint32_t) * kBitsPerByte; ++bit_length) { 81 const uint32_t value = 0xDEADBEEF & mask; 82 for (uint32_t initial_value = 0; initial_value <= 1; initial_value++) { 83 // Check Store and Load with bit_offset set on the region. 84 std::fill_n(data, sizeof(data), initial_value * 0xFF); 85 BitMemoryRegion bmr1(MemoryRegion(&data, sizeof(data)), bit_offset, bit_length); 86 bmr1.StoreBits(0, value, bit_length); 87 EXPECT_EQ(bmr1.LoadBits(0, bit_length), value); 88 CheckBits(data, sizeof(data), initial_value, bit_offset, bit_length, value); 89 // Check Store and Load with bit_offset set on the methods. 90 std::fill_n(data, sizeof(data), initial_value * 0xFF); 91 BitMemoryRegion bmr2(MemoryRegion(&data, sizeof(data))); 92 bmr2.StoreBits(bit_offset, value, bit_length); 93 EXPECT_EQ(bmr2.LoadBits(bit_offset, bit_length), value); 94 CheckBits(data, sizeof(data), initial_value, bit_offset, bit_length, value); 95 } 96 mask = (mask << 1) | 1; 97 } 98 } 99 } 100 101 } // namespace art 102