Index: syzygy/agent/asan/shadow_unittest.cc |
diff --git a/syzygy/agent/asan/shadow_unittest.cc b/syzygy/agent/asan/shadow_unittest.cc |
index a8f2851cf41df065372b7008f7ef9f542c48b9be..3fb482741eb5a82f719ef91df4b5a55163bc970f 100644 |
--- a/syzygy/agent/asan/shadow_unittest.cc |
+++ b/syzygy/agent/asan/shadow_unittest.cc |
@@ -317,7 +317,7 @@ TEST_F(ShadowTest, FindFirstPoisonedByte) { |
EXPECT_EQ(nullptr, |
test_shadow.FindFirstPoisonedByte(test_array + i, size - i)); |
- // Try valid ranges ending at every poisition inside the unpoisoned range. |
+ // Try valid ranges ending at every position inside the unpoisoned range. |
EXPECT_EQ(nullptr, |
test_shadow.FindFirstPoisonedByte(test_array, size - i)); |
} |
@@ -345,12 +345,12 @@ TEST_F(ShadowTest, MarkAsFreed) { |
uint8_t* d0 = data; |
BlockInfo i0 = {}; |
- BlockInitialize(l0, d0, false, &i0); |
+ BlockInitialize(l0, d0, &i0); |
test_shadow.PoisonAllocatedBlock(i0); |
uint8_t* d1 = i0.RawBody() + kShadowRatio; |
BlockInfo i1 = {}; |
- BlockInitialize(l1, d1, true, &i1); |
+ BlockInitialize(l1, d1, &i1); |
test_shadow.PoisonAllocatedBlock(i1); |
test_shadow.MarkAsFreed(i0.body, i0.body_size); |
@@ -387,7 +387,7 @@ TEST_F(ShadowTest, PoisonAllocatedBlock) { |
uint8_t* data = new uint8_t[layout.block_size]; |
BlockInfo info = {}; |
- BlockInitialize(layout, data, false, &info); |
+ BlockInitialize(layout, data, &info); |
test_shadow.PoisonAllocatedBlock(info); |
EXPECT_EQ(test_shadow.GetShadowMarkerForAddress(data + 0 * 8), |
@@ -430,62 +430,22 @@ TEST_F(ShadowTest, ScanLeftAndRight) { |
size_t offset = test_shadow.length() / 2; |
size_t l = 0; |
test_shadow.shadow_[offset + 0] = kHeapBlockStartMarker0; |
- test_shadow.shadow_[offset + 1] = kHeapNestedBlockStartMarker0; |
- test_shadow.shadow_[offset + 2] = kHeapAddressableMarker; |
- test_shadow.shadow_[offset + 3] = kHeapNestedBlockEndMarker; |
- test_shadow.shadow_[offset + 4] = kHeapBlockEndMarker; |
+ test_shadow.shadow_[offset + 1] = kHeapAddressableMarker; |
+ test_shadow.shadow_[offset + 2] = kHeapBlockEndMarker; |
- EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(0, offset + 0, &l)); |
- EXPECT_EQ(offset, l); |
- EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(0, offset + 1, &l)); |
- EXPECT_EQ(offset + 1, l); |
- EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(0, offset + 2, &l)); |
- EXPECT_EQ(offset + 1, l); |
- EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(0, offset + 3, &l)); |
- EXPECT_EQ(offset + 1, l); |
- EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(0, offset + 4, &l)); |
+ EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(offset + 0, &l)); |
EXPECT_EQ(offset, l); |
- |
- EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 0, &l)); |
- EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 1, &l)); |
+ EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(offset + 1, &l)); |
EXPECT_EQ(offset, l); |
- EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 2, &l)); |
+ EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(offset + 2, &l)); |
EXPECT_EQ(offset, l); |
- EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 3, &l)); |
- EXPECT_EQ(offset, l); |
- EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 4, &l)); |
- |
- EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(2, offset + 0, &l)); |
- EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(2, offset + 1, &l)); |
- EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(2, offset + 2, &l)); |
- EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(2, offset + 3, &l)); |
- EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(2, offset + 4, &l)); |
- |
- EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(0, offset + 0, &l)); |
- EXPECT_EQ(offset + 4, l); |
- EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(0, offset + 1, &l)); |
- EXPECT_EQ(offset + 3, l); |
- EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(0, offset + 2, &l)); |
- EXPECT_EQ(offset + 3, l); |
- EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(0, offset + 3, &l)); |
- EXPECT_EQ(offset + 3, l); |
- EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(0, offset + 4, &l)); |
- EXPECT_EQ(offset + 4, l); |
- |
- EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(1, offset + 0, &l)); |
- EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(1, offset + 1, &l)); |
- EXPECT_EQ(offset + 4, l); |
- EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(1, offset + 2, &l)); |
- EXPECT_EQ(offset + 4, l); |
- EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(1, offset + 3, &l)); |
- EXPECT_EQ(offset + 4, l); |
- EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(1, offset + 4, &l)); |
- |
- EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(2, offset + 0, &l)); |
- EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(2, offset + 1, &l)); |
- EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(2, offset + 2, &l)); |
- EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(2, offset + 3, &l)); |
- EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(2, offset + 4, &l)); |
+ |
+ EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(offset + 0, &l)); |
+ EXPECT_EQ(offset + 2, l); |
+ EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(offset + 1, &l)); |
+ EXPECT_EQ(offset + 2, l); |
+ EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(offset + 2, &l)); |
+ EXPECT_EQ(offset + 2, l); |
::memset(test_shadow.shadow_ + offset, 0, 5); |
} |
@@ -497,23 +457,14 @@ TEST_F(ShadowTest, ScanRightPerfTest) { |
::memset(test_shadow.shadow_ + offset, 0, length); |
test_shadow.shadow_[offset + 0] = kHeapBlockStartMarker0; |
- // A nested block with freed contents. |
- test_shadow.shadow_[offset + 50] = kHeapNestedBlockStartMarker0; |
- ::memset(test_shadow.shadow_ + offset + 51, kHeapFreedMarker, 8); |
- test_shadow.shadow_[offset + 60] = kHeapNestedBlockEndMarker; |
- // A nested block with a nested block. |
- test_shadow.shadow_[offset + 100000] = kHeapNestedBlockStartMarker0; |
- test_shadow.shadow_[offset + 100100] = kHeapNestedBlockStartMarker0; |
- test_shadow.shadow_[offset + 100400] = kHeapNestedBlockEndMarker; |
- test_shadow.shadow_[offset + 200000] = kHeapNestedBlockEndMarker; |
- // The end of the outer block. |
+ // The end of the block. |
test_shadow.shadow_[offset + length - 1] = kHeapBlockEndMarker; |
uint64_t tnet = 0; |
for (size_t i = 0; i < 100; ++i) { |
size_t l = 0; |
uint64_t t0 = ::__rdtsc(); |
- test_shadow.ScanRightForBracketingBlockEnd(0, offset + 1, &l); |
+ test_shadow.ScanRightForBracketingBlockEnd(offset + 1, &l); |
uint64_t t1 = ::__rdtsc(); |
tnet += t1 - t0; |
} |
@@ -533,7 +484,7 @@ TEST_F(ShadowTest, IsLeftOrRightRedzone) { |
std::unique_ptr<uint8_t[]> data(new uint8_t[layout.block_size]); |
BlockInfo info = {}; |
- BlockInitialize(layout, data.get(), false, &info); |
+ BlockInitialize(layout, data.get(), &info); |
test_shadow.PoisonAllocatedBlock(info); |
uint8_t* block = reinterpret_cast<uint8_t*>(info.header); |
@@ -557,58 +508,20 @@ TEST_F(ShadowTest, IsLeftOrRightRedzone) { |
namespace { |
-void TestBlockInfoFromShadow(Shadow* shadow, |
- const BlockLayout& outer, |
- const BlockLayout& nested) { |
+void TestBlockInfoFromShadow(Shadow* shadow, const BlockLayout& block_layout) { |
ASSERT_TRUE(shadow != nullptr); |
- ASSERT_LE(nested.block_size, outer.body_size); |
- uint8_t* data = new uint8_t[outer.block_size]; |
+ uint8_t* data = new uint8_t[block_layout.block_size]; |
- // Try recovering the block from every position within it when no nested |
- // block exists. Expect finding a nested block to fail. |
BlockInfo info = {}; |
- BlockInitialize(outer, data, false, &info); |
+ BlockInitialize(block_layout, data, &info); |
shadow->PoisonAllocatedBlock(info); |
BlockInfo info_recovered = {}; |
for (size_t i = 0; i < info.block_size; ++i) { |
EXPECT_TRUE(shadow->BlockInfoFromShadow( |
info.RawBlock() + i, &info_recovered)); |
EXPECT_EQ(0, ::memcmp(&info, &info_recovered, sizeof(info))); |
- |
- // This block should have no parent block as its not nested. |
- EXPECT_FALSE(shadow->ParentBlockInfoFromShadow( |
- info, &info_recovered)); |
- } |
- |
- // Place a nested block and try the recovery from every position again. |
- size_t padding = ::common::AlignDown(info.body_size - nested.block_size, |
- kShadowRatio * 2); |
- uint8_t* nested_begin = info.RawBody() + padding / 2; |
- uint8_t* nested_end = nested_begin + nested.block_size; |
- BlockInfo nested_info = {}; |
- BlockInitialize(nested, nested_begin, true, &nested_info); |
- nested_info.header->is_nested = true; |
- shadow->PoisonAllocatedBlock(nested_info); |
- for (size_t i = 0; i < info.block_size; ++i) { |
- uint8_t* pos = info.RawBlock() + i; |
- EXPECT_TRUE(shadow->BlockInfoFromShadow(pos, &info_recovered)); |
- |
- BlockInfo parent_info = {}; |
- bool found_parent = shadow->ParentBlockInfoFromShadow( |
- info_recovered, &parent_info); |
- |
- if (pos >= nested_begin && pos < nested_end) { |
- EXPECT_EQ(0, ::memcmp(&nested_info, &info_recovered, |
- sizeof(nested_info))); |
- EXPECT_TRUE(found_parent); |
- EXPECT_EQ(0, ::memcmp(&info, &parent_info, sizeof(info))); |
- } else { |
- EXPECT_EQ(0, ::memcmp(&info, &info_recovered, sizeof(info))); |
- EXPECT_FALSE(found_parent); |
- } |
} |
- shadow->Unpoison(info.header, info.block_size); |
delete [] data; |
} |
@@ -616,30 +529,21 @@ void TestBlockInfoFromShadow(Shadow* shadow, |
} // namespace |
TEST_F(ShadowTest, BlockInfoFromShadow) { |
- // This is a simple layout that will be nested inside of another block. |
BlockLayout layout0 = {}; |
EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 6, 0, 0, &layout0)); |
- // Plan two layouts, one with padding and another with none. The first has |
- // exactly enough space for the nested block, while the second has room to |
- // spare. |
- BlockLayout layout1 = {}; |
- BlockLayout layout2 = {}; |
- EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, |
- static_cast<uint32_t>( |
- ::common::AlignUp(layout0.block_size, kShadowRatio) + 4), 0, 0, |
- &layout1)); |
- ASSERT_EQ(0u, layout1.header_padding_size); |
- ASSERT_EQ(0u, layout1.trailer_padding_size); |
- EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, |
- layout0.block_size + 2 * kShadowRatio, 32, 13, &layout2)); |
- ASSERT_LT(0u, layout2.header_padding_size); |
- ASSERT_LT(0u, layout2.trailer_padding_size); |
- |
- EXPECT_NO_FATAL_FAILURE(TestBlockInfoFromShadow( |
- &test_shadow, layout1, layout0)); |
- EXPECT_NO_FATAL_FAILURE(TestBlockInfoFromShadow( |
- &test_shadow, layout2, layout0)); |
+ uint8_t* data = new uint8_t[layout0.block_size]; |
+ |
+ BlockInfo info = {}; |
+ BlockInitialize(layout0, data, &info); |
+ test_shadow.PoisonAllocatedBlock(info); |
+ BlockInfo info_recovered = {}; |
+ for (size_t i = 0; i < info.block_size; ++i) { |
+ EXPECT_TRUE( |
+ test_shadow.BlockInfoFromShadow(info.RawBlock() + i, &info_recovered)); |
+ EXPECT_EQ(0, ::memcmp(&info, &info_recovered, sizeof(info))); |
+ } |
+ delete[] data; |
} |
TEST_F(ShadowTest, IsBeginningOfBlockBody) { |
@@ -650,7 +554,7 @@ TEST_F(ShadowTest, IsBeginningOfBlockBody) { |
std::unique_ptr<uint8_t[]> data(new uint8_t[data_size]); |
BlockInfo block_info = {}; |
- BlockInitialize(l, data.get(), false, &block_info); |
+ BlockInitialize(l, data.get(), &block_info); |
test_shadow.PoisonAllocatedBlock(block_info); |
@@ -674,7 +578,7 @@ TEST_F(ShadowTest, IsBeginningOfBlockBodyForBlockOfSizeZero) { |
std::unique_ptr<uint8_t[]> data(new uint8_t[data_size]); |
BlockInfo block_info = {}; |
- BlockInitialize(l, data.get(), false, &block_info); |
+ BlockInitialize(l, data.get(), &block_info); |
test_shadow.PoisonAllocatedBlock(block_info); |
@@ -758,22 +662,20 @@ class ShadowWalkerTest : public testing::Test { |
} // namespace |
TEST_F(ShadowWalkerTest, WalkEmptyRange) { |
- ShadowWalker w(&test_shadow, true, &test_shadow, &test_shadow); |
+ ShadowWalker w(&test_shadow, &test_shadow, &test_shadow); |
BlockInfo i = {}; |
EXPECT_FALSE(w.Next(&i)); |
} |
TEST_F(ShadowWalkerTest, WalkRangeAtEndOfAddressSpace) { |
TestShadow ts1(4, 30); // 4GB. |
- ShadowWalker w( |
- &ts1, true, |
- reinterpret_cast<const void*>(ts1.memory_size() - 100), |
- reinterpret_cast<const void*>(ts1.memory_size())); |
+ ShadowWalker w(&ts1, reinterpret_cast<const void*>(ts1.memory_size() - 100), |
+ reinterpret_cast<const void*>(ts1.memory_size())); |
BlockInfo i = {}; |
EXPECT_FALSE(w.Next(&i)); |
} |
-TEST_F(ShadowWalkerTest, WalksNonNestedBlocks) { |
+TEST_F(ShadowWalkerTest, WalksBlocks) { |
BlockLayout l = {}; |
EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 7, 0, 0, &l)); |
@@ -784,9 +686,9 @@ TEST_F(ShadowWalkerTest, WalksNonNestedBlocks) { |
uint8_t* data2 = data1 + l.block_size; |
BlockInfo i0 = {}, i1 = {}, i2 = {}; |
- BlockInitialize(l, data0, false, &i0); |
- BlockInitialize(l, data1, false, &i1); |
- BlockInitialize(l, data2, false, &i2); |
+ BlockInitialize(l, data0, &i0); |
+ BlockInitialize(l, data1, &i1); |
+ BlockInitialize(l, data2, &i2); |
test_shadow.PoisonAllocatedBlock(i0); |
test_shadow.PoisonAllocatedBlock(i1); |
@@ -797,128 +699,11 @@ TEST_F(ShadowWalkerTest, WalksNonNestedBlocks) { |
// Do a non-recursive walk through the shadow. |
BlockInfo i = {}; |
- ShadowWalker w0(&test_shadow, false, data, data + data_size); |
- EXPECT_EQ(-1, w0.nesting_depth()); |
- EXPECT_TRUE(w0.Next(&i)); |
- EXPECT_EQ(0, w0.nesting_depth()); |
- EXPECT_TRUE(w0.Next(&i)); |
- EXPECT_EQ(0, w0.nesting_depth()); |
- EXPECT_TRUE(w0.Next(&i)); |
- EXPECT_EQ(0, w0.nesting_depth()); |
- EXPECT_FALSE(w0.Next(&i)); |
- EXPECT_EQ(-1, w0.nesting_depth()); |
- |
- // Walk recursively through the shadow and expect the same results. |
- ShadowWalker w1(&test_shadow, true, data, data + data_size); |
- EXPECT_EQ(-1, w1.nesting_depth()); |
- EXPECT_TRUE(w1.Next(&i)); |
- EXPECT_EQ(0, w1.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i0, sizeof(i))); |
- EXPECT_TRUE(w1.Next(&i)); |
- EXPECT_EQ(0, w1.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i1, sizeof(i))); |
- EXPECT_TRUE(w1.Next(&i)); |
- EXPECT_EQ(0, w1.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i2, sizeof(i))); |
- EXPECT_FALSE(w1.Next(&i)); |
- EXPECT_EQ(-1, w1.nesting_depth()); |
- |
- test_shadow.Unpoison(data, data_size); |
- delete [] data; |
-} |
- |
-TEST_F(ShadowWalkerTest, WalksNestedBlocks) { |
- BlockLayout b0 = {}, b1 = {}, b2 = {}, b00 = {}, b01 = {}, b10 = {}, |
- b100 = {}; |
- EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 15, 30, 30, &b00)); |
- EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 7, 0, 0, &b01)); |
- EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, |
- b00.block_size + b01.block_size + kShadowRatio, 0, 0, &b0)); |
- EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 7, 0, 0, &b100)); |
- EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, b100.block_size, 0, 0, |
- &b10)); |
- EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, b10.block_size, 0, 0, |
- &b1)); |
- EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 100, 0, 0, &b2)); |
- |
- size_t data_size = b0.block_size + b1.block_size + kShadowRatio + |
- b2.block_size; |
- uint8_t* data = new uint8_t[data_size]; |
- |
- // Initialize the depth 0 blocks. |
- uint8_t* d0 = data; |
- uint8_t* d1 = d0 + b0.block_size; |
- uint8_t* d2 = d1 + b1.block_size + kShadowRatio; |
- BlockInfo i0 = {}, i1 = {}, i2 = {}; |
- BlockInitialize(b0, d0, false, &i0); |
- BlockInitialize(b1, d1, false, &i1); |
- BlockInitialize(b2, d2, false, &i2); |
- test_shadow.PoisonAllocatedBlock(i0); |
- test_shadow.PoisonAllocatedBlock(i1); |
- test_shadow.PoisonAllocatedBlock(i2); |
- |
- // Initialize depth 1 blocks. |
- uint8_t* d00 = i0.RawBody(); |
- uint8_t* d01 = d00 + b00.block_size + kShadowRatio; |
- uint8_t* d10 = i1.RawBody(); |
- BlockInfo i00 = {}, i01 = {}, i10 = {}; |
- BlockInitialize(b00, d00, true, &i00); |
- BlockInitialize(b01, d01, true, &i01); |
- BlockInitialize(b10, d10, true, &i10); |
- test_shadow.PoisonAllocatedBlock(i00); |
- test_shadow.PoisonAllocatedBlock(i01); |
- test_shadow.PoisonAllocatedBlock(i10); |
- |
- // Initialize depth 2 blocks. |
- uint8_t* d100 = i10.RawBody(); |
- BlockInfo i100 = {}; |
- BlockInitialize(b100, d100, true, &i100); |
- test_shadow.PoisonAllocatedBlock(i100); |
- i100.header->state = QUARANTINED_FLOODED_BLOCK; |
- test_shadow.MarkAsFreed(i100.body, i100.body_size); |
- |
- // Do a non-recursive walk through the shadow. |
- BlockInfo i = {}; |
- ShadowWalker w0(&test_shadow, false, data, data + data_size); |
- EXPECT_EQ(-1, w0.nesting_depth()); |
+ ShadowWalker w0(&test_shadow, data, data + data_size); |
EXPECT_TRUE(w0.Next(&i)); |
- EXPECT_EQ(0, w0.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i0, sizeof(i))); |
EXPECT_TRUE(w0.Next(&i)); |
- EXPECT_EQ(0, w0.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i1, sizeof(i))); |
EXPECT_TRUE(w0.Next(&i)); |
- EXPECT_EQ(0, w0.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i2, sizeof(i))); |
EXPECT_FALSE(w0.Next(&i)); |
- EXPECT_EQ(-1, w0.nesting_depth()); |
- |
- // Walk recursively through the shadow. |
- ShadowWalker w1(&test_shadow, true, data, data + data_size); |
- EXPECT_EQ(-1, w1.nesting_depth()); |
- EXPECT_TRUE(w1.Next(&i)); |
- EXPECT_EQ(0, w1.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i0, sizeof(i))); |
- EXPECT_TRUE(w1.Next(&i)); |
- EXPECT_EQ(1, w1.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i00, sizeof(i))); |
- EXPECT_TRUE(w1.Next(&i)); |
- EXPECT_EQ(1, w1.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i01, sizeof(i))); |
- EXPECT_TRUE(w1.Next(&i)); |
- EXPECT_EQ(0, w1.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i1, sizeof(i))); |
- EXPECT_TRUE(w1.Next(&i)); |
- EXPECT_EQ(1, w1.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i10, sizeof(i))); |
- EXPECT_TRUE(w1.Next(&i)); |
- EXPECT_EQ(2, w1.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i100, sizeof(i))); |
- EXPECT_TRUE(w1.Next(&i)); |
- EXPECT_EQ(0, w1.nesting_depth()); |
- EXPECT_EQ(0, ::memcmp(&i, &i2, sizeof(i))); |
- EXPECT_FALSE(w1.Next(&i)); |
- EXPECT_EQ(-1, w1.nesting_depth()); |
test_shadow.Unpoison(data, data_size); |
delete [] data; |
@@ -967,7 +752,7 @@ TEST_F(ShadowWalkerTest, WalkShadowWithUncommittedRanges) { |
uint8_t* page_address = ::common::AlignUp( |
memory_block + i * GetPageSize() * kShadowRatio, kShadowRatio); |
BlockInfo block_info = {}; |
- BlockInitialize(l, page_address, false, &block_info); |
+ BlockInitialize(l, page_address, &block_info); |
block_info_vec.push_back(block_info); |
// Poison the block. |
@@ -975,7 +760,7 @@ TEST_F(ShadowWalkerTest, WalkShadowWithUncommittedRanges) { |
} |
size_t block_count = 0; |
- ShadowWalker w(&ts1, true, memory_block, memory_block + kMemorySize); |
+ ShadowWalker w(&ts1, memory_block, memory_block + kMemorySize); |
BlockInfo i = {}; |
while (w.Next(&i)) { |
EXPECT_LT(block_count, block_info_vec.size()); |