267 lines
8.3 KiB
Java
267 lines
8.3 KiB
Java
/*
|
|
* Copyright (c) 1998, 2016, 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.
|
|
*/
|
|
|
|
import java.io.IOException;
|
|
import java.io.PrintWriter;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.lang.reflect.Modifier;
|
|
import java.util.ArrayList;
|
|
import java.util.Map;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* IntlTest is a base class for tests that can be run conveniently from
|
|
* the command line as well as under the Java test harness.
|
|
* <p>
|
|
* Sub-classes implement a set of public void methods named "Test*" or
|
|
* "test*" with no arguments. Each of these methods performs some
|
|
* test. Test methods should indicate errors by calling either err() or
|
|
* errln(). This will increment the errorCount field and may optionally
|
|
* print a message to the log. Debugging information may also be added to
|
|
* the log via the log and logln methods. These methods will add their
|
|
* arguments to the log only if the test is being run in verbose mode.
|
|
*/
|
|
public abstract class IntlTest {
|
|
|
|
//------------------------------------------------------------------------
|
|
// Everything below here is boilerplate code that makes it possible
|
|
// to add a new test by simply adding a method to an existing class.
|
|
//------------------------------------------------------------------------
|
|
|
|
protected IntlTest() {
|
|
// Populate testMethods with all the test methods.
|
|
Method[] methods = getClass().getDeclaredMethods();
|
|
for (Method method : methods) {
|
|
if (Modifier.isPublic(method.getModifiers())
|
|
&& method.getReturnType() == void.class
|
|
&& method.getParameterCount() == 0) {
|
|
String name = method.getName();
|
|
if (name.length() > 4) {
|
|
if (name.startsWith("Test") || name.startsWith("test")) {
|
|
testMethods.put(name, method);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void run(String[] args) throws Exception
|
|
{
|
|
// Set up the log and reference streams. We use PrintWriters in order to
|
|
// take advantage of character conversion. The JavaEsc converter will
|
|
// convert Unicode outside the ASCII range to Java's \\uxxxx notation.
|
|
log = new PrintWriter(System.out, true);
|
|
|
|
// Parse the test arguments. They can be either the flag
|
|
// "-verbose" or names of test methods. Create a list of
|
|
// tests to be run.
|
|
List<Method> testsToRun = new ArrayList<>(args.length);
|
|
for (String arg : args) {
|
|
switch (arg) {
|
|
case "-verbose":
|
|
verbose = true;
|
|
break;
|
|
case "-prompt":
|
|
prompt = true;
|
|
break;
|
|
case "-nothrow":
|
|
nothrow = true;
|
|
break;
|
|
default:
|
|
Method m = testMethods.get(arg);
|
|
if (m == null) {
|
|
System.out.println("Method " + arg + ": not found");
|
|
usage();
|
|
return;
|
|
}
|
|
testsToRun.add(m);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If no test method names were given explicitly, run them all.
|
|
if (testsToRun.isEmpty()) {
|
|
testsToRun.addAll(testMethods.values());
|
|
}
|
|
|
|
System.out.println(getClass().getName() + " {");
|
|
indentLevel++;
|
|
|
|
// Run the list of tests given in the test arguments
|
|
for (Method testMethod : testsToRun) {
|
|
int oldCount = errorCount;
|
|
|
|
writeTestName(testMethod.getName());
|
|
|
|
try {
|
|
testMethod.invoke(this, new Object[0]);
|
|
} catch (IllegalAccessException e) {
|
|
errln("Can't acces test method " + testMethod.getName());
|
|
} catch (InvocationTargetException e) {
|
|
errln("Uncaught exception thrown in test method "
|
|
+ testMethod.getName());
|
|
e.getTargetException().printStackTrace(this.log);
|
|
}
|
|
writeTestResult(errorCount - oldCount);
|
|
}
|
|
indentLevel--;
|
|
writeTestResult(errorCount);
|
|
|
|
if (prompt) {
|
|
System.out.println("Hit RETURN to exit...");
|
|
try {
|
|
System.in.read();
|
|
} catch (IOException e) {
|
|
System.out.println("Exception: " + e.toString() + e.getMessage());
|
|
}
|
|
}
|
|
if (nothrow) {
|
|
System.exit(errorCount);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the given message to the log if we are in verbose mode.
|
|
*/
|
|
protected void log(String message) {
|
|
logImpl(message, false);
|
|
}
|
|
|
|
protected void logln(String message) {
|
|
logImpl(message, true);
|
|
}
|
|
|
|
protected void logln() {
|
|
logImpl(null, true);
|
|
}
|
|
|
|
private void logImpl(String message, boolean newline) {
|
|
if (verbose) {
|
|
if (message != null) {
|
|
indent(indentLevel + 1);
|
|
log.print(message);
|
|
}
|
|
if (newline) {
|
|
log.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void err(String message) {
|
|
errImpl(message, false);
|
|
}
|
|
|
|
protected void errln(String message) {
|
|
errImpl(message, true);
|
|
}
|
|
|
|
private void errImpl(String message, boolean newline) {
|
|
errorCount++;
|
|
indent(indentLevel + 1);
|
|
log.print(message);
|
|
if (newline) {
|
|
log.println();
|
|
}
|
|
log.flush();
|
|
|
|
if (!nothrow) {
|
|
throw new RuntimeException(message);
|
|
}
|
|
}
|
|
|
|
protected int getErrorCount() {
|
|
return errorCount;
|
|
}
|
|
|
|
protected void writeTestName(String testName) {
|
|
indent(indentLevel);
|
|
log.print(testName);
|
|
log.flush();
|
|
needLineFeed = true;
|
|
}
|
|
|
|
protected void writeTestResult(int count) {
|
|
if (!needLineFeed) {
|
|
indent(indentLevel);
|
|
log.print("}");
|
|
}
|
|
needLineFeed = false;
|
|
|
|
if (count != 0) {
|
|
log.println(" FAILED");
|
|
} else {
|
|
log.println(" Passed");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Returns a spece-delimited hex String.
|
|
*/
|
|
protected static String toHexString(String s) {
|
|
StringBuilder sb = new StringBuilder(" ");
|
|
|
|
for (int i = 0; i < s.length(); i++) {
|
|
sb.append(Integer.toHexString(s.charAt(i)));
|
|
sb.append(' ');
|
|
}
|
|
|
|
return sb.toString();
|
|
}
|
|
|
|
private void indent(int distance) {
|
|
if (needLineFeed) {
|
|
log.println(" {");
|
|
needLineFeed = false;
|
|
}
|
|
log.print(SPACES.substring(0, distance * 2));
|
|
}
|
|
|
|
/**
|
|
* Print a usage message for this test class.
|
|
*/
|
|
void usage() {
|
|
System.out.println(getClass().getName() +
|
|
": [-verbose] [-nothrow] [-prompt] [test names]");
|
|
|
|
System.out.println(" Available test names:");
|
|
for (String methodName : testMethods.keySet()) {
|
|
System.out.println("\t" + methodName);
|
|
}
|
|
}
|
|
|
|
private boolean prompt;
|
|
private boolean nothrow;
|
|
protected boolean verbose;
|
|
|
|
private PrintWriter log;
|
|
private int indentLevel;
|
|
private boolean needLineFeed;
|
|
private int errorCount;
|
|
|
|
private final Map<String, Method> testMethods = new LinkedHashMap<>();
|
|
|
|
private static final String SPACES = " ";
|
|
}
|