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