reorganize classes so test data is separate from test cases

src/test/java/org/json/junit/data/BrokenToString.java

@@ -0,0 +1,13 @@
+package org.json.junit.data;
+
+/**
+ * test class for verifying write errors.
+ * @author John Aylward
+ *
+ */
+public class BrokenToString {
+    @Override
+    public String toString() {
+        throw new IllegalStateException("Something went horribly wrong!");
+    }
+}

src/test/java/org/json/junit/data/Fraction.java

@@ -0,0 +1,180 @@
+package org.json.junit.data;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.RoundingMode;
+
+/**
+ * basic fraction class, no frills.
+ * @author John Aylward
+ *
+ */
+public class Fraction extends Number implements Comparable<Fraction> {
+    /**
+     * serial id.
+     */
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * value as a big decimal.
+     */
+    private final BigDecimal bigDecimal;
+
+    /**
+     * value of the denominator.
+     */
+    private final BigInteger denominator;
+    /**
+     * value of the numerator.
+     */
+    private final BigInteger numerator;
+
+    /**
+     * @param numerator
+     *            numerator
+     * @param denominator
+     *            denominator
+     */
+    public Fraction(final BigInteger numerator, final BigInteger denominator) {
+        super();
+        if (numerator == null || denominator == null) {
+            throw new IllegalArgumentException("All values must be non-null");
+        }
+        if (denominator.compareTo(BigInteger.ZERO)==0) {
+            throw new IllegalArgumentException("Divide by zero");
+        }
+
+        final BigInteger n;
+        final BigInteger d;
+        // normalize fraction
+        if (denominator.signum()<0) {
+            n = numerator.negate();
+            d = denominator.negate();
+        } else {
+            n = numerator;
+            d = denominator;
+        }
+        this.numerator = n;
+        this.denominator = d;
+        if (n.compareTo(BigInteger.ZERO)==0) {
+            this.bigDecimal = BigDecimal.ZERO;
+        } else if (n.compareTo(d)==0) {// i.e. 4/4, 10/10
+            this.bigDecimal = BigDecimal.ONE;
+        } else {
+            this.bigDecimal = new BigDecimal(this.numerator).divide(new BigDecimal(this.denominator),
+                    RoundingMode.HALF_EVEN);
+        }
+    }
+    
+    /**
+     * @param numerator
+     *            numerator
+     * @param denominator
+     *            denominator
+     */
+    public Fraction(final long numerator, final long denominator) {
+        this(BigInteger.valueOf(numerator),BigInteger.valueOf(denominator));
+    }    
+
+    /**
+     * @return the decimal
+     */
+    public BigDecimal bigDecimalValue() {
+        return this.bigDecimal;
+    }
+
+    @Override
+    public int compareTo(final Fraction o) {
+        // .equals call this, so no .equals compare allowed
+
+        // if they are the same reference, just return equals
+        if (this == o) {
+            return 0;
+        }
+
+        // if my denominators are already equal, just compare the numerators
+        if (this.denominator.compareTo(o.denominator)==0) {
+            return this.numerator.compareTo(o.numerator);
+        }
+
+        // get numerators of common denominators
+        // a    x     ay   xb
+        // --- --- = ---- ----
+        // b    y     by   yb
+        final BigInteger thisN = this.numerator.multiply(o.denominator);
+        final BigInteger otherN = o.numerator.multiply(this.denominator);
+
+        return thisN.compareTo(otherN);
+    }
+
+    @Override
+    public double doubleValue() {
+        return this.bigDecimal.doubleValue();
+    }
+
+    /**
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    @Override
+    public boolean equals(final Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (this.getClass() != obj.getClass()) {
+            return false;
+        }
+        final Fraction other = (Fraction) obj;
+        return this.compareTo(other) == 0;
+    }
+
+    @Override
+    public float floatValue() {
+        return this.bigDecimal.floatValue();
+    }
+
+    /**
+     * @return the denominator
+     */
+    public BigInteger getDenominator() {
+        return this.denominator;
+    }
+
+    /**
+     * @return the numerator
+     */
+    public BigInteger getNumerator() {
+        return this.numerator;
+    }
+
+    /**
+     * @see java.lang.Object#hashCode()
+     */
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + (this.bigDecimal == null ? 0 : this.bigDecimal.hashCode());
+        return result;
+    }
+
+    @Override
+    public int intValue() {
+        return this.bigDecimal.intValue();
+    }
+
+    @Override
+    public long longValue() {
+        return this.bigDecimal.longValue();
+    }
+
+    /**
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        return this.numerator + "/" + this.denominator;
+    }
+}

src/test/java/org/json/junit/data/MyBean.java

@@ -0,0 +1,16 @@
+package org.json.junit.data;
+
+import java.io.*;
+
+/**
+ * Used in testing when Bean behavior is needed
+ */
+public interface MyBean {
+    public Integer getIntKey();
+    public Double getDoubleKey();
+    public String getStringKey();
+    public String getEscapeStringKey();
+    public Boolean isTrueKey();
+    public Boolean isFalseKey();
+    public StringReader getStringReaderKey();
+}

src/test/java/org/json/junit/data/MyBigNumberBean.java

@@ -0,0 +1,11 @@
+package org.json.junit.data;
+
+import java.math.*;
+
+/**
+ * Used in testing when a Bean containing big numbers is needed
+ */
+public interface MyBigNumberBean {
+    public BigInteger getBigInteger();
+    public BigDecimal getBigDecimal();
+}

src/test/java/org/json/junit/data/MyEnum.java

@@ -0,0 +1,10 @@
+package org.json.junit.data;
+
+/**
+ * An enum with no methods or data
+ */
+public enum MyEnum {
+    VAL1,
+    VAL2,
+    VAL3;
+}

