3party/crashpad
0
0
Fork 0
mirror of https://github.com/chromium/crashpad.git synced 2025-03-09 14:06:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Pull test utilities from MinidumpMemoryWriter’s test out into their own file.

Browse Source 
These utilities are also useful to MinidumpThreadWriter’s test.

TEST=minidump_test MinidumpMemoryWriter.*
R=rsesek@chromium.org

Review URL: https://codereview.chromium.org/639513002
This commit is contained in:
Mark Mentovai 2014-10-07 17:58:43 -04:00
parent b677bc4ec0
commit 9c76cc60db
4 changed files with 221 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
minidump/minidump.gyp
View File

@ -72,6 +72,8 @@
'minidump_context_writer_test.cc',
'minidump_file_writer_test.cc',
'minidump_memory_writer_test.cc',
'minidump_memory_writer_test_util.cc',
'minidump_memory_writer_test_util.h',
'minidump_misc_info_writer_test.cc',
'minidump_module_writer_test.cc',
'minidump_string_writer_test.cc',

145
minidump/minidump_memory_writer_test.cc
View File

@ -21,6 +21,7 @@
#include "gtest/gtest.h"
#include "minidump/minidump_extensions.h"
#include "minidump/minidump_file_writer.h"
#include "minidump/minidump_memory_writer_test_util.h"
#include "minidump/minidump_stream_writer.h"
#include "minidump/minidump_test_util.h"
#include "util/file/string_file_writer.h"
@ -100,88 +101,6 @@ TEST(MinidumpMemoryWriter, EmptyMemoryList) {
EXPECT_EQ(0u, memory_list->NumberOfMemoryRanges);
}
class TestMemoryWriter final : public MinidumpMemoryWriter {
public:
TestMemoryWriter(uint64_t base_address, size_t size, uint8_t value)
: MinidumpMemoryWriter(),
base_address_(base_address),
expected_offset_(-1),
size_(size),
value_(value) {}
~TestMemoryWriter() {}
protected:
// MinidumpMemoryWriter:
virtual uint64_t MemoryRangeBaseAddress() const override {
EXPECT_EQ(state(), kStateFrozen);
return base_address_;
}
virtual size_t MemoryRangeSize() const override {
EXPECT_GE(state(), kStateFrozen);
return size_;
}
// MinidumpWritable:
virtual bool WillWriteAtOffsetImpl(off_t offset) override {
EXPECT_EQ(state(), kStateFrozen);
expected_offset_ = offset;
bool rv = MinidumpMemoryWriter::WillWriteAtOffsetImpl(offset);
EXPECT_TRUE(rv);
return rv;
}
virtual bool WriteObject(FileWriterInterface* file_writer) override {
EXPECT_EQ(state(), kStateWritable);
EXPECT_EQ(expected_offset_, file_writer->Seek(0, SEEK_CUR));
bool rv = true;
if (size_ > 0) {
std::string data(size_, value_);
rv = file_writer->Write(&data[0], size_);
EXPECT_TRUE(rv);
}
return rv;
}
private:
uint64_t base_address_;
off_t expected_offset_;
size_t size_;
uint8_t value_;
DISALLOW_COPY_AND_ASSIGN(TestMemoryWriter);
};
void ExpectMemoryDescriptorAndContents(
const MINIDUMP_MEMORY_DESCRIPTOR* expected,
const MINIDUMP_MEMORY_DESCRIPTOR* observed,
const std::string& file_contents,
uint8_t value,
bool at_eof) {
const uint32_t kMemoryAlignment = 16;
EXPECT_EQ(expected->StartOfMemoryRange, observed->StartOfMemoryRange);
EXPECT_EQ(expected->Memory.DataSize, observed->Memory.DataSize);
EXPECT_EQ(
(expected->Memory.Rva + kMemoryAlignment - 1) & ~(kMemoryAlignment - 1),
observed->Memory.Rva);
if (at_eof) {
EXPECT_EQ(file_contents.size(),
observed->Memory.Rva + observed->Memory.DataSize);
} else {
EXPECT_GE(file_contents.size(),
observed->Memory.Rva + observed->Memory.DataSize);
}
std::string expected_data(expected->Memory.DataSize, value);
std::string observed_data(&file_contents[observed->Memory.Rva],
observed->Memory.DataSize);
EXPECT_EQ(expected_data, observed_data);
}
TEST(MinidumpMemoryWriter, OneMemoryRegion) {
MinidumpFileWriter minidump_file_writer;
MinidumpMemoryListWriter memory_list_writer;
@ -190,7 +109,7 @@ TEST(MinidumpMemoryWriter, OneMemoryRegion) {
const uint64_t kSize = 0x1000;
const uint8_t kValue = 'm';
TestMemoryWriter memory_writer(kBaseAddress, kSize, kValue);
TestMinidumpMemoryWriter memory_writer(kBaseAddress, kSize, kValue);
memory_list_writer.AddMemory(&memory_writer);
minidump_file_writer.AddStream(&memory_list_writer);
@ -211,11 +130,11 @@ TEST(MinidumpMemoryWriter, OneMemoryRegion) {
sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
sizeof(MINIDUMP_MEMORY_LIST) +
memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
ExpectMemoryDescriptorAndContents(&expected,
&memory_list->MemoryRanges[0],
file_writer.string(),
kValue,
true);
ExpectMinidumpMemoryDescriptorAndContents(&expected,
&memory_list->MemoryRanges[0],
file_writer.string(),
kValue,
true);
}
TEST(MinidumpMemoryWriter, TwoMemoryRegions) {
@ -229,9 +148,9 @@ TEST(MinidumpMemoryWriter, TwoMemoryRegions) {
const uint64_t kSize2 = 0x0200;
const uint8_t kValue2 = '!';
TestMemoryWriter memory_writer_1(kBaseAddress1, kSize1, kValue1);
TestMinidumpMemoryWriter memory_writer_1(kBaseAddress1, kSize1, kValue1);
memory_list_writer.AddMemory(&memory_writer_1);
TestMemoryWriter memory_writer_2(kBaseAddress2, kSize2, kValue2);
TestMinidumpMemoryWriter memory_writer_2(kBaseAddress2, kSize2, kValue2);
memory_list_writer.AddMemory(&memory_writer_2);
minidump_file_writer.AddStream(&memory_list_writer);
@ -258,11 +177,11 @@ TEST(MinidumpMemoryWriter, TwoMemoryRegions) {
sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
sizeof(MINIDUMP_MEMORY_LIST) +
memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
ExpectMemoryDescriptorAndContents(&expected,
&memory_list->MemoryRanges[0],
file_writer.string(),
kValue1,
false);
ExpectMinidumpMemoryDescriptorAndContents(&expected,
&memory_list->MemoryRanges[0],
file_writer.string(),
kValue1,
false);
}
{
@ -272,11 +191,11 @@ TEST(MinidumpMemoryWriter, TwoMemoryRegions) {
expected.Memory.DataSize = kSize2;
expected.Memory.Rva = memory_list->MemoryRanges[0].Memory.Rva +
memory_list->MemoryRanges[0].Memory.DataSize;
ExpectMemoryDescriptorAndContents(&expected,
&memory_list->MemoryRanges[1],
file_writer.string(),
kValue2,
true);
ExpectMinidumpMemoryDescriptorAndContents(&expected,
&memory_list->MemoryRanges[1],
file_writer.string(),
kValue2,
true);
}
}
@ -287,7 +206,7 @@ class TestMemoryStream final : public internal::MinidumpStreamWriter {
~TestMemoryStream() {}
TestMemoryWriter* memory() { return &memory_; }
TestMinidumpMemoryWriter* memory() { return &memory_; }
// MinidumpStreamWriter:
virtual MinidumpStreamType StreamType() const override {
@ -313,7 +232,7 @@ class TestMemoryStream final : public internal::MinidumpStreamWriter {
}
private:
TestMemoryWriter memory_;
TestMinidumpMemoryWriter memory_;
DISALLOW_COPY_AND_ASSIGN(TestMemoryStream);
};
@ -338,7 +257,7 @@ TEST(MinidumpMemoryWriter, ExtraMemory) {
const uint64_t kSize2 = 0x0400;
const uint8_t kValue2 = 'm';
TestMemoryWriter memory_writer(kBaseAddress2, kSize2, kValue2);
TestMinidumpMemoryWriter memory_writer(kBaseAddress2, kSize2, kValue2);
memory_list_writer.AddMemory(&memory_writer);
minidump_file_writer.AddStream(&memory_list_writer);
@ -365,11 +284,11 @@ TEST(MinidumpMemoryWriter, ExtraMemory) {
sizeof(MINIDUMP_HEADER) + 2 * sizeof(MINIDUMP_DIRECTORY) +
sizeof(MINIDUMP_MEMORY_LIST) +
memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
ExpectMemoryDescriptorAndContents(&expected,
&memory_list->MemoryRanges[0],
file_writer.string(),
kValue1,
false);
ExpectMinidumpMemoryDescriptorAndContents(&expected,
&memory_list->MemoryRanges[0],
file_writer.string(),
kValue1,
false);
}
{
@ -379,11 +298,11 @@ TEST(MinidumpMemoryWriter, ExtraMemory) {
expected.Memory.DataSize = kSize2;
expected.Memory.Rva = memory_list->MemoryRanges[0].Memory.Rva +
memory_list->MemoryRanges[0].Memory.DataSize;
ExpectMemoryDescriptorAndContents(&expected,
&memory_list->MemoryRanges[1],
file_writer.string(),
kValue2,
true);
ExpectMinidumpMemoryDescriptorAndContents(&expected,
&memory_list->MemoryRanges[1],
file_writer.string(),
kValue2,
true);
}
}

96
minidump/minidump_memory_writer_test_util.cc Normal file
View File

@ -0,0 +1,96 @@
// Copyright 2014 The Crashpad Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "minidump/minidump_memory_writer_test_util.h"
#include "gtest/gtest.h"
namespace crashpad {
namespace test {
TestMinidumpMemoryWriter::TestMinidumpMemoryWriter(uint64_t base_address,
size_t size,
uint8_t value)
: MinidumpMemoryWriter(),
base_address_(base_address),
expected_offset_(-1),
size_(size),
value_(value) {
}
TestMinidumpMemoryWriter::~TestMinidumpMemoryWriter() {
}
uint64_t TestMinidumpMemoryWriter::MemoryRangeBaseAddress() const {
EXPECT_EQ(state(), kStateFrozen);
return base_address_;
}
size_t TestMinidumpMemoryWriter::MemoryRangeSize() const {
EXPECT_GE(state(), kStateFrozen);
return size_;
}
bool TestMinidumpMemoryWriter::WillWriteAtOffsetImpl(off_t offset) {
EXPECT_EQ(state(), kStateFrozen);
expected_offset_ = offset;
bool rv = MinidumpMemoryWriter::WillWriteAtOffsetImpl(offset);
EXPECT_TRUE(rv);
return rv;
}
bool TestMinidumpMemoryWriter::WriteObject(FileWriterInterface* file_writer) {
EXPECT_EQ(state(), kStateWritable);
EXPECT_EQ(expected_offset_, file_writer->Seek(0, SEEK_CUR));
bool rv = true;
if (size_ > 0) {
std::string data(size_, value_);
rv = file_writer->Write(&data[0], size_);
EXPECT_TRUE(rv);
}
return rv;
}
void ExpectMinidumpMemoryDescriptorAndContents(
const MINIDUMP_MEMORY_DESCRIPTOR* expected,
const MINIDUMP_MEMORY_DESCRIPTOR* observed,
const std::string& file_contents,
uint8_t value,
bool at_eof) {
EXPECT_EQ(expected->StartOfMemoryRange, observed->StartOfMemoryRange);
EXPECT_EQ(expected->Memory.DataSize, observed->Memory.DataSize);
if (expected->Memory.Rva != 0) {
const uint32_t kMemoryAlignment = 16;
EXPECT_EQ(
(expected->Memory.Rva + kMemoryAlignment - 1) & ~(kMemoryAlignment - 1),
observed->Memory.Rva);
}
if (at_eof) {
EXPECT_EQ(file_contents.size(),
observed->Memory.Rva + observed->Memory.DataSize);
} else {
EXPECT_GE(file_contents.size(),
observed->Memory.Rva + observed->Memory.DataSize);
}
std::string expected_data(expected->Memory.DataSize, value);
std::string observed_data(&file_contents[observed->Memory.Rva],
observed->Memory.DataSize);
EXPECT_EQ(expected_data, observed_data);
}
} // namespace test
} // namespace crashpad

91
minidump/minidump_memory_writer_test_util.h Normal file
View File

@ -0,0 +1,91 @@
// Copyright 2014 The Crashpad Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef CRASHPAD_MINIDUMP_MINIDUMP_MEMORY_WRITER_TEST_UTIL_H_
#define CRASHPAD_MINIDUMP_MINIDUMP_MEMORY_WRITER_TEST_UTIL_H_
#include "minidump/minidump_memory_writer.h"
#include <dbghelp.h>
#include <stdint.h>
#include <string>
#include "base/basictypes.h"
#include "util/file/file_writer.h"
namespace crashpad {
namespace test {
//! \brief A MinidumpMemoryWriter implementation used for testing.
//!
//! TestMinidumpMemoryWriter objects are created with a fixed base address and
//! size, and will write the same byte (\a value) repeatedly, \a size times.
class TestMinidumpMemoryWriter final : public MinidumpMemoryWriter {
public:
TestMinidumpMemoryWriter(uint64_t base_address, size_t size, uint8_t value);
~TestMinidumpMemoryWriter();
protected:
// MinidumpMemoryWriter:
virtual uint64_t MemoryRangeBaseAddress() const override;
virtual size_t MemoryRangeSize() const override;
// MinidumpWritable:
virtual bool WillWriteAtOffsetImpl(off_t offset) override;
virtual bool WriteObject(FileWriterInterface* file_writer) override;
private:
uint64_t base_address_;
off_t expected_offset_;
size_t size_;
uint8_t value_;
DISALLOW_COPY_AND_ASSIGN(TestMinidumpMemoryWriter);
};
//! \brief Verifies, via gtest assertions, that a MINIDUMP_MEMORY_DESCRIPTOR
//! structure contains expected values, and that the memory region it points
//! to contains expected values assuming it was written by a
//! TestMinidumpMemoryWriter object.
//!
//! In \a expected and \a observed,
//! MINIDUMP_MEMORY_DESCRIPTOR::StartOfMemoryRange and
//! MINIDUMP_LOCATION_DESCRIPTOR::DataSize are compared and must match. If
//! MINIDUMP_LOCATION_DESCRIPTOR::Rva is nonzero in \a expected, the same field
//! in \a observed must match it, subject to a 16-byte alignment augmentation.
//!
//! \param[in] expected A MINIDUMP_MEMORY_DESCRIPTOR structure containing
//! expected values.
//! \param[in] observed A MINIDUMP_MEMORY_DESCRIPTOR structure containing
//! observed values.
//! \param[in] file_contents The contents of the minidump file in which \a
//! observed was found. The memory region referenced by \a observed will be
//! read from this string.
//! \param[in] value The \a value used to create a TestMinidumpMemoryWriter.
//! Each byte of memory in the region referenced by \a observed must be this
//! value.
//! \param[in] at_eof If `true`, the region referenced by \a observed must
//! appear at the end of \a file_contents, without any data following it.
void ExpectMinidumpMemoryDescriptorAndContents(
const MINIDUMP_MEMORY_DESCRIPTOR* expected,
const MINIDUMP_MEMORY_DESCRIPTOR* observed,
const std::string& file_contents,
uint8_t value,
bool at_eof);
} // namespace test
} // namespace crashpad
#endif // CRASHPAD_MINIDUMP_MINIDUMP_MEMORY_WRITER_TEST_UTIL_H_