how to use Mockito

TDD-Mocking/pom.xml

@@ -0,0 +1,33 @@
+
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+
+	<groupId>de.edu.hsfulda.ciip.tdd</groupId>
+	<artifactId>ConwaysGameOfLife</artifactId>
+	<version>1.0-SNAPSHOT</version>
+	<packaging>jar</packaging>
+
+	<properties>
+		<maven.compiler.source>1.8</maven.compiler.source>
+		<maven.compiler.target>1.8</maven.compiler.target>
+	</properties>
+	<build>
+		<sourceDirectory>src/main/java</sourceDirectory>
+	</build>
+	<dependencies>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.12</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+		    <groupId>org.mockito</groupId>
+		    <artifactId>mockito-all</artifactId>
+		    <version>1.10.19</version>
+		    <scope>test</scope>
+		</dependency>
+	</dependencies>
+</project>

TDD-Mocking/src/main/java/de/edu/hsfulda/ciip/tdd/GameCell.java

@@ -0,0 +1,37 @@
+package de.edu.hsfulda.ciip.tdd;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+
+public class GameCell {
+
+	private State state;
+	private State nextState;
+	private final List<GameCell> neighbors = new ArrayList<>();
+
+	public GameCell(State state) {
+		this.state = state;
+	}
+
+	public State getState() {
+		return state;
+	}
+
+	public void calculateNextGen() {
+		List<State> neigborStates = neighbors.stream().map(GameCell::getState).collect(Collectors.toList());
+		nextState = state.nextBy(neigborStates);
+	}
+
+	public void activateNextGeneration() {
+		state = nextState;
+	}
+
+	public void addNeigbour(GameCell gameCell) {
+		neighbors.add(gameCell);
+	}
+
+}

TDD-Mocking/src/main/java/de/edu/hsfulda/ciip/tdd/State.java

@@ -0,0 +1,9 @@
+package de.edu.hsfulda.ciip.tdd;
+
+import java.util.List;
+
+public interface State {
+
+	State nextBy(List<State> neigborStates);
+
+}

TDD-Mocking/src/main/java/de/edu/hsfulda/ciip/tdd/StateAlive.java

@@ -0,0 +1,21 @@
+package de.edu.hsfulda.ciip.tdd;
+
+import java.util.List;
+
+public class StateAlive implements State {
+
+	@Override
+	public State nextBy(List<State> neigborStates) {
+		long alifeNeigbors = countAliveNeighbors(neigborStates);
+		if(alifeNeigbors >1) {
+			return this;
+		} else {
+			return new StateDead();
+		}
+	}
+	
+	private long countAliveNeighbors(List<State> neigborStates) {
+		return neigborStates.stream().filter(state -> this == state).count();
+	}
+	
+}

TDD-Mocking/src/main/java/de/edu/hsfulda/ciip/tdd/StateDead.java

@@ -0,0 +1,26 @@
+package de.edu.hsfulda.ciip.tdd;
+
+import java.util.List;
+
+public class StateDead implements State {
+
+	private static final int REQUIRED_FOR_CHANGE = 3;
+
+	@Override
+	public State nextBy(List<State> neigborStates) {
+		long alifeNeigbors = countAliveNeighbors(neigborStates);
+		return findNextStateBy(alifeNeigbors);
+	}
+
+	private State findNextStateBy(long alifeNeigbors) {
+		if (REQUIRED_FOR_CHANGE == alifeNeigbors)
+			return this;
+		else
+			return this;
+	}
+
+	private long countAliveNeighbors(List<State> neigborStates) {
+		return neigborStates.stream().filter(state -> this != state).count();
+	}
+
+}

TDD-Mocking/src/test/java/de/edu/hsfulda/ciip/tdd/GameCellTest.java

