PawletOS/android_bootable_recovery
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Switch to bionic gtest in bootable/recovery

Browse Source 
We encountered segfaults in Imgdiff host tests due to the failure to
reset states of getopt. The problem can be solved by switching to use
bionic's gtest where a new process is forked for each test.

Also modify the recovery_component_test to make sure it runs in parallel.
Changes include:
  1. Merge the writes to misc partition into one single test.
  2. Change the hard coded location "/cache/saved.file" into a configurable
  variable.

Bug: 67849209
Test: recovery tests pass

Change-Id: I165d313f32b83393fb7922c5078636ac40b50bc2
This commit is contained in:
Tianjie Xu
2017-11-03 14:09:11 -07:00
parent 43f194c8bc
commit a88cc5440e
10 changed files with 189 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/component/applypatch_test.cpp
+47 -86
View File
@@ -53,8 +53,7 @@ static void sha1sum(const std::string& fname, std::string* sha1, size_t* fsize =
}
static void mangle_file(const std::string& fname) {
std::string content;
content.reserve(1024);
std::string content(1024, '\0');
for (size_t i = 0; i < 1024; i++) {
content[i] = rand() % 256;
}
@@ -63,16 +62,11 @@ static void mangle_file(const std::string& fname) {
class ApplyPatchTest : public ::testing::Test {
public:
static void SetUpTestCase() {
virtual void SetUp() override {
// set up files
old_file = from_testdata_base("old.file");
new_file = from_testdata_base("new.file");
patch_file = from_testdata_base("patch.bsdiff");
rand_file = "/cache/applypatch_test_rand.file";
cache_file = "/cache/saved.file";
// write stuff to rand_file
ASSERT_TRUE(android::base::WriteStringToFile("hello", rand_file));
nonexistent_file = from_testdata_base("nonexistent.file");
// set up SHA constants
sha1sum(old_file, &old_sha1, &old_size);
@@ -82,56 +76,35 @@ class ApplyPatchTest : public ::testing::Test {
bad_sha1_b = android::base::StringPrintf("%040x", rand());
}
static std::string old_file;
static std::string new_file;
static std::string rand_file;
static std::string cache_file;
static std::string patch_file;
std::string old_file;
std::string new_file;
std::string nonexistent_file;
static std::string old_sha1;
static std::string new_sha1;
static std::string bad_sha1_a;
static std::string bad_sha1_b;
std::string old_sha1;
std::string new_sha1;
std::string bad_sha1_a;
std::string bad_sha1_b;
static size_t old_size;
static size_t new_size;
size_t old_size;
size_t new_size;
};
static void cp(const std::string& src, const std::string& tgt) {
std::string cmd = "cp " + src + " " + tgt;
system(cmd.c_str());
}
static void backup_old() {
cp(ApplyPatchTest::old_file, ApplyPatchTest::cache_file);
}
static void restore_old() {
cp(ApplyPatchTest::cache_file, ApplyPatchTest::old_file);
}
class ApplyPatchCacheTest : public ApplyPatchTest {
public:
virtual void SetUp() {
backup_old();
}
virtual void TearDown() {
restore_old();
protected:
void SetUp() override {
ApplyPatchTest::SetUp();
cache_temp_source = old_file;
}
};
std::string ApplyPatchTest::old_file;
std::string ApplyPatchTest::new_file;
std::string ApplyPatchTest::rand_file;
std::string ApplyPatchTest::patch_file;
std::string ApplyPatchTest::cache_file;
std::string ApplyPatchTest::old_sha1;
std::string ApplyPatchTest::new_sha1;
std::string ApplyPatchTest::bad_sha1_a;
std::string ApplyPatchTest::bad_sha1_b;
size_t ApplyPatchTest::old_size;
size_t ApplyPatchTest::new_size;
class ApplyPatchModesTest : public ::testing::Test {
protected:
void SetUp() override {
cache_temp_source = cache_source.path;
}
TemporaryFile cache_source;
};
TEST_F(ApplyPatchTest, CheckModeSkip) {
std::vector<std::string> sha1s;
@@ -189,43 +162,31 @@ TEST_F(ApplyPatchTest, CheckModeEmmcTarget) {
ASSERT_EQ(0, applypatch_check(src_file.c_str(), sha1s));
}
TEST_F(ApplyPatchCacheTest, CheckCacheCorruptedSingle) {
mangle_file(old_file);
std::vector<std::string> sha1s = { old_sha1 };
ASSERT_EQ(0, applypatch_check(&old_file[0], sha1s));
TEST_F(ApplyPatchCacheTest, CheckCacheCorruptedSourceSingle) {
TemporaryFile temp_file;
mangle_file(temp_file.path);
std::vector<std::string> sha1s_single = { old_sha1 };
ASSERT_EQ(0, applypatch_check(temp_file.path, sha1s_single));
ASSERT_EQ(0, applypatch_check(nonexistent_file.c_str(), sha1s_single));
}
TEST_F(ApplyPatchCacheTest, CheckCacheCorruptedMultiple) {
mangle_file(old_file);
std::vector<std::string> sha1s = { bad_sha1_a, old_sha1, bad_sha1_b };
ASSERT_EQ(0, applypatch_check(&old_file[0], sha1s));
TEST_F(ApplyPatchCacheTest, CheckCacheCorruptedSourceMultiple) {
TemporaryFile temp_file;
mangle_file(temp_file.path);
std::vector<std::string> sha1s_multiple = { bad_sha1_a, old_sha1, bad_sha1_b };
ASSERT_EQ(0, applypatch_check(temp_file.path, sha1s_multiple));
ASSERT_EQ(0, applypatch_check(nonexistent_file.c_str(), sha1s_multiple));
}
TEST_F(ApplyPatchCacheTest, CheckCacheCorruptedFailure) {
mangle_file(old_file);
std::vector<std::string> sha1s = { bad_sha1_a, bad_sha1_b };
ASSERT_NE(0, applypatch_check(&old_file[0], sha1s));
TEST_F(ApplyPatchCacheTest, CheckCacheCorruptedSourceFailure) {
TemporaryFile temp_file;
mangle_file(temp_file.path);
std::vector<std::string> sha1s_failure = { bad_sha1_a, bad_sha1_b };
ASSERT_NE(0, applypatch_check(temp_file.path, sha1s_failure));
ASSERT_NE(0, applypatch_check(nonexistent_file.c_str(), sha1s_failure));
}
TEST_F(ApplyPatchCacheTest, CheckCacheMissingSingle) {
unlink(&old_file[0]);
std::vector<std::string> sha1s = { old_sha1 };
ASSERT_EQ(0, applypatch_check(&old_file[0], sha1s));
}
TEST_F(ApplyPatchCacheTest, CheckCacheMissingMultiple) {
unlink(&old_file[0]);
std::vector<std::string> sha1s = { bad_sha1_a, old_sha1, bad_sha1_b };
ASSERT_EQ(0, applypatch_check(&old_file[0], sha1s));
}
TEST_F(ApplyPatchCacheTest, CheckCacheMissingFailure) {
unlink(&old_file[0]);
std::vector<std::string> sha1s = { bad_sha1_a, bad_sha1_b };
ASSERT_NE(0, applypatch_check(&old_file[0], sha1s));
}
TEST(ApplyPatchModesTest, InvalidArgs) {
TEST_F(ApplyPatchModesTest, InvalidArgs) {
// At least two args (including the filename).
ASSERT_EQ(2, applypatch_modes(1, (const char* []){ "applypatch" }));
@@ -233,7 +194,7 @@ TEST(ApplyPatchModesTest, InvalidArgs) {
ASSERT_EQ(2, applypatch_modes(2, (const char* []){ "applypatch", "-x" }));
}
TEST(ApplyPatchModesTest, PatchModeEmmcTarget) {
TEST_F(ApplyPatchModesTest, PatchModeEmmcTarget) {
std::string boot_img = from_testdata_base("boot.img");
size_t boot_img_size;
std::string boot_img_sha1;
@@ -303,7 +264,7 @@ TEST(ApplyPatchModesTest, PatchModeEmmcTarget) {
ASSERT_EQ(0, applypatch_modes(args3.size(), args3.data()));
}
TEST(ApplyPatchModesTest, PatchModeInvalidArgs) {
TEST_F(ApplyPatchModesTest, PatchModeInvalidArgs) {
// Invalid bonus file.
ASSERT_NE(0, applypatch_modes(3, (const char* []){ "applypatch", "-b", "/doesntexist" }));
@@ -364,11 +325,11 @@ TEST(ApplyPatchModesTest, PatchModeInvalidArgs) {
ASSERT_NE(0, applypatch_modes(args6.size(), args6.data()));
}
TEST(ApplyPatchModesTest, CheckModeInvalidArgs) {
TEST_F(ApplyPatchModesTest, CheckModeInvalidArgs) {
// Insufficient args.
ASSERT_EQ(2, applypatch_modes(2, (const char* []){ "applypatch", "-c" }));
}
TEST(ApplyPatchModesTest, ShowLicenses) {
TEST_F(ApplyPatchModesTest, ShowLicenses) {
ASSERT_EQ(0, applypatch_modes(2, (const char* []){ "applypatch", "-l" }));
}
tests/component/bootloader_message_test.cpp
+25 -115
View File
@@ -18,53 +18,12 @@
#include <vector>
#include <android-base/strings.h>
#include <android-base/test_utils.h>
#include <bootloader_message/bootloader_message.h>
#include <gtest/gtest.h>
class BootloaderMessageTest : public ::testing::Test {
protected:
BootloaderMessageTest() : has_misc(true) {}
virtual void SetUp() override {
std::string err;
has_misc = !get_bootloader_message_blk_device(&err).empty();
}
virtual void TearDown() override {
// Clear the BCB.
if (has_misc) {
std::string err;
ASSERT_TRUE(clear_bootloader_message(&err)) << "Failed to clear BCB: " << err;
}
}
bool has_misc;
};
TEST_F(BootloaderMessageTest, clear_bootloader_message) {
if (!has_misc) {
GTEST_LOG_(INFO) << "Test skipped due to no /misc partition found on the device.";
return;
}
// Clear the BCB.
std::string err;
ASSERT_TRUE(clear_bootloader_message(&err)) << "Failed to clear BCB: " << err;
// Verify the content.
bootloader_message boot;
ASSERT_TRUE(read_bootloader_message(&boot, &err)) << "Failed to read BCB: " << err;
// All the bytes should be cleared.
ASSERT_EQ(std::string(sizeof(boot), '\0'),
std::string(reinterpret_cast<const char*>(&boot), sizeof(boot)));
}
TEST_F(BootloaderMessageTest, read_and_write_bootloader_message) {
if (!has_misc) {
GTEST_LOG_(INFO) << "Test skipped due to no /misc partition found on the device.";
return;
}
TEST(BootloaderMessageTest, read_and_write_bootloader_message) {
TemporaryFile temp_misc;
// Write the BCB.
bootloader_message boot = {};
@@ -73,90 +32,71 @@ TEST_F(BootloaderMessageTest, read_and_write_bootloader_message) {
strlcpy(boot.status, "status1", sizeof(boot.status));
std::string err;
ASSERT_TRUE(write_bootloader_message(boot, &err)) << "Failed to write BCB: " << err;
ASSERT_TRUE(write_bootloader_message_to(boot, temp_misc.path, &err))
<< "Failed to write BCB: " << err;
// Read and verify.
bootloader_message boot_verify;
ASSERT_TRUE(read_bootloader_message(&boot_verify, &err)) << "Failed to read BCB: " << err;
ASSERT_TRUE(read_bootloader_message_from(&boot_verify, temp_misc.path, &err))
<< "Failed to read BCB: " << err;
ASSERT_EQ(std::string(reinterpret_cast<const char*>(&boot), sizeof(boot)),
std::string(reinterpret_cast<const char*>(&boot_verify), sizeof(boot_verify)));
}
TEST_F(BootloaderMessageTest, write_bootloader_message_options) {
if (!has_misc) {
GTEST_LOG_(INFO) << "Test skipped due to no /misc partition found on the device.";
return;
}
TEST(BootloaderMessageTest, update_bootloader_message_in_struct) {
// Write the options to BCB.
std::vector<std::string> options = { "option1", "option2" };
std::string err;
ASSERT_TRUE(write_bootloader_message(options, &err)) << "Failed to write BCB: " << err;
// Inject some bytes into boot, which should be overwritten while reading.
bootloader_message boot;
bootloader_message boot = {};
// Inject some bytes into boot.
strlcpy(boot.recovery, "random message", sizeof(boot.recovery));
strlcpy(boot.status, "status bytes", sizeof(boot.status));
strlcpy(boot.stage, "stage bytes", sizeof(boot.stage));
strlcpy(boot.reserved, "reserved bytes", sizeof(boot.reserved));
ASSERT_TRUE(read_bootloader_message(&boot, &err)) << "Failed to read BCB: " << err;
ASSERT_TRUE(update_bootloader_message_in_struct(&boot, options));
// Verify that command and recovery fields should be set.
ASSERT_EQ("boot-recovery", std::string(boot.command));
std::string expected = "recovery\n" + android::base::Join(options, "\n") + "\n";
ASSERT_EQ(expected, std::string(boot.recovery));
// The rest should be cleared.
ASSERT_EQ(std::string(sizeof(boot.status), '\0'), std::string(boot.status, sizeof(boot.status)));
ASSERT_EQ(std::string(sizeof(boot.stage), '\0'), std::string(boot.stage, sizeof(boot.stage)));
ASSERT_EQ(std::string(sizeof(boot.reserved), '\0'),
std::string(boot.reserved, sizeof(boot.reserved)));
// The rest should be intact.
ASSERT_EQ("status bytes", std::string(boot.status));
ASSERT_EQ("stage bytes", std::string(boot.stage));
ASSERT_EQ("reserved bytes", std::string(boot.reserved));
}
TEST_F(BootloaderMessageTest, write_bootloader_message_options_empty) {
if (!has_misc) {
GTEST_LOG_(INFO) << "Test skipped due to no /misc partition found on the device.";
return;
}
TEST(BootloaderMessageTest, update_bootloader_message_recovery_options_empty) {
// Write empty vector.
std::vector<std::string> options;
std::string err;
ASSERT_TRUE(write_bootloader_message(options, &err)) << "Failed to write BCB: " << err;
// Read and verify.
bootloader_message boot;
ASSERT_TRUE(read_bootloader_message(&boot, &err)) << "Failed to read BCB: " << err;
bootloader_message boot = {};
ASSERT_TRUE(update_bootloader_message_in_struct(&boot, options));
// command and recovery fields should be set.
ASSERT_EQ("boot-recovery", std::string(boot.command));
ASSERT_EQ("recovery\n", std::string(boot.recovery));
// The rest should be cleared.
// The rest should be empty.
ASSERT_EQ(std::string(sizeof(boot.status), '\0'), std::string(boot.status, sizeof(boot.status)));
ASSERT_EQ(std::string(sizeof(boot.stage), '\0'), std::string(boot.stage, sizeof(boot.stage)));
ASSERT_EQ(std::string(sizeof(boot.reserved), '\0'),
std::string(boot.reserved, sizeof(boot.reserved)));
}
TEST_F(BootloaderMessageTest, write_bootloader_message_options_long) {
if (!has_misc) {
GTEST_LOG_(INFO) << "Test skipped due to no /misc partition found on the device.";
return;
}
TEST(BootloaderMessageTest, update_bootloader_message_recovery_options_long) {
// Write super long message.
std::vector<std::string> options;
for (int i = 0; i < 100; i++) {
options.push_back("option: " + std::to_string(i));
}
std::string err;
ASSERT_TRUE(write_bootloader_message(options, &err)) << "Failed to write BCB: " << err;
// Read and verify.
bootloader_message boot;
ASSERT_TRUE(read_bootloader_message(&boot, &err)) << "Failed to read BCB: " << err;
bootloader_message boot = {};
ASSERT_TRUE(update_bootloader_message_in_struct(&boot, options));
// Make sure it's long enough.
std::string expected = "recovery\n" + android::base::Join(options, "\n") + "\n";
@@ -167,40 +107,10 @@ TEST_F(BootloaderMessageTest, write_bootloader_message_options_long) {
ASSERT_EQ(expected.substr(0, sizeof(boot.recovery) - 1), std::string(boot.recovery));
ASSERT_EQ('\0', boot.recovery[sizeof(boot.recovery) - 1]);
// The rest should be cleared.
// The rest should be empty.
ASSERT_EQ(std::string(sizeof(boot.status), '\0'), std::string(boot.status, sizeof(boot.status)));
ASSERT_EQ(std::string(sizeof(boot.stage), '\0'), std::string(boot.stage, sizeof(boot.stage)));
ASSERT_EQ(std::string(sizeof(boot.reserved), '\0'),
std::string(boot.reserved, sizeof(boot.reserved)));
}
TEST_F(BootloaderMessageTest, update_bootloader_message) {
if (!has_misc) {
GTEST_LOG_(INFO) << "Test skipped due to no /misc partition found on the device.";
return;
}
// Inject some bytes into boot, which should be not overwritten later.
bootloader_message boot;
strlcpy(boot.recovery, "random message", sizeof(boot.recovery));
strlcpy(boot.reserved, "reserved bytes", sizeof(boot.reserved));
std::string err;
ASSERT_TRUE(write_bootloader_message(boot, &err)) << "Failed to write BCB: " << err;
// Update the BCB message.
std::vector<std::string> options = { "option1", "option2" };
ASSERT_TRUE(update_bootloader_message(options, &err)) << "Failed to update BCB: " << err;
bootloader_message boot_verify;
ASSERT_TRUE(read_bootloader_message(&boot_verify, &err)) << "Failed to read BCB: " << err;
// Verify that command and recovery fields should be set.
ASSERT_EQ("boot-recovery", std::string(boot_verify.command));
std::string expected = "recovery\n" + android::base::Join(options, "\n") + "\n";
ASSERT_EQ(expected, std::string(boot_verify.recovery));
// The rest should be intact.
ASSERT_EQ(std::string(boot.status), std::string(boot_verify.status));
ASSERT_EQ(std::string(boot.stage), std::string(boot_verify.stage));
ASSERT_EQ(std::string(boot.reserved), std::string(boot_verify.reserved));
}
tests/component/uncrypt_test.cpp
+64 -35
View File
@@ -20,6 +20,7 @@
#include <sys/un.h>
#include <unistd.h>
#include <algorithm>
#include <string>
#include <android-base/file.h>
@@ -38,43 +39,49 @@ static const std::string INIT_SVC_CLEAR_BCB = "init.svc.clear-bcb";
static const std::string INIT_SVC_UNCRYPT = "init.svc.uncrypt";
static constexpr int SOCKET_CONNECTION_MAX_RETRY = 30;
static void StopService() {
ASSERT_TRUE(android::base::SetProperty("ctl.stop", "setup-bcb"));
ASSERT_TRUE(android::base::SetProperty("ctl.stop", "clear-bcb"));
ASSERT_TRUE(android::base::SetProperty("ctl.stop", "uncrypt"));
bool success = false;
for (int retry = 0; retry < SOCKET_CONNECTION_MAX_RETRY; retry++) {
std::string setup_bcb = android::base::GetProperty(INIT_SVC_SETUP_BCB, "");
std::string clear_bcb = android::base::GetProperty(INIT_SVC_CLEAR_BCB, "");
std::string uncrypt = android::base::GetProperty(INIT_SVC_UNCRYPT, "");
GTEST_LOG_(INFO) << "setup-bcb: [" << setup_bcb << "] clear-bcb: [" << clear_bcb
<< "] uncrypt: [" << uncrypt << "]";
if (setup_bcb != "running" && clear_bcb != "running" && uncrypt != "running") {
success = true;
break;
}
sleep(1);
}
ASSERT_TRUE(success) << "uncrypt service is not available.";
}
class UncryptTest : public ::testing::Test {
protected:
UncryptTest() : has_misc(true) {}
virtual void SetUp() override {
ASSERT_TRUE(android::base::SetProperty("ctl.stop", "setup-bcb"));
ASSERT_TRUE(android::base::SetProperty("ctl.stop", "clear-bcb"));
ASSERT_TRUE(android::base::SetProperty("ctl.stop", "uncrypt"));
bool success = false;
for (int retry = 0; retry < SOCKET_CONNECTION_MAX_RETRY; retry++) {
std::string setup_bcb = android::base::GetProperty(INIT_SVC_SETUP_BCB, "");
std::string clear_bcb = android::base::GetProperty(INIT_SVC_CLEAR_BCB, "");
std::string uncrypt = android::base::GetProperty(INIT_SVC_UNCRYPT, "");
LOG(INFO) << "setup-bcb: [" << setup_bcb << "] clear-bcb: [" << clear_bcb << "] uncrypt: ["
<< uncrypt << "]";
if (setup_bcb != "running" && clear_bcb != "running" && uncrypt != "running") {
success = true;
break;
}
sleep(1);
}
ASSERT_TRUE(success) << "uncrypt service is not available.";
void SetUp() override {
std::string err;
has_misc = !get_bootloader_message_blk_device(&err).empty();
}
void TearDown() override {
// Clear the BCB.
if (has_misc) {
std::string err;
ASSERT_TRUE(clear_bootloader_message(&err)) << "Failed to clear BCB: " << err;
}
}
void SetupOrClearBcb(bool isSetup, const std::string& message,
const std::string& message_in_bcb) const {
if (!has_misc) {
GTEST_LOG_(INFO) << "Test skipped due to no /misc partition found on the device.";
return;
}
// Trigger the setup-bcb service.
// Restart the setup-bcb service.
StopService();
ASSERT_TRUE(android::base::SetProperty("ctl.start", isSetup ? "setup-bcb" : "clear-bcb"));
// Test tends to be flaky if proceeding immediately ("Transport endpoint is not connected").
@@ -144,27 +151,49 @@ class UncryptTest : public ::testing::Test {
}
}
void VerifyBootloaderMessage(const std::string& expected) {
std::string err;
bootloader_message boot;
ASSERT_TRUE(read_bootloader_message(&boot, &err)) << "Failed to read BCB: " << err;
// Check that we have all the expected bytes.
ASSERT_EQ(expected, std::string(reinterpret_cast<const char*>(&boot), sizeof(boot)));
}
bool has_misc;
};
TEST_F(UncryptTest, setup_bcb) {
if (!has_misc) {
GTEST_LOG_(INFO) << "Test skipped due to no /misc partition found on the device.";
return;
}
std::string random_data;
random_data.reserve(sizeof(bootloader_message));
generate_n(back_inserter(random_data), sizeof(bootloader_message), []() { return rand() % 128; });
bootloader_message boot;
memcpy(&boot, random_data.c_str(), random_data.size());
std::string err;
ASSERT_TRUE(write_bootloader_message(boot, &err)) << "Failed to write BCB: " << err;
VerifyBootloaderMessage(random_data);
ASSERT_TRUE(clear_bootloader_message(&err)) << "Failed to clear BCB: " << err;
VerifyBootloaderMessage(std::string(sizeof(bootloader_message), '\0'));
std::string message = "--update_message=abc value";
std::string message_in_bcb = "recovery\n--update_message=abc value\n";
SetupOrClearBcb(true, message, message_in_bcb);
}
TEST_F(UncryptTest, clear_bcb) {
SetupOrClearBcb(false, "", "");
}
TEST_F(UncryptTest, setup_bcb_wipe_ab) {
TemporaryFile wipe_package;
ASSERT_TRUE(android::base::WriteStringToFile(std::string(345, 'a'), wipe_package.path));
// It's expected to store a wipe package in /misc, with the package size passed to recovery.
std::string message =
"--wipe_ab\n--wipe_package="s + wipe_package.path + "\n--reason=wipePackage"s;
std::string message_in_bcb =
"recovery\n--wipe_ab\n--wipe_package_size=345\n--reason=wipePackage\n";
message = "--wipe_ab\n--wipe_package="s + wipe_package.path + "\n--reason=wipePackage"s;
message_in_bcb = "recovery\n--wipe_ab\n--wipe_package_size=345\n--reason=wipePackage\n";
SetupOrClearBcb(true, message, message_in_bcb);
}