Eclipse Extension Point Evaluation Made Easy
Coding Eclipse Extension Point evaluations comes in a bit verbose and sparsely self-explaining. As I got round to busy myself with this topic recently, I wrote a little helper with the intent to reduce boilerplate code for common programming steps, while increasing development guidance and readability at the same time….
JUnit in a Nutshell: Yet Another JUnit Tutorial
Why Another JUnit Tutorial? JUnit seems to be the most popular testing tool for developers within the Java world. So it is no wonder that there have been written some good books about this topic. But I still meet quite often programmers, who at most have a vague understanding of…
How to Access a Git Repository with JGit
A Git repository is represented in JGit through the Repository class that can be viewed as a handle to a repository. With a Repository instance, you can create JGit commands (through the Git factory class), gain access to configuration settings, resolve refs, etc. There are several ways to obtain a…
How to Safely Use SWT’s Display asyncExec
Most user interface (UI) toolkits are single-threaded and SWT is no exception. This restriction means that UI objects must be accessed exclusively from a single thread, the so-called UI thread. On the other hand, long-running tasks should be executed in background threads to keep the UI responsive. This makes it…
JUnit in a Nutshell: Unit Test Assertion
The last chapter of my multi-part tutorial about JUnit essentials covers various unit test assertion techniques. It elaborates on the pros and cons of the built-in mechanism, Hamcrest matchers and AssertJ assertions. The ongoing example enlarges upon the subject and shows how to create and use custom matchers/assertions. Unit Test…
JUnit in a Nutshell: Test Runners
The fourth chapter of my multi-part tutorial about JUnit testing essentials explains the purpose of the tool’s exchangable test runners architecture and introduces some of the available implementations. The ongoing example enlarges upon the subject by going through the different possibilities of writting parameterized tests. Since I have already published…
JUnit in a Nutshell: Test Isolation
Chapter three of my multi-part tutorial about JUnit essentials discusses the implications of unit dependencies for testing. The post illustrates the test isolation principle and shows how it can be put into practice – based on the nomenclature defined by Meszaros in xUnit Test Patterns [MES]. The ongoing example continues…
JUnit in a Nutshell: Test Structure
Chapter two of my multi-part tutorial about JUnit testing essentials will continue the ongoing example and work out the common structure that charactarizes well written unit tests. The nomenclature used throughout this post was defined by Meszaros in xUnit Test Patterns [MES]. The Four Phases of a Test The tutorial’s…
JUnit in a Nutshell: Hello World
JUnit in a Nutshell is a multi-part tutorial about the essentials of JUnit testing. This Hello World chapter introduces the very basics of a test: how it is written, executed and evaluated. The post also kicks off the ongoing example, which is continuously carried forward throughout this mini-series. Why bother?…
Clean JUnit Throwable-Tests with Java 8 Lambdas
Recently I was involved in a short online discussion on twitter and google+ which concerned the question why the arrival of Java 8 Lambda expressions makes the catch-exception library1 obsolete. This was triggered by a brief announcement that the library won’t be longer maintained as lambdas will make it redundant….
A JUnit Rule to Run a Test in Its Own Thread
In JUnit it could be occasionally helpful to run a test in its own thread. In particular when writing integration tests that interact with encapsulated ThreadLocals or the like this could come in handy. A separate thread would implicitly ensure that the thread related reference of the threadlocal is uninitialized…
Java Code Style: The Final Decision
Isn’t it funny how the alleged most unremarkable things can lead to controversial discussions or sometimes even heated debates with hardened fronts? I witnessed on several occasions, for example, how the usage of the Java final keyword triggered quite passionate arguments. And for an outside observer this might have looked…
Clean Synchronization Using ReentrantLock and Lambdas
Recently I was reading an informative post about the differences between synchronized vs ReentrantLock by Javin Paul1. He emphasises on the advantages of the latter, but does not withhold some downsides, which are related to the cumbersome try-finally block needed for proper usage. While agreeing with his statements I brooded…
What are Mockito Extra Interfaces?
Mockito is my favored little helper if it comes down to write light weight JUnit tests. It is very useful to replace the ‘real’ dependencies of a unit under test easily by mocks if necessary. In particular when working on the borderline to framework APIs such dependencies can otherwise be…
Getting JUnit Test Names Right
Finding good names is one of the challenges of crafting software. And you need to find them all the time and for everything – classes, methods, variables, just to name a few. But what makes a name a good name? To quote Uncle Bob: ‘Three things: Readability, readability, and readability!’…
Clean SWT Listener Notifcations with SWTEventHelper
Writing tests for SWT based UIs often requires to notify widget listeners programmatically. Unfortunately, the code to create, initialize and finally to trigger the event is a bit verbose and distracts from the actual purpose of the test. After writing similar initialization routines a couple of times I came up…
Working Efficiently with JUnit in Eclipse
Recently I was dragged into a discussion1 with some test infected2 fellows about how we use JUnit within the Eclipse IDE. Surprisingly the conversation brought up some ‘tips and tricks’ not everybody was aware of. This gave me the idea to write this post doing a sum up of our…