Enigma Code Kata

Reflector.java

package nl.tdd.enigma;

import java.util.HashMap;
import java.util.Map;

public class Reflector {
	
	private final Map<String, String> reflections = new HashMap<String, String>();
	
	{
		reflections.put("a", "y");
		reflections.put("b", "r");
		reflections.put("c", "u");
		reflections.put("a", "y");
		reflections.put("b", "r");
		reflections.put("c", "u");
		reflections.put("d", "h");
		reflections.put("e", "q");
		reflections.put("f", "s");
		reflections.put("g", "l");
		reflections.put("h", "d");
		reflections.put("i", "p");
		reflections.put("j", "x");
		reflections.put("k", "n");
		reflections.put("l", "g");
		reflections.put("m", "o");
		reflections.put("n", "k");
		reflections.put("o", "m");
		reflections.put("p", "i");
		reflections.put("q", "e");
		reflections.put("r", "b");
		reflections.put("s", "f");
		reflections.put("t", "z");
		reflections.put("u", "c");
		reflections.put("v", "w");
		reflections.put("w", "v");
		reflections.put("x", "j");
		reflections.put("y", "a");
		reflections.put("z", "t");
	}
	
	public Object reflect(String character) {
		return reflections.get(character);
	}

}

ReflectorTest.java

package nl.tdd.enigma;

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class)
public class ReflectorTest {
	private final String inputCharacter;
	private final String expectedCharacter;
	
	public ReflectorTest(String inputCharacter, String expectedCharacter) {
		this.inputCharacter = inputCharacter;
		this.expectedCharacter = expectedCharacter;
	}
	
	@Test
	public void createReflector() {
		Reflector reflector = new Reflector();
		
		assertEquals(expectedCharacter, reflector.reflect(inputCharacter));
	}
	
	@Parameters
	public static Collection<Object[]> data() {
		List<Object[]> data = new ArrayList<Object[]>();
		data.add(new Object[]{"a", "y"});
		data.add(new Object[]{"b", "r"});
		data.add(new Object[]{"c", "u"});
		data.add(new Object[]{"d", "h"});
		data.add(new Object[]{"e", "q"});
		data.add(new Object[]{"f", "s"});
		data.add(new Object[]{"g", "l"});
		data.add(new Object[]{"h", "d"});
		data.add(new Object[]{"i", "p"});
		data.add(new Object[]{"j", "x"});
		data.add(new Object[]{"k", "n"});
		data.add(new Object[]{"l", "g"});
		data.add(new Object[]{"m", "o"});
		data.add(new Object[]{"n", "k"});
		data.add(new Object[]{"o", "m"});
		data.add(new Object[]{"p", "i"});
		data.add(new Object[]{"q", "e"});
		data.add(new Object[]{"r", "b"});
		data.add(new Object[]{"s", "f"});
		data.add(new Object[]{"t", "z"});
		data.add(new Object[]{"u", "c"});
		data.add(new Object[]{"v", "w"});
		data.add(new Object[]{"w", "v"});
		data.add(new Object[]{"x", "j"});
		data.add(new Object[]{"y", "a"});
		data.add(new Object[]{"z", "t"});
		return data;
	}

}

Rotor.java

package nl.tdd.enigma;

import java.util.HashMap;
import java.util.Map;

public class Rotor {
	private static final int BACKWARDS = -1;
	private static final int FORWARD = 1;
	private static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
	private final Map<String, String> encodings = new HashMap<String, String>();
	private final String setting;

	{
		encodings.put("a", "e");
		encodings.put("b", "k");
		encodings.put("c", "m");
		encodings.put("d", "f");
		encodings.put("e", "l");
		encodings.put("f", "g");
		encodings.put("g", "d");
		encodings.put("h", "q");
		encodings.put("i", "v");
		encodings.put("j", "z");
		encodings.put("k", "n");
		encodings.put("l", "t");
		encodings.put("m", "o");
		encodings.put("n", "w");
		encodings.put("o", "y");
		encodings.put("p", "h");
		encodings.put("q", "x");
		encodings.put("r", "u");
		encodings.put("s", "s");
		encodings.put("t", "p");
		encodings.put("u", "a");
		encodings.put("v", "i");
		encodings.put("w", "b");
		encodings.put("x", "r");
		encodings.put("y", "c");
		encodings.put("z", "j");
	}

	public Rotor(String string) {
		this.setting = string;
	}

	public Object encode(String character) {
		return unshift(encodings.get(shift(character)));
	}

	public Object shift(String character) {
		return rotate(character, FORWARD);
	}

	private Object rotate(String character, int sign) {
		int settingOffset = ALPHABET.indexOf(setting);
		int characterOffset = ALPHABET.indexOf(character);
		
		return String.valueOf(ALPHABET.charAt(mod(characterOffset + sign * settingOffset, ALPHABET.length())));
	}

	public Object unshift(String character) {
		return rotate(character, BACKWARDS);
	}
	
	private int mod(int number, int modulus) {
		int result = number % modulus;
		while (result < 0) {
			result += modulus;
		}
		return result;
	}
}

