src/native_client_sdk/src/tests/nacl_io_test/path_test.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 <fcntl.h>
   6
   7 #include "gtest/gtest.h"
   8
   9 #include "nacl_io/kernel_proxy.h"
  10 #include "nacl_io/path.h"
  11
  12 using namespace nacl_io;
  13
  14 TEST(PathTest, SanityChecks) {
  15   // can we construct and delete?
  16   Path ph1(".");
  17   Path *ph2 = new Path(".");
  18   delete ph2;
  19
  20   Path p1(".");
  21   EXPECT_FALSE(p1.IsAbsolute());
  22   EXPECT_EQ(".", p1.Join());
  23   Path p2("/");
  24   EXPECT_TRUE(p2.IsAbsolute());
  25   EXPECT_EQ("/", p2.Join());
  26 }
  27
  28 TEST(PathTest, Assignment) {
  29   Path empty;
  30   Path dot(".");
  31   Path root("/");
  32   Path abs_str("/abs/from/string");
  33   Path rel_str("rel/from/string");
  34   Path self_str("./rel/from/string");
  35
  36   EXPECT_EQ(0, empty.Size());
  37   EXPECT_FALSE(empty.IsAbsolute());
  38   EXPECT_EQ(std::string(""), empty.Join());
  39
  40   EXPECT_EQ(1, dot.Size());
  41   EXPECT_FALSE(dot.IsAbsolute());
  42   EXPECT_EQ(std::string("."), dot.Join());
  43
  44   EXPECT_EQ(1, root.Size());
  45   EXPECT_TRUE(root.IsAbsolute());
  46   EXPECT_EQ(std::string("/"), root.Join());
  47
  48   EXPECT_EQ(4, abs_str.Size());
  49   EXPECT_TRUE(abs_str.IsAbsolute());
  50   EXPECT_EQ(std::string("/abs/from/string"), abs_str.Join());
  51
  52   EXPECT_EQ(3, rel_str.Size());
  53   EXPECT_FALSE(rel_str.IsAbsolute());
  54   EXPECT_EQ(std::string("rel/from/string"), rel_str.Join());
  55
  56   EXPECT_EQ(3, self_str.Size());
  57   EXPECT_FALSE(self_str.IsAbsolute());
  58   EXPECT_EQ(std::string("rel/from/string"), self_str.Join());
  59
  60   empty = "";
  61   dot = ".";
  62   root = "/";
  63   abs_str = "/abs/from/assign";
  64   rel_str = "rel/from/assign";
  65   self_str = "./rel/from/assign";
  66
  67   EXPECT_EQ(1, empty.Size());
  68   EXPECT_FALSE(empty.IsAbsolute());
  69   EXPECT_EQ(std::string("."), empty.Join());
  70
  71   EXPECT_EQ(1, dot.Size());
  72   EXPECT_FALSE(dot.IsAbsolute());
  73   EXPECT_EQ(std::string("."), dot.Join());
  74
  75   EXPECT_EQ(1, root.Size());
  76   EXPECT_TRUE(root.IsAbsolute());
  77   EXPECT_EQ(std::string("/"), root.Join());
  78
  79   EXPECT_EQ(4, abs_str.Size());
  80   EXPECT_TRUE(abs_str.IsAbsolute());
  81   EXPECT_EQ(std::string("/abs/from/assign"), abs_str.Join());
  82
  83   EXPECT_EQ(3, rel_str.Size());
  84   EXPECT_FALSE(rel_str.IsAbsolute());
  85   EXPECT_EQ(std::string("rel/from/assign"), rel_str.Join());
  86
  87   EXPECT_EQ(3, self_str.Size());
  88   EXPECT_FALSE(self_str.IsAbsolute());
  89   EXPECT_EQ(std::string("rel/from/assign"), self_str.Join());
  90
  91   Path cpy_str;
  92   cpy_str = empty;
  93   EXPECT_EQ(1, cpy_str.Size());
  94   EXPECT_FALSE(cpy_str.IsAbsolute());
  95   EXPECT_EQ(std::string("."), cpy_str.Join());
  96
  97   cpy_str = dot;
  98   EXPECT_EQ(1, cpy_str.Size());
  99   EXPECT_FALSE(cpy_str.IsAbsolute());
 100   EXPECT_EQ(std::string("."), cpy_str.Join());
 101
 102   cpy_str = root;
 103   EXPECT_EQ(1, cpy_str.Size());
 104   EXPECT_TRUE(cpy_str.IsAbsolute());
 105   EXPECT_EQ(std::string("/"), cpy_str.Join());
 106
 107   cpy_str = abs_str;
 108   EXPECT_EQ(4, cpy_str.Size());
 109   EXPECT_TRUE(cpy_str.IsAbsolute());
 110   EXPECT_EQ(std::string("/abs/from/assign"), cpy_str.Join());
 111
 112   cpy_str = rel_str;
 113   EXPECT_EQ(3, cpy_str.Size());
 114   EXPECT_FALSE(cpy_str.IsAbsolute());
 115   EXPECT_EQ(std::string("rel/from/assign"), cpy_str.Join());
 116
 117   cpy_str = self_str;
 118   EXPECT_EQ(3, cpy_str.Size());
 119   EXPECT_FALSE(cpy_str.IsAbsolute());
 120   EXPECT_EQ(std::string("rel/from/assign"), cpy_str.Join());
 121 }
 122
 123
 124 TEST(PathTest, Collapse) {
 125   StringArray_t path_components;
 126
 127   Path p1("/simple/splitter/test");
 128   path_components = p1.Split();
 129   EXPECT_EQ("/", path_components[0]);
 130   EXPECT_EQ("/", p1.Part(0));
 131
 132   EXPECT_EQ("simple", path_components[1]);
 133   EXPECT_EQ("simple", p1.Part(1));
 134
 135   EXPECT_EQ("splitter",path_components[2]);
 136   EXPECT_EQ("splitter",p1.Part(2));
 137
 138   EXPECT_EQ("test", path_components[3]);
 139   EXPECT_EQ("test", p1.Part(3));
 140
 141   Path p2("///simple//splitter///test/");
 142   path_components = p2.Split();
 143   EXPECT_EQ(4, static_cast<int>(path_components.size()));
 144   EXPECT_EQ(4, static_cast<int>(p2.Size()));
 145   EXPECT_EQ("/", path_components[0]);
 146   EXPECT_EQ("simple", path_components[1]);
 147   EXPECT_EQ("splitter", path_components[2]);
 148   EXPECT_EQ("test", path_components[3]);
 149
 150   Path p3("sim/ple//spli/tter/te/st/");
 151   path_components = p3.Split();
 152   EXPECT_EQ(6, static_cast<int>(path_components.size()));
 153   EXPECT_FALSE(p3.IsAbsolute());
 154   EXPECT_EQ("sim", path_components[0]);
 155   EXPECT_EQ("ple", path_components[1]);
 156   EXPECT_EQ("spli", path_components[2]);
 157   EXPECT_EQ("tter", path_components[3]);
 158   EXPECT_EQ("te", path_components[4]);
 159   EXPECT_EQ("st", path_components[5]);
 160
 161   Path p4("");
 162   path_components = p4.Split();
 163   EXPECT_EQ(1, static_cast<int>(path_components.size()));
 164
 165   Path p5("/");
 166   path_components = p5.Split();
 167   EXPECT_EQ(1, static_cast<int>(path_components.size()));
 168 }
 169
 170 TEST(PathTest, AppendAndJoin) {
 171   Path ph1("/usr/local/hi/there");
 172
 173   EXPECT_EQ("/usr/local/hi/there", ph1.Join());
 174   ph1 = ph1.Append("..");
 175   EXPECT_EQ("/usr/local/hi", ph1.Join());
 176   ph1 = ph1.Append(".././././hi/there/../.././././");
 177   EXPECT_EQ("/usr/local", ph1.Join());
 178   ph1 = ph1.Append("../../../../../../../../././../");
 179   EXPECT_EQ("/", ph1.Join());
 180   ph1 = ph1.Append("usr/lib/../bin/.././etc/../local/../share");
 181   EXPECT_EQ("/usr/share", ph1.Join());
 182
 183   Path ph2("./");
 184   EXPECT_EQ(".", ph2.Join());
 185
 186   Path ph3("/");
 187   EXPECT_EQ("/", ph3.Join());
 188   ph3 = ph3.Append("");
 189   EXPECT_EQ("/", ph3.Join());
 190   ph3 = ph3.Append("USR/local/SHARE");
 191   EXPECT_EQ("/USR/local/SHARE", ph3.Join());
 192   ph3 = ph3.Append("///////////////////////////////");
 193   EXPECT_EQ("/USR/local/SHARE", ph3.Join());
 194
 195   Path ph4("..");
 196   EXPECT_EQ("..", ph4.Join());
 197   ph4 = ph4.Append("/node1/node3/../../node1/./");
 198   EXPECT_EQ("../node1", ph4.Join());
 199   ph4 = ph4.Append("node4/../../node1/./node5");
 200   EXPECT_EQ("../node1/node5", ph4.Join());
 201 }
 202
 203
 204 TEST(PathTest, Invalid) {
 205   Path rooted("/usr/local");
 206   Path current("./usr/local");
 207   Path relative("usr/local");
 208
 209   Path test;
 210
 211   test = rooted;
 212   test.Append("../..");
 213   EXPECT_EQ("/", test.Join());
 214
 215   test = rooted;
 216   test.Append("../../..");
 217   EXPECT_EQ("/", test.Join());
 218
 219   test = rooted;
 220   test.Append("../../../foo");
 221   EXPECT_EQ("/foo", test.Join());
 222
 223   test = current;
 224   test.Append("../..");
 225   EXPECT_EQ(".", test.Join());
 226
 227   test = current;
 228   test.Append("../../..");
 229   EXPECT_EQ("..", test.Join());
 230
 231   test = current;
 232   test.Append("../../../foo");
 233   EXPECT_EQ("../foo", test.Join());
 234
 235   test = relative;
 236   test.Append("../..");
 237   EXPECT_EQ(".", test.Join());
 238
 239   test = relative;
 240   test.Append("../../..");
 241   EXPECT_EQ("..", test.Join());
 242
 243   test = relative;
 244   test.Append("../../../foo");
 245   EXPECT_EQ("../foo", test.Join());
 246 }
 247
 248 TEST(PathTest, Range) {
 249   Path p("/an/absolute/path");
 250
 251   // p's parts should be ["/", "an", "absolute", "path"].
 252   EXPECT_EQ("/an/absolute/path", p.Range(0, 4));
 253   EXPECT_EQ("an/absolute/path", p.Range(1, 4));
 254   EXPECT_EQ("absolute/path", p.Range(2, 4));
 255   EXPECT_EQ("path", p.Range(3, 4));
 256
 257   EXPECT_EQ("/an/absolute", p.Range(0, 3));
 258   EXPECT_EQ("an/absolute", p.Range(1, 3));
 259   EXPECT_EQ("absolute", p.Range(2, 3));
 260 }
 261