// Copyright 2015 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.
#ifndef CRASHPAD_TEST_WIN_WIN_MULTIPROCESS_H_
#define CRASHPAD_TEST_WIN_WIN_MULTIPROCESS_H_
#include <windows.h>
#include "gtest/gtest.h"
#include "test/win/win_child_process.h"
#include "util/file/file_io.h"
#include "util/win/scoped_handle.h"
namespace crashpad {
namespace test {
//! \brief Manages a multiprocess test on Windows.
class WinMultiprocess {
public:
WinMultiprocess();
WinMultiprocess(const WinMultiprocess&) = delete;
WinMultiprocess& operator=(const WinMultiprocess&) = delete;
//! \brief Runs the test.
//!
//! This method establishes the testing environment by respawning the process
//! as a child with additional flags.
//!
//! In the parent process, WinMultiprocessParent() is run, and in the child
//! WinMultiprocessChild().
template <class T>
static void Run() {
ASSERT_NO_FATAL_FAILURE(
WinChildProcess::EntryPoint<ChildProcessHelper<T>>());
// If WinChildProcess::EntryPoint returns, we are in the parent process.
T parent_process;
WinMultiprocess* parent_multiprocess = &parent_process;
parent_multiprocess->WinMultiprocessParentBeforeChild();
std::unique_ptr<WinChildProcess::Handles> child_handles =
WinChildProcess::Launch();
ASSERT_TRUE(child_handles.get());
parent_process.child_handles_ = child_handles.get();
parent_multiprocess->WinMultiprocessParent();
// Close our side of the handles now that we're done. The child can
// use this to know when it's safe to complete.
child_handles->read.reset();
child_handles->write.reset();
// Wait for the child to complete.
ASSERT_EQ(WaitForSingleObject(child_handles->process.get(), INFINITE),
WAIT_OBJECT_0);
DWORD exit_code;
ASSERT_TRUE(GetExitCodeProcess(child_handles->process.get(), &exit_code));
ASSERT_EQ(exit_code, parent_process.exit_code_);
parent_multiprocess->WinMultiprocessParentAfterChild(
child_handles->process.get());
}
protected:
virtual ~WinMultiprocess();
//! \brief Sets the expected exit code of the child process.
//!
//! The default expected termination code is `EXIT_SUCCESS` (`0`).
//!
//! \param[in] exit_code The expected exit status of the child.
void SetExpectedChildExitCode(unsigned int exit_code);
//! \brief Returns the read pipe's file handle.
//!
//! This method may be called by either the parent or the child process.
//! Anything written to the write pipe in the partner process will appear
//! on this file handle in this process.
//!
//! It is an error to call this after CloseReadPipe() has been called.
//!
//! \return The read pipe's file handle.
FileHandle ReadPipeHandle() const;
//! \brief Returns the write pipe's file handle.
//!
//! This method may be called by either the parent or the child process.
//! Anything written to this file handle in this process will appear on
//! the read pipe in the partner process.
//!
//! It is an error to call this after CloseWritePipe() has been called.
//!
//! \return The write pipe's file handle.
FileHandle WritePipeHandle() const;
//! \brief Closes the read pipe.
//!
//! This method may be called by either the parent or the child process.
//! ReadPipeHandle() must not be called after this.
void CloseReadPipe();
//! \brief Closes the write pipe.
//!
//! This method may be called by either the parent or the child process. An
//! attempt to read from the read pipe in the partner process will indicate
//! end-of-file. WritePipeHandle() must not be called after this.
void CloseWritePipe();
//! \brief Returns a handle to the child process.
//!
//! This method may only be called by the parent process.
HANDLE ChildProcess() const;
private:
// Implements an adapter to provide WinMultiprocess with access to the
// anonymous pipe handles from WinChildProcess.
class ChildProcessHelperBase : public WinChildProcess {
public:
ChildProcessHelperBase() {}
ChildProcessHelperBase(const ChildProcessHelperBase&) = delete;
ChildProcessHelperBase& operator=(const ChildProcessHelperBase&) = delete;
~ChildProcessHelperBase() override {}
void CloseWritePipeForwarder() { CloseWritePipe(); }
void CloseReadPipeForwarder() { CloseReadPipe(); }
FileHandle ReadPipeHandleForwarder() const { return ReadPipeHandle(); }
FileHandle WritePipeHandleForwarder() const { return WritePipeHandle(); }
};
// Forwards WinChildProcess::Run to T::WinMultiprocessChild.
template <class T>
class ChildProcessHelper : public ChildProcessHelperBase {
public:
ChildProcessHelper() {}
ChildProcessHelper(const ChildProcessHelper&) = delete;
ChildProcessHelper& operator=(const ChildProcessHelper&) = delete;
~ChildProcessHelper() override {}
private:
int Run() override {
T child_process;
child_process.child_process_helper_ = this;
static_cast<WinMultiprocess*>(&child_process)->WinMultiprocessChild();
if (testing::Test::HasFailure())
return 255;
return EXIT_SUCCESS;
}
};
//! \brief The subclass-provided parent routine.
//!
//! Test failures should be reported via Google Test: `EXPECT_*()`,
//! `ASSERT_*()`, `FAIL()`, etc.
//!
//! This method need not use `WaitForSingleObject()`-family call to wait for
//! the child process to exit, as this is handled by this class.
//!
//! Subclasses must implement this method to define how the parent operates.
virtual void WinMultiprocessParent() = 0;
//! \brief The optional routine run in parent before the child is spawned.
//!
//! Subclasses may implement this method to prepare the environment for
//! the child process.
virtual void WinMultiprocessParentBeforeChild() {}
//! \brief The optional routine run in parent after the child exits.
//!
//! Subclasses may implement this method to clean up the environment after
//! the child process has exited.
//!
//! \param[in] child A handle to the exited child process.
virtual void WinMultiprocessParentAfterChild(HANDLE child) {}
//! \brief The subclass-provided child routine.
//!
//! Test failures should be reported via Google Test: `EXPECT_*()`,
//! `ASSERT_*()`, `FAIL()`, etc.
//!
//! Subclasses must implement this method to define how the child operates.
//! Subclasses may exit with a failure status by using `LOG(FATAL)`,
//! `abort()`, or similar. They may exit cleanly by returning from this
//! method.
virtual void WinMultiprocessChild() = 0;
unsigned int exit_code_;
WinChildProcess::Handles* child_handles_;
ChildProcessHelperBase* child_process_helper_;
};
} // namespace test
} // namespace crashpad
#endif // CRASHPAD_TEST_WIN_WIN_MULTIPROCESS_H_
Codebase Browser
chromium