automation_core/src/UnitTest/ExtendedClasses/VellumTestCase.as

////////////////////////////////////////////////////////////////////////////////
//
//  Licensed to the Apache Software Foundation (ASF) under one or more
//  contributor license agreements.  See the NOTICE file distributed with
//  this work for additional information regarding copyright ownership.
//  The ASF licenses this file to You under the Apache License, Version 2.0
//  (the "License"); you may not use this file except in compliance with
//  the License.  You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//
////////////////////////////////////////////////////////////////////////////////
package UnitTest.ExtendedClasses
{
	import UnitTest.Fixtures.FileRepository;
	import UnitTest.Fixtures.TestApp;
	import UnitTest.Fixtures.TestConfig;
	import UnitTest.Validation.BoundsChecker;
	import UnitTest.Validation.LineSnapshot;
	import UnitTest.Validation.MD5;
	import UnitTest.Validation.StringSnapshot;
	import UnitTest.Validation.TCMComposition;
	import UnitTest.Validation.XMLSnapshot;
	
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.DisplayObject;
	import flash.display.IBitmapDrawable;
	import flash.display.Sprite;
	import flash.system.System;
	import flash.utils.ByteArray;
	import flash.utils.getTimer;
	
	import flashx.textLayout.compose.StandardFlowComposer;
	import flashx.textLayout.container.ContainerController;
	import flashx.textLayout.container.ScrollPolicy;
	import flashx.textLayout.conversion.ITextImporter;
	import flashx.textLayout.conversion.TextConverter;
	import flashx.textLayout.edit.EditManager;
	import flashx.textLayout.edit.EditingMode;
	import flashx.textLayout.edit.SelectionFormat;
	import flashx.textLayout.elements.Configuration;
	import flashx.textLayout.elements.TextFlow;
	import flashx.textLayout.factory.TextFlowTextLineFactory;
	import flashx.textLayout.formats.TextLayoutFormat;
	import flashx.textLayout.tlf_internal;
	use namespace tlf_internal;
	
	import flexunit.framework.TestCase;
	
	import mx.containers.Canvas;
	import mx.core.UIComponent;
	import mx.skins.Border;


	public class VellumTestCase extends TestCase
	{
		//public static var app:VellumUnit = Application.application as VellumUnit;
		public static var testApp:TestApp;
		public var TestID:String;
		public var TestData:Object;
		public var TestFrame:ContainerController;
		public var TestDisplayObject:DisplayObject;
		public var SelManager:EditManager;
		public var containerType:String;
		public var writingDirection:Array;
		public var useEmbeddedFonts:Boolean;
		public var baseURL:String;		// baseURL for loading files
		public var doBeforeAfterCompare:Boolean;
		public var diffTolerance:Number;

		public var bitmapBaseline:Bitmap;
		public var lineBaseline:XML;
		public var plaintextBaseline:String;
		public var xflBaseline:XML;
		public var htmlBaseline:XML;

		//checksum for the baseline
		public var bitmapBaselineChecksum:String = null;
		public var lineBaselineChecksum:String = null;
		public var plaintextBaselineChecksum:String = null;
		public var xflBaselineChecksum:String = null;
		public var htmlBaselineChecksum:String = null;

		//checksum for the snapshot
		public var bitmapSnapshotChecksum:String = null;
		public var lineSnapshotChecksum:String = null;
		public var plaintextSnapshotChecksum:String = null;
		public var xflSnapshotChecksum:String = null;
		public var htmlSnapshotChecksum:String = null;

		//result link for the failed snapshot
		public static var snapAdminServerUrl:String = "";
		public var runID:Number;

		public var fileName:String = null;
		public var beforeData:BitmapData = null;
		public var afterData:Bitmap = null;

		public var bitmapSnapshot:Bitmap = null;
		public var lineSnapshot:XML = null;
		public var plaintextSnapshot:String = null;
		public var xflSnapshot:XML = null;
		public var htmlSnapshot:XML = null;


		public var TCMCompositionResult:Boolean = true;
		public var bitmapResult:Boolean = true;
		public var lineResult:Boolean = true;
		public var plaintextResult:Boolean = true;
		public var xflResult:Boolean = true;
		public var htmlResult:Boolean = true;

		private var failString:String = "";
		private var endOfSetupTime:Number;
		
		protected var addDefaultTestSettings:Boolean;

		private static var useRandom:Boolean = false;
		private static var LineSnapshotUtils:LineSnapshot = new LineSnapshot();
		private static var XMLSnapshotUtils:XMLSnapshot = new XMLSnapshot();
		private static var StringSnapshotUtils:StringSnapshot = new StringSnapshot();

		public function VellumTestCase(methodName:String, testID:String, testConfig:TestConfig, testCaseXML:XML = null)
		{
			TestData = new Object();

			// set defaults to some items in TestData - these can be overridden
			// in a specific test case's constructor or in an XML file
			TestData.bitmapSnapshot = "false";
			TestData.lineSnapshot = "false";
			TestData.xflSnapshot = "false";
			TestData.minimal = "true";

			if (testCaseXML)
			{
				for each (var testDataXML:XML in testCaseXML.*)
				{
					TestData[testDataXML.@name] = testDataXML.toString();
				}
			}

			if (TestData["bitmapSnapshotTolerance"] != null)
				diffTolerance = TestData["bitmapSnapshotTolerance"];
			else
				diffTolerance = 0.001;

			writingDirection = testConfig.writingDirection;
			containerType = testConfig.containerType;
			doBeforeAfterCompare = testConfig.doBeforeAfterCompare;
			useEmbeddedFonts = testConfig.useEmbeddedFonts;
			baseURL = testConfig.baseURL;
			addDefaultTestSettings = true;

			TestID = testID;

			super (methodName);

		}

		public static function suiteFromXML(testCaseClass:Class, testListXML:XML, testConfig:TestConfig, ts:TestSuiteExtended):void
		{
  			var writingDirection:String = testConfig.writingDirection[0] + "_" + testConfig.writingDirection[1];
			for each (var testCaseXML:XML in testListXML.*)
			{
				var testFile:String = testCaseXML.TestData.(@name == "testFile").toString();
				if (testFile != "")
				{
					var extension:String = getExtension(testFile);
					var folderName:String = "";
					if (extension == "html")
						folderName = "html/";
					else if (extension == "txt")
						folderName = "plainText/";
					else
						folderName = "tlf/";
					FileRepository.readFile(testConfig.baseURL, "../../test/testFiles/markup/" + folderName + testFile);
				}
				if ((testCaseXML.TestData.(@name == writingDirection).toString() != "false") &&
					(testCaseXML.TestData.(@name == testConfig.containerType).toString() != "false") &&
					(testCaseXML.TestData.(@name == testConfig.flashVersion) != "false"))
				{
					ts.addTestDescriptor (new TestDescriptor (testCaseClass, testCaseXML.@functionName, testConfig, testCaseXML));
				}
			}
		}

		static public var defaultFileName:String = "simple.xml";
		static private var DEFAULT_COMPOSITION_WIDTH:Number = 826;
		static private var DEFAULT_COMPOSITION_HEIGHT:Number = 477;

		/** start every test with nothing on the canvas
		 */
		public function cleanUpTestApp() : void
		{
			testApp.detachActiveFlow(true);
			var canvas:Canvas = testApp.getDisplayObject();
			// remove everything but the Border
			for (var i:int = canvas.rawChildren.numChildren - 1; i >= 0; i--)
				if (!(canvas.rawChildren.getChildAt(i) is Border))
					canvas.rawChildren.removeChildAt(i);
		}

		override public function setUp() : void
		{
			//trace("Beginning test: " + TestID);

			// Make sure whatever was left from last test is cleared
			cleanUpTestApp();

			testApp.contentChange(null);
			testApp.setInteractionManager(EditingMode.READ_WRITE);
			testApp.changeContainerSetup("arrangeSideBySide", 0, 1);

	//		if (TestData.requiresLayout == "true")
	//		{
	//			trace ("-----------set up layout-enabled container here-----------");
	//		}

			fileName = TestData.fileName == undefined ? defaultFileName : TestData.fileName;

			loadTestFile(fileName);

			TestFrame = TextFlow(testApp.getTextFlow()).flowComposer.getControllerAt(0);
			TestDisplayObject = testApp.getDisplayObject();

			// all of this should eventually go away, but some tests are depending
			// on it at the moment.  I'm assuming that:
			// 1. Container attributes should either stay the default, or these
			//    attributes should get put into the default file.
			// 2. Tests that depend on scrolling being off should do that themselves
			// 3. Writing direction for the default file should be handled in loadTestFile.
			if (fileName == defaultFileName && addDefaultTestSettings)
			{
		 		// set the container attributes to the same as those in the Flex TextContainer (see the flow:TextContaienr below)
		 		var containerAttr:TextLayoutFormat = new TextLayoutFormat(TestFrame.format);
		 		containerAttr.columnCount = 2;
	 			containerAttr.columnGap = 10;
	 			//containerAttr.paddingLeft = 4;
	 			containerAttr.paddingRight = 4;
	 			//containerAttr.paddingTop = 4;
	  			TestFrame.horizontalScrollPolicy = ScrollPolicy.OFF;
	 			TestFrame.verticalScrollPolicy = ScrollPolicy.OFF;
	  			TestFrame.format = containerAttr;
	 			containerAttr = null;
				if (TestFrame.compositionWidth != DEFAULT_COMPOSITION_WIDTH || TestFrame.compositionHeight != DEFAULT_COMPOSITION_HEIGHT)
					TestFrame.setCompositionSize(DEFAULT_COMPOSITION_WIDTH, DEFAULT_COMPOSITION_HEIGHT);

			}

			// Set the writing direction specified by the test
			if (fileName == defaultFileName && TestFrame.rootElement)
			{
				TestFrame.rootElement.blockProgression = writingDirection[0];
				TestFrame.rootElement.direction        = writingDirection[1];
			}
			
			TextFlow(testApp.getTextFlow()).flowComposer.updateAllControllers();

			if (TestFrame.rootElement)
			{
				SelManager = EditManager(TestFrame.rootElement.getTextFlow().interactionManager);
				if(SelManager)
				{
					setSelectionRange();
					//make sure there is never any blinking when running these tests
					setCaretBlinkRate (0);
				}
			}
			//endOfSetupTime = getTimer();
		}

		override public function tearDown() : void
		{
		//	trace ("Beginning of teardown.");

			if (TestFrame && TestFrame.flowComposer)
				TestFrame.flowComposer.updateAllControllers();

			//middleDuration = (getTimer() - endOfSetupTime);

			// generic validation
			// note: why must the selectionmanager be active?
			if (SelManager)
			{
				assertTrue ("teardown assert for active SelectionManager failed", SelManager.hasSelection());
				CONFIG::debug
				{
					assertTrue("teardown assert for SelManager.debugCheckSelectionManager() failed", SelManager.debugCheckSelectionManager() == 0);
					assertTrue("teardown assert for SelManager.textFlow.debugCheckTextFlow() failed", SelManager.textFlow.debugCheckTextFlow() == 0);
				}
			}

			if (containerType == "sprite")
				assertTrue ("TestFrame should be a Sprite, but is not", TestFrame.container is Sprite);


			//Only run this test if VellumUnit is set to do it.
			if (doBeforeAfterCompare)
			{
				var tempSelManager:EditManager = new EditManager();
				var fFormat:SelectionFormat = SelManager.focusedSelectionFormat;
				var nfFormat:SelectionFormat = SelManager.unfocusedSelectionFormat;
				var inFormat:SelectionFormat = SelManager.inactiveSelectionFormat;
				tempSelManager.focusedSelectionFormat = new SelectionFormat(fFormat.rangeColor, fFormat.rangeAlpha, fFormat.rangeBlendMode, fFormat.pointColor, fFormat.pointAlpha, fFormat.pointBlendMode, 1000);
				tempSelManager.unfocusedSelectionFormat = new SelectionFormat(nfFormat.rangeColor, nfFormat.rangeAlpha, nfFormat.rangeBlendMode, nfFormat.pointColor, nfFormat.pointAlpha, nfFormat.pointBlendMode, 1000);
				tempSelManager.inactiveSelectionFormat = new SelectionFormat(inFormat.rangeColor, inFormat.rangeAlpha, inFormat.rangeBlendMode, inFormat.pointColor, inFormat.pointAlpha, inFormat.pointBlendMode, 1000);

				var TestCanvas:Canvas = testApp.getDisplayObject();
				var curTextFlow:TextFlow = TextFlow(testApp.getTextFlow());

				var TCMCompositionUtils:TCMComposition = new TCMComposition(TestCanvas, curTextFlow);
				TCMCompositionUtils.Height = testApp.getDisplayObject().height;
				TCMCompositionUtils.Width = testApp.getDisplayObject().width;
				TCMCompositionResult = TCMCompositionUtils.compare();

				if (!TCMCompositionResult)
				{
					failString += " TextContainerManager composition: " + TCMCompositionUtils.ErrorString;
				}

				SelManager = tempSelManager;
			}

			if (TestData.bitmapSnapshot == true)
			{
				// Create the afterData snapshot.
				if (TestDisplayObject is mx.core.UIComponent)
					mx.core.UIComponent(TestDisplayObject).validateNow();
				var bits:BitmapData = new BitmapData(TestDisplayObject.width, TestDisplayObject.height);
				bits.draw(TestDisplayObject as IBitmapDrawable);
				bitmapSnapshot = new Bitmap(bits);
				bits = null;

				var pixels:ByteArray = bitmapSnapshot.bitmapData.getPixels(bitmapSnapshot.bitmapData.rect);
				pixels.compress();
				pixels.position = 0;
				bitmapSnapshotChecksum = MD5.hashBinary(pixels);

				// If there is a baseline, then run a compare. If not, (gcai) we'll report an error about what's wrong there.
				//bitmapResult = true;
				if (bitmapBaseline != null)
				{
					if(bitmapSnapshotChecksum != bitmapBaselineChecksum)
					{
						// If the checksum is different, do the bitmap compare of the two bitmaps to make the diffTolerance enabled.
						bitmapBaseline.bitmapData.draw(bitmapSnapshot, null, null, "difference");
						var diffPixels:ByteArray = bitmapBaseline.bitmapData.getPixels(bitmapBaseline.bitmapData.rect);
						diffPixels.position = 0;
						var pixelCount:uint = diffPixels.bytesAvailable;
						var diffCount:uint = 0;
						var redDiff:uint = 0;
						var greenDiff:uint = 0;
						var blueDiff:uint = 0;
						var componentTolerance:uint = 20;
						
						while (diffPixels.bytesAvailable > 0)
						{
							// throw away alpha
							diffPixels.readUnsignedByte();
							
							redDiff = diffPixels.readUnsignedByte();
							greenDiff = diffPixels.readUnsignedByte();
							blueDiff = diffPixels.readUnsignedByte();
							
							// only count pixels where the difference is visible
							if (redDiff > componentTolerance || greenDiff > componentTolerance || blueDiff > componentTolerance)
							{
								// previously we'd count the number of pixels that were different
								//diffCount ++;
								// now we're summing the amount of the differences - so a small number of very different
								// pixels will error, but only a large number of slightly different pixels will error
								diffCount += redDiff + greenDiff + blueDiff
							}
							
							redDiff = 0;
							greenDiff = 0;
							blueDiff = 0;
						}

						// If this is larger than the tolerance, then something changed and it is a bug.
						// previous pixel count threshold
						//bitmapResult = (((diffCount/(pixelCount/4))*100) < diffTolerance);
						// new summed differences threshold
						bitmapResult = diffCount < (pixelCount/4)*diffTolerance*255*3;
						//trace ("  TestID: " + TestID + " count: "+ diffCount + " threshold: " + (pixelCount/4)*diffTolerance*255);

						if (!bitmapResult)
						{
							failString += "Bitmap data snapshot differed from the baseline. Detail:"+getUrl("Bitmap");
							failString += "  Bitmap compare failed by " + ((diffCount/pixelCount)*100) + " percent of pixels compared.";
						}
     				}
				}
				else
				{
					bitmapResult = false;
					failString += "Don't have any bitmap baseline for current case. Detail:"+getUrl("Bitmap");
				}
			}

			if (TestData.lineSnapshot == true)
			{
				lineSnapshot = LineSnapshotUtils.takeSnapshot(TestFrame.rootElement.getTextFlow());
				var lineDataBytes:ByteArray = new ByteArray();
				lineSnapshot.normalize();
				lineDataBytes.writeObject (lineSnapshot);
				lineDataBytes.compress();
				lineDataBytes.uncompress();
				lineSnapshot = new XML(lineDataBytes.readObject());
				lineSnapshot.normalize();

				lineSnapshotChecksum = getChecksum(lineSnapshot);
				// Do a compare as long as there is a baseline.
				if (lineBaseline != null)
				{
					if(lineSnapshotChecksum != lineBaselineChecksum)
					{
						lineResult = XMLSnapshotUtils.compareAdvanced(lineBaseline, lineSnapshot);
						if (!lineResult)
						{
							failString += "  , Line data snapshot differed from the baseline. Detail:"+getUrl("Line");
						}
					}
				}
				else
				{
					lineResult = false;
					failString += " , Don't have any line baseline for current case. Detail:"+getUrl("Line");
				}
			}

			if (TestData.plaintextSnapshot == true)
			{
				plaintextSnapshot = StringSnapshotUtils.takeSnapshot(TestFrame.rootElement.getTextFlow(), TextConverter.PLAIN_TEXT_FORMAT);
				plaintextSnapshotChecksum = MD5.hash(plaintextSnapshot);
				// Do a compare as long as there is a baseline.
				if (plaintextBaseline != null)
				{
					if(plaintextSnapshotChecksum != plaintextBaselineChecksum)
					{
						plaintextResult = StringSnapshotUtils.compare(plaintextBaseline, plaintextSnapshot);
						if (!plaintextResult)
						{
							failString += "  , PlainText data snapshot differed from the baseline. Detail:" + getUrl("PlainText");
						}
					}
				}
				else
				{
					plaintextResult = false;
					failString += " , Don't have any PlainText baseline for current case. Detail:"+getUrl("PlainText");
				}
			}

			if (TestData.xflSnapshot == true)
			{
				xflSnapshot = XMLSnapshotUtils.takeSnapshot(TestFrame.rootElement.getTextFlow(), TextConverter.TEXT_LAYOUT_FORMAT);
				xflSnapshotChecksum = getChecksum(xflSnapshot);
				// Do a compare as long as there is a baseline.
				if (xflBaseline != null)
				{
					if(xflSnapshotChecksum != xflBaselineChecksum)
					{
						xflResult = XMLSnapshotUtils.compareAdvanced(xflBaseline, xflSnapshot);
						if (!xflResult)
						{
							failString += "  , XFL data snapshot differed from the baseline. Detail:" + getUrl("XFL");
						}
					}
				}
				else
				{
					xflResult = false;
					failString += " , Don't have any xfl baseline for current case. Detail:"+getUrl("XFL");
				}
			}

			if (TestData.htmlSnapshot == true)
			{
				htmlSnapshot = XMLSnapshotUtils.takeSnapshot(TestFrame.rootElement.getTextFlow(), TextConverter.TEXT_FIELD_HTML_FORMAT);
				htmlSnapshotChecksum = getChecksum(htmlSnapshot);
				// Do a compare as long as there is a baseline.
				if (htmlBaseline != null)
				{
					if(htmlBaselineChecksum != htmlSnapshotChecksum)
					{
						htmlResult = XMLSnapshotUtils.compareAdvanced(htmlBaseline, htmlSnapshot);
						if (!htmlResult)
						{
							failString += "  , HTML data snapshot differed from the baseline. Detail:"+getUrl("HTML");
						}
					}
				}
				else
				{
					htmlResult = false;
					failString += " , Don't have any HTML baseline for current case. Detail:"+getUrl("HTML");
				}
			}

		//	Comment this code in to enable bounds checking on each test. 
		/*	if (TestFrame && TestFrame.textFlow)
			{
				var s:Sprite = new Sprite();
				testApp.getDisplayObject().rawChildren.addChild(s);
				BoundsChecker.boundsValidation(TestFrame.textFlow, s);
				testApp.getDisplayObject().rawChildren.removeChild(s);
			} */


			//	trace ("Ending test: " + TestID);

			//*****************************************************
			if (SelManager)
			{
				//turn caret blinking back on
				setCaretBlinkRate (1000);
			}
			// Nulls for garbage collection
			TestFrame = null;
			SelManager = null;
	//		trace ("End of teardown.");
			
			
			// This code breaks snapshotting of XML - need to move the disposeXML calls somewhere else
			/*if (Configuration.playerEnablesArgoFeatures)
				System["disposeXML"](lineSnapshot);
			lineSnapshot = null;
			plaintextSnapshot = null;
			if (Configuration.playerEnablesArgoFeatures)
				System["disposeXML"](xflSnapshot);
			xflSnapshot = null;
			if (Configuration.playerEnablesArgoFeatures)
				System["disposeXML"](htmlSnapshot);
			htmlSnapshot = null;*/

			
			// The assert makes it end the test, so we need to put that at the very
			// end of everything, so that all snapshot tests get a chance to run.
			assertTrue (failString, ((TCMCompositionResult) && (bitmapResult) && (lineResult) && (xflResult) && (htmlResult)));
//				fail(failString);
		}

		private function getUrl(snapShotType:String):String
		{
			return snapAdminServerUrl+"runid="+runID+";caseid="+TestID+";snapshottype="+snapShotType;
		}

		private function getChecksum(file:XML):String
		{
			var dataBytes:ByteArray = new ByteArray();
			dataBytes.writeObject (file);
			dataBytes.compress();
			dataBytes.position = 0;

			return MD5.hashBinary(dataBytes);
		}

		override public function toString():String
		{
			return TestID;
		}

		private function getRandomInteger(start:int, end:int):int
			// Return a random number between start and end
		{
			var num:Number = Math.random();
			return Math.ceil((num * (end - start)) + start);
		}

		private function setSelectionRange():void
		{
			if (useRandom)
			{
				var startIdx:int = getRandomInteger(0, SelManager.textFlow.textLength);
				var endIdx:int = getRandomInteger(0, SelManager.textFlow.textLength);
				if (startIdx > endIdx)
				{
					var tmp:int = startIdx;
					startIdx = endIdx;
					endIdx = tmp;
				}
				SelManager.selectRange(startIdx, endIdx);
			}
			else
			{
				if(SelManager.textFlow.textLength > 60){
					SelManager.selectRange(22, 60);
				}else{
					SelManager.selectRange(0, SelManager.textFlow.textLength / 2);
				}
			}
		}

		public function setCaretBlinkRate (caretBlinkRate:int):void
		{
			var fFormat:SelectionFormat = SelManager.focusedSelectionFormat;
			var nfFormat:SelectionFormat = SelManager.unfocusedSelectionFormat;
			var inFormat:SelectionFormat = SelManager.inactiveSelectionFormat;
			SelManager.focusedSelectionFormat = new SelectionFormat(fFormat.rangeColor, fFormat.rangeAlpha, fFormat.rangeBlendMode, fFormat.pointColor, fFormat.pointAlpha, fFormat.pointBlendMode, caretBlinkRate);
			SelManager.unfocusedSelectionFormat = new SelectionFormat(nfFormat.rangeColor, nfFormat.rangeAlpha, nfFormat.rangeBlendMode, nfFormat.pointColor, nfFormat.pointAlpha, nfFormat.pointBlendMode, caretBlinkRate);
			SelManager.inactiveSelectionFormat = new SelectionFormat(inFormat.rangeColor, inFormat.rangeAlpha, inFormat.rangeBlendMode, inFormat.pointColor, inFormat.pointAlpha, inFormat.pointBlendMode, caretBlinkRate);
		}

		protected function get importParser():ITextImporter
		{
			var extension:String = getExtension(fileName);
			if (extension == "xml")
				extension = TextConverter.TEXT_LAYOUT_FORMAT;
			else if (extension == "txt")
				extension = TextConverter.PLAIN_TEXT_FORMAT;
			else if (extension == "html")
				extension = TextConverter.TEXT_FIELD_HTML_FORMAT;
			return TextConverter.getImporter(extension);
		}

		public static function getExtension(fileName:String):String
		{
			var dotPos:int = fileName.lastIndexOf(".");
			if (dotPos >= 0)
				return fileName.substring(dotPos + 1);
			return fileName;
		}

  		public function importContent (content:Object):void
		{
			var beginTime:int = getTimer();
			//TestFrame.removeAllChildren();
			var parser:ITextImporter = importParser;
			var textFlow:TextFlow = parser.importToFlow(content);

			setUpFlowForTest(textFlow);
		}

		public function setUpFlowForTest(textFlow:TextFlow):void
		{
			textFlow.flowComposer = null;
			testApp.contentChange (textFlow);

			TestFrame = TextFlow(testApp.getTextFlow()).flowComposer.getControllerAt(0);
			if (TestFrame.rootElement)
			{
				SelManager = EditManager(TestFrame.rootElement.getTextFlow().interactionManager);
				if(SelManager) setSelectionRange();
			}

			if (textFlow.flowComposer)
				textFlow.flowComposer.compose();
		}


		public function getFileData(fileName:String):Object
		{
			var fileData:Object; // XML or String

			var extension:String = getExtension(fileName);
			if (extension == "html")
				fileData = FileRepository.getFile(baseURL, "../../test/testFiles/markup/html/" + fileName);
			else if (extension == "txt")
				fileData = FileRepository.getFile(baseURL, "../../test/testFiles/markup/plainText/" + fileName);
			else
				fileData = FileRepository.getFileAsXML(baseURL, "../../test/testFiles/markup/tlf/" + fileName);
			return fileData;
		}

		static private var cacheTestFile:TextFlow;
		public function loadTestFile (fileName:String):void
		{
			var containerFormat:TextLayoutFormat;

			if (fileName == defaultFileName && cacheTestFile != null)
			{
				var textFlow:TextFlow = cacheTestFile.deepCopy(0, cacheTestFile.textLength) as TextFlow;
				setUpFlowForTest(textFlow);
			}
			else
			{
				var fileData:Object = getFileData(fileName); // XML or String
				if (fileData is XML)
				{
					var flowNS:Namespace = fileData.namespace("flow");
					if (writingDirection[0] != "tb" && writingDirection[1] != "ltr")
					{
						fileData.flowNS::TextFlow.@blockProgression = writingDirection[0];
						fileData.flowNS::TextFlow.@direction = writingDirection[1];
					}
					if (useEmbeddedFonts)
					{
						fileData.flowNS::TextFlow.@fontLookup = "embeddedCff";
					}
				}
				importContent(fileData);
			}

			if (!cacheTestFile && fileName == defaultFileName)
			{
				var resultFlow:TextFlow = TestFrame.rootElement as TextFlow;
				cacheTestFile = resultFlow.deepCopy() as TextFlow;
			}
		}
	}
}