| // Copyright 2016 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // How to build and run the tests: |
| // |
| // chroot$ cros_run_unit_tests --board=$BOARD --packages arc-setup |
| // |
| // Note: only x86 $BOARDs like cyan are supported. |
| |
| #include "arc/setup/arc_setup_util.h" |
| |
| #include <fcntl.h> |
| #include <ifaddrs.h> |
| #include <inttypes.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| |
| #include <limits> |
| |
| #include <base/base64.h> |
| #include <base/bind.h> |
| #include <base/environment.h> |
| #include <base/files/file_enumerator.h> |
| #include <base/files/file_path.h> |
| #include <base/files/file_util.h> |
| #include <base/files/scoped_temp_dir.h> |
| #include <base/rand_util.h> |
| #include <base/strings/string_util.h> |
| #include <base/strings/stringprintf.h> |
| #include <base/time/time.h> |
| #include <base/timer/elapsed_timer.h> |
| #include <brillo/file_utils.h> |
| #include <brillo/files/safe_fd.h> |
| #include <gtest/gtest.h> |
| |
| namespace arc { |
| |
| namespace { |
| |
| bool FindLineCallback(std::string* out_prop, const std::string& line) { |
| if (line != "string_to_find") |
| return false; |
| *out_prop = "FOUND"; |
| return true; |
| } |
| |
| constexpr char kTestProperitesFromFileContent[] = |
| "" |
| "# begin build properties\n" |
| "\n" |
| "ro.build.version.sdk=25\n" |
| "ro.product.board=board\n" |
| "ro.build.fingerprint=fingerprint\n"; |
| |
| constexpr char kTestProperitesFromFileContentBad[] = |
| "" |
| "# begin build properties\n" |
| "\n" |
| "ro.build.version.sdk=25\n" |
| "ro.product.board board\n"; // no '=' separator |
| |
| } // namespace |
| |
| TEST(ArcSetupUtil, TestCreateOrTruncate) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| |
| // Create a new empty file. |
| EXPECT_TRUE(CreateOrTruncate(temp_directory.GetPath().Append("file"), 0777)); |
| // Confirm that the mode of the file is 0777. |
| int mode = 0; |
| EXPECT_TRUE(base::GetPosixFilePermissions( |
| temp_directory.GetPath().Append("file"), &mode)); |
| EXPECT_EQ(0777, mode); |
| // Confirm that the size of the file is 0. |
| int64_t size = -1; |
| EXPECT_TRUE( |
| base::GetFileSize(temp_directory.GetPath().Append("file"), &size)); |
| EXPECT_EQ(0, size); |
| |
| // Make the file non-empty. |
| EXPECT_TRUE( |
| WriteToFile(temp_directory.GetPath().Append("file"), 0777, "abc")); |
| EXPECT_TRUE( |
| base::GetFileSize(temp_directory.GetPath().Append("file"), &size)); |
| EXPECT_EQ(3, size); |
| |
| // Call the API again with a different mode. |
| EXPECT_TRUE(CreateOrTruncate(temp_directory.GetPath().Append("file"), 0700)); |
| // Confirm that the mode of the file is now 0700. |
| mode = 0; |
| EXPECT_TRUE(base::GetPosixFilePermissions( |
| temp_directory.GetPath().Append("file"), &mode)); |
| EXPECT_EQ(0700, mode); |
| // Confirm that the size of the file is still 0. |
| size = -1; |
| EXPECT_TRUE( |
| base::GetFileSize(temp_directory.GetPath().Append("file"), &size)); |
| EXPECT_EQ(0, size); |
| } |
| |
| TEST(ArcSetupUtil, TestWaitForPaths) { |
| constexpr base::TimeDelta timeout = base::TimeDelta::FromSeconds(1); |
| |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| base::ScopedTempDir temp_dir2; |
| ASSERT_TRUE(temp_dir2.CreateUniqueTempDir()); |
| |
| // Confirm that when the first argument is empty, it returns true. |
| // Also confirm that the third argument can be nullptr. |
| EXPECT_TRUE(WaitForPaths({}, timeout, nullptr)); |
| |
| // Confirm that the function can handle one path. |
| base::TimeDelta elapsed; |
| EXPECT_TRUE(WaitForPaths({temp_dir.GetPath()}, timeout, &elapsed)); |
| EXPECT_GT(elapsed, base::TimeDelta()); |
| // Strictly speaking, WaitForPaths does not guarantee this, but in practice, |
| // this check passes. |
| EXPECT_LE(elapsed, timeout); |
| elapsed = base::TimeDelta(); |
| |
| // Does the same with a nonexistent file. |
| EXPECT_FALSE(WaitForPaths({temp_dir.GetPath().Append("nonexistent")}, timeout, |
| &elapsed)); |
| EXPECT_GT(elapsed, timeout); |
| elapsed = base::TimeDelta(); |
| |
| // Confirm that the function can handle two paths. |
| EXPECT_TRUE(WaitForPaths({temp_dir.GetPath(), temp_dir2.GetPath()}, timeout, |
| &elapsed)); |
| EXPECT_GT(elapsed, base::TimeDelta()); |
| EXPECT_LE(elapsed, timeout); // same |
| elapsed = base::TimeDelta(); |
| |
| EXPECT_FALSE(WaitForPaths( |
| {temp_dir.GetPath().Append("nonexistent"), temp_dir2.GetPath()}, timeout, |
| &elapsed)); |
| EXPECT_GT(elapsed, timeout); |
| elapsed = base::TimeDelta(); |
| |
| EXPECT_FALSE(WaitForPaths( |
| {temp_dir.GetPath(), temp_dir2.GetPath().Append("nonexistent")}, timeout, |
| &elapsed)); |
| EXPECT_GT(elapsed, timeout); |
| elapsed = base::TimeDelta(); |
| |
| EXPECT_FALSE(WaitForPaths({temp_dir.GetPath().Append("nonexistent"), |
| temp_dir2.GetPath().Append("nonexistent")}, |
| timeout, &elapsed)); |
| EXPECT_GT(elapsed, timeout); |
| } |
| |
| TEST(ArcSetupUtil, TestWriteToFile) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| |
| // Create a non-empty file. |
| EXPECT_TRUE( |
| WriteToFile(temp_directory.GetPath().Append("file"), 0700, "abcde")); |
| // Confirm that the mode of the file is now 0700. |
| int mode = 0; |
| EXPECT_TRUE(base::GetPosixFilePermissions( |
| temp_directory.GetPath().Append("file"), &mode)); |
| EXPECT_EQ(0700, mode); |
| // Confirm that the size of the file is still 0. |
| int64_t size = -1; |
| EXPECT_TRUE( |
| base::GetFileSize(temp_directory.GetPath().Append("file"), &size)); |
| EXPECT_EQ(5, size); |
| |
| // Call the API again with a different mode and content. |
| EXPECT_TRUE( |
| WriteToFile(temp_directory.GetPath().Append("file"), 0777, "xyz")); |
| // Confirm that the mode of the file is now 0700. |
| mode = 0; |
| EXPECT_TRUE(base::GetPosixFilePermissions( |
| temp_directory.GetPath().Append("file"), &mode)); |
| EXPECT_EQ(0777, mode); |
| // Confirm that the size of the file is still 0. |
| size = -1; |
| EXPECT_TRUE( |
| base::GetFileSize(temp_directory.GetPath().Append("file"), &size)); |
| EXPECT_EQ(3, size); |
| } |
| |
| TEST(ArcSetupUtil, TestWriteToFileWithSymlink) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| base::ScopedTempDir temp_directory2; |
| ASSERT_TRUE(temp_directory2.CreateUniqueTempDir()); |
| |
| const base::FilePath symlink = temp_directory.GetPath().Append("symlink"); |
| ASSERT_TRUE(base::CreateSymbolicLink(temp_directory2.GetPath(), symlink)); |
| |
| // WriteToFile should fail when the path points to a symlink. |
| EXPECT_FALSE(WriteToFile(symlink, 0777, "abc")); |
| |
| // WriteToFile should also fail when a path component in the middle is a |
| // symlink. |
| const base::FilePath path_with_symlink = symlink.Append("not-a-symlink"); |
| EXPECT_FALSE(WriteToFile(path_with_symlink, 0777, "abcde")); |
| } |
| |
| TEST(ArcSetupUtil, TestWriteToFileWithFifo) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| const base::FilePath fifo = temp_directory.GetPath().Append("fifo"); |
| ASSERT_EQ(0, mkfifo(fifo.value().c_str(), 0700)); |
| |
| // WriteToFile should fail when the path points to a fifo. |
| EXPECT_FALSE(WriteToFile(fifo, 0777, "abc")); |
| } |
| |
| TEST(ArcSetupUtil, TestGetPropertyFromFile) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| base::FilePath prop_file = temp_directory.GetPath().Append("test.prop"); |
| |
| // Create a new prop file and read it. |
| ASSERT_TRUE(WriteToFile(prop_file, 0700, "key=val")); |
| std::string v; |
| EXPECT_TRUE(GetPropertyFromFile(prop_file, "key", &v)); |
| EXPECT_EQ("val", v); |
| EXPECT_FALSE(GetPropertyFromFile(prop_file, "k", &v)); |
| EXPECT_FALSE(GetPropertyFromFile(prop_file, "ke", &v)); |
| EXPECT_FALSE(GetPropertyFromFile(prop_file, "keyX", &v)); |
| |
| // Retry with an empty file. |
| ASSERT_TRUE(WriteToFile(prop_file, 0700, "")); |
| EXPECT_FALSE(GetPropertyFromFile(prop_file, "", &v)); |
| EXPECT_FALSE(GetPropertyFromFile(prop_file, "key", &v)); |
| |
| // Retry with a multi-line file. |
| ASSERT_TRUE(WriteToFile(prop_file, 0700, "k1=v1\nk2=v2\nk3=v3")); |
| EXPECT_TRUE(GetPropertyFromFile(prop_file, "k1", &v)); |
| EXPECT_EQ("v1", v); |
| EXPECT_TRUE(GetPropertyFromFile(prop_file, "k2", &v)); |
| EXPECT_EQ("v2", v); |
| EXPECT_TRUE(GetPropertyFromFile(prop_file, "k3", &v)); |
| EXPECT_EQ("v3", v); |
| EXPECT_FALSE(GetPropertyFromFile(prop_file, "", &v)); |
| EXPECT_FALSE(GetPropertyFromFile(prop_file, "=", &v)); |
| EXPECT_FALSE(GetPropertyFromFile(prop_file, "1", &v)); |
| EXPECT_FALSE(GetPropertyFromFile(prop_file, "k", &v)); |
| EXPECT_FALSE(GetPropertyFromFile(prop_file, "k4", &v)); |
| } |
| |
| TEST(ArcSetupUtil, TestGetPropertiesFromFile) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| base::FilePath prop_file = temp_directory.GetPath().Append("test.prop"); |
| |
| // Create a new prop file and read it. |
| ASSERT_TRUE(WriteToFile(prop_file, 0700, kTestProperitesFromFileContent)); |
| std::map<std::string, std::string> properties; |
| EXPECT_TRUE(GetPropertiesFromFile(prop_file, &properties)); |
| EXPECT_EQ(3U, properties.size()); |
| EXPECT_EQ("25", properties["ro.build.version.sdk"]); |
| EXPECT_EQ("board", properties["ro.product.board"]); |
| EXPECT_EQ("fingerprint", properties["ro.build.fingerprint"]); |
| } |
| |
| TEST(ArcSetupUtil, TestGetPropertiesFromFileBad) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| base::FilePath prop_file = temp_directory.GetPath().Append("test.prop"); |
| |
| // Create a new prop file and read it. |
| ASSERT_TRUE(WriteToFile(prop_file, 0700, kTestProperitesFromFileContentBad)); |
| std::map<std::string, std::string> properties; |
| EXPECT_FALSE(GetPropertiesFromFile(prop_file, &properties)); |
| EXPECT_TRUE(properties.empty()); |
| } |
| |
| TEST(ArcSetupUtil, TestGetFingerprintAndSdkVersionFromPackagesXml) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| base::FilePath packages_file = |
| temp_directory.GetPath().Append("packages.xml"); |
| |
| // Create a new file and read it. |
| ASSERT_TRUE(WriteToFile( |
| packages_file, 0700, |
| "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n" |
| "<packages>\n" |
| " <version sdkVersion=\"25\" databaseVersion=\"3\" fingerprint=\"f1\">\n" |
| " <version volumeUuid=\"primary_physical\" " |
| "sdkVersion=\"25\" databaseVersion=\"25\" fingerprint=\"f2\">\n" |
| "</packages>")); |
| std::string fingerprint; |
| std::string sdk_version; |
| EXPECT_TRUE(GetFingerprintAndSdkVersionFromPackagesXml( |
| packages_file, &fingerprint, &sdk_version)); |
| EXPECT_EQ("f1", fingerprint); |
| EXPECT_EQ("25", sdk_version); |
| |
| ASSERT_TRUE(WriteToFile( |
| packages_file, 0700, |
| // Reverse the order of the version elements. |
| "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n" |
| "<packages>\n" |
| " <version volumeUuid=\"primary_physical\" " |
| "sdkVersion=\"25\" databaseVersion=\"25\" fingerprint=\"f2\">\n" |
| " <version sdkVersion=\"25\" databaseVersion=\"3\" fingerprint=\"f1\">\n" |
| "</packages>")); |
| fingerprint.clear(); |
| sdk_version.clear(); |
| EXPECT_TRUE(GetFingerprintAndSdkVersionFromPackagesXml( |
| packages_file, &fingerprint, &sdk_version)); |
| EXPECT_EQ("f1", fingerprint); |
| EXPECT_EQ("25", sdk_version); |
| |
| // Test invalid <version>s. |
| ASSERT_TRUE(WriteToFile( |
| packages_file, 0700, |
| // "external" version only. |
| "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n" |
| "<packages>\n" |
| " <version volumeUuid=\"primary_physical\" " |
| "sdkVersion=\"25\" databaseVersion=\"25\" fingerprint=\"f2\">\n" |
| "</packages>")); |
| EXPECT_FALSE(GetFingerprintAndSdkVersionFromPackagesXml( |
| packages_file, &fingerprint, &sdk_version)); |
| |
| ASSERT_TRUE( |
| WriteToFile(packages_file, 0700, |
| // No sdkVersion. |
| "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n" |
| "<packages>\n" |
| " <version databaseVersion=\"3\" fingerprint=\"f1\">\n" |
| "</packages>")); |
| EXPECT_FALSE(GetFingerprintAndSdkVersionFromPackagesXml( |
| packages_file, &fingerprint, &sdk_version)); |
| |
| ASSERT_TRUE( |
| WriteToFile(packages_file, 0700, |
| // No databaseVersion. |
| "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n" |
| "<packages>\n" |
| " <version sdkVersion=\"25\" fingerprint=\"f1\">\n" |
| "</packages>")); |
| EXPECT_FALSE(GetFingerprintAndSdkVersionFromPackagesXml( |
| packages_file, &fingerprint, &sdk_version)); |
| |
| ASSERT_TRUE( |
| WriteToFile(packages_file, 0700, |
| // No fingerprint. |
| "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n" |
| "<packages>\n" |
| " <version sdkVersion=\"25\" databaseVersion=\"3\">\n" |
| "</packages>")); |
| EXPECT_FALSE(GetFingerprintAndSdkVersionFromPackagesXml( |
| packages_file, &fingerprint, &sdk_version)); |
| |
| ASSERT_TRUE(WriteToFile( |
| packages_file, 0700, |
| // No valid fingerprint. |
| "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n" |
| "<packages>\n" |
| " <version sdkVersion=\"25\" databaseVersion=\"3\" fingerprint=\"X>\n" |
| "</packages>")); |
| EXPECT_FALSE(GetFingerprintAndSdkVersionFromPackagesXml( |
| packages_file, &fingerprint, &sdk_version)); |
| |
| ASSERT_TRUE( |
| WriteToFile(packages_file, 0700, |
| // No <version> elements. |
| "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n" |
| "<packages/>\n")); |
| EXPECT_FALSE(GetFingerprintAndSdkVersionFromPackagesXml( |
| packages_file, &fingerprint, &sdk_version)); |
| |
| ASSERT_TRUE(WriteToFile(packages_file, 0700, |
| // Empty file. |
| "")); |
| EXPECT_FALSE(GetFingerprintAndSdkVersionFromPackagesXml( |
| packages_file, &fingerprint, &sdk_version)); |
| } |
| |
| TEST(ArcSetupUtil, TestFindLine) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| base::FilePath file = temp_directory.GetPath().Append("test.file"); |
| |
| // Create a new prop file and read it. |
| ASSERT_TRUE(WriteToFile(file, 0700, "string_to_find")); |
| std::string v; |
| EXPECT_TRUE(FindLine(file, base::Bind(&FindLineCallback, &v))); |
| EXPECT_EQ("FOUND", v); |
| |
| // Test with multi-line files. |
| v.clear(); |
| ASSERT_TRUE(WriteToFile(file, 0700, "string_to_find\nline")); |
| EXPECT_TRUE(FindLine(file, base::Bind(&FindLineCallback, &v))); |
| EXPECT_EQ("FOUND", v); |
| v.clear(); |
| ASSERT_TRUE(WriteToFile(file, 0700, "line\nstring_to_find\nline")); |
| EXPECT_TRUE(FindLine(file, base::Bind(&FindLineCallback, &v))); |
| EXPECT_EQ("FOUND", v); |
| v.clear(); |
| ASSERT_TRUE(WriteToFile(file, 0700, "line\nstring_to_find")); |
| EXPECT_TRUE(FindLine(file, base::Bind(&FindLineCallback, &v))); |
| EXPECT_EQ("FOUND", v); |
| v.clear(); |
| ASSERT_TRUE(WriteToFile(file, 0700, "line\nstring_to_find\n")); |
| EXPECT_TRUE(FindLine(file, base::Bind(&FindLineCallback, &v))); |
| EXPECT_EQ("FOUND", v); |
| |
| // Test without the target string. |
| ASSERT_TRUE(WriteToFile(file, 0700, "string_to_findX")); |
| EXPECT_FALSE(FindLine(file, base::Bind(&FindLineCallback, &v))); |
| ASSERT_TRUE(WriteToFile(file, 0700, "string_to_fin")); |
| EXPECT_FALSE(FindLine(file, base::Bind(&FindLineCallback, &v))); |
| ASSERT_TRUE(WriteToFile(file, 0700, "string_to_fin\nd")); |
| EXPECT_FALSE(FindLine(file, base::Bind(&FindLineCallback, &v))); |
| ASSERT_TRUE(WriteToFile(file, 0700, "s\ntring_to_find")); |
| EXPECT_FALSE(FindLine(file, base::Bind(&FindLineCallback, &v))); |
| ASSERT_TRUE(WriteToFile(file, 0700, "")); |
| EXPECT_FALSE(FindLine(file, base::Bind(&FindLineCallback, &v))); |
| } |
| |
| TEST(ArcSetupUtil, TestInstallDirectory) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| |
| // Set |temp_directory| to 0707. |
| EXPECT_TRUE(base::SetPosixFilePermissions(temp_directory.GetPath(), 0707)); |
| |
| // Create a new directory. |
| EXPECT_TRUE(InstallDirectory(0777, getuid(), getgid(), |
| temp_directory.GetPath().Append("sub1/sub2"))); |
| // Confirm that the mode for sub2 is 0777. |
| int mode_sub2 = 0; |
| EXPECT_TRUE(base::GetPosixFilePermissions( |
| temp_directory.GetPath().Append("sub1/sub2"), &mode_sub2)); |
| EXPECT_EQ(0777, mode_sub2); |
| // Confirm that the mode for sub1 is NOT 0777 but the secure default, 0755. |
| int mode_sub1 = 0; |
| EXPECT_TRUE(base::GetPosixFilePermissions( |
| temp_directory.GetPath().Append("sub1"), &mode_sub1)); |
| EXPECT_EQ(0755, mode_sub1); |
| |
| // Confirm that the existing directory |temp_directory| still has 0707 mode. |
| int mode = 0; |
| EXPECT_TRUE(base::GetPosixFilePermissions(temp_directory.GetPath(), &mode)); |
| EXPECT_EQ(0707, mode); |
| |
| // Call InstallDirectory again with the same path but a different mode, 01700. |
| EXPECT_TRUE(InstallDirectory(0700 | S_ISVTX, getuid(), getgid(), |
| temp_directory.GetPath().Append("sub1/sub2"))); |
| // Confirm that the mode for sub2 is now 01700. |
| struct stat st; |
| EXPECT_EQ( |
| 0, |
| stat(temp_directory.GetPath().Append("sub1/sub2").value().c_str(), &st)); |
| EXPECT_EQ(0700 | S_ISVTX, st.st_mode & ~S_IFMT); |
| mode_sub2 = 0; |
| EXPECT_TRUE(base::GetPosixFilePermissions( |
| temp_directory.GetPath().Append("sub1/sub2"), &mode_sub2)); |
| EXPECT_EQ(0700, mode_sub2); // base's function masks the mode with 0777. |
| // Confirm that the mode for sub1 is still 0755. |
| mode_sub1 = 0; |
| EXPECT_TRUE(base::GetPosixFilePermissions( |
| temp_directory.GetPath().Append("sub1"), &mode_sub1)); |
| EXPECT_EQ(0755, mode_sub1); |
| // Confirm that the existing directory |temp_directory| still has 0707 mode. |
| mode = 0; |
| EXPECT_TRUE(base::GetPosixFilePermissions(temp_directory.GetPath(), &mode)); |
| EXPECT_EQ(0707, mode); |
| } |
| |
| TEST(ArcSetupUtil, TestInstallDirectoryWithSymlink) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| base::ScopedTempDir temp_directory2; |
| ASSERT_TRUE(temp_directory2.CreateUniqueTempDir()); |
| |
| const base::FilePath symlink = temp_directory.GetPath().Append("symlink"); |
| ASSERT_TRUE(base::CreateSymbolicLink(temp_directory2.GetPath(), symlink)); |
| |
| // InstallDirectory should fail when the path points to a symlink. |
| EXPECT_FALSE(InstallDirectory(0777, getuid(), getgid(), symlink)); |
| |
| // InstallDirectory should also fail when a path component in the middle |
| // is a symlink. |
| const base::FilePath path_with_symlink = symlink.Append("not-a-symlink"); |
| EXPECT_FALSE(InstallDirectory(0777, getuid(), getgid(), path_with_symlink)); |
| } |
| |
| TEST(ArcSetupUtil, TestInstallDirectoryWithFifo) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| const base::FilePath fifo = temp_directory.GetPath().Append("fifo"); |
| ASSERT_EQ(0, mkfifo(fifo.value().c_str(), 0700)); |
| |
| // InstallDirectory should fail when the path points to a fifo. |
| EXPECT_FALSE(InstallDirectory(0777, getuid(), getgid(), fifo)); |
| } |
| |
| TEST(ArcSetupUtil, TestDeleteFilesInDir) { |
| base::ScopedTempDir directory; |
| ASSERT_TRUE(directory.CreateUniqueTempDir()); |
| ASSERT_TRUE(brillo::MkdirRecursively(directory.GetPath().Append("arm"), 0755) |
| .is_valid()); |
| ASSERT_TRUE( |
| brillo::MkdirRecursively(directory.GetPath().Append("arm64"), 0755) |
| .is_valid()); |
| ASSERT_TRUE(CreateOrTruncate( |
| directory.GetPath().Append("arm/system@framework@boot.art"), 0755)); |
| ASSERT_TRUE(CreateOrTruncate( |
| directory.GetPath().Append("arm64/system@framework@boot.art"), 0755)); |
| EXPECT_TRUE(base::PathExists( |
| directory.GetPath().Append("arm/system@framework@boot.art"))); |
| EXPECT_TRUE(base::PathExists( |
| directory.GetPath().Append("arm/system@framework@boot.art"))); |
| |
| EXPECT_TRUE(arc::DeleteFilesInDir(directory.GetPath())); |
| |
| EXPECT_TRUE(base::PathExists(directory.GetPath().Append("arm"))); |
| EXPECT_TRUE(base::PathExists(directory.GetPath().Append("arm64"))); |
| EXPECT_FALSE(base::PathExists( |
| directory.GetPath().Append("arm/system@framework@boot.art"))); |
| EXPECT_FALSE(base::PathExists( |
| directory.GetPath().Append("arm/system@framework@boot.art"))); |
| } |
| |
| TEST(ArcSetupUtil, TestLaunchAndWait) { |
| base::ElapsedTimer timer; |
| // Check that LaunchAndWait actually blocks until sleep returns. |
| EXPECT_TRUE(LaunchAndWait({"/usr/bin/sleep", "1"})); |
| EXPECT_LE(1, timer.Elapsed().InSeconds()); |
| |
| EXPECT_FALSE(LaunchAndWait({"/bin/false"})); |
| EXPECT_FALSE(LaunchAndWait({"/no_such_binary"})); |
| } |
| |
| TEST(ArcSetupUtil, TestGenerateFakeSerialNumber) { |
| // Check that the function always returns 20-character string. |
| EXPECT_EQ(20U, |
| GenerateFakeSerialNumber("mytestaccount@gmail.com", "001122aabbcc") |
| .size()); |
| EXPECT_EQ(20U, GenerateFakeSerialNumber("", "").size()); |
| EXPECT_EQ(20U, GenerateFakeSerialNumber("a", "b").size()); |
| |
| // Check that the function always returns the same ID for the same |
| // account and hwid_raw. |
| const std::string id_1 = |
| GenerateFakeSerialNumber("mytestaccount@gmail.com", "001122aabbcc"); |
| const std::string id_2 = |
| GenerateFakeSerialNumber("mytestaccount@gmail.com", "001122aabbcc"); |
| EXPECT_EQ(id_1, id_2); |
| |
| // Generate an ID for a different account but for the same machine. |
| // Check that the ID is not the same as |id_1|. |
| const std::string id_3 = |
| GenerateFakeSerialNumber("mytestaccount2@gmail.com", "001122aabbcc"); |
| EXPECT_NE(id_1, id_3); |
| |
| // Generate an ID for a different machine but for the same account. |
| // Check that the ID is not the same as |id_1|. |
| const std::string id_4 = |
| GenerateFakeSerialNumber("mytestaccount@gmail.com", "001122aaddcc"); |
| EXPECT_NE(id_1, id_4); |
| |
| // Check that the function treats '\0' in |salt| properly. |
| const std::string id_5 = |
| GenerateFakeSerialNumber("mytestaccount@gmail.com", {'a', '\0', 'b'}); |
| const std::string id_6 = |
| GenerateFakeSerialNumber("mytestaccount@gmail.com", {'a', '\0', 'c'}); |
| EXPECT_NE(id_5, id_6); |
| } |
| |
| TEST(ArcSetupUtil, TestGetArtCompilationOffsetSeed) { |
| const uint64_t seed1 = GetArtCompilationOffsetSeed("salt1", "build1"); |
| const uint64_t seed2 = GetArtCompilationOffsetSeed("salt2", "build1"); |
| const uint64_t seed3 = GetArtCompilationOffsetSeed("salt1", "build2"); |
| EXPECT_NE(0ULL, seed1); |
| EXPECT_NE(0ULL, seed2); |
| EXPECT_NE(0ULL, seed3); |
| EXPECT_NE(seed1, seed2); |
| EXPECT_NE(seed2, seed3); |
| EXPECT_NE(seed3, seed1); |
| } |
| |
| TEST(ArcSetupUtil, MoveDirIntoDataOldDir) { |
| base::ScopedTempDir test_dir; |
| ASSERT_TRUE(test_dir.CreateUniqueTempDir()); |
| base::FilePath dir = test_dir.GetPath().Append("android-data"); |
| base::FilePath data_old_dir = test_dir.GetPath().Append("android-data-old"); |
| |
| // Create android-data/path/to/file and run MoveDirIntoDataOldDir. |
| ASSERT_TRUE(brillo::MkdirRecursively( |
| test_dir.GetPath().Append("android-data/path/to"), 0755) |
| .is_valid()); |
| ASSERT_TRUE(CreateOrTruncate( |
| test_dir.GetPath().Append("android-data/path/to/file"), 0755)); |
| EXPECT_TRUE(MoveDirIntoDataOldDir(dir, data_old_dir)); |
| EXPECT_TRUE(base::IsDirectoryEmpty(dir)); |
| |
| // android-data has been cleared. |
| // Create android-data/path/to/file and run MoveDirIntoDataOldDir again. |
| ASSERT_TRUE(brillo::MkdirRecursively( |
| test_dir.GetPath().Append("android-data/path/to"), 0755) |
| .is_valid()); |
| ASSERT_TRUE(CreateOrTruncate( |
| test_dir.GetPath().Append("android-data/path/to/file"), 0755)); |
| EXPECT_TRUE(MoveDirIntoDataOldDir(dir, data_old_dir)); |
| |
| EXPECT_TRUE(base::IsDirectoryEmpty(dir)); |
| ASSERT_TRUE(base::DirectoryExists(data_old_dir)); |
| |
| // There should be two temp dirs in android-data-old now. |
| // Both temp dirs should contain path/to/file. |
| base::FileEnumerator temp_dir_iter(data_old_dir, false, |
| base::FileEnumerator::DIRECTORIES); |
| base::FilePath temp_dir; |
| int temp_dir_count = 0; |
| while (!(temp_dir = temp_dir_iter.Next()).empty()) { |
| EXPECT_TRUE(base::PathExists(temp_dir.Append("path/to/file"))); |
| ++temp_dir_count; |
| } |
| EXPECT_EQ(2, temp_dir_count); |
| } |
| |
| TEST(ArcSetupUtil, MoveDirIntoDataOldDir_AndroidDataDirDoesNotExist) { |
| base::ScopedTempDir test_dir; |
| ASSERT_TRUE(test_dir.CreateUniqueTempDir()); |
| |
| base::FilePath dir = test_dir.GetPath().Append("android-data"); |
| base::FilePath data_old_dir = test_dir.GetPath().Append("android-data-old"); |
| |
| EXPECT_TRUE(MoveDirIntoDataOldDir(dir, data_old_dir)); |
| |
| EXPECT_TRUE(base::IsDirectoryEmpty(dir)); |
| EXPECT_TRUE(base::IsDirectoryEmpty(data_old_dir)); |
| } |
| |
| TEST(ArcSetupUtil, MoveDirIntoDataOldDir_AndroidDataDirIsEmpty) { |
| base::ScopedTempDir test_dir; |
| ASSERT_TRUE(test_dir.CreateUniqueTempDir()); |
| |
| base::FilePath dir = test_dir.GetPath().Append("android-data"); |
| base::FilePath data_old_dir = test_dir.GetPath().Append("android-data-old"); |
| |
| ASSERT_TRUE( |
| brillo::MkdirRecursively(test_dir.GetPath().Append("android-data"), 0755) |
| .is_valid()); |
| |
| EXPECT_TRUE(MoveDirIntoDataOldDir(dir, data_old_dir)); |
| |
| EXPECT_FALSE(base::DirectoryExists(dir)); |
| |
| base::FileEnumerator temp_dir_iter(data_old_dir, false /* recursive */, |
| base::FileEnumerator::DIRECTORIES); |
| base::FilePath temp_dir; |
| int temp_dir_count = 0; |
| while (!(temp_dir = temp_dir_iter.Next()).empty()) { |
| EXPECT_TRUE(base::IsDirectoryEmpty(temp_dir)); |
| ++temp_dir_count; |
| } |
| EXPECT_EQ(1, temp_dir_count); |
| } |
| |
| TEST(ArcSetupUtil, MoveDirIntoDataOldDir_AndroidDataDirIsFile) { |
| base::ScopedTempDir test_dir; |
| ASSERT_TRUE(test_dir.CreateUniqueTempDir()); |
| |
| base::FilePath dir = test_dir.GetPath().Append("android-data"); |
| base::FilePath data_old_dir = test_dir.GetPath().Append("android-data-old"); |
| |
| // dir is a file, not a directory. |
| ASSERT_TRUE(CreateOrTruncate(dir, 0755)); |
| |
| EXPECT_TRUE(MoveDirIntoDataOldDir(dir, data_old_dir)); |
| |
| EXPECT_TRUE(base::PathExists(dir)); |
| EXPECT_TRUE(base::IsDirectoryEmpty(data_old_dir)); |
| } |
| |
| TEST(ArcSetupUtil, MoveDirIntoDataOldDir_AndroidDataOldIsFile) { |
| base::ScopedTempDir test_dir; |
| ASSERT_TRUE(test_dir.CreateUniqueTempDir()); |
| |
| base::FilePath dir = test_dir.GetPath().Append("android-data"); |
| base::FilePath data_old_dir = test_dir.GetPath().Append("android-data-old"); |
| |
| ASSERT_TRUE(brillo::MkdirRecursively( |
| test_dir.GetPath().Append("android-data/path/to"), 0755) |
| .is_valid()); |
| ASSERT_TRUE(CreateOrTruncate( |
| test_dir.GetPath().Append("android-data/path/to/file"), 0755)); |
| |
| // Create a file (not a directory) named android-data-old. |
| ASSERT_TRUE( |
| CreateOrTruncate(test_dir.GetPath().Append("android-data-old"), 0755)); |
| |
| // This should remove the file named android-data-old and create |
| // android-data-old dir instead. |
| EXPECT_TRUE(MoveDirIntoDataOldDir(dir, data_old_dir)); |
| |
| base::FileEnumerator temp_dir_iter(data_old_dir, false, |
| base::FileEnumerator::DIRECTORIES); |
| base::FilePath temp_dir; |
| int temp_dir_count = 0; |
| while (!(temp_dir = temp_dir_iter.Next()).empty()) { |
| EXPECT_TRUE(base::PathExists(temp_dir.Append("path/to/file"))); |
| ++temp_dir_count; |
| } |
| EXPECT_EQ(1, temp_dir_count); |
| } |
| |
| TEST(ArcSetupUtil, MoveDirIntoDataOldDir_DirUnderSymlink) { |
| base::ScopedTempDir test_dir; |
| ASSERT_TRUE(test_dir.CreateUniqueTempDir()); |
| |
| const base::FilePath target = test_dir.GetPath().Append("symlink_target"); |
| const base::FilePath test_file = target.Append("android-data/path/to/file"); |
| ASSERT_TRUE(brillo::MkdirRecursively(test_file.DirName(), 0755).is_valid()); |
| ASSERT_TRUE(CreateOrTruncate(test_file, 0755)); |
| |
| base::FilePath data_old_dir = |
| test_dir.GetPath().Append("old-parent/android-data-old"); |
| ASSERT_TRUE(brillo::MkdirRecursively(data_old_dir, 0755).is_valid()); |
| |
| base::FilePath dir = test_dir.GetPath().Append("data-parent/android-data"); |
| ASSERT_TRUE(base::CreateSymbolicLink(target, dir.DirName())); |
| |
| EXPECT_FALSE(MoveDirIntoDataOldDir(dir, data_old_dir)); |
| |
| EXPECT_TRUE(base::IsDirectoryEmpty(data_old_dir)); |
| EXPECT_TRUE(base::PathExists(test_file)); |
| } |
| |
| TEST(ArcSetupUtil, MoveDirIntoDataOldDir_OldDirUnderSymlink) { |
| base::ScopedTempDir test_dir; |
| ASSERT_TRUE(test_dir.CreateUniqueTempDir()); |
| |
| base::FilePath dir = test_dir.GetPath().Append("data-parent/android-data"); |
| base::FilePath data_old_dir = |
| test_dir.GetPath().Append("old-parent/android-data-old"); |
| |
| const base::FilePath target = test_dir.GetPath().Append("symlink_target"); |
| ASSERT_TRUE(brillo::MkdirRecursively(target.Append("android-data-old"), 0755) |
| .is_valid()); |
| |
| ASSERT_TRUE(base::CreateSymbolicLink(target, data_old_dir.DirName())); |
| |
| const base::FilePath test_file = dir.Append("path/to/file"); |
| ASSERT_TRUE(brillo::MkdirRecursively(test_file.DirName(), 0755).is_valid()); |
| ASSERT_TRUE(CreateOrTruncate(test_file, 0755)); |
| |
| EXPECT_FALSE(MoveDirIntoDataOldDir(dir, data_old_dir)); |
| |
| EXPECT_TRUE(base::PathExists(dir)); |
| EXPECT_TRUE(base::IsDirectoryEmpty(target.Append("android-data-old"))); |
| } |
| |
| TEST(ArcSetupUtil, TestGetChromeOsChannelFromFile) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| base::FilePath prop_file = temp_directory.GetPath().Append("test.prop"); |
| |
| ASSERT_TRUE( |
| WriteToFile(prop_file, 0700, "CHROMEOS_RELEASE_TRACK=beta-channel")); |
| EXPECT_EQ("beta", GetChromeOsChannelFromFile(prop_file)); |
| |
| ASSERT_TRUE( |
| WriteToFile(prop_file, 0700, "CHROMEOS_RELEASE_TRACK=canary-channel")); |
| EXPECT_EQ("canary", GetChromeOsChannelFromFile(prop_file)); |
| |
| ASSERT_TRUE( |
| WriteToFile(prop_file, 0700, "CHROMEOS_RELEASE_TRACK=dev-channel")); |
| EXPECT_EQ("dev", GetChromeOsChannelFromFile(prop_file)); |
| |
| ASSERT_TRUE( |
| WriteToFile(prop_file, 0700, "CHROMEOS_RELEASE_TRACK=dogfood-channel")); |
| EXPECT_EQ("dogfood", GetChromeOsChannelFromFile(prop_file)); |
| |
| ASSERT_TRUE( |
| WriteToFile(prop_file, 0700, "CHROMEOS_RELEASE_TRACK=stable-channel")); |
| EXPECT_EQ("stable", GetChromeOsChannelFromFile(prop_file)); |
| |
| ASSERT_TRUE( |
| WriteToFile(prop_file, 0700, "CHROMEOS_RELEASE_TRACK=testimage-channel")); |
| EXPECT_EQ("testimage", GetChromeOsChannelFromFile(prop_file)); |
| |
| // Checked "unknown" is returned if no value is set |
| ASSERT_TRUE(WriteToFile(prop_file, 0700, "CHROMEOS_RELEASE_TRACK=")); |
| EXPECT_EQ("unknown", GetChromeOsChannelFromFile(prop_file)); |
| |
| // Checked "unknown" is returned if some unknown string is set |
| ASSERT_TRUE(WriteToFile(prop_file, 0700, "CHROMEOS_RELEASE_TRACK=foo_bar")); |
| EXPECT_EQ("unknown", GetChromeOsChannelFromFile(prop_file)); |
| |
| // Checked "unknown" is returned if CHROMEOS_RELEASE_TRACK is not in the file |
| ASSERT_TRUE(WriteToFile(prop_file, 0700, " ")); |
| EXPECT_EQ("unknown", GetChromeOsChannelFromFile(prop_file)); |
| |
| // Checked "unknown" is returned if file is not present |
| EXPECT_EQ("unknown", GetChromeOsChannelFromFile(base::FilePath("foo"))); |
| } |
| |
| TEST(ArcSetupUtil, TestParseContainerState) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| base::FilePath json_file = temp_directory.GetPath().Append("state.json"); |
| |
| const base::FilePath kRootfsPath( |
| "/opt/google/containers/android/rootfs/root"); |
| |
| constexpr char kJsonTemplate[] = R"json( |
| { |
| "ociVersion": "1.0", |
| "id": "android-container", |
| "status": "created", |
| "pid": 4422, |
| "bundle": "/opt/google/containers/android", |
| "annotations": { |
| "org.chromium.run_oci.container_root": "%s" |
| } |
| } |
| )json"; |
| |
| ASSERT_TRUE(WriteToFile( |
| json_file, 0700, |
| base::StringPrintf(kJsonTemplate, |
| temp_directory.GetPath().value().c_str()))); |
| ASSERT_TRUE(brillo::MkdirRecursively( |
| temp_directory.GetPath().Append("mountpoints"), 0755) |
| .is_valid()); |
| ASSERT_TRUE(base::CreateSymbolicLink( |
| kRootfsPath, |
| temp_directory.GetPath().Append("mountpoints/container-root"))); |
| |
| pid_t container_pid; |
| base::FilePath rootfs; |
| EXPECT_TRUE(GetOciContainerState(json_file, &container_pid, &rootfs)); |
| EXPECT_EQ(4422, container_pid); |
| EXPECT_EQ(kRootfsPath, rootfs); |
| } |
| |
| TEST(ArcSetupUtil, TestIsProcessAlive) { |
| EXPECT_TRUE(IsProcessAlive(getpid())); |
| // We can reasonably expect that a process with a large enough pid doesn't |
| // exist. |
| EXPECT_FALSE(IsProcessAlive(std::numeric_limits<pid_t>::max())); |
| } |
| |
| TEST(ArcSetupUtil, TestGetSha1HashOfFiles) { |
| base::ScopedTempDir temp_directory; |
| ASSERT_TRUE(temp_directory.CreateUniqueTempDir()); |
| const base::FilePath file1 = temp_directory.GetPath().Append("file1"); |
| const base::FilePath file2 = temp_directory.GetPath().Append("file2"); |
| |
| // Create the files. |
| EXPECT_TRUE(WriteToFile(file1, 0700, "The quick brown fox ")); |
| EXPECT_TRUE(WriteToFile(file2, 0700, "jumps over the lazy dog")); |
| |
| // Get the hash of these files. |
| std::string hash; |
| EXPECT_TRUE(GetSha1HashOfFiles({file1, file2}, &hash)); |
| |
| // Compare it with the pre-computed value. The value can be obtained with: |
| // $ echo -n "The quick brown fox jumps over the lazy dog" | |
| // openssl sha1 -binary | base64 |
| std::string hash_expected; |
| EXPECT_TRUE( |
| base::Base64Decode("L9ThxnotKPzthJ7hu3bnORuT6xI=", &hash_expected)); |
| EXPECT_EQ(hash_expected, hash); |
| |
| // Check that the function can accept an empty input. |
| EXPECT_TRUE(GetSha1HashOfFiles({}, &hash)); |
| EXPECT_TRUE( |
| base::Base64Decode("2jmj7l5rSw0yVb/vlWAYkK/YBwk=", &hash_expected)); |
| EXPECT_EQ(hash_expected, hash); |
| |
| // Check that the function returns false when one of the input files does not |
| // exist. |
| const base::FilePath file3 = |
| temp_directory.GetPath().Append("file3"); // does not exist. |
| EXPECT_FALSE(GetSha1HashOfFiles({file2, file3}, &hash)); |
| EXPECT_FALSE(GetSha1HashOfFiles({file3, file2}, &hash)); |
| EXPECT_FALSE(GetSha1HashOfFiles({file3}, &hash)); |
| } |
| |
| TEST(ArcSetupUtil, TestShouldDeleteAndroidData) { |
| // Shouldn't delete data when no upgrade or downgrade. |
| EXPECT_FALSE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_M, |
| AndroidSdkVersion::ANDROID_M)); |
| EXPECT_FALSE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_N_MR1, |
| AndroidSdkVersion::ANDROID_N_MR1)); |
| EXPECT_FALSE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_P, |
| AndroidSdkVersion::ANDROID_P)); |
| EXPECT_FALSE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_R, |
| AndroidSdkVersion::ANDROID_R)); |
| |
| // Shouldn't delete data for initial installation. |
| EXPECT_FALSE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_M, |
| AndroidSdkVersion::UNKNOWN)); |
| EXPECT_FALSE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_N_MR1, |
| AndroidSdkVersion::UNKNOWN)); |
| EXPECT_FALSE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_P, |
| AndroidSdkVersion::UNKNOWN)); |
| EXPECT_FALSE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_R, |
| AndroidSdkVersion::UNKNOWN)); |
| |
| // All sorts of downgrades should delete data. |
| EXPECT_TRUE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_N_MR1, |
| AndroidSdkVersion::ANDROID_P)); |
| EXPECT_TRUE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_M, |
| AndroidSdkVersion::ANDROID_N_MR1)); |
| EXPECT_TRUE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_P, |
| AndroidSdkVersion::ANDROID_R)); |
| |
| // Explicitly delete data when ARC++ is upgraded from M to >= P. |
| EXPECT_TRUE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_P, |
| AndroidSdkVersion::ANDROID_M)); |
| |
| // Explicitly delete data when ARC++ is upgraded from N to R. |
| EXPECT_TRUE(ShouldDeleteAndroidData(AndroidSdkVersion::ANDROID_R, |
| AndroidSdkVersion::ANDROID_N_MR1)); |
| } |
| |
| TEST(ArcSetupUtil, TestGetUserId) { |
| uid_t uid = -1; |
| gid_t gid = -1; |
| EXPECT_FALSE(GetUserId("thisuserdoesntexist", &uid, &gid)); |
| EXPECT_TRUE(GetUserId("root", &uid, &gid)); |
| EXPECT_EQ(0, uid); |
| EXPECT_EQ(0, gid); |
| EXPECT_TRUE(GetUserId("android-root", &uid, &gid)); |
| EXPECT_EQ(655360, uid); |
| EXPECT_EQ(655360, gid); |
| if (USE_ARCVM) { |
| EXPECT_TRUE(GetUserId("crosvm", &uid, &gid)); |
| EXPECT_NE(655360, uid); |
| EXPECT_NE(655360, gid); |
| } |
| } |
| |
| TEST(ArcSetupUtil, SafeCopyFile) { |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| const base::FilePath src_file = temp_dir.GetPath().Append("srcfile"); |
| |
| // Create a new source file and write it. |
| ASSERT_TRUE(WriteToFile(src_file, 0755, "testabc")); |
| |
| const base::FilePath dest_file = |
| temp_dir.GetPath().Append("dest").Append("destfile"); |
| ASSERT_TRUE(SafeCopyFile(src_file, brillo::SafeFD::Root().first, dest_file, |
| brillo::SafeFD::Root().first)); |
| |
| const base::FilePath symlink = temp_dir.GetPath().Append("symlink"); |
| ASSERT_TRUE(base::CreateSymbolicLink(dest_file, symlink)); |
| ASSERT_FALSE(SafeCopyFile(src_file, brillo::SafeFD::Root().first, symlink, |
| brillo::SafeFD::Root().first)); |
| } |
| |
| } // namespace arc |
