asproject 0.1.21

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/framework/Assertion.as

@@ -0,0 +1,27 @@
+
+class com.asunit.framework.Assertion {
+	private var className:String;
+	private var methodName:String;
+	private var message:String;
+	private var assertion:String;
+	private var passed:Boolean;
+
+	private function Assertion(cName:String, mName:String, msg:String, assert:String)
+	{
+		className = cName;
+		methodName = mName;
+		message = msg;
+		assertion = assert;
+	}
+
+	public function toString():String
+	{
+		var str:String = "";
+		for(var i:String in this) {
+			if(!(this[i] instanceof Function)) {
+				str += i + " : " + this[i] + "\n";
+			}
+		}
+		return str;
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/framework/Reflection.as

@@ -0,0 +1,68 @@
+
+import com.asunit.framework.*;
+
+class com.asunit.framework.Reflection {
+	private var visitedObjects:Array;
+	private var qualifiedName:String;
+
+	public static function getQualifiedName(ref:Object)
+	{
+		return new Reflection(ref).toString();
+	}
+
+	// Use static Constructor / getQualifiedName
+	private function Reflection(ref:Object)
+	{
+		visitedObjects = new Array();
+		qualifiedName = getNameSpace("", _global, ref);
+	}
+
+	public function toString()
+	{
+		return qualifiedName;
+	}
+
+	public function beenVisited(obj:Object):Boolean
+	{
+		for(var i in visitedObjects) {
+			if(visitedObjects[i] == obj) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public function openMember(ref:Object)
+	{
+		_global.ASSetPropFlags(ref, null, 6, true);
+	}
+
+	public function closeMember(ref:Object)
+	{
+		_global.ASSetPropFlags(ref, null, 0, true);
+	}
+
+	public function getNameSpace(name:String, ref:Object, obj:Object)
+	{
+		if(!beenVisited(ref)) {
+			var str = name;
+			openMember(ref);
+			visitedObjects.push(ref);
+			for(var i in ref) {
+   				if(i == "prototype" || i == "__proto__" || i == "toLocaleString" || i == "constructor") {
+   					continue;
+   				}
+				str += ((str == "") ? "" :".") + i;
+				if(ref[i] == obj) {
+					closeMember(ref);
+					return str;
+				}
+				closeMember(ref);
+				// check here so that looping continues if result is invalid...
+				return getNameSpace(str, ref[i], obj);
+			}
+			closeMember(ref);
+			return str;
+		}
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/framework/Test.as

@@ -0,0 +1,3 @@
+
+interface com.asunit.framework.Test {
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/framework/TestCase.as

@@ -0,0 +1,191 @@
+
+import com.asunit.framework.*;
+import com.asunit.util.*;
+
+class com.asunit.framework.TestCase extends Assert implements Test {
+	private var methods:Array;
+	private var className:String = "[ClassName Unknown]";
+
+	// Abstract Class
+	private function TestCase()
+	{
+		init();
+	}
+
+	private function init()
+	{
+		checkClassName(className);
+		run();
+	}
+
+	private function checkClassName(name:String)
+	{
+	}
+
+	private function getClassName():String
+	{
+		return className;
+	}
+
+	private function getHiddenMembers():Object
+	{
+		var obj:Object = new Object();
+		obj.testFailed = true;
+		obj.testSucceeded = true;
+		obj.testMembers = true;
+		return obj;
+	}
+
+	private function getMethods():Array
+	{
+		var arr:Array = new Array();
+		var hiddenMembers:Object = getHiddenMembers();
+
+		_global.ASSetPropFlags(this.__proto__, null, 6, true);
+		for(var i:String in this) {
+			if(i.indexOf("test") == 0 && !hiddenMembers[i] && this[i] instanceof Function) {
+				arr.push(i);
+			}
+		}
+		_global.ASSetPropFlags(this.__proto__, null, 1, true);
+		arr.reverse();
+		return arr;
+	}
+
+	private function runMethod(method:String)
+	{
+		setUp();
+		setCurrentMethod(method);
+		this[method]();
+		tearDown();
+	}
+
+	private function createEmptyMovieClip(name:String, depth:Number):MovieClip {
+		return _root.createEmptyMovieClip(name, depth);
+	}
+
+	private function createTextField(name:String, depth:Number, x:Number, y:Number, width:Number, height:Number):TextField {
+	    _root.createTextField(name, depth, x, y, width, height);
+	    return TextField(_root[name]);
+	}
+
+	private function getNextHighestDepth():Number {
+		return _root.getNextHighestDepth();
+	}
+
+	// This helper method will support the following method signatures:
+	// attachMovie(linkageId:String):MovieClip;
+	// attachMovie(linkageId:String, initObject:Object):MovieClip;
+	// attachMovie(linkageId:String, name:String, depth:Number):MovieClip;
+	// attachMovie(linkageId:String, name:String, depth:Number, initObject:Object):MovieClip;
+ 	private function attachMovie():MovieClip {
+ 		var linkageId:String = arguments[0];
+ 		var name:String;
+ 		var depth:Number;
+ 		var initObj:Object = new Object();
+
+		switch(arguments.length) {
+			case 1 :
+			case 2 :
+			name = getValidName(_root, name);
+			depth = getValidDepth(_root);
+ 			initObj = arguments[1];
+ 			break;
+ 			case 3 :
+ 			case 4 :
+ 			name = arguments[1];
+ 			depth = arguments[2];
+ 			initObj = arguments[3];
+ 			break;
+		}
+		return _root.attachMovie(linkageId, name, depth, initObj);
+ 	}
+
+	public function getUpperEmptyDepth(parent:MovieClip, depth:Number):Number {
+		if(depth == undefined || !isValidDepth(parent, depth)) {
+			var high:Number = (depth == undefined) ? 1 : depth;
+			for(var i:String in parent) {
+				if(parent[i] instanceof MovieClip && parent[i].getDepth() != undefined) {
+					high = Math.max(parent[i].getDepth()+1, high);
+				}
+			}
+			return high;
+		}
+		return depth;
+	}
+
+	private function getValidName(parent:MovieClip, nm:Object):String {
+		var incr:Number = 1;
+
+		var name:String = (nm == undefined || nm instanceof Object) ? "item" : nm.toString();
+		var ref:MovieClip = parent[name];
+
+		var name2:String = name;
+		while(ref != undefined && incr < 100) {
+			name2 = name + "-" + (incr++);
+			ref = parent[name2];
+		}
+		return name2;
+	}
+
+	private function isValidDepth(parent:MovieClip, depth:Number):Boolean {
+		var item:MovieClip = getItemByDepth(parent, depth);
+		return (item == null) ? true : false;
+	}
+
+	private function getItemByDepth(parent:MovieClip, depth:Number):MovieClip {
+		for(var i:String in parent) {
+			if(parent[i].getDepth() == depth) {
+				return parent[i];
+			}
+		}
+		return null;
+	}
+
+	private function getValidDepth(mc:MovieClip):Number {
+		var mcDepth:Number;
+		var dp:Number = nextDepth();
+		for(var i:String in mc) {
+			mcDepth = mc[i].getDepth();
+			if(mc[i] instanceof MovieClip && mcDepth < 10000) {
+				dp = Math.max(mcDepth, dp);
+			}
+		}
+		return ++dp;
+	}
+
+	private function run():Void
+	{
+		setCurrentClassName(className);
+		var mList:Array = getMethods();
+		for(var i:Number=0; i<mList.length; i++) {
+			runMethod(mList[i]);
+		}
+		cleanUp();
+	}
+
+	public function cleanUp():Void {
+	}
+
+	public function onXmlLoaded(node:XMLNode):Void {
+	}
+
+	public function onTextFileLoaded(obj:TextFile):Void {
+	}
+
+	private function testFailed():Void
+	{
+	}
+
+	private function testSucceeded():Void
+	{
+	}
+
+	public function setUp():Void
+	{
+	}
+
+	public function tearDown():Void
+	{
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/framework/TestCaseXml.as

@@ -0,0 +1,31 @@
+
+import com.asunit.framework.*;
+
+class com.asunit.framework.TestCaseXml extends XML {
+
+	public static var linkageId:String = "com.asunit.framework.TestCaseXml";
+	public static var classRef:Function = TestCaseXml;
+
+	private var source:String;
+	private var callback:TestCase;
+	
+	public function TestCaseXml(src:String, cb:TestCase) {
+		source = src;
+		callback = cb;
+		ignoreWhite = true;
+		onLoad = doLoad;
+		if(src != undefined) {
+			load(source);
+		}
+	}
+	
+	public function doLoad(success:Boolean):Void {
+		if(success) {
+			callback.onXmlLoaded(this.firstChild);
+		} else {
+			Sys.println(">> there was an error loading XML at : " + source);
+		}
+	}
+	
+	public static var serializable:Boolean = Object.registerClass(linkageId, classRef);
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/framework/TestFailure.as

@@ -0,0 +1,15 @@
+
+import com.asunit.framework.*;
+
+class com.asunit.framework.TestFailure extends Assertion implements Test {
+
+	public var output:String = "F";
+	public var success:Boolean = false;
+
+	public function TestFailure(cName:String, mName:String, msg:String, assertion:String)
+	{
+		super(cName, mName, msg, assertion);
+		output = "F";
+		success = false;
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/framework/TestResult.as

@@ -0,0 +1,15 @@
+
+import com.asunit.framework.*;
+
+class com.asunit.framework.TestResult extends Assertion implements Test {
+
+	public var output:String;
+	public var success:Boolean;
+
+	public function TestResult(cName:String, mName:String, msg:String, assertion:String)
+	{
+		super(cName, mName, msg, assertion);
+		output = ".";
+		success = true;
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/framework/TestRunner.as

@@ -0,0 +1,41 @@
+
+import com.asunit.framework.*;
+import com.asunit.util.*;
+
+class com.asunit.framework.TestRunner extends Array {
+	public static var localConn:LocalConnClient;
+	private var intervalId:Number;
+	private var interval:Number = 10;
+	private var tests:Array;
+
+	private static function getLocalConn():LocalConnClient {
+		if(localConn == null) {
+			localConn = LocalConnGateway.createClient("_AsUnitTestRunner");
+			localConn["clearTestDisplay"]();
+		}
+		return localConn;
+	}
+
+	public function TestRunner() {
+		tests = new Array();
+	}
+
+	public function push(item:Object):Number {
+		var num:Number = tests.push(item);
+		clearInterval(intervalId);
+
+		if(num > 100) {
+			renderTests();
+		} else {
+			intervalId = setInterval(this, "renderTests", interval);
+		}
+		return num;
+	}
+
+	public function renderTests():Void {
+		clearInterval(intervalId);
+		var lc:LocalConnClient = getLocalConn();
+		lc["addTests"](tests);
+		tests = new Array();
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/framework/TestSetup.as

@@ -0,0 +1,19 @@
+
+import com.asunit.framework.*;
+
+class com.asunit.framework.TestSetup extends TestCase {
+ 
+	private function runMethod(method:String):Void {
+		setCurrentMethod(method);
+		this[method]();
+	}
+
+	private function run():Void {
+		var mList:Array = getMethods();
+		setUp();
+		for(var i:Number=0; i<mList.length; i++) {
+			runMethod(mList[i]);
+		}
+		tearDown();
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/framework/TestSuite.as

@@ -0,0 +1,22 @@
+
+import com.asunit.framework.*;
+
+class com.asunit.framework.TestSuite extends TestCase {
+
+	public function TestSuite()
+	{
+		super();
+	}
+
+	public function addTest(test:Test):Void
+	{
+	}
+
+	public function addTestSuite(test:TestSuite):Void
+	{
+	}
+
+	public function run(result:TestResult):Void
+	{
+	}
+}

data/templates/asproject/asunit2/project/lib/asunit/com/asunit/ui/Main.as

@@ -0,0 +1,325 @@
+
+import com.asunit.ui.*;
+import com.asunit.framework.*;
+import com.asunit.util.*;
+import mx.controls.*;
+
+class Main extends MovieClip {
+	public static var linkageId:String = "com.asunit.ui.Main";
+
+	var version:String = "2.8.0";
+	var flashIsTextEditorResult:Boolean;
+	var remoteVersionObj:RemoteVersion;
+	var localConn:LocalConnServer;
+	var outputLine:LocalConnServer;
+	var tResult:TestResult;
+	var tFailure:TestFailure;
+	var test:Test;
+	var intervalId:Number;
+
+	var items:Array;
+	var gutter:Number = 10;
+	var successes:Number = 0;
+	var failures:Number = 0;
+	var totalTests:Number = 0;
+
+	var output_txt:TextArea;
+	var clearAll:Button;
+	var reload:Button;
+	var outputPanel:TextArea;
+	var showSys:CheckBox;
+	var showSysSo:SharedObject;
+
+	var bar_mc:SuccessMeter;
+
+	public function Main() {
+		configureAssets();
+		items = new Array();
+		showSysSo = SharedObject.getLocal("showSysSoId");
+		_visible = false;
+		onEnterFrame = function() {
+			_visible = true;
+			remoteVersionObj = new RemoteVersion(this);
+			showSys.clickHandler = onShowClicked;
+			showSys.setSelected(showSysSo.data.isSelected);
+			onResize();
+	 		Stage.addListener(this);
+
+			delete onEnterFrame;
+		}
+
+	}
+
+	public function checkRemoteVersion(remoteVersion:String):Void {
+		var remNumber:Number = Number(remoteVersion.split(".").join(""));
+		var vers:Number = Number(getVersionNumber().split(".").join("").split(" [Release Candidate]").join(""));
+		if(remNumber > vers) {
+			var obj:Object = new Object();
+			obj.success = false;
+			obj.message = ">> There is a newer version of AsUnit (" + remoteVersion + ") available for download at: <a href='http://www.asunit.com'><u>http://www.asunit.com</u></a>";
+			addTests([obj]);
+		}
+	}
+
+	// Attached as clickHandler to the CheckBox
+	public function onShowClicked():Void {
+		_parent.onResize();
+	}
+
+	public function getVersionNumber():String {
+		return version;
+	}
+
+	public function onUnload():Void {
+		localConn.close();
+		outputLine.close();
+		saveTraceChoice();
+	}
+
+	public function saveTraceChoice():Void {
+		var success:Object = showSysSo.flush();
+	}
+
+	public function configureAssets() {
+		output_txt.vScrollPolicy = "auto";
+
+		reload.onRelease = function() {
+			_parent.onReload();
+		}
+
+		clearAll.onRelease = function() {
+			_parent.onClear();
+		}
+	}
+
+	public function clearTestDisplay():Void {
+		items 	= new Array();
+		refreshOutput();
+	}
+
+	public function onClear() {
+		MMExecute("fl.outputPanel.clear();");
+		clearTestDisplay();
+	}
+
+	public function onReload():Void {
+		_root.loadUi();
+	}
+
+	public function onLoad():Void {
+		init();
+	}
+
+	public function onResizeNoTrace():Void {
+		var w:Number = Stage.width-gutter*2;
+		var h:Number = Stage.height-(bar_mc._height + gutter*3);
+		outputPanel._visible = false;
+
+		output_txt.setSize(w, h);
+		output_txt._x = gutter;
+		showSys._x = gutter;
+		reload._x = showSys._x + showSys._width + gutter;
+		bar_mc._x = reload._x + reload._width + gutter;
+		output_txt._y = gutter;
+		bar_mc.setSize(w - (reload._x + reload._width), bar_mc._height);
+		reload._y = clearAll._y = bar_mc._y = output_txt._y + output_txt.height + gutter;
+		showSys._y = reload._y;
+	}
+
+	public function onResizeWithTrace():Void {
+		var w:Number = Stage.width-gutter*2;
+		var h:Number = Stage.height-(bar_mc._height + gutter*4);
+		outputPanel._visible = true;
+
+		outputPanel._x = gutter;
+		outputPanel._y = gutter;
+		outputPanel.setSize(w, h/2);
+		output_txt.setSize(w, h/2);
+		output_txt._y = outputPanel._y + outputPanel._height + gutter;
+		output_txt._x = gutter;
+		clearAll._x = output_txt._x;
+		showSys._x = gutter;
+		reload._x = showSys._x + showSys._width + gutter;
+		bar_mc._x = reload._x + reload._width + gutter;
+		bar_mc.setSize(w - (reload._x + reload._width), bar_mc._height);
+		reload._y = clearAll._y = bar_mc._y = output_txt._y + output_txt.height + gutter;
+		showSys._y = reload._y;
+	}
+
+	public function onResize():Void {
+		showSysSo.data.isSelected = showSys.selected;
+		showSysSo.flush();
+
+		if(showSys.selected) {
+			onResizeWithTrace();
+		} else {
+			onResizeNoTrace();
+		}
+	}
+
+	public function init():Void {
+		localConn = LocalConnGateway.createServer(this, "_AsUnitTestRunner");
+		outputLine = LocalConnGateway.createServer(this, "_outputLineLc");
+		output_txt.wordWrap = true;
+		refreshOutput();
+	}
+
+	public function onShowEcho(msg, category) {
+		msg = unescape(msg);
+		if(showSys.selected) {
+			outputPanel.text += msg;
+		} else {
+			MMExecute("fl.trace('" + msg + "');");
+		}
+	}
+
+	public function getFirstLine():String {
+		var str:String = "Version : " + getVersionNumber() + "\n";
+		if(localConn.status) {
+			str += "Unit Test UI Loaded at LocalConnection ID: '" + localConn.getId() + "'\n";
+		} else {
+			str += "ALERT : Unit Test UI LocalConnection <b>Failed</b> at ID : '<b>" + localConn.getId() + "</b>'\n";
+		}
+		if(outputLine.status) {
+			str += "Echo Output Loaded at LocalConnection ID: '" + outputLine.getId() + "'\n";
+		} else {
+			str += "ALERT : Echo Output LocalConnection <b>Failed</b> at ID : '<b>" + outputLine.getId() + "</b>'\n";
+		}
+		return str;
+	}
+
+	public function getTestResultString():String {
+		successes = 0;
+		failures = 0;
+		 var str = "";
+		 var fStr = "";
+		 for(var i=0; i<items.length; i++) {
+		 	str += items[i].output;
+		 	if(items[i].success) {
+		 		successes++;
+		 	} else {
+		 		failures++;
+		 		fStr += renderItemFailure(items[i]);
+		 	}
+		 }
+		 return str + "\n" + getTestNumberOutput() + "\n" + fStr;
+	}
+
+	public function osIsWin():Boolean {
+		var vs = $version;
+		vs = vs.split(" ");
+		vs = vs[0];
+		if(vs != "WIN") {
+			return false;
+		}
+		return true;
+	}
+
+	public function flashIsTextEditor():Boolean {
+		if(flashIsTextEditorResult == undefined) {
+			var doc = MMExecute("fl.getDocumentDOM().getDataFromDocument('lastFlashEditor');");
+			if(doc == "true" || doc == null) {
+				flashIsTextEditorResult = true;
+			} else {
+				flashIsTextEditorResult = false;
+			}
+		}
+		return flashIsTextEditorResult;
+	}
+
+	public function renderItemFailure(item:Object):String {
+		var str = "-----------------\nItem Failed at :\n";
+		var isWin:Boolean = osIsWin();
+
+		str += "assertion : " + item.assertion + "\n";
+		str += "message : " + item.message + "\n";
+		str += "methodName : " + item.methodName + "\n";
+		if(isWin) {
+			str += "className : " + "<a href=\"asfunction:_parent.classNameClicked," + item.className + "\"><u>" + item.className + "</u></a>\n";
+		} else {
+			str += "className : " + item.className + "\n";
+		}
+
+// 		for(var i in item) {
+// 			if(i == "className" && isWin) {
+// 				str += i + " : " + "<a href=\"asfunction:_parent.classNameClicked," + item[i] + "\"><u>" + item[i] + "</u></a>\n";
+// 			} else {
+// 				str += i + " : " + item[i] + "\n";
+// 			}
+// 		}
+		return str;
+	}
+
+	public function classNameClicked(name:String):Void {
+		name = name.split(".").join("/") + ".as";
+		var uri:String = "";
+		if(MMExecute('fl.version.indexOf("MAC");') == -1) {
+			if(flashIsTextEditor()) {
+				uri = getMacPath(name);
+		 		MMExecute('fl.openScript("' + uri + '");');;
+			} else {
+				uri = getWinPath(name);
+		 		MMExecute("FileIo.open('" + uri + "');");
+		 	}
+		}
+		else {
+			uri = getMacPath(name);
+	 		MMExecute('fl.openScript("' + uri + '");');;
+		}
+	}
+
+	public function getWinPath(suffix:String):String {
+		var flaUri:String = MMExecute("fl.getDocumentDOM().path");
+		var dPath = flaUri.split(Sys.getFileSeparator());
+		var sPath = suffix.split("/");
+		dPath.pop();
+		dPath = dPath.join("\\\\") + "\\\\" + sPath.join("\\\\");
+		dPath = dPath.split(" ").join("\\ ");
+		return dPath;
+	}
+
+	public function getMacPath(suffix:String):String {
+		return getCurrentUri(suffix);
+	}
+
+	public function getCurrentUri(suffix:String):String {
+		var flaUri:String = MMExecute("fl.getDocumentDOM().path");
+		var dPath = flaUri.split(Sys.getFileSeparator());
+		dPath.pop();
+		dPath = dPath.join("/")
+		// Perform Windows Colonoscopy
+		if(dPath.charAt(1) == ":") {
+			dPath = dPath.substring(0,1) + "|" + dPath.substring(2);
+		}
+		return "file:///" + dPath + "/" + suffix;
+	}
+
+	public function getTestNumberOutput():String {
+		return successes + " out of " + items.length + " Asserts passed.\n";
+	}
+
+	public function refreshOutput() {
+		output_txt.text = getFirstLine();
+		output_txt.text += "\n" + getTestResultString();
+		bar_mc.setSuccess((failures == 0));
+		if(intervalId == undefined) {
+			intervalId = setInterval(this, "scrollDown", 100);
+		}
+	}
+
+	public function scrollDown():Void {
+		output_txt.vPosition = output_txt.maxVPosition;
+		clearInterval(intervalId);
+		delete intervalId;
+	}
+
+	public function addTests(arr:Array) {
+		if(items == undefined) {
+			items = new Array();
+		}
+		for(var i = 0; i < arr.length; i++) {
+			items.push(arr[i]);
+		}
+		refreshOutput();
+	}
+}