Rotor1SettingTest.java

package nl.tdd.enigma;

import static org.junit.Assert.*;

import org.junit.Ignore;
import org.junit.Test;

public class Rotor1SettingTest {

	@Test
	public void shiftForSettingA() {
		Rotor rotor = new Rotor("a");
		
		assertEquals("a", rotor.shift("a"));
		assertEquals("b", rotor.shift("b"));
		assertEquals("c", rotor.shift("c"));
	}

	@Test
	public void shiftForSettingB() {
		Rotor rotor = new Rotor("b");
		
		assertEquals("b", rotor.shift("a"));
		assertEquals("c", rotor.shift("b"));
		assertEquals("d", rotor.shift("c"));
	}

	@Test
	public void shiftForSettingZ() {
		Rotor rotor = new Rotor("z");
		
		assertEquals("z", rotor.shift("a"));
		assertEquals("a", rotor.shift("b"));
	}


	@Test
	public void unshiftForSettingA() {
		Rotor rotor = new Rotor("a");
		
		assertEquals("a", rotor.unshift("a"));
		assertEquals("b", rotor.unshift("b"));
	}
	
	@Test
	public void unshiftForSettingB() {
		Rotor rotor = new Rotor("b");
		
		assertEquals("z", rotor.unshift("a"));
		assertEquals("a", rotor.unshift("b"));
	}
	
	@Test
	public void unshiftForSettingZ() {
		Rotor rotor = new Rotor("z");
		
		assertEquals("b", rotor.unshift("a"));
		assertEquals("c", rotor.unshift("b"));
	}
	
}

Rotor1Test.java

package nl.tdd.enigma;

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class)
public class Rotor1Test {
	private final String inputCharacter;
	private final String expectedCharacter;
	private final String setting;
	
	public Rotor1Test(String setting, String inputCharacter, String expectedCharacter) {
		this.inputCharacter = inputCharacter;
		this.expectedCharacter = expectedCharacter;
		this.setting = setting;
	}
	
	@Test
	public void createReflector() {
		Rotor rotor = new Rotor(setting);
		
		assertEquals(expectedCharacter, rotor.encode(inputCharacter));
	}
	
	@Parameters
	public static Collection<Object[]> data() {
		List<Object[]> data = new ArrayList<Object[]>();
		
		data.add(new Object[]{"a","a", "e"});
		data.add(new Object[]{"a","b", "k"});
		data.add(new Object[]{"a","c", "m"});
		data.add(new Object[]{"a","d", "f"});
		data.add(new Object[]{"a","e", "l"});
		data.add(new Object[]{"a","f", "g"});
		data.add(new Object[]{"a","g", "d"});
		data.add(new Object[]{"a","h", "q"});
		data.add(new Object[]{"a","i", "v"});
		data.add(new Object[]{"a","j", "z"});
		data.add(new Object[]{"a","k", "n"});
		data.add(new Object[]{"a","l", "t"});
		data.add(new Object[]{"a","m", "o"});
		data.add(new Object[]{"a","n", "w"});
		data.add(new Object[]{"a","o", "y"});
		data.add(new Object[]{"a","p", "h"});
		data.add(new Object[]{"a","q", "x"});
		data.add(new Object[]{"a","r", "u"});
		data.add(new Object[]{"a","s", "s"});
		data.add(new Object[]{"a","t", "p"});
		data.add(new Object[]{"a","u", "a"});
		data.add(new Object[]{"a","v", "i"});
		data.add(new Object[]{"a","w", "b"});
		data.add(new Object[]{"a","x", "r"});
		data.add(new Object[]{"a","y", "c"});
		data.add(new Object[]{"a","z", "j"});
		

		data.add(new Object[]{"b","a", "j"});
		data.add(new Object[]{"b","b", "l"});
		data.add(new Object[]{"b","c", "e"});
		data.add(new Object[]{"b","d", "k"});
		data.add(new Object[]{"b","e", "f"});
		data.add(new Object[]{"b","f", "c"});
		data.add(new Object[]{"b","g", "p"});
		data.add(new Object[]{"b","h", "u"});
		data.add(new Object[]{"b","i", "y"});
		data.add(new Object[]{"b","j", "m"});
		data.add(new Object[]{"b","k", "s"});
		data.add(new Object[]{"b","l", "n"});
		data.add(new Object[]{"b","m", "v"});
		data.add(new Object[]{"b","n", "x"});
		data.add(new Object[]{"b","o", "g"});
		data.add(new Object[]{"b","p", "w"});
		data.add(new Object[]{"b","q", "t"});
		data.add(new Object[]{"b","r", "r"});
		data.add(new Object[]{"b","s", "o"});
		data.add(new Object[]{"b","t", "z"});
		data.add(new Object[]{"b","u", "h"});
		data.add(new Object[]{"b","v", "a"});
		data.add(new Object[]{"b","w", "q"});
		data.add(new Object[]{"b","x", "b"});
		data.add(new Object[]{"b","y", "i"});
		data.add(new Object[]{"b","z", "d"});
		
		return data;
	}

}