Improve test coverage

jericks · jericks · commit b7f39a911759 · 2015-09-28T19:37:19.000-07:00
diff --git a/src/main/java/org/geometrycommands/App.java b/src/main/java/org/geometrycommands/App.java
@@ -11,7 +11,6 @@
 
 /**
  * The command line application
- *
  * @author Jared Erickson
  */
 public class App {
diff --git a/src/main/java/org/geometrycommands/GetEndPointCommand.java b/src/main/java/org/geometrycommands/GetEndPointCommand.java
@@ -53,7 +53,7 @@ public GetEndPointOptions getOptions() {
     @Override
     protected void processGeometry(Geometry geometry, GetEndPointOptions options, Reader reader, Writer writer) throws Exception {
         if (!(geometry instanceof Lineal)) {
-            throw new IllegalArgumentException("The input geometry a LineString or a MultiLineString!");
+            throw new IllegalArgumentException("The input geometry must be a LineString or a MultiLineString!");
         }
         LineString lineString;
         if (geometry instanceof MultiLineString) {
diff --git a/src/main/java/org/geometrycommands/GetStartPointCommand.java b/src/main/java/org/geometrycommands/GetStartPointCommand.java
@@ -53,7 +53,7 @@ public GetStartPointOptions getOptions() {
     @Override
     protected void processGeometry(Geometry geometry, GetStartPointOptions options, Reader reader, Writer writer) throws Exception {
         if (!(geometry instanceof Lineal)) {
-            throw new IllegalArgumentException("The input geometry a LineString or a MultiLineString!");
+            throw new IllegalArgumentException("The input geometry must be a LineString or a MultiLineString!");
         }
         LineString lineString;
         if (geometry instanceof MultiLineString) {
diff --git a/src/main/java/org/geometrycommands/InterpolatePointCommand.java b/src/main/java/org/geometrycommands/InterpolatePointCommand.java
@@ -57,7 +57,7 @@ public InterpolatePointOptions getOptions() {
     @Override
     protected void processGeometry(Geometry geometry, InterpolatePointOptions options, Reader reader, Writer writer) throws Exception {
         if (!(geometry instanceof Lineal)) {
-            throw new IllegalArgumentException("The input geometry a LineString or a MultiLineString!");
+            throw new IllegalArgumentException("The input geometry must be a LineString or a MultiLineString!");
         }
         LengthIndexedLine indexedLine = new LengthIndexedLine(geometry);
         double length = geometry.getLength();
diff --git a/src/main/java/org/geometrycommands/IsClosedCommand.java b/src/main/java/org/geometrycommands/IsClosedCommand.java
@@ -52,7 +52,7 @@ public IsClosedOptions getOptions() {
     @Override
     protected void processGeometry(Geometry geometry, IsClosedOptions options, Reader reader, Writer writer) throws Exception {
         if (!(geometry instanceof Lineal)) {
-            throw new IllegalArgumentException("Input geometry must be a LineString or a MultiLineString!");
+            throw new IllegalArgumentException("The input geometry must be a LineString or a MultiLineString!");
         }
         boolean closed = false;
         if (geometry instanceof LineString) {
diff --git a/src/main/java/org/geometrycommands/IsRingCommand.java b/src/main/java/org/geometrycommands/IsRingCommand.java
@@ -50,7 +50,7 @@ public IsRingOptions getOptions() {
     @Override
     protected void processGeometry(Geometry geometry, IsRingOptions options, Reader reader, Writer writer) throws Exception {
         if (!(geometry instanceof LineString)) {
-            throw new IllegalArgumentException("Input geometry must be a LineString!");
+            throw new IllegalArgumentException("The input geometry must be a LineString!");
         }
         boolean isRing = ((LineString) geometry).isRing();
         writer.write(String.valueOf(isRing));
diff --git a/src/main/java/org/geometrycommands/LocatePointCommand.java b/src/main/java/org/geometrycommands/LocatePointCommand.java
@@ -58,12 +58,13 @@ protected void processGeometries(Geometry geometry, Geometry other, LocatePointO
         
         if (geometry instanceof Point) {
             point = (Point)geometry;
-        }else if (other instanceof Point) {
+        } else if (other instanceof Point) {
             point = (Point)other;
         }
+
         if (geometry instanceof Lineal) {
             line = geometry;
-        }else if (other instanceof Lineal) {
+        } else if (other instanceof Lineal) {
             line = other;
         }
         
diff --git a/src/test/java/org/geometrycommands/AppTest.java b/src/test/java/org/geometrycommands/AppTest.java
@@ -62,6 +62,26 @@ public void testHelp() {
                 + " -g (--geometry) VAL : The input geometry", values.get("out"));
     }
 
+    @Test
+    public void testHelpWhenRequiredArgsNotPresent() {
+        CaptureOutput capture = CaptureOutput.createAndStart();
+        try {
+            App.main(new String[]{
+                    "buffer", "--help"
+            });
+        } catch (OverrideExitException ex) {
+        }
+        Map<String, String> values = capture.stop();
+        assertEquals("geom buffer: Buffer a geometry by a distance." + NEW_LINE +
+                " --help                    : Print help message" + NEW_LINE +
+                " -c (--endCapStyle) VAL    : The end cap style (round, flat/butt, square)" + NEW_LINE +
+                " -d (--distance) N         : The buffer distance" + NEW_LINE +
+                " -g (--geometry) VAL       : The input geometry" + NEW_LINE +
+                " -q (--quadrantSegments) N : The number of quadrant segments" + NEW_LINE +
+                " -s (--singleSided)        : The flag for whether the buffer should be single" + NEW_LINE +
+                "                             sided", values.get("out"));
+    }
+
     @Test
     public void testArgumentError() {
         CaptureOutput capture = CaptureOutput.createAndStart();
diff --git a/src/test/java/org/geometrycommands/ArcCommandTest.java b/src/test/java/org/geometrycommands/ArcCommandTest.java
@@ -24,6 +24,7 @@ public void execute() throws Exception {
         options.setWidth(50);
         options.setHeight(50);
         options.setNumberOfPoints(10);
+        options.setDegrees(false);
 
         Reader reader = new StringReader(inputGeometry);
         StringWriter writer = new StringWriter();
@@ -85,6 +86,23 @@ public void run() throws Exception {
                 + "148.2299398518295 115.76041697475566, "
                 + "148.7342558247792 132.8539862772947, "
                 + "138.13304972044324 146.27258811335295)", result);
+
+        // Radians
+        result = runApp(new String[]{
+                "arc",
+                "-a", "45",
+                "-e", "90",
+                "-w", "50",
+                "-h", "50",
+                "-p", "10",
+                "-d"
+        }, "POINT (100 100)");
+        assertEquals("LINESTRING (142.6776695296637 142.6776695296637, " +
+                "139.33941090877616 145.4788011072248, 135.56545654351748 147.65769467591625, " +
+                "131.47047612756302 149.1481456572267, 127.17889356869145 149.90486745229364, " +
+                "122.82110643130855 149.90486745229364, 118.52952387243698 149.1481456572267, " +
+                "114.43454345648252 147.65769467591625, 110.66058909122384 145.4788011072248, " +
+                "107.32233047033631 142.6776695296637)", result);
     }
 
 }
diff --git a/src/test/java/org/geometrycommands/ArcPolygonCommandTest.java b/src/test/java/org/geometrycommands/ArcPolygonCommandTest.java
@@ -24,6 +24,7 @@ public void execute() throws Exception {
         options.setWidth(50);
         options.setHeight(50);
         options.setNumberOfPoints(10);
+        options.setDegrees(false);
 
         Reader reader = new StringReader(inputGeometry);
         StringWriter writer = new StringWriter();
@@ -89,6 +90,22 @@ public void run() throws Exception {
                 + "148.7342558247792 132.8539862772947, "
                 + "138.13304972044324 146.27258811335295, "
                 + "125 125))", result);
+
+        // Degrees
+        result = runApp(new String[]{
+                "arcpoly",
+                "-a", "45",
+                "-e", "90",
+                "-w", "50",
+                "-h", "50",
+                "-p", "10",
+                "-d"
+        }, "POINT (100 100)");
+        assertEquals("POLYGON ((125 125, 142.6776695296637 142.6776695296637, 139.33941090877616 145.4788011072248, " +
+                "135.56545654351748 147.65769467591625, 131.47047612756302 149.1481456572267, " +
+                "127.17889356869145 149.90486745229364, 122.82110643130855 149.90486745229364, " +
+                "118.52952387243698 149.1481456572267, 114.43454345648252 147.65769467591625, " +
+                "110.66058909122384 145.4788011072248, 107.32233047033631 142.6776695296637, 125 125))", result);
     }
 
 }
diff --git a/src/test/java/org/geometrycommands/BaseTest.java b/src/test/java/org/geometrycommands/BaseTest.java
@@ -1,14 +1,18 @@
 package org.geometrycommands;
 
 import java.io.*;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * The Base Test class
  * @author Jared Erickson
  */
 public abstract class BaseTest {
 
+    public static final String NEW_LINE = System.getProperty("line.separator");
+
     public String runApp(String[] args, String input) throws Exception {
         // Save normal System.in and System.out
         InputStream sysin = System.in;
@@ -30,4 +34,32 @@ public String runApp(String[] args, String input) throws Exception {
         return out.toString("UTF-8").trim();
     }
 
+    public Map<String,String> runAppWithOutAndErr(String[] args, String input) throws Exception {
+        // Save normal System.in and System.out
+        InputStream sysin = System.in;
+        PrintStream syserr = System.err;
+        PrintStream sysout = System.out;
+        // Replace System.in with input text
+        if (input == null) {
+            input = "";
+        }
+        System.setIn(new ByteArrayInputStream(input.getBytes("UTF-8")));
+        // Replace System.out with OutputStream we can capture
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(out));
+        // Replace System.err with OutputStream we can capture
+        ByteArrayOutputStream err = new ByteArrayOutputStream();
+        System.setErr(new PrintStream(err));
+        // Run the app with the List of arguments
+        App.main(args);
+        // Replace normal System.in and System.out
+        System.setIn(sysin);
+        System.setOut(sysout);
+        System.setErr(syserr);
+        // Return the captured output
+        Map<String,String> outputs =new HashMap<String, String>();
+        outputs.put("out", out.toString("UTF-8").trim());
+        outputs.put("err", err.toString("UTF-8").trim());
+        return outputs;
+    }
 }
diff --git a/src/test/java/org/geometrycommands/CloseLineStringCommandTest.java b/src/test/java/org/geometrycommands/CloseLineStringCommandTest.java
@@ -5,6 +5,8 @@
 import java.io.Reader;
 import java.io.StringReader;
 import java.io.StringWriter;
+import java.util.Map;
+
 import org.geometrycommands.CloseLineStringCommand.CloseLineStringOptions;
 import static org.junit.Assert.assertEquals;
 
@@ -55,6 +57,35 @@ public void run() throws Exception {
                 "closelinestring"
         }, "LINESTRING (0 0, 0 4, 4 4, 4 0)");
         assertEquals("LINEARRING (0 0, 0 4, 4 4, 4 0, 0 0)", result);
+
+        // Geometry from input stream
+        result = runApp(new String[]{
+                "closelinestring"
+        }, "LINESTRING (0 0, 0 4, 4 4, 4 0, 0 0)");
+        assertEquals("LINEARRING (0 0, 0 4, 4 4, 4 0, 0 0)", result);
     }
 
+    @Test
+    public void runWithWrongGeometry() throws Exception {
+        Map<String,String> outputs = runAppWithOutAndErr(new String[]{
+                "closelinestring",
+                "-g", "POINT (0 0)"
+        }, null);
+        assertEquals("Input geometry must be a LineString!" + NEW_LINE +
+                "Usage: geom <command> <args>" + NEW_LINE +
+                " --help              : Print help message" + NEW_LINE +
+                " -g (--geometry) VAL : The input geometry", outputs.get("err"));
+    }
+
+    @Test
+    public void runWithLineStringTooShort() throws Exception {
+        Map<String,String> outputs = runAppWithOutAndErr(new String[]{
+                "closelinestring",
+                "-g", "LINESTRING (0 0, 10 10)"
+        }, null);
+        assertEquals("You need at least three points to close a LineString!" + NEW_LINE +
+                "Usage: geom <command> <args>" + NEW_LINE +
+                " --help              : Print help message" + NEW_LINE +
+                " -g (--geometry) VAL : The input geometry", outputs.get("err"));
+    }
 }
diff --git a/src/test/java/org/geometrycommands/EqualsCommandTest.java b/src/test/java/org/geometrycommands/EqualsCommandTest.java
@@ -90,6 +90,22 @@ public void execute() throws Exception {
         command = new EqualsCommand();
         command.execute(options, reader, writer);
         assertEquals("true", writer.getBuffer().toString());
+
+        // exact with tolerance
+        inputGeometry = "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))";
+        otherGeometry = "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))";
+        options = new EqualsOptions();
+        options.setGeometry(inputGeometry);
+        options.setOtherGeometry(otherGeometry);
+        options.setType("exact");
+        options.setTolerance(1.1);
+
+        reader = new StringReader(inputGeometry);
+        writer = new StringWriter();
+
+        command = new EqualsCommand();
+        command.execute(options, reader, writer);
+        assertEquals("true", writer.getBuffer().toString());
     }
 
     @Test
@@ -108,5 +124,13 @@ public void run() throws Exception {
                 "-o", "POLYGON ((1 1, 1 10, 10 10, 10 1, 1 1))"
         }, "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))");
         assertFalse(Boolean.parseBoolean(result));
+
+        // topo
+        result = runApp(new String[]{
+                "equals",
+                "-o", "POLYGON ((1 1, 1 10, 10 10, 10 1, 1 1))",
+                "-t", "topo"
+        }, "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))");
+        assertFalse(Boolean.parseBoolean(result));
     }
 }
diff --git a/src/test/java/org/geometrycommands/FromWkbCommandTest.java b/src/test/java/org/geometrycommands/FromWkbCommandTest.java
@@ -20,6 +20,8 @@ public void execute() throws Exception {
         String wkb = "0000000003000000010000000500000000000000000000000000000000000000000000000040240000" +
                 "000000004024000000000000402400000000000040240000000000000000000000000000000000000000000" +
                 "00000000000000000";
+
+        // From standard input stream
         FromWkbOptions options = new FromWkbOptions();
 
         Reader reader = new StringReader(wkb);
@@ -28,6 +30,17 @@ public void execute() throws Exception {
         FromWkbCommand command = new FromWkbCommand();
         command.execute(options, reader, writer);
         assertEquals("POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))", writer.getBuffer().toString());
+
+        // From Options
+        options = new FromWkbOptions();
+        options.setWkb(wkb);
+
+        reader = new StringReader("");
+        writer = new StringWriter();
+
+        command = new FromWkbCommand();
+        command.execute(options, reader, writer);
+        assertEquals("POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))", writer.getBuffer().toString());
     }
 
     @Test
diff --git a/src/test/java/org/geometrycommands/GetEndPointCommandTest.java b/src/test/java/org/geometrycommands/GetEndPointCommandTest.java
@@ -3,6 +3,8 @@
 import java.io.Reader;
 import java.io.StringReader;
 import java.io.StringWriter;
+import java.util.Map;
+
 import org.junit.Test;
 import static org.junit.Assert.assertEquals;
 import org.geometrycommands.GetEndPointCommand.GetEndPointOptions;
@@ -53,4 +55,17 @@ public void run() throws Exception {
         }, "MULTILINESTRING ((1 1, 5 5, 10 10), (20 20, 30 30, 40 40))");
         assertEquals("POINT (40 40)", result);
     }
+
+    @Test
+    public void runWithWrongGeometryType() throws Exception {
+        Map<String,String> result = runAppWithOutAndErr(new String[]{
+                "endpoint",
+                "-g", "POINT (1 1)"
+        }, null);
+        assertEquals("The input geometry must be a LineString or a MultiLineString!" + NEW_LINE +
+                "Usage: geom <command> <args>" + NEW_LINE +
+                " --help              : Print help message" + NEW_LINE +
+                " -g (--geometry) VAL : The input geometry", result.get("err"));
+    }
+
 }
diff --git a/src/test/java/org/geometrycommands/GetStartPointCommandTest.java b/src/test/java/org/geometrycommands/GetStartPointCommandTest.java
@@ -3,6 +3,8 @@
 import java.io.Reader;
 import java.io.StringReader;
 import java.io.StringWriter;
+import java.util.Map;
+
 import org.junit.Test;
 import static org.junit.Assert.assertEquals;
 import org.geometrycommands.GetStartPointCommand.GetStartPointOptions;
@@ -53,4 +55,16 @@ public void run() throws Exception {
         }, "MULTILINESTRING ((1 1, 5 5, 10 10), (20 20, 30 30, 40 40))");
         assertEquals("POINT (1 1)", result);
     }
+
+    @Test
+    public void runWithWrongGeometryType() throws Exception {
+        Map<String,String> result = runAppWithOutAndErr(new String[]{
+                "startpoint",
+                "-g", "POINT (1 1)"
+        }, null);
+        assertEquals("The input geometry must be a LineString or a MultiLineString!" + NEW_LINE +
+                "Usage: geom <command> <args>" + NEW_LINE +
+                " --help              : Print help message" + NEW_LINE +
+                " -g (--geometry) VAL : The input geometry", result.get("err"));
+    }
 }
diff --git a/src/test/java/org/geometrycommands/InterpolatePointCommandTest.java b/src/test/java/org/geometrycommands/InterpolatePointCommandTest.java
diff --git a/src/test/java/org/geometrycommands/IsClosedCommandTest.java b/src/test/java/org/geometrycommands/IsClosedCommandTest.java
diff --git a/src/test/java/org/geometrycommands/IsRingCommandTest.java b/src/test/java/org/geometrycommands/IsRingCommandTest.java
diff --git a/src/test/java/org/geometrycommands/IsValidCommandTest.java b/src/test/java/org/geometrycommands/IsValidCommandTest.java
diff --git a/src/test/java/org/geometrycommands/LocatePointCommandTest.java b/src/test/java/org/geometrycommands/LocatePointCommandTest.java
diff --git a/src/test/java/org/geometrycommands/OptionsTest.java b/src/test/java/org/geometrycommands/OptionsTest.java
diff --git a/src/test/java/org/geometrycommands/PlacePointCommandTest.java b/src/test/java/org/geometrycommands/PlacePointCommandTest.java
diff --git a/src/test/java/org/geometrycommands/PrecisionReducerCommandTest.java b/src/test/java/org/geometrycommands/PrecisionReducerCommandTest.java

Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ public GetEndPointOptions getOptions() {`
`53`	`53`	`@Override`
`54`	`54`	`protected void processGeometry(Geometry geometry, GetEndPointOptions options, Reader reader, Writer writer) throws Exception {`
`55`	`55`	`if (!(geometry instanceof Lineal)) {`
`56`		`- throw new IllegalArgumentException("The input geometry a LineString or a MultiLineString!");`
	`56`	`+ throw new IllegalArgumentException("The input geometry must be a LineString or a MultiLineString!");`
`57`	`57`	`}`
`58`	`58`	`LineString lineString;`
`59`	`59`	`if (geometry instanceof MultiLineString) {`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ public GetStartPointOptions getOptions() {`
`53`	`53`	`@Override`
`54`	`54`	`protected void processGeometry(Geometry geometry, GetStartPointOptions options, Reader reader, Writer writer) throws Exception {`
`55`	`55`	`if (!(geometry instanceof Lineal)) {`
`56`		`- throw new IllegalArgumentException("The input geometry a LineString or a MultiLineString!");`
	`56`	`+ throw new IllegalArgumentException("The input geometry must be a LineString or a MultiLineString!");`
`57`	`57`	`}`
`58`	`58`	`LineString lineString;`
`59`	`59`	`if (geometry instanceof MultiLineString) {`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ public InterpolatePointOptions getOptions() {`
`57`	`57`	`@Override`
`58`	`58`	`protected void processGeometry(Geometry geometry, InterpolatePointOptions options, Reader reader, Writer writer) throws Exception {`
`59`	`59`	`if (!(geometry instanceof Lineal)) {`
`60`		`- throw new IllegalArgumentException("The input geometry a LineString or a MultiLineString!");`
	`60`	`+ throw new IllegalArgumentException("The input geometry must be a LineString or a MultiLineString!");`
`61`	`61`	`}`
`62`	`62`	`LengthIndexedLine indexedLine = new LengthIndexedLine(geometry);`
`63`	`63`	`double length = geometry.getLength();`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public IsClosedOptions getOptions() {`
`52`	`52`	`@Override`
`53`	`53`	`protected void processGeometry(Geometry geometry, IsClosedOptions options, Reader reader, Writer writer) throws Exception {`
`54`	`54`	`if (!(geometry instanceof Lineal)) {`
`55`		`- throw new IllegalArgumentException("Input geometry must be a LineString or a MultiLineString!");`
	`55`	`+ throw new IllegalArgumentException("The input geometry must be a LineString or a MultiLineString!");`
`56`	`56`	`}`
`57`	`57`	`boolean closed = false;`
`58`	`58`	`if (geometry instanceof LineString) {`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ public IsRingOptions getOptions() {`
`50`	`50`	`@Override`
`51`	`51`	`protected void processGeometry(Geometry geometry, IsRingOptions options, Reader reader, Writer writer) throws Exception {`
`52`	`52`	`if (!(geometry instanceof LineString)) {`
`53`		`- throw new IllegalArgumentException("Input geometry must be a LineString!");`
	`53`	`+ throw new IllegalArgumentException("The input geometry must be a LineString!");`
`54`	`54`	`}`
`55`	`55`	`boolean isRing = ((LineString) geometry).isRing();`
`56`	`56`	`writer.write(String.valueOf(isRing));`
Original file line number	Diff line number	Diff line change
`@@ -58,12 +58,13 @@ protected void processGeometries(Geometry geometry, Geometry other, LocatePointO`
`58`	`58`
`59`	`59`	`if (geometry instanceof Point) {`
`60`	`60`	`point = (Point)geometry;`
`61`		`- }else if (other instanceof Point) {`
	`61`	`+ } else if (other instanceof Point) {`
`62`	`62`	`point = (Point)other;`
`63`	`63`	`}`
	`64`	`+`
`64`	`65`	`if (geometry instanceof Lineal) {`
`65`	`66`	`line = geometry;`
`66`		`- }else if (other instanceof Lineal) {`
	`67`	`+ } else if (other instanceof Lineal) {`
`67`	`68`	`line = other;`
`68`	`69`	`}`
`69`	`70`