View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.io;
18  
19  import static org.junit.jupiter.api.Assertions.assertEquals;
20  import static org.junit.jupiter.api.Assertions.assertFalse;
21  import static org.junit.jupiter.api.Assertions.assertNull;
22  import static org.junit.jupiter.api.Assertions.assertThrows;
23  import static org.junit.jupiter.api.Assertions.assertTrue;
24  
25  import java.io.BufferedOutputStream;
26  import java.io.File;
27  import java.io.IOException;
28  import java.nio.file.Files;
29  import java.nio.file.Path;
30  import java.util.ArrayList;
31  import java.util.Arrays;
32  import java.util.Collection;
33  
34  import org.apache.commons.io.test.TestUtils;
35  import org.apache.commons.lang3.SystemUtils;
36  import org.junit.jupiter.api.BeforeEach;
37  import org.junit.jupiter.api.Test;
38  import org.junit.jupiter.api.io.TempDir;
39  
40  /**
41   * Tests {@link FilenameUtils}.
42   */
43  public class FilenameUtilsTest {
44  
45      private static final String SEP = "" + File.separatorChar;
46  
47      private static final boolean WINDOWS = File.separatorChar == '\\';
48  
49      @TempDir
50      public Path temporaryFolder;
51  
52      private Path testFile1;
53      private Path testFile2;
54  
55      private int testFile1Size;
56      private int testFile2Size;
57  
58      @BeforeEach
59      public void setUp() throws Exception {
60          testFile1 = Files.createTempFile(temporaryFolder, "test", "1");
61          testFile2 = Files.createTempFile(temporaryFolder, "test", "2");
62  
63          testFile1Size = (int) Files.size(testFile1);
64          testFile2Size = (int) Files.size(testFile2);
65          if (!Files.exists(testFile1.getParent())) {
66              throw new IOException("Cannot create file " + testFile1
67                      + " as the parent directory does not exist");
68          }
69          try (BufferedOutputStream output3 =
70                  new BufferedOutputStream(Files.newOutputStream(testFile1))) {
71              TestUtils.generateTestData(output3, testFile1Size);
72          }
73          if (!Files.exists(testFile2.getParent())) {
74              throw new IOException("Cannot create file " + testFile2
75                      + " as the parent directory does not exist");
76          }
77          try (BufferedOutputStream output2 =
78                  new BufferedOutputStream(Files.newOutputStream(testFile2))) {
79              TestUtils.generateTestData(output2, testFile2Size);
80          }
81          if (!Files.exists(testFile1.getParent())) {
82              throw new IOException("Cannot create file " + testFile1
83                      + " as the parent directory does not exist");
84          }
85          try (BufferedOutputStream output1 =
86                  new BufferedOutputStream(Files.newOutputStream(testFile1))) {
87              TestUtils.generateTestData(output1, testFile1Size);
88          }
89          if (!Files.exists(testFile2.getParent())) {
90              throw new IOException("Cannot create file " + testFile2
91                      + " as the parent directory does not exist");
92          }
93          try (BufferedOutputStream output =
94                  new BufferedOutputStream(Files.newOutputStream(testFile2))) {
95              TestUtils.generateTestData(output, testFile2Size);
96          }
97      }
98  
99      @Test
100     public void testConcat() {
101         assertNull(FilenameUtils.concat("", null));
102         assertNull(FilenameUtils.concat(null, null));
103         assertNull(FilenameUtils.concat(null, ""));
104         assertNull(FilenameUtils.concat(null, "a"));
105         assertEquals(SEP + "a", FilenameUtils.concat(null, "/a"));
106 
107         assertNull(FilenameUtils.concat("", ":")); // invalid prefix
108         assertNull(FilenameUtils.concat(":", "")); // invalid prefix
109 
110         assertEquals("f" + SEP, FilenameUtils.concat("", "f/"));
111         assertEquals("f", FilenameUtils.concat("", "f"));
112         assertEquals("a" + SEP + "f" + SEP, FilenameUtils.concat("a/", "f/"));
113         assertEquals("a" + SEP + "f", FilenameUtils.concat("a", "f"));
114         assertEquals("a" + SEP + "b" + SEP + "f" + SEP, FilenameUtils.concat("a/b/", "f/"));
115         assertEquals("a" + SEP + "b" + SEP + "f", FilenameUtils.concat("a/b", "f"));
116 
117         assertEquals("a" + SEP + "f" + SEP, FilenameUtils.concat("a/b/", "../f/"));
118         assertEquals("a" + SEP + "f", FilenameUtils.concat("a/b", "../f"));
119         assertEquals("a" + SEP + "c" + SEP + "g" + SEP, FilenameUtils.concat("a/b/../c/", "f/../g/"));
120         assertEquals("a" + SEP + "c" + SEP + "g", FilenameUtils.concat("a/b/../c", "f/../g"));
121 
122         assertEquals("a" + SEP + "c.txt" + SEP + "f", FilenameUtils.concat("a/c.txt", "f"));
123 
124         assertEquals(SEP + "f" + SEP, FilenameUtils.concat("", "/f/"));
125         assertEquals(SEP + "f", FilenameUtils.concat("", "/f"));
126         assertEquals(SEP + "f" + SEP, FilenameUtils.concat("a/", "/f/"));
127         assertEquals(SEP + "f", FilenameUtils.concat("a", "/f"));
128 
129         assertEquals(SEP + "c" + SEP + "d", FilenameUtils.concat("a/b/", "/c/d"));
130         assertEquals("C:c" + SEP + "d", FilenameUtils.concat("a/b/", "C:c/d"));
131         assertEquals("C:" + SEP + "c" + SEP + "d", FilenameUtils.concat("a/b/", "C:/c/d"));
132         assertEquals("~" + SEP + "c" + SEP + "d", FilenameUtils.concat("a/b/", "~/c/d"));
133         assertEquals("~user" + SEP + "c" + SEP + "d", FilenameUtils.concat("a/b/", "~user/c/d"));
134         assertEquals("~" + SEP, FilenameUtils.concat("a/b/", "~"));
135         assertEquals("~user" + SEP, FilenameUtils.concat("a/b/", "~user"));
136     }
137 
138     @Test
139     public void testDirectoryContains() {
140         assertTrue(FilenameUtils.directoryContains("/foo", "/foo/bar"));
141         assertTrue(FilenameUtils.directoryContains("/foo/", "/foo/bar"));
142         assertTrue(FilenameUtils.directoryContains("C:\\foo", "C:\\foo\\bar"));
143         assertTrue(FilenameUtils.directoryContains("C:\\foo\\", "C:\\foo\\bar"));
144 
145         assertFalse(FilenameUtils.directoryContains("/foo", "/foo"));
146         assertFalse(FilenameUtils.directoryContains("/foo", "/foobar"));
147         assertFalse(FilenameUtils.directoryContains("C:\\foo", "C:\\foobar"));
148         assertFalse(FilenameUtils.directoryContains("/foo", null));
149         assertFalse(FilenameUtils.directoryContains("", ""));
150         assertFalse(FilenameUtils.directoryContains("", "/foo"));
151         assertFalse(FilenameUtils.directoryContains("/foo", ""));
152     }
153 
154     @Test
155     public void testEquals() {
156         assertTrue(FilenameUtils.equals(null, null));
157         assertFalse(FilenameUtils.equals(null, ""));
158         assertFalse(FilenameUtils.equals("", null));
159         assertTrue(FilenameUtils.equals("", ""));
160         assertTrue(FilenameUtils.equals("file.txt", "file.txt"));
161         assertFalse(FilenameUtils.equals("file.txt", "FILE.TXT"));
162         assertFalse(FilenameUtils.equals("a\\b\\file.txt", "a/b/file.txt"));
163     }
164 
165     @Test
166     public void testEquals_fullControl() {
167         assertFalse(FilenameUtils.equals("file.txt", "FILE.TXT", true, IOCase.SENSITIVE));
168         assertTrue(FilenameUtils.equals("file.txt", "FILE.TXT", true, IOCase.INSENSITIVE));
169         assertEquals(WINDOWS, FilenameUtils.equals("file.txt", "FILE.TXT", true, IOCase.SYSTEM));
170         assertFalse(FilenameUtils.equals("file.txt", "FILE.TXT", true, null));
171     }
172 
173     @Test
174     public void testEqualsNormalized() {
175         assertTrue(FilenameUtils.equalsNormalized(null, null));
176         assertFalse(FilenameUtils.equalsNormalized(null, ""));
177         assertFalse(FilenameUtils.equalsNormalized("", null));
178         assertTrue(FilenameUtils.equalsNormalized("", ""));
179         assertTrue(FilenameUtils.equalsNormalized("file.txt", "file.txt"));
180         assertFalse(FilenameUtils.equalsNormalized("file.txt", "FILE.TXT"));
181         assertTrue(FilenameUtils.equalsNormalized("a\\b\\file.txt", "a/b/file.txt"));
182         assertFalse(FilenameUtils.equalsNormalized("a/b/", "a/b"));
183     }
184 
185     /**
186      * Test for https://issues.apache.org/jira/browse/IO-128
187      */
188     @Test
189     public void testEqualsNormalizedError_IO_128() {
190         assertFalse(FilenameUtils.equalsNormalizedOnSystem("//file.txt", "file.txt"));
191         assertFalse(FilenameUtils.equalsNormalizedOnSystem("file.txt", "//file.txt"));
192         assertFalse(FilenameUtils.equalsNormalizedOnSystem("//file.txt", "//file.txt"));
193     }
194 
195     @Test
196     public void testEqualsNormalizedOnSystem() {
197         assertTrue(FilenameUtils.equalsNormalizedOnSystem(null, null));
198         assertFalse(FilenameUtils.equalsNormalizedOnSystem(null, ""));
199         assertFalse(FilenameUtils.equalsNormalizedOnSystem("", null));
200         assertTrue(FilenameUtils.equalsNormalizedOnSystem("", ""));
201         assertTrue(FilenameUtils.equalsNormalizedOnSystem("file.txt", "file.txt"));
202         assertEquals(WINDOWS, FilenameUtils.equalsNormalizedOnSystem("file.txt", "FILE.TXT"));
203         assertTrue(FilenameUtils.equalsNormalizedOnSystem("a\\b\\file.txt", "a/b/file.txt"));
204         assertFalse(FilenameUtils.equalsNormalizedOnSystem("a/b/", "a/b"));
205         assertFalse(FilenameUtils.equalsNormalizedOnSystem("//a.html", "//ab.html"));
206     }
207 
208     @Test
209     public void testEqualsOnSystem() {
210         assertTrue(FilenameUtils.equalsOnSystem(null, null));
211         assertFalse(FilenameUtils.equalsOnSystem(null, ""));
212         assertFalse(FilenameUtils.equalsOnSystem("", null));
213         assertTrue(FilenameUtils.equalsOnSystem("", ""));
214         assertTrue(FilenameUtils.equalsOnSystem("file.txt", "file.txt"));
215         assertEquals(WINDOWS, FilenameUtils.equalsOnSystem("file.txt", "FILE.TXT"));
216         assertFalse(FilenameUtils.equalsOnSystem("a\\b\\file.txt", "a/b/file.txt"));
217     }
218 
219     @Test
220     public void testGetBaseName() {
221         assertNull(FilenameUtils.getBaseName(null));
222         assertEquals("noseparator", FilenameUtils.getBaseName("noseparator.inthispath"));
223         assertEquals("c", FilenameUtils.getBaseName("a/b/c.txt"));
224         assertEquals("c", FilenameUtils.getBaseName("a/b/c"));
225         assertEquals("", FilenameUtils.getBaseName("a/b/c/"));
226         assertEquals("c", FilenameUtils.getBaseName("a\\b\\c"));
227         assertEquals("file.txt", FilenameUtils.getBaseName("file.txt.bak"));
228     }
229 
230     @Test
231     public void testGetBaseName_with_null_character() {
232         assertThrows(IllegalArgumentException.class, () -> FilenameUtils.getBaseName("fil\u0000e.txt.bak"));
233     }
234 
235     @Test
236     public void testGetExtension() {
237         assertNull(FilenameUtils.getExtension(null));
238         assertEquals("ext", FilenameUtils.getExtension("file.ext"));
239         assertEquals("", FilenameUtils.getExtension("README"));
240         assertEquals("com", FilenameUtils.getExtension("domain.dot.com"));
241         assertEquals("jpeg", FilenameUtils.getExtension("image.jpeg"));
242         assertEquals("", FilenameUtils.getExtension("a.b/c"));
243         assertEquals("txt", FilenameUtils.getExtension("a.b/c.txt"));
244         assertEquals("", FilenameUtils.getExtension("a/b/c"));
245         assertEquals("", FilenameUtils.getExtension("a.b\\c"));
246         assertEquals("txt", FilenameUtils.getExtension("a.b\\c.txt"));
247         assertEquals("", FilenameUtils.getExtension("a\\b\\c"));
248         assertEquals("", FilenameUtils.getExtension("C:\\temp\\foo.bar\\README"));
249         assertEquals("ext", FilenameUtils.getExtension("../filename.ext"));
250 
251         if (FilenameUtils.isSystemWindows()) {
252             // Special case handling for NTFS ADS names
253             final IllegalArgumentException e = assertThrows(IllegalArgumentException.class, () -> FilenameUtils.getExtension("foo.exe:bar.txt"));
254             assertEquals("NTFS ADS separator (':') in file name is forbidden.", e.getMessage());
255         } else {
256             // Upwards compatibility:
257             assertEquals("txt", FilenameUtils.getExtension("foo.exe:bar.txt"));
258         }
259     }
260 
261     @Test
262     public void testGetFullPath() {
263         assertNull(FilenameUtils.getFullPath(null));
264         assertEquals("", FilenameUtils.getFullPath("noseparator.inthispath"));
265         assertEquals("a/b/", FilenameUtils.getFullPath("a/b/c.txt"));
266         assertEquals("a/b/", FilenameUtils.getFullPath("a/b/c"));
267         assertEquals("a/b/c/", FilenameUtils.getFullPath("a/b/c/"));
268         assertEquals("a\\b\\", FilenameUtils.getFullPath("a\\b\\c"));
269 
270         assertNull(FilenameUtils.getFullPath(":"));
271         assertNull(FilenameUtils.getFullPath("1:/a/b/c.txt"));
272         assertNull(FilenameUtils.getFullPath("1:"));
273         assertNull(FilenameUtils.getFullPath("1:a"));
274         assertNull(FilenameUtils.getFullPath("///a/b/c.txt"));
275         assertNull(FilenameUtils.getFullPath("//a"));
276 
277         assertEquals("", FilenameUtils.getFullPath(""));
278 
279         if (SystemUtils.IS_OS_WINDOWS) {
280             assertEquals("C:", FilenameUtils.getFullPath("C:"));
281         }
282         if (SystemUtils.IS_OS_LINUX) {
283             assertEquals("", FilenameUtils.getFullPath("C:"));
284         }
285 
286         assertEquals("C:/", FilenameUtils.getFullPath("C:/"));
287         assertEquals("//server/", FilenameUtils.getFullPath("//server/"));
288         assertEquals("~/", FilenameUtils.getFullPath("~"));
289         assertEquals("~/", FilenameUtils.getFullPath("~/"));
290         assertEquals("~user/", FilenameUtils.getFullPath("~user"));
291         assertEquals("~user/", FilenameUtils.getFullPath("~user/"));
292 
293         assertEquals("a/b/", FilenameUtils.getFullPath("a/b/c.txt"));
294         assertEquals("/a/b/", FilenameUtils.getFullPath("/a/b/c.txt"));
295         assertEquals("C:", FilenameUtils.getFullPath("C:a"));
296         assertEquals("C:a/b/", FilenameUtils.getFullPath("C:a/b/c.txt"));
297         assertEquals("C:/a/b/", FilenameUtils.getFullPath("C:/a/b/c.txt"));
298         assertEquals("//server/a/b/", FilenameUtils.getFullPath("//server/a/b/c.txt"));
299         assertEquals("~/a/b/", FilenameUtils.getFullPath("~/a/b/c.txt"));
300         assertEquals("~user/a/b/", FilenameUtils.getFullPath("~user/a/b/c.txt"));
301     }
302 
303     @Test
304     public void testGetFullPathNoEndSeparator() {
305         assertNull(FilenameUtils.getFullPathNoEndSeparator(null));
306         assertEquals("", FilenameUtils.getFullPathNoEndSeparator("noseparator.inthispath"));
307         assertEquals("a/b", FilenameUtils.getFullPathNoEndSeparator("a/b/c.txt"));
308         assertEquals("a/b", FilenameUtils.getFullPathNoEndSeparator("a/b/c"));
309         assertEquals("a/b/c", FilenameUtils.getFullPathNoEndSeparator("a/b/c/"));
310         assertEquals("a\\b", FilenameUtils.getFullPathNoEndSeparator("a\\b\\c"));
311 
312         assertNull(FilenameUtils.getFullPathNoEndSeparator(":"));
313         assertNull(FilenameUtils.getFullPathNoEndSeparator("1:/a/b/c.txt"));
314         assertNull(FilenameUtils.getFullPathNoEndSeparator("1:"));
315         assertNull(FilenameUtils.getFullPathNoEndSeparator("1:a"));
316         assertNull(FilenameUtils.getFullPathNoEndSeparator("///a/b/c.txt"));
317         assertNull(FilenameUtils.getFullPathNoEndSeparator("//a"));
318 
319         assertEquals("", FilenameUtils.getFullPathNoEndSeparator(""));
320 
321         if (SystemUtils.IS_OS_WINDOWS) {
322             assertEquals("C:", FilenameUtils.getFullPathNoEndSeparator("C:"));
323         }
324         if (SystemUtils.IS_OS_LINUX) {
325             assertEquals("", FilenameUtils.getFullPathNoEndSeparator("C:"));
326         }
327 
328         assertEquals("C:/", FilenameUtils.getFullPathNoEndSeparator("C:/"));
329         assertEquals("//server/", FilenameUtils.getFullPathNoEndSeparator("//server/"));
330         assertEquals("~", FilenameUtils.getFullPathNoEndSeparator("~"));
331         assertEquals("~/", FilenameUtils.getFullPathNoEndSeparator("~/"));
332         assertEquals("~user", FilenameUtils.getFullPathNoEndSeparator("~user"));
333         assertEquals("~user/", FilenameUtils.getFullPathNoEndSeparator("~user/"));
334 
335         assertEquals("a/b", FilenameUtils.getFullPathNoEndSeparator("a/b/c.txt"));
336         assertEquals("/a/b", FilenameUtils.getFullPathNoEndSeparator("/a/b/c.txt"));
337         assertEquals("C:", FilenameUtils.getFullPathNoEndSeparator("C:a"));
338         assertEquals("C:a/b", FilenameUtils.getFullPathNoEndSeparator("C:a/b/c.txt"));
339         assertEquals("C:/a/b", FilenameUtils.getFullPathNoEndSeparator("C:/a/b/c.txt"));
340         assertEquals("//server/a/b", FilenameUtils.getFullPathNoEndSeparator("//server/a/b/c.txt"));
341         assertEquals("~/a/b", FilenameUtils.getFullPathNoEndSeparator("~/a/b/c.txt"));
342         assertEquals("~user/a/b", FilenameUtils.getFullPathNoEndSeparator("~user/a/b/c.txt"));
343     }
344 
345     /**
346      * Test for https://issues.apache.org/jira/browse/IO-248
347      */
348     @Test
349     public void testGetFullPathNoEndSeparator_IO_248() {
350 
351         // Test single separator
352         assertEquals("/", FilenameUtils.getFullPathNoEndSeparator("/"));
353         assertEquals("\\", FilenameUtils.getFullPathNoEndSeparator("\\"));
354 
355         // Test one level directory
356         assertEquals("/", FilenameUtils.getFullPathNoEndSeparator("/abc"));
357         assertEquals("\\", FilenameUtils.getFullPathNoEndSeparator("\\abc"));
358 
359         // Test one level directory
360         assertEquals("/abc", FilenameUtils.getFullPathNoEndSeparator("/abc/xyz"));
361         assertEquals("\\abc", FilenameUtils.getFullPathNoEndSeparator("\\abc\\xyz"));
362     }
363 
364     @Test
365     public void testGetName() {
366         assertNull(FilenameUtils.getName(null));
367         assertEquals("noseparator.inthispath", FilenameUtils.getName("noseparator.inthispath"));
368         assertEquals("c.txt", FilenameUtils.getName("a/b/c.txt"));
369         assertEquals("c", FilenameUtils.getName("a/b/c"));
370         assertEquals("", FilenameUtils.getName("a/b/c/"));
371         assertEquals("c", FilenameUtils.getName("a\\b\\c"));
372     }
373 
374     @Test
375     public void testGetPath() {
376         assertNull(FilenameUtils.getPath(null));
377         assertEquals("", FilenameUtils.getPath("noseparator.inthispath"));
378         assertEquals("", FilenameUtils.getPath("/noseparator.inthispath"));
379         assertEquals("", FilenameUtils.getPath("\\noseparator.inthispath"));
380         assertEquals("a/b/", FilenameUtils.getPath("a/b/c.txt"));
381         assertEquals("a/b/", FilenameUtils.getPath("a/b/c"));
382         assertEquals("a/b/c/", FilenameUtils.getPath("a/b/c/"));
383         assertEquals("a\\b\\", FilenameUtils.getPath("a\\b\\c"));
384 
385         assertNull(FilenameUtils.getPath(":"));
386         assertNull(FilenameUtils.getPath("1:/a/b/c.txt"));
387         assertNull(FilenameUtils.getPath("1:"));
388         assertNull(FilenameUtils.getPath("1:a"));
389         assertNull(FilenameUtils.getPath("///a/b/c.txt"));
390         assertNull(FilenameUtils.getPath("//a"));
391 
392         assertEquals("", FilenameUtils.getPath(""));
393         assertEquals("", FilenameUtils.getPath("C:"));
394         assertEquals("", FilenameUtils.getPath("C:/"));
395         assertEquals("", FilenameUtils.getPath("//server/"));
396         assertEquals("", FilenameUtils.getPath("~"));
397         assertEquals("", FilenameUtils.getPath("~/"));
398         assertEquals("", FilenameUtils.getPath("~user"));
399         assertEquals("", FilenameUtils.getPath("~user/"));
400 
401         assertEquals("a/b/", FilenameUtils.getPath("a/b/c.txt"));
402         assertEquals("a/b/", FilenameUtils.getPath("/a/b/c.txt"));
403         assertEquals("", FilenameUtils.getPath("C:a"));
404         assertEquals("a/b/", FilenameUtils.getPath("C:a/b/c.txt"));
405         assertEquals("a/b/", FilenameUtils.getPath("C:/a/b/c.txt"));
406         assertEquals("a/b/", FilenameUtils.getPath("//server/a/b/c.txt"));
407         assertEquals("a/b/", FilenameUtils.getPath("~/a/b/c.txt"));
408         assertEquals("a/b/", FilenameUtils.getPath("~user/a/b/c.txt"));
409     }
410 
411     @Test
412     public void testGetPath_with_null_character() {
413         assertThrows(IllegalArgumentException.class, () -> FilenameUtils.getPath("~user/a/\u0000b/c.txt"));
414     }
415 
416     @Test
417     public void testGetPathNoEndSeparator() {
418         assertNull(FilenameUtils.getPath(null));
419         assertEquals("", FilenameUtils.getPath("noseparator.inthispath"));
420         assertEquals("", FilenameUtils.getPathNoEndSeparator("/noseparator.inthispath"));
421         assertEquals("", FilenameUtils.getPathNoEndSeparator("\\noseparator.inthispath"));
422         assertEquals("a/b", FilenameUtils.getPathNoEndSeparator("a/b/c.txt"));
423         assertEquals("a/b", FilenameUtils.getPathNoEndSeparator("a/b/c"));
424         assertEquals("a/b/c", FilenameUtils.getPathNoEndSeparator("a/b/c/"));
425         assertEquals("a\\b", FilenameUtils.getPathNoEndSeparator("a\\b\\c"));
426 
427         assertNull(FilenameUtils.getPathNoEndSeparator(":"));
428         assertNull(FilenameUtils.getPathNoEndSeparator("1:/a/b/c.txt"));
429         assertNull(FilenameUtils.getPathNoEndSeparator("1:"));
430         assertNull(FilenameUtils.getPathNoEndSeparator("1:a"));
431         assertNull(FilenameUtils.getPathNoEndSeparator("///a/b/c.txt"));
432         assertNull(FilenameUtils.getPathNoEndSeparator("//a"));
433 
434         assertEquals("", FilenameUtils.getPathNoEndSeparator(""));
435         assertEquals("", FilenameUtils.getPathNoEndSeparator("C:"));
436         assertEquals("", FilenameUtils.getPathNoEndSeparator("C:/"));
437         assertEquals("", FilenameUtils.getPathNoEndSeparator("//server/"));
438         assertEquals("", FilenameUtils.getPathNoEndSeparator("~"));
439         assertEquals("", FilenameUtils.getPathNoEndSeparator("~/"));
440         assertEquals("", FilenameUtils.getPathNoEndSeparator("~user"));
441         assertEquals("", FilenameUtils.getPathNoEndSeparator("~user/"));
442 
443         assertEquals("a/b", FilenameUtils.getPathNoEndSeparator("a/b/c.txt"));
444         assertEquals("a/b", FilenameUtils.getPathNoEndSeparator("/a/b/c.txt"));
445         assertEquals("", FilenameUtils.getPathNoEndSeparator("C:a"));
446         assertEquals("a/b", FilenameUtils.getPathNoEndSeparator("C:a/b/c.txt"));
447         assertEquals("a/b", FilenameUtils.getPathNoEndSeparator("C:/a/b/c.txt"));
448         assertEquals("a/b", FilenameUtils.getPathNoEndSeparator("//server/a/b/c.txt"));
449         assertEquals("a/b", FilenameUtils.getPathNoEndSeparator("~/a/b/c.txt"));
450         assertEquals("a/b", FilenameUtils.getPathNoEndSeparator("~user/a/b/c.txt"));
451     }
452 
453     @Test
454     public void testGetPathNoEndSeparator_with_null_character() {
455         assertThrows(IllegalArgumentException.class, () -> FilenameUtils.getPathNoEndSeparator("~user/a\u0000/b/c.txt"));
456     }
457 
458     @Test
459     public void testGetPrefix() {
460         assertNull(FilenameUtils.getPrefix(null));
461         assertNull(FilenameUtils.getPrefix(":"));
462         assertNull(FilenameUtils.getPrefix("1:\\a\\b\\c.txt"));
463         assertNull(FilenameUtils.getPrefix("1:"));
464         assertNull(FilenameUtils.getPrefix("1:a"));
465         assertNull(FilenameUtils.getPrefix("\\\\\\a\\b\\c.txt"));
466         assertNull(FilenameUtils.getPrefix("\\\\a"));
467 
468         assertEquals("", FilenameUtils.getPrefix(""));
469         assertEquals("\\", FilenameUtils.getPrefix("\\"));
470 
471         if (SystemUtils.IS_OS_WINDOWS) {
472             assertEquals("C:", FilenameUtils.getPrefix("C:"));
473         }
474         if (SystemUtils.IS_OS_LINUX) {
475             assertEquals("", FilenameUtils.getPrefix("C:"));
476         }
477 
478         assertEquals("C:\\", FilenameUtils.getPrefix("C:\\"));
479         assertEquals("//server/", FilenameUtils.getPrefix("//server/"));
480         assertEquals("~/", FilenameUtils.getPrefix("~"));
481         assertEquals("~/", FilenameUtils.getPrefix("~/"));
482         assertEquals("~user/", FilenameUtils.getPrefix("~user"));
483         assertEquals("~user/", FilenameUtils.getPrefix("~user/"));
484 
485         assertEquals("", FilenameUtils.getPrefix("a\\b\\c.txt"));
486         assertEquals("\\", FilenameUtils.getPrefix("\\a\\b\\c.txt"));
487         assertEquals("C:\\", FilenameUtils.getPrefix("C:\\a\\b\\c.txt"));
488         assertEquals("\\\\server\\", FilenameUtils.getPrefix("\\\\server\\a\\b\\c.txt"));
489 
490         assertEquals("", FilenameUtils.getPrefix("a/b/c.txt"));
491         assertEquals("/", FilenameUtils.getPrefix("/a/b/c.txt"));
492         assertEquals("C:/", FilenameUtils.getPrefix("C:/a/b/c.txt"));
493         assertEquals("//server/", FilenameUtils.getPrefix("//server/a/b/c.txt"));
494         assertEquals("~/", FilenameUtils.getPrefix("~/a/b/c.txt"));
495         assertEquals("~user/", FilenameUtils.getPrefix("~user/a/b/c.txt"));
496 
497         assertEquals("", FilenameUtils.getPrefix("a\\b\\c.txt"));
498         assertEquals("\\", FilenameUtils.getPrefix("\\a\\b\\c.txt"));
499         assertEquals("~\\", FilenameUtils.getPrefix("~\\a\\b\\c.txt"));
500         assertEquals("~user\\", FilenameUtils.getPrefix("~user\\a\\b\\c.txt"));
501     }
502 
503     @Test
504     public void testGetPrefix_with_null_character() {
505         assertThrows(IllegalArgumentException.class, () -> FilenameUtils.getPrefix("~u\u0000ser\\a\\b\\c.txt"));
506     }
507 
508     @Test
509     public void testGetPrefixLength() {
510         assertEquals(-1, FilenameUtils.getPrefixLength(null));
511         assertEquals(-1, FilenameUtils.getPrefixLength(":"));
512         assertEquals(-1, FilenameUtils.getPrefixLength("1:\\a\\b\\c.txt"));
513         assertEquals(-1, FilenameUtils.getPrefixLength("1:"));
514         assertEquals(-1, FilenameUtils.getPrefixLength("1:a"));
515         assertEquals(-1, FilenameUtils.getPrefixLength("\\\\\\a\\b\\c.txt"));
516         assertEquals(-1, FilenameUtils.getPrefixLength("\\\\a"));
517 
518         assertEquals(0, FilenameUtils.getPrefixLength(""));
519         assertEquals(1, FilenameUtils.getPrefixLength("\\"));
520 
521         if (SystemUtils.IS_OS_WINDOWS) {
522             assertEquals(2, FilenameUtils.getPrefixLength("C:"));
523         }
524         if (SystemUtils.IS_OS_LINUX) {
525             assertEquals(0, FilenameUtils.getPrefixLength("C:"));
526         }
527 
528         assertEquals(3, FilenameUtils.getPrefixLength("C:\\"));
529         assertEquals(9, FilenameUtils.getPrefixLength("//server/"));
530         assertEquals(2, FilenameUtils.getPrefixLength("~"));
531         assertEquals(2, FilenameUtils.getPrefixLength("~/"));
532         assertEquals(6, FilenameUtils.getPrefixLength("~user"));
533         assertEquals(6, FilenameUtils.getPrefixLength("~user/"));
534 
535         assertEquals(0, FilenameUtils.getPrefixLength("a\\b\\c.txt"));
536         assertEquals(1, FilenameUtils.getPrefixLength("\\a\\b\\c.txt"));
537         assertEquals(2, FilenameUtils.getPrefixLength("C:a\\b\\c.txt"));
538         assertEquals(3, FilenameUtils.getPrefixLength("C:\\a\\b\\c.txt"));
539         assertEquals(9, FilenameUtils.getPrefixLength("\\\\server\\a\\b\\c.txt"));
540 
541         assertEquals(0, FilenameUtils.getPrefixLength("a/b/c.txt"));
542         assertEquals(1, FilenameUtils.getPrefixLength("/a/b/c.txt"));
543         assertEquals(3, FilenameUtils.getPrefixLength("C:/a/b/c.txt"));
544         assertEquals(9, FilenameUtils.getPrefixLength("//server/a/b/c.txt"));
545         assertEquals(2, FilenameUtils.getPrefixLength("~/a/b/c.txt"));
546         assertEquals(6, FilenameUtils.getPrefixLength("~user/a/b/c.txt"));
547 
548         assertEquals(0, FilenameUtils.getPrefixLength("a\\b\\c.txt"));
549         assertEquals(1, FilenameUtils.getPrefixLength("\\a\\b\\c.txt"));
550         assertEquals(2, FilenameUtils.getPrefixLength("~\\a\\b\\c.txt"));
551         assertEquals(6, FilenameUtils.getPrefixLength("~user\\a\\b\\c.txt"));
552 
553         assertEquals(9, FilenameUtils.getPrefixLength("//server/a/b/c.txt"));
554         assertEquals(-1, FilenameUtils.getPrefixLength("\\\\\\a\\b\\c.txt"));
555         assertEquals(-1, FilenameUtils.getPrefixLength("///a/b/c.txt"));
556 
557         assertEquals(1, FilenameUtils.getPrefixLength("/:foo"));
558         assertEquals(1, FilenameUtils.getPrefixLength("/:/"));
559         assertEquals(1, FilenameUtils.getPrefixLength("/:::::::.txt"));
560 
561         assertEquals(12, FilenameUtils.getPrefixLength("\\\\127.0.0.1\\a\\b\\c.txt"));
562         assertEquals(6, FilenameUtils.getPrefixLength("\\\\::1\\a\\b\\c.txt"));
563         assertEquals(21, FilenameUtils.getPrefixLength("\\\\server.example.org\\a\\b\\c.txt"));
564         assertEquals(10, FilenameUtils.getPrefixLength("\\\\server.\\a\\b\\c.txt"));
565 
566         assertEquals(-1, FilenameUtils.getPrefixLength("\\\\-server\\a\\b\\c.txt"));
567         assertEquals(-1, FilenameUtils.getPrefixLength("\\\\.\\a\\b\\c.txt"));
568         assertEquals(-1, FilenameUtils.getPrefixLength("\\\\..\\a\\b\\c.txt"));
569     }
570 
571     @Test
572     public void testIndexOfExtension() {
573         assertEquals(-1, FilenameUtils.indexOfExtension(null));
574         assertEquals(-1, FilenameUtils.indexOfExtension("file"));
575         assertEquals(4, FilenameUtils.indexOfExtension("file.txt"));
576         assertEquals(13, FilenameUtils.indexOfExtension("a.txt/b.txt/c.txt"));
577         assertEquals(-1, FilenameUtils.indexOfExtension("a/b/c"));
578         assertEquals(-1, FilenameUtils.indexOfExtension("a\\b\\c"));
579         assertEquals(-1, FilenameUtils.indexOfExtension("a/b.notextension/c"));
580         assertEquals(-1, FilenameUtils.indexOfExtension("a\\b.notextension\\c"));
581 
582         if (FilenameUtils.isSystemWindows()) {
583             // Special case handling for NTFS ADS names
584             final IllegalArgumentException e = assertThrows(IllegalArgumentException.class, () -> FilenameUtils.indexOfExtension("foo.exe:bar.txt"));
585             assertEquals("NTFS ADS separator (':') in file name is forbidden.", e.getMessage());
586         } else {
587             // Upwards compatibility on other systems
588             assertEquals(11, FilenameUtils.indexOfExtension("foo.exe:bar.txt"));
589         }
590 
591     }
592 
593     @Test
594     public void testIndexOfLastSeparator() {
595         assertEquals(-1, FilenameUtils.indexOfLastSeparator(null));
596         assertEquals(-1, FilenameUtils.indexOfLastSeparator("noseparator.inthispath"));
597         assertEquals(3, FilenameUtils.indexOfLastSeparator("a/b/c"));
598         assertEquals(3, FilenameUtils.indexOfLastSeparator("a\\b\\c"));
599     }
600 
601     @Test
602     public void testInjectionFailure() {
603         assertThrows(IllegalArgumentException.class, () -> FilenameUtils.getName("a\\b\\\u0000c"));
604     }
605 
606     @Test
607     public void testIsExtension() {
608         assertFalse(FilenameUtils.isExtension(null, (String) null));
609         assertFalse(FilenameUtils.isExtension("file.txt", (String) null));
610         assertTrue(FilenameUtils.isExtension("file", (String) null));
611         assertFalse(FilenameUtils.isExtension("file.txt", ""));
612         assertTrue(FilenameUtils.isExtension("file", ""));
613         assertTrue(FilenameUtils.isExtension("file.txt", "txt"));
614         assertFalse(FilenameUtils.isExtension("file.txt", "rtf"));
615 
616         assertFalse(FilenameUtils.isExtension("a/b/file.txt", (String) null));
617         assertFalse(FilenameUtils.isExtension("a/b/file.txt", ""));
618         assertTrue(FilenameUtils.isExtension("a/b/file.txt", "txt"));
619         assertFalse(FilenameUtils.isExtension("a/b/file.txt", "rtf"));
620 
621         assertFalse(FilenameUtils.isExtension("a.b/file.txt", (String) null));
622         assertFalse(FilenameUtils.isExtension("a.b/file.txt", ""));
623         assertTrue(FilenameUtils.isExtension("a.b/file.txt", "txt"));
624         assertFalse(FilenameUtils.isExtension("a.b/file.txt", "rtf"));
625 
626         assertFalse(FilenameUtils.isExtension("a\\b\\file.txt", (String) null));
627         assertFalse(FilenameUtils.isExtension("a\\b\\file.txt", ""));
628         assertTrue(FilenameUtils.isExtension("a\\b\\file.txt", "txt"));
629         assertFalse(FilenameUtils.isExtension("a\\b\\file.txt", "rtf"));
630 
631         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", (String) null));
632         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", ""));
633         assertTrue(FilenameUtils.isExtension("a.b\\file.txt", "txt"));
634         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", "rtf"));
635 
636         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", "TXT"));
637     }
638 
639     @Test
640     public void testIsExtension_injection() {
641         assertThrows(IllegalArgumentException.class, () -> FilenameUtils.isExtension("a.b\\fi\u0000le.txt", "TXT"));
642     }
643 
644     @Test
645     public void testIsExtensionArray() {
646         assertFalse(FilenameUtils.isExtension(null, (String[]) null));
647         assertFalse(FilenameUtils.isExtension("file.txt", (String[]) null));
648         assertTrue(FilenameUtils.isExtension("file", (String[]) null));
649         assertFalse(FilenameUtils.isExtension("file.txt"));
650         assertTrue(FilenameUtils.isExtension("file.txt", new String[]{"txt"}));
651         assertFalse(FilenameUtils.isExtension("file.txt", new String[]{"rtf"}));
652         assertTrue(FilenameUtils.isExtension("file", "rtf", ""));
653         assertTrue(FilenameUtils.isExtension("file.txt", "rtf", "txt"));
654 
655         assertFalse(FilenameUtils.isExtension("a/b/file.txt", (String[]) null));
656         assertFalse(FilenameUtils.isExtension("a/b/file.txt"));
657         assertTrue(FilenameUtils.isExtension("a/b/file.txt", new String[]{"txt"}));
658         assertFalse(FilenameUtils.isExtension("a/b/file.txt", new String[]{"rtf"}));
659         assertTrue(FilenameUtils.isExtension("a/b/file.txt", "rtf", "txt"));
660 
661         assertFalse(FilenameUtils.isExtension("a.b/file.txt", (String[]) null));
662         assertFalse(FilenameUtils.isExtension("a.b/file.txt"));
663         assertTrue(FilenameUtils.isExtension("a.b/file.txt", new String[]{"txt"}));
664         assertFalse(FilenameUtils.isExtension("a.b/file.txt", new String[]{"rtf"}));
665         assertTrue(FilenameUtils.isExtension("a.b/file.txt", "rtf", "txt"));
666 
667         assertFalse(FilenameUtils.isExtension("a\\b\\file.txt", (String[]) null));
668         assertFalse(FilenameUtils.isExtension("a\\b\\file.txt"));
669         assertTrue(FilenameUtils.isExtension("a\\b\\file.txt", new String[]{"txt"}));
670         assertFalse(FilenameUtils.isExtension("a\\b\\file.txt", new String[]{"rtf"}));
671         assertTrue(FilenameUtils.isExtension("a\\b\\file.txt", "rtf", "txt"));
672 
673         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", (String[]) null));
674         assertFalse(FilenameUtils.isExtension("a.b\\file.txt"));
675         assertTrue(FilenameUtils.isExtension("a.b\\file.txt", new String[]{"txt"}));
676         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", new String[]{"rtf"}));
677         assertTrue(FilenameUtils.isExtension("a.b\\file.txt", "rtf", "txt"));
678 
679         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", new String[]{"TXT"}));
680         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", "TXT", "RTF"));
681     }
682 
683     @Test
684     public void testIsExtensionCollection() {
685         assertFalse(FilenameUtils.isExtension(null, (Collection<String>) null));
686         assertFalse(FilenameUtils.isExtension("file.txt", (Collection<String>) null));
687         assertTrue(FilenameUtils.isExtension("file", (Collection<String>) null));
688         assertFalse(FilenameUtils.isExtension("file.txt", new ArrayList<>()));
689         assertTrue(FilenameUtils.isExtension("file.txt", new ArrayList<>(Arrays.asList("txt"))));
690         assertFalse(FilenameUtils.isExtension("file.txt", new ArrayList<>(Arrays.asList("rtf"))));
691         assertTrue(FilenameUtils.isExtension("file", new ArrayList<>(Arrays.asList("rtf", ""))));
692         assertTrue(FilenameUtils.isExtension("file.txt", new ArrayList<>(Arrays.asList("rtf", "txt"))));
693 
694         assertFalse(FilenameUtils.isExtension("a/b/file.txt", (Collection<String>) null));
695         assertFalse(FilenameUtils.isExtension("a/b/file.txt", new ArrayList<>()));
696         assertTrue(FilenameUtils.isExtension("a/b/file.txt", new ArrayList<>(Arrays.asList("txt"))));
697         assertFalse(FilenameUtils.isExtension("a/b/file.txt", new ArrayList<>(Arrays.asList("rtf"))));
698         assertTrue(FilenameUtils.isExtension("a/b/file.txt", new ArrayList<>(Arrays.asList("rtf", "txt"))));
699 
700         assertFalse(FilenameUtils.isExtension("a.b/file.txt", (Collection<String>) null));
701         assertFalse(FilenameUtils.isExtension("a.b/file.txt", new ArrayList<>()));
702         assertTrue(FilenameUtils.isExtension("a.b/file.txt", new ArrayList<>(Arrays.asList("txt"))));
703         assertFalse(FilenameUtils.isExtension("a.b/file.txt", new ArrayList<>(Arrays.asList("rtf"))));
704         assertTrue(FilenameUtils.isExtension("a.b/file.txt", new ArrayList<>(Arrays.asList("rtf", "txt"))));
705 
706         assertFalse(FilenameUtils.isExtension("a\\b\\file.txt", (Collection<String>) null));
707         assertFalse(FilenameUtils.isExtension("a\\b\\file.txt", new ArrayList<>()));
708         assertTrue(FilenameUtils.isExtension("a\\b\\file.txt", new ArrayList<>(Arrays.asList("txt"))));
709         assertFalse(FilenameUtils.isExtension("a\\b\\file.txt", new ArrayList<>(Arrays.asList("rtf"))));
710         assertTrue(FilenameUtils.isExtension("a\\b\\file.txt", new ArrayList<>(Arrays.asList("rtf", "txt"))));
711 
712         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", (Collection<String>) null));
713         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", new ArrayList<>()));
714         assertTrue(FilenameUtils.isExtension("a.b\\file.txt", new ArrayList<>(Arrays.asList("txt"))));
715         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", new ArrayList<>(Arrays.asList("rtf"))));
716         assertTrue(FilenameUtils.isExtension("a.b\\file.txt", new ArrayList<>(Arrays.asList("rtf", "txt"))));
717 
718         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", new ArrayList<>(Arrays.asList("TXT"))));
719         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", new ArrayList<>(Arrays.asList("TXT", "RTF"))));
720     }
721 
722     @Test
723     public void testIsExtensionVarArgs() {
724         assertTrue(FilenameUtils.isExtension("file.txt", "txt"));
725         assertFalse(FilenameUtils.isExtension("file.txt", "rtf"));
726         assertTrue(FilenameUtils.isExtension("file", "rtf", ""));
727         assertTrue(FilenameUtils.isExtension("file.txt", "rtf", "txt"));
728 
729         assertTrue(FilenameUtils.isExtension("a/b/file.txt", "txt"));
730         assertFalse(FilenameUtils.isExtension("a/b/file.txt", "rtf"));
731         assertTrue(FilenameUtils.isExtension("a/b/file.txt", "rtf", "txt"));
732 
733         assertTrue(FilenameUtils.isExtension("a.b/file.txt", "txt"));
734         assertFalse(FilenameUtils.isExtension("a.b/file.txt", "rtf"));
735         assertTrue(FilenameUtils.isExtension("a.b/file.txt", "rtf", "txt"));
736 
737         assertTrue(FilenameUtils.isExtension("a\\b\\file.txt", "txt"));
738         assertFalse(FilenameUtils.isExtension("a\\b\\file.txt", "rtf"));
739         assertTrue(FilenameUtils.isExtension("a\\b\\file.txt", "rtf", "txt"));
740 
741         assertTrue(FilenameUtils.isExtension("a.b\\file.txt", "txt"));
742         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", "rtf"));
743         assertTrue(FilenameUtils.isExtension("a.b\\file.txt", "rtf", "txt"));
744 
745         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", "TXT"));
746         assertFalse(FilenameUtils.isExtension("a.b\\file.txt", "TXT", "RTF"));
747     }
748 
749     @Test
750     public void testNormalize() {
751         assertNull(FilenameUtils.normalize(null));
752         assertNull(FilenameUtils.normalize(":"));
753         assertNull(FilenameUtils.normalize("1:\\a\\b\\c.txt"));
754         assertNull(FilenameUtils.normalize("1:"));
755         assertNull(FilenameUtils.normalize("1:a"));
756         assertNull(FilenameUtils.normalize("\\\\\\a\\b\\c.txt"));
757         assertNull(FilenameUtils.normalize("\\\\a"));
758 
759         assertEquals("a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("a\\b/c.txt"));
760         assertEquals("" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("\\a\\b/c.txt"));
761         assertEquals("C:" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("C:\\a\\b/c.txt"));
762         assertEquals("" + SEP + "" + SEP + "server" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("\\\\server\\a\\b/c.txt"));
763         assertEquals("~" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("~\\a\\b/c.txt"));
764         assertEquals("~user" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("~user\\a\\b/c.txt"));
765 
766         assertEquals("a" + SEP + "c", FilenameUtils.normalize("a/b/../c"));
767         assertEquals("c", FilenameUtils.normalize("a/b/../../c"));
768         assertEquals("c" + SEP, FilenameUtils.normalize("a/b/../../c/"));
769         assertNull(FilenameUtils.normalize("a/b/../../../c"));
770         assertEquals("a" + SEP, FilenameUtils.normalize("a/b/.."));
771         assertEquals("a" + SEP, FilenameUtils.normalize("a/b/../"));
772         assertEquals("", FilenameUtils.normalize("a/b/../.."));
773         assertEquals("", FilenameUtils.normalize("a/b/../../"));
774         assertNull(FilenameUtils.normalize("a/b/../../.."));
775         assertEquals("a" + SEP + "d", FilenameUtils.normalize("a/b/../c/../d"));
776         assertEquals("a" + SEP + "d" + SEP, FilenameUtils.normalize("a/b/../c/../d/"));
777         assertEquals("a" + SEP + "b" + SEP + "d", FilenameUtils.normalize("a/b//d"));
778         assertEquals("a" + SEP + "b" + SEP, FilenameUtils.normalize("a/b/././."));
779         assertEquals("a" + SEP + "b" + SEP, FilenameUtils.normalize("a/b/./././"));
780         assertEquals("a" + SEP, FilenameUtils.normalize("./a/"));
781         assertEquals("a", FilenameUtils.normalize("./a"));
782         assertEquals("", FilenameUtils.normalize("./"));
783         assertEquals("", FilenameUtils.normalize("."));
784         assertNull(FilenameUtils.normalize("../a"));
785         assertNull(FilenameUtils.normalize(".."));
786         assertEquals("", FilenameUtils.normalize(""));
787 
788         assertEquals(SEP + "a", FilenameUtils.normalize("/a"));
789         assertEquals(SEP + "a" + SEP, FilenameUtils.normalize("/a/"));
790         assertEquals(SEP + "a" + SEP + "c", FilenameUtils.normalize("/a/b/../c"));
791         assertEquals(SEP + "c", FilenameUtils.normalize("/a/b/../../c"));
792         assertNull(FilenameUtils.normalize("/a/b/../../../c"));
793         assertEquals(SEP + "a" + SEP, FilenameUtils.normalize("/a/b/.."));
794         assertEquals(SEP + "", FilenameUtils.normalize("/a/b/../.."));
795         assertNull(FilenameUtils.normalize("/a/b/../../.."));
796         assertEquals(SEP + "a" + SEP + "d", FilenameUtils.normalize("/a/b/../c/../d"));
797         assertEquals(SEP + "a" + SEP + "b" + SEP + "d", FilenameUtils.normalize("/a/b//d"));
798         assertEquals(SEP + "a" + SEP + "b" + SEP, FilenameUtils.normalize("/a/b/././."));
799         assertEquals(SEP + "a", FilenameUtils.normalize("/./a"));
800         assertEquals(SEP + "", FilenameUtils.normalize("/./"));
801         assertEquals(SEP + "", FilenameUtils.normalize("/."));
802         assertNull(FilenameUtils.normalize("/../a"));
803         assertNull(FilenameUtils.normalize("/.."));
804         assertEquals(SEP + "", FilenameUtils.normalize("/"));
805 
806         assertEquals("~" + SEP + "a", FilenameUtils.normalize("~/a"));
807         assertEquals("~" + SEP + "a" + SEP, FilenameUtils.normalize("~/a/"));
808         assertEquals("~" + SEP + "a" + SEP + "c", FilenameUtils.normalize("~/a/b/../c"));
809         assertEquals("~" + SEP + "c", FilenameUtils.normalize("~/a/b/../../c"));
810         assertNull(FilenameUtils.normalize("~/a/b/../../../c"));
811         assertEquals("~" + SEP + "a" + SEP, FilenameUtils.normalize("~/a/b/.."));
812         assertEquals("~" + SEP + "", FilenameUtils.normalize("~/a/b/../.."));
813         assertNull(FilenameUtils.normalize("~/a/b/../../.."));
814         assertEquals("~" + SEP + "a" + SEP + "d", FilenameUtils.normalize("~/a/b/../c/../d"));
815         assertEquals("~" + SEP + "a" + SEP + "b" + SEP + "d", FilenameUtils.normalize("~/a/b//d"));
816         assertEquals("~" + SEP + "a" + SEP + "b" + SEP, FilenameUtils.normalize("~/a/b/././."));
817         assertEquals("~" + SEP + "a", FilenameUtils.normalize("~/./a"));
818         assertEquals("~" + SEP, FilenameUtils.normalize("~/./"));
819         assertEquals("~" + SEP, FilenameUtils.normalize("~/."));
820         assertNull(FilenameUtils.normalize("~/../a"));
821         assertNull(FilenameUtils.normalize("~/.."));
822         assertEquals("~" + SEP, FilenameUtils.normalize("~/"));
823         assertEquals("~" + SEP, FilenameUtils.normalize("~"));
824 
825         assertEquals("~user" + SEP + "a", FilenameUtils.normalize("~user/a"));
826         assertEquals("~user" + SEP + "a" + SEP, FilenameUtils.normalize("~user/a/"));
827         assertEquals("~user" + SEP + "a" + SEP + "c", FilenameUtils.normalize("~user/a/b/../c"));
828         assertEquals("~user" + SEP + "c", FilenameUtils.normalize("~user/a/b/../../c"));
829         assertNull(FilenameUtils.normalize("~user/a/b/../../../c"));
830         assertEquals("~user" + SEP + "a" + SEP, FilenameUtils.normalize("~user/a/b/.."));
831         assertEquals("~user" + SEP + "", FilenameUtils.normalize("~user/a/b/../.."));
832         assertNull(FilenameUtils.normalize("~user/a/b/../../.."));
833         assertEquals("~user" + SEP + "a" + SEP + "d", FilenameUtils.normalize("~user/a/b/../c/../d"));
834         assertEquals("~user" + SEP + "a" + SEP + "b" + SEP + "d", FilenameUtils.normalize("~user/a/b//d"));
835         assertEquals("~user" + SEP + "a" + SEP + "b" + SEP, FilenameUtils.normalize("~user/a/b/././."));
836         assertEquals("~user" + SEP + "a", FilenameUtils.normalize("~user/./a"));
837         assertEquals("~user" + SEP + "", FilenameUtils.normalize("~user/./"));
838         assertEquals("~user" + SEP + "", FilenameUtils.normalize("~user/."));
839         assertNull(FilenameUtils.normalize("~user/../a"));
840         assertNull(FilenameUtils.normalize("~user/.."));
841         assertEquals("~user" + SEP, FilenameUtils.normalize("~user/"));
842         assertEquals("~user" + SEP, FilenameUtils.normalize("~user"));
843 
844         assertEquals("C:" + SEP + "a", FilenameUtils.normalize("C:/a"));
845         assertEquals("C:" + SEP + "a" + SEP, FilenameUtils.normalize("C:/a/"));
846         assertEquals("C:" + SEP + "a" + SEP + "c", FilenameUtils.normalize("C:/a/b/../c"));
847         assertEquals("C:" + SEP + "c", FilenameUtils.normalize("C:/a/b/../../c"));
848         assertNull(FilenameUtils.normalize("C:/a/b/../../../c"));
849         assertEquals("C:" + SEP + "a" + SEP, FilenameUtils.normalize("C:/a/b/.."));
850         assertEquals("C:" + SEP + "", FilenameUtils.normalize("C:/a/b/../.."));
851         assertNull(FilenameUtils.normalize("C:/a/b/../../.."));
852         assertEquals("C:" + SEP + "a" + SEP + "d", FilenameUtils.normalize("C:/a/b/../c/../d"));
853         assertEquals("C:" + SEP + "a" + SEP + "b" + SEP + "d", FilenameUtils.normalize("C:/a/b//d"));
854         assertEquals("C:" + SEP + "a" + SEP + "b" + SEP, FilenameUtils.normalize("C:/a/b/././."));
855         assertEquals("C:" + SEP + "a", FilenameUtils.normalize("C:/./a"));
856         assertEquals("C:" + SEP + "", FilenameUtils.normalize("C:/./"));
857         assertEquals("C:" + SEP + "", FilenameUtils.normalize("C:/."));
858         assertNull(FilenameUtils.normalize("C:/../a"));
859         assertNull(FilenameUtils.normalize("C:/.."));
860         assertEquals("C:" + SEP + "", FilenameUtils.normalize("C:/"));
861 
862         assertEquals("C:" + "a", FilenameUtils.normalize("C:a"));
863         assertEquals("C:" + "a" + SEP, FilenameUtils.normalize("C:a/"));
864         assertEquals("C:" + "a" + SEP + "c", FilenameUtils.normalize("C:a/b/../c"));
865         assertEquals("C:" + "c", FilenameUtils.normalize("C:a/b/../../c"));
866         assertNull(FilenameUtils.normalize("C:a/b/../../../c"));
867         assertEquals("C:" + "a" + SEP, FilenameUtils.normalize("C:a/b/.."));
868         assertEquals("C:" + "", FilenameUtils.normalize("C:a/b/../.."));
869         assertNull(FilenameUtils.normalize("C:a/b/../../.."));
870         assertEquals("C:" + "a" + SEP + "d", FilenameUtils.normalize("C:a/b/../c/../d"));
871         assertEquals("C:" + "a" + SEP + "b" + SEP + "d", FilenameUtils.normalize("C:a/b//d"));
872         assertEquals("C:" + "a" + SEP + "b" + SEP, FilenameUtils.normalize("C:a/b/././."));
873         assertEquals("C:" + "a", FilenameUtils.normalize("C:./a"));
874         assertEquals("C:" + "", FilenameUtils.normalize("C:./"));
875         assertEquals("C:" + "", FilenameUtils.normalize("C:."));
876         assertNull(FilenameUtils.normalize("C:../a"));
877         assertNull(FilenameUtils.normalize("C:.."));
878         assertEquals("C:" + "", FilenameUtils.normalize("C:"));
879 
880         assertEquals(SEP + SEP + "server" + SEP + "a", FilenameUtils.normalize("//server/a"));
881         assertEquals(SEP + SEP + "server" + SEP + "a" + SEP, FilenameUtils.normalize("//server/a/"));
882         assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "c", FilenameUtils.normalize("//server/a/b/../c"));
883         assertEquals(SEP + SEP + "server" + SEP + "c", FilenameUtils.normalize("//server/a/b/../../c"));
884         assertNull(FilenameUtils.normalize("//server/a/b/../../../c"));
885         assertEquals(SEP + SEP + "server" + SEP + "a" + SEP, FilenameUtils.normalize("//server/a/b/.."));
886         assertEquals(SEP + SEP + "server" + SEP + "", FilenameUtils.normalize("//server/a/b/../.."));
887         assertNull(FilenameUtils.normalize("//server/a/b/../../.."));
888         assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "d", FilenameUtils.normalize("//server/a/b/../c/../d"));
889         assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "b" + SEP + "d", FilenameUtils.normalize("//server/a/b//d"));
890         assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "b" + SEP, FilenameUtils.normalize("//server/a/b/././."));
891         assertEquals(SEP + SEP + "server" + SEP + "a", FilenameUtils.normalize("//server/./a"));
892         assertEquals(SEP + SEP + "server" + SEP + "", FilenameUtils.normalize("//server/./"));
893         assertEquals(SEP + SEP + "server" + SEP + "", FilenameUtils.normalize("//server/."));
894         assertNull(FilenameUtils.normalize("//server/../a"));
895         assertNull(FilenameUtils.normalize("//server/.."));
896         assertEquals(SEP + SEP + "server" + SEP + "", FilenameUtils.normalize("//server/"));
897 
898         assertEquals(SEP + SEP + "127.0.0.1" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("\\\\127.0.0.1\\a\\b\\c.txt"));
899         assertEquals(SEP + SEP + "::1" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("\\\\::1\\a\\b\\c.txt"));
900         assertEquals(SEP + SEP + "1::" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("\\\\1::\\a\\b\\c.txt"));
901         assertEquals(SEP + SEP + "server.example.org" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("\\\\server.example.org\\a\\b\\c.txt"));
902         assertEquals(SEP + SEP + "server.sub.example.org" + SEP + "a" + SEP + "b" + SEP + "c.txt",
903             FilenameUtils.normalize("\\\\server.sub.example.org\\a\\b\\c.txt"));
904         assertEquals(SEP + SEP + "server." + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("\\\\server.\\a\\b\\c.txt"));
905         assertEquals(SEP + SEP + "1::127.0.0.1" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("\\\\1::127.0.0.1\\a\\b\\c.txt"));
906 
907         // not valid IPv4 addresses but technically a valid "reg-name"s according to RFC1034
908         assertEquals(SEP + SEP + "127.0.0.256" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("\\\\127.0.0.256\\a\\b\\c.txt"));
909         assertEquals(SEP + SEP + "127.0.0.01" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalize("\\\\127.0.0.01\\a\\b\\c.txt"));
910 
911         assertNull(FilenameUtils.normalize("\\\\-server\\a\\b\\c.txt"));
912         assertNull(FilenameUtils.normalize("\\\\.\\a\\b\\c.txt"));
913         assertNull(FilenameUtils.normalize("\\\\..\\a\\b\\c.txt"));
914         assertNull(FilenameUtils.normalize("\\\\127.0..1\\a\\b\\c.txt"));
915         assertNull(FilenameUtils.normalize("\\\\::1::2\\a\\b\\c.txt"));
916         assertNull(FilenameUtils.normalize("\\\\:1\\a\\b\\c.txt"));
917         assertNull(FilenameUtils.normalize("\\\\1:\\a\\b\\c.txt"));
918         assertNull(FilenameUtils.normalize("\\\\1:2:3:4:5:6:7:8:9\\a\\b\\c.txt"));
919         assertNull(FilenameUtils.normalize("\\\\g:2:3:4:5:6:7:8\\a\\b\\c.txt"));
920         assertNull(FilenameUtils.normalize("\\\\1ffff:2:3:4:5:6:7:8\\a\\b\\c.txt"));
921         assertNull(FilenameUtils.normalize("\\\\1:2\\a\\b\\c.txt"));
922         // IO-556
923         assertNull(FilenameUtils.normalize("//../foo"));
924         assertNull(FilenameUtils.normalize("\\\\..\\foo"));
925     }
926 
927     /**
928      */
929     @Test
930     public void testNormalize_with_null_character() {
931         assertThrows(IllegalArgumentException.class, () -> FilenameUtils.normalize("a\\b/c\u0000.txt"));
932         assertThrows(IllegalArgumentException.class, () -> FilenameUtils.normalize("\u0000a\\b/c.txt"));
933     }
934 
935     @Test
936     public void testNormalizeFromJavaDoc() {
937         // Examples from Javadoc
938         assertEquals(SEP + "foo" + SEP, FilenameUtils.normalize("/foo//"));
939         assertEquals(SEP + "foo" + SEP, FilenameUtils.normalize(SEP + "foo" + SEP + "." + SEP));
940         assertEquals(SEP + "bar", FilenameUtils.normalize(SEP + "foo" + SEP + ".." + SEP + "bar"));
941         assertEquals(SEP + "bar" + SEP, FilenameUtils.normalize(SEP + "foo" + SEP + ".." + SEP + "bar" + SEP));
942         assertEquals(SEP + "baz", FilenameUtils.normalize(SEP + "foo" + SEP + ".." + SEP + "bar" + SEP + ".." + SEP + "baz"));
943         assertEquals(SEP + SEP + "foo" + SEP + "bar", FilenameUtils.normalize("//foo//./bar"));
944         assertNull(FilenameUtils.normalize(SEP + ".." + SEP));
945         assertNull(FilenameUtils.normalize(".." + SEP + "foo"));
946         assertEquals("foo" + SEP, FilenameUtils.normalize("foo" + SEP + "bar" + SEP + ".."));
947         assertNull(FilenameUtils.normalize("foo" + SEP + ".." + SEP + ".." + SEP + "bar"));
948         assertEquals("bar", FilenameUtils.normalize("foo" + SEP + ".." + SEP + "bar"));
949         assertEquals(SEP + SEP + "server" + SEP + "bar", FilenameUtils.normalize(SEP + SEP + "server" + SEP + "foo" + SEP + ".." + SEP + "bar"));
950         assertNull(FilenameUtils.normalize(SEP + SEP + "server" + SEP + ".." + SEP + "bar"));
951         assertEquals("C:" + SEP + "bar", FilenameUtils.normalize("C:" + SEP + "foo" + SEP + ".." + SEP + "bar"));
952         assertNull(FilenameUtils.normalize("C:" + SEP + ".." + SEP + "bar"));
953         assertEquals("~" + SEP + "bar" + SEP, FilenameUtils.normalize("~" + SEP + "foo" + SEP + ".." + SEP + "bar" + SEP));
954         assertNull(FilenameUtils.normalize("~" + SEP + ".." + SEP + "bar"));
955 
956         assertEquals(SEP + SEP + "foo" + SEP + "bar", FilenameUtils.normalize("//foo//./bar"));
957         assertEquals(SEP + SEP + "foo" + SEP + "bar", FilenameUtils.normalize("\\\\foo\\\\.\\bar"));
958     }
959 
960     @Test
961     public void testNormalizeNoEndSeparator() {
962         assertNull(FilenameUtils.normalizeNoEndSeparator(null));
963         assertNull(FilenameUtils.normalizeNoEndSeparator(":"));
964         assertNull(FilenameUtils.normalizeNoEndSeparator("1:\\a\\b\\c.txt"));
965         assertNull(FilenameUtils.normalizeNoEndSeparator("1:"));
966         assertNull(FilenameUtils.normalizeNoEndSeparator("1:a"));
967         assertNull(FilenameUtils.normalizeNoEndSeparator("\\\\\\a\\b\\c.txt"));
968         assertNull(FilenameUtils.normalizeNoEndSeparator("\\\\a"));
969 
970         assertEquals("a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalizeNoEndSeparator("a\\b/c.txt"));
971         assertEquals("" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalizeNoEndSeparator("\\a\\b/c.txt"));
972         assertEquals("C:" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalizeNoEndSeparator("C:\\a\\b/c.txt"));
973         assertEquals("" + SEP + "" + SEP + "server" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalizeNoEndSeparator("\\\\server\\a\\b/c.txt"));
974         assertEquals("~" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalizeNoEndSeparator("~\\a\\b/c.txt"));
975         assertEquals("~user" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalizeNoEndSeparator("~user\\a\\b/c.txt"));
976         assertEquals("C:" + SEP + "a" + SEP + "b" + SEP + "c.txt", FilenameUtils.normalizeNoEndSeparator("C:\\\\a\\\\b\\\\c.txt"));
977 
978         assertEquals("a" + SEP + "c", FilenameUtils.normalizeNoEndSeparator("a/b/../c"));
979         assertEquals("c", FilenameUtils.normalizeNoEndSeparator("a/b/../../c"));
980         assertEquals("c", FilenameUtils.normalizeNoEndSeparator("a/b/../../c/"));
981         assertNull(FilenameUtils.normalizeNoEndSeparator("a/b/../../../c"));
982         assertEquals("a", FilenameUtils.normalizeNoEndSeparator("a/b/.."));
983         assertEquals("a", FilenameUtils.normalizeNoEndSeparator("a/b/../"));
984         assertEquals("", FilenameUtils.normalizeNoEndSeparator("a/b/../.."));
985         assertEquals("", FilenameUtils.normalizeNoEndSeparator("a/b/../../"));
986         assertNull(FilenameUtils.normalizeNoEndSeparator("a/b/../../.."));
987         assertEquals("a" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("a/b/../c/../d"));
988         assertEquals("a" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("a/b/../c/../d/"));
989         assertEquals("a" + SEP + "b" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("a/b//d"));
990         assertEquals("a" + SEP + "b", FilenameUtils.normalizeNoEndSeparator("a/b/././."));
991         assertEquals("a" + SEP + "b", FilenameUtils.normalizeNoEndSeparator("a/b/./././"));
992         assertEquals("a", FilenameUtils.normalizeNoEndSeparator("./a/"));
993         assertEquals("a", FilenameUtils.normalizeNoEndSeparator("./a"));
994         assertEquals("", FilenameUtils.normalizeNoEndSeparator("./"));
995         assertEquals("", FilenameUtils.normalizeNoEndSeparator("."));
996         assertNull(FilenameUtils.normalizeNoEndSeparator("../a"));
997         assertNull(FilenameUtils.normalizeNoEndSeparator(".."));
998         assertEquals("", FilenameUtils.normalizeNoEndSeparator(""));
999 
1000         assertEquals(SEP + "a", FilenameUtils.normalizeNoEndSeparator("/a"));
1001         assertEquals(SEP + "a", FilenameUtils.normalizeNoEndSeparator("/a/"));
1002         assertEquals(SEP + "a" + SEP + "c", FilenameUtils.normalizeNoEndSeparator("/a/b/../c"));
1003         assertEquals(SEP + "c", FilenameUtils.normalizeNoEndSeparator("/a/b/../../c"));
1004         assertNull(FilenameUtils.normalizeNoEndSeparator("/a/b/../../../c"));
1005         assertEquals(SEP + "a", FilenameUtils.normalizeNoEndSeparator("/a/b/.."));
1006         assertEquals(SEP + "", FilenameUtils.normalizeNoEndSeparator("/a/b/../.."));
1007         assertNull(FilenameUtils.normalizeNoEndSeparator("/a/b/../../.."));
1008         assertEquals(SEP + "a" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("/a/b/../c/../d"));
1009         assertEquals(SEP + "a" + SEP + "b" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("/a/b//d"));
1010         assertEquals(SEP + "a" + SEP + "b", FilenameUtils.normalizeNoEndSeparator("/a/b/././."));
1011         assertEquals(SEP + "a", FilenameUtils.normalizeNoEndSeparator("/./a"));
1012         assertEquals(SEP + "", FilenameUtils.normalizeNoEndSeparator("/./"));
1013         assertEquals(SEP + "", FilenameUtils.normalizeNoEndSeparator("/."));
1014         assertNull(FilenameUtils.normalizeNoEndSeparator("/../a"));
1015         assertNull(FilenameUtils.normalizeNoEndSeparator("/.."));
1016         assertEquals(SEP + "", FilenameUtils.normalizeNoEndSeparator("/"));
1017 
1018         assertEquals("~" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("~/a"));
1019         assertEquals("~" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("~/a/"));
1020         assertEquals("~" + SEP + "a" + SEP + "c", FilenameUtils.normalizeNoEndSeparator("~/a/b/../c"));
1021         assertEquals("~" + SEP + "c", FilenameUtils.normalizeNoEndSeparator("~/a/b/../../c"));
1022         assertNull(FilenameUtils.normalizeNoEndSeparator("~/a/b/../../../c"));
1023         assertEquals("~" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("~/a/b/.."));
1024         assertEquals("~" + SEP + "", FilenameUtils.normalizeNoEndSeparator("~/a/b/../.."));
1025         assertNull(FilenameUtils.normalizeNoEndSeparator("~/a/b/../../.."));
1026         assertEquals("~" + SEP + "a" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("~/a/b/../c/../d"));
1027         assertEquals("~" + SEP + "a" + SEP + "b" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("~/a/b//d"));
1028         assertEquals("~" + SEP + "a" + SEP + "b", FilenameUtils.normalizeNoEndSeparator("~/a/b/././."));
1029         assertEquals("~" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("~/./a"));
1030         assertEquals("~" + SEP, FilenameUtils.normalizeNoEndSeparator("~/./"));
1031         assertEquals("~" + SEP, FilenameUtils.normalizeNoEndSeparator("~/."));
1032         assertNull(FilenameUtils.normalizeNoEndSeparator("~/../a"));
1033         assertNull(FilenameUtils.normalizeNoEndSeparator("~/.."));
1034         assertEquals("~" + SEP, FilenameUtils.normalizeNoEndSeparator("~/"));
1035         assertEquals("~" + SEP, FilenameUtils.normalizeNoEndSeparator("~"));
1036 
1037         assertEquals("~user" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("~user/a"));
1038         assertEquals("~user" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("~user/a/"));
1039         assertEquals("~user" + SEP + "a" + SEP + "c", FilenameUtils.normalizeNoEndSeparator("~user/a/b/../c"));
1040         assertEquals("~user" + SEP + "c", FilenameUtils.normalizeNoEndSeparator("~user/a/b/../../c"));
1041         assertNull(FilenameUtils.normalizeNoEndSeparator("~user/a/b/../../../c"));
1042         assertEquals("~user" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("~user/a/b/.."));
1043         assertEquals("~user" + SEP + "", FilenameUtils.normalizeNoEndSeparator("~user/a/b/../.."));
1044         assertNull(FilenameUtils.normalizeNoEndSeparator("~user/a/b/../../.."));
1045         assertEquals("~user" + SEP + "a" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("~user/a/b/../c/../d"));
1046         assertEquals("~user" + SEP + "a" + SEP + "b" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("~user/a/b//d"));
1047         assertEquals("~user" + SEP + "a" + SEP + "b", FilenameUtils.normalizeNoEndSeparator("~user/a/b/././."));
1048         assertEquals("~user" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("~user/./a"));
1049         assertEquals("~user" + SEP + "", FilenameUtils.normalizeNoEndSeparator("~user/./"));
1050         assertEquals("~user" + SEP + "", FilenameUtils.normalizeNoEndSeparator("~user/."));
1051         assertNull(FilenameUtils.normalizeNoEndSeparator("~user/../a"));
1052         assertNull(FilenameUtils.normalizeNoEndSeparator("~user/.."));
1053         assertEquals("~user" + SEP, FilenameUtils.normalizeNoEndSeparator("~user/"));
1054         assertEquals("~user" + SEP, FilenameUtils.normalizeNoEndSeparator("~user"));
1055 
1056         assertEquals("C:" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("C:/a"));
1057         assertEquals("C:" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("C:/a/"));
1058         assertEquals("C:" + SEP + "a" + SEP + "c", FilenameUtils.normalizeNoEndSeparator("C:/a/b/../c"));
1059         assertEquals("C:" + SEP + "c", FilenameUtils.normalizeNoEndSeparator("C:/a/b/../../c"));
1060         assertNull(FilenameUtils.normalizeNoEndSeparator("C:/a/b/../../../c"));
1061         assertEquals("C:" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("C:/a/b/.."));
1062         assertEquals("C:" + SEP + "", FilenameUtils.normalizeNoEndSeparator("C:/a/b/../.."));
1063         assertNull(FilenameUtils.normalizeNoEndSeparator("C:/a/b/../../.."));
1064         assertEquals("C:" + SEP + "a" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("C:/a/b/../c/../d"));
1065         assertEquals("C:" + SEP + "a" + SEP + "b" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("C:/a/b//d"));
1066         assertEquals("C:" + SEP + "a" + SEP + "b", FilenameUtils.normalizeNoEndSeparator("C:/a/b/././."));
1067         assertEquals("C:" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("C:/./a"));
1068         assertEquals("C:" + SEP + "", FilenameUtils.normalizeNoEndSeparator("C:/./"));
1069         assertEquals("C:" + SEP + "", FilenameUtils.normalizeNoEndSeparator("C:/."));
1070         assertNull(FilenameUtils.normalizeNoEndSeparator("C:/../a"));
1071         assertNull(FilenameUtils.normalizeNoEndSeparator("C:/.."));
1072         assertEquals("C:" + SEP + "", FilenameUtils.normalizeNoEndSeparator("C:/"));
1073 
1074         assertEquals("C:" + "a", FilenameUtils.normalizeNoEndSeparator("C:a"));
1075         assertEquals("C:" + "a", FilenameUtils.normalizeNoEndSeparator("C:a/"));
1076         assertEquals("C:" + "a" + SEP + "c", FilenameUtils.normalizeNoEndSeparator("C:a/b/../c"));
1077         assertEquals("C:" + "c", FilenameUtils.normalizeNoEndSeparator("C:a/b/../../c"));
1078         assertNull(FilenameUtils.normalizeNoEndSeparator("C:a/b/../../../c"));
1079         assertEquals("C:" + "a", FilenameUtils.normalizeNoEndSeparator("C:a/b/.."));
1080         assertEquals("C:" + "", FilenameUtils.normalizeNoEndSeparator("C:a/b/../.."));
1081         assertNull(FilenameUtils.normalizeNoEndSeparator("C:a/b/../../.."));
1082         assertEquals("C:" + "a" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("C:a/b/../c/../d"));
1083         assertEquals("C:" + "a" + SEP + "b" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("C:a/b//d"));
1084         assertEquals("C:" + "a" + SEP + "b", FilenameUtils.normalizeNoEndSeparator("C:a/b/././."));
1085         assertEquals("C:" + "a", FilenameUtils.normalizeNoEndSeparator("C:./a"));
1086         assertEquals("C:" + "", FilenameUtils.normalizeNoEndSeparator("C:./"));
1087         assertEquals("C:" + "", FilenameUtils.normalizeNoEndSeparator("C:."));
1088         assertNull(FilenameUtils.normalizeNoEndSeparator("C:../a"));
1089         assertNull(FilenameUtils.normalizeNoEndSeparator("C:.."));
1090         assertEquals("C:" + "", FilenameUtils.normalizeNoEndSeparator("C:"));
1091 
1092         assertEquals(SEP + SEP + "server" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("//server/a"));
1093         assertEquals(SEP + SEP + "server" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("//server/a/"));
1094         assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "c", FilenameUtils.normalizeNoEndSeparator("//server/a/b/../c"));
1095         assertEquals(SEP + SEP + "server" + SEP + "c", FilenameUtils.normalizeNoEndSeparator("//server/a/b/../../c"));
1096         assertNull(FilenameUtils.normalizeNoEndSeparator("//server/a/b/../../../c"));
1097         assertEquals(SEP + SEP + "server" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("//server/a/b/.."));
1098         assertEquals(SEP + SEP + "server" + SEP + "", FilenameUtils.normalizeNoEndSeparator("//server/a/b/../.."));
1099         assertNull(FilenameUtils.normalizeNoEndSeparator("//server/a/b/../../.."));
1100         assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("//server/a/b/../c/../d"));
1101         assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "b" + SEP + "d", FilenameUtils.normalizeNoEndSeparator("//server/a/b//d"));
1102         assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "b", FilenameUtils.normalizeNoEndSeparator("//server/a/b/././."));
1103         assertEquals(SEP + SEP + "server" + SEP + "a", FilenameUtils.normalizeNoEndSeparator("//server/./a"));
1104         assertEquals(SEP + SEP + "server" + SEP + "", FilenameUtils.normalizeNoEndSeparator("//server/./"));
1105         assertEquals(SEP + SEP + "server" + SEP + "", FilenameUtils.normalizeNoEndSeparator("//server/."));
1106         assertNull(FilenameUtils.normalizeNoEndSeparator("//server/../a"));
1107         assertNull(FilenameUtils.normalizeNoEndSeparator("//server/.."));
1108         assertEquals(SEP + SEP + "server" + SEP + "", FilenameUtils.normalizeNoEndSeparator("//server/"));
1109     }
1110 
1111     @Test
1112     public void testNormalizeNoEndSeparatorUnixWin() {
1113 
1114         // Normalize (Unix Separator)
1115         assertEquals("/a/c", FilenameUtils.normalizeNoEndSeparator("/a/b/../c/", true));
1116         assertEquals("/a/c", FilenameUtils.normalizeNoEndSeparator("\\a\\b\\..\\c\\", true));
1117 
1118         // Normalize (Windows Separator)
1119         assertEquals("\\a\\c", FilenameUtils.normalizeNoEndSeparator("/a/b/../c/", false));
1120         assertEquals("\\a\\c", FilenameUtils.normalizeNoEndSeparator("\\a\\b\\..\\c\\", false));
1121     }
1122 
1123     @Test
1124     public void testNormalizeUnixWin() {
1125 
1126         // Normalize (Unix Separator)
1127         assertEquals("/a/c/", FilenameUtils.normalize("/a/b/../c/", true));
1128         assertEquals("/a/c/", FilenameUtils.normalize("\\a\\b\\..\\c\\", true));
1129 
1130         // Normalize (Windows Separator)
1131         assertEquals("\\a\\c\\", FilenameUtils.normalize("/a/b/../c/", false));
1132         assertEquals("\\a\\c\\", FilenameUtils.normalize("\\a\\b\\..\\c\\", false));
1133     }
1134 
1135     @Test
1136     public void testRemoveExtension() {
1137         assertNull(FilenameUtils.removeExtension(null));
1138         assertEquals("file", FilenameUtils.removeExtension("file.ext"));
1139         assertEquals("README", FilenameUtils.removeExtension("README"));
1140         assertEquals("domain.dot", FilenameUtils.removeExtension("domain.dot.com"));
1141         assertEquals("image", FilenameUtils.removeExtension("image.jpeg"));
1142         assertEquals("a.b/c", FilenameUtils.removeExtension("a.b/c"));
1143         assertEquals("a.b/c", FilenameUtils.removeExtension("a.b/c.txt"));
1144         assertEquals("a/b/c", FilenameUtils.removeExtension("a/b/c"));
1145         assertEquals("a.b\\c", FilenameUtils.removeExtension("a.b\\c"));
1146         assertEquals("a.b\\c", FilenameUtils.removeExtension("a.b\\c.txt"));
1147         assertEquals("a\\b\\c", FilenameUtils.removeExtension("a\\b\\c"));
1148         assertEquals("C:\\temp\\foo.bar\\README", FilenameUtils.removeExtension("C:\\temp\\foo.bar\\README"));
1149         assertEquals("../filename", FilenameUtils.removeExtension("../filename.ext"));
1150     }
1151 
1152     @Test
1153     public void testSeparatorsToSystem() {
1154         if (WINDOWS) {
1155             assertNull(FilenameUtils.separatorsToSystem(null));
1156             assertEquals("\\a\\b\\c", FilenameUtils.separatorsToSystem("\\a\\b\\c"));
1157             assertEquals("\\a\\b\\c.txt", FilenameUtils.separatorsToSystem("\\a\\b\\c.txt"));
1158             assertEquals("\\a\\b\\c", FilenameUtils.separatorsToSystem("\\a\\b/c"));
1159             assertEquals("\\a\\b\\c", FilenameUtils.separatorsToSystem("/a/b/c"));
1160             assertEquals("D:\\a\\b\\c", FilenameUtils.separatorsToSystem("D:/a/b/c"));
1161         } else {
1162             assertNull(FilenameUtils.separatorsToSystem(null));
1163             assertEquals("/a/b/c", FilenameUtils.separatorsToSystem("/a/b/c"));
1164             assertEquals("/a/b/c.txt", FilenameUtils.separatorsToSystem("/a/b/c.txt"));
1165             assertEquals("/a/b/c", FilenameUtils.separatorsToSystem("/a/b\\c"));
1166             assertEquals("/a/b/c", FilenameUtils.separatorsToSystem("\\a\\b\\c"));
1167             assertEquals("D:/a/b/c", FilenameUtils.separatorsToSystem("D:\\a\\b\\c"));
1168         }
1169     }
1170 
1171     @Test
1172     public void testSeparatorsToUnix() {
1173         assertNull(FilenameUtils.separatorsToUnix(null));
1174         assertEquals("/a/b/c", FilenameUtils.separatorsToUnix("/a/b/c"));
1175         assertEquals("/a/b/c.txt", FilenameUtils.separatorsToUnix("/a/b/c.txt"));
1176         assertEquals("/a/b/c", FilenameUtils.separatorsToUnix("/a/b\\c"));
1177         assertEquals("/a/b/c", FilenameUtils.separatorsToUnix("\\a\\b\\c"));
1178         assertEquals("D:/a/b/c", FilenameUtils.separatorsToUnix("D:\\a\\b\\c"));
1179     }
1180 
1181     @Test
1182     public void testSeparatorsToWindows() {
1183         assertNull(FilenameUtils.separatorsToWindows(null));
1184         assertEquals("\\a\\b\\c", FilenameUtils.separatorsToWindows("\\a\\b\\c"));
1185         assertEquals("\\a\\b\\c.txt", FilenameUtils.separatorsToWindows("\\a\\b\\c.txt"));
1186         assertEquals("\\a\\b\\c", FilenameUtils.separatorsToWindows("\\a\\b/c"));
1187         assertEquals("\\a\\b\\c", FilenameUtils.separatorsToWindows("/a/b/c"));
1188         assertEquals("D:\\a\\b\\c", FilenameUtils.separatorsToWindows("D:/a/b/c"));
1189     }
1190 }