2012-12-29
2012-12-24
Let's Code Jumi #204: Run Events (Part 1)
The RunIds and the onRunStarted/onRunFinished events must still be propagated through the rest of the system and put into full use.
2012-12-01
Let's Code Jumi #200: Generating RunIds (Part 1)
The user interface supports multiple test runs, but the backend does not yet generate unique RunIds for the runs.
2012-11-20
2012-11-15
2012-11-09
2012-11-06
Let's Code Jumi #196: Fixing Event Stub Conflicts (Part 1)
An earlier refactoring exposed a problem with the code generator which caused the generated event stubs of one interface to overwrite those of another interface.
2012-10-23
Let's Code Jumi #194: Design Feedback (Part 1)
Writing unit tests in SuiteRunnerTest revealed that the DriverFinder interface makes things hard to test, so let's improve the design to make it testable.
2012-10-01
Let's Code Jumi #190: Calm Before the Storm (Part 1)
The next feature to add is generating the RunIds. But before implementing that, let's take a moment to refactor the classes which will soon be modified.
2012-09-21
Let's Code Jumi #188: Checking Test Runs (Part 1)
With TextUIParser implemented, we can improve the end-to-end tests to check individual test runs, which will expose what has not yet been implemented in the support for multiple test runs.
P.S. The Jumi test runner has just now had its first release. Go check out the announcement video on YouTube.
2012-09-14
Let's Code Jumi #187: Regular Expressions (Part 4)
Adding support for multiple test runs into TextUIParser. Lots of regular expressions are needed, including less often used regex features such as positive lookahead and embedded flag expressions.
2012-09-07
Let's Code Jumi #184: Regular Expressions (Part 1)
Adding support for multiple test runs into TextUIParser. Lots of regular expressions are needed, including less often used regex features such as positive lookahead and embedded flag expressions.
2012-09-01
Let's Code Jumi #182: Primitive Obsession (Part 1)
Removing primitive obsession by replacing the use of ints with RunId. Tens of places need to be updated, so it's important to proceed in small steps, passing all tests every couple of minutes.
2012-08-26
Let's Code Jumi #180: Enter RunId (Part 1)
Introducing Run IDs step by step, to make it possible to identify concurrent test runs.
2012-08-21
Let's Code Jumi #178: Imports (Part 1)
Our code generator tries to import primitive types, so that needs to be fixed before we can add Run IDs to the SuiteListener interface. This is also a chance to leave the code a little bit better than we found it.
2012-08-13
Let's Code Jumi #175: Text UI Parsing (Part 1)
To improve the end-to-end tests to detect the incompleteness of the system, I will need to parse the text UI.
2012-08-07
2012-08-04
2012-08-01
2012-07-29
Let's Code Jumi #171: Refactoring TestClassRunner (Part 1)
The tests are now being executed in parallel, though the events from parallel test runs are still mixed in the output. But the new code must be cleaned up before fixing that.
2012-07-16
Let's Code Jumi #167: Parallel Execution (Part 1)
It's time to make the system run tests in parallel. We'll write a test class which passes only if its test methods are called in parallel, and then fix one part of the system which accidentally assumed sequential execution.
2012-07-12
2012-07-09
2012-07-07
2012-07-03
Let's Code Jumi #163: Require Thread-Safety Annotations (Part 1)
I forgot to add the @NotThreadSafe annotation to TextUI, so let's write a test to make sure I will never again forget that. Those annotations have RetentionPolicy.CLASS so using reflection is not an option and bytecode analyzing is required.
2012-07-01
Let's Code Jumi #162: Use the New Text UI
With the new event-based text UI working, we can replace the old text UI with it.
2012-06-17
Let's Code Jumi #159: Test Names (Part 1)
Improving the new text UI to print the names of tests and their beginnings and endings.
2012-06-02
Let's Code Jumi #155: Event-Based Text UI (Part 1)
Creating a more production-ready text user interface which will print results as they arrive, instead of waiting for all tests to finish executing.
2012-05-16
Let's Code Jumi #151: Text UI & Stack Traces (Part 1)
Creating a text user interface and changing the end-to-end tests to run against it. Showing exception stack traces in the UI.
2012-05-13
Let's Code Jumi Special #1: Contract Tests
Trying a more systematic way of creating a new implementation to pass contract tests than what I did a year ago when originally implementing single-threaded actors. See my blog post for more details on this experiment.
2012-05-03
Let's Code Jumi #148: Mutation Testing (Part 1)
PIT is the first user friendly mutation testing framework for Java that I know of. Line coverage is a lousy measure compared to mutation coverage, which actually makes sure that your tests are testing something.
2012-04-30
Let's Code Jumi #147: Single-Class Imports
The generated imports can be made a bit more specific, avoiding superfluous imports.
2012-04-24
Let's Code Jumi #145: Builder (Part 1)
Now I can see clearer what the code generator's structure should be like, so let's replace the previous procedural approach with a builder.
2012-04-12
Let's Code Jumi #141: Generic Type Parameters (Part 1)
Improving the code generator to produce correct generic type parameters. Even after Java's type erasure it's possible to dig out some type parameter information using reflection.
2012-04-07
Let's Code Jumi #139: Better Printing (Part 1)
With the previous feature done, it's a good time to refactor the code generator some. Let's first generate toString() methods for the event classes and improve the code formatting.
2012-04-02
Let's Code Jumi #137: One Failing Test (Part 6)
Let's see where the end-to-end tests fail next and continue our implementation of failure reporting from there.
2012-03-30
2012-03-25
Let's Code Jumi #135: SimpleUnit's Test Reporting (Part 1)
The end-to-end tests were failing because our minimal SimpleUnit testing framework is incomplete - it does not yet execute tests and report test execution events.
2012-03-22
Let's Code Jumi #134: One Failing Test (Part 5)
Let's see where the end-to-end tests fail next and continue our implementation of failure reporting from there.
2012-03-19
Let's Code Jumi #133: Fail Early
Improving the SpyListener and SingleThreadedActors classes to fail early, to help catching more problems.
2012-03-13
Let's Code Jumi #131: One Failing Test (Part 3)
Let's see where the end-to-end tests fail next and continue our implementation of failure reporting from there.
2012-02-28
Let's Code Jumi #127: Better Mocks (Part 2)
None of Java's three popular mocking frameworks produced as readable error messages as I would like, so let's try creating a hand-written mock.
2012-02-25
Let's Code Jumi #126: Better Mocks (Part 1)
In the last episode there was a test failure with a misleading error message. I will evaluate JMock and EasyMock to see whether they would produce better error messages than Mockito.
2012-02-19
Let's Code Jumi #124: One Failing Test (Part 1)
Begin adding support for reporting test failures. Let's first focus on getting just the number of failed tests reported, and leave reporting the stack traces for later.
2012-02-16
Let's Code Jumi #123: Hunting Concurrency Bugs (Part 2)
Adding the rest of the JSR-305 annotations and doing some performance testing for the thread safety checker.
2012-02-12
Let's Code Jumi #122: Improved Stack Traces
Because of the way how Java shortens chained strack traces, the stack traces in last episode were a bit confusing to read, so let's improve that before continuing with more concurrency testing.
2012-02-01
Let's Code Jumi #121: Hunting Concurrency Bugs (Part 1)
Adding JSR-305 annotations (@NotThreadSafe etc.) and actually finding one concurrency bug, so our doubts were not unwarranted.
2012-01-29
Let's Code Jumi #120: Finishing Touches
Some refactoring to improve thread-safety checker's exception messages before starting to use it.
2012-01-21
Let's Code Jumi #117: Generating Line Numbers (Part 1)
The stack traces from the thread-safety checker are missing line numbers for the method which was called from a wrong thread, so let's add those to the generated bytecode.
2012-01-16
Let's Code Jumi #115: Using the Agent (Part 1)
Putting the thread-safety checker's Java agent into real use, which helps to weed out some bugs.