Clean Java Coding and Testing

René Schwietzke, Xceptance


The big picture about this lecture.

  • Clean Java programming
  • Java JUnit testing
  • Thinking like a programmer
  • Thinking like a good programmer
  • Thinking like a professional tester


What you should know before we start.

  • Slides and code are in English only
  • This is not a one-way class
  • Always ask and discuss
  • Some Java knowledge required
  • How to use an IDE is not discussed
  • If we do not make it through, no problem
  • Some stuff could be boring

Programming is like writing books. Not every book is good, not every book will make you famous, not every book will earn you enough.

But a lot of people think they can write a book... cannot be that hard, can it?


This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.

c b a

Feel Good

In 5 minutes

Our First (Test)Code

Couple of lines that show the basics.

  • Code under test and test code in one class.
  • We do not care about the syntax yet.
  • Just copy stuff and make it run.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class FeelGood
	 * Returns the max number.
	 * @param a value one
	 * @param b value two
	 * @return the maximum of a and b
	private static int max(final int a, final int b)
		if (a < b)
			return b;
			return a;

	public final void test()
		assertEquals(3, max (1, 3));

Get a Task

No learning without topic.

Our own ArrayList

Simple data structure with enough functionality but also with enough room for testing and extensions.

  • Similar to java.util.ArrayList
  • No Generics
  • No collection interfaces
  • As plain as possible in the beginning
  • Typed to String

Our Approach

Steps to approach the programming and testing topic.

  • Get the basic idea of an ArrayList
  • Think about the interface
  • Develop an implementation idea
  • Lay the foundation
  • Code it
  • Test it

Requirements and Design

Let the brain do the work first.

What is an ArrayList?

A dynamic array, growable array, resizable array, dynamic table, mutable array, or array list is a random access, variable-size list data structure that allows elements to be added or removed.

  • Dynamic size
  • Random access
  • Adding and Removing
  • List = Index

Basic Functionality

What is the minimal set of functionality that is needed?

  • Does not care about the size
  • Elements can be added but where...
    • Add the end
    • Anywhere
  • Add another ArrayList
  • Get size
  • Remove element but where...
    • Anywhere
    • All at once

Open Questions

Question you should immediately ask yourself.

  • Is null permitted?
  • What happens when something is removed with that position?
  • What happens if I want to remove something that does not exist?
  • How does the dynamic size thing work?
  • Can I insert something beyond the current size?
  • How big can it become?

Check the Environment

Align us to speed up programming.

You need

Verify all of that

  • JDK 8 or higher
  • An IDE, such as Eclipse, Netbeans, or IntelliJ
  • Java skills
  • Motivation

ArrayList Again

Programming our ideas.



  • The package
  • The class
  • The basic comments
  • The interfaces
  • Make the skeleton compile
  • Member variables
  • All JavaDoc for methods
  • Code your ideas as comments
  • Finally start to write code


Test the hell out of your code!

What is Unit Testing?

How to test code.

  • Examines the behavior of a distinct unit of work.
  • Small, compact, fast, atomic.
  • JUnit is a unit testing framework for the Java programming language.
  • JUnit has been important in the development of test-driven development


	 * Removes a string from the list by a given position. If the
	 * position does not exist, an ArrayIndexOutOfBoundsException is
	 * thrown.
	 * @param pos the position to remove
	 * @exception ArrayIndexOutOfBoundsException
	 * 				when pos is invalid such as negative or too large
	 * @return the string that has been removed from the list
	public String remove(final int pos)
		// get the result
		final String result = array[pos];

		// we have to close the hole
		for (int i = pos; i < size - 1; i++)
			array[i] = array[i + 1];

		// to be really great to GC, we have to make sure we do not hold
		// a copy of the last element at the end, this position should be
		// empty now. Make it so!
		array[size - 1] = null;

		// correct size

		// return the result
		return result;
	 * Remove last element
	public void removeLastListEntry()
		final ArrayList list = new ArrayList();

		final String r1 = list.remove(0);

		Assert.assertEquals(0, list.size());
		Assert.assertEquals("s1", r1);

	 * Error handling, remove from empty
	@Test(expected = ArrayIndexOutOfBoundsException.class)
	public void removeErrorHandling1()
		final ArrayList list = new ArrayList();

Basic Principles

No strictly enforced.

  • One class under test, one test class.
  • One test case per test method.
  • Each method will run independently.
  • Stateless.
  • Repeatability.
  • Realiability.
  • Predictability.
  • Performance.

Advanced Principles

Everything beyond this class.

  • Hamcrest as matcher.
  • Testing private methods.
  • Mocking connected classes.
  • Mocking system state, e.g. time.
  • Using JUnit as concept not methodology.
  • Spanning into integration testing.
  • Multi-threaded testing.

Mark as Test


  • Java Annotation
  • Marks a method as test method.
  • Has to be public.
  • No return value, no exception permitted.
 * Remove last element
public void removeLastListEntry()
	final ArrayList list = new ArrayList();

	final String r1 = list.remove(0);

	Assert.assertEquals(0, list.size());
	Assert.assertEquals("s1", r1);

Assert an assumption


  • Verify the state.
  • Proves the expectations.
  • Can be used often.
  • No very luxurious.
  • For later:
 * Test adding the same data again
public void addHandlingDuplicateData()
	final String A = "foo1";
	final String B = new String("foo1");

	// this is the string challenge :)
	Assert.assertNotSame(A, B);
	Assert.assertEquals(A, B);

	final ArrayList list = new ArrayList();
	Assert.assertEquals(0, list.size());

Expect something

@Test (expect = Exception.class)

  • Check that the exception is thrown.
  • Provoke it.
  • Only type not text can be verified.
 * Test error handling
public void addErrorHandling()
	final ArrayList list = new ArrayList();


@After, @Before...

  • Create data needed.
  • Once per class or once per method.
  • Make sure the cleanup is safe!
  • Do not create side-effects.
 * Setup data for the test once
public void createSomethingOnce() {}

* Setup data for the test before each method
public void createSomething() {}

* Clean up after each test
public void removeStuff() {}

* Clean up stuff once
public void removeStuffOnce() {}


Measure your testing.

  • Use tools to measure your test reach.
  • See that you touched every line.
  • See that you covered every branch.
  • Does not mean, the test is meaningful.