Schreiben weiterer Testfälle

SimpleLinkedList/.classpath

@@ -0,0 +1,11 @@
+<?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">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

SimpleLinkedList/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>SimpleLinkedList</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>

SimpleLinkedList/src/solution/AbstractSimpleList.java

@@ -0,0 +1,25 @@
+package solution;
+
+import java.util.Collection;
+
+public abstract class AbstractSimpleList<E> implements ISimpleList<E> {
+
+	@Override
+	public boolean add(Collection<E> c) {
+		boolean temp = true;
+		for (E e : c) {
+			temp = temp && add(e);
+		}
+
+		return temp;
+	}
+
+	@Override
+	public void forAll(ICommand<E> command) {
+		if (command != null) {
+			for (int i = 0; i < size(); i++) {
+				command.execute(get(i));
+			}
+		}
+	}
+}

SimpleLinkedList/src/solution/ICommand.java

@@ -0,0 +1,6 @@
+package solution;
+
+public interface ICommand<E> {
+
+	void execute(E e);
+}

SimpleLinkedList/src/solution/ISimpleList.java

@@ -0,0 +1,54 @@
+package solution;
+
+import java.util.Collection;
+import java.util.Comparator;
+
+public interface ISimpleList<E> {
+
+	// Anzahl der Elemente in der Liste
+	int size();
+
+	// fügt das Element e am Ende der Liste ein, sofern es ungleich null ist:
+	// Liefert true, falls ein Element eingefügt wurde (false sonst)
+	boolean add(E e);
+
+	// fügt alle Elemente der Collection c ein (sofern diese nicht null sind).
+	boolean add(Collection<E> c);
+
+	// prüft, ob das Objekt o in der Liste enthalten ist (o == null führt zur
+	// Rückgabe false)
+	boolean contains(Object o);
+
+	// entfernt das Objekt o aus der Liste // true: Ein Element wurde entfernt,
+	// false sonst
+	boolean remove(Object o);
+
+	// Durchläuft alle Elemente der Liste und wendet command.execute auf jedes
+	// Element an
+	void forAll(ICommand<E> command);
+
+	// fügt das Element an der Position i ein, sofern es nicht null ist und 0 <= i
+	// <= Anzahl an Elementen gilt. Rückgabe true, false sonst.
+	default void add(int i, E e) throws IndexOutOfBoundsException {
+	}
+
+	// Liefert das Element, das an Position i steht, null falls i keinen gültigen
+	// Index darstellt.
+	default E get(int i) throws IndexOutOfBoundsException {
+		return null;
+	}
+
+	// Ersetzt das i-te Element durch e, sofern es vorhanden ist (Index gültig)
+	default void set(int i, E e) throws IndexOutOfBoundsException {
+	}
+
+	// Löscht das i-te Element, sofern der Index gültig ist. Rückgabe true, false
+	// sonst.
+	default boolean remove(int i) {
+		return false;
+	}
+
+	// Sortiermethode mittels Comparator
+	default void sort(Comparator<E> comparator) {
+	}
+}

SimpleLinkedList/src/solution/Node.java

@@ -0,0 +1,36 @@
+package solution;
+
+public class Node <E>{
+	private Node<E> predecessor; // Vorgänger
+	private Node<E> successor; // Nachfolger
+	private E payload; // Nutzlast
+
+	//Konstruktor mit Parameter payload
+	public Node(E payload) {
+		this.payload = payload;
+	}
+
+	public Node<E> getPredecessor() {
+		return predecessor;
+	}
+
+	public void setPredecessor(Node<E> predecessor) {
+		this.predecessor = predecessor;
+	}
+
+	public Node<E> getSuccessor() {
+		return successor;
+	}
+
+	public void setSuccessor(Node<E> e) {
+		this.successor = e;
+	}
+
+	public E getPayload() {
+		return payload;
+	}
+
+	public void setPayload(E payload) {
+		this.payload = payload;
+	}
+}

SimpleLinkedList/src/solution/SimpleLinkedList.java

