client/ios_handler/in_process_intermediate_dump_handler_test.cc - third_party/crashpad - Git at Google

 // Copyright 2021 The Crashpad Authors
 //
 // 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 "client/ios_handler/in_process_intermediate_dump_handler.h"

 #include <sys/utsname.h>

 #include <iterator>

 #include "base/files/file_path.h"
 #include "build/build_config.h"
 #include "client/annotation.h"
 #include "client/annotation_list.h"
 #include "client/crashpad_info.h"
 #include "client/simple_string_dictionary.h"
 #include "gtest/gtest.h"
 #include "snapshot/ios/process_snapshot_ios_intermediate_dump.h"
 #include "test/scoped_set_thread_name.h"
 #include "test/scoped_temp_dir.h"
 #include "test/test_paths.h"
 #include "util/file/filesystem.h"
 #include "util/misc/capture_context.h"

 namespace crashpad {
 namespace test {
 namespace {

 using internal::InProcessIntermediateDumpHandler;

 class InProcessIntermediateDumpHandlerTest : public testing::Test {
  protected:
   // testing::Test:

   void SetUp() override {
     path_ = temp_dir_.path().Append("dump_file");
     writer_ = std::make_unique<internal::IOSIntermediateDumpWriter>();
     EXPECT_TRUE(writer_->Open(path_));
     ASSERT_TRUE(IsRegularFile(path_));
   }

   void TearDown() override {
     EXPECT_TRUE(writer_->Close());
     writer_.reset();
     EXPECT_FALSE(IsRegularFile(path_));
   }

   void WriteReportAndCloseWriter() {
     {
       internal::IOSIntermediateDumpWriter::ScopedRootMap rootMap(writer_.get());
       InProcessIntermediateDumpHandler::WriteHeader(writer_.get());
       InProcessIntermediateDumpHandler::WriteProcessInfo(
           writer_.get(), {{"before_dump", "pre"}});
       InProcessIntermediateDumpHandler::WriteSystemInfo(
           writer_.get(), system_data_, ClockMonotonicNanoseconds());
       InProcessIntermediateDumpHandler::WriteThreadInfo(writer_.get(), 0, 0);
       InProcessIntermediateDumpHandler::WriteModuleInfo(writer_.get());
     }
     EXPECT_TRUE(writer_->Close());
   }

   void WriteMachException() {
     crashpad::NativeCPUContext cpu_context;
     crashpad::CaptureContext(&cpu_context);
     const mach_exception_data_type_t code[2] = {};
     static constexpr int kSimulatedException = -1;
     InProcessIntermediateDumpHandler::WriteExceptionFromMachException(
         writer_.get(),
         MACH_EXCEPTION_CODES,
         mach_thread_self(),
         kSimulatedException,
         code,
         std::size(code),
         MACHINE_THREAD_STATE,
         reinterpret_cast<ConstThreadState>(&cpu_context),
         MACHINE_THREAD_STATE_COUNT);
   }

   const auto& path() const { return path_; }
   auto writer() const { return writer_.get(); }

 #if TARGET_OS_SIMULATOR
   // macOS 14.0 is 23A344, macOS 13.6.5 is 22G621, so if the first two
   // characters in the kern.osversion are > 22, this build will reproduce the
   // simulator bug in crbug.com/328282286
   bool IsMacOSVersion143OrGreaterAndiOS16OrLess() {
     if (__builtin_available(iOS 17, *)) {
       return false;
     }
     return std::stoi(system_data_.Build().substr(0, 2)) > 22;
   }
 #endif

  private:
   std::unique_ptr<internal::IOSIntermediateDumpWriter> writer_;
   internal::IOSSystemDataCollector system_data_;
   ScopedTempDir temp_dir_;
   base::FilePath path_;
 };

 TEST_F(InProcessIntermediateDumpHandlerTest, TestSystem) {
   WriteReportAndCloseWriter();
   internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
   ASSERT_TRUE(process_snapshot.InitializeWithFilePath(path(), {}));

   // Snpahot
   const SystemSnapshot* system = process_snapshot.System();
   ASSERT_NE(system, nullptr);
 #if defined(ARCH_CPU_X86_64)
   EXPECT_EQ(system->GetCPUArchitecture(), kCPUArchitectureX86_64);
   EXPECT_STREQ(system->CPUVendor().c_str(), "GenuineIntel");
 #elif defined(ARCH_CPU_ARM64)
   EXPECT_EQ(system->GetCPUArchitecture(), kCPUArchitectureARM64);
 #else
 #error Port to your CPU architecture
 #endif
 #if TARGET_OS_SIMULATOR
   EXPECT_EQ(system->MachineDescription().substr(0, 13),
             std::string("iOS Simulator"));
 #elif TARGET_OS_IPHONE
   utsname uts;
   ASSERT_EQ(uname(&uts), 0);
   EXPECT_STREQ(system->MachineDescription().c_str(), uts.machine);
 #endif

   EXPECT_EQ(system->GetOperatingSystem(), SystemSnapshot::kOperatingSystemIOS);
 }

 TEST_F(InProcessIntermediateDumpHandlerTest, TestAnnotations) {
 #if TARGET_OS_SIMULATOR
   // This test will fail on older (<iOS17 simulators) when running on macOS 14.3
   // or newer due to a bug in Simulator. crbug.com/328282286
   if (IsMacOSVersion143OrGreaterAndiOS16OrLess()) {
     // For TearDown.
     ASSERT_TRUE(LoggingRemoveFile(path()));
     return;
   }
 #endif
   // This is “leaked” to crashpad_info.
   crashpad::SimpleStringDictionary* simple_annotations =
       new crashpad::SimpleStringDictionary();
   simple_annotations->SetKeyValue("#TEST# pad", "break");
   simple_annotations->SetKeyValue("#TEST# key", "value");
   simple_annotations->SetKeyValue("#TEST# pad", "crash");
   simple_annotations->SetKeyValue("#TEST# x", "y");
   simple_annotations->SetKeyValue("#TEST# longer", "shorter");
   simple_annotations->SetKeyValue("#TEST# empty_value", "");

   crashpad::CrashpadInfo* crashpad_info =
       crashpad::CrashpadInfo::GetCrashpadInfo();

   crashpad_info->set_simple_annotations(simple_annotations);

   crashpad::AnnotationList::Register();  // This is “leaked” to crashpad_info.

   static crashpad::StringAnnotation<32> test_annotation_one{"#TEST# one"};
   static crashpad::StringAnnotation<32> test_annotation_two{"#TEST# two"};
   static crashpad::StringAnnotation<32> test_annotation_three{
       "#TEST# same-name"};
   static crashpad::StringAnnotation<32> test_annotation_four{
       "#TEST# same-name"};

   test_annotation_one.Set("moocow");
   test_annotation_two.Set("this will be cleared");
   test_annotation_three.Set("same-name 3");
   test_annotation_four.Set("same-name 4");
   test_annotation_two.Clear();

   WriteReportAndCloseWriter();
   internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
   ASSERT_TRUE(process_snapshot.InitializeWithFilePath(
       path(), {{"after_dump", "post"}}));

   auto process_map = process_snapshot.AnnotationsSimpleMap();
   EXPECT_EQ(process_map.size(), 3u);
   EXPECT_EQ(process_map["before_dump"], "pre");
   EXPECT_EQ(process_map["after_dump"], "post");
   EXPECT_TRUE(process_map.find("crashpad_uptime_ns") != process_map.end());

   std::map<std::string, std::string> all_annotations_simple_map;
   std::vector<AnnotationSnapshot> all_annotations;
   for (const auto* module : process_snapshot.Modules()) {
     std::map<std::string, std::string> module_annotations_simple_map =
         module->AnnotationsSimpleMap();
     all_annotations_simple_map.insert(module_annotations_simple_map.begin(),
                                       module_annotations_simple_map.end());

     std::vector<AnnotationSnapshot> annotations = module->AnnotationObjects();
     all_annotations.insert(
         all_annotations.end(), annotations.begin(), annotations.end());
   }

   EXPECT_EQ(all_annotations_simple_map.size(), 5u);
   EXPECT_EQ(all_annotations_simple_map["#TEST# pad"], "crash");
   EXPECT_EQ(all_annotations_simple_map["#TEST# key"], "value");
   EXPECT_EQ(all_annotations_simple_map["#TEST# x"], "y");
   EXPECT_EQ(all_annotations_simple_map["#TEST# longer"], "shorter");
   EXPECT_EQ(all_annotations_simple_map["#TEST# empty_value"], "");

   bool saw_same_name_3 = false, saw_same_name_4 = false;
   for (const auto& annotation : all_annotations) {
     EXPECT_EQ(annotation.type,
               static_cast<uint16_t>(Annotation::Type::kString));
     std::string value(reinterpret_cast<const char*>(annotation.value.data()),
                       annotation.value.size());
     if (annotation.name == "#TEST# one") {
       EXPECT_EQ(value, "moocow");
     } else if (annotation.name == "#TEST# same-name") {
       if (value == "same-name 3") {
         EXPECT_FALSE(saw_same_name_3);
         saw_same_name_3 = true;
       } else if (value == "same-name 4") {
         EXPECT_FALSE(saw_same_name_4);
         saw_same_name_4 = true;
       } else {
         ADD_FAILURE() << "unexpected annotation value " << value;
       }
     } else {
       ADD_FAILURE() << "unexpected annotation " << annotation.name;
     }
   }
 }

 TEST_F(InProcessIntermediateDumpHandlerTest, TestThreads) {
   const ScopedSetThreadName scoped_set_thread_name("TestThreads");

   WriteReportAndCloseWriter();
   internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
   ASSERT_TRUE(process_snapshot.InitializeWithFilePath(path(), {}));

   const auto& threads = process_snapshot.Threads();
   ASSERT_GT(threads.size(), 0u);

   thread_identifier_info identifier_info;
   mach_msg_type_number_t count = THREAD_IDENTIFIER_INFO_COUNT;
   ASSERT_EQ(thread_info(mach_thread_self(),
                         THREAD_IDENTIFIER_INFO,
                         reinterpret_cast<thread_info_t>(&identifier_info),
                         &count),
             0);
   EXPECT_EQ(threads[0]->ThreadID(), identifier_info.thread_id);
   EXPECT_EQ(threads[0]->ThreadName(), "TestThreads");
 }

 TEST_F(InProcessIntermediateDumpHandlerTest, TestProcess) {
   WriteReportAndCloseWriter();
   internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
   ASSERT_TRUE(process_snapshot.InitializeWithFilePath(path(), {}));
   EXPECT_EQ(process_snapshot.ProcessID(), getpid());
 }

 TEST_F(InProcessIntermediateDumpHandlerTest, TestMachException) {
   WriteReportAndCloseWriter();
   internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
   ASSERT_TRUE(process_snapshot.InitializeWithFilePath(path(), {}));
 }

 TEST_F(InProcessIntermediateDumpHandlerTest, TestSignalException) {
   WriteReportAndCloseWriter();
   internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
   ASSERT_TRUE(process_snapshot.InitializeWithFilePath(path(), {}));
 }

 TEST_F(InProcessIntermediateDumpHandlerTest, TestNSException) {
   WriteReportAndCloseWriter();
   internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
   ASSERT_TRUE(process_snapshot.InitializeWithFilePath(path(), {}));
 }

 }  // namespace
 }  // namespace test
 }  // namespace crashpad
	// Copyright 2021 The Crashpad Authors
	//
	// 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 "client/ios_handler/in_process_intermediate_dump_handler.h"

	#include <sys/utsname.h>

	#include <iterator>

	#include "base/files/file_path.h"
	#include "build/build_config.h"
	#include "client/annotation.h"
	#include "client/annotation_list.h"
	#include "client/crashpad_info.h"
	#include "client/simple_string_dictionary.h"
	#include "gtest/gtest.h"
	#include "snapshot/ios/process_snapshot_ios_intermediate_dump.h"
	#include "test/scoped_set_thread_name.h"
	#include "test/scoped_temp_dir.h"
	#include "test/test_paths.h"
	#include "util/file/filesystem.h"
	#include "util/misc/capture_context.h"

	namespace crashpad {
	namespace test {
	namespace {

	using internal::InProcessIntermediateDumpHandler;

	class InProcessIntermediateDumpHandlerTest : public testing::Test {
	protected:
	// testing::Test:

	void SetUp() override {
	path_ = temp_dir_.path().Append("dump_file");
	writer_ = std::make_unique<internal::IOSIntermediateDumpWriter>();
	EXPECT_TRUE(writer_->Open(path_));
	ASSERT_TRUE(IsRegularFile(path_));
	}

	void TearDown() override {
	EXPECT_TRUE(writer_->Close());
	writer_.reset();
	EXPECT_FALSE(IsRegularFile(path_));
	}

	void WriteReportAndCloseWriter() {
	{
	internal::IOSIntermediateDumpWriter::ScopedRootMap rootMap(writer_.get());
	InProcessIntermediateDumpHandler::WriteHeader(writer_.get());
	InProcessIntermediateDumpHandler::WriteProcessInfo(
	writer_.get(), {{"before_dump", "pre"}});
	InProcessIntermediateDumpHandler::WriteSystemInfo(
	writer_.get(), system_data_, ClockMonotonicNanoseconds());
	InProcessIntermediateDumpHandler::WriteThreadInfo(writer_.get(), 0, 0);
	InProcessIntermediateDumpHandler::WriteModuleInfo(writer_.get());
	}
	EXPECT_TRUE(writer_->Close());
	}

	void WriteMachException() {
	crashpad::NativeCPUContext cpu_context;
	crashpad::CaptureContext(&cpu_context);
	const mach_exception_data_type_t code[2] = {};
	static constexpr int kSimulatedException = -1;
	InProcessIntermediateDumpHandler::WriteExceptionFromMachException(
	writer_.get(),
	MACH_EXCEPTION_CODES,
	mach_thread_self(),
	kSimulatedException,
	code,
	std::size(code),
	MACHINE_THREAD_STATE,
	reinterpret_cast<ConstThreadState>(&cpu_context),
	MACHINE_THREAD_STATE_COUNT);
	}

	const auto& path() const { return path_; }
	auto writer() const { return writer_.get(); }

	#if TARGET_OS_SIMULATOR
	// macOS 14.0 is 23A344, macOS 13.6.5 is 22G621, so if the first two
	// characters in the kern.osversion are > 22, this build will reproduce the
	// simulator bug in crbug.com/328282286
	bool IsMacOSVersion143OrGreaterAndiOS16OrLess() {
	if (__builtin_available(iOS 17, *)) {
	return false;
	}
	return std::stoi(system_data_.Build().substr(0, 2)) > 22;
	}
	#endif

	private:
	std::unique_ptr<internal::IOSIntermediateDumpWriter> writer_;
	internal::IOSSystemDataCollector system_data_;
	ScopedTempDir temp_dir_;
	base::FilePath path_;
	};

	TEST_F(InProcessIntermediateDumpHandlerTest, TestSystem) {
	WriteReportAndCloseWriter();
	internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
	ASSERT_TRUE(process_snapshot.InitializeWithFilePath(path(), {}));

	// Snpahot
	const SystemSnapshot* system = process_snapshot.System();
	ASSERT_NE(system, nullptr);
	#if defined(ARCH_CPU_X86_64)
	EXPECT_EQ(system->GetCPUArchitecture(), kCPUArchitectureX86_64);
	EXPECT_STREQ(system->CPUVendor().c_str(), "GenuineIntel");
	#elif defined(ARCH_CPU_ARM64)
	EXPECT_EQ(system->GetCPUArchitecture(), kCPUArchitectureARM64);
	#else
	#error Port to your CPU architecture
	#endif
	#if TARGET_OS_SIMULATOR
	EXPECT_EQ(system->MachineDescription().substr(0, 13),
	std::string("iOS Simulator"));
	#elif TARGET_OS_IPHONE
	utsname uts;
	ASSERT_EQ(uname(&uts), 0);
	EXPECT_STREQ(system->MachineDescription().c_str(), uts.machine);
	#endif

	EXPECT_EQ(system->GetOperatingSystem(), SystemSnapshot::kOperatingSystemIOS);
	}

	TEST_F(InProcessIntermediateDumpHandlerTest, TestAnnotations) {
	#if TARGET_OS_SIMULATOR
	// This test will fail on older (<iOS17 simulators) when running on macOS 14.3
	// or newer due to a bug in Simulator. crbug.com/328282286
	if (IsMacOSVersion143OrGreaterAndiOS16OrLess()) {
	// For TearDown.
	ASSERT_TRUE(LoggingRemoveFile(path()));
	return;
	}
	#endif
	// This is “leaked” to crashpad_info.
	crashpad::SimpleStringDictionary* simple_annotations =
	new crashpad::SimpleStringDictionary();
	simple_annotations->SetKeyValue("#TEST# pad", "break");
	simple_annotations->SetKeyValue("#TEST# key", "value");
	simple_annotations->SetKeyValue("#TEST# pad", "crash");
	simple_annotations->SetKeyValue("#TEST# x", "y");
	simple_annotations->SetKeyValue("#TEST# longer", "shorter");
	simple_annotations->SetKeyValue("#TEST# empty_value", "");

	crashpad::CrashpadInfo* crashpad_info =
	crashpad::CrashpadInfo::GetCrashpadInfo();

	crashpad_info->set_simple_annotations(simple_annotations);

	crashpad::AnnotationList::Register(); // This is “leaked” to crashpad_info.

	static crashpad::StringAnnotation<32> test_annotation_one{"#TEST# one"};
	static crashpad::StringAnnotation<32> test_annotation_two{"#TEST# two"};
	static crashpad::StringAnnotation<32> test_annotation_three{
	"#TEST# same-name"};
	static crashpad::StringAnnotation<32> test_annotation_four{
	"#TEST# same-name"};

	test_annotation_one.Set("moocow");
	test_annotation_two.Set("this will be cleared");
	test_annotation_three.Set("same-name 3");
	test_annotation_four.Set("same-name 4");
	test_annotation_two.Clear();

	WriteReportAndCloseWriter();
	internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
	ASSERT_TRUE(process_snapshot.InitializeWithFilePath(
	path(), {{"after_dump", "post"}}));

	auto process_map = process_snapshot.AnnotationsSimpleMap();
	EXPECT_EQ(process_map.size(), 3u);
	EXPECT_EQ(process_map["before_dump"], "pre");
	EXPECT_EQ(process_map["after_dump"], "post");
	EXPECT_TRUE(process_map.find("crashpad_uptime_ns") != process_map.end());

	std::map<std::string, std::string> all_annotations_simple_map;
	std::vector<AnnotationSnapshot> all_annotations;
	for (const auto* module : process_snapshot.Modules()) {
	std::map<std::string, std::string> module_annotations_simple_map =
	module->AnnotationsSimpleMap();
	all_annotations_simple_map.insert(module_annotations_simple_map.begin(),
	module_annotations_simple_map.end());

	std::vector<AnnotationSnapshot> annotations = module->AnnotationObjects();
	all_annotations.insert(
	all_annotations.end(), annotations.begin(), annotations.end());
	}

	EXPECT_EQ(all_annotations_simple_map.size(), 5u);
	EXPECT_EQ(all_annotations_simple_map["#TEST# pad"], "crash");
	EXPECT_EQ(all_annotations_simple_map["#TEST# key"], "value");
	EXPECT_EQ(all_annotations_simple_map["#TEST# x"], "y");
	EXPECT_EQ(all_annotations_simple_map["#TEST# longer"], "shorter");
	EXPECT_EQ(all_annotations_simple_map["#TEST# empty_value"], "");

	bool saw_same_name_3 = false, saw_same_name_4 = false;
	for (const auto& annotation : all_annotations) {
	EXPECT_EQ(annotation.type,
	static_cast<uint16_t>(Annotation::Type::kString));
	std::string value(reinterpret_cast<const char*>(annotation.value.data()),
	annotation.value.size());
	if (annotation.name == "#TEST# one") {
	EXPECT_EQ(value, "moocow");
	} else if (annotation.name == "#TEST# same-name") {
	if (value == "same-name 3") {
	EXPECT_FALSE(saw_same_name_3);
	saw_same_name_3 = true;
	} else if (value == "same-name 4") {
	EXPECT_FALSE(saw_same_name_4);
	saw_same_name_4 = true;
	} else {
	ADD_FAILURE() << "unexpected annotation value " << value;
	}
	} else {
	ADD_FAILURE() << "unexpected annotation " << annotation.name;
	}
	}
	}

	TEST_F(InProcessIntermediateDumpHandlerTest, TestThreads) {
	const ScopedSetThreadName scoped_set_thread_name("TestThreads");

	WriteReportAndCloseWriter();
	internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
	ASSERT_TRUE(process_snapshot.InitializeWithFilePath(path(), {}));

	const auto& threads = process_snapshot.Threads();
	ASSERT_GT(threads.size(), 0u);

	thread_identifier_info identifier_info;
	mach_msg_type_number_t count = THREAD_IDENTIFIER_INFO_COUNT;
	ASSERT_EQ(thread_info(mach_thread_self(),
	THREAD_IDENTIFIER_INFO,
	reinterpret_cast<thread_info_t>(&identifier_info),
	&count),
	0);
	EXPECT_EQ(threads[0]->ThreadID(), identifier_info.thread_id);
	EXPECT_EQ(threads[0]->ThreadName(), "TestThreads");
	}

	TEST_F(InProcessIntermediateDumpHandlerTest, TestProcess) {
	WriteReportAndCloseWriter();
	internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
	ASSERT_TRUE(process_snapshot.InitializeWithFilePath(path(), {}));
	EXPECT_EQ(process_snapshot.ProcessID(), getpid());
	}

	TEST_F(InProcessIntermediateDumpHandlerTest, TestMachException) {
	WriteReportAndCloseWriter();
	internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
	ASSERT_TRUE(process_snapshot.InitializeWithFilePath(path(), {}));
	}

	TEST_F(InProcessIntermediateDumpHandlerTest, TestSignalException) {
	WriteReportAndCloseWriter();
	internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
	ASSERT_TRUE(process_snapshot.InitializeWithFilePath(path(), {}));
	}

	TEST_F(InProcessIntermediateDumpHandlerTest, TestNSException) {
	WriteReportAndCloseWriter();
	internal::ProcessSnapshotIOSIntermediateDump process_snapshot;
	ASSERT_TRUE(process_snapshot.InitializeWithFilePath(path(), {}));
	}

	} // namespace
	} // namespace test
	} // namespace crashpad