[utest commit] r11 - in trunk: . run src src/tests/utest/ui src/tests/utest/ui/common src/utest src/utest/ui/com...
codesite...@google.com
Date: Sat Aug 30 13:11:27 2008
New Revision: 11
Added:
trunk/run/ResultTest.hxml
trunk/src/tests/utest/ui/
trunk/src/tests/utest/ui/common/
trunk/src/tests/utest/ui/common/ResultTest.hx
trunk/src/utest/ui/common/ClassResult.hx (contents, props changed)
- copied, changed from r9, /trunk/src/utest/ui/common/TestClass.hx
trunk/src/utest/ui/common/FixtureResult.hx
trunk/src/utest/ui/common/PackageResult.hx (contents, props changed)
- copied, changed from r9, /trunk/src/utest/ui/common/TestPackage.hx
trunk/src/utest/ui/common/ResultAggregator.hx
Removed:
trunk/src/utest/ui/common/TestClass.hx
trunk/src/utest/ui/common/TestPackage.hx
Modified:
trunk/ (props changed)
trunk/src/ (props changed)
trunk/src/utest/Assert.hx
trunk/src/utest/ui/text/TraceReport.hx
Log:
implemented classes in utest.ui.common for the aggregation of test results
(some classes still require more tests)
changed the output of TraceReport using the new aggregator classes
Added: trunk/run/ResultTest.hxml
==============================================================================
--- (empty file)
+++ trunk/run/ResultTest.hxml Sat Aug 30 13:11:27 2008
@@ -0,0 +1,55 @@
+# Neko
+-neko ../bin/www/tests/main.n
+-main tests.utest.ui.common.ResultTest
+-debug
+-cp ../src
+
+--next
+# PHP
+-php ../bin/www/tests
+-main tests.utest.ui.common.ResultTest
+-debug
+-cp ../src
+--php-front main.php
+
+--next
+#
+-swf9 ../bin/www/tests/mainf9.swf
+-main tests.utest.ui.common.ResultTest
+-debug
+-cp ../src
+-swf-header 410:240:120:ffffff
+
+--next
+#
+-swf ../bin/www/tests/mainf8.swf
+-main tests.utest.ui.common.ResultTest
+-debug
+-cp ../src
+-swf-version 8
+-swf-header 410:240:120:ffffff
+
+--next
+#
+-swf ../bin/www/tests/mainf7.swf
+-main tests.utest.ui.common.ResultTest
+-debug
+-cp ../src
+-swf-version 7
+-swf-header 410:240:120:ffffff
+
+--next
+#
+-swf ../bin/www/tests/mainf6.swf
+-main tests.utest.ui.common.ResultTest
+-debug
+-cp ../src
+-swf-version 6
+-swf-header 410:240:120:ffffff
+
+--next
+# JS
+-js ../bin/www/tests/main.js
+-main tests.utest.ui.common.ResultTest
+-debug
+-cp ../src
Added: trunk/src/tests/utest/ui/common/ResultTest.hx
==============================================================================
--- (empty file)
+++ trunk/src/tests/utest/ui/common/ResultTest.hx Sat Aug 30 13:11:27 2008
@@ -0,0 +1,199 @@
+package tests.utest.ui.common;
+
+import utest.Assert;
+import utest.Assertation;
+import utest.Runner;
+import utest.ui.text.TraceReport;
+import utest.ui.common.PackageResult;
+import utest.ui.common.ClassResult;
+import utest.ui.common.FixtureResult;
+import utest.ui.common.ResultAggregator;
+
+class ResultTest {
+ public function new();
+
+ public static function main() {
+ var runner = new Runner();
+ runner.addCase(new ResultTest());
+ var report = new TraceReport(runner);
+ runner.run();
+ }
+
+ public function testFixtureResultEmpty() {
+ var r = new FixtureResult(0, "test");
+ Assert.equals(0, r.assertations);
+ Assert.equals(0, r.errors);
+ Assert.equals(0, r.failures);
+ Assert.equals(0, r.successes);
+ Assert.equals(0, r.warnings);
+ Assert.isFalse(r.hasAsyncError);
+ Assert.isFalse(r.hasErrors);
+ Assert.isFalse(r.hasFailures);
+ Assert.isFalse(r.hasSetupError);
+ Assert.isFalse(r.hasTeardownError);
+ Assert.isFalse(r.hasTestError);
+ Assert.isFalse(r.hasTimeoutError);
+ Assert.isFalse(r.hasWarnings);
+ Assert.isTrue(r.isOk);
+
+ var c = 0;
+ for(_ in r.iterator())
+ c++;
+ Assert.equals(0, c);
+ }
+
+ public function testFixtureResultAll() {
+ var r = new FixtureResult(0, "test");
+
+ r.add(Success(null));
+ Assert.isTrue(r.isOk);
+ Assert.equals(1, r.assertations);
+ Assert.equals(0, r.errors);
+ Assert.equals(0, r.failures);
+ Assert.equals(1, r.successes);
+ Assert.equals(0, r.warnings);
+
+ r.add(Success(null));
+ Assert.isTrue(r.isOk);
+ Assert.equals(2, r.assertations);
+
+ r.add(Failure(null, null));
+ Assert.isFalse(r.isOk);
+ Assert.equals(1, r.failures);
+ Assert.equals(2, r.successes);
+ Assert.equals(3, r.assertations);
+
+ r.add(Failure(null, null));
+ Assert.isFalse(r.isOk);
+ Assert.equals(2, r.failures);
+
+ r.add(Error(null));
+ Assert.equals(2, r.failures);
+ Assert.equals(1, r.errors);
+
+ r.add(SetupError(null));
+ Assert.equals(2, r.errors);
+ Assert.isTrue(r.hasSetupError);
+ Assert.isFalse(r.hasTeardownError);
+
+ r.add(TeardownError(null));
+ Assert.equals(3, r.errors);
+ Assert.isTrue(r.hasTeardownError);
+
+ r.add(TimeoutError(0));
+ Assert.equals(4, r.errors);
+ Assert.isTrue(r.hasTimeoutError);
+
+ r.add(AsyncError(null));
+ Assert.equals(5, r.errors);
+ Assert.isTrue(r.hasAsyncError);
+
+ Assert.equals(0, r.warnings);
+ Assert.isFalse(r.hasWarnings);
+ r.add(Warning(null));
+ Assert.equals(1, r.warnings);
+ Assert.isTrue(r.hasWarnings);
+
+ r.add(Warning(null));
+ Assert.equals(2, r.warnings);
+ Assert.isTrue(r.hasWarnings);
+
+ Assert.isFalse(r.isOk);
+ Assert.equals(11, r.assertations);
+
+ var c = 0;
+ for(_ in r.iterator())
+ c++;
+ Assert.equals(11, c);
+ }
+
+ function createFixture(method : String, ?assertations :
Array<Assertation>) {
+ var fix = new FixtureResult(1, method);
+ if(assertations != null)
+ for(assertation in assertations)
+ fix.add(assertation);
+ return fix;
+ }
+
+ function equalsArrays(a : Array<String>, b : Array<String>, id : String) {
+ if(a.length != b.length) {
+ Assert.fail("arrays length doesn't match");
+ return;
+ }
+ for(i in 0...a.length) {
+ Assert.equals(a[i], b[i], id+ ": error at index #"+i);
+ }
+ }
+
+ public function testClassResult() {
+ var r = new ClassResult("c", null, null);
+ Assert.equals("c", r.className);
+ Assert.equals(0, r.methods);
+ Assert.equals(0, r.successes);
+ Assert.equals(0, r.assertations);
+ Assert.equals(0, r.errors);
+ Assert.equals(0, r.failures);
+ Assert.equals(0, r.warnings);
+ Assert.isFalse(r.hasErrors);
+ Assert.isFalse(r.hasFailures);
+ Assert.isFalse(r.hasWarnings);
+ Assert.isFalse(r.hasSetup);
+ Assert.isFalse(r.hasTeardown);
+
+ r.add(createFixture("a", [Success(null)]));
+ Assert.equals(1, r.methods);
+ Assert.equals(1, r.successes);
+ Assert.equals(1, r.assertations);
+ Assert.equals(0, r.errors);
+ Assert.equals(0, r.failures);
+ Assert.equals(0, r.warnings);
+ Assert.isFalse(r.hasErrors);
+ Assert.isFalse(r.hasFailures);
+ Assert.isFalse(r.hasWarnings);
+
+ r.add(createFixture("b", [Warning(null), Success(null)]));
+ Assert.equals(2, r.methods);
+ Assert.equals(2, r.successes);
+ Assert.equals(3, r.assertations);
+ Assert.equals(1, r.warnings);
+ Assert.isFalse(r.hasErrors);
+ Assert.isFalse(r.hasFailures);
+ Assert.isTrue(r.hasWarnings);
+
+ equalsArrays(["a", "b"], r.methodNames(false), "warnings #1");
+ equalsArrays(["b", "a"], r.methodNames(), "warnings #2");
+ equalsArrays(["b", "a"], r.methodNames(true), "warnings #3");
+
+ r.add(createFixture("c", [Failure(null, null)]));
+ Assert.equals(3, r.methods);
+ Assert.equals(2, r.successes);
+ Assert.equals(4, r.assertations);
+ Assert.equals(1, r.failures);
+ Assert.isTrue(r.hasFailures);
+
+ equalsArrays(["a", "b", "c"], r.methodNames(false), "failures #1");
+ equalsArrays(["c", "b", "a"], r.methodNames(), "failures #2");
+
+ r.add(createFixture("d", [Error(null)]));
+ Assert.equals(4, r.methods);
+ Assert.equals(2, r.successes);
+ Assert.equals(5, r.assertations);
+ Assert.equals(1, r.failures);
+ Assert.equals(1, r.errors);
+ Assert.isTrue(r.hasErrors);
+ equalsArrays(["a", "b", "c", "d"], r.methodNames(false), "errors #1");
+ equalsArrays(["d", "c", "b", "a"], r.methodNames(), "errors #1");
+ }
+
+ public function testClassResultSetupTeardown() {
+ var r = new ClassResult("c", "s", null);
+ Assert.equals("s", r.setupName);
+ Assert.isTrue(r.hasSetup);
+ Assert.isFalse(r.hasTeardown);
+
+ r = new ClassResult("c", null, "t");
+ Assert.equals("t", r.teardownName);
+ Assert.isFalse(r.hasSetup);
+ Assert.isTrue(r.hasTeardown);
+ }
+}
\ No newline at end of file
Modified: trunk/src/utest/Assert.hx
==============================================================================
--- trunk/src/utest/Assert.hx (original)
+++ trunk/src/utest/Assert.hx Sat Aug 30 13:11:27 2008
@@ -53,6 +53,10 @@
isTrue(false, msg, pos);
}
+ public static function warn(msg) {
+ results.add(Warning(msg));
+ }
+
public static dynamic function createAsync(f : Void->Void, ?timeout :
Int) {
return function(){};
}
Copied: trunk/src/utest/ui/common/ClassResult.hx (from r9,
/trunk/src/utest/ui/common/TestClass.hx)
==============================================================================
--- /trunk/src/utest/ui/common/TestClass.hx (original)
+++ trunk/src/utest/ui/common/ClassResult.hx Sat Aug 30 13:11:27 2008
@@ -0,0 +1,109 @@
+package utest.ui.common;
+
+import utest.TestResult;
+
+class ClassResult {
+ public var executionTime(default, null) : Int;
+ var fixtures : Hash<FixtureResult>;
+ public var className(default, null) : String;
+ public var setupName(default, null) : String;
+ public var teardownName(default, null) : String;
+ public var hasSetup(default, null) : Bool;
+ public var hasTeardown(default, null) : Bool;
+
+ public var methods(default, null) : Int;
+ public var assertations(default, null) : Int;
+ public var successes(default, null) : Int;
+ public var failures(default, null) : Int;
+ public var errors(default, null) : Int;
+ public var warnings(default, null) : Int;
+
+ public var isOk(default, null) : Bool;
+ public var hasFailures(default, null) : Bool;
+ public var hasErrors(default, null) : Bool;
+ public var hasWarnings(default, null) : Bool;
+
+ public function new(className : String, setupName : String,
teardownName : String) {
+ executionTime = 0;
+ fixtures = new Hash();
+ this.className = className;
+ this.setupName = setupName;
+ hasSetup = setupName != null;
+ this.teardownName = teardownName;
+ hasTeardown = teardownName != null;
+
+ methods = 0;
+ assertations = 0;
+ successes = 0;
+ failures = 0;
+ errors = 0;
+ warnings = 0;
+
+ isOk = true;
+ hasFailures = false;
+ hasErrors = false;
+ hasWarnings = false;
+ }
+
+ public function add(result : FixtureResult) {
+ if(fixtures.exists(result.methodName)) throw "invalid duplicated fixture
result";
+ methods++;
+ fixtures.set(result.methodName, result);
+ executionTime += result.executionTime;
+ assertations += result.assertations;
+ successes += result.successes;
+ failures += result.failures;
+ errors += result.errors;
+ warnings += result.warnings;
+ isOk = isOk && result.isOk;
+ if(result.hasFailures)
+ hasFailures = true;
+ if(result.hasErrors)
+ hasErrors = true;
+ if(result.hasWarnings)
+ hasWarnings = true;
+ }
+
+ public function get(method : String) {
+ return fixtures.get(method);
+ }
+
+ public function exists(method : String) {
+ return fixtures.exists(method);
+ }
+
+ public function methodNames(errorsHavePriority = true) : Array<String> {
+ var names = [];
+ for(name in fixtures.keys())
+ names.push(name);
+ if(errorsHavePriority) {
+ var me = this;
+ names.sort(function(a, b) {
+ var afix = me.get(a);
+ var bfix = me.get(b);
+ if(afix.hasErrors) {
+ return (!bfix.hasErrors) ? -1 : (afix.errors == bfix.errors ?
Reflect.compare(a, b) : Reflect.compare(afix.errors, bfix.errors));
+ } else if(bfix.hasErrors) {
+ return 1;
+ } else if(afix.hasFailures) {
+ return (!bfix.hasFailures) ? -1 : (afix.failures == bfix.failures ?
Reflect.compare(a, b) : Reflect.compare(afix.failures, bfix.failures));
+ } else if(bfix.hasFailures) {
+ return 1;
+ } else if(afix.hasWarnings) {
+ return (!bfix.hasWarnings) ? -1 : (afix.warnings == bfix.warnings ?
Reflect.compare(a, b) : Reflect.compare(afix.warnings, bfix.warnings));
+ } else if(bfix.hasWarnings) {
+ return 1;
+ } else {
+ return Reflect.compare(a, b);
+ }
+ });
+ } else {
+ names.sort(function(a, b) {
+ return Reflect.compare(a, b);
+ });
+ }
+ return names;
+ }
+
+
+}
\ No newline at end of file
Added: trunk/src/utest/ui/common/FixtureResult.hx
==============================================================================
--- (empty file)
+++ trunk/src/utest/ui/common/FixtureResult.hx Sat Aug 30 13:11:27 2008
@@ -0,0 +1,95 @@
+package utest.ui.common;
+
+import utest.Assertation;
+
+class FixtureResult {
+ public var executionTime(default, null) : Int;
+ public var methodName(default, null) : String;
+
+ public var assertations(default, null) : Int;
+ public var successes(default, null) : Int;
+ public var failures(default, null) : Int;
+ public var errors(default, null) : Int;
+ public var warnings(default, null) : Int;
+
+ public var isOk(default, null) : Bool;
+ public var hasFailures(default, null) : Bool;
+ public var hasErrors(default, null) : Bool;
+ public var hasWarnings(default, null) : Bool;
+
+ public var hasTestError(default, null) : Bool;
+ public var hasSetupError(default, null) : Bool;
+ public var hasTeardownError(default, null) : Bool;
+ public var hasTimeoutError(default, null) : Bool;
+ public var hasAsyncError(default, null) : Bool;
+
+ var list(default, null) : List<Assertation>;
+ public function new(executionTime : Int, methodName : String) {
+ this.executionTime = executionTime;
+ this.methodName = methodName;
+ this.list = new List();
+
+ assertations = 0;
+ successes = 0;
+ failures = 0;
+ errors = 0;
+ warnings = 0;
+
+ isOk = true;
+ hasFailures = false;
+ hasErrors = false;
+ hasWarnings = false;
+
+ hasTestError = false;
+ hasSetupError = false;
+ hasTeardownError = false;
+ hasTimeoutError = false;
+ hasAsyncError = false;
+ }
+
+ public function iterator() {
+ return list.iterator();
+ }
+
+ public function add(assertation : Assertation) {
+ list.add(assertation);
+ assertations++;
+ switch(assertation) {
+ case Success(_):
+ successes++;
+ case Failure(_, _):
+ failures++;
+ hasFailures = true;
+ isOk = false;
+ case Error(_):
+ errors++;
+ hasErrors = true;
+ hasTestError = true;
+ isOk = false;
+ case SetupError(_):
+ errors++;
+ hasErrors = true;
+ hasSetupError = true;
+ isOk = false;
+ case TeardownError(_):
+ errors++;
+ hasErrors = true;
+ hasTeardownError = true;
+ isOk = false;
+ case TimeoutError(_):
+ errors++;
+ hasErrors = true;
+ hasTimeoutError = true;
+ isOk = false;
+ case AsyncError(_):
+ errors++;
+ hasErrors = true;
+ hasAsyncError = true;
+ isOk = false;
+ case Warning(_):
+ warnings++;
+ hasWarnings = true;
+ isOk = false;
+ }
+ }
+}
\ No newline at end of file
Copied: trunk/src/utest/ui/common/PackageResult.hx (from r9,
/trunk/src/utest/ui/common/TestPackage.hx)
==============================================================================
--- /trunk/src/utest/ui/common/TestPackage.hx (original)
+++ trunk/src/utest/ui/common/PackageResult.hx Sat Aug 30 13:11:27 2008
@@ -0,0 +1,218 @@
+/*
+* TODO: this class needs to be tested
+*/
+package utest.ui.common;
+
+import utest.TestResult;
+import utest.Assertation;
+
+class PackageResult {
+ public var executionTime(default, null) : Int;
+ public var packageName(default, null) : String;
+ var classes : Hash<ClassResult>;
+ var packages : Hash<PackageResult>;
+
+ public var assertations(default, null) : Int;
+ public var successes(default, null) : Int;
+ public var failures(default, null) : Int;
+ public var errors(default, null) : Int;
+ public var warnings(default, null) : Int;
+
+ public var isOk(default, null) : Bool;
+ public var hasFailures(default, null) : Bool;
+ public var hasErrors(default, null) : Bool;
+ public var hasWarnings(default, null) : Bool;
+
+ public function new(packageName : String) {
+ this.packageName = packageName;
+
+ executionTime = 0;
+ classes = new Hash();
+ packages = new Hash();
+
+ assertations = 0;
+ successes = 0;
+ failures = 0;
+ errors = 0;
+ warnings = 0;
+
+ isOk = true;
+ hasFailures = false;
+ hasErrors = false;
+ hasWarnings = false;
+ }
+
+ public function addResult(result : TestResult, flattenPackage : Bool) {
+ var pack = getOrCreatePackage(result.pack, flattenPackage, this);
+ var cls = getOrCreateClass(pack, result.cls, result.setup,
result.teardown);
+ var fix = createFixtureAndIncrement(result.method, result.executionTime,
result.assertations);
+ cls.add(fix);
+ }
+
+ function createFixtureAndIncrement(method : String, executionTime : Int,
assertations : Iterable<Assertation>) {
+ var f = new FixtureResult(executionTime, method);
+ for(assertation in assertations)
+ f.add(assertation);
+
+ executionTime += f.executionTime;
+ this.assertations += f.assertations;
+ successes += f.successes;
+ failures += f.failures;
+ errors += f.errors;
+ warnings += f.warnings;
+
+ isOk = isOk && f.isOk;
+ if(f.hasFailures)
+ hasFailures = true;
+ if(f.hasErrors)
+ hasErrors = true;
+ if(f.hasWarnings)
+ hasWarnings = true;
+
+ return f;
+ }
+
+ function getOrCreateClass(pack : PackageResult, cls : String, setup :
String, teardown : String) {
+ if(pack.existsClass(cls)) return pack.getClass(cls);
+ var c = new ClassResult(cls, setup, teardown);
+ pack.addClass(c);
+ return c;
+ }
+
+ function getOrCreatePackage(pack : String, flat : Bool, ref :
PackageResult) {
+ if(pack == null || pack == '') return ref;
+ if(flat) {
+ if(ref.existsPackage(pack))
+ return ref.getPackage(pack);
+ var p = new PackageResult(pack);
+ ref.addPackage(p);
+ return p;
+ } else {
+ var parts = pack.split('.');
+ for(part in parts) {
+ ref = getOrCreatePackage(part, true, ref);
+ }
+ return ref;
+ }
+ }
+
+ public function addClass(result : ClassResult) {
+ classes.set(result.className, result);
+
+ executionTime += result.executionTime;
+ assertations += result.assertations;
+ successes += result.successes;
+ failures += result.failures;
+ errors += result.errors;
+ warnings += result.warnings;
+
+ isOk = isOk && result.isOk;
+ if(result.hasFailures)
+ hasFailures = true;
+ if(result.hasErrors)
+ hasErrors = true;
+ if(result.hasWarnings)
+ hasWarnings = true;
+ }
+
+ public function addPackage(result : PackageResult) {
+ packages.set(result.packageName, result);
+
+ executionTime += result.executionTime;
+ assertations += result.assertations;
+ successes += result.successes;
+ failures += result.failures;
+ errors += result.errors;
+ warnings += result.warnings;
+
+ isOk = isOk && result.isOk;
+ if(result.hasFailures)
+ hasFailures = true;
+ if(result.hasErrors)
+ hasErrors = true;
+ if(result.hasWarnings)
+ hasWarnings = true;
+ }
+
+ public function existsPackage(name : String) {
+ return packages.exists(name);
+ }
+
+ public function existsClass(name : String) {
+ return classes.exists(name);
+ }
+
+ public function getPackage(name : String) {
+ return packages.get(name);
+ }
+
+ public function getClass(name : String) {
+ return classes.get(name);
+ }
+
+ public function classNames(errorsHavePriority = true) : Array<String> {
+ var names = [];
+ for(name in classes.keys())
+ names.push(name);
+ if(errorsHavePriority) {
+ var me = this;
+ names.sort(function(a, b) {
+ var afix = me.getClass(a);
+ var bfix = me.getClass(b);
+ if(afix.hasErrors) {
+ return (!bfix.hasErrors) ? -1 : (afix.errors == bfix.errors ?
Reflect.compare(a, b) : Reflect.compare(afix.errors, bfix.errors));
+ } else if(bfix.hasErrors) {
+ return 1;
+ } else if(afix.hasFailures) {
+ return (!bfix.hasFailures) ? -1 : (afix.failures == bfix.failures ?
Reflect.compare(a, b) : Reflect.compare(afix.failures, bfix.failures));
+ } else if(bfix.hasFailures) {
+ return 1;
+ } else if(afix.hasWarnings) {
+ return (!bfix.hasWarnings) ? -1 : (afix.warnings == bfix.warnings ?
Reflect.compare(a, b) : Reflect.compare(afix.warnings, bfix.warnings));
+ } else if(bfix.hasWarnings) {
+ return 1;
+ } else {
+ return Reflect.compare(a, b);
+ }
+ });
+ } else {
+ names.sort(function(a, b) {
+ return Reflect.compare(a, b);
+ });
+ }
+ return names;
+ }
+
+ public function packageNames(errorsHavePriority = true) : Array<String> {
+ var names = [];
+ for(name in packages.keys())
+ names.push(name);
+ if(errorsHavePriority) {
+ var me = this;
+ names.sort(function(a, b) {
+ var afix = me.getPackage(a);
+ var bfix = me.getPackage(b);
+ if(afix.hasErrors) {
+ return (!bfix.hasErrors) ? -1 : (afix.errors == bfix.errors ?
Reflect.compare(a, b) : Reflect.compare(afix.errors, bfix.errors));
+ } else if(bfix.hasErrors) {
+ return 1;
+ } else if(afix.hasFailures) {
+ return (!bfix.hasFailures) ? -1 : (afix.failures == bfix.failures ?
Reflect.compare(a, b) : Reflect.compare(afix.failures, bfix.failures));
+ } else if(bfix.hasFailures) {
+ return 1;
+ } else if(afix.hasWarnings) {
+ return (!bfix.hasWarnings) ? -1 : (afix.warnings == bfix.warnings ?
Reflect.compare(a, b) : Reflect.compare(afix.warnings, bfix.warnings));
+ } else if(bfix.hasWarnings) {
+ return 1;
+ } else {
+ return Reflect.compare(a, b);
+ }
+ });
+ } else {
+ names.sort(function(a, b) {
+ return Reflect.compare(a, b);
+ });
+ }
+ return names;
+ }
+}
\ No newline at end of file
Added: trunk/src/utest/ui/common/ResultAggregator.hx
==============================================================================
--- (empty file)
+++ trunk/src/utest/ui/common/ResultAggregator.hx Sat Aug 30 13:11:27 2008
@@ -0,0 +1,71 @@
+/*
+* TODO: this class needs to be tested
+*/
+package utest.ui.common;
+
+import utest.Runner;
+import utest.TestResult;
+
+class ResultAggregator {
+ var runner : Runner;
+ var flattenPackage : Bool;
+ public var root(default, null) : PackageResult;
+ public function new(runner : Runner, flattenPackage = false) {
+ if(runner == null) throw "runner argument is null";
+ this.flattenPackage = flattenPackage;
+ this.runner = runner;
+ runner.onStart = start;
+ runner.onProgress = progress;
+ runner.onComplete = complete;
+ }
+
+ function start(runner : Runner) {
+ root = new PackageResult(null);
+ onStart();
+ }
+
+ function getOrCreatePackage(pack : String, flat : Bool, ?ref :
PackageResult) {
+ if(ref == null) ref = root;
+ if(pack == null || pack == '') return ref;
+ if(flat) {
+ if(ref.existsPackage(pack))
+ return ref.getPackage(pack);
+ var p = new PackageResult(pack);
+ ref.addPackage(p);
+ return p;
+ } else {
+ var parts = pack.split('.');
+ for(part in parts) {
+ ref = getOrCreatePackage(part, true, ref);
+ }
+ return ref;
+ }
+ }
+
+ function getOrCreateClass(pack : PackageResult, cls : String, setup :
String, teardown : String) {
+ if(pack.existsClass(cls)) return pack.getClass(cls);
+ var c = new ClassResult(cls, setup, teardown);
+ pack.addClass(c);
+ return c;
+ }
+
+ function createFixture(result : TestResult) {
+ var f = new FixtureResult(result.executionTime, result.method);
+ for(assertation in result.assertations)
+ f.add(assertation);
+ return f;
+ }
+
+ function progress(runner : Runner, result : TestResult, done : Int,
totals : Int) {
+ root.addResult(result, flattenPackage);
+ onProgress(done, totals);
+ }
+
+ function complete(runner : Runner) {
+ onComplete(root);
+ }
+
+ public dynamic function onStart();
+ public dynamic function onComplete(pack : PackageResult);
+ public dynamic function onProgress(done : Int, totals : Int);
+}
\ No newline at end of file
Modified: trunk/src/utest/ui/text/TraceReport.hx
==============================================================================
--- trunk/src/utest/ui/text/TraceReport.hx (original)
+++ trunk/src/utest/ui/text/TraceReport.hx Sat Aug 30 13:11:27 2008
@@ -4,84 +4,118 @@
import utest.Runner;
import utest.TestResult;
+import utest.ui.common.ResultAggregator;
+import utest.ui.common.PackageResult;
-#if js
-import js.Dom;
-#end
class TraceReport {
+ var aggregator : ResultAggregator;
+ var newline : String;
+ var indent : String;
public function new(runner : Runner) {
- runner.onStart = start;
- runner.onComplete = complete;
- runner.onProgress = progress;
- }
-
- var counter : Int;
-
- static inline var STATUS_OK = 0;
- static inline var STATUS_WARNING = 1;
- static inline var STATUS_FAIL = 2;
- static inline var STATUS_ERROR = 3;
- function printResult(result : TestResult) {
- counter++;
- var status = STATUS_OK;
- var buff = '';
- var messages = '';
- for(assertation in result.assertations) {
- switch(assertation) {
- case Success(pos):
- buff += '.';
- case Failure(msg, pos):
- if(status < STATUS_FAIL) status = STATUS_FAIL;
- buff += 'F';
- messages += " line: " + pos.lineNumber + ", " + msg;
- case Error(e):
- if(status < STATUS_ERROR) status = STATUS_ERROR;
- buff += 'E';
- messages += " " + Std.string(e);
- case SetupError(e):
- if(status < STATUS_ERROR) status = STATUS_ERROR;
- buff += 'S';
- messages += " " + Std.string(e);
- case TeardownError(e):
- if(status < STATUS_ERROR) status = STATUS_ERROR;
- buff += 'T';
- messages += " " + Std.string(e);
- case TimeoutError(missedAsyncs):
- if(status < STATUS_ERROR) status = STATUS_ERROR;
- buff += 'O';
- messages += " " + "missed async calls: " + missedAsyncs;
- case AsyncError(e):
- if(status < STATUS_ERROR) status = STATUS_ERROR;
- buff += 'A';
- messages += " " + Std.string(e);
- case Warning(msg):
- if(status < STATUS_WARNING) status = STATUS_WARNING;
- buff += 'W';
- messages += " " + msg;
- }
+ aggregator = new ResultAggregator(runner, true);
+ aggregator.onComplete = complete;
+ aggregator.onStart = start;
+ aggregator.onProgress = progress;
+#if php
+ if(php.Lib.isCli()) {
+ newline = "\n";
+ indent = " ";
+ } else {
+ newline = "<br>";
+ indent = " ";
}
- var r = switch(status) {
- case STATUS_OK : "OK";
- case STATUS_WARNING : "WARNING";
- case STATUS_FAIL : "FAIL";
- case STATUS_ERROR : "ERROR";
- };
- trace(counter +". "+result.cls + "." + result.method + ": "+r + " " +
buff);
- if(messages != '') {
- trace(messages);
+#elseif neko
+ if(neko.Web.isModNeko) {
+ newline = "<br>";
+ indent = " ";
+ } else {
+ newline = "\n";
+ indent = " ";
}
+#else
+ newline = "\n";
+ indent = " ";
+#end
}
- function start(r : Runner) {
- counter = 0;
+ function indents(c : Int) {
+ var s = '';
+ for(_ in 0...c)
+ s += indent;
+ return s;
}
- function complete(r : Runner) {
- trace("[DONE]");
+ function start() {
+
+ }
+
+ function complete(result : PackageResult) {
+ var buf = new StringBuf();
+ buf.add("results: " + (result.isOk ? "ALL TESTS OK" : "SOME TESTS
FAILURES")+newline+" "+newline);
+
+ buf.add("assertations: " + result.assertations+newline);
+ buf.add("successes: " + result.successes+newline);
+ buf.add("errors: " + result.errors+newline);
+ buf.add("failures: " + result.failures+newline);
+ buf.add("warnings: " + result.warnings+newline);
+ buf.add("total time: " + result.executionTime+newline);
+ buf.add(newline);
+
+
+ for(pname in result.packageNames()) {
+ var pack = result.getPackage(pname);
+ for(cname in pack.classNames()) {
+ var cls = pack.getClass(cname);
+ buf.add(pname+newline);
+ for(mname in cls.methodNames()) {
+ var fix = cls.get(mname);
+ buf.add(indents(1)+mname+": ");
+ if(fix.isOk) {
+ buf.add("OK ");
+ } else if(fix.hasErrors) {
+ buf.add("ERROR ");
+ } else if(fix.hasFailures) {
+ buf.add("FAILURE ");
+ } else if(fix.hasWarnings) {
+ buf.add("WARNING ");
+ }
+ var messages = '';
+ for(assertation in fix.iterator()) {
+ switch(assertation) {
+ case Success(pos):
+ buf.add('.');
+ case Failure(msg, pos):
+ buf.add('F');
+ messages += indents(2)+"line: " + pos.lineNumber + ", " + msg +
newline;
+ case Error(e):
+ buf.add('E');
+ messages += indents(2)+ Std.string(e) + newline;
+ case SetupError(e):
+ buf.add('S');
+ messages += indents(2)+ Std.string(e) + newline;
+ case TeardownError(e):
+ buf.add('T');
+ messages += indents(2)+ Std.string(e) + newline;
+ case TimeoutError(missedAsyncs):
+ buf.add('O');
+ messages += indents(2)+ "missed async calls: " + missedAsyncs +
newline;
+ case AsyncError(e):
+ buf.add('A');
+ messages += indents(2)+ Std.string(e) + newline;
+ case Warning(msg):
+ buf.add('W');
+ messages += indents(2)+ msg + newline;
+ }
+ }
+ buf.add(newline);
+ buf.add(messages);
+ }
+ }
+ }
+ trace(buf.toString());
}
- function progress(r : Runner, result : TestResult, done : Int, totals :
Int) {
- printResult(result);
+ function progress(done : Int, totals : Int) {
}
}