TDD JUnit

Question

Hi, I have been trying to use Test driven development and work back from test cases. So far I have these test cases:
package poly;
import static org.junit.Assert.*;
import org.junit.Test;
public class ConEqTest {
     private int min = Integer.MIN_VALUE;
     private int max = Integer.MAX_VALUE;
      * Testing the constructor
      * Values for coefficient: min -7 0 7 max Values for exponent: -1 0 9 max
      * Combinations for test cases: con1 (min,9) ok con2 (-7,9) ok con3 (0,9) ok
      * con4 (7,9) ok con5 (max,9) ok con6 (7, -1) NegativeExponent con7 (7,0) ok
      * con8 (7,9) ok con9 (7,max) ok
     @Test
     public void con1() throws TError {
          new Term(min, 9);
     @Test
     public void con2() throws TError {
          new Term(-7, 9);
     @Test
     public void con3() throws TError {
          new Term(0, 9);
     @Test
     public void con4() throws TError {
          new Term(7, 9);
     @Test
     public void con5() throws TError {
          new Term(max, 9);
     @Test(expected = NegativeExponent.class)
     public void con6() throws TError {
          new Term(7, -1);
     @Test
     public void con7() throws TError {
          new Term(7, 0);
     @Test
     public void con8() throws TError {
          new Term(7, 9);
     @Test
     public void con9() throws TError {
          new Term(7, max);
      * Valid terms that are equivalent: eq01 (-10,0) (-10,0) => true eq02 (0,0)
      * (0,0) => true eq03 (0,0) (0,2) => true eq04 (10,0) (10,0) => true eq05
      * (-10,2) (-10,2) => true eq06 (0,2) (0,0) => true eq07 (0,2) (0,2) => true
      * eq08 (10,2) (10,2) => true
      * Valid terms that are not equivalent eq09 (-10,0) (0,0) => false eq10
      * (-10,0) (10,0) => false eq11 (0,0) (-10,0) => false eq12 (0,0) (10,0) =>
      * false eq13 (10,0) (-10,0) => false eq14 (10,0) (0,0) => false eq15
      * (-10,0) (-10,2) => false eq16 (10,0) (10,2) => false
      * Invalid objects eq17 (10,2) null => false eq18 (10,2) "junk" => false
      * eq19 (10,2) (10,-2) => NegativeExponent eq20 (0,0) null => false
      * Testing Zero eq21 Test.Zero (0,1) => true eq22 Test.Zero (0,0) => true
     @Test
     public void eq01() throws TError {
          assertTrue(new Term(-10, 0).equals(new Term(-10, 0)));
     @Test
     public void eq02() throws TError {
          assertTrue(new Term(0, 0).equals(new Term(0, 0)));
     @Test
     public void eq03() throws TError {
          assertTrue(new Term(0, 0).equals(new Term(0, 2)));
     @Test
     public void eq04() throws TError {
          assertTrue(new Term(10, 0).equals(new Term(10, 0)));
     @Test
     public void eq05() throws TError {
          assertTrue(new Term(-10, 2).equals(new Term(-10, 2)));
     @Test
     public void eq06() throws TError {
          assertTrue(new Term(0, 2).equals(new Term(0, 0)));
     @Test
     public void eq07() throws TError {
          assertTrue(new Term(0, 2).equals(new Term(0, 2)));
     @Test
     public void eq08() throws TError {
          assertTrue(new Term(10, 2).equals(new Term(10, 2)));
     @Test
     public void eq09() throws TError {
          assertFalse(new Term(-10, 0).equals(new Term(0, 0)));
     @Test
     public void eq10() throws TError {
          assertFalse(new Term(-10, 0).equals(new Term(10, 0)));
     @Test
     public void eq11() throws TError {
          assertFalse(new Term(0, 0).equals(new Term(-10, 0)));
     @Test
     public void eq12() throws TError {
          assertFalse(new Term(0, 0).equals(new Term(10, 0)));
     @Test
     public void eq13() throws TError {
          assertFalse(new Term(10, 0).equals(new Term(-10, 0)));
     @Test
     public void eq14() throws TError {
          assertFalse(new Term(10, 0).equals(new Term(0, 0)));
     @Test
     public void eq15() throws TError {
          assertFalse(new Term(-10, 0).equals(new Term(-10, 2)));
     @Test
     public void eq16() throws TError {
          assertFalse(new Term(10, 0).equals(new Term(10, 2)));
     @Test
     public void eq17() throws TError {
          assertFalse(new Term(10, 2).equals(null));
     @Test
     public void eq18() throws TError {
          assertFalse(new Term(10, 2).equals("junk"));
     @Test(expected = NegativeExponent.class)
     public void eq19() throws TError {
          assertFalse(new Term(10, 2).equals(new Term(10, -2)));
     @Test
     public void eq20() throws TError {
          assertFalse(new Term(0, 0).equals(null));
     @Test
     public void eq21() throws TError {
          assertEquals(Term.Zero, new Term(0, 1));
     @Test
     public void eq22() throws TError {
          assertEquals(Term.Zero, new Term(0, 0));
      * Check the predicate functions
      * zero1 isZero(zero) => true zero2 isZero(unit) => false zero3
      * isZero((0,5)) => true zero4 isZero((5,0)) => false
     @Test
     public void zero1() throws TError {
          assertTrue(Term.Zero.isZero());
     @Test
     public void zero2() throws TError {
          assertFalse(Term.Unit.isZero());
     @Test
     public void zero3() throws TError {
          assertTrue(new Term(0, 5).isZero());
     @Test
     public void zero4() throws TError {
          assertFalse(new Term(5, 0).isZero());
      * neg1 isNegative(zero) => false neg2 isNegative(unit) => false neg3
      * isNegative(-1,0) => true neg4 isNegative(min,2) => true neg5
      * isNegative(max,2) => false
     @Test
     public void neg1() throws TError {
          assertFalse(Term.Zero.isNegative());
     @Test
     public void neg2() throws TError {
          assertFalse(Term.Unit.isNegative());
     @Test
     public void neg3() throws TError {     
          assertTrue(new Term(-1, 2).isNegative());
     @Test
     public void neg4() throws TError {
          assertTrue(new Term(Integer.MIN_VALUE, 2).isNegative());
     @Test
     public void neg5() throws TError {
          assertFalse(new Term(Integer.MAX_VALUE, 2).isNegative());
      * const1 isConstant(zero) => true const2 isConstant(unit) => true const3
      * isConstant(0,5) => true const4 isConstant(5,1) => false
     @Test
     public void const1() throws TError {
          assertTrue(Term.Zero.isConstant());
     @Test
     public void const2() throws TError {
          assertTrue(Term.Unit.isConstant());
     @Test
     public void const3() throws TError {
          assertTrue(new Term(0, 5).isConstant());
     @Test
     public void const4() throws TError {
          assertFalse(new Term(5, 1).isConstant());
}and my term class so far is:
package poly;
public class Term {
     public Term(int c, int e) throws NegativeExponent {
     public boolean isConstant() {
     public boolean isZero() {
     public boolean isNegative() {
     public String toString() {
     public boolean equals(Object that) {
     public Term negate() throws CoefficientOverflow {
     public Term scale(int m) throws CoefficientOverflow {
     public Term times(Term that) throws CoefficientOverflow, ExponentOverflow {
     public Term add(Term that) throws CoefficientOverflow, IncompatibleTerms {
}I have a version where I can get about 50% of the tests to work, but I am not sure I am even doing it correctly. If someone could advise me, it would be really helpful. I am mainly stuck on the "equals" function and the "isZero" function.
Thank you!
Edited by: 968077 on 28-Oct-2012 08:12
Edited by: 968077 on 28-Oct-2012 08:13

Answer 1

Hi my term class is:
package poly;
public class Term
     final private int coef;
     final private int expo;
     private static Term zero, unit;
     static     {     try {      zero = new Term(0,0);          // the number zero
                              unit = new Term(1,0);          // the number one
                    catch (Exception e) {
                         // constructor will not throw an exception here anyway
      * @param c The coefficient of the new term
      * @param e The exponent of the new term (must be non-negative)
      * @throws NegativeExponent
     public Term(int c, int e) throws NegativeExponent {
          if (e <= 0) throw new NegativeExponent();
          coef = c;
          expo = (coef == 0) ? 1 : e;
     final public static Term Zero = zero;
     final public static Term Unit = unit;
      * Tests to see if the term represents a constant value
      * @return true if the term has a zero coefficient
     public boolean isConstant() {
          return false;  // unimplemented - default value false is only a placeholder
      * Tests to see if the term is equal to zero
      * @return true if the term is equal to zero
     public boolean isZero() {
          return false;  // unimplemented - default value false is only a placeholder
      * Tests to see if the term is negative
      * @return true if the coefficient is less than
     public boolean isNegative() {
          return false;  // unimplemented - default value false is only a placeholder
      * Represents a term as a string in a standard form: specification by example:
      * (An underscore represents any value)
      * (-7,0)          =>     "-7"
      * (-7,1)          =>     "-7x"
      * (-7,2)          =>     "-7^2"
      * (-1,0)          =>     "-1"
      * (-1,1)          =>     "-x"
      * (-1,2)          =>     "-x^2"
      * (0, _)          =>     "0"
      * (1,0)          =>     "1"
      * (1,1)          =>     "x"
      * (1,2)          =>     "x^2"
      * (7,0)          =>     "7"
      * (7,1)          =>     "7x"
      * (7,2)          =>     "7^2"
     @Override
     public String toString() {
          return null;  // unimplemented - default value null is only a placeholder
     @Override
     public boolean equals(Object other) {
          return false;  // unimplemented - default value false is only a placeholder
      * Negates a term
      * @return a new term with the original coefficient negated
      * @throws CoefficientOverflow
     public Term negate() throws CoefficientOverflow {
          return null;  // unimplemented - default value null is only a placeholder
      * Multiplies a term by a scalar amount
      * @param m The value to multiply by
      * @return a new Term whose coefficient is the original coefficient multiplied by scale
      * @throws CoefficientOverflow
     public Term scale(int m) throws CoefficientOverflow {
          return null;  // unimplemented - default value null is only a placeholder
      * Multiplies two terms together
      * @param that represents the term to be multiplied by
      * @return a new Term whose coefficient is the product of the two terms, and whose exponent is the sum of the two terms
      * @throws CoefficientOverflow
      * @throws ExponentOverflow
     public Term times(Term that) throws CoefficientOverflow, ExponentOverflow {
          return null;  // unimplemented - default value null is only a placeholder
      * Adds two terms together
      * Precondition: The two exponents must be equal for this to be valid
      * @param thats represent the term to be added
      * @return a new Term whose coefficient is the sum of the two original coefficients
      * @throws CoefficientOverflow
      * @throws IncompatibleTerms
     public Term add(Term that) throws CoefficientOverflow, IncompatibleTerms {
          return null;  // unimplemented - default value null is only a placeholder
}Thank you for the link, I will definitely check it out!