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
12using namespace nacl_io;
13
14TEST(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
28TEST(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("", empty.Join());
39
40  EXPECT_EQ(1, dot.Size());
41  EXPECT_FALSE(dot.IsAbsolute());
42  EXPECT_EQ(".", dot.Join());
43
44  EXPECT_EQ(1, root.Size());
45  EXPECT_TRUE(root.IsAbsolute());
46  EXPECT_EQ("/", root.Join());
47
48  EXPECT_EQ(4, abs_str.Size());
49  EXPECT_TRUE(abs_str.IsAbsolute());
50  EXPECT_EQ("/abs/from/string", abs_str.Join());
51
52  EXPECT_EQ(3, rel_str.Size());
53  EXPECT_FALSE(rel_str.IsAbsolute());
54  EXPECT_EQ("rel/from/string", rel_str.Join());
55
56  EXPECT_EQ(3, self_str.Size());
57  EXPECT_FALSE(self_str.IsAbsolute());
58  EXPECT_EQ("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(".", empty.Join());
70
71  EXPECT_EQ(1, dot.Size());
72  EXPECT_FALSE(dot.IsAbsolute());
73  EXPECT_EQ(".", dot.Join());
74
75  EXPECT_EQ(1, root.Size());
76  EXPECT_TRUE(root.IsAbsolute());
77  EXPECT_EQ("/", root.Join());
78
79  EXPECT_EQ(4, abs_str.Size());
80  EXPECT_TRUE(abs_str.IsAbsolute());
81  EXPECT_EQ("/abs/from/assign", abs_str.Join());
82
83  EXPECT_EQ(3, rel_str.Size());
84  EXPECT_FALSE(rel_str.IsAbsolute());
85  EXPECT_EQ("rel/from/assign", rel_str.Join());
86
87  EXPECT_EQ(3, self_str.Size());
88  EXPECT_FALSE(self_str.IsAbsolute());
89  EXPECT_EQ("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(".", cpy_str.Join());
96
97  cpy_str = dot;
98  EXPECT_EQ(1, cpy_str.Size());
99  EXPECT_FALSE(cpy_str.IsAbsolute());
100  EXPECT_EQ(".", cpy_str.Join());
101
102  cpy_str = root;
103  EXPECT_EQ(1, cpy_str.Size());
104  EXPECT_TRUE(cpy_str.IsAbsolute());
105  EXPECT_EQ("/", 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("/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("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("rel/from/assign", cpy_str.Join());
121}
122
123
124TEST(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
170TEST(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
203TEST(PathTest, Invalid) {
204  Path absolute("/usr/local");
205  Path current("./usr/local");
206  Path relative("usr/local");
207
208  Path test;
209
210  test = absolute;
211  test.Append("../..");
212  EXPECT_EQ("/", test.Join());
213
214  test = absolute;
215  test.Append("../../..");
216  EXPECT_EQ("/", test.Join());
217
218  test = absolute;
219  test.Append("../../../foo");
220  EXPECT_EQ("/foo", test.Join());
221
222  test = current;
223  test.Append("../..");
224  EXPECT_EQ(".", test.Join());
225
226  test = current;
227  test.Append("../../..");
228  EXPECT_EQ("..", test.Join());
229
230  test = current;
231  test.Append("../../../foo");
232  EXPECT_EQ("../foo", test.Join());
233
234  test = relative;
235  test.Append("../..");
236  EXPECT_EQ(".", test.Join());
237
238  test = relative;
239  test.Append("../../..");
240  EXPECT_EQ("..", test.Join());
241
242  test = relative;
243  test.Append("../../../foo");
244  EXPECT_EQ("../foo", test.Join());
245}
246
247TEST(PathTest, Range) {
248  Path p("/an/absolute/path");
249
250  // p's parts should be ["/", "an", "absolute", "path"].
251  EXPECT_EQ("/an/absolute/path", p.Range(0, 4));
252  EXPECT_EQ("an/absolute/path", p.Range(1, 4));
253  EXPECT_EQ("absolute/path", p.Range(2, 4));
254  EXPECT_EQ("path", p.Range(3, 4));
255
256  EXPECT_EQ("/an/absolute", p.Range(0, 3));
257  EXPECT_EQ("an/absolute", p.Range(1, 3));
258  EXPECT_EQ("absolute", p.Range(2, 3));
259}
260
261TEST(PathTest, PrependRelative) {
262  Path p("foo/bar");
263  p.Prepend("prefix");
264  EXPECT_EQ("prefix/foo/bar", p.Join());
265}
266
267TEST(PathTest, PrependAbsolute) {
268  Path p("/foo/bar");
269  p.Prepend("/prefix");
270  EXPECT_EQ("/prefix/foo/bar", p.Join());
271}
272