src/tools/windows/dump_syms/dump_syms_unittest.cc - breakpad - Git at Google

 // Copyright 2003 Google Inc. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include <Windows.h>
 #include <shellapi.h>

 #include <string>
 #include <utility>

 #include "breakpad_googletest_includes.h"

 namespace tools {
 namespace windows {
 namespace dump_syms {

 namespace {

 // Root names of PDB and dumped symbol files to be regression tested. These are
 // specified in complexity of the resulting dumped symbol files.
 const wchar_t* kRootNames[] = {
   // A PDB file with no OMAP data.
   L"dump_syms_regtest",
   // A PDB file with OMAP data for an image that has been function-level
   // reordered.
   L"omap_reorder_funcs",
   // A PDB file with OMAP data for an image that had new content injected, all
   // of it with source data.
   L"omap_stretched_filled",
   // A PDB file with OMAP data for an image that had new content injected, but
   // without source data.
   L"omap_stretched",
   // A PDB file with OMAP data for an image that has been basic block reordered.
   L"omap_reorder_bbs",
   // A 64bit PDB file with no OMAP data.
   L"dump_syms_regtest64",
 };

 const wchar_t* kPEOnlyRootNames[] = {
   L"pe_only_symbol_test",
 };

 void TrimLastComponent(const std::wstring& path,
                        std::wstring* trimmed,
                        std::wstring* component) {
   size_t len = path.size();
   while (len > 0 && path[len - 1] != '\\')
     --len;

   if (component != NULL)
     component->assign(path.c_str() + len, path.c_str() + path.size());

   while (len > 0 && path[len - 1] == '\\')
     --len;

   if (trimmed != NULL)
     trimmed->assign(path.c_str(), len);
 }

 // Get the directory of the current executable.
 bool GetSelfDirectory(std::wstring* self_dir) {
   std::wstring command_line = GetCommandLineW();

   int num_args = 0;
   wchar_t** args = NULL;
   args = ::CommandLineToArgvW(command_line.c_str(), &num_args);
   if (args == NULL)
     return false;

   *self_dir = args[0];
   TrimLastComponent(*self_dir, self_dir, NULL);

   return true;
 }

 void RunCommand(const std::wstring& command_line,
                 std::string* stdout_string) {
   // Create a PIPE for the child process stdout.
   HANDLE child_stdout_read = 0;
   HANDLE child_stdout_write = 0;
   SECURITY_ATTRIBUTES sec_attr_stdout = {};
   sec_attr_stdout.nLength = sizeof(sec_attr_stdout);
   sec_attr_stdout.bInheritHandle = TRUE;
   ASSERT_TRUE(::CreatePipe(&child_stdout_read, &child_stdout_write,
                            &sec_attr_stdout, 0));
   ASSERT_TRUE(::SetHandleInformation(child_stdout_read, HANDLE_FLAG_INHERIT,
                                      0));

   // Create a PIPE for the child process stdin.
   HANDLE child_stdin_read = 0;
   HANDLE child_stdin_write = 0;
   SECURITY_ATTRIBUTES sec_attr_stdin = {};
   sec_attr_stdin.nLength = sizeof(sec_attr_stdin);
   sec_attr_stdin.bInheritHandle = TRUE;
   ASSERT_TRUE(::CreatePipe(&child_stdin_read, &child_stdin_write,
                            &sec_attr_stdin, 0));
   ASSERT_TRUE(::SetHandleInformation(child_stdin_write, HANDLE_FLAG_INHERIT,
                                      0));

   // Startup the child.
   STARTUPINFO startup_info = {};
   PROCESS_INFORMATION process_info = {};
   startup_info.cb = sizeof(STARTUPINFO);
   startup_info.hStdError = NULL;
   startup_info.hStdInput = child_stdin_read;
   startup_info.hStdOutput = child_stdout_write;
   startup_info.dwFlags = STARTF_USESTDHANDLES;
   ASSERT_TRUE(::CreateProcessW(NULL, (LPWSTR)command_line.c_str(), NULL, NULL,
                                TRUE, 0, NULL, NULL,
                                &startup_info, &process_info));

   // Collect the output.
   ASSERT_TRUE(::CloseHandle(child_stdout_write));
   char buffer[4096] = {};
   DWORD bytes_read = 0;
   while (::ReadFile(child_stdout_read, buffer, sizeof(buffer), &bytes_read,
                     NULL) && bytes_read > 0) {
     stdout_string->append(buffer, bytes_read);
   }

   // Wait for the process to finish.
   ::WaitForSingleObject(process_info.hProcess, INFINITE);

   // Shut down all of our handles.
   ASSERT_TRUE(::CloseHandle(process_info.hThread));
   ASSERT_TRUE(::CloseHandle(process_info.hProcess));
   ASSERT_TRUE(::CloseHandle(child_stdin_write));
   ASSERT_TRUE(::CloseHandle(child_stdin_read));
   ASSERT_TRUE(::CloseHandle(child_stdout_read));
 }

 void GetFileContents(const std::wstring& path, std::string* content) {
   FILE* f = ::_wfopen(path.c_str(), L"rb");
   ASSERT_TRUE(f != NULL);

   char buffer[4096] = {};
   while (true) {
     size_t bytes_read = ::fread(buffer, 1, sizeof(buffer), f);
     if (bytes_read == 0)
       break;
     content->append(buffer, bytes_read);
   }
 }

 class DumpSymsRegressionTest : public testing::TestWithParam<const wchar_t *> {
  public:
   virtual void SetUp() {
     std::wstring self_dir;
     ASSERT_TRUE(GetSelfDirectory(&self_dir));
     dump_syms_exe = self_dir + L"\\dump_syms.exe";

     TrimLastComponent(self_dir, &testdata_dir, NULL);
     testdata_dir += L"\\testdata";
   }

   std::wstring dump_syms_exe;
   std::wstring testdata_dir;
 };

 class DumpSymsPEOnlyRegressionTest : public testing::TestWithParam<const wchar_t *> {
 public:
   virtual void SetUp() {
     std::wstring self_dir;
     ASSERT_TRUE(GetSelfDirectory(&self_dir));
     dump_syms_exe = self_dir + L"\\dump_syms.exe";

     TrimLastComponent(self_dir, &testdata_dir, NULL);
     testdata_dir += L"\\testdata";
   }

   std::wstring dump_syms_exe;
   std::wstring testdata_dir;
 };

 }  //namespace

 TEST_P(DumpSymsRegressionTest, EnsureDumpedSymbolsMatch) {
   const wchar_t* root_name = GetParam();
   std::wstring root_path = testdata_dir + L"\\" + root_name;

   std::wstring sym_path = root_path + L".sym";
   std::string expected_symbols;
   ASSERT_NO_FATAL_FAILURE(GetFileContents(sym_path, &expected_symbols));

   std::wstring pdb_path = root_path + L".pdb";
   std::wstring command_line = L"\"" + dump_syms_exe + L"\" \"" +
     pdb_path + L"\"";
   std::string symbols;
   ASSERT_NO_FATAL_FAILURE(RunCommand(command_line, &symbols));

   EXPECT_EQ(expected_symbols, symbols);
 }

 INSTANTIATE_TEST_CASE_P(DumpSyms, DumpSymsRegressionTest,
   testing::ValuesIn(kRootNames));

 TEST_P(DumpSymsPEOnlyRegressionTest, EnsurePEOnlyDumpedSymbolsMatch) {
   const wchar_t* root_name = GetParam();
   std::wstring root_path = testdata_dir + L"\\" + root_name;

   std::wstring sym_path = root_path + L".sym";
   std::string expected_symbols;
   ASSERT_NO_FATAL_FAILURE(GetFileContents(sym_path, &expected_symbols));

   std::wstring dll_path = root_path + L".dll";
   std::wstring command_line = L"\"" + dump_syms_exe + L"\" --pe \"" +
     dll_path + L"\"";
   std::string symbols;
   ASSERT_NO_FATAL_FAILURE(RunCommand(command_line, &symbols));

   EXPECT_EQ(expected_symbols, symbols);
 }

 INSTANTIATE_TEST_CASE_P(PEOnlyDumpSyms, DumpSymsPEOnlyRegressionTest,
   testing::ValuesIn(kPEOnlyRootNames));


 }  // namespace dump_syms
 }  // namespace windows
 }  // namespace tools
	// Copyright 2003 Google Inc. All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following disclaimer
	// in the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#include <Windows.h>
	#include <shellapi.h>

	#include <string>
	#include <utility>

	#include "breakpad_googletest_includes.h"

	namespace tools {
	namespace windows {
	namespace dump_syms {

	namespace {

	// Root names of PDB and dumped symbol files to be regression tested. These are
	// specified in complexity of the resulting dumped symbol files.
	const wchar_t* kRootNames[] = {
	// A PDB file with no OMAP data.
	L"dump_syms_regtest",
	// A PDB file with OMAP data for an image that has been function-level
	// reordered.
	L"omap_reorder_funcs",
	// A PDB file with OMAP data for an image that had new content injected, all
	// of it with source data.
	L"omap_stretched_filled",
	// A PDB file with OMAP data for an image that had new content injected, but
	// without source data.
	L"omap_stretched",
	// A PDB file with OMAP data for an image that has been basic block reordered.
	L"omap_reorder_bbs",
	// A 64bit PDB file with no OMAP data.
	L"dump_syms_regtest64",
	};

	const wchar_t* kPEOnlyRootNames[] = {
	L"pe_only_symbol_test",
	};

	void TrimLastComponent(const std::wstring& path,
	std::wstring* trimmed,
	std::wstring* component) {
	size_t len = path.size();
	while (len > 0 && path[len - 1] != '\\')
	--len;

	if (component != NULL)
	component->assign(path.c_str() + len, path.c_str() + path.size());

	while (len > 0 && path[len - 1] == '\\')
	--len;

	if (trimmed != NULL)
	trimmed->assign(path.c_str(), len);
	}

	// Get the directory of the current executable.
	bool GetSelfDirectory(std::wstring* self_dir) {
	std::wstring command_line = GetCommandLineW();

	int num_args = 0;
	wchar_t** args = NULL;
	args = ::CommandLineToArgvW(command_line.c_str(), &num_args);
	if (args == NULL)
	return false;

	*self_dir = args[0];
	TrimLastComponent(*self_dir, self_dir, NULL);

	return true;
	}

	void RunCommand(const std::wstring& command_line,
	std::string* stdout_string) {
	// Create a PIPE for the child process stdout.
	HANDLE child_stdout_read = 0;
	HANDLE child_stdout_write = 0;
	SECURITY_ATTRIBUTES sec_attr_stdout = {};
	sec_attr_stdout.nLength = sizeof(sec_attr_stdout);
	sec_attr_stdout.bInheritHandle = TRUE;
	ASSERT_TRUE(::CreatePipe(&child_stdout_read, &child_stdout_write,
	&sec_attr_stdout, 0));
	ASSERT_TRUE(::SetHandleInformation(child_stdout_read, HANDLE_FLAG_INHERIT,
	0));

	// Create a PIPE for the child process stdin.
	HANDLE child_stdin_read = 0;
	HANDLE child_stdin_write = 0;
	SECURITY_ATTRIBUTES sec_attr_stdin = {};
	sec_attr_stdin.nLength = sizeof(sec_attr_stdin);
	sec_attr_stdin.bInheritHandle = TRUE;
	ASSERT_TRUE(::CreatePipe(&child_stdin_read, &child_stdin_write,
	&sec_attr_stdin, 0));
	ASSERT_TRUE(::SetHandleInformation(child_stdin_write, HANDLE_FLAG_INHERIT,
	0));

	// Startup the child.
	STARTUPINFO startup_info = {};
	PROCESS_INFORMATION process_info = {};
	startup_info.cb = sizeof(STARTUPINFO);
	startup_info.hStdError = NULL;
	startup_info.hStdInput = child_stdin_read;
	startup_info.hStdOutput = child_stdout_write;
	startup_info.dwFlags = STARTF_USESTDHANDLES;
	ASSERT_TRUE(::CreateProcessW(NULL, (LPWSTR)command_line.c_str(), NULL, NULL,
	TRUE, 0, NULL, NULL,
	&startup_info, &process_info));

	// Collect the output.
	ASSERT_TRUE(::CloseHandle(child_stdout_write));
	char buffer[4096] = {};
	DWORD bytes_read = 0;
	while (::ReadFile(child_stdout_read, buffer, sizeof(buffer), &bytes_read,
	NULL) && bytes_read > 0) {
	stdout_string->append(buffer, bytes_read);
	}

	// Wait for the process to finish.
	::WaitForSingleObject(process_info.hProcess, INFINITE);

	// Shut down all of our handles.
	ASSERT_TRUE(::CloseHandle(process_info.hThread));
	ASSERT_TRUE(::CloseHandle(process_info.hProcess));
	ASSERT_TRUE(::CloseHandle(child_stdin_write));
	ASSERT_TRUE(::CloseHandle(child_stdin_read));
	ASSERT_TRUE(::CloseHandle(child_stdout_read));
	}

	void GetFileContents(const std::wstring& path, std::string* content) {
	FILE* f = ::_wfopen(path.c_str(), L"rb");
	ASSERT_TRUE(f != NULL);

	char buffer[4096] = {};
	while (true) {
	size_t bytes_read = ::fread(buffer, 1, sizeof(buffer), f);
	if (bytes_read == 0)
	break;
	content->append(buffer, bytes_read);
	}
	}

	class DumpSymsRegressionTest : public testing::TestWithParam<const wchar_t *> {
	public:
	virtual void SetUp() {
	std::wstring self_dir;
	ASSERT_TRUE(GetSelfDirectory(&self_dir));
	dump_syms_exe = self_dir + L"\\dump_syms.exe";

	TrimLastComponent(self_dir, &testdata_dir, NULL);
	testdata_dir += L"\\testdata";
	}

	std::wstring dump_syms_exe;
	std::wstring testdata_dir;
	};

	class DumpSymsPEOnlyRegressionTest : public testing::TestWithParam<const wchar_t *> {
	public:
	virtual void SetUp() {
	std::wstring self_dir;
	ASSERT_TRUE(GetSelfDirectory(&self_dir));
	dump_syms_exe = self_dir + L"\\dump_syms.exe";

	TrimLastComponent(self_dir, &testdata_dir, NULL);
	testdata_dir += L"\\testdata";
	}

	std::wstring dump_syms_exe;
	std::wstring testdata_dir;
	};

	} //namespace

	TEST_P(DumpSymsRegressionTest, EnsureDumpedSymbolsMatch) {
	const wchar_t* root_name = GetParam();
	std::wstring root_path = testdata_dir + L"\\" + root_name;

	std::wstring sym_path = root_path + L".sym";
	std::string expected_symbols;
	ASSERT_NO_FATAL_FAILURE(GetFileContents(sym_path, &expected_symbols));

	std::wstring pdb_path = root_path + L".pdb";
	std::wstring command_line = L"\"" + dump_syms_exe + L"\" \"" +
	pdb_path + L"\"";
	std::string symbols;
	ASSERT_NO_FATAL_FAILURE(RunCommand(command_line, &symbols));

	EXPECT_EQ(expected_symbols, symbols);
	}

	INSTANTIATE_TEST_CASE_P(DumpSyms, DumpSymsRegressionTest,
	testing::ValuesIn(kRootNames));

	TEST_P(DumpSymsPEOnlyRegressionTest, EnsurePEOnlyDumpedSymbolsMatch) {
	const wchar_t* root_name = GetParam();
	std::wstring root_path = testdata_dir + L"\\" + root_name;

	std::wstring sym_path = root_path + L".sym";
	std::string expected_symbols;
	ASSERT_NO_FATAL_FAILURE(GetFileContents(sym_path, &expected_symbols));

	std::wstring dll_path = root_path + L".dll";
	std::wstring command_line = L"\"" + dump_syms_exe + L"\" --pe \"" +
	dll_path + L"\"";
	std::string symbols;
	ASSERT_NO_FATAL_FAILURE(RunCommand(command_line, &symbols));

	EXPECT_EQ(expected_symbols, symbols);
	}

	INSTANTIATE_TEST_CASE_P(PEOnlyDumpSyms, DumpSymsPEOnlyRegressionTest,
	testing::ValuesIn(kPEOnlyRootNames));


	} // namespace dump_syms
	} // namespace windows
	} // namespace tools