Merge pull request #9 from onlyliuxin/master

lite-junit v1

liuxin/ood/ood-assignment/src/main/java/org/litejunit/v1/Assert.java

@@ -0,0 +1,225 @@
+package org.litejunit.v1;
+
+/**
+ * A set of assert methods.
+ */
+
+public class Assert {
+	/**
+	 * Protect constructor since it is a static only class
+	 */
+	protected Assert() {
+	}
+
+	/**
+	 * Asserts that a condition is true. If it isn't it throws
+	 * an AssertionFailedError with the given message.
+	 */
+	static public void assertTrue(String message, boolean condition) {
+		if (!condition)
+			fail(message);
+	}
+	/**
+	 * Asserts that a condition is true. If it isn't it throws
+	 * an AssertionFailedError.
+	 */
+	static public void assertTrue(boolean condition) {
+		assertTrue(null, condition);
+	}
+	/**
+	 * Fails a test with the given message. 
+	 */
+	static public void fail(String message) {
+		throw new AssertionFailedError(message);
+	}
+	/**
+	 * Fails a test with no message. 
+	 */
+	static public void fail() {
+		fail(null);
+	}
+	/**
+	 * Asserts that two objects are equal. If they are not
+	 * an AssertionFailedError is thrown.
+	 */
+	static public void assertEquals(String message, Object expected, Object actual) {
+		if (expected == null && actual == null)
+			return;
+		if (expected != null && expected.equals(actual))
+			return;
+		failNotEquals(message, expected, actual);
+	}
+	/**
+	 * Asserts that two objects are equal. If they are not
+	 * an AssertionFailedError is thrown.
+	 */
+	static public void assertEquals(Object expected, Object actual) {
+	    assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two doubles are equal concerning a delta. If the expected
+	 * value is infinity then the delta value is ignored.
+	 */
+	static public void assertEquals(String message, double expected, double actual, double delta) {
+		// handle infinity specially since subtracting to infinite values gives NaN and the
+		// the following test fails
+		if (Double.isInfinite(expected)) {
+			if (!(expected == actual))
+				failNotEquals(message, new Double(expected), new Double(actual));
+		} else if (!(Math.abs(expected-actual) <= delta)) // Because comparison with NaN always returns false
+			failNotEquals(message, new Double(expected), new Double(actual));
+	}
+	/**
+	 * Asserts that two doubles are equal concerning a delta. If the expected
+	 * value is infinity then the delta value is ignored.
+	 */
+	static public void assertEquals(double expected, double actual, double delta) {
+	    assertEquals(null, expected, actual, delta);
+	}
+	/**
+	 * Asserts that two floats are equal concerning a delta. If the expected
+	 * value is infinity then the delta value is ignored.
+	 */
+	static public void assertEquals(String message, float expected, float actual, float delta) {
+ 		// handle infinity specially since subtracting to infinite values gives NaN and the
+		// the following test fails
+		if (Float.isInfinite(expected)) {
+			if (!(expected == actual))
+				failNotEquals(message, new Float(expected), new Float(actual));
+		} else if (!(Math.abs(expected-actual) <= delta))
+      		failNotEquals(message, new Float(expected), new Float(actual));
+	}
+	/**
+	 * Asserts that two floats are equal concerning a delta. If the expected
+	 * value is infinity then the delta value is ignored.
+	 */
+	static public void assertEquals(float expected, float actual, float delta) {
+		assertEquals(null, expected, actual, delta);
+	}
+	/**
+	 * Asserts that two longs are equal.
+	 */
+	static public void assertEquals(String message, long expected, long actual) {
+	    assertEquals(message, new Long(expected), new Long(actual));
+	}
+	/**
+	 * Asserts that two longs are equal.
+	 */
+	static public void assertEquals(long expected, long actual) {
+	    assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two booleans are equal.
+	 */
+	static public void assertEquals(String message, boolean expected, boolean actual) {
+    		assertEquals(message, new Boolean(expected), new Boolean(actual));
+  	}
+	/**
+	 * Asserts that two booleans are equal.
+ 	 */
+	static public void assertEquals(boolean expected, boolean actual) {
+		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two bytes are equal.
+	 */
+  	static public void assertEquals(String message, byte expected, byte actual) {
+		assertEquals(message, new Byte(expected), new Byte(actual));
+	}
+	/**
+   	 * Asserts that two bytes are equal.
+	 */
+	static public void assertEquals(byte expected, byte actual) {
+		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two chars are equal.
+	 */
+  	static public void assertEquals(String message, char expected, char actual) {
+    		assertEquals(message, new Character(expected), new Character(actual));
+  	}
+	/**
+	 * Asserts that two chars are equal.
+	 */
+  	static public void assertEquals(char expected, char actual) {
+		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two shorts are equal.
+	 */
+	static public void assertEquals(String message, short expected, short actual) {
+    		assertEquals(message, new Short(expected), new Short(actual));
+	}
+  	/**
+	 * Asserts that two shorts are equal.
+	 */
+	static public void assertEquals(short expected, short actual) {
+		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that two ints are equal.
+	 */
+  	static public void assertEquals(String message, int expected, int actual) {
+		assertEquals(message, new Integer(expected), new Integer(actual));
+  	}
+  	/**
+   	 * Asserts that two ints are equal.
+	 */
+  	static public void assertEquals(int expected, int actual) {
+  		assertEquals(null, expected, actual);
+	}
+	/**
+	 * Asserts that an object isn't null.
+	 */
+	static public void assertNotNull(Object object) {
+		assertNotNull(null, object);
+	}
+	/**
+	 * Asserts that an object isn't null.
+	 */
+	static public void assertNotNull(String message, Object object) {
+		assertTrue(message, object != null); 
+	}
+	/**
+	 * Asserts that an object is null.
+	 */
+	static public void assertNull(Object object) {
+		assertNull(null, object);
+	}
+	/**
+	 * Asserts that an object is null.
+	 */
+	static public void assertNull(String message, Object object) {
+		assertTrue(message, object == null); 
+	}
+	/**
+	 * Asserts that two objects refer to the same object. If they are not
+	 * an AssertionFailedError is thrown.
+	 */
+	static public void assertSame(String message, Object expected, Object actual) {
+		if (expected == actual)
+			return;
+		failNotSame(message, expected, actual);
+	}
+	/**
+	 * Asserts that two objects refer to the same object. If they are not
+	 * the same an AssertionFailedError is thrown.
+	 */
+	static public void assertSame(Object expected, Object actual) {
+	    assertSame(null, expected, actual);
+	}
+
+	static private void failNotEquals(String message, Object expected, Object actual) {
+		String formatted= "";
+		if (message != null)
+			formatted= message+" ";
+		fail(formatted+"expected:<"+expected+"> but was:<"+actual+">");
+	}
+
+	static private void failNotSame(String message, Object expected, Object actual) {
+		String formatted= "";
+		if (message != null)
+			formatted= message+" ";
+		fail(formatted+"expected same");
+	}
+}

liuxin/ood/ood-assignment/src/main/java/org/litejunit/v1/AssertionFailedError.java

@@ -0,0 +1,13 @@
+package org.litejunit.v1;
+
+/**
+ * Thrown when an assertion failed.
+ */
+public class AssertionFailedError extends Error {
+
+	public AssertionFailedError () {
+	}
+	public AssertionFailedError (String message) {
+		super (message);
+	}
+}

liuxin/ood/ood-assignment/src/main/java/org/litejunit/v1/Calculator.java

@@ -0,0 +1,22 @@
+package org.litejunit.v1;
+
+public class Calculator {
+
+	private int result = 0;
+	public  void add(int x){
+		result += x;
+	}
+	public void subtract(int x){
+		result -=x;
+	}
+
+	public int getResult(){
+		return this.result;
+	}
+	public static void main(String[] args){
+		Calculator calculator = new Calculator();
+		calculator.add(10);
+		calculator.subtract(5);		
+		System.out.println(calculator.getResult());
+	}
+}

liuxin/ood/ood-assignment/src/main/java/org/litejunit/v1/CalculatorTest.java

@@ -0,0 +1,65 @@
+package org.litejunit.v1;
+
+
+public class CalculatorTest extends TestCase {	
+	public CalculatorTest(String name) {
+		super(name);
+
+	}
+	Calculator calculator =null;
+	public void setUp(){
+		calculator = new Calculator();
+	}
+	public void tearDown(){
+		calculator = null;
+	}
+	public void testAdd(){
+
+		calculator.add(10);
+		assertEquals(10,calculator.getResult());
+	}	
+	public void testSubtract(){
+		calculator.add(10);
+		calculator.subtract(5);
+		assertEquals(4,calculator.getResult());
+	}
+
+	public static void main(String[] args){
+		TestSuite ts = new TestSuite(CalculatorTest.class);
+		TestResult tr = new TestResult();
+		ts.run(tr);
+		System.out.println(tr.wasSuccessful());
+		for(TestFailure failure : tr.failures){
+			System.err.println(failure);
+		}
+
+		/*{
+		TestCase tc1 = new CalculatorTest("testAdd"){
+			protected void runTest() {
+				testAdd();
+			}
+		};
+		
+		TestCase tc2 = new CalculatorTest("testSubtract"){
+			protected void runTest() {
+				testSubtract();
+			}
+		};
+		tc1.run();
+		tc2.run();
+		}
+		
+		
+		TestSuite ts = new TestSuite();
+		ts.addTest(new CalculatorTest("testAdd"));
+		ts.addTest(new CalculatorTest("testSubtract"));
+		
+		
+		{
+			TestCase tc1 = new CalculatorTest("test1");
+			TestCase tc2 = new CalculatorTest("test2");
+			tc1.run();
+			tc2.run();
+		}*/
+	}
+}

liuxin/ood/ood-assignment/src/main/java/org/litejunit/v1/Test.java

@@ -0,0 +1,6 @@
+package org.litejunit.v1;
+
+public interface Test {
+	public abstract int countTestCases();
+	public void run(TestResult tr);
+}