1/*
2 * Copyright (c) 1998, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24/* @test
25   @bug 4131169 4168988
26   @summary Basic File constructor tests
27 */
28
29
30import java.io.*;
31import java.util.ArrayList;
32
33
34public class Cons {
35
36    private static boolean debug = false;
37    private static boolean old = false;
38    private static boolean win32 = (File.separatorChar == '\\');
39
40
41    private static String cvt(String s) {
42        if (s == null) return s;
43        if (win32) return s.replace('/', '\\');
44        return s;
45    }
46
47    private static String[] slashPerms(String s) {
48        if (!win32) return new String[] { s };
49        if (s == null) return new String[] { s };
50        int i = s.indexOf('/');
51        if (i < 0) return new String[] { s };
52        ArrayList a = new ArrayList();
53        String p1 = s.substring(0, i);
54        String[] p2 = slashPerms(s.substring(i + 1));
55        for (int j = 0; j < p2.length; j++)
56            a.add(p1 + '/' + p2[j]);
57        for (int j = 0; j < p2.length; j++)
58            a.add(p1 + '\\' + p2[j]);
59        return (String[])(a.toArray(new String[a.size()]));
60    }
61
62
63    static class F extends File {
64        String exp;
65
66        public F(String path) {
67            super(path);
68            this.exp = cons(path);
69        }
70
71        public F(String parent, String child) {
72            super(parent, child);
73            this.exp = cons(parent, child);
74        }
75
76        public F(F parent, String child) {
77            super(parent, child);
78            if (parent == null) this.exp = cons((String)null, child);
79            else this.exp = cons(parent, child);
80        }
81
82    }
83
84
85    private static String nos(String s) {
86        if (s == null) return "null";
87        else return "\"" + s + "\"";
88    }
89
90    private static void ok(String ans, String exp) {
91        System.err.println(nos(ans) + " <== " + exp);
92    }
93
94    private static void err(String ans, String exp, String got) throws Exception {
95        System.err.println(nos(ans) + " <-- " + exp + " ==> " + nos(got));
96        if (!debug) {
97            throw new Exception("Mismatch: " + exp + " ==> " + nos(got)
98                                + ", should be " + nos(ans));
99        }
100    }
101
102    private static void ck(String ans, String exp, String got)
103        throws Exception
104    {
105        if ((got == ans) || ((got != null) && got.equals(ans))) ok(ans, exp);
106        else err(ans, exp, got);
107    }
108
109    private static String cons(String arg) {
110        return "new File(" + nos(arg) + ")";
111    }
112
113    private static String cons(String arg1, String arg2) {
114        return "new File(" + nos(arg1) + ", " + nos(arg2) + ")";
115    }
116
117    private static String cons(F arg1, String arg2) {
118        return "new File(" + arg1.exp + ", " + nos(arg2) + ")";
119    }
120
121    private static String op(String exp, String opname) {
122        return exp + "." + opname + "()";
123    }
124
125    private static void ckpnp(F f,
126                              String parent, String name, String path)
127        throws Exception
128    {
129        ck(cvt(path), op(f.exp, "getPath"), f.getPath());
130        ck(cvt(parent), op(f.exp, "getParent"), f.getParent());
131        ck(cvt(name), op(f.exp, "getName"), f.getName());
132    }
133
134    private static void ck1(String arg,
135                            String parent, String name, String path)
136        throws Exception
137    {
138        String[] parg = slashPerms(arg);
139        for (int i = 0; i < parg.length; i++)
140            ckpnp(new F(parg[i]), parent, name, path);
141    }
142
143    private static void ck2(String arg1, String arg2,
144                            String parent, String name, String path)
145        throws Exception
146    {
147        String[] parg1 = slashPerms(arg1);
148        String[] parg2 = slashPerms(arg2);
149        for (int i = 0; i < parg1.length; i++)
150            for (int j = 0; j < parg2.length; j++)
151                ckpnp(new F(parg1[i], parg2[j]), parent, name, path);
152    }
153
154    private static void ck2f(String arg1, String arg2,
155                             String parent, String name, String path)
156        throws Exception
157    {
158        String[] parg1 = slashPerms(arg1);
159        String[] parg2 = slashPerms(arg2);
160        for (int i = 0; i < parg1.length; i++)
161            for (int j = 0; j < parg2.length; j++) {
162                F p = (parg1[i] == null) ? null : new F(parg1[i]);
163                ckpnp(new F(p, parg2[j]), parent, name, path);
164            }
165    }
166
167
168    static void testBoth() throws Exception {
169
170        /* Null/empty constructor cases */
171        ck1("", null, "", "");
172        ck2(null, "", null, "", "");
173        ck2("", "", null, "", "/"); /* ugh */
174        ck2f("", "", null, "", "/");
175        if (!old) {
176            /* throws NullPointerException */
177            ck2f(null, "", null, "", "");
178        }
179
180        /* Separators-in-pathnames cases */
181        ck1("/", null, "", "/");
182        ck2f("/", "", null, "", "/");
183
184        /* One-arg constructor cases */
185        ck1("foo", null, "foo", "foo");
186        ck1("/foo", "/", "foo", "/foo");
187        ck1("/foo/bar", "/foo", "bar", "/foo/bar");
188        ck1("foo/bar", "foo", "bar", "foo/bar");
189        if (!old) {
190            ck1("foo/", null, "foo", "foo");
191            ck1("/foo/", "/", "foo", "/foo");
192            ck1("/foo//", "/", "foo", "/foo");
193            ck1("/foo///", "/", "foo", "/foo");
194            ck1("/foo//bar", "/foo", "bar", "/foo/bar");
195            ck1("/foo/bar//", "/foo", "bar", "/foo/bar");
196            ck1("foo//bar", "foo", "bar", "foo/bar");
197            ck1("foo/bar/", "foo", "bar", "foo/bar");
198            ck1("foo/bar//", "foo", "bar", "foo/bar");
199        }
200
201        /* Two-arg constructor cases, string parent */
202        ck2("foo", "bar", "foo", "bar", "foo/bar");
203        ck2("foo/", "bar", "foo", "bar", "foo/bar");
204        ck2("/foo", "bar", "/foo", "bar", "/foo/bar");
205        ck2("/foo/", "bar", "/foo", "bar", "/foo/bar");
206        if (!old) {
207            ck2("foo//", "bar", "foo", "bar", "foo/bar");
208            ck2("foo", "bar/", "foo", "bar", "foo/bar");
209            ck2("foo", "bar//", "foo", "bar", "foo/bar");
210            ck2("/foo//", "bar", "/foo", "bar", "/foo/bar");
211            ck2("/foo", "bar/", "/foo", "bar", "/foo/bar");
212            ck2("/foo", "bar//", "/foo", "bar", "/foo/bar");
213            ck2("foo", "/bar", "foo", "bar", "foo/bar");
214            ck2("foo", "//bar", "foo", "bar", "foo/bar");
215            ck2("/", "bar", "/", "bar", "/bar");
216            ck2("/", "/bar", "/", "bar", "/bar");
217        }
218
219        /* Two-arg constructor cases, File parent */
220        ck2f("foo", "bar", "foo", "bar", "foo/bar");
221        ck2f("foo/", "bar", "foo", "bar", "foo/bar");
222        ck2f("/foo", "bar", "/foo", "bar", "/foo/bar");
223        ck2f("/foo/", "bar", "/foo", "bar", "/foo/bar");
224        if (!old) {
225            ck2f("foo//", "bar", "foo", "bar", "foo/bar");
226            ck2f("foo", "bar/", "foo", "bar", "foo/bar");
227            ck2f("foo", "bar//", "foo", "bar", "foo/bar");
228            ck2f("/foo//", "bar", "/foo", "bar", "/foo/bar");
229            ck2f("/foo", "bar/", "/foo", "bar", "/foo/bar");
230            ck2f("/foo", "bar//", "/foo", "bar", "/foo/bar");
231            ck2f("foo", "/bar", "foo", "bar", "foo/bar");
232            ck2f("foo", "//bar", "foo", "bar", "foo/bar");
233        }
234    }
235
236
237    static void testUnix() throws Exception {
238
239        /* Separators-in-pathnames cases */
240        if (!old) {
241            ck1("//", null, "", "/");
242        }
243
244        /* One-arg constructor cases */
245        if (!old) {
246            ck1("//foo", "/", "foo", "/foo");
247            ck1("///foo", "/", "foo", "/foo");
248            ck1("//foo/bar", "/foo", "bar", "/foo/bar");
249        }
250
251        /* Two-arg constructors cases, string parent */
252        if (!old) {
253            ck2("//foo", "bar", "/foo", "bar", "/foo/bar");
254        }
255
256        /* Two-arg constructor cases, File parent */
257        if (!old) {
258            ck2f("//foo", "bar", "/foo", "bar", "/foo/bar");
259        }
260
261        File f = new File("/foo");
262        if (! f.isAbsolute()) throw new Exception(f + " should be absolute");
263
264        f = new File("foo");
265        if (f.isAbsolute()) throw new Exception(f + " should not be absolute");
266    }
267
268
269    static void testWin32() throws Exception {
270
271        if (!old) {
272            /* Separators-in-pathnames cases */
273            ck1("//", null, "", "//");
274
275            /* One-arg constructor cases */
276            ck1("//foo", "//", "foo", "//foo");
277            ck1("///foo", "//", "foo", "//foo");
278            ck1("//foo/bar", "//foo", "bar", "//foo/bar");
279
280            ck1("z:", null, "", "z:");
281            ck1("z:/", null, "", "z:/");
282            ck1("z://", null, "", "z:/");
283            ck1("z:/foo", "z:/", "foo", "z:/foo");
284            ck1("z:/foo/", "z:/", "foo", "z:/foo");
285            ck1("/z:/foo", "z:/", "foo", "z:/foo");
286            ck1("//z:/foo", "z:/", "foo", "z:/foo");
287            ck1("z:/foo/bar", "z:/foo", "bar", "z:/foo/bar");
288            ck1("z:foo", "z:", "foo", "z:foo");
289
290            /* Two-arg constructors cases, string parent */
291            ck2("z:", "/", null, "", "z:/");    /* ## ? */
292            ck2("z:", "/foo", "z:/", "foo", "z:/foo");
293            ck2("z:/", "foo", "z:/", "foo", "z:/foo");
294            ck2("z://", "foo", "z:/", "foo", "z:/foo");
295            ck2("z:/", "/foo", "z:/", "foo", "z:/foo");
296            ck2("z:/", "//foo", "z:/", "foo", "z:/foo");
297            ck2("z:/", "foo/", "z:/", "foo", "z:/foo");
298            ck2("//foo", "bar", "//foo", "bar", "//foo/bar");
299
300            /* Two-arg constructor cases, File parent */
301            ck2f("//foo", "bar", "//foo", "bar", "//foo/bar");
302
303        }
304    }
305
306
307    public static void main(String[] args) throws Exception {
308        old = new File("foo/").getPath().equals("foo/");
309        if (old) System.err.println("** Testing old java.io.File class");
310        testBoth();
311        if (win32) testWin32();
312        else testUnix();
313    }
314
315}
316