| // Copyright 2018 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 <filesystem> |
| #include <map> |
| |
| #include "garnet/bin/zxdb/client/remote_api.h" |
| #include "garnet/bin/zxdb/client/session.h" |
| #include "garnet/bin/zxdb/common/host_util.h" |
| #include "garnet/lib/debug_ipc/helper/platform_message_loop.h" |
| #include "gtest/gtest.h" |
| |
| namespace zxdb { |
| |
| class MinidumpTest : public testing::Test { |
| public: |
| MinidumpTest(); |
| virtual ~MinidumpTest(); |
| |
| debug_ipc::PlatformMessageLoop& loop() { return loop_; } |
| Session& session() { return *session_; } |
| |
| Err TryOpen(const std::string& filename); |
| |
| template <typename RequestType, typename ReplyType> |
| void DoRequest( |
| RequestType request, ReplyType& reply, Err& err, |
| void (RemoteAPI::*handler)(const RequestType&, |
| std::function<void(const Err&, ReplyType)>)); |
| |
| private: |
| debug_ipc::PlatformMessageLoop loop_; |
| std::unique_ptr<Session> session_; |
| }; |
| |
| MinidumpTest::MinidumpTest() { |
| loop_.Init(); |
| session_ = std::make_unique<Session>(); |
| } |
| |
| MinidumpTest::~MinidumpTest() { loop_.Cleanup(); } |
| |
| Err MinidumpTest::TryOpen(const std::string& filename) { |
| static auto data_dir = |
| std::filesystem::path(GetSelfPath()).parent_path() / |
| "test_data" / "zxdb"; |
| |
| Err err; |
| auto path = (data_dir / filename).string(); |
| |
| session().OpenMinidump(path, [&err](const Err& got) { |
| err = got; |
| debug_ipc::MessageLoop::Current()->QuitNow(); |
| }); |
| |
| loop().Run(); |
| |
| return err; |
| } |
| |
| template <typename RequestType, typename ReplyType> |
| void MinidumpTest::DoRequest( |
| RequestType request, ReplyType& reply, Err& err, |
| void (RemoteAPI::*handler)(const RequestType&, |
| std::function<void(const Err&, ReplyType)>)) { |
| (session().remote_api()->*handler)( |
| request, [&reply, &err](const Err& e, ReplyType r) { |
| err = e; |
| reply = r; |
| debug_ipc::MessageLoop::Current()->QuitNow(); |
| }); |
| loop().Run(); |
| } |
| |
| template <typename Data> |
| std::vector<uint8_t> AsData(Data d) { |
| std::vector<uint8_t> ret; |
| |
| ret.resize(sizeof(d)); |
| |
| *reinterpret_cast<Data*>(ret.data()) = d; |
| return ret; |
| } |
| |
| #define EXPECT_ZXDB_SUCCESS(e_) \ |
| ({ \ |
| Err e = e_; \ |
| EXPECT_FALSE(e.has_error()) << e.msg(); \ |
| }) |
| #define ASSERT_ZXDB_SUCCESS(e_) \ |
| ({ \ |
| Err e = e_; \ |
| ASSERT_FALSE(e.has_error()) << e.msg(); \ |
| }) |
| |
| constexpr uint32_t kTestExampleMinidumpKOID = 656254UL; |
| constexpr uint32_t kTestExampleMinidumpThreadKOID = 671806UL; |
| |
| constexpr uint32_t kTestExampleMinidumpWithAspaceKOID = 9462UL; |
| |
| TEST_F(MinidumpTest, Load) { |
| EXPECT_ZXDB_SUCCESS(TryOpen("test_example_minidump.dmp")); |
| } |
| |
| TEST_F(MinidumpTest, ProcessTreeRecord) { |
| ASSERT_ZXDB_SUCCESS(TryOpen("test_example_minidump.dmp")); |
| |
| Err err; |
| debug_ipc::ProcessTreeReply reply; |
| DoRequest(debug_ipc::ProcessTreeRequest(), reply, err, |
| &RemoteAPI::ProcessTree); |
| ASSERT_ZXDB_SUCCESS(err); |
| |
| auto record = reply.root; |
| EXPECT_EQ(debug_ipc::ProcessTreeRecord::Type::kProcess, record.type); |
| EXPECT_EQ("scenic", record.name); |
| EXPECT_EQ(kTestExampleMinidumpKOID, record.koid); |
| EXPECT_EQ(0UL, record.children.size()); |
| } |
| |
| TEST_F(MinidumpTest, AttachDetach) { |
| ASSERT_ZXDB_SUCCESS(TryOpen("test_example_minidump.dmp")); |
| |
| Err err; |
| debug_ipc::AttachRequest request; |
| debug_ipc::AttachReply reply; |
| |
| request.koid = kTestExampleMinidumpKOID; |
| DoRequest(request, reply, err, &RemoteAPI::Attach); |
| ASSERT_ZXDB_SUCCESS(err); |
| |
| EXPECT_EQ(0UL, reply.status); |
| EXPECT_EQ("scenic", reply.name); |
| |
| debug_ipc::DetachRequest detach_request; |
| debug_ipc::DetachReply detach_reply; |
| |
| detach_request.koid = kTestExampleMinidumpKOID; |
| DoRequest(detach_request, detach_reply, err, &RemoteAPI::Detach); |
| ASSERT_ZXDB_SUCCESS(err); |
| |
| EXPECT_EQ(0UL, detach_reply.status); |
| |
| /* Try to detach when not attached */ |
| DoRequest(detach_request, detach_reply, err, &RemoteAPI::Detach); |
| ASSERT_ZXDB_SUCCESS(err); |
| |
| EXPECT_NE(0UL, detach_reply.status); |
| } |
| |
| TEST_F(MinidumpTest, AttachFail) { |
| ASSERT_ZXDB_SUCCESS(TryOpen("test_example_minidump.dmp")); |
| |
| Err err; |
| debug_ipc::AttachRequest request; |
| debug_ipc::AttachReply reply; |
| |
| request.koid = 42; |
| DoRequest(request, reply, err, &RemoteAPI::Attach); |
| ASSERT_ZXDB_SUCCESS(err); |
| |
| EXPECT_NE(0UL, reply.status); |
| } |
| |
| TEST_F(MinidumpTest, Threads) { |
| ASSERT_ZXDB_SUCCESS(TryOpen("test_example_minidump.dmp")); |
| |
| Err err; |
| debug_ipc::ThreadsRequest request; |
| debug_ipc::ThreadsReply reply; |
| |
| request.process_koid = kTestExampleMinidumpKOID; |
| DoRequest(request, reply, err, &RemoteAPI::Threads); |
| ASSERT_ZXDB_SUCCESS(err); |
| |
| ASSERT_LT(0UL, reply.threads.size()); |
| EXPECT_EQ(1UL, reply.threads.size()); |
| |
| auto& thread = reply.threads[0]; |
| |
| EXPECT_EQ(kTestExampleMinidumpThreadKOID, thread.koid); |
| EXPECT_EQ("", thread.name); |
| EXPECT_EQ(debug_ipc::ThreadRecord::State::kCoreDump, thread.state); |
| } |
| |
| TEST_F(MinidumpTest, Registers) { |
| ASSERT_ZXDB_SUCCESS(TryOpen("test_example_minidump.dmp")); |
| |
| Err err; |
| debug_ipc::ReadRegistersRequest request; |
| debug_ipc::ReadRegistersReply reply; |
| |
| using C = debug_ipc::RegisterCategory::Type; |
| using R = debug_ipc::RegisterID; |
| |
| request.process_koid = kTestExampleMinidumpKOID; |
| request.thread_koid = kTestExampleMinidumpThreadKOID; |
| request.categories = { |
| C::kGeneral, |
| C::kFP, |
| C::kVector, |
| C::kDebug, |
| }; |
| DoRequest(request, reply, err, &RemoteAPI::ReadRegisters); |
| ASSERT_ZXDB_SUCCESS(err); |
| |
| EXPECT_EQ(4UL, reply.categories.size()); |
| |
| EXPECT_EQ(C::kGeneral, reply.categories[0].type); |
| EXPECT_EQ(C::kFP, reply.categories[1].type); |
| EXPECT_EQ(C::kVector, reply.categories[2].type); |
| EXPECT_EQ(C::kDebug, reply.categories[3].type); |
| |
| std::map<std::pair<C, R>, std::vector<uint8_t>> got; |
| for (const auto& cat : reply.categories) { |
| for (const auto& reg : cat.registers) { |
| got[std::pair(cat.type, reg.id)] = reg.data; |
| } |
| } |
| |
| std::vector<uint8_t> zero_short = {0, 0}; |
| std::vector<uint8_t> zero_128 = {0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0}; |
| |
| EXPECT_EQ(AsData(0x83UL), got[std::pair(C::kGeneral, R::kX64_rax)]); |
| EXPECT_EQ(AsData(0x2FE150062100UL), got[std::pair(C::kGeneral, R::kX64_rbx)]); |
| EXPECT_EQ(AsData(0x0UL), got[std::pair(C::kGeneral, R::kX64_rcx)]); |
| EXPECT_EQ(AsData(0x4DC647A67264UL), got[std::pair(C::kGeneral, R::kX64_rdx)]); |
| EXPECT_EQ(AsData(0x5283B9A79945UL), got[std::pair(C::kGeneral, R::kX64_rsi)]); |
| EXPECT_EQ(AsData(0x4DC647A671D8UL), got[std::pair(C::kGeneral, R::kX64_rdi)]); |
| EXPECT_EQ(AsData(0x37F880986D70UL), got[std::pair(C::kGeneral, R::kX64_rbp)]); |
| EXPECT_EQ(AsData(0x37F880986D48UL), got[std::pair(C::kGeneral, R::kX64_rsp)]); |
| EXPECT_EQ(AsData(0x1UL), got[std::pair(C::kGeneral, R::kX64_r8)]); |
| EXPECT_EQ(AsData(0x0UL), got[std::pair(C::kGeneral, R::kX64_r9)]); |
| EXPECT_EQ(AsData(0x4DC647A671D8UL), got[std::pair(C::kGeneral, R::kX64_r10)]); |
| EXPECT_EQ(AsData(0x83UL), got[std::pair(C::kGeneral, R::kX64_r11)]); |
| EXPECT_EQ(AsData(0x2FE150077070UL), got[std::pair(C::kGeneral, R::kX64_r12)]); |
| EXPECT_EQ(AsData(0x3F4C20970A28UL), got[std::pair(C::kGeneral, R::kX64_r13)]); |
| EXPECT_EQ(AsData(0xFFFFFFF5UL), got[std::pair(C::kGeneral, R::kX64_r14)]); |
| EXPECT_EQ(AsData(0x2FE150062138UL), got[std::pair(C::kGeneral, R::kX64_r15)]); |
| EXPECT_EQ(AsData(0x4DC6479A5B1EUL), got[std::pair(C::kGeneral, R::kX64_rip)]); |
| EXPECT_EQ(AsData(0x10206UL), got[std::pair(C::kGeneral, R::kX64_rflags)]); |
| |
| EXPECT_EQ(zero_short, got[std::pair(C::kFP, R::kX64_fcw)]); |
| EXPECT_EQ(zero_short, got[std::pair(C::kFP, R::kX64_fsw)]); |
| EXPECT_EQ(AsData('\0'), got[std::pair(C::kFP, R::kX64_ftw)]); |
| EXPECT_EQ(zero_short, got[std::pair(C::kFP, R::kX64_fop)]); |
| EXPECT_EQ(AsData(0x0UL), got[std::pair(C::kFP, R::kX64_fip)]); |
| EXPECT_EQ(AsData(0x0UL), got[std::pair(C::kFP, R::kX64_fdp)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kFP, R::kX64_st0)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kFP, R::kX64_st1)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kFP, R::kX64_st2)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kFP, R::kX64_st3)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kFP, R::kX64_st4)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kFP, R::kX64_st5)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kFP, R::kX64_st6)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kFP, R::kX64_st7)]); |
| |
| EXPECT_EQ(AsData(0x0U), got[std::pair(C::kVector, R::kX64_mxcsr)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm0)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm1)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm2)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm3)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm4)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm5)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm6)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm7)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm8)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm9)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm10)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm11)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm12)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm13)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm14)]); |
| EXPECT_EQ(zero_128, got[std::pair(C::kVector, R::kX64_xmm15)]); |
| |
| EXPECT_EQ(AsData(0x0UL), got[std::pair(C::kDebug, R::kX64_dr0)]); |
| EXPECT_EQ(AsData(0x0UL), got[std::pair(C::kDebug, R::kX64_dr1)]); |
| EXPECT_EQ(AsData(0x0UL), got[std::pair(C::kDebug, R::kX64_dr2)]); |
| EXPECT_EQ(AsData(0x0UL), got[std::pair(C::kDebug, R::kX64_dr3)]); |
| EXPECT_EQ(AsData(0x0UL), got[std::pair(C::kDebug, R::kX64_dr6)]); |
| EXPECT_EQ(AsData(0x0UL), got[std::pair(C::kDebug, R::kX64_dr7)]); |
| } |
| |
| TEST_F(MinidumpTest, Modules) { |
| ASSERT_ZXDB_SUCCESS(TryOpen("test_example_minidump.dmp")); |
| |
| Err err; |
| debug_ipc::ModulesRequest request; |
| debug_ipc::ModulesReply reply; |
| |
| request.process_koid = kTestExampleMinidumpKOID; |
| |
| DoRequest(request, reply, err, &RemoteAPI::Modules); |
| ASSERT_ZXDB_SUCCESS(err); |
| |
| ASSERT_EQ(17UL, reply.modules.size()); |
| |
| EXPECT_EQ("scenic", reply.modules[0].name); |
| EXPECT_EQ(0x5283b9a60000UL, reply.modules[0].base); |
| EXPECT_EQ("892eb410-d365-1c5e-0000-000000000000", reply.modules[0].build_id); |
| |
| EXPECT_EQ("libfxl_logging.so", reply.modules[1].name); |
| EXPECT_EQ(0x4b3297cab000UL, reply.modules[1].base); |
| EXPECT_EQ("d0a7bf1a-05f2-2fd6-0000-000000000000", reply.modules[1].build_id); |
| |
| EXPECT_EQ("libfxl.so", reply.modules[2].name); |
| EXPECT_EQ(0x668d303bd000UL, reply.modules[2].base); |
| EXPECT_EQ("50b1c0b1-04a9-1aa3-0000-000000000000", reply.modules[2].build_id); |
| |
| EXPECT_EQ("libfsl.so", reply.modules[3].name); |
| EXPECT_EQ(0x590935d06000UL, reply.modules[3].base); |
| EXPECT_EQ("a72c1f38-23be-4b09-0000-000000000000", reply.modules[3].build_id); |
| |
| EXPECT_EQ("libvulkan.so", reply.modules[4].name); |
| EXPECT_EQ(0x117b5412000UL, reply.modules[4].base); |
| EXPECT_EQ("403dd74f-719f-52ae-0000-000000000000", reply.modules[4].build_id); |
| |
| EXPECT_EQ("libmagma.so", reply.modules[5].name); |
| EXPECT_EQ(0x17e7d1bef000UL, reply.modules[5].base); |
| EXPECT_EQ("de195bb2-3412-f748-0000-000000000000", reply.modules[5].build_id); |
| |
| EXPECT_EQ("libfdio.so", reply.modules[6].name); |
| EXPECT_EQ(0x6bc14ef2000UL, reply.modules[6].base); |
| EXPECT_EQ("e3cfa857-c5e3-e6f3-18dc-f1ea95c2125f", reply.modules[6].build_id); |
| |
| EXPECT_EQ("libzircon.so", reply.modules[7].name); |
| EXPECT_EQ(0x469a0a8cc000UL, reply.modules[7].base); |
| EXPECT_EQ("2ead1ae7-9187-c1e7-c33a-c16dda37994f", reply.modules[7].build_id); |
| |
| EXPECT_EQ("libasync-default.so", reply.modules[8].name); |
| EXPECT_EQ(0x3051c2800000UL, reply.modules[8].base); |
| EXPECT_EQ("51f70165-90ad-92dc-59f3-e54e6d375fb6", reply.modules[8].build_id); |
| |
| EXPECT_EQ("libtrace-engine.so", reply.modules[9].name); |
| EXPECT_EQ(0xfd47fbc000UL, reply.modules[9].base); |
| EXPECT_EQ("c67714cc-f5ec-c092-b073-5fb6214d005a", reply.modules[9].build_id); |
| |
| EXPECT_EQ("libsyslog.so", reply.modules[10].name); |
| EXPECT_EQ(0x5615f3ac000UL, reply.modules[10].base); |
| EXPECT_EQ("d7dbc27f-5270-2a6e-eaa2-8d4c0987fd7a", reply.modules[10].build_id); |
| |
| EXPECT_EQ("libdriver.so", reply.modules[11].name); |
| EXPECT_EQ(0x3b0bf8718000UL, reply.modules[11].base); |
| EXPECT_EQ("860c8221-6226-1a44-154c-edf719ffe9d6", reply.modules[11].build_id); |
| |
| EXPECT_EQ("libc++.so.2", reply.modules[12].name); |
| EXPECT_EQ(0x4bf2c6583000UL, reply.modules[12].base); |
| EXPECT_EQ("082ae8e5-20a3-c01e-0000-000000000000", reply.modules[12].build_id); |
| |
| EXPECT_EQ("libc++abi.so.1", reply.modules[13].name); |
| EXPECT_EQ(0x2aa8fa149000UL, reply.modules[13].base); |
| EXPECT_EQ("222277b9-d22e-2509-0000-000000000000", reply.modules[13].build_id); |
| |
| EXPECT_EQ("libunwind.so.1", reply.modules[14].name); |
| EXPECT_EQ(0x5ac9a6da2000UL, reply.modules[14].base); |
| EXPECT_EQ("3e851a5b-fb10-981f-0000-000000000000", reply.modules[14].build_id); |
| |
| EXPECT_EQ("libc.so", reply.modules[15].name); |
| EXPECT_EQ(0x4dc64798f000UL, reply.modules[15].base); |
| EXPECT_EQ("9193a3d9-74e6-cd7f-3cce-958895461cc0", reply.modules[15].build_id); |
| |
| EXPECT_EQ("libframebuffer.so", reply.modules[16].name); |
| EXPECT_EQ(0x5fa025a5b000UL, reply.modules[16].base); |
| EXPECT_EQ("aceb6958-deae-a336-d43a-24359083c628", reply.modules[16].build_id); |
| } |
| |
| TEST_F(MinidumpTest, AddressSpace) { |
| ASSERT_ZXDB_SUCCESS(TryOpen("test_example_minidump_with_aspace.dmp")); |
| |
| Err err; |
| debug_ipc::AddressSpaceRequest request; |
| debug_ipc::AddressSpaceReply reply; |
| |
| request.process_koid = kTestExampleMinidumpWithAspaceKOID; |
| |
| DoRequest(request, reply, err, &RemoteAPI::AddressSpace); |
| ASSERT_ZXDB_SUCCESS(err); |
| |
| ASSERT_EQ(18UL, reply.map.size()); |
| |
| EXPECT_EQ("", reply.map[0].name); |
| EXPECT_EQ(0x12766084a000UL, reply.map[0].base); |
| EXPECT_EQ(262144UL, reply.map[0].size); |
| EXPECT_EQ(0UL, reply.map[0].depth); |
| |
| EXPECT_EQ("", reply.map[1].name); |
| EXPECT_EQ(0x1a531e112000UL, reply.map[1].base); |
| EXPECT_EQ(262144UL, reply.map[1].size); |
| EXPECT_EQ(0UL, reply.map[1].depth); |
| |
| EXPECT_EQ("", reply.map[2].name); |
| EXPECT_EQ(0x38b28bf10000UL, reply.map[2].base); |
| EXPECT_EQ(4096UL, reply.map[2].size); |
| EXPECT_EQ(0UL, reply.map[2].depth); |
| |
| EXPECT_EQ("", reply.map[3].name); |
| EXPECT_EQ(0x41ea65c3d000UL, reply.map[3].base); |
| EXPECT_EQ(4096UL, reply.map[3].size); |
| EXPECT_EQ(0UL, reply.map[3].depth); |
| |
| EXPECT_EQ("", reply.map[4].name); |
| EXPECT_EQ(0x44b8c3369000UL, reply.map[4].base); |
| EXPECT_EQ(2097152UL, reply.map[4].size); |
| EXPECT_EQ(0UL, reply.map[4].depth); |
| |
| EXPECT_EQ("", reply.map[5].name); |
| EXPECT_EQ(0x45226ca65000UL, reply.map[5].base); |
| EXPECT_EQ(2097152UL, reply.map[5].size); |
| EXPECT_EQ(0UL, reply.map[5].depth); |
| |
| EXPECT_EQ("", reply.map[6].name); |
| EXPECT_EQ(0x513737c43000UL, reply.map[6].base); |
| EXPECT_EQ(28672UL, reply.map[6].size); |
| EXPECT_EQ(0UL, reply.map[6].depth); |
| |
| EXPECT_EQ("", reply.map[7].name); |
| EXPECT_EQ(0x513737c4a000UL, reply.map[7].base); |
| EXPECT_EQ(4096UL, reply.map[7].size); |
| EXPECT_EQ(0UL, reply.map[7].depth); |
| |
| EXPECT_EQ("", reply.map[8].name); |
| EXPECT_EQ(0x5e008a746000UL, reply.map[8].base); |
| EXPECT_EQ(139264UL, reply.map[8].size); |
| EXPECT_EQ(0UL, reply.map[8].depth); |
| |
| EXPECT_EQ("", reply.map[9].name); |
| EXPECT_EQ(0x5e008a768000UL, reply.map[9].base); |
| EXPECT_EQ(8192UL, reply.map[9].size); |
| EXPECT_EQ(0UL, reply.map[9].depth); |
| |
| EXPECT_EQ("", reply.map[10].name); |
| EXPECT_EQ(0x5e008a76a000UL, reply.map[10].base); |
| EXPECT_EQ(12288UL, reply.map[10].size); |
| EXPECT_EQ(0UL, reply.map[10].depth); |
| |
| EXPECT_EQ("", reply.map[11].name); |
| EXPECT_EQ(0x652d9b6bb000UL, reply.map[11].base); |
| EXPECT_EQ(831488UL, reply.map[11].size); |
| EXPECT_EQ(0UL, reply.map[11].depth); |
| |
| EXPECT_EQ("", reply.map[12].name); |
| EXPECT_EQ(0x652d9b787000UL, reply.map[12].base); |
| EXPECT_EQ(12288UL, reply.map[12].size); |
| EXPECT_EQ(0UL, reply.map[12].depth); |
| |
| EXPECT_EQ("", reply.map[13].name); |
| EXPECT_EQ(0x652d9b78a000UL, reply.map[13].base); |
| EXPECT_EQ(12288UL, reply.map[13].size); |
| EXPECT_EQ(0UL, reply.map[13].depth); |
| |
| EXPECT_EQ("", reply.map[14].name); |
| EXPECT_EQ(0x7328c9333000UL, reply.map[14].base); |
| EXPECT_EQ(8192UL, reply.map[14].size); |
| EXPECT_EQ(0UL, reply.map[14].depth); |
| |
| EXPECT_EQ("", reply.map[15].name); |
| EXPECT_EQ(0x7328c9335000UL, reply.map[15].base); |
| EXPECT_EQ(4096UL, reply.map[15].size); |
| EXPECT_EQ(0UL, reply.map[15].depth); |
| |
| EXPECT_EQ("", reply.map[16].name); |
| EXPECT_EQ(0x7328c9336000UL, reply.map[16].base); |
| EXPECT_EQ(4096UL, reply.map[16].size); |
| EXPECT_EQ(0UL, reply.map[16].depth); |
| |
| EXPECT_EQ("", reply.map[17].name); |
| EXPECT_EQ(0x7c1d710c8000UL, reply.map[17].base); |
| EXPECT_EQ(4096UL, reply.map[17].size); |
| EXPECT_EQ(0UL, reply.map[17].depth); |
| } |
| |
| } // namespace zxdb |