* public class MyTest extends NbTestCase {
* public MyTest(String name) {super(name);}
* public void testWhatever() {...}
* }
*
* @param name name of the test case
*/
public NbTestCase(String name) {
super(name);
}
/**
* Sets active filter.
* @param filter Filter to be set as active for current test, null will reset filtering.
*/
public @Override void setFilter(Filter filter) {
this.filter = filter;
}
/**
* Returns expected fail message.
* @return expected fail message if it's expected this test fail, null otherwise.
*/
public @Override String getExpectedFail() {
if (filter == null) {
return null;
}
return filter.getExpectedFail(this.getName());
}
/**
* Checks if a test isn't filtered out by the active filter.
* @return true if the test can run
*/
public @Override boolean canRun() {
if (NbTestSuite.ignoreRandomFailures()) {
if (getClass().isAnnotationPresent(RandomlyFails.class)) {
System.err.println("Skipping " + getClass().getName());
return false;
}
try {
if (getClass().getMethod(getName()).isAnnotationPresent(RandomlyFails.class)) {
System.err.println("Skipping " + getClass().getName() + "." + getName());
return false;
}
} catch (NoSuchMethodException x) {
// Specially named methods; let it pass.
}
}
if (null == filter) {
//System.out.println("NBTestCase.canRun(): filter == null name=" + name ());
return true; // no filter was aplied
}
boolean isIncluded = filter.isIncluded(this.getName());
//System.out.println("NbTestCase.canRun(): filter.isIncluded(this.getName())="+isIncluded+" ; this="+this);
return isIncluded;
}
/**
* Provide ability for tests, setUp and tearDown to request that they run only in the AWT event queue.
* By default, false.
* @return true to run all test methods, setUp and tearDown in the EQ, false to run in whatever thread
*/
protected boolean runInEQ() {
return false;
}
private static final long vmDeadline;
static {
boolean debugMode = false;
// check if we are debugged
RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
ListIf the system property {@code nbjunit.hard.timeout} is set to a number
* (of milliseconds) by which the whole VM must exit (as in the {@code timeout}
* property to Ant's {@code Warning: the working directory is not guaranteed
* to be empty when you get it, so if this is being called in {@link #setUp} you
* are strongly advised to first call {@link #clearWorkDir} to ensure that each
* test run starts with a clean slate.Logger.getLogger({@linkplain #logRoot logRoot()}) and the messages reported to it
* are then send into regular log file (which is accessible thru {@link NbTestCase#getLog})
* and in case of failure the last few messages is also included
* in failure.getMessage().
*
* @return default implementation returns null which disables any logging
* support in test
* @since 1.27
* @see Log#enable
*/
protected Level logLevel() {
return null;
}
/**
* If overriding {@link #logLevel}, may override this as well to collect messages from only some code.
* @return {@code ""} (default) to collect messages from all loggers; or {@code "my.pkg"} or {@code "my.pkg.Class"} etc.
* @since 1.68
*/
protected String logRoot() {
return "";
}
/**
* Runs the test case, while conditionally skip some according to result of
* {@link #canRun} method.
*/
@Override
public void run(final TestResult result) {
if (canRun()) {
System.setProperty("netbeans.full.hack", "true"); // NOI18N
System.setProperty("java.util.prefs.PreferencesFactory",
MemoryPreferencesFactory.class.getName());//NOI18N
try {
Preferences.userRoot().sync();
} catch(BackingStoreException bex) {}
Level lev = logLevel();
if (lev != null) {
Log.configure(lev, logRoot(), NbTestCase.this);
}
super.run(result);
}
}
private static void appendThread(StringBuffer sb, String indent, Thread t, MapsetUp, runTest and tearDown
* to AWT event thread. It also consults {@link #timeOut} and if so, it starts a
* count down and aborts the runTest if the time out expires.
* @exception Throwable if any exception is thrown
*/
@Override
public void runBare() throws Throwable {
abstract class Guard implements Runnable {
private boolean finished;
private Throwable t;
public abstract void doSomething() throws Throwable;
public @Override void run() {
try {
doSomething();
} catch (Throwable thrwn) {
if (MethodOrder.isShuffled()) {
thrwn = Log.wrapWithAddendum(thrwn, "(executed in shuffle mode, run with -DNbTestCase.order=" + MethodOrder.getSeed() + " to reproduce the order)", true);
}
this.t = Log.wrapWithMessages(thrwn, getWorkDirPath());
} finally {
synchronized (this) {
finished = true;
notifyAll();
}
}
}
public synchronized void waitFinished() throws Throwable {
waitFinished(0);
}
public synchronized void waitFinished(final int timeout) throws Throwable {
long time = timeout;
long startTime = System.currentTimeMillis();
while (!finished){
try {
wait(time);
if (timeout > 0) {
time = timeout - (System.currentTimeMillis() - startTime);
if (time < 1) {
break;
}
}
} catch (InterruptedException ex) {
if (t == null) {
t = ex;
}
}
}
if (t != null) {
throw t;
}
if (!finished) {
throw Log.wrapWithMessages(new AssertionFailedError ("The test " + getName() + " did not finish in " + timeout + "ms\n" +
threadDump())
, getWorkDirPath());
}
}
}
/* original sequence from TestCase.runBare():
setUp();
try {
runTest();
} finally {
tearDown();
}
*/
// setUp
if(runInEQ()) {
Guard setUp = new Guard() {
public @Override void doSomething() throws Throwable {
setUp();
}
};
EventQueue.invokeLater(setUp);
// need to have timeout because previous test case can block AWT thread
setUp.waitFinished(computeTimeOut());
} else {
setUp();
}
try {
// runTest
Guard runTest = new Guard() {
public @Override void doSomething() throws Throwable {
long now = System.nanoTime();
try {
runTest();
} catch (Throwable t) {
noteWorkDir(workdirNoCreate());
throw noteRandomness(t);
} finally {
long last = System.nanoTime() - now;
if (last < 1) {
last = 1;
}
NbTestCase.this.time = last;
}
}
};
if (runInEQ()) {
EventQueue.invokeLater(runTest);
runTest.waitFinished(computeTimeOut());
} else {
if (computeTimeOut() == 0) {
// Regular test.
runTest.run();
runTest.waitFinished();
} else {
// Regular test with time out
Thread watchDog = new Thread(runTest, "Test Watch Dog: " + getName());
watchDog.start();
runTest.waitFinished(computeTimeOut());
}
}
} finally {
// tearDown
if(runInEQ()) {
Guard tearDown = new Guard() {
public @Override void doSomething() throws Throwable {
tearDown();
}
};
EventQueue.invokeLater(tearDown);
// need to have timeout because test can block AWT thread
tearDown.waitFinished(computeTimeOut());
} else {
tearDown();
}
}
}
/**
* Make a note of the working directory for a failed test.
* If running inside Hudson, archive it and show the presumed artifact location.
*/
private void noteWorkDir(File wd) {
if (!wd.isDirectory()) {
return;
}
try {
String buildURL = System.getenv("BUILD_URL");
if (buildURL != null) {
String workspace = new File(System.getenv("WORKSPACE")).getCanonicalPath();
if (!workspace.endsWith(File.separator)) {
workspace += File.separator;
}
String path = wd.getCanonicalPath();
if (path.startsWith(workspace)) {
copytree(wd, new File(wd.getParentFile(), wd.getName() + "-FAILED"));
System.err.println("Working directory: " + buildURL + "artifact/" +
path.substring(workspace.length()).replace(File.separatorChar, '/') + "-FAILED/");
return;
}
}
System.err.println("Working directory: " + wd);
} catch (Exception x) {
x.printStackTrace(); // do not mask real error
}
}
static void copytree(File from, File to) throws IOException {
if (from.isDirectory()) {
if (!to.mkdirs()) {
throw new IOException("mkdir: " + to);
}
for (File f : from.listFiles()) {
copytree(f, new File(to, f.getName()));
}
} else {
InputStream is = new FileInputStream(from);
try {
OutputStream os = new FileOutputStream(to);
try {
// XXX using FileChannel would be more efficient, but more complicated
BufferedInputStream bis = new BufferedInputStream(is);
BufferedOutputStream bos = new BufferedOutputStream(os);
int c;
while ((c = bis.read()) != -1) {
bos.write(c);
}
bos.flush();
bos.close();
} finally {
os.close();
}
} finally {
is.close();
}
}
}
private Throwable noteRandomness(Throwable t) {
Class c = getClass();
if (c.isAnnotationPresent(RandomlyFails.class)) {
return Log.wrapWithAddendum(t, "(" + c.getSimpleName() + " marked @RandomlyFails so try just running test again)", false);
}
try {
if (c.getMethod(getName()).isAnnotationPresent(RandomlyFails.class)) {
return Log.wrapWithAddendum(t, "(" + c.getSimpleName() + "." + getName() + " marked @RandomlyFails so try just running test again)", false);
}
} catch (NoSuchMethodException x) {}
return t;
// XXX would be nice to actually try to rerun the test (but would make runBare more complicated)
}
/** Parses the test name to find out whether it encodes a number. The
* testSomeName1343 represents number 1343.
* @return the number
* @exception may throw AssertionFailedError if the number is not found in the test name
*/
protected final int getTestNumber() {
try {
Matcher m = Pattern.compile("test[a-zA-Z]*([0-9]+)").matcher(getName());
assertTrue("Name does not contain numbers: " + getName(), m.find());
return Integer.valueOf(m.group(1)).intValue();
} catch (Exception ex) {
ex.printStackTrace();
fail("Name: " + getName() + " does not represent number");
return 0;
}
}
/** in nanoseconds */
final long getExecutionTime() {
return time;
}
// additional asserts !!!!
/**
* Asserts that two files are the same (their content is identical), when files
* differ {@link org.netbeans.junit.AssertionFileFailedError AssertionFileFailedError} exception is thrown.
* Depending on the Diff implementation additional output can be generated to the file/dir specified by the
* diff param.
* @param message the detail message for this assertion
* @param test first file to be compared, by the convention this should be the test-generated file
* @param pass second file to be compared, it should be so called 'golden' file, which defines
* the correct content for the test-generated file.
* @param diff file, where differences will be stored, when null differences will not be stored. In case
* it points to directory the result file name is constructed from the pass argument and placed to that
* directory. Constructed file name consists from the name of pass file (without extension and path) appended
* by the '.diff'.
* @param externalDiff instance of class implementing the {@link org.netbeans.junit.diff.Diff} interface, it has to be
* already initialized, when passed in this assertFile function.
*/
static public void assertFile(String message, String test, String pass, String diff, Diff externalDiff) {
Diff diffImpl = null == externalDiff ? Manager.getSystemDiff() : externalDiff;
File diffFile = getDiffName(pass, null == diff ? null : new File(diff));
if (null == diffImpl) {
fail("diff is not available");
} else {
try {
if (null == diffFile) {
if (diffImpl.diff(test, pass, null)) {
throw new AssertionFileFailedError(message, "");
}
} else {
if (diffImpl.diff(test, pass, diffFile.getAbsolutePath())) {
throw new AssertionFileFailedError(message, diffFile.getAbsolutePath());
}
}
} catch (IOException e) {
fail("exception in assertFile : " + e.getMessage());
}
}
}
/**
* Asserts that two files are the same, it uses specific {@link org.netbeans.junit.diff.Diff Diff} implementation to
* compare two files and stores possible differences in the output file.
* @param test first file to be compared, by the convention this should be the test-generated file
* @param pass second file to be compared, it should be so called 'golden' file, which defines the
* correct content for the test-generated file.
* @param diff file, where differences will be stored, when null differences will not be stored. In case
* it points to directory the result file name is constructed from the pass argument and placed to that
* directory. Constructed file name consists from the name of pass file (without extension and path) appended
* by the '.diff'.
* @param externalDiff instance of class implementing the {@link org.netbeans.junit.diff.Diff} interface, it has to be
* already initialized, when passed in this assertFile function.
*/
static public void assertFile(String test, String pass, String diff, Diff externalDiff) {
assertFile(null, test, pass, diff, externalDiff);
}
/**
* Asserts that two files are the same, it compares two files and stores possible differences
* in the output file, the message is displayed when assertion fails.
* @param message the detail message for this assertion
* @param test first file to be compared, by the convention this should be the test-generated file
* @param pass second file to be compared, it should be so called 'golden' file, which defines the
* correct content for the test-generated file.
* @param diff file, where differences will be stored, when null differences will not be stored. In case
* it points to directory the result file name is constructed from the pass argument and placed to that
* directory. Constructed file name consists from the name of pass file (without extension and path) appended
* by the '.diff'.
*/
static public void assertFile(String message, String test, String pass, String diff) {
assertFile(message, test, pass, diff, null);
}
/**
* Asserts that two files are the same, it compares two files and stores possible differences
* in the output file.
* @param test first file to be compared, by the convention this should be the test-generated file
* @param pass second file to be compared, it should be so called 'golden' file, which defines the
* correct content for the test-generated file.
* @param diff file, where differences will be stored, when null differences will not be stored. In case
* it points to directory the result file name is constructed from the pass argument and placed to that
* directory. Constructed file name consists from the name of pass file (without extension and path) appended
* by the '.diff'.
*/
static public void assertFile(String test, String pass, String diff) {
assertFile(null, test, pass, diff, null);
}
/**
* Asserts that two files are the same, it just compares two files and doesn't produce any additional output.
* @param test first file to be compared, by the convention this should be the test-generated file
* @param pass second file to be compared, it should be so called 'golden' file, which defines the
* correct content for the test-generated file.
*/
static public void assertFile(String test, String pass) {
assertFile(null, test, pass, null, null);
}
/**
* Asserts that two files are the same (their content is identical), when files
* differ {@link org.netbeans.junit.AssertionFileFailedError AssertionFileFailedError} exception is thrown.
* Depending on the Diff implementation additional output can be generated to the file/dir specified by the
* diff param.
* @param message the detail message for this assertion
* @param test first file to be compared, by the convention this should be the test-generated file
* @param pass second file to be compared, it should be so called 'golden' file, which defines
* the correct content for the test-generated file.
* @param diff file, where differences will be stored, when null differences will not be stored. In case
* it points to directory the result file name is constructed from the pass argument and placed to that
* directory. Constructed file name consists from the name of pass file (without extension and path) appended
* by the '.diff'.
* @param externalDiff instance of class implementing the {@link org.netbeans.junit.diff.Diff} interface, it has to be
* already initialized, when passed in this assertFile function.
*/
static public void assertFile(String message, File test, File pass, File diff, Diff externalDiff) {
Diff diffImpl = null == externalDiff ? Manager.getSystemDiff() : externalDiff;
File diffFile = getDiffName(pass.getAbsolutePath(), diff);
/*
System.out.println("NbTestCase.assertFile(): diffFile="+diffFile);
System.out.println("NbTestCase.assertFile(): diffImpl="+diffImpl);
System.out.println("NbTestCase.assertFile(): externalDiff="+externalDiff);
*/
if (null == diffImpl) {
fail("diff is not available");
} else {
try {
if (diffImpl.diff(test, pass, diffFile)) {
throw new AssertionFileFailedError(message, null == diffFile ? "" : diffFile.getAbsolutePath());
}
} catch (IOException e) {
fail("exception in assertFile : " + e.getMessage());
}
}
}
/**
* Asserts that two files are the same, it uses specific {@link org.netbeans.junit.diff.Diff Diff} implementation to
* compare two files and stores possible differences in the output file.
* @param test first file to be compared, by the convention this should be the test-generated file
* @param pass second file to be compared, it should be so called 'golden' file, which defines the
* correct content for the test-generated file.
* @param diff file, where differences will be stored, when null differences will not be stored. In case
* it points to directory the result file name is constructed from the pass argument and placed to that
* directory. Constructed file name consists from the name of pass file (without extension and path) appended
* by the '.diff'.
* @param externalDiff instance of class implementing the {@link org.netbeans.junit.diff.Diff} interface, it has to be
* already initialized, when passed in this assertFile function.
*/
static public void assertFile(File test, File pass, File diff, Diff externalDiff) {
assertFile(null, test, pass, diff, externalDiff);
}
/**
* Asserts that two files are the same, it compares two files and stores possible differences
* in the output file, the message is displayed when assertion fails.
* @param message the detail message for this assertion
* @param test first file to be compared, by the convention this should be the test-generated file
* @param pass second file to be compared, it should be so called 'golden' file, which defines the
* correct content for the test-generated file.
* @param diff file, where differences will be stored, when null differences will not be stored. In case
* it points to directory the result file name is constructed from the pass argument and placed to that
* directory. Constructed file name consists from the name of pass file (without extension and path) appended
* by the '.diff'.
*/
static public void assertFile(String message, File test, File pass, File diff) {
assertFile(message, test, pass, diff, null);
}
/**
* Asserts that two files are the same, it compares two files and stores possible differences
* in the output file.
* @param test first file to be compared, by the convention this should be the test-generated file
* @param pass second file to be compared, it should be so called 'golden' file, which defines the
* correct content for the test-generated file.
* @param diff file, where differences will be stored, when null differences will not be stored. In case
* it points to directory the result file name is constructed from the pass argument and placed to that
* directory. Constructed file name consists from the name of pass file (without extension and path) appended
* by the '.diff'.
*/
static public void assertFile(File test, File pass, File diff) {
assertFile(null, test, pass, diff, null);
}
/**
* Asserts that two files are the same, it just compares two files and doesn't produce any additional output.
* @param test first file to be compared, by the convention this should be the test-generated file
* @param pass second file to be compared, it should be so called 'golden' file, which defines the
* correct content for the test-generated file.
*/
static public void assertFile(File test, File pass) {
assertFile("Difference between " + test + " and " + pass, test, pass, null, null);
}
/**
*/
static private File getDiffName(String pass, File diff) {
if (null == diff) {
return null;
}
if (!diff.exists() || diff.isFile()) {
return diff;
}
StringBuilder d = new StringBuilder();
int i1, i2;
d.append(diff.getAbsolutePath());
i1 = pass.lastIndexOf('\\');
i2 = pass.lastIndexOf('/');
i1 = i1 > i2 ? i1 : i2;
i1 = -1 == i1 ? 0 : i1 + 1;
i2 = pass.lastIndexOf('.');
i2 = -1 == i2 ? pass.length() : i2;
if (0 < d.length()) {
d.append("/");
}
d.append(pass.substring(i1, i2));
d.append(".diff");
return new File(d.toString());
}
// methods for work with tests' workdirs
/** Returns path to test method working directory as a String. Path is constructed
* as ${nbjunit.workdir}/${package}.${classname}/${testmethodname}. (The nbjunit.workdir
* property should be set in junit.properties; otherwise the default is ${java.io.tmpdir}/tests.)
* Please note that this method does not guarantee that the working directory really exists.
* @return a path to a test method working directory
*/
public String getWorkDirPath() {
if (workDirPath != null) {
return workDirPath;
}
String name = getName();
// start - PerformanceTestCase overrides getName() method and then
// name can contain illegal characters
String osName = System.getProperty("os.name");
if (osName != null && osName.startsWith("Windows")) {
char ntfsIllegal[] ={'"','/','\\','?','<','>','|',':'};
for (int i=0; iFileObject.getURL() should be returning a file-protocol
* URL, which can be converted to a disk path using new File(URI); or
* use FileUtil.toFile.
*/
@Deprecated
public static String convertNBFSURL(URL url) {
if(url == null) {
throw new IllegalArgumentException("Given URL should not be null.");
}
String externalForm = url.toExternalForm();
if (externalForm.startsWith("nbfs://")) {
// new nbfsurl format (post 06/2003)
return convertNewNBFSURL(url);
} else {
// old nbfsurl (and non nbfs urls)
return convertOldNBFSURL(url);
}
}
// radix for new nbfsurl
private final static int radix = 16;
// new nbfsurl decoder - assumes the external form
// begins with nbfs://
private static String convertNewNBFSURL(URL url) {
String externalForm = url.toExternalForm();
String path;
if (externalForm.startsWith("nbfs://nbhost/")) {
// even newer nbfsurl (hope it does not change soon)
// return path and omit first slash sign
path = url.getPath().substring(1);
} else {
path = externalForm.substring("nbfs://".length());
}
// convert separators (%2f = /, etc.)
StringBuilder sb = new StringBuilder();
int i = 0;
int len = path.length();
while (i < len) {
char ch = path.charAt(i++);
if (ch == '%' && (i+1) < len) {
char h1 = path.charAt(i++);
char h2 = path.charAt(i++);
// convert d1+d2 hex number to char
ch = (char)Integer.parseInt("" + h1 + h2, radix);
}
sb.append(ch);
}
return sb.toString();
}
// old nbfsurl decoder
private static String convertOldNBFSURL(URL url) {
String path = url.getFile();
if(url.getProtocol().equals("nbfs")) {
// delete prefix of special Filesystem (e.g. org.netbeans.modules.javacvs.JavaCvsFileSystem)
String prefixFS = "FileSystem ";
if(path.indexOf(prefixFS)>-1) {
path = path.substring(path.indexOf(prefixFS)+prefixFS.length());
}
// convert separators ("QB="/" etc.)
StringBuilder sb = new StringBuilder();
int i = 0;
int len = path.length();
while (i < len) {
char ch = path.charAt(i++);
if (ch == 'Q' && i < len) {
ch = path.charAt(i++);
switch (ch) {
case 'B':
sb.append('/');
break;
case 'C':
sb.append(':');
break;
case 'D':
sb.append('\\');
break;
case 'E':
sb.append('#');
break;
default:
// not a control sequence
sb.append('Q');
sb.append(ch);
break;
}
} else {
// not Q
sb.append(ch);
}
}
path = sb.toString();
}
return path;
}
/** Asserts that the object can be garbage collected. Tries to GC ref's referent.
* @param text the text to show when test fails.
* @param ref the referent to object that
* should be GCed
*/
public static void assertGC(String text, Reference ref) {
assertGC(text, ref, Collections.emptySet());
}
/** Asserts that the object can be garbage collected. Tries to GC ref's referent.
* @param text the text to show when test fails.
* @param ref the referent to object that should be GCed
* @param rootsHint a set of objects that should be considered part of the
* rootset for this scan. This is useful if you want to verify that one structure
* (usually long living in real application) is not holding another structure
* in memory, without setting a static reference to the former structure.
* Example:
*
* // test body
* WeakHashMap map = new WeakHashMap();
* Object target = new Object();
* map.put(target, "Val");
*
* // verification step
* Reference ref = new WeakReference(target);
* target = null;
* assertGC("WeakMap does not hold the key", ref, Collections.singleton(map));
*
*/
public static void assertGC(final String text, final Reference ref, final Set rootsHint) {
NbModuleLogHandler.whileIgnoringOOME(new Runnable() {
@SuppressWarnings({"SleepWhileHoldingLock", "SleepWhileInLoop"})
public @Override void run() {
List-1 on internal error.
*/
public static int assertSize(String message, Collection roots, int limit, final MemoryFilter skip) {
org.netbeans.insane.scanner.Filter f = new org.netbeans.insane.scanner.Filter() {
public @Override boolean accept(Object o, Object refFrom, Field ref) {
return !skip.reject(o);
}
};
return assertSize(message, roots, limit, f);
}
private static int assertSize(String message, Collection roots, int limit,
org.netbeans.insane.scanner.Filter f) {
try {
final CountingVisitor counter = new CountingVisitor();
ScannerUtils.scan(f, counter, roots, false);
int sum = counter.getTotalSize();
if (sum > limit) {
StringBuilder sb = new StringBuilder(4096);
sb.append(message);
sb.append(": leak ").append(sum - limit).append(" bytes ");
sb.append(" over limit of ");
sb.append(limit).append(" bytes");
Set