src/test/java/org/json/junit/data/MyEnumClass.java

@@ -0,0 +1,22 @@
+package org.json.junit.data;
+
+/**
+ * this is simply a class that contains some enum instances
+ */
+public class MyEnumClass {
+    private MyEnum myEnum;
+    private MyEnumField myEnumField;
+
+    public MyEnum getMyEnum() {
+        return myEnum;
+    }
+    public void setMyEnum(MyEnum myEnum) {
+        this.myEnum = myEnum;
+    }
+    public MyEnumField getMyEnumField() {
+        return myEnumField;
+    }
+    public void setMyEnumField(MyEnumField myEnumField) {
+        this.myEnumField = myEnumField;
+    }
+}

src/test/java/org/json/junit/data/MyEnumField.java

@@ -0,0 +1,28 @@
+package org.json.junit.data;
+
+/**
+ * An enum that contains getters and some internal fields
+ */
+@SuppressWarnings("boxing")
+public enum MyEnumField {
+    VAL1(1, "val 1"),
+    VAL2(2, "val 2"),
+    VAL3(3, "val 3");
+
+    private String value;
+    private Integer intVal;
+    private MyEnumField(Integer intVal, String value) {
+        this.value = value;
+        this.intVal = intVal;
+    }
+    public String getValue() {
+        return this.value;
+    }
+    public Integer getIntVal() {
+        return this.intVal;
+    }
+    @Override
+    public String toString(){
+        return this.value;
+    }
+}

src/test/java/org/json/junit/data/MyJsonString.java

@@ -0,0 +1,14 @@
+package org.json.junit.data;
+
+import org.json.*;
+
+/**
+ * Used in testing when a JSONString is needed
+ */
+public class MyJsonString implements JSONString {
+
+    @Override
+    public String toJSONString() {
+        return "my string";
+    }
+}

src/test/java/org/json/junit/data/MyLocaleBean.java

@@ -0,0 +1,12 @@
+package org.json.junit.data;
+
+public class MyLocaleBean {
+    private final String id = "beanId";
+    private final String i = "beanI";
+    public String getId() {
+        return id;
+    }
+    public String getI() {
+        return i;
+    }
+}

src/test/java/org/json/junit/data/MyNumber.java

@@ -0,0 +1,97 @@
+package org.json.junit.data;
+
+import java.math.BigDecimal;
+
+/**
+ * Number override for testing. Number overrides should always override
+ * toString, hashCode, and Equals.
+ * 
+ * @see <a
+ *      href="https://docs.oracle.com/javase/tutorial/java/data/numberclasses.html">The
+ *      Numbers Classes</a>
+ * @see <a
+ *      href="https://docs.oracle.com/javase/tutorial/java/data/numberformat.html">Formatting
+ *      Numeric Print Output</a>
+ * 
+ * @author John Aylward
+ */
+public class MyNumber extends Number {
+    private Number number = BigDecimal.valueOf(42);
+    /**
+     */
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * @return number!
+     */
+    public Number getNumber() {
+        return this.number;
+    }
+
+    @Override
+    public int intValue() {
+        return getNumber().intValue();
+    }
+
+    @Override
+    public long longValue() {
+        return getNumber().longValue();
+    }
+
+    @Override
+    public float floatValue() {
+        return getNumber().floatValue();
+    }
+
+    @Override
+    public double doubleValue() {
+        return getNumber().doubleValue();
+    }
+
+    /* (non-Javadoc)
+     * @see java.lang.Object#toString()
+     * 
+     * Number overrides should in general always override the  toString method.
+     */
+    @Override
+    public String toString() {
+        return getNumber().toString();
+    }
+
+    /* (non-Javadoc)
+     * @see java.lang.Object#hashCode()
+     */
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((this.number == null) ? 0 : this.number.hashCode());
+        return result;
+    }
+
+    /* (non-Javadoc)
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (!(obj instanceof MyNumber)) {
+            return false;
+        }
+        MyNumber other = (MyNumber) obj;
+        if (this.number == null) {
+            if (other.number != null) {
+                return false;
+            }
+        } else if (!this.number.equals(other.number)) {
+            return false;
+        }
+        return true;
+    }
+
+}

src/test/java/org/json/junit/data/MyNumberContainer.java

@@ -0,0 +1,13 @@
+package org.json.junit.data;
+
+/**
+ * Class that holds our MyNumber override as a property.
+ * @author John Aylward
+ */
+public class MyNumberContainer {
+    private MyNumber myNumber = new MyNumber();
+    /**
+     * @return a MyNumber.
+     */
+    public Number getMyNumber() {return this.myNumber;}
+}

src/test/java/org/json/junit/data/MyPublicClass.java

@@ -0,0 +1,10 @@
+package org.json.junit.data;
+
+/**
+ * Need a class with some public data members for testing
+ */
+@SuppressWarnings("boxing")
+public class MyPublicClass {
+    public Integer publicInt = 42;
+    public String publicString = "abc";
+}

src/test/java/org/json/junit/data/StringsResourceBundle.java

@@ -0,0 +1,19 @@
+package org.json.junit.data;
+
+import java.util.*;
+
+/**
+ * A resource bundle class
+ */
+public class StringsResourceBundle extends ListResourceBundle {
+    @Override
+    public Object[][] getContents() {
+        return contents;
+    }
+    static final Object[][] contents = {
+        {"greetings.hello", "Hello, "},
+        {"greetings.world", "World!"},
+        {"farewells.later", "Later, "},
+        {"farewells.gator", "Alligator!"}
+    };
+}