JUnit testCases

src/main/java/Model/DoublyConnectedEdgeList.java

@@ -1,5 +1,6 @@
 package Model;
 
+
 import java.util.LinkedList;
 
 /**
@@ -50,8 +51,7 @@ public class DoublyConnectedEdgeList {
 
     public Face createFace(Edge outerComponent, Edge innerComponent, String id) {
 
-        Face face = new Face();
-        face.setOuterComponent(outerComponent);
+        Face face = new Face(outerComponent, null);
         face.setID(id);
         Edge tempEdge;
 
@@ -65,7 +65,7 @@ public class DoublyConnectedEdgeList {
 
         if (innerComponent != null) {
             LinkedList<Edge> componentlist;
-            componentlist =  face.getInnerComponents();
+            componentlist = face.getInnerComponents();
             componentlist.add(innerComponent);
             tempEdge = innerComponent;
             do {
@@ -74,12 +74,56 @@ public class DoublyConnectedEdgeList {
             } while (!tempEdge.equals(innerComponent));
         }
 
-        return null;
+        return face;
     }
 
     public void createConnection(Edge edge, Edge succ) {
         edge.setNext(succ);
         succ.setPrev(edge);
+
+        edge.getTwin().setPrev(succ.getTwin());
+        succ.getTwin().setNext(edge.getTwin());
+    }
+
+    public LinkedList<Edge> getEdgesOfInnerComponents(Face face) {
+
+        LinkedList<Edge> list = new LinkedList();
+        LinkedList<Edge> innerComponents = face.getInnerComponents();
+        Edge it;
+        for (Edge e : innerComponents) {
+            it = e;
+            do {
+                list.add(it);
+                //System.out.println("Current Edge: "+it.getID()+"\tNext Edge: "+it.getNext().getID());
+                it = it.getNext();
+            } while (it != e);
+        }
+
+        return list;
+    }
+
+    public LinkedList<Edge> getEdgesOfOuterComponents(Face face) {
+
+        LinkedList<Edge> list = new LinkedList();
+        Edge it = face.getOuterComponent();
+        do {
+            list.add(it);
+            //System.out.println("Current Edge: "+it.getID()+"\tNext Edge: "+it.getNext().getID());
+            it = it.getNext();
+        } while (it != face.getOuterComponent());
+
+        return list;
+    }
+
+
+    public LinkedList<Edge> getConnectedEdges(Node node) {
+        Edge edge = node.getIncidentEdge();
+        LinkedList list = new LinkedList();
+        do {
+            list.add(edge);
+            edge = edge.getNext();
+        } while (node != edge.getOrigin());
+        return list;
     }
 
     public LinkedList<Node> getNodes() {

src/main/java/Model/Face.java

@@ -16,13 +16,19 @@ public class Face {
     private String id;
 
     public Face() {
-        new Face(null, null);
+        this.outerComponent = null;
         this.innerComponents = new LinkedList<>();
     }
 
     public Face(Edge outerComponent, LinkedList<Edge> innerComponents) {
         this.outerComponent = outerComponent;
-        this.innerComponents = innerComponents;
+        if (innerComponents != null) {
+            this.innerComponents = innerComponents;
+        } else {
+            this.innerComponents = new LinkedList<>();
+
+        }
+
     }
 
     public LinkedList<Edge> getInnerComponents() {

src/test/java/Model/DoublyConnectedEdgeListTest.java

@@ -3,7 +3,10 @@ package Model;
 import org.junit.Before;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
+import java.util.LinkedList;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
 
 /**
  * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@@ -15,21 +18,79 @@ import static org.junit.Assert.*;
 public class DoublyConnectedEdgeListTest {
 
     private static DoublyConnectedEdgeList dcel;
-    private static Node v1, v2, v3 ,v4, v5;
-    private static Edge e1, e2, e3, e4, e5, e6;
-    private static Face f1, f2, f3;
+    private static Node v1, v2, v3, v4, v5;
+    private static Edge e1, e2, e3, e4, e5;
+    private static Face f1, f2;
 
     @Before
     public void setUp() throws Exception {
         dcel = new DoublyConnectedEdgeList();
 
+        //initialisiere die TestKnoten im Graphen
+        v1 = dcel.createNode(new Coordinates(2.5, 7.5), "v1");
+        v2 = dcel.createNode(new Coordinates(2.5, 4.0), "v2");
+        v3 = dcel.createNode(new Coordinates(6.5, 3.5), "v3");
+        v4 = dcel.createNode(new Coordinates(8.5, 6.5), "v4");
+        v5 = dcel.createNode(new Coordinates(6.0, 8.0), "v5");
+
+        //initialisere Kanten im Graph
+        e1 = dcel.createEdge(v1, v5, "e1");
+        e2 = dcel.createEdge(v5, v4, "e2");
+        e3 = dcel.createEdge(v4, v3, "e3");
+        e4 = dcel.createEdge(v3, v2, "e4");
+        e5 = dcel.createEdge(v2, v1, "e5");
+
+        dcel.createConnection(e1, e2);
+        dcel.createConnection(e2, e3);
+        dcel.createConnection(e3, e4);
+        dcel.createConnection(e4, e5);
+        dcel.createConnection(e5, e1);
+
+        //intialisiere die Flaechen
+        f1 = dcel.createFace(null, e1, "f1");
+        f2 = dcel.createFace(e1.getTwin(), null, "f2");
     }
 
 
     @Test
-    public void testCases(){
+    public void testInnerComponentsAccess() {
+        System.out.println("Test: testInnerComponentAccess();");
+        Edge[] expected = {e1, e2, e3, e4, e5};
+        LinkedList<Edge> list = dcel.getEdgesOfInnerComponents(f1);
 
+        assertArrayEquals(expected, list.toArray());
+    }
+
+    @Test
+    public void testOuterComponentsAccess() {
+        System.out.println("Test: testOuterComponentAccess();");
+        String[] expected = {"#e1", "#e5", "#e4", "#e3", "#e2"};
+        LinkedList<Edge> list = dcel.getEdgesOfOuterComponents(f2);
+
+        for (int i = 0; i < list.size(); i++) {
+            assertEquals(expected[i], list.get(i).getID());
+        }
 
     }
 
+
+    @Test
+    public void testNodeEdgeAccess() {
+        System.out.println("Test: testNodeEdgeAccess();");
+
+        assertEquals(5, dcel.getConnectedEdges(v4).size());
+    }
+
+    @Test
+    public void testDCELAccess() {
+        System.out.println("Test: testDCELAccess();");
+
+        assertEquals(e1, e1.getTwin().getTwin());
+        assertEquals(e1, e1.getPrev().getNext());
+        assertEquals(e2.getID(), e1.getTwin().getPrev().getTwin().getID());
+        assertEquals(e1, e1.getNext().getNext().getNext().getNext().getNext());
+        assertEquals(e1.getTwin(), e1.getTwin().getNext().getNext().getNext().getNext().getNext());
+    }
+
+
 }