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, Empty) {
  15   Path p;
  16   EXPECT_FALSE(p.IsAbsolute());
  17   EXPECT_FALSE(p.IsRoot());
  18   EXPECT_EQ(0, p.Size());
  19   EXPECT_EQ("", p.Basename());
  20   EXPECT_EQ("", p.Join());
  21   EXPECT_EQ("", p.Range(0, 0));
  22   EXPECT_EQ("", p.Parent().Join());
  23 }
  24
  25 TEST(PathTest, Dot) {
  26   Path p(".");
  27   EXPECT_FALSE(p.IsAbsolute());
  28   EXPECT_FALSE(p.IsRoot());
  29   EXPECT_EQ(1, p.Size());
  30   EXPECT_EQ(".", p.Part(0));
  31   EXPECT_EQ(".", p.Basename());
  32   EXPECT_EQ(".", p.Join());
  33   EXPECT_EQ(".", p.Range(0, 1));
  34   EXPECT_EQ(".", p.Parent().Join());  // TODO(binji): this is unexpected.
  35 }
  36
  37 TEST(PathTest, Root) {
  38   Path p("/");
  39   EXPECT_TRUE(p.IsAbsolute());
  40   EXPECT_TRUE(p.IsRoot());
  41   EXPECT_EQ(1, p.Size());
  42   EXPECT_EQ("/", p.Part(0));
  43   EXPECT_EQ("/", p.Basename());
  44   EXPECT_EQ("/", p.Join());
  45   EXPECT_EQ("/", p.Range(0, 1));
  46   EXPECT_EQ("/", p.Parent().Join());
  47 }
  48
  49 TEST(PathTest, OnePart_Relative) {
  50   Path p("foo");
  51   EXPECT_FALSE(p.IsAbsolute());
  52   EXPECT_FALSE(p.IsRoot());
  53   EXPECT_EQ(1, p.Size());
  54   EXPECT_EQ("foo", p.Part(0));
  55   EXPECT_EQ("foo", p.Basename());
  56   EXPECT_EQ("foo", p.Join());
  57   EXPECT_EQ("foo", p.Range(0, 1));
  58   EXPECT_EQ("foo", p.Parent().Join());
  59 }
  60
  61 TEST(PathTest, OnePart_Absolute) {
  62   Path p("/foo");
  63   EXPECT_TRUE(p.IsAbsolute());
  64   EXPECT_FALSE(p.IsRoot());
  65   EXPECT_EQ(2, p.Size());
  66   EXPECT_EQ("/", p.Part(0));
  67   EXPECT_EQ("foo", p.Part(1));
  68   EXPECT_EQ("foo", p.Basename());
  69   EXPECT_EQ("/foo", p.Join());
  70   EXPECT_EQ("/", p.Range(0, 1));
  71   EXPECT_EQ("foo", p.Range(1, 2));
  72   EXPECT_EQ("/foo", p.Range(0, 2));
  73   EXPECT_EQ("", p.Range(2, 2));
  74   EXPECT_EQ("/", p.Parent().Join());
  75 }
  76
  77 TEST(PathTest, TwoPart_Relative) {
  78   Path p("foo/bar");
  79   EXPECT_FALSE(p.IsAbsolute());
  80   EXPECT_FALSE(p.IsRoot());
  81   EXPECT_EQ(2, p.Size());
  82   EXPECT_EQ("foo", p.Part(0));
  83   EXPECT_EQ("bar", p.Part(1));
  84   EXPECT_EQ("bar", p.Basename());
  85   EXPECT_EQ("foo/bar", p.Join());
  86   EXPECT_EQ("foo", p.Range(0, 1));
  87   EXPECT_EQ("bar", p.Range(1, 2));
  88   EXPECT_EQ("foo/bar", p.Range(0, 2));
  89   EXPECT_EQ("", p.Range(2, 2));
  90   EXPECT_EQ("foo", p.Parent().Join());
  91 }
  92
  93 TEST(PathTest, MakeRelative) {
  94   EXPECT_EQ("", Path("/").MakeRelative().Join());
  95   EXPECT_EQ("foo/bar/baz", Path("/foo/bar/baz").MakeRelative().Join());
  96   EXPECT_EQ("foo/bar/baz", Path("foo/bar/baz").MakeRelative().Join());
  97 }
  98
  99 TEST(PathTest, Normalize_EmptyComponent) {
 100   EXPECT_EQ("foo/bar", Path("foo//bar").Join());
 101   EXPECT_EQ("/blah", Path("//blah").Join());
 102   EXPECT_EQ("/a/b/c", Path("//a//b//c").Join());
 103   EXPECT_EQ("path/to/dir", Path("path/to/dir/").Join());
 104 }
 105
 106 TEST(PathTest, Normalize_Dot) {
 107   EXPECT_EQ(".", Path(".").Join());
 108   EXPECT_EQ("foo", Path("foo/.").Join());
 109   EXPECT_EQ("foo/bar", Path("foo/./bar").Join());
 110   EXPECT_EQ("blah", Path("./blah").Join());
 111   EXPECT_EQ("stuff", Path("stuff/./.").Join());
 112   EXPECT_EQ("/", Path("/.").Join());
 113 }
 114
 115 TEST(PathTest, Normalize_DotDot_Relative) {
 116   EXPECT_EQ("..", Path("..").Join());
 117   EXPECT_EQ("../..", Path("../..").Join());
 118   EXPECT_EQ(".", Path("foo/..").Join());
 119   EXPECT_EQ("foo", Path("foo/bar/..").Join());
 120   EXPECT_EQ("bar", Path("foo/../bar").Join());
 121   EXPECT_EQ("foo/baz", Path("foo/bar/../baz").Join());
 122 }
 123
 124 TEST(PathTest, Normalize_DotDot_Absolute) {
 125   EXPECT_EQ("/", Path("/..").Join());
 126   EXPECT_EQ("/", Path("/../..").Join());
 127   EXPECT_EQ("/", Path("/foo/..").Join());
 128   EXPECT_EQ("/foo", Path("/foo/bar/..").Join());
 129   EXPECT_EQ("/bar", Path("/foo/../bar").Join());
 130   EXPECT_EQ("/foo/baz", Path("/foo/bar/../baz").Join());
 131 }
 132
 133 TEST(PathTest, Append) {
 134   EXPECT_EQ(".", Path("").Append(Path("")).Join());
 135   EXPECT_EQ("foo", Path("").Append(Path("foo")).Join());
 136   EXPECT_EQ(".", Path(".").Append(Path("")).Join());
 137   EXPECT_EQ("foo", Path(".").Append(Path("foo")).Join());
 138   EXPECT_EQ("foo/bar", Path(".").Append(Path("foo/bar")).Join());
 139   EXPECT_EQ("foo", Path("foo").Append(Path("")).Join());
 140   EXPECT_EQ("foo/bar", Path("foo").Append(Path("bar")).Join());
 141   EXPECT_EQ("foo/bar/quux", Path("foo").Append(Path("bar/quux")).Join());
 142   EXPECT_EQ("foo/and", Path("foo/and/more").Append(Path("..")).Join());
 143 }
 144
 145 TEST(PathTest, Append_Absolute) {
 146   EXPECT_EQ("/", Path("").Append(Path("/")).Join());
 147   EXPECT_EQ("/hello/world", Path("").Append(Path("/hello/world")).Join());
 148   EXPECT_EQ("/", Path(".").Append(Path("/")).Join());
 149   EXPECT_EQ("/goodbye", Path(".").Append(Path("/goodbye")).Join());
 150   EXPECT_EQ("/foo/bar/baz", Path("/a/b").Append(Path("/foo/bar/baz")).Join());
 151 }
 152
 153 TEST(PathTest, Append_Overflow) {
 154   std::string big(PATH_MAX - 5, 'A');
 155   Path p(big.c_str());
 156   p.Append(Path("0123456789"));
 157
 158   std::string part(p.Join());
 159   EXPECT_EQ(PATH_MAX - 1, part.size());
 160 }
 161
 162 TEST(PathTest, Set) {
 163   Path p("/random/path");
 164   EXPECT_EQ("something/else", p.Set("something/else").Join());
 165   // Set should change p, not just return a copy.
 166   EXPECT_EQ("something/else", p.Join());
 167 }
 168
 169 TEST(PathTest, Set_Overflow) {
 170   std::string big(PATH_MAX * 2, 'A');
 171   Path p(big.c_str());
 172   EXPECT_EQ(PATH_MAX - 1, p.Part(0).size());
 173 }
 174
 175 TEST(PathTest, Range_Empty) {
 176   EXPECT_EQ("", Path("/").Range(1, 1));
 177 }
 178
 179 TEST(PathTest, Range_Relative) {
 180   Path p("a/relative/path");
 181
 182   EXPECT_EQ("a", p.Range(0, 1));
 183   EXPECT_EQ("a/relative", p.Range(0, 2));
 184   EXPECT_EQ("a/relative/path", p.Range(0, 3));
 185
 186   EXPECT_EQ("relative", p.Range(1, 2));
 187   EXPECT_EQ("relative/path", p.Range(1, 3));
 188
 189   EXPECT_EQ("path", p.Range(2, 3));
 190
 191   EXPECT_EQ("path", p.Range(2, 100));
 192   EXPECT_EQ("", p.Range(42, 67));
 193 }
 194
 195 TEST(PathTest, Range_Absolute) {
 196   Path p("/an/absolute/path");
 197
 198   EXPECT_EQ("/", p.Range(0, 1));
 199   EXPECT_EQ("/an", p.Range(0, 2));
 200   EXPECT_EQ("/an/absolute", p.Range(0, 3));
 201   EXPECT_EQ("/an/absolute/path", p.Range(0, 4));
 202
 203   EXPECT_EQ("an", p.Range(1, 2));
 204   EXPECT_EQ("an/absolute", p.Range(1, 3));
 205   EXPECT_EQ("an/absolute/path", p.Range(1, 4));
 206
 207   EXPECT_EQ("absolute", p.Range(2, 3));
 208   EXPECT_EQ("absolute/path", p.Range(2, 4));
 209
 210   EXPECT_EQ("path", p.Range(3, 4));
 211
 212   EXPECT_EQ("absolute/path", p.Range(2, 100));
 213   EXPECT_EQ("", p.Range(42, 67));
 214 }
 215
 216 TEST(PathTest, Assign) {
 217   Path p;
 218
 219   p = "foo/bar";
 220   EXPECT_EQ("foo/bar", p.Join());
 221
 222   // Should normalize.
 223   p = "/foo/../bar";
 224   EXPECT_EQ("/bar", p.Join());
 225
 226   p = Path("hi/planet");
 227   EXPECT_EQ("hi/planet", p.Join());
 228 }
 229
 230 TEST(PathTest, Equals) {
 231   EXPECT_TRUE(Path("/foo") == Path("/foo"));
 232   EXPECT_TRUE(Path("foo/../bar") == Path("bar"));
 233   EXPECT_TRUE(Path("one/path") != Path("another/path"));
 234 }
 235