4040927d17
Reviewed-by: naoto, rriggs, alanb, lancea
214 lines
8.2 KiB
Java
214 lines
8.2 KiB
Java
/*
|
|
* Copyright (c) 2008, 2022, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/* @test
|
|
* @bug 4313887 6866397 8073445 8290047
|
|
* @summary Unit test for java.nio.file.PathMatcher
|
|
*/
|
|
|
|
import java.nio.file.*;
|
|
import java.util.regex.PatternSyntaxException;
|
|
|
|
public class Basic {
|
|
static int failures;
|
|
|
|
static void match(String name, String pattern, boolean expectedToMatch) {
|
|
System.out.format("%s -> %s", name, pattern);
|
|
Path file = Paths.get(name);
|
|
boolean matched = file.getFileSystem()
|
|
.getPathMatcher("glob:" + pattern).matches(file);
|
|
if (matched)
|
|
System.out.print(" (matched)");
|
|
else
|
|
System.out.print(" (no match)");
|
|
if (matched != expectedToMatch) {
|
|
System.out.println(" ==> UNEXPECTED RESULT!");
|
|
failures++;
|
|
} else {
|
|
System.out.println(" OKAY");
|
|
}
|
|
}
|
|
|
|
static void assertMatch(String path, String pattern) {
|
|
match(path, pattern, true);
|
|
}
|
|
|
|
static void assertNotMatch(String path, String pattern) {
|
|
match(path, pattern, false);
|
|
}
|
|
|
|
static void assertBadPattern(String path, String pattern) {
|
|
System.out.format("Compile bad pattern %s\t", pattern);
|
|
try {
|
|
FileSystems.getDefault().getPathMatcher("glob:" + pattern);
|
|
System.out.println("Compiled ==> UNEXPECTED RESULT!");
|
|
failures++;
|
|
} catch (PatternSyntaxException e) {
|
|
System.out.println("Failed to compile ==> OKAY");
|
|
}
|
|
}
|
|
|
|
static void assertRegExMatch(String path, String pattern) {
|
|
System.out.format("Test regex pattern: %s", pattern);
|
|
Path file = Paths.get(path);
|
|
boolean matched = file.getFileSystem()
|
|
.getPathMatcher("regex:" + pattern).matches(file);
|
|
if (matched) {
|
|
System.out.println(" OKAY");
|
|
} else {
|
|
System.out.println(" ==> UNEXPECTED RESULT!");
|
|
failures++;
|
|
}
|
|
}
|
|
|
|
|
|
public static void main(String[] args) {
|
|
// basic
|
|
assertMatch("", "");
|
|
assertMatch("foo.html", "foo.html");
|
|
assertNotMatch("foo.html", "foo.htm");
|
|
assertNotMatch("foo.html", "bar.html");
|
|
|
|
// match zero or more characters
|
|
assertMatch("foo.html", "f*");
|
|
assertMatch("foo.html", "*.html");
|
|
assertMatch("foo.html", "foo.html*");
|
|
assertMatch("foo.html", "*foo.html");
|
|
assertMatch("foo.html", "*foo.html*");
|
|
assertNotMatch("foo.html", "*.htm");
|
|
assertNotMatch("foo.html", "f.*");
|
|
|
|
// match one character
|
|
assertMatch("foo.html", "?oo.html");
|
|
assertMatch("foo.html", "??o.html");
|
|
assertMatch("foo.html", "???.html");
|
|
assertMatch("foo.html", "???.htm?");
|
|
assertNotMatch("foo.html", "foo.???");
|
|
|
|
// group of subpatterns
|
|
assertMatch("foo.html", "foo{.html,.class}");
|
|
assertMatch("foo.html", "foo.{class,html}");
|
|
assertNotMatch("foo.html", "foo{.htm,.class}");
|
|
|
|
// bracket expressions
|
|
assertMatch("foo.html", "[f]oo.html");
|
|
assertMatch("foo.html", "[e-g]oo.html");
|
|
assertMatch("foo.html", "[abcde-g]oo.html");
|
|
assertMatch("foo.html", "[abcdefx-z]oo.html");
|
|
assertMatch("foo.html", "[!a]oo.html");
|
|
assertMatch("foo.html", "[!a-e]oo.html");
|
|
assertMatch("foo-bar", "foo[-a-z]bar"); // match dash
|
|
assertMatch("foo.html", "foo[!-]html"); // match !dash
|
|
|
|
// groups of subpattern with bracket expressions
|
|
assertMatch("foo.html", "[f]oo.{[h]tml,class}");
|
|
assertMatch("foo.html", "foo.{[a-z]tml,class}");
|
|
assertMatch("foo.html", "foo.{[!a-e]tml,.class}");
|
|
|
|
// assume special characters are allowed in file names
|
|
assertMatch("{foo}.html", "\\{foo*");
|
|
assertMatch("{foo}.html", "*\\}.html");
|
|
assertMatch("[foo].html", "\\[foo*");
|
|
assertMatch("[foo].html", "*\\].html");
|
|
|
|
// errors
|
|
assertBadPattern("foo.html", "*[a--z]"); // bad range
|
|
assertBadPattern("foo.html", "*[a--]"); // bad range
|
|
assertBadPattern("foo.html", "*[a-z"); // missing ]
|
|
assertBadPattern("foo.html", "*{class,java"); // missing }
|
|
assertBadPattern("foo.html", "*.{class,{.java}}"); // nested group
|
|
assertBadPattern("foo.html", "*.html\\"); // nothing to escape
|
|
try {
|
|
FileSystems.getDefault().getPathMatcher(":glob");
|
|
System.err.println("No IllegalArgumentException for \":glob\"");
|
|
failures++;
|
|
} catch (IllegalArgumentException iae) {
|
|
System.out.println("IllegalArgumentException for \":glob\" OKAY");
|
|
}
|
|
|
|
// platform specific
|
|
if (System.getProperty("os.name").startsWith("Windows")) {
|
|
assertMatch("C:\\foo", "C:\\\\f*");
|
|
assertMatch("C:\\FOO", "c:\\\\f*");
|
|
assertMatch("C:\\foo\\bar\\gus", "C:\\\\**\\\\gus");
|
|
assertMatch("C:\\foo\\bar\\gus", "C:\\\\**");
|
|
} else {
|
|
assertMatch("/tmp/foo", "/tmp/*");
|
|
assertMatch("/tmp/foo/bar", "/tmp/**");
|
|
|
|
// some special characters not allowed on Windows
|
|
assertMatch("myfile?", "myfile\\?");
|
|
assertMatch("one\\two", "one\\\\two");
|
|
assertMatch("one*two", "one\\*two");
|
|
}
|
|
|
|
// regex syntax
|
|
assertRegExMatch("foo.html", ".*\\.html");
|
|
|
|
if (System.getProperty("os.name").startsWith("Windows")) {
|
|
assertRegExMatch("foo012", "foo\\d+");
|
|
assertRegExMatch("fo o", "fo\\so");
|
|
assertRegExMatch("foo", "\\w+");
|
|
}
|
|
|
|
// unknown syntax
|
|
try {
|
|
System.out.format("Test unknown syntax");
|
|
FileSystems.getDefault().getPathMatcher("grep:foo");
|
|
System.out.println(" ==> NOT EXPECTED TO COMPILE");
|
|
failures++;
|
|
} catch (UnsupportedOperationException e) {
|
|
System.out.println(" OKAY");
|
|
}
|
|
|
|
// GLOB_SYNTAX case sensitivity of getPathMatcher: should not throw UOE
|
|
try {
|
|
FileSystems.getDefault().getPathMatcher("glob:java");
|
|
FileSystems.getDefault().getPathMatcher("Glob:java");
|
|
FileSystems.getDefault().getPathMatcher("GLOB:java");
|
|
System.out.println("Test GLOB_SYNTAX case sensitivity OKAY");
|
|
} catch (UnsupportedOperationException e) {
|
|
System.err.println("getPathMatcher GLOB_SYNTAX case sensitivity");
|
|
e.printStackTrace();
|
|
failures++;
|
|
}
|
|
|
|
// REGEX_SYNTAX case sensitivity of getPathMatcher: should not throw UOE
|
|
try {
|
|
FileSystems.getDefault().getPathMatcher("regex:java");
|
|
FileSystems.getDefault().getPathMatcher("Regex:java");
|
|
FileSystems.getDefault().getPathMatcher("RegEx:java");
|
|
FileSystems.getDefault().getPathMatcher("REGEX:java");
|
|
System.out.println("Test REGEX_SYNTAX case sensitivity OKAY");
|
|
} catch (UnsupportedOperationException e) {
|
|
System.err.println("getPathMatcher REGEX_SYNTAX case sensitivity");
|
|
e.printStackTrace();
|
|
failures++;
|
|
}
|
|
|
|
if (failures > 0)
|
|
throw new RuntimeException(failures +
|
|
" sub-test(s) failed - see log for details");
|
|
}
|
|
}
|