Testat komplettiert

SimpleArrayMap/.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

SimpleArrayMap/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>SimpleArrayMap</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

SimpleArrayMap/src/solution/SimpleArrayMap.java

@@ -0,0 +1,118 @@
+package solution;
+
+import java.util.function.Consumer;
+
+import testat.ISimpleMap;
+
+public class SimpleArrayMap<K, V> implements ISimpleMap<K, V> {
+
+	private K[] keys;
+	private V[] values;
+	private int size;
+
+	public SimpleArrayMap(int arraySize) {
+
+		this.keys = (K[]) new Object[arraySize];
+		this.values = (V[]) new Object[arraySize];
+		this.size = 0;
+	}
+
+	@Override
+	public V put(K k, V v) {
+
+		V tempValue;
+
+		if (k == null || v == null) {
+			return null;
+		}
+
+		for (int i = 0; i < values.length; i++) {
+			if (k.equals(keys[i])) {
+				tempValue = values[i];
+				values[i] = v;
+				return tempValue;
+			}
+		}
+
+		for (int i = 0; i < values.length; i++) {
+			if (keys[i] == null) {
+				keys[i] = k;
+				values[i] = v;
+				size++;
+				break;
+			}
+		}
+
+		return null;
+	}
+
+	@Override
+	public V get(K k) {
+
+		if (k == null) {
+			return null;
+		}
+
+		for (int i = 0; i < values.length; i++) {
+			if (k.equals(keys[i])) {
+				return values[i];
+			}
+		}
+
+		return null;
+	}
+
+	@Override
+	public V remove(K k) {
+
+		V tempValue;
+
+		if (k == null) {
+			return null;
+		}
+
+		for (int i = 0; i < values.length; i++) {
+			if (k.equals(keys[i])) {
+				tempValue = values[i];
+				keys[i] = null;
+				values[i] = null;
+				size--;
+				return tempValue;
+			}
+		}
+
+		return null;
+	}
+
+	@Override
+	public boolean contains(V v) {
+
+		if (v == null) {
+			return false;
+		}
+
+		for (int i = 0; i < values.length; i++) {
+			if (v.equals(values[i])) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	@Override
+	public void forEach(Consumer<? super V> consumer) {
+
+		for (int i = 0; i < values.length; i++) {
+			if (keys[i] != null) {
+				consumer.accept(values[i]);
+			}
+		}
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+	
+}

SimpleArrayMap/src/solution/SimpleMapTest.java

@@ -0,0 +1,13 @@
+package solution;
+
+import testat.ASimpleMapTest;
+import testat.ISimpleMap;
+
+public class SimpleMapTest extends ASimpleMapTest{
+
+	@Override
+	protected ISimpleMap<String, String> getInstance() {
+		
+		return new SimpleArrayMap<>(5);
+	}
+}

SimpleArrayMap/src/testat/ASimpleMapTest.java

@@ -0,0 +1,242 @@
+package testat;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.function.Consumer;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public abstract class ASimpleMapTest {
+
+	ISimpleMap<String, String> map;
+
+	protected abstract ISimpleMap<String, String> getInstance();
+
+	private int counter = 0;
+	private String result;
+
+	Consumer<String> action = s -> {
+		counter++;
+		result = result + s;
+	};
+
+	@BeforeAll
+	static void setUpBeforeClass() throws Exception {
+	}
+
+	@BeforeEach
+	void setUp() throws Exception {
+		map = getInstance();
+	}
+
+	@Test
+	void testadd1() {
+		String actual = map.put("1", "Hallo");
+		assertEquals(null, actual);
+	}
+
+	@Test
+	void testadd2a() {
+		String actual = map.put(null, "xxx");
+		assertEquals(null, actual);
+	}
+
+	@Test
+	void testadd2b() {
+		String actual = map.put("1", null);
+		assertEquals(null, actual);
+	}
+
+	@Test
+	void testadd3() {
+		add3();
+		String actual = map.put("1", "Hallo");
+		assertEquals("Eins", actual);
+	}
+
+	@Test
+	void testadd4() {
+		add3();
+		map.put("4", "Vier");
+		map.put("5", "Fünf");
+		map.remove("3");
+		map.put("6", "Sechs");
+
+		String actual = map.get("1");
+		assertEquals("Eins", actual);
+		actual = map.get("2");
+		assertEquals("Zwei", actual);
+		actual = map.get("4");
+		assertEquals("Vier", actual);
+		actual = map.get("5");
+		assertEquals("Fünf", actual);
+		actual = map.get("6");
+		assertEquals("Sechs", actual);
+	}
+
+	@Test
+	void testget1() {
+		String actual = map.get(null);
+		assertEquals(null, actual);
+	}
+
+	@Test
+	void testget2() {
+		String actual = map.get("1");
+		assertEquals(null, actual);
+	}
+
+	@Test
+	void testget3() {
+		add3();
+		String actual = map.get("1");
+		assertEquals("Eins", actual);
+		actual = map.get("2");
+		assertEquals("Zwei", actual);
+		actual = map.get("3");
+		assertEquals("Drei", actual);
+	}
+
+	@Test
+	void testremove1() {
+		String actual = map.remove(null);
+		assertEquals(null, actual);
+	}
+
+	@Test
+	void testremove2() {
+		String actual = map.remove("1");
+		assertEquals(null, actual);
+	}
+
+	@Test
+	void testremove3() {
+		add3();
+		String actual = map.remove(null);
+		assertEquals(null, actual);
+	}
+
+	@Test
+	void testremove4() {
+		add3();
+		String actual = map.remove("9");
+		assertEquals(null, actual);
+	}
+
+	@Test
+	void testremove5() {
+		add3();
+		String actual = map.remove("1");
+		assertEquals("Eins", actual);
+		actual = map.get("1");
+		assertEquals(null, actual);
+		actual = map.remove("2");
+		assertEquals("Zwei", actual);
+		actual = map.get("2");
+		assertEquals(null, actual);
+		actual = map.remove("3");
+		assertEquals("Drei", actual);
+		actual = map.get("3");
+		assertEquals(null, actual);
+	}
+
+	@Test
+	void testcontains1() {
+		Boolean actual = map.contains(null);
+		assertEquals(false, actual);
+	}
+
+	@Test
+	void testcontains2() {
+		Boolean actual = map.contains("1");
+		assertEquals(false, actual);
+	}
+
+	@Test
+	void testcontains3() {
+		add3();
+		Boolean actual = map.contains("Eins");
+		assertEquals(true, actual);
+		actual = map.contains("Zwei");
+		assertEquals(true, actual);
+		actual = map.contains("Drei");
+		assertEquals(true, actual);
+		actual = map.contains("xxx");
+		assertEquals(false, actual);
+	}
+
+	@Test
+	void testsize1() {
+		int actual = map.size();
+		assertEquals(0, actual);
+	}
+
+	@Test
+	void testsize2() {
+		add3();
+		int actual = map.size();
+		assertEquals(3, actual);
+	}
+
+	@Test
+	void testAddSize1() {
+		add3();
+		add3();
+		int actual = map.size();
+		assertEquals(3, actual);
+	}
+
+	@Test
+	void testRemoveSize1() {
+		add3();
+		map.remove("2");
+		int actual = map.size();
+		assertEquals(2, actual);
+	}
+
+	@Test
+	void testRemoveContains1() {
+		add3();
+		map.remove("2");
+		Boolean actual = map.contains("Eins");
+		assertEquals(true, actual);
+		actual = map.contains("Zwei");
+		assertEquals(false, actual);
+		actual = map.contains("Drei");
+		assertEquals(true, actual);
+		actual = map.contains("xxx");
+		assertEquals(false, actual);
+	}
+
+	@Test
+	void testForAll1() {
+		map.forEach(null);
+		assertEquals(true, true);
+	}
+
+	@Test
+	void testForAll2() {
+		map.forEach(action);
+		assertEquals(true, true);
+	}
+
+	@Test
+	void testForAll3() {
+		add3();
+		counter = 0;
+		result = new String("");
+		map.forEach(action);
+		assertEquals(3, counter);
+		assertEquals(true, result.contains("Eins"));
+		assertEquals(true, result.contains("Zwei"));
+		assertEquals(true, result.contains("Drei"));
+	}
+
+	protected void add3() {
+		map.put("1", "Eins");
+		map.put("2", "Zwei");
+		map.put("3", "Drei");
+	}
+}

SimpleArrayMap/src/testat/ISimpleMap.java

@@ -0,0 +1,34 @@
+package testat;
+
+import java.util.function.Consumer;
+
+public interface ISimpleMap<K, V> {
+
+	// speichert zu dem Schlüssel k den Wert v, sofern beide nicht null sind
+	// (ist mind. einer null, wird null zurück gegeben) .
+	// Falls zu k bereits ein Wert w vorhanden ist, wird dieser durch v
+	// ersetzt. Der alte Wert w wird zurückgegeben.
+	// Falls zu k noch kein Wert gespeichert war, wird zu k der Wert v
+	// aufgenommen und null zurückgegeben
+	V put(K k, V v);
+	
+	// Liefert den zum Schlüssel k gespeicherten Wert. Liefert null,
+	// falls k == null oder falls zu k kein Wert gespeichert ist
+	V get(K k);
+	
+	// Entfernt den zum Schlüssel k gespeicherten Wert v und
+	// liefert v zurück. Liefert null, falls k == null oder falls
+	// zu k kein Wert gespeichert war
+	V remove(K k);
+	
+	// Liefert true, falls der Wert v in der Map (zu irgendeinem Schlüssel)
+	// gespeichert ist
+	boolean contains(V v);
+	
+	// wendet die Methode consumer.accept(v) auf alle in der
+	// Map gespeicherten Werte an
+	void forEach(Consumer<? super V> consumer);
+	
+	// Anzahl an in der Map gespeicherten Werte
+	int size();
+}