java2-home6.java

java2-home6-test.java

import static org.junit.Assert.*;

import org.junit.*;



public class AnswerTest {

	Answer.Graph g;
	Answer.Vertex v1;
	Answer.Vertex v2;
	Answer.Vertex v3;
	Answer.Vertex v4;
	
	@Before
	public void setUp(){
		g 	= new Answer.Graph("G");
		v1 	= new Answer.Vertex("V1", g);
		v2 	= new Answer.Vertex("V2", g);
		v3 	= new Answer.Vertex("V3", g);
		v4 	= new Answer.Vertex("V4", g);
		v1.addEdge(v2);
		v2.addEdge(v3);
		v2.addEdge(v4);
		v4.addEdge(v4);
	}
	
	@Test
	public void testVertexToString() {
		assertTrue("It returns Vertex id", v1.toString()==v1.id);
	}

	@Test
	public void testVertexAddEdge() {
		assertTrue("After calling Vertex#addEdge, it has Edge to Vertex", v1.first.target.equals(v2));
	}
	
	@Test
	public void testVertexHasEdge() {
		assertTrue("It returns true if it has Edge to Vertex", v1.hasEdge(v2));
		assertTrue("It returns true if it has Edge to Vertex", v2.hasEdge(v3));
		assertTrue("It returns true if it has Edge to Vertex", v2.hasEdge(v4));
		assertTrue("It returns true if it has Edge to Vertex", v4.hasEdge(v4));
		assertFalse("It returns false if it has no Edge to Vertex", v1.hasEdge(v1));
		assertFalse("It returns false if it has no Edge to Vertex", v2.hasEdge(v1));
		assertFalse("It returns false if it has no Edge to Vertex", v3.hasEdge(v2));
		assertFalse("It returns false if it has no Edge to Vertex", v4.hasEdge(v3));
	}
	
	@Test
	public void testVertexHasUndirectedEdge() {
		v2.addEdge(v1);

		assertTrue("It returns true if has undirected Edge", v1.hasUndirectedEdge(v2));
		assertFalse("It returns false if has no undirected Edge", v2.hasUndirectedEdge(v4));
	}
	
	@Test
	public void testGraphmakeEdgesToUndirectional(){
		g.makeEdgesToUndirectional();

		assertTrue("It has created reverse Edge", v1.hasUndirectedEdge(v2));
		assertTrue("It has created reverse Edge", v2.hasUndirectedEdge(v3));
		assertTrue("It has created reverse Edge", v2.hasUndirectedEdge(v4));
		assertTrue("It has created reverse Edge", v4.hasUndirectedEdge(v4));
		assertFalse("It has not created Edge for what was not connected", v4.hasEdge(v1));
	}

}

java2-home6.java

// koostada meetodi orienteeritud graafi muutmiseks orienteerimata graafiks 

import java.util.*;

public class Answer {

   public static void main (String[] args) {
      Answer a = new Answer();
      a.run();
   }

   public void run() {
      // TODO!!! YOUR TESTS HERE!

	  Graph g = new Graph ("G");
	  
	  Vertex a = new Vertex ("A", g);
	  Vertex b = new Vertex ("B", g);
      Vertex c = new Vertex ("C", g);
      
      a.addEdge(b);
      a.addEdge(c);
      
      g.makeEdgesToUndirectional();

      System.out.println (g);
   }


   public static class Vertex {

      String id;
      Vertex next;
      Edge first;
      Edge last; // cache value for last Edge (so iteration is not needed, pump up the speed)

      Vertex (String s, Graph g) {
         id = s;
         g.addVertex(this);
      }
      
      public void addEdge(Vertex toVertex) {
    	  if(hasEdge(toVertex)) throw new RuntimeException("Already has Edge to " + toVertex.id);
    	  
    	  Edge e = new Edge(id+toVertex.id, toVertex);
    	  if(last!=null) {
    		  last.next = e;
    		  last = e;
    	  } else {
    		  first = last = e;
    	  }
      }
      
      public boolean hasEdge(Vertex to) {
    	  Edge checkedEdge = first;
    	  while(checkedEdge != null) {
    		  if(checkedEdge.target == to) return true;
    		  checkedEdge = checkedEdge.next;
    	  }
    	  
    	  return false;
      }
      
      public boolean hasUndirectedEdge(Vertex to) {
    	  return this.hasEdge(to) && to.hasEdge(this);
      }

      @Override
      public String toString() {
         return id;
      }

      // TODO!!! Your Vertex methods here!

   } // Vertex


   public static class Edge {

      String id;
      Vertex target;
      Edge next;

      Edge (String s, Vertex v) {
         id = s;
         target = v;
      }

      @Override
      public String toString() {
         return id;
      }

      // TODO!!! Your Edge methods here!

   } // Edge


   public static class Graph {

      String id;
      Vertex first;
      Vertex last; // cache value for last Vertex (so iteration is not needed, pump up the speed)

      Graph (String s) {
         id = s;
      }

      @Override
      public String toString() {
         StringBuffer sb = new StringBuffer (id);
         String nl = System.getProperty ("line.separator");
         sb.append (nl);
         Vertex v = first;
         while (v != null) {
            sb.append (v.toString() + " --> ");
            Edge e = v.first;
            while (e != null) {
               sb.append (e.toString());
               sb.append ("(" + v.toString() + "->" 
                  + e.target.toString() + ") ");
               e = e.next;
            }
            sb.append (nl);
            v = v.next;
         }
         return sb.toString();
      }

      public void addVertex(Vertex v) {
    	  if(last!=null) {
    		  last.next = v;
    		  last = v;
    	  } else {
    		  first = last = v;
    	  }
      }
      
      public void makeEdgesToUndirectional(){
    	  Vertex vertex = first;
    	  while(vertex!=null){
    		  Edge edge = vertex.first;
    		  while(edge!=null){
    			  if(!edge.target.hasEdge(vertex)) edge.target.addEdge(vertex);
    			  edge = edge.next;
    		  }
    		  vertex = vertex.next;
    	  }
      }

   } // Graph

}