Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

195 lines (151 sloc) 5.403 kB

Summary of Changes in version 4.7

Rules

  • Rules allow very flexible addition or redefinition of the behavior of each test method in a test class. Testers can reuse or extend one of the provided Rules below, or write their own.

    For more on this feature, see http://www.threeriversinstitute.org/blog/?p=155

  • The TemporaryFolder Rule allows creation of files and folders that are guaranteed to be deleted when the test method finishes (whether it passes or fails):

    public static class HasTempFolder { @Rule public TemporaryFolder folder= new TemporaryFolder();

      @Test
      public void testUsingTempFolder() throws IOException {
          File createdFile= folder.newFile("myfile.txt");
          File createdFolder= folder.newFolder("subfolder");
          // ...
      }

    }

  • ExternalResource is a base class for Rules (like TemporaryFolder) that set up an external resource before a test (a file, socket, server, database connection, etc.), and guarantee to tear it down afterward:

    public static class UsesExternalResource { Server myServer = new Server();

      @Rule public ExternalResource resource = new ExternalResource() {
          @Override
          protected void before() throws Throwable {
              myServer.connect();
          };
    
          @Override
          protected void after() {
              myServer.disconnect();
          };
      };
    
      @Test public void testFoo() {
          new Client().run(myServer);
      }

    }

  • The ErrorCollector Rule allows execution of a test to continue after the first problem is found (for example, to collect all the incorrect rows in a table, and report them all at once):

    public static class UsesErrorCollectorTwice { @Rule public ErrorCollector collector= new ErrorCollector();

      @Test public void example() {
          collector.addError(new Throwable("first thing went wrong"));
          collector.addError(new Throwable("second thing went wrong"));
      }

    }

  • Verifier is a base class for Rules like ErrorCollector, which can turn otherwise passing test methods into failing tests if a verification check is failed

    public static class ErrorLogVerifier() { private ErrorLog errorLog = new ErrorLog();

     @Rule
     public MethodRule verifier = new Verifier() {
        @Override public void verify() {
           assertTrue(errorLog.isEmpty());
        }
     }
    
     @Test public void testThatMightWriteErrorLog() {
        // ...
     }

    }

  • TestWatchman is a base class for Rules that take note of the testing action, without modifying it. For example, this class will keep a log of each passing and failing test:

    public static class WatchmanTest { private static String watchedLog;

      @Rule
      public MethodRule watchman= new TestWatchman() {
          @Override
          public void failed(Throwable e, FrameworkMethod method) {
              watchedLog+= method.getName() + " "
                      + e.getClass().getSimpleName() + "\n";
          }
    
          @Override
          public void succeeded(FrameworkMethod method) {
              watchedLog+= method.getName() + " " + "success!\n";
          }
      };
    
      @Test
      public void fails() {
          fail();
      }
    
      @Test
      public void succeeds() {
      }

    }

  • The TestName Rule makes the current test name available inside test methods:

    public class NameRuleTest { @Rule public TestName name = new TestName();

    @Test public void testA() {
        assertEquals("testA", name.getMethodName());
    }
    
    @Test public void testB() {
        assertEquals("testB", name.getMethodName());
    }

    }

  • The Timeout Rule applies the same timeout to all test methods in a class:

    public static class HasGlobalTimeout { public static String log;

    @Rule public MethodRule globalTimeout = new Timeout(20);
    
    @Test public void testInfiniteLoop1() {
        log+= "ran1";
        for(;;) {}
    }
    
    @Test public void testInfiniteLoop2() {
        log+= "ran2";
        for(;;) {}
    }

    }

  • The ExpectedException Rule allows in-test specification of expected exception types and messages:

    public static class HasExpectedException { @Rule public ExpectedException thrown= ExpectedException.none();

      @Test
      public void throwsNothing() {
    
      }
    
      @Test
      public void throwsNullPointerException() {
          thrown.expect(NullPointerException.class);
          throw new NullPointerException();
      }
    
      @Test
      public void throwsNullPointerExceptionWithMessage() {
          thrown.expect(NullPointerException.class);
          thrown.expectMessage("happened?");
          thrown.expectMessage(startsWith("What"));
          throw new NullPointerException("What happened?");
      }

    }

Timeouts

  • Tests that time out now show the stack trace of the test thread.

Matchers

  • Due to typing incompatibilities, JUnit is still including the 1.1 release of hamcrest. This is not a change from 4.6, but is a change from pre-beta releases of 4.7. Due to this incompatibility, tests using Hamcrest 1.2 must still use the MatcherAssert.assertThat method from Hamcrest, not Assert.assertThat from JUnit.

Docs

  • Javadocs now link to online JDK javadocs (bug 2090230)
  • Parameterized runner javadocs improved (bug 2186792)
  • Fixed Javadoc code sample for AfterClass (2126279)
  • Fixed Javadoc for assertArraysEqual(float[], float[])

Bug fixes

  • Fixed: BaseTestRunner.getTest() requires class to extend TestCase (1812200)
  • Fixed: Suite does not allow for inheritance in annotations (2783118)
  • Fixed: ParallelComputer skipped tests that took longer than 2 seconds
Jump to Line
Something went wrong with that request. Please try again.