src/webkit/common/fileapi/file_system_util_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "webkit/common/fileapi/file_system_util.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9 #include "url/gurl.h"
  10
  11 namespace fileapi {
  12 namespace {
  13
  14 class FileSystemUtilTest : public testing::Test {};
  15
  16 TEST_F(FileSystemUtilTest, ParseFileSystemSchemeURL) {
  17   GURL uri("filesystem:http://chromium.org/temporary/foo/bar");
  18   GURL origin_url;
  19   FileSystemType type;
  20   base::FilePath virtual_path;
  21   ParseFileSystemSchemeURL(uri, &origin_url, &type, &virtual_path);
  22   EXPECT_EQ(GURL("http://chromium.org"), origin_url);
  23   EXPECT_EQ(fileapi::kFileSystemTypeTemporary, type);
  24 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
  25   base::FilePath expected_path(FILE_PATH_LITERAL("foo\\bar"));
  26 #else
  27   base::FilePath expected_path(FILE_PATH_LITERAL("foo/bar"));
  28 #endif
  29   EXPECT_EQ(expected_path, virtual_path);
  30 }
  31
  32 TEST_F(FileSystemUtilTest, GetTempFileSystemRootURI) {
  33   GURL origin_url("http://chromium.org");
  34   fileapi::FileSystemType type = fileapi::kFileSystemTypeTemporary;
  35   GURL uri = GURL("filesystem:http://chromium.org/temporary/");
  36   EXPECT_EQ(uri, GetFileSystemRootURI(origin_url, type));
  37 }
  38
  39 TEST_F(FileSystemUtilTest, GetPersistentFileSystemRootURI) {
  40   GURL origin_url("http://chromium.org");
  41   fileapi::FileSystemType type = fileapi::kFileSystemTypePersistent;
  42   GURL uri = GURL("filesystem:http://chromium.org/persistent/");
  43   EXPECT_EQ(uri, GetFileSystemRootURI(origin_url, type));
  44 }
  45
  46 TEST_F(FileSystemUtilTest, VirtualPathBaseName) {
  47   struct test_data {
  48     const base::FilePath::StringType path;
  49     const base::FilePath::StringType base_name;
  50   } test_cases[] = {
  51     { FILE_PATH_LITERAL("foo/bar"), FILE_PATH_LITERAL("bar") },
  52     { FILE_PATH_LITERAL("foo/b:bar"), FILE_PATH_LITERAL("b:bar") },
  53     { FILE_PATH_LITERAL(""), FILE_PATH_LITERAL("") },
  54     { FILE_PATH_LITERAL("/"), FILE_PATH_LITERAL("/") },
  55     { FILE_PATH_LITERAL("foo//////bar"), FILE_PATH_LITERAL("bar") },
  56     { FILE_PATH_LITERAL("foo/bar/"), FILE_PATH_LITERAL("bar") },
  57     { FILE_PATH_LITERAL("foo/bar/////"), FILE_PATH_LITERAL("bar") },
  58     { FILE_PATH_LITERAL("/bar/////"), FILE_PATH_LITERAL("bar") },
  59     { FILE_PATH_LITERAL("bar/////"), FILE_PATH_LITERAL("bar") },
  60     { FILE_PATH_LITERAL("bar/"), FILE_PATH_LITERAL("bar") },
  61     { FILE_PATH_LITERAL("/bar"), FILE_PATH_LITERAL("bar") },
  62     { FILE_PATH_LITERAL("////bar"), FILE_PATH_LITERAL("bar") },
  63     { FILE_PATH_LITERAL("bar"), FILE_PATH_LITERAL("bar") }
  64   };
  65   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
  66     base::FilePath input = base::FilePath(test_cases[i].path);
  67     base::FilePath base_name = VirtualPath::BaseName(input);
  68     EXPECT_EQ(test_cases[i].base_name, base_name.value());
  69   }
  70 }
  71
  72 TEST_F(FileSystemUtilTest, VirtualPathDirName) {
  73   struct test_data {
  74     const base::FilePath::StringType path;
  75     const base::FilePath::StringType dir_name;
  76   } test_cases[] = {
  77     { FILE_PATH_LITERAL("foo/bar"), FILE_PATH_LITERAL("foo") },
  78     { FILE_PATH_LITERAL("foo/b:bar"), FILE_PATH_LITERAL("foo") },
  79     { FILE_PATH_LITERAL(""), FILE_PATH_LITERAL(".") },
  80     { FILE_PATH_LITERAL("/"), FILE_PATH_LITERAL("/") },
  81     { FILE_PATH_LITERAL("foo//////bar"), FILE_PATH_LITERAL("foo") },
  82     { FILE_PATH_LITERAL("foo/bar/"), FILE_PATH_LITERAL("foo") },
  83     { FILE_PATH_LITERAL("foo/bar/////"), FILE_PATH_LITERAL("foo") },
  84     { FILE_PATH_LITERAL("/bar/////"), FILE_PATH_LITERAL("/") },
  85     { FILE_PATH_LITERAL("bar/////"), FILE_PATH_LITERAL(".") },
  86     { FILE_PATH_LITERAL("bar/"), FILE_PATH_LITERAL(".") },
  87     { FILE_PATH_LITERAL("/bar"), FILE_PATH_LITERAL("/") },
  88     { FILE_PATH_LITERAL("////bar"), FILE_PATH_LITERAL("/") },
  89     { FILE_PATH_LITERAL("bar"), FILE_PATH_LITERAL(".") },
  90     { FILE_PATH_LITERAL("c:bar"), FILE_PATH_LITERAL(".") },
  91 #ifdef FILE_PATH_USES_WIN_SEPARATORS
  92     { FILE_PATH_LITERAL("foo\\bar"), FILE_PATH_LITERAL("foo") },
  93     { FILE_PATH_LITERAL("foo\\b:bar"), FILE_PATH_LITERAL("foo") },
  94     { FILE_PATH_LITERAL("\\"), FILE_PATH_LITERAL("\\") },
  95     { FILE_PATH_LITERAL("foo\\\\\\\\\\\\bar"), FILE_PATH_LITERAL("foo") },
  96     { FILE_PATH_LITERAL("foo\\bar\\"), FILE_PATH_LITERAL("foo") },
  97     { FILE_PATH_LITERAL("foo\\bar\\\\\\\\\\"), FILE_PATH_LITERAL("foo") },
  98     { FILE_PATH_LITERAL("\\bar\\\\\\\\\\"), FILE_PATH_LITERAL("\\") },
  99     { FILE_PATH_LITERAL("bar\\\\\\\\\\"), FILE_PATH_LITERAL(".") },
 100     { FILE_PATH_LITERAL("bar\\"), FILE_PATH_LITERAL(".") },
 101     { FILE_PATH_LITERAL("\\bar"), FILE_PATH_LITERAL("\\") },
 102     { FILE_PATH_LITERAL("\\\\\\\\bar"), FILE_PATH_LITERAL("\\") },
 103 #endif
 104   };
 105   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
 106     base::FilePath input = base::FilePath(test_cases[i].path);
 107     base::FilePath dir_name = VirtualPath::DirName(input);
 108     EXPECT_EQ(test_cases[i].dir_name, dir_name.value());
 109   }
 110 }
 111
 112 TEST_F(FileSystemUtilTest, GetNormalizedFilePath) {
 113   struct test_data {
 114     const base::FilePath::StringType path;
 115     const base::FilePath::StringType normalized_path;
 116   } test_cases[] = {
 117     { FILE_PATH_LITERAL(""), FILE_PATH_LITERAL("/") },
 118     { FILE_PATH_LITERAL("/"), FILE_PATH_LITERAL("/") },
 119     { FILE_PATH_LITERAL("foo/bar"), FILE_PATH_LITERAL("/foo/bar") },
 120     { FILE_PATH_LITERAL("/foo/bar"), FILE_PATH_LITERAL("/foo/bar") },
 121 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
 122     { FILE_PATH_LITERAL("\\foo"), FILE_PATH_LITERAL("/foo") },
 123 #endif
 124   };
 125   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
 126     base::FilePath input = base::FilePath(test_cases[i].path);
 127     base::FilePath::StringType normalized_path_string =
 128         VirtualPath::GetNormalizedFilePath(input);
 129     EXPECT_EQ(test_cases[i].normalized_path, normalized_path_string);
 130   }
 131 }
 132
 133 TEST_F(FileSystemUtilTest, IsAbsolutePath) {
 134   EXPECT_TRUE(VirtualPath::IsAbsolute(FILE_PATH_LITERAL("/")));
 135   EXPECT_TRUE(VirtualPath::IsAbsolute(FILE_PATH_LITERAL("/foo/bar")));
 136   EXPECT_FALSE(VirtualPath::IsAbsolute(base::FilePath::StringType()));
 137   EXPECT_FALSE(VirtualPath::IsAbsolute(FILE_PATH_LITERAL("foo/bar")));
 138 }
 139
 140 TEST_F(FileSystemUtilTest, IsRootPath) {
 141   EXPECT_TRUE(VirtualPath::IsRootPath(base::FilePath(FILE_PATH_LITERAL(""))));
 142   EXPECT_TRUE(VirtualPath::IsRootPath(base::FilePath()));
 143   EXPECT_TRUE(VirtualPath::IsRootPath(base::FilePath(FILE_PATH_LITERAL("/"))));
 144   EXPECT_TRUE(VirtualPath::IsRootPath(base::FilePath(FILE_PATH_LITERAL("//"))));
 145   EXPECT_FALSE(VirtualPath::IsRootPath(
 146       base::FilePath(FILE_PATH_LITERAL("c:/"))));
 147 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
 148   EXPECT_TRUE(VirtualPath::IsRootPath(base::FilePath(FILE_PATH_LITERAL("\\"))));
 149   EXPECT_FALSE(VirtualPath::IsRootPath(
 150       base::FilePath(FILE_PATH_LITERAL("c:\\"))));
 151 #endif
 152 }
 153
 154 TEST_F(FileSystemUtilTest, VirtualPathGetComponents) {
 155   struct test_data {
 156     const base::FilePath::StringType path;
 157     size_t count;
 158     const base::FilePath::StringType components[3];
 159   } test_cases[] = {
 160     { FILE_PATH_LITERAL("foo/bar"),
 161       2,
 162       { FILE_PATH_LITERAL("foo"), FILE_PATH_LITERAL("bar") } },
 163     { FILE_PATH_LITERAL("foo"),
 164       1,
 165       { FILE_PATH_LITERAL("foo") } },
 166     { FILE_PATH_LITERAL("foo////bar"),
 167       2,
 168       { FILE_PATH_LITERAL("foo"), FILE_PATH_LITERAL("bar") } },
 169     { FILE_PATH_LITERAL("foo/c:bar"),
 170       2,
 171       { FILE_PATH_LITERAL("foo"), FILE_PATH_LITERAL("c:bar") } },
 172     { FILE_PATH_LITERAL("c:foo/bar"),
 173       2,
 174       { FILE_PATH_LITERAL("c:foo"), FILE_PATH_LITERAL("bar") } },
 175     { FILE_PATH_LITERAL("foo/bar"),
 176       2,
 177       { FILE_PATH_LITERAL("foo"), FILE_PATH_LITERAL("bar") } },
 178     { FILE_PATH_LITERAL("/foo/bar"),
 179       2,
 180       { FILE_PATH_LITERAL("foo"), FILE_PATH_LITERAL("bar") } },
 181     { FILE_PATH_LITERAL("c:/bar"),
 182       2,
 183       { FILE_PATH_LITERAL("c:"), FILE_PATH_LITERAL("bar") } },
 184 #ifdef FILE_PATH_USES_WIN_SEPARATORS
 185     { FILE_PATH_LITERAL("c:\\bar"),
 186       2,
 187       { FILE_PATH_LITERAL("c:"), FILE_PATH_LITERAL("bar") } },
 188 #endif
 189   };
 190   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
 191     base::FilePath input = base::FilePath(test_cases[i].path);
 192     std::vector<base::FilePath::StringType> components;
 193     VirtualPath::GetComponents(input, &components);
 194     EXPECT_EQ(test_cases[i].count, components.size());
 195     for (size_t j = 0; j < components.size(); ++j)
 196       EXPECT_EQ(test_cases[i].components[j], components[j]);
 197   }
 198   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
 199     base::FilePath input = base::FilePath(test_cases[i].path);
 200     std::vector<std::string> components;
 201     VirtualPath::GetComponentsUTF8Unsafe(input, &components);
 202     EXPECT_EQ(test_cases[i].count, components.size());
 203     for (size_t j = 0; j < components.size(); ++j) {
 204       EXPECT_EQ(base::FilePath(test_cases[i].components[j]).AsUTF8Unsafe(),
 205                 components[j]);
 206     }
 207   }
 208 }
 209
 210 TEST_F(FileSystemUtilTest, GetIsolatedFileSystemName) {
 211   GURL origin_url("http://foo");
 212   std::string fsname1 = GetIsolatedFileSystemName(origin_url, "bar");
 213   EXPECT_EQ("http_foo_0:Isolated_bar", fsname1);
 214 }
 215
 216 TEST_F(FileSystemUtilTest, CrackIsolatedFileSystemName) {
 217   std::string fsid;
 218   EXPECT_TRUE(CrackIsolatedFileSystemName("foo:Isolated_bar", &fsid));
 219   EXPECT_EQ("bar", fsid);
 220   EXPECT_TRUE(CrackIsolatedFileSystemName("foo:isolated_bar", &fsid));
 221   EXPECT_EQ("bar", fsid);
 222   EXPECT_TRUE(CrackIsolatedFileSystemName("foo:Isolated__bar", &fsid));
 223   EXPECT_EQ("_bar", fsid);
 224   EXPECT_TRUE(CrackIsolatedFileSystemName("foo::Isolated_bar", &fsid));
 225   EXPECT_EQ("bar", fsid);
 226 }
 227
 228 TEST_F(FileSystemUtilTest, RejectBadIsolatedFileSystemName) {
 229   std::string fsid;
 230   EXPECT_FALSE(CrackIsolatedFileSystemName("foobar", &fsid));
 231   EXPECT_FALSE(CrackIsolatedFileSystemName("foo:_bar", &fsid));
 232   EXPECT_FALSE(CrackIsolatedFileSystemName("foo:Isolatedbar", &fsid));
 233   EXPECT_FALSE(CrackIsolatedFileSystemName("fooIsolatedbar", &fsid));
 234   EXPECT_FALSE(CrackIsolatedFileSystemName("foo:Persistent", &fsid));
 235   EXPECT_FALSE(CrackIsolatedFileSystemName("foo:Temporary", &fsid));
 236   EXPECT_FALSE(CrackIsolatedFileSystemName("foo:External", &fsid));
 237   EXPECT_FALSE(CrackIsolatedFileSystemName(":Isolated_bar", &fsid));
 238   EXPECT_FALSE(CrackIsolatedFileSystemName("foo:Isolated_", &fsid));
 239 }
 240
 241 TEST_F(FileSystemUtilTest, ValidateIsolatedFileSystemId) {
 242   EXPECT_TRUE(ValidateIsolatedFileSystemId("ABCDEF0123456789ABCDEF0123456789"));
 243   EXPECT_TRUE(ValidateIsolatedFileSystemId("ABCDEFABCDEFABCDEFABCDEFABCDEFAB"));
 244   EXPECT_TRUE(ValidateIsolatedFileSystemId("01234567890123456789012345678901"));
 245
 246   const size_t kExpectedFileSystemIdSize = 32;
 247
 248   // Should not contain lowercase characters.
 249   const std::string kLowercaseId = "abcdef0123456789abcdef0123456789";
 250   EXPECT_EQ(kExpectedFileSystemIdSize, kLowercaseId.size());
 251   EXPECT_FALSE(ValidateIsolatedFileSystemId(kLowercaseId));
 252
 253   // Should not be shorter/longer than expected.
 254   EXPECT_FALSE(ValidateIsolatedFileSystemId(std::string()));
 255
 256   const std::string kShorterId = "ABCDEF0123456789ABCDEF";
 257   EXPECT_GT(kExpectedFileSystemIdSize, kShorterId.size());
 258   EXPECT_FALSE(ValidateIsolatedFileSystemId(kShorterId));
 259
 260   const std::string kLongerId = "ABCDEF0123456789ABCDEF0123456789ABCDEF";
 261   EXPECT_LT(kExpectedFileSystemIdSize, kLongerId.size());
 262   EXPECT_FALSE(ValidateIsolatedFileSystemId(kLongerId));
 263
 264   // Should not contain not alphabetical nor numerical characters.
 265   const std::string kSlashId = "ABCD/EFGH/IJKL/MNOP/QRST/UVWX/YZ";
 266   EXPECT_EQ(kExpectedFileSystemIdSize, kSlashId.size());
 267   EXPECT_FALSE(ValidateIsolatedFileSystemId(kSlashId));
 268
 269   const std::string kBackslashId = "ABCD\\EFGH\\IJKL\\MNOP\\QRST\\UVWX\\YZ";
 270   EXPECT_EQ(kExpectedFileSystemIdSize, kBackslashId.size());
 271   EXPECT_FALSE(ValidateIsolatedFileSystemId(kBackslashId));
 272
 273   const std::string kSpaceId = "ABCD EFGH IJKL MNOP QRST UVWX YZ";
 274   EXPECT_EQ(kExpectedFileSystemIdSize, kSpaceId.size());
 275   EXPECT_FALSE(ValidateIsolatedFileSystemId(kSpaceId));
 276 }
 277
 278 }  // namespace
 279 }  // namespace fileapi