broker_simple_message_unittest.cc | Explore in Territory

// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "sandbox/linux/syscall_broker/broker_simple_message.h"

#include <linux/kcmp.h>
#include <unistd.h>

#include "base/files/scoped_file.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/logging.h"
#include "base/run_loop.h"
#include "base/synchronization/waitable_event.h"
#include "base/task/thread_pool.h"
#include "base/test/bind.h"
#include "base/test/task_environment.h"
#include "base/threading/thread.h"
#include "sandbox/linux/syscall_broker/broker_channel.h"
#include "sandbox/linux/syscall_broker/broker_simple_message.h"
#include "sandbox/linux/system_headers/linux_syscalls.h"
#include "sandbox/linux/tests/test_utils.h"
#include "sandbox/linux/tests/unit_tests.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace sandbox {

namespace syscall_broker {

namespace {

void PostWaitableEventToThread(base::Thread* thread,
                               base::WaitableEvent* wait_event) { … }

}  // namespace

class ExpectedResultValue { … };

class ExpectedResultDataValue : public ExpectedResultValue { … };

class ExpectedResultIntValue : public ExpectedResultValue { … };

class BrokerSimpleMessageTestHelper { … };

ExpectedResultDataValue::ExpectedResultDataValue() { … }

ExpectedResultDataValue::ExpectedResultDataValue(const char* data,
                                                 size_t length)
    : … { … }

bool ExpectedResultDataValue::NextMessagePieceMatches(
    BrokerSimpleMessage* message) { … }

size_t ExpectedResultDataValue::Size() { … }

ExpectedResultIntValue::ExpectedResultIntValue() { … }

ExpectedResultIntValue::ExpectedResultIntValue(int value) : … { … }

bool ExpectedResultIntValue::NextMessagePieceMatches(
    BrokerSimpleMessage* message) { … }

size_t ExpectedResultIntValue::Size() { … }

// static
bool BrokerSimpleMessageTestHelper::MessageContentMatches(
    const BrokerSimpleMessage& message,
    const uint8_t* content,
    size_t length) { … }

// static
void BrokerSimpleMessageTestHelper::SendMsg(int write_fd,
                                            BrokerSimpleMessage* message,
                                            int fd) { … }

// static
void BrokerSimpleMessageTestHelper::RecvMsg(
    BrokerChannel::EndPoint* ipc_reader,
    ExpectedResultValue** expected_values,
    int expected_values_length) { … }

// static
void BrokerSimpleMessageTestHelper::RecvMsgBadRead(
    BrokerChannel::EndPoint* ipc_reader,
    int fd) { … }

// static
void BrokerSimpleMessageTestHelper::RecvMsgAndReply(
    BrokerChannel::EndPoint* ipc_reader,
    ExpectedResultValue** expected_values,
    int expected_values_length,
    const char* response_msg,
    int fd) { … }

// static
uint8_t* BrokerSimpleMessageTestHelper::WriteDataType(uint8_t* dst) { … }

// static
uint8_t* BrokerSimpleMessageTestHelper::WriteIntType(uint8_t* dst) { … }

TEST(BrokerSimpleMessage, AddData) { … }

TEST(BrokerSimpleMessage, SendAndRecvMsg) { … }

TEST(BrokerSimpleMessage, SendRecvMsgSynchronous) { … }

namespace {
// Adds a gtest failure and returns false iff any of the following conditions
// are true:
// 1. |fd1| or |fd2| are invalid fds
// 2. Kcmp fails
// 3. fd1 and fd2 do not compare equal under kcmp.
bool CheckKcmpResult(int fd1, int fd2) { … }

// Receives an fd over |ipc_reader|, and if it does not point to the same
// description as stdout, prints a message and returns false.
// On any other error, also prints a message and returns false.
void ReceiveStdoutDupFd(BrokerChannel::EndPoint* ipc_reader) { … }

void ReceiveTwoDupFds(BrokerChannel::EndPoint* ipc_reader) { … }

void ReceiveThreeFdsSendTwoBack(BrokerChannel::EndPoint* ipc_reader) { … }
}  // namespace

class BrokerSimpleMessageFdTest : public testing::Test { … };

// Passes one fd with RecvMsg, SendMsg.
TEST_F(BrokerSimpleMessageFdTest, PassOneFd) { … }

TEST_F(BrokerSimpleMessageFdTest, PassTwoFds) { … }

TEST_F(BrokerSimpleMessageFdTest, SynchronousPassTwoFds) { … }

}  // namespace syscall_broker

}  // namespace sandbox
chromium/sandbox/linux/syscall_broker/broker_simple_message_unittest.cc
