blob: 3d2feaa9d247ccb58370c0dfcad3723470934815 [file] [log] [blame]
// Copyright (c) 2012 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.
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <map>
#include <string>
#include <vector>
#include <base/file_path.h>
#include <base/file_util.h>
#include <base/string_util.h>
#include <base/stringprintf.h>
#include <gtest/gtest.h>
#include "update_engine/test_utils.h"
#include "update_engine/utils.h"
using std::map;
using std::string;
using std::vector;
namespace chromeos_update_engine {
class UtilsTest : public ::testing::Test { };
TEST(UtilsTest, IsOfficialBuild) {
// Pretty lame test...
EXPECT_TRUE(utils::IsOfficialBuild());
}
TEST(UtilsTest, IsNormalBootMode) {
// Pretty lame test...
EXPECT_TRUE(utils::IsNormalBootMode());
}
TEST(UtilsTest, NormalizePathTest) {
EXPECT_EQ("", utils::NormalizePath("", false));
EXPECT_EQ("", utils::NormalizePath("", true));
EXPECT_EQ("/", utils::NormalizePath("/", false));
EXPECT_EQ("", utils::NormalizePath("/", true));
EXPECT_EQ("/", utils::NormalizePath("//", false));
EXPECT_EQ("", utils::NormalizePath("//", true));
EXPECT_EQ("foo", utils::NormalizePath("foo", false));
EXPECT_EQ("foo", utils::NormalizePath("foo", true));
EXPECT_EQ("/foo/", utils::NormalizePath("/foo//", false));
EXPECT_EQ("/foo", utils::NormalizePath("/foo//", true));
EXPECT_EQ("bar/baz/foo/adlr", utils::NormalizePath("bar/baz//foo/adlr",
false));
EXPECT_EQ("bar/baz/foo/adlr", utils::NormalizePath("bar/baz//foo/adlr",
true));
EXPECT_EQ("/bar/baz/foo/adlr/", utils::NormalizePath("/bar/baz//foo/adlr/",
false));
EXPECT_EQ("/bar/baz/foo/adlr", utils::NormalizePath("/bar/baz//foo/adlr/",
true));
EXPECT_EQ("\\\\", utils::NormalizePath("\\\\", false));
EXPECT_EQ("\\\\", utils::NormalizePath("\\\\", true));
EXPECT_EQ("\\:/;$PATH\n\\", utils::NormalizePath("\\://;$PATH\n\\", false));
EXPECT_EQ("\\:/;$PATH\n\\", utils::NormalizePath("\\://;$PATH\n\\", true));
EXPECT_EQ("/spaces s/ ok/s / / /",
utils::NormalizePath("/spaces s/ ok/s / / /", false));
EXPECT_EQ("/spaces s/ ok/s / / ",
utils::NormalizePath("/spaces s/ ok/s / / /", true));
}
TEST(UtilsTest, ReadFileFailure) {
vector<char> empty;
EXPECT_FALSE(utils::ReadFile("/this/doesn't/exist", &empty));
}
TEST(UtilsTest, ReadFileChunk) {
FilePath file;
EXPECT_TRUE(file_util::CreateTemporaryFile(&file));
ScopedPathUnlinker unlinker(file.value());
vector<char> data;
const size_t kSize = 1024 * 1024;
for (size_t i = 0; i < kSize; i++) {
data.push_back(i % 255);
}
EXPECT_TRUE(utils::WriteFile(file.value().c_str(), &data[0], data.size()));
vector<char> in_data;
EXPECT_TRUE(utils::ReadFileChunk(file.value().c_str(), kSize, 10, &in_data));
EXPECT_TRUE(in_data.empty());
EXPECT_TRUE(utils::ReadFileChunk(file.value().c_str(), 0, -1, &in_data));
EXPECT_TRUE(data == in_data);
in_data.clear();
EXPECT_TRUE(utils::ReadFileChunk(file.value().c_str(), 10, 20, &in_data));
EXPECT_TRUE(vector<char>(data.begin() + 10, data.begin() + 10 + 20) ==
in_data);
}
TEST(UtilsTest, ErrnoNumberAsStringTest) {
EXPECT_EQ("No such file or directory", utils::ErrnoNumberAsString(ENOENT));
}
TEST(UtilsTest, StringHasSuffixTest) {
EXPECT_TRUE(utils::StringHasSuffix("foo", "foo"));
EXPECT_TRUE(utils::StringHasSuffix("foo", "o"));
EXPECT_TRUE(utils::StringHasSuffix("", ""));
EXPECT_TRUE(utils::StringHasSuffix("abcabc", "abc"));
EXPECT_TRUE(utils::StringHasSuffix("adlrwashere", "ere"));
EXPECT_TRUE(utils::StringHasSuffix("abcdefgh", "gh"));
EXPECT_TRUE(utils::StringHasSuffix("abcdefgh", ""));
EXPECT_FALSE(utils::StringHasSuffix("foo", "afoo"));
EXPECT_FALSE(utils::StringHasSuffix("", "x"));
EXPECT_FALSE(utils::StringHasSuffix("abcdefgh", "fg"));
EXPECT_FALSE(utils::StringHasSuffix("abcdefgh", "ab"));
}
TEST(UtilsTest, StringHasPrefixTest) {
EXPECT_TRUE(utils::StringHasPrefix("foo", "foo"));
EXPECT_TRUE(utils::StringHasPrefix("foo", "f"));
EXPECT_TRUE(utils::StringHasPrefix("", ""));
EXPECT_TRUE(utils::StringHasPrefix("abcabc", "abc"));
EXPECT_TRUE(utils::StringHasPrefix("adlrwashere", "adl"));
EXPECT_TRUE(utils::StringHasPrefix("abcdefgh", "ab"));
EXPECT_TRUE(utils::StringHasPrefix("abcdefgh", ""));
EXPECT_FALSE(utils::StringHasPrefix("foo", "fooa"));
EXPECT_FALSE(utils::StringHasPrefix("", "x"));
EXPECT_FALSE(utils::StringHasPrefix("abcdefgh", "bc"));
EXPECT_FALSE(utils::StringHasPrefix("abcdefgh", "gh"));
}
TEST(UtilsTest, BootDeviceTest) {
// Pretty lame test...
EXPECT_FALSE(utils::BootDevice().empty());
}
TEST(UtilsTest, BootKernelDeviceTest) {
EXPECT_EQ("", utils::BootKernelDevice("foo"));
EXPECT_EQ("", utils::BootKernelDevice("/dev/sda0"));
EXPECT_EQ("", utils::BootKernelDevice("/dev/sda1"));
EXPECT_EQ("", utils::BootKernelDevice("/dev/sda2"));
EXPECT_EQ("/dev/sda2", utils::BootKernelDevice("/dev/sda3"));
EXPECT_EQ("", utils::BootKernelDevice("/dev/sda4"));
EXPECT_EQ("/dev/sda4", utils::BootKernelDevice("/dev/sda5"));
EXPECT_EQ("", utils::BootKernelDevice("/dev/sda6"));
EXPECT_EQ("/dev/sda6", utils::BootKernelDevice("/dev/sda7"));
EXPECT_EQ("", utils::BootKernelDevice("/dev/sda8"));
EXPECT_EQ("", utils::BootKernelDevice("/dev/sda9"));
}
TEST(UtilsTest, RecursiveUnlinkDirTest) {
EXPECT_EQ(0, mkdir("RecursiveUnlinkDirTest-a", 0755));
EXPECT_EQ(0, mkdir("RecursiveUnlinkDirTest-b", 0755));
EXPECT_EQ(0, symlink("../RecursiveUnlinkDirTest-a",
"RecursiveUnlinkDirTest-b/link"));
EXPECT_EQ(0, system("echo hi > RecursiveUnlinkDirTest-b/file"));
EXPECT_EQ(0, mkdir("RecursiveUnlinkDirTest-b/dir", 0755));
EXPECT_EQ(0, system("echo ok > RecursiveUnlinkDirTest-b/dir/subfile"));
EXPECT_TRUE(utils::RecursiveUnlinkDir("RecursiveUnlinkDirTest-b"));
EXPECT_TRUE(utils::FileExists("RecursiveUnlinkDirTest-a"));
EXPECT_EQ(0, system("rm -rf RecursiveUnlinkDirTest-a"));
EXPECT_FALSE(utils::FileExists("RecursiveUnlinkDirTest-b"));
EXPECT_TRUE(utils::RecursiveUnlinkDir("/something/that/doesnt/exist"));
}
TEST(UtilsTest, IsSymlinkTest) {
string temp_dir;
EXPECT_TRUE(utils::MakeTempDirectory("/tmp/symlink-test.XXXXXX", &temp_dir));
string temp_file = temp_dir + "temp-file";
EXPECT_TRUE(utils::WriteFile(temp_file.c_str(), "", 0));
string temp_symlink = temp_dir + "temp-symlink";
EXPECT_EQ(0, symlink(temp_file.c_str(), temp_symlink.c_str()));
EXPECT_FALSE(utils::IsSymlink(temp_dir.c_str()));
EXPECT_FALSE(utils::IsSymlink(temp_file.c_str()));
EXPECT_TRUE(utils::IsSymlink(temp_symlink.c_str()));
EXPECT_FALSE(utils::IsSymlink("/non/existent/path"));
EXPECT_TRUE(utils::RecursiveUnlinkDir(temp_dir));
}
TEST(UtilsTest, TempFilenameTest) {
const string original = "/foo.XXXXXX";
const string result = utils::TempFilename(original);
EXPECT_EQ(original.size(), result.size());
EXPECT_TRUE(utils::StringHasPrefix(result, "/foo."));
EXPECT_FALSE(utils::StringHasSuffix(result, "XXXXXX"));
}
TEST(UtilsTest, RootDeviceTest) {
EXPECT_EQ("/dev/sda", utils::RootDevice("/dev/sda3"));
EXPECT_EQ("/dev/mmc0", utils::RootDevice("/dev/mmc0p3"));
EXPECT_EQ("", utils::RootDevice("/dev/foo/bar"));
EXPECT_EQ("", utils::RootDevice("/"));
EXPECT_EQ("", utils::RootDevice(""));
}
TEST(UtilsTest, SysfsBlockDeviceTest) {
EXPECT_EQ("/sys/block/sda", utils::SysfsBlockDevice("/dev/sda"));
EXPECT_EQ("", utils::SysfsBlockDevice("/foo/sda"));
EXPECT_EQ("", utils::SysfsBlockDevice("/dev/foo/bar"));
EXPECT_EQ("", utils::SysfsBlockDevice("/"));
EXPECT_EQ("", utils::SysfsBlockDevice("./"));
EXPECT_EQ("", utils::SysfsBlockDevice(""));
}
TEST(UtilsTest, IsRemovableDeviceTest) {
EXPECT_FALSE(utils::IsRemovableDevice(""));
EXPECT_FALSE(utils::IsRemovableDevice("/dev/non-existent-device"));
}
TEST(UtilsTest, PartitionNumberTest) {
EXPECT_EQ("3", utils::PartitionNumber("/dev/sda3"));
EXPECT_EQ("3", utils::PartitionNumber("/dev/mmc0p3"));
}
TEST(UtilsTest, CompareCpuSharesTest) {
EXPECT_LT(utils::CompareCpuShares(utils::kCpuSharesLow,
utils::kCpuSharesNormal), 0);
EXPECT_GT(utils::CompareCpuShares(utils::kCpuSharesNormal,
utils::kCpuSharesLow), 0);
EXPECT_EQ(utils::CompareCpuShares(utils::kCpuSharesNormal,
utils::kCpuSharesNormal), 0);
EXPECT_GT(utils::CompareCpuShares(utils::kCpuSharesHigh,
utils::kCpuSharesNormal), 0);
}
TEST(UtilsTest, FuzzIntTest) {
static const unsigned int kRanges[] = { 0, 1, 2, 20 };
for (size_t r = 0; r < arraysize(kRanges); ++r) {
unsigned int range = kRanges[r];
const int kValue = 50;
for (int tries = 0; tries < 100; ++tries) {
int value = utils::FuzzInt(kValue, range);
EXPECT_GE(value, kValue - range / 2);
EXPECT_LE(value, kValue + range - range / 2);
}
}
}
TEST(UtilsTest, ApplyMapTest) {
int initial_values[] = {1, 2, 3, 4, 6};
vector<int> collection(&initial_values[0],
initial_values + arraysize(initial_values));
EXPECT_EQ(arraysize(initial_values), collection.size());
int expected_values[] = {1, 2, 5, 4, 8};
map<int, int> value_map;
value_map[3] = 5;
value_map[6] = 8;
value_map[5] = 10;
utils::ApplyMap(&collection, value_map);
size_t index = 0;
for (vector<int>::iterator it = collection.begin(), e = collection.end();
it != e; ++it) {
EXPECT_EQ(expected_values[index++], *it);
}
}
TEST(UtilsTest, RunAsRootGetFilesystemSizeTest) {
string img;
EXPECT_TRUE(utils::MakeTempFile("/tmp/img.XXXXXX", &img, NULL));
ScopedPathUnlinker img_unlinker(img);
CreateExtImageAtPath(img, NULL);
// Extend the "partition" holding the file system from 10MiB to 20MiB.
EXPECT_EQ(0, System(base::StringPrintf(
"dd if=/dev/zero of=%s seek=20971519 bs=1 count=1",
img.c_str())));
EXPECT_EQ(20 * 1024 * 1024, utils::FileSize(img));
int block_count = 0;
int block_size = 0;
EXPECT_TRUE(utils::GetFilesystemSize(img, &block_count, &block_size));
EXPECT_EQ(4096, block_size);
EXPECT_EQ(10 * 1024 * 1024 / 4096, block_count);
}
namespace {
gboolean TerminateScheduleCrashReporterUploadTest(void* arg) {
GMainLoop* loop = reinterpret_cast<GMainLoop*>(arg);
g_main_loop_quit(loop);
return FALSE; // Don't call this callback again
}
} // namespace {}
TEST(UtilsTest, ScheduleCrashReporterUploadTest) {
// Not much to test. At least this tests for memory leaks, crashes,
// log errors.
GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
utils::ScheduleCrashReporterUpload();
g_timeout_add_seconds(1, &TerminateScheduleCrashReporterUploadTest, loop);
g_main_loop_run(loop);
g_main_loop_unref(loop);
}
TEST(UtilsTest, FormatTimeDeltaTest) {
// utils::FormatTimeDelta() is not locale-aware (it's only used for logging
// which is not localized) so we only need to test the C locale
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromMilliseconds(100)),
"0.1s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(0)),
"0s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(1)),
"1s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(59)),
"59s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(60)),
"1m0s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(61)),
"1m1s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(90)),
"1m30s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(1205)),
"20m5s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(3600)),
"1h0m0s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(3601)),
"1h0m1s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(3661)),
"1h1m1s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(7261)),
"2h1m1s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(86400)),
"1d0h0m0s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(86401)),
"1d0h0m1s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(200000)),
"2d7h33m20s");
EXPECT_EQ(utils::FormatTimeDelta(base::TimeDelta::FromSeconds(200000) +
base::TimeDelta::FromMilliseconds(1)),
"2d7h33m20.001s");
}
} // namespace chromeos_update_engine