blob: b23f674ce941b5089a7dc4bf5d07a3bbf6c9f5d6 [file]
// Copyright 2022 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/firmware/lib/fastboot/test/fastboot-test.h"
#include <fcntl.h>
#include <fidl/fuchsia.buildinfo/cpp/wire.h>
#include <fidl/fuchsia.buildinfo/cpp/wire_test_base.h>
#include <fidl/fuchsia.fshost/cpp/wire.h>
#include <fidl/fuchsia.fshost/cpp/wire_test_base.h>
#include <fidl/fuchsia.hardware.power.statecontrol/cpp/wire.h>
#include <fidl/fuchsia.hardware.power.statecontrol/cpp/wire_test_base.h>
#include <fidl/fuchsia.paver/cpp/wire.h>
#include <fidl/fuchsia.paver/cpp/wire_test_base.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/async/default.h>
#include <lib/async/dispatcher.h>
#include <lib/async_patterns/cpp/dispatcher_bound.h>
#include <lib/component/incoming/cpp/directory.h>
#include <lib/component/incoming/cpp/protocol.h>
#include <lib/component/outgoing/cpp/outgoing_directory.h>
#include <lib/fastboot/fastboot.h>
#include <lib/fastboot/test/test-transport.h>
#include <future>
#include <tuple>
#include <unordered_map>
#include <vector>
#include <fbl/auto_lock.h>
#include <fbl/mutex.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "src/lib/fxl/strings/string_printf.h"
#include "src/storage/lib/vfs/cpp/managed_vfs.h"
#include "src/storage/lib/vfs/cpp/pseudo_dir.h"
#include "src/storage/lib/vfs/cpp/service.h"
#include "src/storage/testing/fake-paver.h"
namespace fastboot {
namespace {
using fuchsia_hardware_power_statecontrol::ShutdownAction;
TEST(FastbootTest, NoPacket) {
Fastboot fastboot(0x40000);
TestTransport transport;
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
Packets expected_packets = {};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
}
TEST(FastbootTest, GetVarMaxDownloadSize) {
Fastboot fastboot(0x40000);
const char command[] = "getvar:max-download-size";
TestTransport transport;
transport.AddInPacket(command, strlen(command));
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
Packets expected_packets = {"OKAY0x00040000"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
}
TEST(FastbootTest, GetVarUnknownVariable) {
Fastboot fastboot(0x40000);
const char command[] = "getvar:unknown";
TestTransport transport;
transport.AddInPacket(command, strlen(command));
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
TEST(FastbootTest, GetVarNotEnoughArgument) {
Fastboot fastboot(0x40000);
const char command[] = "getvar";
TestTransport transport;
transport.AddInPacket(command, strlen(command));
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
TEST(FastbootTest, UnknownCommand) {
Fastboot fastboot(0x40000);
const char command[] = "Unknown";
TestTransport transport;
transport.AddInPacket(command, strlen(command));
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
const char kNewLineMessage[] =
"test line 1\n"
"test line 2";
const size_t kNewLineMessageSplits = 2ULL;
TEST(FastbootResponseTest, FailNewLineMessageNotSplit) {
std::string_view message(kNewLineMessage);
TestTransport transport;
auto ret = Fastboot::SendResponse(Fastboot::ResponseType::kFail, message, &transport, zx::ok());
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0], std::string("FAIL") + kNewLineMessage);
}
TEST(FastbootResponseTest, OkayNewLineMessageNotSplit) {
std::string_view message(kNewLineMessage);
TestTransport transport;
auto ret = Fastboot::SendResponse(Fastboot::ResponseType::kOkay, message, &transport, zx::ok());
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0], std::string("OKAY") + kNewLineMessage);
}
TEST(FastbootResponseTest, InfoNewLineMessageSplitAtNewLine) {
std::string_view message(kNewLineMessage);
TestTransport transport;
auto ret = Fastboot::SendResponse(Fastboot::ResponseType::kInfo, message, &transport, zx::ok());
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), kNewLineMessageSplits);
ASSERT_EQ(sent_packets[0], std::string("INFO") + "test line 1");
ASSERT_EQ(sent_packets[1], std::string("INFO") + "test line 2");
}
const char kLongMessage[] =
"0123456789abcdef"
"1123456789abcdef"
"2123456789abcdef"
"3123456789abcdef"
"4123456789abcdef"
"5123456789abcdef"
"6123456789abcdef"
"7123456789abcdef";
const size_t kLongMessageSplits = 3ULL;
TEST(FastbootResponseTest, FailLongMessageNotSplit) {
std::string_view message(kLongMessage);
TestTransport transport;
auto ret = Fastboot::SendResponse(Fastboot::ResponseType::kFail, message, &transport, zx::ok());
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0], (std::string("FAIL") + kLongMessage).substr(0, kMaxCommandPacketSize));
}
TEST(FastbootResponseTest, OkayLongMessageNotSplit) {
std::string_view message(kLongMessage);
TestTransport transport;
auto ret = Fastboot::SendResponse(Fastboot::ResponseType::kOkay, message, &transport, zx::ok());
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0], (std::string("OKAY") + kLongMessage).substr(0, kMaxCommandPacketSize));
}
TEST(FastbootResponseTest, InfoLongMessageSplitAtNewLine) {
std::string_view message(kLongMessage);
TestTransport transport;
auto ret = Fastboot::SendResponse(Fastboot::ResponseType::kInfo, message, &transport, zx::ok());
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), kLongMessageSplits);
std::string res_message;
for (auto& pkt : sent_packets) {
EXPECT_EQ(pkt.compare(0, 4, "INFO"), 0);
res_message += pkt.substr(4);
}
EXPECT_EQ(res_message, kLongMessage);
}
TEST(FastbootResponseTest, InfoLongMessageErrorAdded) {
const zx_status_t kExpectedError = ZX_ERR_NOT_SUPPORTED;
const std::string kExpectedErrorString = "(ZX_ERR_NOT_SUPPORTED)";
std::string_view message(kLongMessage);
TestTransport transport;
auto ret = Fastboot::SendResponse(Fastboot::ResponseType::kInfo, message, &transport,
zx::error(kExpectedError));
ASSERT_TRUE(ret.is_error());
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), kLongMessageSplits);
std::string res_message;
for (auto& pkt : sent_packets) {
EXPECT_EQ(pkt.compare(0, 4, "INFO"), 0);
res_message += pkt.substr(4);
}
EXPECT_EQ(res_message, kLongMessage + kExpectedErrorString);
}
// Test to cover error string at the end of the message that can be truncated (it doesn't wrap as
// message)
TEST(FastbootResponseTest, InfoLongMessageErrorAddedTruncated) {
const zx_status_t kExpectedError = ZX_ERR_NOT_SUPPORTED;
const std::string kExpectedErrorString = "(ZX_ERR_"; // NOT_SUPPORTED)"; Truncated error message
std::string message = std::string(kLongMessage) + "padding ";
TestTransport transport;
auto ret = Fastboot::SendResponse(Fastboot::ResponseType::kInfo, message, &transport,
zx::error(kExpectedError));
ASSERT_TRUE(ret.is_error());
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), kLongMessageSplits);
std::string res_message;
for (auto& pkt : sent_packets) {
EXPECT_EQ(pkt.compare(0, 4, "INFO"), 0);
res_message += pkt.substr(4);
}
EXPECT_EQ(res_message, message + kExpectedErrorString);
}
TEST(FastbootResponseTest, BadType) {
const zx_status_t kExpectedError = ZX_ERR_INVALID_ARGS;
Fastboot::ResponseType bad_type = static_cast<Fastboot::ResponseType>(123);
TestTransport transport;
auto ret = Fastboot::SendResponse(bad_type, {}, &transport, zx::ok());
ASSERT_TRUE(ret.is_error());
EXPECT_EQ(ret.error_value(), kExpectedError);
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 0ULL);
}
} // namespace
namespace {
TEST_F(FastbootDownloadTest, DownloadSucceed) {
Fastboot fastboot(0x40000);
std::vector<uint8_t> download_content;
for (size_t i = 0; i <= 0xff; i++) {
download_content.push_back(static_cast<uint8_t>(i));
}
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
}
TEST_F(FastbootDownloadTest, DownloadCompleteResetState) {
Fastboot fastboot(0x40000);
std::vector<uint8_t> download_content;
for (size_t i = 0; i <= std::numeric_limits<uint8_t>::max(); i++) {
download_content.push_back(static_cast<uint8_t>(i));
}
// Test the download command twice. The second time is to test that Fastboot re-enter
// the command waiting state after a complete download.
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
// Make sure that all states are reset.
ASSERT_EQ(fastboot.remaining_download_size(), 0ULL);
ASSERT_EQ(fastboot.state(), FastbootBase::State::kCommand);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
}
TEST(FastbootTest, DownloadFailsOnUnexpectedAmountOfData) {
Fastboot fastboot(0x40000);
std::vector<uint8_t> download_content;
for (size_t i = 0; i <= std::numeric_limits<uint8_t>::max(); i++) {
download_content.push_back(static_cast<uint8_t>(i));
}
std::string size_hex_str = fxl::StringPrintf("%08zx", download_content.size());
std::string command = "download:" + size_hex_str;
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
// Transmit the first half.
std::vector<uint8_t> first_half(download_content.begin(),
download_content.begin() + download_content.size() / 2);
transport.AddInPacket(first_half);
ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
// The second transmit sends the entire download, which will exceed expected size.
transport.AddInPacket(download_content);
ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
// Check that the last packet is a FAIL response
ASSERT_EQ(transport.GetOutPackets().size(), 2ULL);
ASSERT_EQ(transport.GetOutPackets().back().compare(0, 4, "FAIL"), 0);
ASSERT_EQ(fastboot.total_download_size(), 0ULL);
ASSERT_EQ(fastboot.remaining_download_size(), 0ULL);
ASSERT_EQ(fastboot.state(), FastbootBase::State::kCommand);
}
TEST(FastbootTest, DownloadFailsOnZeroSizeDownload) {
Fastboot fastboot(0x40000);
std::string command = "download:00000000";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
ASSERT_EQ(fastboot.total_download_size(), 0ULL);
ASSERT_EQ(fastboot.remaining_download_size(), 0ULL);
ASSERT_EQ(fastboot.state(), FastbootBase::State::kCommand);
}
TEST(FastbootTest, DownloadFailsOnNotEnoughArgument) {
Fastboot fastboot(0x40000);
std::string command = "download";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
ASSERT_EQ(fastboot.total_download_size(), 0ULL);
ASSERT_EQ(fastboot.remaining_download_size(), 0ULL);
ASSERT_EQ(fastboot.state(), FastbootBase::State::kCommand);
}
class FastbootFailGetDownloadBuffer : public Fastboot {
public:
using Fastboot::Fastboot;
private:
zx::result<void*> GetDownloadBuffer(size_t total_download_size) override {
return zx::error(ZX_ERR_UNAVAILABLE);
}
};
TEST(FastbootTest, DownloadFailsOnetDownloadBuffer) {
FastbootFailGetDownloadBuffer fastboot(0x40000);
std::vector<uint8_t> download_content;
for (size_t i = 0; i <= std::numeric_limits<uint8_t>::max(); i++) {
download_content.push_back(static_cast<uint8_t>(i));
}
std::string size_hex_str = fxl::StringPrintf("%08zx", download_content.size());
std::string command = "download:" + size_hex_str;
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_error());
// Check that the last packet is a FAIL response
ASSERT_EQ(transport.GetOutPackets().size(), 1ULL);
ASSERT_EQ(transport.GetOutPackets().back().compare(0, 4, "FAIL"), 0);
ASSERT_EQ(fastboot.total_download_size(), 0ULL);
ASSERT_EQ(fastboot.remaining_download_size(), 0ULL);
ASSERT_EQ(fastboot.state(), FastbootBase::State::kCommand);
}
class FastbootFlashTest : public FastbootDownloadTest {
protected:
FastbootFlashTest() : loop_(&kAsyncLoopConfigNoAttachToCurrentThread), vfs_(loop_.dispatcher()) {
// Set up a svc root directory with a paver service entry.
auto root_dir = fbl::MakeRefCounted<fs::PseudoDir>();
root_dir->AddEntry(
fidl::DiscoverableProtocolName<fuchsia_paver::Paver>,
fbl::MakeRefCounted<fs::Service>([this](fidl::ServerEnd<fuchsia_paver::Paver> request) {
fake_paver_.Connect(loop_.dispatcher(), std::move(request));
return ZX_OK;
}));
zx::result server_end = fidl::CreateEndpoints(&svc_local_);
EXPECT_TRUE(server_end.is_ok()) << server_end.status_string();
vfs_.ServeDirectory(root_dir, std::move(server_end.value()));
loop_.StartThread("fastboot-flash-test-loop");
}
fidl::ClientEnd<fuchsia_io::Directory>& svc_chan() { return svc_local_; }
paver_test::FakePaver& paver() { return fake_paver_; }
~FastbootFlashTest() override {
std::promise<zx_status_t> promise;
vfs_.Shutdown([&promise](zx_status_t status) { promise.set_value(status); });
EXPECT_EQ(promise.get_future().get(), ZX_OK);
loop_.Shutdown();
}
void TestFlashBootloader(Fastboot& fastboot, fuchsia_paver::wire::Configuration config,
const std::string& type_suffix) {
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
paver_test::FakePaver& fake_paver = paver();
fake_paver.set_expected_payload_size(download_content.size());
std::unordered_map<fuchsia_paver::wire::Configuration, std::string> config_to_partition = {
{fuchsia_paver::wire::Configuration::kA, "bootloader_a"},
{fuchsia_paver::wire::Configuration::kB, "bootloader_b"},
{fuchsia_paver::wire::Configuration::kRecovery, "bootloader_r"},
};
TestTransport transport;
std::string command = "flash:" + config_to_partition[config] + type_suffix;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
ASSERT_EQ(fake_paver.last_firmware_config(), config);
}
void TestFlashBootloaderNoFirmwareType(Fastboot& fastboot,
fuchsia_paver::wire::Configuration config) {
fake_paver_.set_supported_firmware_type("");
ASSERT_NO_FATAL_FAILURE(TestFlashBootloader(fastboot, config, ""));
ASSERT_EQ(fake_paver_.last_firmware_type(), "");
}
void TestFlashBootloaderWithFirmwareType(Fastboot& fastboot,
fuchsia_paver::wire::Configuration config,
const std::string& type) {
fake_paver_.set_supported_firmware_type(type);
ASSERT_NO_FATAL_FAILURE(TestFlashBootloader(fastboot, config, ":" + type));
ASSERT_EQ(fake_paver_.last_firmware_type(), type);
}
void TestFlashAsset(const std::string& partition, fuchsia_paver::wire::Configuration config,
fuchsia_paver::wire::Asset asset) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
paver_test::FakePaver& fake_paver = paver();
fake_paver.set_expected_payload_size(download_content.size());
std::string command = "flash:" + partition;
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
ASSERT_EQ(fake_paver.last_asset_config(), config);
ASSERT_EQ(fake_paver.last_asset(), asset);
}
void TestSetActive(const std::string& slot) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
paver().set_abr_supported(true);
TestTransport transport;
const std::string command = "set_active:" + slot;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
}
async::Loop loop_;
fs::ManagedVfs vfs_;
paver_test::FakePaver fake_paver_;
fidl::ClientEnd<fuchsia_io::Directory> svc_local_;
};
TEST_F(FastbootFlashTest, FlashFailsOnNotEnoughArguments) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
std::string command = "flash";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
TEST_F(FastbootFlashTest, FlashFailsOnUnsupportedPartition) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
std::string command = "flash:unknown-partition";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
TEST_F(FastbootFlashTest, FlashBootloaderNoAbrNoFirmwareType) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
paver_test::FakePaver& fake_paver = paver();
fake_paver.set_expected_payload_size(download_content.size());
TestTransport transport;
std::string command = "flash:bootloader";
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
ASSERT_EQ(fake_paver.last_firmware_config(), fuchsia_paver::wire::Configuration::kA);
}
TEST_F(FastbootFlashTest, FlashBootloaderNoAbrWithFirmwareType) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
paver_test::FakePaver& fake_paver = paver();
fake_paver.set_expected_payload_size(download_content.size());
std::string firmware_type = "firmware_type";
fake_paver.set_supported_firmware_type(firmware_type);
TestTransport transport;
std::string command = "flash:bootloader:" + firmware_type;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
ASSERT_EQ(fake_paver.last_firmware_config(), fuchsia_paver::wire::Configuration::kA);
ASSERT_EQ(fake_paver_.last_firmware_type(), firmware_type);
}
TEST_F(FastbootFlashTest, FlashBooloaderASlot) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
ASSERT_NO_FATAL_FAILURE(
TestFlashBootloaderNoFirmwareType(fastboot, fuchsia_paver::wire::Configuration::kA));
}
TEST_F(FastbootFlashTest, FlashBooloaderBSlot) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
ASSERT_NO_FATAL_FAILURE(
TestFlashBootloaderNoFirmwareType(fastboot, fuchsia_paver::wire::Configuration::kB));
}
TEST_F(FastbootFlashTest, FlashBooloaderRSlot) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
ASSERT_NO_FATAL_FAILURE(
TestFlashBootloaderNoFirmwareType(fastboot, fuchsia_paver::wire::Configuration::kRecovery));
}
TEST_F(FastbootFlashTest, FlashBooloaderASlotWithFirmwareType) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
ASSERT_NO_FATAL_FAILURE(TestFlashBootloaderWithFirmwareType(
fastboot, fuchsia_paver::wire::Configuration::kA, "firmware_type"));
}
TEST_F(FastbootFlashTest, FlashBooloaderBSlotWithFirmwareType) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
ASSERT_NO_FATAL_FAILURE(TestFlashBootloaderWithFirmwareType(
fastboot, fuchsia_paver::wire::Configuration::kB, "firmware_type"));
}
TEST_F(FastbootFlashTest, FlashBooloaderRSlotWithFirmwareType) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
ASSERT_NO_FATAL_FAILURE(TestFlashBootloaderWithFirmwareType(
fastboot, fuchsia_paver::wire::Configuration::kRecovery, "firmware_type"));
}
TEST_F(FastbootFlashTest, FlashBooloaderWriteFail) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
// Insert a write firmware error
paver_test::FakePaver& fake_paver = paver();
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
fake_paver.set_expected_payload_size(0);
std::string command = "flash:bootloader_a";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_FALSE(ret.is_ok());
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
TEST_F(FastbootFlashTest, FlashBooloaderUnsupportedFirmwareType) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
// Insert an unsupported firmware failure
paver().set_supported_firmware_type("unsupported");
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
std::string command = "flash:bootloader_a";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
TEST_F(FastbootFlashTest, FlashFuchsiaEsp) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
paver_test::FakePaver& fake_paver = paver();
fake_paver.set_expected_payload_size(download_content.size());
std::string command = "flash:fuchsia-esp";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
ASSERT_EQ(fake_paver.last_firmware_config(), fuchsia_paver::wire::Configuration::kA);
ASSERT_EQ(fake_paver.last_firmware_type(), "");
}
TEST_F(FastbootFlashTest, FlashAssetZirconA) {
TestFlashAsset("zircon_a", fuchsia_paver::wire::Configuration::kA,
fuchsia_paver::wire::Asset::kKernel);
}
TEST_F(FastbootFlashTest, FlashAssetZirconB) {
TestFlashAsset("zircon_b", fuchsia_paver::wire::Configuration::kB,
fuchsia_paver::wire::Asset::kKernel);
}
TEST_F(FastbootFlashTest, FlashAssetZirconR) {
TestFlashAsset("zircon_r", fuchsia_paver::wire::Configuration::kRecovery,
fuchsia_paver::wire::Asset::kKernel);
}
TEST_F(FastbootFlashTest, FlashAssetLegacyZirconA) {
TestFlashAsset("zircon_a", fuchsia_paver::wire::Configuration::kA,
fuchsia_paver::wire::Asset::kKernel);
}
TEST_F(FastbootFlashTest, FlashAssetLegacyZirconB) {
TestFlashAsset("zircon_b", fuchsia_paver::wire::Configuration::kB,
fuchsia_paver::wire::Asset::kKernel);
}
TEST_F(FastbootFlashTest, FlashAssetLegacyZirconR) {
TestFlashAsset("zircon_r", fuchsia_paver::wire::Configuration::kRecovery,
fuchsia_paver::wire::Asset::kKernel);
}
TEST_F(FastbootFlashTest, FlashAssetVerifiedBootMetadataA) {
TestFlashAsset("vbmeta_a", fuchsia_paver::wire::Configuration::kA,
fuchsia_paver::wire::Asset::kVerifiedBootMetadata);
}
TEST_F(FastbootFlashTest, FlashAssetVerifiedBootMetadataB) {
TestFlashAsset("vbmeta_b", fuchsia_paver::wire::Configuration::kB,
fuchsia_paver::wire::Asset::kVerifiedBootMetadata);
}
TEST_F(FastbootFlashTest, FlashAssetVerifiedBootMetadataR) {
TestFlashAsset("vbmeta_r", fuchsia_paver::wire::Configuration::kRecovery,
fuchsia_paver::wire::Asset::kVerifiedBootMetadata);
}
TEST_F(FastbootFlashTest, FlashAssetFail) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
// Trigger an internal error by using an incorrect size
paver().set_expected_payload_size(128);
std::string command = "flash:zircon_a";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_FALSE(ret.is_ok());
ASSERT_EQ(transport.GetOutPackets().back().compare(0, 4, "FAIL"), 0);
}
TEST_F(FastbootFlashTest, SetActiveSlotA) {
TestSetActive("a");
ASSERT_TRUE(paver().abr_data().slot_a.active);
}
TEST_F(FastbootFlashTest, SetActiveSlotB) {
TestSetActive("b");
ASSERT_TRUE(paver().abr_data().slot_b.active);
}
TEST_F(FastbootFlashTest, SetActiveInvalidSlot) {
paver().set_abr_supported(true);
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::string command = "set_active:r";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
TEST_F(FastbootFlashTest, GetVarVersion) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
const char command[] = "getvar:version";
TestTransport transport;
transport.AddInPacket(command, strlen(command));
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY0.4"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
}
TEST_F(FastbootFlashTest, GetVarSlotCount) {
paver().set_abr_supported(true);
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::string command = "getvar:slot-count";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY2"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
}
TEST_F(FastbootFlashTest, GetVarSlotCountAbrNotSupported) {
paver().set_abr_supported(false);
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::string command = "getvar:slot-count";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY1"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
}
TEST_F(FastbootFlashTest, GetVarIsUserspace) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::string command = "getvar:is-userspace";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAYyes"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
}
TEST_F(FastbootFlashTest, GetVarAll) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::string command = "getvar:all";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {
"INFOversion: 0.4",
"INFOslot-count: 1",
"INFOproduct: [error: ZX_ERR_PEER_CLOSED]",
"INFOis-userspace: yes",
"INFOhw-revision: [error: ZX_ERR_PEER_CLOSED]",
"INFOmax-download-size: 0x00040000",
"OKAYnot all variables were retrieved successfully",
};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
}
TEST_F(FastbootFlashTest, OemInitPartitionTables) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::string command = "oem init-partition-tables";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
ASSERT_EQ(paver().GetCommandTrace(),
std::vector<paver_test::Command>{paver_test::Command::kInitPartitionTables});
}
TEST_F(FastbootFlashTest, OemWipePartitionTables) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::string command = "oem wipe-partition-tables";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
ASSERT_EQ(paver().GetCommandTrace(),
std::vector<paver_test::Command>{paver_test::Command::kWipePartitionTables});
}
// Sends |command| to |fastboot| over |transport| and asserts that the operation is successful.
void CommandSuccess(Fastboot& fastboot, TestTransport& transport, std::string_view command) {
transport.AddInPacket(command);
ASSERT_TRUE(fastboot.ProcessPacket(&transport).is_ok());
ASSERT_EQ(transport.GetOutPackets().size(), 1ULL);
ASSERT_EQ(transport.GetOutPackets()[0], "OKAY");
}
// Sends |command| to |fastboot| over |transport| and asserts that the operation fails.
void CommandFailure(Fastboot& fastboot, TestTransport& transport, std::string_view command) {
transport.AddInPacket(command);
ASSERT_TRUE(fastboot.ProcessPacket(&transport).is_error());
ASSERT_EQ(transport.GetOutPackets().size(), 1ULL);
ASSERT_EQ(transport.GetOutPackets()[0].substr(0, 4), "FAIL");
}
TEST_F(FastbootFlashTest, FlashGptMeta) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
TestTransport transport;
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, kGptMetaDefault));
ASSERT_NO_FATAL_FAILURE(CommandSuccess(fastboot, transport, "flash:gpt-meta"));
ASSERT_EQ(paver().GetCommandTrace(),
std::vector<paver_test::Command>{paver_test::Command::kInitPartitionTables});
}
TEST_F(FastbootFlashTest, FlashGptMetaNoDownloadFailure) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
TestTransport transport;
// No data downloaded should cause a failure.
ASSERT_NO_FATAL_FAILURE(CommandFailure(fastboot, transport, "flash:gpt-meta"));
ASSERT_TRUE(paver().GetCommandTrace().empty());
}
TEST_F(FastbootFlashTest, FlashGptMetaUnknownContentsFailure) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
TestTransport transport;
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, "default_plus_invalid_extra_contents"));
ASSERT_NO_FATAL_FAILURE(CommandFailure(fastboot, transport, "flash:gpt-meta"));
ASSERT_TRUE(paver().GetCommandTrace().empty());
}
TEST_F(FastbootFlashTest, FlashGptMetaInvalidSlotFailure) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
TestTransport transport;
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, kGptMetaDefault));
// The gpt-meta pseudo-partition doesn't support slot suffixes.
ASSERT_NO_FATAL_FAILURE(CommandFailure(fastboot, transport, "flash:gpt-meta_a"));
ASSERT_TRUE(paver().GetCommandTrace().empty());
}
class FastbootRebootTest : public testing::Test {
public:
// |TestState| is shared between |Background| and the main test object.
class TestState {
public:
void set_shutdown_action(ShutdownAction action) {
fbl::AutoLock al(&lock_);
shutdown_action_ = action;
}
std::optional<ShutdownAction> shutdown_action() const {
fbl::AutoLock al(&lock_);
return shutdown_action_;
}
private:
std::optional<ShutdownAction> shutdown_action_ __TA_GUARDED(lock_) = std::nullopt;
mutable fbl::Mutex lock_;
};
class MockFidlServer
: public fidl::testing::WireTestBase<fuchsia_paver::Paver>,
public fidl::testing::WireTestBase<fuchsia_paver::BootManager>,
public fidl::testing::WireTestBase<fuchsia_hardware_power_statecontrol::Admin> {
public:
MockFidlServer(async_dispatcher_t* dispatcher, std::shared_ptr<TestState> state)
: dispatcher_(dispatcher), state_(std::move(state)) {}
fidl::ProtocolHandler<fuchsia_hardware_power_statecontrol::Admin> PublishAdmin() {
return admin_bindings_.CreateHandler(this, dispatcher_, fidl::kIgnoreBindingClosure);
}
fidl::ProtocolHandler<fuchsia_paver::Paver> PublishPaver() {
return paver_bindings_.CreateHandler(this, dispatcher_, fidl::kIgnoreBindingClosure);
}
private:
void Shutdown(ShutdownRequestView request, ShutdownCompleter::Sync& completer) override {
state_->set_shutdown_action(request->options.action());
completer.ReplySuccess();
}
void FindBootManager(FindBootManagerRequestView request,
FindBootManagerCompleter::Sync& completer) override {
boot_manager_bindings_.AddBinding(dispatcher_, std::move(request->boot_manager), this,
fidl::kIgnoreBindingClosure);
}
void NotImplemented_(const std::string& name, fidl::CompleterBase& completer) override {
FAIL() << "Unexpected call to BuildInfo: " << name;
}
async_dispatcher_t* dispatcher_;
std::shared_ptr<TestState> state_;
fidl::ServerBindingGroup<fuchsia_paver::Paver> paver_bindings_;
fidl::ServerBindingGroup<fuchsia_hardware_power_statecontrol::Admin> admin_bindings_;
fidl::ServerBindingGroup<fuchsia_paver::BootManager> boot_manager_bindings_;
};
// This class is managed and used from a parallel background |async::Loop|
// while the main thread runs blocking operations.
class MockComponent {
public:
MockComponent(fidl::ServerEnd<fuchsia_io::Directory> svc,
const std::shared_ptr<TestState>& state)
: dispatcher_(async_get_default_dispatcher()),
outgoing_(dispatcher_),
server_(dispatcher_, state) {
EXPECT_EQ(outgoing_
.AddUnmanagedProtocol<fuchsia_hardware_power_statecontrol::Admin>(
server_.PublishAdmin())
.status_value(),
ZX_OK);
EXPECT_EQ(outgoing_.AddUnmanagedProtocol<fuchsia_paver::Paver>(server_.PublishPaver())
.status_value(),
ZX_OK);
EXPECT_EQ(outgoing_.Serve(std::move(svc)).status_value(), ZX_OK);
}
private:
async_dispatcher_t* dispatcher_;
component::OutgoingDirectory outgoing_;
MockFidlServer server_;
};
FastbootRebootTest() : loop_(&kAsyncLoopConfigNoAttachToCurrentThread) {
loop_.StartThread("fastboot-reboot-test-loop");
auto endpoints = fidl::Endpoints<fuchsia_io::Directory>::Create();
zx::result svc_local = component::OpenDirectoryAt(endpoints.client, "svc");
EXPECT_TRUE(svc_local.is_ok()) << svc_local.status_string();
svc_local_ = std::move(svc_local.value());
mock_.emplace(std::move(endpoints.server), state_);
}
fidl::ClientEnd<fuchsia_io::Directory>& svc_chan() { return svc_local_; }
const TestState& state() const { return *state_; }
async::Loop loop_;
std::shared_ptr<TestState> state_ = std::make_shared<TestState>();
fidl::ClientEnd<fuchsia_io::Directory> svc_local_;
async_patterns::DispatcherBound<MockComponent> mock_{loop_.dispatcher()};
};
TEST_F(FastbootRebootTest, RebootShutdownAction) {
constexpr std::tuple<std::string_view, ShutdownAction> kCommandActionMap[] = {
{"continue", ShutdownAction::kReboot},
{"reboot", ShutdownAction::kReboot},
{"reboot-bootloader", ShutdownAction::kRebootToBootloader},
{"reboot-fastboot", ShutdownAction::kRebootToRecovery},
{"reboot-recovery", ShutdownAction::kRebootToRecovery},
};
Fastboot fastboot(0x40000, std::move(svc_chan()));
for (auto [command, expected_action] : kCommandActionMap) {
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << "Failed to process packet for command " << command << ": "
<< ret.status_string();
std::vector<std::string> expected_packets = {"OKAY"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets))
<< "wrong response for command " << command;
ASSERT_EQ(state().shutdown_action(), expected_action)
<< "wrong shutdown action for command " << command;
}
}
TEST_F(FastbootFlashTest, UnknownOemCommand) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::string command = "oem unknown";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
class FastbootFshostTest : public FastbootDownloadTest {
public:
class TestState {
public:
const std::string& data_file_name() const {
fbl::AutoLock al(&lock_);
return data_file_name_;
}
void set_data_file_name(std::string v) {
fbl::AutoLock al(&lock_);
data_file_name_ = std::move(v);
}
const std::string& data_file_content() const {
fbl::AutoLock al(&lock_);
return data_file_content_;
}
void set_data_file_content(std::string v) {
fbl::AutoLock al(&lock_);
data_file_content_ = std::move(v);
}
uint64_t data_file_vmo_content_size() const {
fbl::AutoLock al(&lock_);
return data_file_vmo_content_size_;
}
void set_data_file_vmo_content_size(uint64_t v) {
fbl::AutoLock al(&lock_);
data_file_vmo_content_size_ = v;
}
private:
std::string data_file_name_ TA_GUARDED(lock_);
std::string data_file_content_ TA_GUARDED(lock_);
uint64_t data_file_vmo_content_size_ TA_GUARDED(lock_);
mutable fbl::Mutex lock_;
};
class MockFshostRecovery : public fidl::testing::WireTestBase<fuchsia_fshost::Recovery> {
public:
explicit MockFshostRecovery(async_dispatcher_t* dispatcher,
const std::shared_ptr<TestState>& state)
: dispatcher_(dispatcher), state_(state) {}
fidl::ProtocolHandler<fuchsia_fshost::Recovery> Publish() {
return admin_bindings_.CreateHandler(this, dispatcher_, fidl::kIgnoreBindingClosure);
}
private:
void WriteDataFile(WriteDataFileRequestView request,
WriteDataFileCompleter::Sync& completer) override {
state_->set_data_file_name(std::string(request->filename.data(), request->filename.size()));
uint64_t size;
ASSERT_EQ(request->payload.get_size(&size), ZX_OK);
std::string data_file_content;
data_file_content.resize(size);
ASSERT_EQ(request->payload.read(data_file_content.data(), 0, size), ZX_OK);
state_->set_data_file_content(std::move(data_file_content));
uint64_t data_file_vmo_content_size;
ASSERT_EQ(request->payload.get_prop_content_size(&data_file_vmo_content_size), ZX_OK);
state_->set_data_file_vmo_content_size(data_file_vmo_content_size);
completer.ReplySuccess();
}
void NotImplemented_(const std::string& name, fidl::CompleterBase& completer) override {
FAIL() << "Unexpected call to ControllerImpl: " << name;
}
async_dispatcher_t* dispatcher_;
std::shared_ptr<TestState> state_;
fidl::ServerBindingGroup<fuchsia_fshost::Recovery> admin_bindings_;
};
class MockComponent {
public:
explicit MockComponent(fidl::ServerEnd<fuchsia_io::Directory> directory,
const std::shared_ptr<TestState>& state)
: dispatcher_(async_get_default_dispatcher()),
outgoing_(dispatcher_),
server_(dispatcher_, state) {
EXPECT_EQ(outgoing_.AddUnmanagedProtocol<fuchsia_fshost::Recovery>(server_.Publish())
.status_value(),
ZX_OK);
EXPECT_EQ(outgoing_.Serve(std::move(directory)).status_value(), ZX_OK);
}
private:
async_dispatcher_t* dispatcher_;
component::OutgoingDirectory outgoing_;
MockFshostRecovery server_;
};
FastbootFshostTest() : loop_(&kAsyncLoopConfigNoAttachToCurrentThread) {
loop_.StartThread("fastboot-fshost-test-loop");
auto endpoints = fidl::Endpoints<fuchsia_io::Directory>::Create();
zx::result svc_local = component::OpenDirectoryAt(endpoints.client, "svc");
EXPECT_TRUE(svc_local.is_ok()) << svc_local.status_string();
svc_local_ = std::move(svc_local.value());
mock_.emplace(std::move(endpoints.server), state_);
}
fidl::ClientEnd<fuchsia_io::Directory>& svc_chan() { return svc_local_; }
const TestState& state() const { return *state_; }
private:
async::Loop loop_;
std::shared_ptr<TestState> state_ = std::make_shared<TestState>();
fidl::ClientEnd<fuchsia_io::Directory> svc_local_;
async_patterns::DispatcherBound<MockComponent> mock_{loop_.dispatcher()};
};
TEST_F(FastbootFshostTest, OemAddStagedBootloaderFile) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
std::string command =
"oem add-staged-bootloader-file " + std::string(sshd_host::kAuthorizedKeysBootloaderFileName);
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
ASSERT_EQ(state().data_file_name(), sshd_host::kAuthorizedKeyPathInData);
ASSERT_EQ(state().data_file_vmo_content_size(), download_content.size());
ASSERT_EQ(std::memcmp(state().data_file_content().data(), download_content.data(),
download_content.size()),
0);
}
TEST_F(FastbootFlashTest, OemAddStagedBootloaderFileInvalidNumberOfArguments) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::string command = "oem add-staged-bootloader-file";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
TEST_F(FastbootFlashTest, OemAddStagedBootloaderFileUnsupportedFile) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::string command = "oem add-staged-bootloader-file unknown";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
TEST_F(FastbootFlashTest, FlashRawFVM) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
paver_test::FakePaver& fake_paver = paver();
fake_paver.set_expected_payload_size(download_content.size());
std::string command = "flash:fvm";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
std::vector<std::string> expected_packets = {"OKAY"};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
}
TEST_F(FastbootFlashTest, FlashRawFVMFail) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
std::vector<uint8_t> download_content(256, 1);
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
paver_test::FakePaver& fake_paver = paver();
// Use an incorrect size to trigger an error
fake_paver.set_expected_payload_size(download_content.size() + 1);
std::string command = "flash:fvm";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_error());
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
TEST_F(FastbootFlashTest, AndroidSparseImageNotSupported) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
sparse_header_t header{
.magic = SPARSE_HEADER_MAGIC,
};
const uint8_t* header_ptr = reinterpret_cast<const uint8_t*>(&header);
std::vector<uint8_t> download_content(header_ptr, header_ptr + sizeof(header));
ASSERT_NO_FATAL_FAILURE(DownloadData(fastboot, download_content));
paver_test::FakePaver& fake_paver = paver();
fake_paver.set_expected_payload_size(download_content.size());
std::string command = "flash:fvm";
TestTransport transport;
transport.AddInPacket(command);
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
const std::vector<std::string>& sent_packets = transport.GetOutPackets();
ASSERT_EQ(sent_packets.size(), 1ULL);
ASSERT_EQ(sent_packets[0].compare(0, 4, "FAIL"), 0);
}
TEST(FastbootBase, ExtractCommandArgsMultipleArgs) {
FastbootBase::CommandArgs args;
FastbootBase::ExtractCommandArgs("cmd:arg1:arg2:arg3:a", ":", args);
EXPECT_EQ(args.num_args, 5ul);
EXPECT_EQ(args.args[0], "cmd");
EXPECT_EQ(args.args[1], "arg1");
EXPECT_EQ(args.args[2], "arg2");
EXPECT_EQ(args.args[3], "arg3");
EXPECT_EQ(args.args[4], "a");
EXPECT_EQ(args.args[5], "");
}
TEST(FastbootBase, ExtractCommandArgsNoArgs) {
FastbootBase::CommandArgs args;
FastbootBase::ExtractCommandArgs("cmd", ":", args);
EXPECT_EQ(args.num_args, 1ul);
EXPECT_EQ(args.args[0], "cmd");
EXPECT_EQ(args.args[1], "");
}
TEST(FastbootBase, ExtractCommandArgsMiddleEmptyArgs) {
FastbootBase::CommandArgs args;
FastbootBase::ExtractCommandArgs("cmd::arg2", ":", args);
EXPECT_EQ(args.num_args, 2ul);
EXPECT_EQ(args.args[0], "cmd");
EXPECT_EQ(args.args[1], "arg2");
}
TEST(FastbootBase, ExtractCommandArgsEndEmptyArgs) {
FastbootBase::CommandArgs args;
FastbootBase::ExtractCommandArgs("cmd:arg1:", ":", args);
EXPECT_EQ(args.num_args, 2ul);
EXPECT_EQ(args.args[0], "cmd");
EXPECT_EQ(args.args[1], "arg1");
}
TEST(FastbootBase, ExtractCommandArgsMultipleBySpace) {
FastbootBase::CommandArgs args;
FastbootBase::ExtractCommandArgs("cmd arg1 arg2 arg3", " ", args);
EXPECT_EQ(args.num_args, 4ul);
EXPECT_EQ(args.args[0], "cmd");
EXPECT_EQ(args.args[1], "arg1");
EXPECT_EQ(args.args[2], "arg2");
EXPECT_EQ(args.args[3], "arg3");
EXPECT_EQ(args.args[4], "");
}
constexpr char kTestBoardConfig[] = "test-board-config";
constexpr char kTestProductConfig[] = "test-product-config";
class FastbootBuildInfoTest : public FastbootDownloadTest {
public:
class MockBuildInfoProvider : public fidl::testing::WireTestBase<fuchsia_buildinfo::Provider> {
public:
explicit MockBuildInfoProvider(async_dispatcher_t* dispatcher) : dispatcher_(dispatcher) {}
fidl::ProtocolHandler<fuchsia_buildinfo::Provider> Publish() {
return provider_bindings_.CreateHandler(this, dispatcher_, fidl::kIgnoreBindingClosure);
}
private:
void GetBuildInfo(GetBuildInfoCompleter::Sync& completer) override {
fidl::Arena arena;
auto ret = fuchsia_buildinfo::wire::BuildInfo::Builder(arena)
.board_config(fidl::StringView(kTestBoardConfig))
.product_config(fidl::StringView(kTestProductConfig))
.Build();
completer.Reply(ret);
}
void NotImplemented_(const std::string& name, fidl::CompleterBase& completer) override {
FAIL() << "Unexpected call to BuildInfo: " << name;
}
async_dispatcher_t* dispatcher_;
fidl::ServerBindingGroup<fuchsia_buildinfo::Provider> provider_bindings_;
};
class MockComponent {
public:
explicit MockComponent(fidl::ServerEnd<fuchsia_io::Directory> server_end)
: dispatcher_(async_get_default_dispatcher()),
outgoing_(dispatcher_),
provider_server_(dispatcher_) {
EXPECT_EQ(
outgoing_.AddUnmanagedProtocol<fuchsia_buildinfo::Provider>(provider_server_.Publish())
.status_value(),
ZX_OK);
EXPECT_EQ(outgoing_.Serve(std::move(server_end)).status_value(), ZX_OK);
}
private:
async_dispatcher_t* dispatcher_;
component::OutgoingDirectory outgoing_;
MockBuildInfoProvider provider_server_;
};
FastbootBuildInfoTest() : loop_(&kAsyncLoopConfigNoAttachToCurrentThread) {
loop_.StartThread("fastboot-build-info-test-loop");
auto endpoints = fidl::Endpoints<fuchsia_io::Directory>::Create();
zx::result svc_local = component::OpenDirectoryAt(endpoints.client, "svc");
EXPECT_TRUE(svc_local.is_ok()) << svc_local.status_string();
svc_local_ = std::move(svc_local.value());
mock_.emplace(std::move(endpoints.server));
}
fidl::ClientEnd<fuchsia_io::Directory>& svc_chan() { return svc_local_; }
private:
async::Loop loop_;
fidl::ClientEnd<fuchsia_io::Directory> svc_local_;
async_patterns::DispatcherBound<MockComponent> mock_{loop_.dispatcher()};
};
TEST_F(FastbootBuildInfoTest, GetVarHwRevision) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
const char command[] = "getvar:hw-revision";
TestTransport transport;
transport.AddInPacket(command, strlen(command));
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
Packets expected_packets = {"OKAY" + std::string(kTestBoardConfig)};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
}
TEST_F(FastbootBuildInfoTest, GetVarProduct) {
Fastboot fastboot(0x40000, std::move(svc_chan()));
const char command[] = "getvar:product";
TestTransport transport;
transport.AddInPacket(command, strlen(command));
zx::result<> ret = fastboot.ProcessPacket(&transport);
ASSERT_TRUE(ret.is_ok()) << ret.status_string();
Packets expected_packets = {"OKAY" + std::string(kTestProductConfig)};
ASSERT_THAT(transport.GetOutPackets(), testing::ContainerEq(expected_packets));
}
} // namespace
} // namespace fastboot