asunit4 4.2.2.pre → 4.2.3.pre

data/test/asunit/printers/XMLPrinterTest.as

@@ -0,0 +1,131 @@
+package asunit.printers {
+    
+    import asunit.asserts.*;
+    import asunit.errors.AssertionFailedError;
+    import asunit.framework.ITestFailure;
+    import asunit.framework.TestCase;
+
+    import asunit.framework.IResult;
+    import asunit.framework.ITestSuccess;
+    import asunit.framework.ITestWarning;
+    import asunit.framework.Method;
+    import asunit.framework.Result;
+    import asunit.framework.TestFailure;
+    import asunit.framework.TestSuccess;
+    import asunit.framework.TestWarning;
+
+    import p2.reflect.Reflection;
+    import p2.reflect.ReflectionMethod;
+
+
+    public class XMLPrinterTest extends TestCase {
+
+        private var printer:XMLPrinter;
+        private var test:*;
+        private var testSuccess:ITestSuccess;
+        private var testError:ITestFailure;
+        private var testFailure:ITestFailure;
+        private var testResult:IResult;
+        private var testWarning:ITestWarning;
+
+        public function XMLPrinterTest(method:String=null) {
+            super(method);
+        }
+
+        override protected function setUp():void {
+            super.setUp();
+            printer    = new XMLPrinter();
+            printer.traceResults = false;
+
+            test        = new FakeTestCase();
+            var reflect:Reflection = Reflection.create(test);
+            var methodReflection:ReflectionMethod = reflect.methods[0];
+            var method:Method = new Method(test, methodReflection);
+
+            testResult  = new Result();
+            testError   = new TestFailure(test, 'testSomethingThatErrors', new Error('Fake Error'));
+            testFailure = new TestFailure(test, 'testSomethingThatFails', new AssertionFailedError('Fake Failure'));
+            testSuccess = new TestSuccess(test, 'testSomethingThatSucceeds');
+            testWarning = new TestWarning(test, method);
+            testResult.addListener(printer);
+        }
+
+        private function executeTestWith(handler:Function):void {
+            testResult.onRunStarted();
+            testResult.onTestStarted(test);
+            handler.call(this);
+            testResult.onTestCompleted(test);
+            testResult.onRunCompleted(null);
+        }
+
+        private function executeASucceedingTest():String {
+            executeTestWith(function():void {
+                testResult.onTestSuccess(testSuccess);
+            });
+            return printer.toString();
+        }
+
+        private function executeASucceedingTestWithWarning():String {
+            executeTestWith(function():void {
+                testResult.onWarning(testWarning);
+                testResult.onTestSuccess(testSuccess);
+            });
+            testResult.onRunStarted();
+            testResult.onTestStarted(test);
+            testResult.onTestCompleted(test);
+            testResult.onRunCompleted(null);
+            return printer.toString();
+        }
+
+        private function executeAFailingTest():String {
+            executeTestWith(function():void {
+                testResult.onTestFailure(testFailure);
+            });
+            return printer.toString();
+        }
+
+        private function executeAnErrorTest():String {
+            executeTestWith(function():void {
+                testResult.onTestFailure(testError);
+            });
+            return printer.toString();
+        }
+
+        public function testPrinterStartAndFinish():void {
+            var actual:String = executeASucceedingTest();
+            assertMatches(/<TestResults>/, actual);
+            assertMatches(/startTestRun/, actual);
+            assertMatches(/<endOfTestRun \/>/, actual);
+            assertMatches(/<\/TestResults>/, actual);
+
+            assertMatches(/status='success'/, actual);
+        }
+
+        public function testPrinterFailure():void {
+            var actual:String = executeAFailingTest();
+            assertMatches(/status='failure'/, actual);
+            assertMatches(/stackTraceInfo/, actual);
+            assertMatches(/asunit\/printers\/XMLPrinterTest.as/, actual);
+        }
+
+        public function testPrinterError():void {
+            var actual:String = executeAnErrorTest();
+            assertMatches(/status='error'/, actual);
+            assertMatches(/stackTraceInfo/, actual);
+            assertMatches(/asunit\/printers\/XMLPrinterTest.as/, actual);
+        }
+
+        public function testPrinterWarning():void {
+            var actual:String = executeASucceedingTestWithWarning();
+            assertMatches(/status='warning'/, actual);
+            assertMatches(/status='success'/, actual);
+        }
+    }
+}
+
+class FakeTestCase {
+
+    [Test]
+    public function testSomething():void {
+    }
+}

data/test/asunit/runners/LegacyRunnerTest.as