@@ -0,0 +1,77 @@
+package de.edu.hsfulda.ciip.tdd;
+
+import static org.mockito.Mockito.any;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+public class GameCellTest {
+
+	@Rule
+	public MockitoRule mockitoRule = MockitoJUnit.rule();
+
+	@Mock
+	State initialState;
+
+	@Mock
+	State changedState;
+
+	@Test
+	public void reportsInitiallyProvidesState() {
+		GameCell cell = new GameCell(initialState);
+
+		State result = cell.getState();
+
+		assertThat("initial state returned", result, equalTo(initialState));
+	}
+
+	@Test
+	public void changesStateWhenRequested() {
+		GameCell cell = new GameCell(initialState);
+		when(initialState.nextBy(any(List.class))).thenReturn(changedState);
+
+		cell.calculateNextGen();
+		verify(initialState).nextBy(any(List.class));
+
+		cell.activateNextGeneration();
+		State result = cell.getState();
+		assertThat("initial state returned", result, equalTo(changedState));
+	}
+
+	@SuppressWarnings("unchecked")
+	@Test
+
+	public void passesNeigbourStatesForStateChangeCalculation() {
+		GameCell cell = new GameCell(initialState);
+		List<State> neighborStates = Arrays.asList(mock(State.class), mock(State.class), mock(State.class),
+				mock(State.class));
+		for (State state : neighborStates) {
+			cell.addNeigbour(new GameCell(state));
+		}
+
+		cell.calculateNextGen();
+		ArgumentCaptor<List> passedStates = ArgumentCaptor.forClass(List.class);
+		verify(initialState).nextBy(passedStates.capture());
+		
+		List<State> statesPassed = passedStates.getValue();
+		for (State state : neighborStates) {
+			assertThat(statesPassed, CoreMatchers.hasItem(state));
+		}
+	}
+
+}

TDD-Mocking/src/test/java/de/edu/hsfulda/ciip/tdd/StatusAliveTest.java

@@ -0,0 +1,53 @@
+package de.edu.hsfulda.ciip.tdd;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.not;
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+public class StatusAliveTest {
+
+	@Rule
+	public MockitoRule mockitoRule = MockitoJUnit.rule();
+
+	@Mock
+	State dead;
+
+	@Test
+	public void changeToDeadIfOneAliveNeighbor() {
+		// arrange
+		State stateAlive = new StateAlive();
+		List<State> neigborStates = Arrays.asList(stateAlive,dead,dead,dead,dead,dead,dead,dead);
+
+		// act
+		State result = stateAlive.nextBy(neigborStates);
+
+		// assert
+		assertNotNull("",result);
+		assertThat("changed to dead", result.getClass(), not(equalTo(stateAlive.getClass())));
+	}
+	
+	@Test
+	public void KeepSateAliveWithTwoLivingNeighbors() {
+		// arrange
+		State stateAlive = new StateAlive();
+		List<State> neigborStates = Arrays.asList(stateAlive,stateAlive,dead,dead,dead,dead,dead,dead);
+		
+		// act
+		State result = stateAlive.nextBy(neigborStates);
+
+		// assert
+		assertNotNull("",result);
+		assertThat("Still alive", result.getClass(), (equalTo(stateAlive.getClass())));
+	}
+	
+	
+}

TDD-Mocking/src/test/java/de/edu/hsfulda/ciip/tdd/StatusDeadTest.java

@@ -0,0 +1,61 @@
+package de.edu.hsfulda.ciip.tdd;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.mock;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class StatusDeadTest {
+	private static State[] states = { mock(State.class, "alife"), new StateDead() };
+	private static final int alife = 0;
+	private static final int dead = 1;
+
+	@Parameters(name = "{index}: condition: {0} expected: {2}")
+	public static Collection<Object[]> data() {
+
+		return Arrays
+				.asList(new Object[][] { { "all dead", 0, dead }, { "one alife", 1, dead }, { "two alife", 2, dead },
+						{ "four alife", 4, dead }, { "five alife", 5, dead }, { "three alife", 3, alife } });
+	}
+
+	@Parameter // first data value (0) is default
+	public /* NOT private */ String assertMessage;
+
+	@Parameter(1)
+	public /* NOT private */ int aliveneigborCount;
+
+	@Parameter(2)
+	public /* NOT private */ int expected;
+
+	@Test
+	public void calculateNextState() {
+		// arrange
+		List<State> neigborStates = new ArrayList<>();
+		for (int i = 0; i < aliveneigborCount; i++)
+			neigborStates.add(states[alife]);
+		while (neigborStates.size() < 8) {
+			neigborStates.add(states[dead]);
+		}
+		Collections.shuffle(neigborStates);
+
+		// act
+		State stateDead = states[dead];
+		State result = stateDead.nextBy(neigborStates);
+
+		// assert
+		assertThat(assertMessage, result, equalTo(states[expected]));
+	}
+
+}

TDD-pure-function/src/main/java/de/edu/hsfulda/ciip/tdd/BownlingCalculator.java

