mirror of
https://github.com/chromium/crashpad.git
synced 2024-12-29 08:39:44 +08:00
6d2d31d2d1
This was done in Chromium’s local copy of Crashpad in 562827afb599. This change is similar to that one, except more care was taken to avoid including headers from a .cc or _test.cc when already included by the associated .h. Rather than using <stddef.h> for size_t, Crashpad has always used <sys/types.h>, so that’s used here as well. This updates mini_chromium to 8a2363f486e3a0dc562a68884832d06d28d38dcc, which removes base/basictypes.h. e128dcf10122 Remove base/move.h; use std::move() instead of Pass() 8a2363f486e3 Move basictypes.h to macros.h R=avi@chromium.org Review URL: https://codereview.chromium.org/1566713002 .
838 lines
26 KiB
C++
838 lines
26 KiB
C++
// 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_writable.h"
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "base/macros.h"
|
|
#include "gtest/gtest.h"
|
|
#include "util/file/string_file.h"
|
|
|
|
namespace crashpad {
|
|
namespace test {
|
|
namespace {
|
|
|
|
class BaseTestMinidumpWritable : public crashpad::internal::MinidumpWritable {
|
|
public:
|
|
BaseTestMinidumpWritable()
|
|
: MinidumpWritable(),
|
|
children_(),
|
|
expected_offset_(-1),
|
|
alignment_(0),
|
|
phase_(kPhaseEarly),
|
|
has_alignment_(false),
|
|
has_phase_(false),
|
|
verified_(false) {}
|
|
|
|
~BaseTestMinidumpWritable() { EXPECT_TRUE(verified_); }
|
|
|
|
void SetAlignment(size_t alignment) {
|
|
alignment_ = alignment;
|
|
has_alignment_ = true;
|
|
}
|
|
|
|
void AddChild(BaseTestMinidumpWritable* child) { children_.push_back(child); }
|
|
|
|
void SetPhaseLate() {
|
|
phase_ = kPhaseLate;
|
|
has_phase_ = true;
|
|
}
|
|
|
|
void Verify() {
|
|
verified_ = true;
|
|
EXPECT_EQ(kStateWritten, state());
|
|
for (BaseTestMinidumpWritable* child : children_) {
|
|
child->Verify();
|
|
}
|
|
}
|
|
|
|
protected:
|
|
bool Freeze() override {
|
|
EXPECT_EQ(kStateMutable, state());
|
|
bool rv = MinidumpWritable::Freeze();
|
|
EXPECT_TRUE(rv);
|
|
EXPECT_EQ(kStateFrozen, state());
|
|
return rv;
|
|
}
|
|
|
|
size_t Alignment() override {
|
|
EXPECT_GE(state(), kStateFrozen);
|
|
return has_alignment_ ? alignment_ : MinidumpWritable::Alignment();
|
|
}
|
|
|
|
std::vector<MinidumpWritable*> Children() override {
|
|
EXPECT_GE(state(), kStateFrozen);
|
|
if (!children_.empty()) {
|
|
std::vector<MinidumpWritable*> children;
|
|
for (BaseTestMinidumpWritable* child : children_) {
|
|
children.push_back(child);
|
|
}
|
|
return children;
|
|
}
|
|
return MinidumpWritable::Children();
|
|
}
|
|
|
|
Phase WritePhase() override {
|
|
return has_phase_ ? phase_ : MinidumpWritable::Phase();
|
|
}
|
|
|
|
bool WillWriteAtOffsetImpl(FileOffset offset) override {
|
|
EXPECT_EQ(state(), kStateFrozen);
|
|
expected_offset_ = offset;
|
|
bool rv = MinidumpWritable::WillWriteAtOffsetImpl(offset);
|
|
EXPECT_TRUE(rv);
|
|
return rv;
|
|
}
|
|
|
|
bool WriteObject(FileWriterInterface* file_writer) override {
|
|
EXPECT_EQ(state(), kStateWritable);
|
|
EXPECT_EQ(expected_offset_, file_writer->Seek(0, SEEK_CUR));
|
|
|
|
// Subclasses must override this.
|
|
return false;
|
|
}
|
|
|
|
private:
|
|
std::vector<BaseTestMinidumpWritable*> children_;
|
|
FileOffset expected_offset_;
|
|
size_t alignment_;
|
|
Phase phase_;
|
|
bool has_alignment_;
|
|
bool has_phase_;
|
|
bool verified_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(BaseTestMinidumpWritable);
|
|
};
|
|
|
|
class TestStringMinidumpWritable final : public BaseTestMinidumpWritable {
|
|
public:
|
|
TestStringMinidumpWritable() : BaseTestMinidumpWritable(), data_() {}
|
|
|
|
~TestStringMinidumpWritable() {}
|
|
|
|
void SetData(const std::string& string) { data_ = string; }
|
|
|
|
protected:
|
|
size_t SizeOfObject() override {
|
|
EXPECT_GE(state(), kStateFrozen);
|
|
return data_.size();
|
|
}
|
|
|
|
bool WriteObject(FileWriterInterface* file_writer) override {
|
|
BaseTestMinidumpWritable::WriteObject(file_writer);
|
|
bool rv = file_writer->Write(&data_[0], data_.size());
|
|
EXPECT_TRUE(rv);
|
|
return rv;
|
|
}
|
|
|
|
private:
|
|
std::string data_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(TestStringMinidumpWritable);
|
|
};
|
|
|
|
TEST(MinidumpWritable, MinidumpWritable) {
|
|
StringFile string_file;
|
|
|
|
{
|
|
SCOPED_TRACE("empty");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable string_writable;
|
|
EXPECT_TRUE(string_writable.WriteEverything(&string_file));
|
|
EXPECT_TRUE(string_file.string().empty());
|
|
string_writable.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("childless");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable string_writable;
|
|
string_writable.SetData("a");
|
|
EXPECT_TRUE(string_writable.WriteEverything(&string_file));
|
|
EXPECT_EQ(1u, string_file.string().size());
|
|
EXPECT_EQ("a", string_file.string());
|
|
string_writable.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("parent-child");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("b");
|
|
TestStringMinidumpWritable child;
|
|
child.SetData("c");
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(5u, string_file.string().size());
|
|
EXPECT_EQ(std::string("b\0\0\0c", 5), string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("base alignment 2");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("de");
|
|
TestStringMinidumpWritable child;
|
|
child.SetData("f");
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(5u, string_file.string().size());
|
|
EXPECT_EQ(std::string("de\0\0f", 5), string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("base alignment 3");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("ghi");
|
|
TestStringMinidumpWritable child;
|
|
child.SetData("j");
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(5u, string_file.string().size());
|
|
EXPECT_EQ(std::string("ghi\0j", 5), string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("base alignment 4");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("klmn");
|
|
TestStringMinidumpWritable child;
|
|
child.SetData("o");
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(5u, string_file.string().size());
|
|
EXPECT_EQ("klmno", string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("base alignment 5");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("pqrst");
|
|
TestStringMinidumpWritable child;
|
|
child.SetData("u");
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(9u, string_file.string().size());
|
|
EXPECT_EQ(std::string("pqrst\0\0\0u", 9), string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("two children");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("parent");
|
|
TestStringMinidumpWritable child_0;
|
|
child_0.SetData("child_0");
|
|
parent.AddChild(&child_0);
|
|
TestStringMinidumpWritable child_1;
|
|
child_1.SetData("child_1");
|
|
parent.AddChild(&child_1);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(23u, string_file.string().size());
|
|
EXPECT_EQ(std::string("parent\0\0child_0\0child_1", 23), string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("grandchild");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("parent");
|
|
TestStringMinidumpWritable child;
|
|
child.SetData("child");
|
|
parent.AddChild(&child);
|
|
TestStringMinidumpWritable grandchild;
|
|
grandchild.SetData("grandchild");
|
|
child.AddChild(&grandchild);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(26u, string_file.string().size());
|
|
EXPECT_EQ(std::string("parent\0\0child\0\0\0grandchild", 26),
|
|
string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("grandchild with empty parent");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
TestStringMinidumpWritable child;
|
|
child.SetData("child");
|
|
parent.AddChild(&child);
|
|
TestStringMinidumpWritable grandchild;
|
|
grandchild.SetData("grandchild");
|
|
child.AddChild(&grandchild);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(18u, string_file.string().size());
|
|
EXPECT_EQ(std::string("child\0\0\0grandchild", 18), string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("grandchild with empty child");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("parent");
|
|
TestStringMinidumpWritable child;
|
|
parent.AddChild(&child);
|
|
TestStringMinidumpWritable grandchild;
|
|
grandchild.SetData("grandchild");
|
|
child.AddChild(&grandchild);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(18u, string_file.string().size());
|
|
EXPECT_EQ(std::string("parent\0\0grandchild", 18), string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("grandchild with empty grandchild");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("parent");
|
|
TestStringMinidumpWritable child;
|
|
child.SetData("child");
|
|
parent.AddChild(&child);
|
|
TestStringMinidumpWritable grandchild;
|
|
child.AddChild(&grandchild);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(13u, string_file.string().size());
|
|
EXPECT_EQ(std::string("parent\0\0child", 13), string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("grandchild with late-phase grandchild");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("parent");
|
|
TestStringMinidumpWritable child;
|
|
child.SetData("child");
|
|
parent.AddChild(&child);
|
|
TestStringMinidumpWritable grandchild;
|
|
grandchild.SetData("grandchild");
|
|
grandchild.SetPhaseLate();
|
|
child.AddChild(&grandchild);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(26u, string_file.string().size());
|
|
EXPECT_EQ(std::string("parent\0\0child\0\0\0grandchild", 26),
|
|
string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("grandchild with late-phase child");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("parent");
|
|
TestStringMinidumpWritable child;
|
|
child.SetData("child");
|
|
child.SetPhaseLate();
|
|
parent.AddChild(&child);
|
|
TestStringMinidumpWritable grandchild;
|
|
grandchild.SetData("grandchild");
|
|
child.AddChild(&grandchild);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(25u, string_file.string().size());
|
|
EXPECT_EQ(std::string("parent\0\0grandchild\0\0child", 25),
|
|
string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("family tree");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("P..");
|
|
TestStringMinidumpWritable child_0;
|
|
child_0.SetData("C0.");
|
|
parent.AddChild(&child_0);
|
|
TestStringMinidumpWritable child_1;
|
|
child_1.SetData("C1.");
|
|
parent.AddChild(&child_1);
|
|
TestStringMinidumpWritable grandchild_00;
|
|
grandchild_00.SetData("G00");
|
|
child_0.AddChild(&grandchild_00);
|
|
TestStringMinidumpWritable grandchild_01;
|
|
grandchild_01.SetData("G01");
|
|
child_0.AddChild(&grandchild_01);
|
|
TestStringMinidumpWritable grandchild_10;
|
|
grandchild_10.SetData("G10");
|
|
child_1.AddChild(&grandchild_10);
|
|
TestStringMinidumpWritable grandchild_11;
|
|
grandchild_11.SetData("G11");
|
|
child_1.AddChild(&grandchild_11);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(27u, string_file.string().size());
|
|
EXPECT_EQ(std::string("P..\0C0.\0G00\0G01\0C1.\0G10\0G11", 27),
|
|
string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("family tree with C0 late");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("P..");
|
|
TestStringMinidumpWritable child_0;
|
|
child_0.SetData("C0.");
|
|
child_0.SetPhaseLate();
|
|
parent.AddChild(&child_0);
|
|
TestStringMinidumpWritable child_1;
|
|
child_1.SetData("C1.");
|
|
parent.AddChild(&child_1);
|
|
TestStringMinidumpWritable grandchild_00;
|
|
grandchild_00.SetData("G00");
|
|
child_0.AddChild(&grandchild_00);
|
|
TestStringMinidumpWritable grandchild_01;
|
|
grandchild_01.SetData("G01");
|
|
child_0.AddChild(&grandchild_01);
|
|
TestStringMinidumpWritable grandchild_10;
|
|
grandchild_10.SetData("G10");
|
|
child_1.AddChild(&grandchild_10);
|
|
TestStringMinidumpWritable grandchild_11;
|
|
grandchild_11.SetData("G11");
|
|
child_1.AddChild(&grandchild_11);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(27u, string_file.string().size());
|
|
EXPECT_EQ(std::string("P..\0G00\0G01\0C1.\0G10\0G11\0C0.", 27),
|
|
string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("family tree with G0 late");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("P..");
|
|
TestStringMinidumpWritable child_0;
|
|
child_0.SetData("C0.");
|
|
parent.AddChild(&child_0);
|
|
TestStringMinidumpWritable child_1;
|
|
child_1.SetData("C1.");
|
|
parent.AddChild(&child_1);
|
|
TestStringMinidumpWritable grandchild_00;
|
|
grandchild_00.SetData("G00");
|
|
grandchild_00.SetPhaseLate();
|
|
child_0.AddChild(&grandchild_00);
|
|
TestStringMinidumpWritable grandchild_01;
|
|
grandchild_01.SetData("G01");
|
|
grandchild_01.SetPhaseLate();
|
|
child_0.AddChild(&grandchild_01);
|
|
TestStringMinidumpWritable grandchild_10;
|
|
grandchild_10.SetData("G10");
|
|
child_1.AddChild(&grandchild_10);
|
|
TestStringMinidumpWritable grandchild_11;
|
|
grandchild_11.SetData("G11");
|
|
child_1.AddChild(&grandchild_11);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(27u, string_file.string().size());
|
|
EXPECT_EQ(std::string("P..\0C0.\0C1.\0G10\0G11\0G00\0G01", 27),
|
|
string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("align 1");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("p");
|
|
TestStringMinidumpWritable child;
|
|
child.SetData("c");
|
|
child.SetAlignment(1);
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(2u, string_file.string().size());
|
|
EXPECT_EQ("pc", string_file.string());
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("align 2");
|
|
string_file.Reset();
|
|
TestStringMinidumpWritable parent;
|
|
parent.SetData("p");
|
|
TestStringMinidumpWritable child;
|
|
child.SetData("c");
|
|
child.SetAlignment(2);
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
EXPECT_EQ(3u, string_file.string().size());
|
|
EXPECT_EQ(std::string("p\0c", 3), string_file.string());
|
|
parent.Verify();
|
|
}
|
|
}
|
|
|
|
class TestRVAMinidumpWritable final : public BaseTestMinidumpWritable {
|
|
public:
|
|
TestRVAMinidumpWritable() : BaseTestMinidumpWritable(), rva_() {}
|
|
|
|
~TestRVAMinidumpWritable() {}
|
|
|
|
void SetRVA(MinidumpWritable* other) { other->RegisterRVA(&rva_); }
|
|
|
|
protected:
|
|
size_t SizeOfObject() override {
|
|
EXPECT_GE(state(), kStateFrozen);
|
|
return sizeof(rva_);
|
|
}
|
|
|
|
bool WriteObject(FileWriterInterface* file_writer) override {
|
|
BaseTestMinidumpWritable::WriteObject(file_writer);
|
|
EXPECT_TRUE(file_writer->Write(&rva_, sizeof(rva_)));
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
RVA rva_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(TestRVAMinidumpWritable);
|
|
};
|
|
|
|
RVA RVAAtIndex(const std::string& string, size_t index) {
|
|
return *reinterpret_cast<const RVA*>(&string[index * sizeof(RVA)]);
|
|
}
|
|
|
|
TEST(MinidumpWritable, RVA) {
|
|
StringFile string_file;
|
|
|
|
{
|
|
SCOPED_TRACE("unset");
|
|
string_file.Reset();
|
|
TestRVAMinidumpWritable rva_writable;
|
|
EXPECT_TRUE(rva_writable.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(sizeof(RVA), string_file.string().size());
|
|
EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(string_file.string(), 0));
|
|
rva_writable.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("self");
|
|
string_file.Reset();
|
|
TestRVAMinidumpWritable rva_writable;
|
|
rva_writable.SetRVA(&rva_writable);
|
|
EXPECT_TRUE(rva_writable.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(sizeof(RVA), string_file.string().size());
|
|
EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(string_file.string(), 0));
|
|
rva_writable.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("parent-child self");
|
|
string_file.Reset();
|
|
TestRVAMinidumpWritable parent;
|
|
parent.SetRVA(&parent);
|
|
TestRVAMinidumpWritable child;
|
|
child.SetRVA(&child);
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(2 * sizeof(RVA), string_file.string().size());
|
|
EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(string_file.string(), 0));
|
|
EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 1));
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("parent-child only");
|
|
string_file.Reset();
|
|
TestRVAMinidumpWritable parent;
|
|
TestRVAMinidumpWritable child;
|
|
parent.SetRVA(&child);
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(2 * sizeof(RVA), string_file.string().size());
|
|
EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 0));
|
|
EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(string_file.string(), 1));
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("parent-child circular");
|
|
string_file.Reset();
|
|
TestRVAMinidumpWritable parent;
|
|
TestRVAMinidumpWritable child;
|
|
parent.SetRVA(&child);
|
|
child.SetRVA(&parent);
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(2 * sizeof(RVA), string_file.string().size());
|
|
EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 0));
|
|
EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(string_file.string(), 1));
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("grandchildren");
|
|
string_file.Reset();
|
|
TestRVAMinidumpWritable parent;
|
|
TestRVAMinidumpWritable child;
|
|
parent.SetRVA(&child);
|
|
parent.AddChild(&child);
|
|
TestRVAMinidumpWritable grandchild_0;
|
|
grandchild_0.SetRVA(&child);
|
|
child.AddChild(&grandchild_0);
|
|
TestRVAMinidumpWritable grandchild_1;
|
|
grandchild_1.SetRVA(&child);
|
|
child.AddChild(&grandchild_1);
|
|
TestRVAMinidumpWritable grandchild_2;
|
|
grandchild_2.SetRVA(&child);
|
|
child.AddChild(&grandchild_2);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(5 * sizeof(RVA), string_file.string().size());
|
|
EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 0));
|
|
EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(string_file.string(), 1));
|
|
EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 2));
|
|
EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 3));
|
|
EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 4));
|
|
parent.Verify();
|
|
}
|
|
}
|
|
|
|
class TestLocationDescriptorMinidumpWritable final
|
|
: public BaseTestMinidumpWritable {
|
|
public:
|
|
TestLocationDescriptorMinidumpWritable()
|
|
: BaseTestMinidumpWritable(), location_descriptor_(), string_() {}
|
|
|
|
~TestLocationDescriptorMinidumpWritable() {}
|
|
|
|
void SetLocationDescriptor(MinidumpWritable* other) {
|
|
other->RegisterLocationDescriptor(&location_descriptor_);
|
|
}
|
|
|
|
void SetString(const std::string& string) { string_ = string; }
|
|
|
|
protected:
|
|
size_t SizeOfObject() override {
|
|
EXPECT_GE(state(), kStateFrozen);
|
|
// NUL-terminate.
|
|
return sizeof(location_descriptor_) + string_.size() + 1;
|
|
}
|
|
|
|
bool WriteObject(FileWriterInterface* file_writer) override {
|
|
BaseTestMinidumpWritable::WriteObject(file_writer);
|
|
WritableIoVec iov;
|
|
iov.iov_base = &location_descriptor_;
|
|
iov.iov_len = sizeof(location_descriptor_);
|
|
std::vector<WritableIoVec> iovecs(1, iov);
|
|
// NUL-terminate.
|
|
iov.iov_base = &string_[0];
|
|
iov.iov_len = string_.size() + 1;
|
|
iovecs.push_back(iov);
|
|
EXPECT_TRUE(file_writer->WriteIoVec(&iovecs));
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
MINIDUMP_LOCATION_DESCRIPTOR location_descriptor_;
|
|
std::string string_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(TestLocationDescriptorMinidumpWritable);
|
|
};
|
|
|
|
struct LocationDescriptorAndData {
|
|
MINIDUMP_LOCATION_DESCRIPTOR location_descriptor;
|
|
char string[1];
|
|
};
|
|
|
|
const LocationDescriptorAndData* LDDAtIndex(const std::string& string,
|
|
size_t index) {
|
|
return reinterpret_cast<const LocationDescriptorAndData*>(&string[index]);
|
|
}
|
|
|
|
TEST(MinidumpWritable, LocationDescriptor) {
|
|
StringFile string_file;
|
|
|
|
{
|
|
SCOPED_TRACE("unset");
|
|
string_file.Reset();
|
|
TestLocationDescriptorMinidumpWritable location_descriptor_writable;
|
|
EXPECT_TRUE(location_descriptor_writable.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(9u, string_file.string().size());
|
|
const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
|
|
EXPECT_EQ(0u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(0u, ldd->location_descriptor.Rva);
|
|
location_descriptor_writable.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("self");
|
|
string_file.Reset();
|
|
TestLocationDescriptorMinidumpWritable location_descriptor_writable;
|
|
location_descriptor_writable.SetLocationDescriptor(
|
|
&location_descriptor_writable);
|
|
EXPECT_TRUE(location_descriptor_writable.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(9u, string_file.string().size());
|
|
const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
|
|
EXPECT_EQ(9u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(0u, ldd->location_descriptor.Rva);
|
|
location_descriptor_writable.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("self with data");
|
|
string_file.Reset();
|
|
TestLocationDescriptorMinidumpWritable location_descriptor_writable;
|
|
location_descriptor_writable.SetLocationDescriptor(
|
|
&location_descriptor_writable);
|
|
location_descriptor_writable.SetString("zz");
|
|
EXPECT_TRUE(location_descriptor_writable.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(11u, string_file.string().size());
|
|
const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
|
|
EXPECT_EQ(11u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(0u, ldd->location_descriptor.Rva);
|
|
EXPECT_STREQ("zz", ldd->string);
|
|
location_descriptor_writable.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("parent-child self");
|
|
string_file.Reset();
|
|
TestLocationDescriptorMinidumpWritable parent;
|
|
parent.SetLocationDescriptor(&parent);
|
|
parent.SetString("yy");
|
|
TestLocationDescriptorMinidumpWritable child;
|
|
child.SetLocationDescriptor(&child);
|
|
child.SetString("x");
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(22u, string_file.string().size());
|
|
const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
|
|
EXPECT_EQ(11u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(0u, ldd->location_descriptor.Rva);
|
|
EXPECT_STREQ("yy", ldd->string);
|
|
ldd = LDDAtIndex(string_file.string(), 12);
|
|
EXPECT_EQ(10u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(12u, ldd->location_descriptor.Rva);
|
|
EXPECT_STREQ("x", ldd->string);
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("parent-child only");
|
|
string_file.Reset();
|
|
TestLocationDescriptorMinidumpWritable parent;
|
|
TestLocationDescriptorMinidumpWritable child;
|
|
parent.SetLocationDescriptor(&child);
|
|
parent.SetString("www");
|
|
child.SetString("vv");
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(23u, string_file.string().size());
|
|
const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
|
|
EXPECT_EQ(11u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(12u, ldd->location_descriptor.Rva);
|
|
EXPECT_STREQ("www", ldd->string);
|
|
ldd = LDDAtIndex(string_file.string(), 12);
|
|
EXPECT_EQ(0u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(0u, ldd->location_descriptor.Rva);
|
|
EXPECT_STREQ("vv", ldd->string);
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("parent-child circular");
|
|
string_file.Reset();
|
|
TestLocationDescriptorMinidumpWritable parent;
|
|
TestLocationDescriptorMinidumpWritable child;
|
|
parent.SetLocationDescriptor(&child);
|
|
parent.SetString("uuuu");
|
|
child.SetLocationDescriptor(&parent);
|
|
child.SetString("tttt");
|
|
parent.AddChild(&child);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(29u, string_file.string().size());
|
|
const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
|
|
EXPECT_EQ(13u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(16u, ldd->location_descriptor.Rva);
|
|
EXPECT_STREQ("uuuu", ldd->string);
|
|
ldd = LDDAtIndex(string_file.string(), 16);
|
|
EXPECT_EQ(13u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(0u, ldd->location_descriptor.Rva);
|
|
EXPECT_STREQ("tttt", ldd->string);
|
|
parent.Verify();
|
|
}
|
|
|
|
{
|
|
SCOPED_TRACE("grandchildren");
|
|
string_file.Reset();
|
|
TestLocationDescriptorMinidumpWritable parent;
|
|
TestLocationDescriptorMinidumpWritable child;
|
|
parent.SetLocationDescriptor(&child);
|
|
parent.SetString("s");
|
|
parent.AddChild(&child);
|
|
child.SetString("r");
|
|
TestLocationDescriptorMinidumpWritable grandchild_0;
|
|
grandchild_0.SetLocationDescriptor(&child);
|
|
grandchild_0.SetString("q");
|
|
child.AddChild(&grandchild_0);
|
|
TestLocationDescriptorMinidumpWritable grandchild_1;
|
|
grandchild_1.SetLocationDescriptor(&child);
|
|
grandchild_1.SetString("p");
|
|
child.AddChild(&grandchild_1);
|
|
TestLocationDescriptorMinidumpWritable grandchild_2;
|
|
grandchild_2.SetLocationDescriptor(&child);
|
|
grandchild_2.SetString("o");
|
|
child.AddChild(&grandchild_2);
|
|
EXPECT_TRUE(parent.WriteEverything(&string_file));
|
|
|
|
ASSERT_EQ(58u, string_file.string().size());
|
|
const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
|
|
EXPECT_EQ(10u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(12u, ldd->location_descriptor.Rva);
|
|
EXPECT_STREQ("s", ldd->string);
|
|
ldd = LDDAtIndex(string_file.string(), 12);
|
|
EXPECT_EQ(0u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(0u, ldd->location_descriptor.Rva);
|
|
EXPECT_STREQ("r", ldd->string);
|
|
ldd = LDDAtIndex(string_file.string(), 24);
|
|
EXPECT_EQ(10u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(12u, ldd->location_descriptor.Rva);
|
|
EXPECT_STREQ("q", ldd->string);
|
|
ldd = LDDAtIndex(string_file.string(), 36);
|
|
EXPECT_EQ(10u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(12u, ldd->location_descriptor.Rva);
|
|
EXPECT_STREQ("p", ldd->string);
|
|
ldd = LDDAtIndex(string_file.string(), 48);
|
|
EXPECT_EQ(10u, ldd->location_descriptor.DataSize);
|
|
EXPECT_EQ(12u, ldd->location_descriptor.Rva);
|
|
EXPECT_STREQ("o", ldd->string);
|
|
parent.Verify();
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace test
|
|
} // namespace crashpad
|