build.xml

<!--
     CS311 Homework 6 Tests
     ======================

     ## Downloading

     To use these tests, just use Git and clone them into the directory you
     have your project.

     You can do this using:
        git clone <url here> tests

     ## Running the Tests

     If you compile things from the command line and have ant installed:
     http://ant.apache.org/, you only have to modify a few lines to make it
     work.

     1. First, modify the property below with the name "src.dir". It should point
        to the directory that your package lives in.

     2. Open up TestRunner.java file and edit the return line of the method
        `newInstance`.  The class that is instantiated should point to your
        implementation of IGraph.

     3. Now you should just be able to run `ant test` on the command line.

     ## Additional Things

     This ant build.xml file contains a few targets:

     1. `ant init`
     2. `ant build`
     3. `ant build-test`
     4. `ant test`
     5. `ant clean`

     More than likely you'll only have to run `clean` and `test`.

    ## Contributing

    Feel free to Fork this Gist and make changes. Let me know when/if you do
    and I'll add them to the existing tests.
-->

<project name="311Homework6" default="build" basedir=".">

-->

<project name="311Homework6" default="build" basedir=".">
    <!--
         Edit this value.

         Replace "../src/" with the directory of your Java package.

         It should be the same directory that edu/iastate/cs311/f13/hw6 lives.
    -->

    <property name="src.dir" value="../src/"/>

    <!-- -->
    <!-- -->
    <!--
         No additional changes should be required below this.
    -->
    <!-- -->
    <!-- -->

    <property name="test.dir" value="."/>
    <property name="dest.dir" value="./dest"/>

    <presetdef name="javac">
        <javac includeantruntime="false"/>
    </presetdef>

    <path id="classpath.base">
    </path>
    <path id="classpath.test">
        <pathelement location="junit.jar"/>
        <pathelement location="hamcrest-core.jar"/>
        <pathelement location="${test.dir}"/>
        <pathelement location="${dest.dir}"/>
        <path refid="classpath.base"/>
    </path>

    <target name="init">
        <mkdir dir="${dest.dir}"/>
    </target>

    <target name="clean">
        <delete dir="${dest.dir}"/>
    </target>

    <target name="build" depends="init">
        <javac srcdir="${src.dir}" destdir="${dest.dir}"/>
    </target>

    <target name="build-test" depends="init">
        <javac srcdir="${test.dir}" destdir="${dest.dir}">
            <include name="TestRunner.java" />
            <classpath refid="classpath.test"/>
        </javac>
    </target>

    <target name="test" depends="build,build-test">
        <junit dir="${dest.dir}" printsummary="yes" haltonfailure="no">
            <classpath refid="classpath.test"/>
            <formatter type="plain" usefile="false"/>
            <test name="TestRunner"/>
        </junit>
    </target>
</project>

hamcrest-core.jar

junit.jar

TestGraph.java

import static org.junit.Assert.assertThat;
import static org.hamcrest.CoreMatchers.equalTo;

import org.junit.Test;

import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collection;

import edu.iastate.cs311.f13.hw6.IGraph;

/**
 * Test IGraph implementation class.
 */
public class TestGraph {

    /**
     * Test that creating a new instance of the IGraph implementation doens't
     * give us an exception.
     *
     * If it does, check the TestRunner.java file to make sure your IGraph
     * implementation class is being imported and set correctly.
     */
    @Test
    public void testCreateEmptyGraph() {
        TestRunner.newGraph();
    }

    @Test
    public void testEmptyGraph() {
        IGraph g = TestRunner.newGraph();

        Collection<String> expected = Arrays.asList();
        Collection<String> actual = g.getVertices();

        assertThat("Check the graph has no vertices", actual, equalTo(expected));
    }

    @Test
    public void testAddOneVertex() {
        IGraph g = TestRunner.newGraph();
        String v = "A";

        g.addVertex(v);

        Collection<String> expected = Arrays.asList(v);
        Collection<String> actual = g.getVertices();

        assertThat("Check the added vertex was added", actual, equalTo(expected));
    }

    @Test
    public void testAddMultipleVertices() {
        IGraph g = TestRunner.newGraph();
        ArrayList<String> vertices = new ArrayList<String>();

        for (char c = 'A'; c < 'A' + 10; c += 1) {
            String s = "" + c;
            vertices.add(s);
            g.addVertex(s);
        }

        Collection<String> expected = (Collection<String>) vertices;
        Collection<String> actual = g.getVertices();

        assertThat("Check for added vertices", actual, equalTo(expected));
    }

    @Test
    public void testEmptyEdgesForSingleVertex() {
        IGraph g = TestRunner.newGraph();
        String v = "A";

        g.addVertex(v);

        Collection<String> expected = Arrays.asList();
        Collection<String> actual = g.getOutgoingEdges(v);

        assertThat("Check a single vertex has no outgoing edges", actual, equalTo(expected));
    }
}

TestMaxFlow.java

import org.junit.Test;

/**
 * Test max flow algorithms.
 */
public class TestMaxFlow {
    @Test
    public final void emptyTest() {
    }
}

TestRunner.java

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

import edu.iastate.cs311.f13.hw6.*;

@RunWith(Suite.class)
@Suite.SuiteClasses({
    TestGraph.class,
    TestMaxFlow.class,
    TestTopologicalSort.class,
})

/**
 * Almost empty class for the suites.
 */
public final class TestRunner {
    /**
     * Create a new instance of the above class automatically.
     * @return An instance that adheres to the IGraph interface
     *
     * Replace `Graph` class with the name of your implementation of the IGraph
     * interface.
     *
     */
    public static IGraph newGraph() {
        return new Graph();
    }
}

TestTopologicalSort.java

import org.junit.Test;

/**
 * Test topological algorithms.
 */
public class TestTopologicalSort {
    @Test
    public final void simpleTopologicalSort() {

    }
}