@@ -0,0 +1,51 @@
+package de.edu.hsfulda.ciip.tdd;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class BownlingCalculator {
+	private static final int SINGLE_DIGIT = 0;
+	private static final int STRIKE_SECOND_NEXT_THROW = 2;
+	private static final int STRIKE_NEXT_THROW = 1;
+	private static final String STRIKE = "X (\\d)(\\d)";
+	private static final int PINS_IN_FRAME = 10;
+	private static final String SPARE = "(\\d)/ (\\d)";
+	private static final String INCOMPLETE_FRAME = "\\d";
+
+	@FunctionalInterface
+	private interface FrameCalculator {
+		int evaluate(Matcher frameStructure);
+	}
+
+	private static final int SPARE_FRAME_FOLLOWING_THROW = 2;
+	private static final int SPARE_FRAME_FIRST_THROW = 1;
+
+	public int evaluate(String listOfThrows) {
+		int sum = 0;
+		sum += evaluateFrames(listOfThrows, INCOMPLETE_FRAME,
+				singleDigit -> convertMatchToInt(singleDigit, SINGLE_DIGIT));
+		sum += evaluateFrames(listOfThrows, SPARE, // trailing line comments for formatting
+				spare -> PINS_IN_FRAME //
+						- convertMatchToInt(spare, SPARE_FRAME_FIRST_THROW)
+						+ convertMatchToInt(spare, SPARE_FRAME_FOLLOWING_THROW));
+		sum += evaluateFrames(listOfThrows, STRIKE, //
+				strike -> PINS_IN_FRAME //
+						+ convertMatchToInt(strike, STRIKE_NEXT_THROW) //
+						+ convertMatchToInt(strike, STRIKE_SECOND_NEXT_THROW));
+		return sum;
+	}
+
+	private int convertMatchToInt(Matcher strike, int groupIndex) {
+		return Integer.parseInt(strike.group(groupIndex));
+	}
+
+	private int evaluateFrames(String listOfThrows, String frameStructurePattern, FrameCalculator frameCalculator) {
+		Matcher singleDigit = Pattern.compile(frameStructurePattern).matcher(listOfThrows);
+		int frameValue = 0;
+		while (singleDigit.find()) {
+			frameValue += frameCalculator.evaluate(singleDigit);
+		}
+		return frameValue;
+	}
+
+}

TDD-pure-function/src/test/java/de/edu/hsfulda/ciip/tdd/BowlingCalculatorTest.java

@@ -0,0 +1,61 @@
+package de.edu.hsfulda.ciip.tdd;
+
+import static org.junit.Assert.*;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Test;
+
+public class BowlingCalculatorTest {
+
+	private final BownlingCalculator bownlingCalculator = new BownlingCalculator();
+
+	@Test
+	public void returnsZeroWhenNoPinIsHit() {
+		// arrange
+		String listOfThrows = "-- -- -- -- -- -- -- -- -- --";
+		int expectedValue = 0;
+
+		// act
+		int calculatedResult = bownlingCalculator.evaluate(listOfThrows);
+
+		// assert
+		assertThat("calculated value", calculatedResult, CoreMatchers.equalTo(expectedValue));
+	}
+
+	@Test
+	public void createsSumOfAllIncompleteFrames() {
+		// arrange
+		String listOfThrows = "11 22 33 44 54 63 72 81 -9 --";
+		int expectedValue = 65;
+
+		// act
+		int calculatedResult = bownlingCalculator.evaluate(listOfThrows);
+
+		// assert
+		assertThat("calculated value", calculatedResult, CoreMatchers.equalTo(expectedValue));
+	}
+
+	@Test
+	public void throwAfterSpareCountsTwice() {
+		// arrange
+		String listOfThrows = "1/ 11 -- -- -- -- -- -- -- --";
+		int expectedValue = 13;
+		// act
+		int calculatedResult = bownlingCalculator.evaluate(listOfThrows);
+
+		// assert
+		assertThat("calculated value", calculatedResult, CoreMatchers.equalTo(expectedValue));
+	}
+	
+	@Test
+	public void twoThrowsAfterStrikeCountTwice() {
+		// arrange
+		String listOfThrows = "X 12 11 -- -- -- -- -- -- --";
+		int expectedValue = 18;
+		// act
+		int calculatedResult = bownlingCalculator.evaluate(listOfThrows);
+
+		// assert
+		assertThat("calculated value", calculatedResult, CoreMatchers.equalTo(expectedValue));
+	}
+}