@@ -0,0 +1,152 @@
+package solution;
+
+public class SimpleLinkedList<E> extends AbstractSimpleList<E> {
+
+	Node<E> firstNode;
+	int size;
+
+	public SimpleLinkedList() {
+		firstNode = null;
+		size = 0;
+	}
+
+	@Override
+	public int size() {
+		return size;
+	}
+
+	@Override
+	public boolean add(E e) {
+		if (e == null) {
+			return false;
+		} else if (firstNode == null) {
+			firstNode = new Node<E>(e);
+		} else {
+			Node<E> currentNode = firstNode;
+			while (currentNode != null) {
+				if (currentNode.getSuccessor() == null) {
+					break;
+				}
+				currentNode = currentNode.getSuccessor();
+			}
+			Node<E> newNode = new Node<E>(e);
+			currentNode.setSuccessor(newNode);
+			newNode.setPredecessor(currentNode);
+		}
+
+		size++;
+		return true;
+	}
+
+	@Override
+	public boolean remove(Object o) {
+		if (o == null) {
+			return false;
+		}
+		Node<E> currentNode = firstNode;
+		while (currentNode != null) {
+			if (o.equals(currentNode.getPayload())) {
+				currentNode.setPayload(null);
+				size--;
+				return true;
+			}
+
+			if (currentNode.getSuccessor() == null) {
+				break;
+			}
+			currentNode = currentNode.getSuccessor();
+		}
+		return false;
+	}
+
+	@Override
+	public boolean contains(Object o) {
+		if (o == null) {
+			return false;
+		}
+		Node<E> currentNode = firstNode;
+		while (currentNode != null) {
+			if (o.equals(currentNode.getPayload())) {
+				return true;
+			}
+
+			currentNode = currentNode.getSuccessor();
+		}
+
+		return false;
+	}
+
+	@Override
+	public void forAll(ICommand<E> command) {
+		if (command != null) {
+			Node<E> currentNode = firstNode;
+			while (currentNode != null) {
+				command.execute(currentNode.getPayload());
+				currentNode = currentNode.getSuccessor();
+			}
+		}
+	}
+
+	private Node<E> getIndex(int i) {
+
+		if (i < 0 || size <= i) {
+			return null;
+		}
+		Node<E> currentNode = firstNode;
+		int currentIndex = 0;
+		while (currentNode != null) {
+			if (currentIndex >= i) {
+
+				if (currentNode.getPayload() != null) {
+					return currentNode;
+				}
+			}
+			currentNode = currentNode.getSuccessor();
+			currentIndex++;
+		}
+		return null;
+	}
+
+	public E get(int i) throws IndexOutOfBoundsException {
+
+		return getIndex(i).getPayload();
+	}
+
+	public void set(int i, E e) throws IndexOutOfBoundsException {
+
+		getIndex(i).setPayload(e);
+	}
+
+	public boolean remove(int i) throws IndexOutOfBoundsException {
+
+		if (getIndex(i) != null) {
+			getIndex(i).setPayload(null);
+			size--;
+			return true;
+		}
+		return false;
+	}
+
+	public void add(int i, E e) throws IndexOutOfBoundsException {
+		if (size == 0) {
+			if (i != 0) {
+				throw new IndexOutOfBoundsException("Index " + i + " is out of bounds!");
+			}
+			set(0, e);
+
+		} else if (i == size) {
+			add(e);
+
+		} else if (size > 0 && i < size) {
+			Node<E> newNode = new Node<>(e);// node3
+
+			Node<E> tempNode = getIndex(i); // node2
+			Node<E> preTempNode = getIndex(i).getPredecessor(); // node1
+
+			preTempNode.setSuccessor(newNode);
+			newNode.setPredecessor(preTempNode);
+			newNode.setSuccessor(tempNode);
+			tempNode.setPredecessor(newNode);
+		}
+	}
+}

SimpleLinkedList/src/solution/SimpleLinkedListTest.java

@@ -0,0 +1,9 @@
+package solution;
+
+public class SimpleLinkedListTest extends SimpleListTest90{
+	
+	@Override
+	protected ISimpleList<String> getInstance1() {
+		return new SimpleLinkedList<>();
+	}
+}

SimpleLinkedList/src/solution/SimpleListTest90.java

@@ -0,0 +1,137 @@
+package solution;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public abstract class SimpleListTest90 {
+
+	ISimpleList<String> list;
+
+	protected String nodeNull = null;
+	protected String node0 = "0";
+	protected String node1 = "1";
+	protected String node2 = "2";
+	protected String node3 = "3";
+	protected String node4 = "4";
+
+	protected abstract ISimpleList<String> getInstance1();
+
+	protected void add2() {
+		list.add(node1);
+		list.add(node2);
+	}
+
+	@BeforeAll
+	static void setUpBeforeClass() throws Exception {
+	}
+
+	@BeforeEach
+	void setUp() throws Exception {
+		list = getInstance1();
+	}
+
+	@Test
+	public void testAdd1() {
+		boolean actual = list.add(node1);
+		assertEquals(true, actual);
+	}
+
+	@Test
+	public void testAdd2() {
+		add2();
+		list.remove(node2);
+		list.add(node3);
+		list.add(node4);
+		String actual = list.get(2);
+		assertEquals(node3, actual);
+	}
+
+	@Test
+	public void testRemoveObject() {
+		list.add(node1);
+		list.add(node2);
+		list.add(node3);
+
+		boolean actual = list.remove(node2);
+		assertEquals(true, actual);
+	}
+
+	@Test
+	public void testRemoveSize() {
+		add2();
+		list.remove(1);
+		int actual = list.size();
+		assertEquals(1, actual);
+	}
+
+	@Test
+	public void testContainsTrue() {
+		add2();
+		boolean actual = list.contains(node1);
+		assertEquals(true, actual);
+	}
+
+	@Test
+	public void testContainsFalse() {
+		add2();
+		boolean actual = list.contains(node3);
+		assertEquals(false, actual);
+	}
+
+	@Test
+	public void testForAll1() {
+		list.forAll(null);
+		assertEquals(true, true);
+	}
+
+	@Test
+	public void getNodeIndex() {
+		add2();
+		String actual = list.get(1);
+		assertEquals(node2, actual);
+	}
+
+	@Test
+	public void setNodeIndex() {
+		add2();
+		list.set(1, node3);
+		String actual = list.get(1);
+		assertEquals(node3, actual);
+	}
+
+	@Test
+	public void testRemoveIndex() {
+		add2();
+		list.add(node3);
+		boolean actual = list.remove(1);
+		assertEquals(true, actual);
+	}
+
+	@Test
+	public void testAddIndexException() {
+		try {
+			list.add(-1, node1);
+			list.get(0);
+		} catch (Exception e) {
+			assertEquals(true, e instanceof IndexOutOfBoundsException);
+		}
+	}
+
+	@Test
+	public void testAddIndexSameSize() {
+		add2();
+		list.add(2, node4);
+		String actual = list.get(2);
+		assertEquals(node4, actual);
+	}
+
+	@Test
+	public void testAddIndexNewNode() {
+		add2();
+		list.add(1, node3);
+		String actual = list.get(1);
+		assertEquals(node3, actual);
+	}
+}