@@ -5,9 +5,9 @@ package asunit.runners {
     import asunit.framework.Result;
     import asunit.framework.TestCase;
     import asunit.support.LegacyTestCase;
+	import flash.display.Sprite;
 
     import flash.events.Event;
-    import asunit.framework.CallbackBridge;
 
     public class LegacyRunnerTest extends TestCase {
 
@@ -30,11 +30,11 @@ package asunit.runners {
 
         public function testSimpleSubclass():void {
             var handler:Function = function(event:Event):void {
-                assertEquals(0, testRunner.bridge.failureCount);
-                assertEquals(2, testRunner.bridge.runCount);
+                assertEquals(0, testRunner.result.failureCount);
+                assertEquals(2, testRunner.result.runCount);
             };
             testRunner.addEventListener(Event.COMPLETE, addAsync(handler));
-            testRunner.run(LegacyTestCase);
+            testRunner.run(LegacyTestCase, null, new Sprite());
         }
     }
 }

data/test/asunit/runners/SuiteRunnerTest.as

@@ -5,6 +5,7 @@ package asunit.runners {
     import asunit.framework.Result;
     import asunit.support.DoubleFailSuite;
     import asunit.support.InjectionVerification;
+	import flash.display.Sprite;
 
     import flash.events.Event;
 
@@ -12,12 +13,14 @@ package asunit.runners {
 
         [Inject]
         public var async:IAsync;
-
-        [Inject]
-        public var suiteRunner:SuiteRunner;
-
-        [Inject]
-        public var runnerResult:Result;
+        private var suiteRunner:SuiteRunner;
+        private var runnerResult:Result;
+		
+        [Before]
+        public function setUp():void {
+			runnerResult = new Result();
+			suiteRunner = new SuiteRunner(null, runnerResult);
+		}
 
         public function testRunTriggersCompleteEvent():void {
             suiteRunner.addEventListener(Event.COMPLETE, async.add(checkResultWasNotSuccessful));
@@ -31,7 +34,7 @@ package asunit.runners {
         [Test]
         public function testCanHandATestToSuiteRunner():void {
             suiteRunner.addEventListener(Event.COMPLETE, async.add());
-            suiteRunner.run(InjectionVerification);
+            suiteRunner.run(InjectionVerification, null, new Sprite());
             assertFalse(runnerResult.wasSuccessful);
         }
     }

data/test/asunit/runners/TestRunnerAsyncMethodTest.as

@@ -1,7 +1,6 @@
 package asunit.runners {
 
     import asunit.asserts.*;
-    import asunit.framework.CallbackBridge;
     import asunit.framework.TestCase;
     import asunit.util.Iterator;
 
@@ -18,9 +17,12 @@ package asunit.runners {
 
         [Inject]
         public var async:IAsync;
-
-        [Inject]
-        public var runner:TestRunner;
+        private var runner:TestRunner;
+		
+		[Before]
+		public function before():void {
+			runner = new TestRunner();
+		}
 
         [Test]
         public function asyncShouldWork():void {
@@ -35,7 +37,7 @@ package asunit.runners {
         }
         
         private function ensureRunnerHasNotYetFailed(e:Event):void {
-            assertFalse('runner result has not failed', runner.bridge.failureEncountered);
+            assertFalse('runner result has not failed', runner.result.failureEncountered);
         }
         
         [Test]
@@ -45,8 +47,8 @@ package asunit.runners {
         }
         
         private function checkResultForIllegalOperationError(e:Event):void {
-            assertEquals('number of errors', 1, runner.bridge.errors.length);
-            var failure0:TestFailure = runner.bridge.errors[0] as TestFailure;
+            assertEquals('number of errors', 1, runner.result.errors.length);
+            var failure0:TestFailure = runner.result.errors[0] as TestFailure;
             assertEquals('exception type', 'flash.errors::IllegalOperationError', getQualifiedClassName(failure0.thrownException));
             assertEquals('failed method name', 'shouldFailForBeingTooSlow', failure0.failedMethod);
         }

data/test/asunit/runners/TestRunnerErrorMethodTest.as

@@ -40,7 +40,7 @@ package asunit.runners {
 		}
 		
 		private function check_Result_has_one_error(e:Event):void {
-            var runnerResult:IResult = runner.bridge;
+            var runnerResult:IResult = runner.result;
 			assertFalse('runnerResult.wasSuccessful', runnerResult.wasSuccessful);
 			
 			assertEquals('one error in testResult',   1, runnerResult.errorCount);

data/test/asunit/runners/TestRunnerExpectsErrorTest.as

@@ -42,7 +42,7 @@ package asunit.runners {
 		}
 		
 		private function check_Result_has_no_errors(e:Event):void {
-            var runnerResult:IResult = runner.bridge;
+            var runnerResult:IResult = runner.result;
 			assertEquals('no errors in testResult',   0, runnerResult.errorCount);
 			assertEquals('no failures in testResult', 0, runnerResult.failureCount);
 		}
@@ -53,7 +53,7 @@ package asunit.runners {
 		}
 		
 		private function check_Result_has_one_assertion_failure(e:Event):void {
-            var runnerResult:IResult = runner.bridge;
+            var runnerResult:IResult = runner.result;
 			assertFalse(runnerResult.wasSuccessful);
 			
 			assertEquals('one failure in testResult', 1, runnerResult.failureCount);

data/test/asunit/runners/TestRunnerExpectsErrorWithMessageTest.as

@@ -0,0 +1,125 @@
+package asunit.runners {
+
+	import asunit.errors.AssertionFailedError;
+	import asunit.framework.TestCase;
+
+	import asunit.framework.IResult;
+	import asunit.framework.Result;
+	import asunit.framework.TestFailure;
+
+	import flash.events.Event;
+
+	public class TestRunnerExpectsErrorWithMessageTest extends TestCase {
+
+		private var runner:TestRunner;
+		private var successTest:Class;
+		private var throwNothingTest:Class;
+		private var throwWrongErrorTest:Class;
+		private var throwWrongMessageTest:Class;
+
+		private var failedTest:Class;
+		private var failedMethod:String;
+
+		public function TestRunnerExpectsErrorWithMessageTest(testMethod:String = null) {
+			super(testMethod);
+		}
+
+		protected override function setUp():void {
+            super.setUp();
+			runner = new TestRunner();
+			successTest = TestExpectsArgumentErrorAndThrowsIt;
+			throwNothingTest = TestExpectsArgumentErrorButThrowsNothing;
+			throwWrongErrorTest = TestExpectsArgumentErrorButThrowsWrongError;
+			throwWrongMessageTest = TestExpectsArgumentErrorButThrowsWrongMessage;
+		}
+
+		protected override function tearDown():void {
+            super.tearDown();
+			runner                = null;
+			successTest           = null;
+			throwNothingTest      = null;
+			throwWrongErrorTest   = null;
+			throwWrongMessageTest = null;
+			failedTest            = null;
+			failedMethod          = null;
+		}
+
+		public function test_method_expects_specific_error_and_throws_it_yields_successful_test_result():void {
+			runner.addEventListener(Event.COMPLETE, addAsync(check_Result_has_no_errors, 100));
+			runner.run(successTest);
+		}
+		
+		public function test_method_expects_specific_error_but_nothing_thrown_yields_assertion_failure():void {
+			failedTest   = throwNothingTest;
+			failedMethod = "fail_by_throwing_nothing";
+			runner.addEventListener(Event.COMPLETE, addAsync(check_Result_has_one_assertion_failure, 100));
+			runner.run(throwNothingTest);
+		}
+		
+		public function test_method_expects_specific_error_but_wrong_one_thrown_yields_assertion_failure():void {
+			failedTest   = throwWrongErrorTest;
+			failedMethod = "fail_by_throwing_wrong_error";
+			runner.addEventListener(Event.COMPLETE, addAsync(check_Result_has_one_assertion_failure, 100));
+			runner.run(throwWrongErrorTest);
+		}
+
+		public function test_method_expects_specific_message_but_wrong_one_thrown_yields_assertion_failure():void {
+			failedTest   = throwWrongMessageTest;
+			failedMethod = "fail_by_throwing_wrong_message";
+			runner.addEventListener(Event.COMPLETE, addAsync(check_Result_has_one_assertion_failure, 100));
+			runner.run(throwWrongMessageTest);
+		}
+
+
+		private function check_Result_has_no_errors(e:Event):void {
+            var runnerResult:IResult = runner.result;
+			assertEquals('no errors in testResult',   0, runnerResult.errorCount);
+			assertEquals('no failures in testResult', 0, runnerResult.failureCount);
+		}
+
+		private function check_Result_has_one_assertion_failure(e:Event):void {
+            var runnerResult:IResult = runner.result;
+			assertFalse(runnerResult.wasSuccessful);
+			
+			assertEquals('one failure in testResult', 1, runnerResult.failureCount);
+			assertEquals('no errors in testResult',   0, runnerResult.errorCount);
+			
+			var failure0:TestFailure = runnerResult.failures[0] as TestFailure;
+			assertTrue('thrownException is correct type', failure0.thrownException is AssertionFailedError);
+			assertTrue('failedTest is instance of the test class', failure0.failedTest is failedTest);
+			assertSame('failedMethod name', failedMethod, failure0.failedMethod);
+		}
+	}
+}
+
+class TestExpectsArgumentErrorAndThrowsIt {
+	
+	[Test(expects="ArgumentError", message="generated by TestExpectsArgumentError")]
+	public function throwArgumentError():void {
+		throw new ArgumentError('generated by TestExpectsArgumentError');
+	}
+}
+
+class TestExpectsArgumentErrorButThrowsNothing {
+	
+	[Test(expects="ArgumentError", message="generated by TestExpectsArgumentErrorButThrowsNothing")]
+	public function fail_by_throwing_nothing():void {
+	}
+}
+
+class TestExpectsArgumentErrorButThrowsWrongError {
+	
+	[Test(expects="ArgumentError", message="generated by TestExpectsArgumentErrorButThrowsWrongError")]
+	public function fail_by_throwing_wrong_error():void {
+		throw new Error('generated by TestExpectsArgumentErrorButThrowsWrongError');
+	}
+}
+
+class TestExpectsArgumentErrorButThrowsWrongMessage {
+	
+	[Test(expects="Error", message="foo")]
+	public function fail_by_throwing_wrong_message():void {
+		throw new Error('bar');
+	}
+}
+

data/test/asunit/runners/TestRunnerIgnoredMethodTest.as

@@ -2,7 +2,6 @@ package asunit.runners {
 
     import asunit.framework.TestCase;
 
-    import asunit.framework.Result;
     import asunit.support.IgnoredMethod;
 
     import flash.events.Event;
@@ -34,8 +33,8 @@ package asunit.runners {
         }
         
         private function checkResultHasOneIgnoredMethod(e:Event):void {
-            assertFalse('runnerResult.failureEncountered', runner.bridge.failureEncountered);
-            assertEquals('one ignored test in result', 1, runner.bridge.ignoredTests.length);
+            assertFalse('runnerResult.failureEncountered', runner.result.failureEncountered);
+            assertEquals('one ignored test in result', 1, runner.result.ignoredTests.length);
         }
     }
 }

data/test/asunit/runners/TestRunnerTest.as

@@ -8,8 +8,6 @@ package asunit.runners {
     import asunit.framework.Result;
     import asunit.framework.TestCase;
     import asunit.framework.TestFailure;
-    import asunit.support.AnnotatedSubClass;
-    import asunit.support.InjectTimeoutOnAsync;
     import asunit.support.InjectionFailure;
     import asunit.support.InjectionVerification;
     import asunit.support.MultiMethod;
@@ -97,10 +95,10 @@ package asunit.runners {
         }
         
         private function checkResultWasNotSuccessful(e:Event):void {
-            assertTrue(runner.bridge.failureEncountered);
-            assertFalse(runner.bridge.wasSuccessful);
+            assertTrue(runner.result.failureEncountered);
+            assertFalse(runner.result.wasSuccessful);
             
-            var failures:Array = runner.bridge.failures;
+            var failures:Array = runner.result.failures;
             assertEquals('one failure in testResult', 1, failures.length);
             
             var failure0:ITestFailure = failures[0] as TestFailure;
@@ -143,28 +141,7 @@ package asunit.runners {
         [Test]
         public function shouldInjectTypes():void {
             runner.run(InjectionVerification, null, context);
-            assertFalse("Should not have encountered failures: " + runner.bridge.failures.join("\n\n"), runner.bridge.failureEncountered);
-        }
-
-        [Test]
-        public function shouldInjectWithUnknownAttribute():void {
-            runner.run(InjectionFailure);
-            var warnings:Array = runner.bridge.warnings;
-            assertEquals(1, warnings.length);
-        }
-
-        [Test]
-        public function shouldInjectAsyncTimeout():void {
-            var async:IAsync = runner.async;
-            assertEquals(Async.DEFAULT_TIMEOUT, async.timeout);
-            runner.run(InjectTimeoutOnAsync);
-            assertEquals(5, async.timeout);
-        }
-
-        [Test]
-        public function annotationsOnSuperClassShouldBeRespected():void {
-            runner.run(AnnotatedSubClass);
-            assertFalse("Should not have failures: " + runner.bridge.failures.join("\n\n"), runner.bridge.failureEncountered);
+            assertFalse("Should not have encountered failures: " + runner.result.failures.join("\n\n"), runner.result.failureEncountered);
         }
     }
 }