Added a death test for the pure virtual function call....

src/client/windows/unittests/exception_handler_death_test.cc

 // Copyright 2009, 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
@@ skipping 35 matching lines @@
 BOOL DoesPathExist(const TCHAR *path_name);
 
 class ExceptionHandlerDeathTest : public ::testing::Test {
  protected:
   // Member variable for each test that they can use
   // for temporary storage.
   TCHAR temp_path_[MAX_PATH];
   // Actually constructs a temp path name.
   virtual void SetUp();
   // A helper method that tests can use to crash.
-  void DoCrash();
+  void DoCrashAccessViolation();
+  void DoCrashPureVirtualCall();
 };
 
 void ExceptionHandlerDeathTest::SetUp() {
   const ::testing::TestInfo* const test_info =
     ::testing::UnitTest::GetInstance()->current_test_info();
   TCHAR temp_path[MAX_PATH] = { '\0' };
   TCHAR test_name_wide[MAX_PATH] = { '\0' };
   // We want the temporary directory to be what the OS returns
   // to us, + the test case name.
   GetTempPath(MAX_PATH, temp_path);
@@ skipping 52 matching lines @@
 }
 
 static bool gDumpCallbackCalled = false;
 
 void clientDumpCallback(void *dump_context,
                         const google_breakpad::ClientInfo *client_info,
                         const std::wstring *dump_path) {
   gDumpCallbackCalled = true;
 }
 
-void ExceptionHandlerDeathTest::DoCrash() {
+void ExceptionHandlerDeathTest::DoCrashAccessViolation() {
   google_breakpad::ExceptionHandler *exc =
     new google_breakpad::ExceptionHandler(
     temp_path_, NULL, NULL, NULL,
     google_breakpad::ExceptionHandler::HANDLER_ALL, MiniDumpNormal, kPipeName,
     NULL);
   // Although this is executing in the child process of the death test,
   // if it's not true we'll still get an error rather than the crash
   // being expected.
   ASSERT_TRUE(exc->IsOutOfProcess());
   int *i = NULL;
@@ skipping 13 matching lines @@
   std::wstring dump_path(temp_path_);
   google_breakpad::CrashGenerationServer server(
     kPipeName, NULL, NULL, NULL, &clientDumpCallback, NULL, NULL, NULL, true,
     &dump_path);
 
   // This HAS to be EXPECT_, because when this test case is executed in the
   // child process, the server registration will fail due to the named pipe
   // being the same.
   EXPECT_TRUE(server.Start());
   EXPECT_FALSE(gDumpCallbackCalled);
-  ASSERT_DEATH(this->DoCrash(), "");
+  ASSERT_DEATH(this->DoCrashAccessViolation(), "");
   EXPECT_TRUE(gDumpCallbackCalled);
 }
 
 TEST_F(ExceptionHandlerDeathTest, InvalidParameterTest) {
   using google_breakpad::ExceptionHandler;
 
   ASSERT_TRUE(DoesPathExist(temp_path_));
   ExceptionHandler handler(temp_path_, NULL, NULL, NULL,
                            ExceptionHandler::HANDLER_INVALID_PARAMETER);
 
   // Disable the message box for assertions
   _CrtSetReportMode(_CRT_ASSERT, 0);
 
   // Call with a bad argument. The invalid parameter will be swallowed
   // and a dump will be generated, the process will exit(0).
   ASSERT_EXIT(printf(NULL), ::testing::ExitedWithCode(0), "");
 }
+
+
+struct PureVirtualCallBase {
+  PureVirtualCallBase() {
+    // We have to reinterpret so the linker doesn't get confused because the
+    // method isn't defined.
+    reinterpret_cast<PureVirtualCallBase*>(this)->PureFunction();

[Sigurður Ásgeirsson, 2010/05/13 20:57:10]

Really? How weird.

+  }
+  virtual ~PureVirtualCallBase() {}
+  virtual void PureFunction() const = 0;
+};
+struct PureVirtualCall : public PureVirtualCallBase {
+  PureVirtualCall() { PureFunction(); }
+  virtual void PureFunction() const {}
+};
+
+void ExceptionHandlerDeathTest::DoCrashPureVirtualCall() {
+  PureVirtualCall instance;
 }
+
+TEST_F(ExceptionHandlerDeathTest, PureVirtualCallTest) {
+  using google_breakpad::ExceptionHandler;
+
+  ASSERT_TRUE(DoesPathExist(temp_path_));
+  ExceptionHandler handler(temp_path_, NULL, NULL, NULL,
+                           ExceptionHandler::HANDLER_PURECALL);
+
+  // Disable the message box for assertions
+  _CrtSetReportMode(_CRT_ASSERT, 0);
+
+  // Calls a pure virtual function.
+  EXPECT_EXIT(DoCrashPureVirtualCall(), ::testing::ExitedWithCode(0), "");
+}
+}