| // Copyright 2020 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "src/developer/debug/debug_agent/aligned_chunk.h" | |
| #include <algorithm> | |
| #include <gtest/gtest.h> | |
| namespace debug_agent { | |
| namespace { | |
| std::vector<uint8_t> MakeSequence(size_t length, uint8_t first_value) { | |
| std::vector<uint8_t> result; | |
| for (size_t i = 0; i < length; i++) | |
| result.push_back(first_value + i); | |
| return result; | |
| } | |
| bool ReadFn(uint64_t addr, uint64_t* value) { | |
| // Expect all addresses to be word aligned. | |
| EXPECT_EQ(0u, addr % 8); | |
| const uint64_t* ptr = reinterpret_cast<const uint64_t*>(static_cast<intptr_t>(addr)); | |
| *value = *ptr; | |
| return true; | |
| } | |
| bool WriteFn(uint64_t addr, uint64_t value) { | |
| // Expect all addresses to be word aligned. | |
| EXPECT_EQ(0u, addr % 8); | |
| uint64_t* ptr = reinterpret_cast<uint64_t*>(static_cast<intptr_t>(addr)); | |
| *ptr = value; | |
| return true; | |
| } | |
| // Wraps "WriteAligned64Chunks". | |
| bool CallWriteAligned(const void* src, size_t src_size, void* dest) { | |
| return WriteAligned64Chunks(src, src_size, &ReadFn, &WriteFn, reinterpret_cast<intptr_t>(dest)); | |
| } | |
| } // namespace | |
| // Writing 0 bytes should not change anything. | |
| TEST(AlignedChunk, EmptyWrite) { | |
| auto original = MakeSequence(10, 1); | |
| auto buf = original; | |
| EXPECT_TRUE(CallWriteAligned("", 0, buf.data())); | |
| EXPECT_EQ(original, buf); | |
| } | |
| TEST(AlignedChunk, Aligned) { | |
| auto buf = MakeSequence(32, 1); | |
| auto new_data = MakeSequence(16, 100); | |
| constexpr size_t kDestOffset = 8; | |
| auto expected = buf; | |
| std::copy(new_data.begin(), new_data.end(), expected.begin() + kDestOffset); | |
| EXPECT_TRUE(CallWriteAligned(new_data.data(), new_data.size(), &buf[kDestOffset])); | |
| EXPECT_EQ(expected, buf); | |
| } | |
| TEST(AlignedChunk, Unaligned) { | |
| auto new_data = MakeSequence(8, 100); | |
| // Try all the different offsets in the starting word. | |
| for (size_t i = 0; i < 8; i++) { | |
| auto buf = MakeSequence(32, 1); | |
| auto expected = buf; | |
| std::copy(new_data.begin(), new_data.end(), expected.begin() + i); | |
| EXPECT_TRUE(CallWriteAligned(new_data.data(), new_data.size(), &buf[i])); | |
| EXPECT_EQ(expected, buf); | |
| } | |
| } | |
| // Tests writing one byte to each position in a word. | |
| TEST(AlignedChunk, OneByte) { | |
| const char new_data = 100; | |
| // Try all the different offsets in the starting word. | |
| for (size_t i = 0; i < 8; i++) { | |
| auto buf = MakeSequence(32, 1); | |
| auto expected = buf; | |
| expected[i] = new_data; | |
| EXPECT_TRUE(CallWriteAligned(&new_data, 1, &buf[i])); | |
| EXPECT_EQ(expected, buf); | |
| } | |
| } | |
| // Tests writing a sequence of three bytes to every offset within a word. | |
| TEST(AlignedChunk, ThreeBytes) { | |
| auto new_data = MakeSequence(3, 100); | |
| // Try all the different offsets in the starting word. | |
| for (size_t i = 0; i < 8; i++) { | |
| auto buf = MakeSequence(32, 1); | |
| auto expected = buf; | |
| std::copy(new_data.begin(), new_data.end(), expected.begin() + i); | |
| EXPECT_TRUE(CallWriteAligned(new_data.data(), new_data.size(), &buf[i])); | |
| EXPECT_EQ(expected, buf); | |
| } | |
| } | |
| // When the read/write fails the function call should report that. | |
| TEST(AlignedChunk, ReportsFailure) { | |
| const char new_data = 100; | |
| auto buf = MakeSequence(32, 1); | |
| // Read reports failure. | |
| EXPECT_FALSE(WriteAligned64Chunks( | |
| &new_data, 1, [](uint64_t addr, uint64_t*) { return false; }, &WriteFn, | |
| reinterpret_cast<intptr_t>(buf.data()))); | |
| // Write reports failure. | |
| EXPECT_FALSE(WriteAligned64Chunks( | |
| &new_data, 1, &ReadFn, [](uint64_t, uint64_t) { return false; }, | |
| reinterpret_cast<intptr_t>(buf.data()))); | |
| } | |
| } // namespace debug_agent |