////////////////////////////////////////////////////////////////////////////////
//
//  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.Tests
{
	import UnitTest.ExtendedClasses.TestDescriptor;
	import UnitTest.ExtendedClasses.TestSuiteExtended;
	import UnitTest.ExtendedClasses.VellumTestCase;
	import UnitTest.Fixtures.TestConfig;
	
	import flash.display.Graphics;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.IEventDispatcher;
	import flash.geom.Rectangle;
	import flash.system.*;
	import flash.text.engine.TextLine;
	
	import flashx.textLayout.container.ContainerController;
	import flashx.textLayout.container.ScrollPolicy;
	import flashx.textLayout.container.TextContainerManager;
	import flashx.textLayout.conversion.ConversionType;
	import flashx.textLayout.conversion.TextConverter;
	import flashx.textLayout.edit.EditManager;
	import flashx.textLayout.elements.FlowLeafElement;
	import flashx.textLayout.elements.InlineGraphicElement;
	import flashx.textLayout.elements.InlineGraphicElementStatus;
	import flashx.textLayout.elements.TextFlow;
	import flashx.textLayout.events.StatusChangeEvent;
	import flashx.textLayout.factory.StringTextLineFactory;
	import flashx.textLayout.factory.TextFlowTextLineFactory;
	import flashx.textLayout.formats.BlockProgression;
	import flashx.textLayout.formats.Direction;
	import flashx.textLayout.formats.ITextLayoutFormat;
	import flashx.textLayout.formats.TextLayoutFormat;
	import flashx.textLayout.tlf_internal;

    import org.flexunit.asserts.assertTrue;
    import org.flexunit.asserts.fail;

    use namespace tlf_internal;
	
	import mx.containers.Canvas;
	import mx.utils.LoaderUtil;

	public class MeasurementGridTest extends VellumTestCase  implements IEventDispatcher
	{
		// Don't check in with true
		private static const kVerbose:Boolean = false;

		// Creation Types
		private static const USE_FLOW:String = "textFlow";
		private static const USE_FACTORY_STRING:String = "factoryStr";
		private static const USE_FACTORY_FLOW:String = "factoryTF";
		private static const USE_TCM:String = "textContainerManager";

		private static const MEASURE_WIDTH:String = "measureW";
		private static const MEASURE_HEIGHT:String = "measureH";
		private static const MEASURE_BOTH:String = "measureWH";
		private static const MEASURE_NONE:String = "explicitWH";
		private static var measureTypes:Array = [ MEASURE_NONE, MEASURE_BOTH ];
		

		private static var textAlignArray:Array = ["left", "center", "right", "start", "end" ];
		private static var verticalAlignArray:Array = ["top", "middle", "bottom"];
		private static var lineBreakArray:Array = ["toFit", "explicit" ];
		private const horizontalGap:Number = 30;
		private const verticalGap:Number = 10;
		private var w:Number = 210;
		private var h:Number = 40;
		private var width:Number;
		private var height:Number;
		private var paddingWidth:int = 0;
		private var paddingHeight:int = 0;

		private var labelWidth:Number = 210;
		private var labelHeight:Number = 50;

		private var _blockProgression:String;
		private var _direction:String;
		private var _creationType:String;
		private var _lineBreak:String;
		private var _measureType:String;
		private var eventDispatcher:EventDispatcher;
		// bounds and format of last sprite for comparison function
		private var compareBounds:Rectangle;

		private var marginOfError:int = 3;
		private var sFactBounds:Rectangle;
		private var fFactBounds:Rectangle;
		private var tFlowBounds:Rectangle;

		private var notReadyGraphicsCount:int;

		private var scrollPolicy:String = ScrollPolicy.ON;

		private static var stringFactory:StringTextLineFactory = null;
		private static var textFlowFactory:TextFlowTextLineFactory = null;
		private static var labelFactory:StringTextLineFactory = null;
		private var sprite:Sprite;
		private var testCanvas:Canvas;


		public function MeasurementGridTest(methodName:String, testID:String, testConfig:TestConfig, testXML:XML) //measureType:String, lineBreak:String)
		{
			super(methodName, testID, testConfig, null);

           eventDispatcher = new EventDispatcher();

			if (!stringFactory)
				stringFactory = new StringTextLineFactory();
			if (!textFlowFactory)
				textFlowFactory = new TextFlowTextLineFactory();
			if (!labelFactory)
			{
				labelFactory = new StringTextLineFactory();
				var labelFormat:TextLayoutFormat = new TextLayoutFormat();
				labelFormat.fontSize = 12;
				labelFactory.spanFormat = labelFormat;
			}

			//reset containerType to avoid assert in tearDown
			containerType = "custom";

			_blockProgression = testConfig.writingDirection[0];
			_direction = testConfig.writingDirection[1];
			//_creationType = creationType;
			_measureType = testXML.TestData.(@name == "measureType").toString();
			_lineBreak = testXML.TestData.(@name == "lineBreak").toString();

			//reset ID to include more variables
			TestID = TestID + ":" + _measureType + ":" + _lineBreak;

			width = logicalWidth;
			height = logicalHeight;
			switch (_measureType)
			{
				case MEASURE_BOTH:	width = NaN;
									height = NaN;
									break;

				case MEASURE_WIDTH:	width = NaN;
									break;

				case MEASURE_HEIGHT:
									height = NaN;
									break;
			}
			if (_blockProgression == BlockProgression.RL)		// swap coordinates if we're vertical
			{
				var tmp:Number = width;
				width = height;
				height = tmp;

				tmp = w;
				w = h;
				h = tmp;
			}

			// enables snapshots for the measurementgridtest - DO NOT SUBMIT ENABLED - It takes too long!
			// TestData["bitmapSnapshot"] = "true";
			// Note: These must correspond to a Watson product area (case-sensitive)
			metaData.productArea = "Text Composition";
		}

		public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false): void
		{
			eventDispatcher.addEventListener(type, listener, useCapture, priority, useWeakReference);
		}

		public function dispatchEvent(evt:Event):Boolean
		{
			return eventDispatcher.dispatchEvent(evt);
		}

		public function hasEventListener(type:String):Boolean
		{
			return eventDispatcher.hasEventListener(type);
		}

		public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false): void
		{
			eventDispatcher.removeEventListener(type, listener, useCapture);
		}

		public function willTrigger(type:String):Boolean
		{
			return eventDispatcher.willTrigger(type);
		}
		// end of IEventDispatcher functions

		override public function setUpTest() : void
		{
			cleanUpTestApp();
			TestDisplayObject = testApp.getDisplayObject();
			if (!TestDisplayObject)
			{
				fail("Did not get a blank canvas to work with");
			}
		}

		private function addToCanvas(sprite:Sprite):void
		{
			TestDisplayObject = testApp.getDisplayObject();
			if (TestDisplayObject)
			{
				testCanvas = Canvas(TestDisplayObject);
				testCanvas.rawChildren.addChild(sprite);
			}
		}

		private function spriteHandler(event:Event, data:Array):void
		{
  			var xOrigin:Number = 10;
			var yOrigin:Number = 10;
			_creationType = USE_FACTORY_FLOW;
			var textFlowArray:Array = createTextFlows(data[4]);
			addTestSet(data[0], data[1], data[2], data[3], textFlowArray, data[5], _creationType, _lineBreak, marginOfError);
			assertTrue("fFactBounds doesn't have the same output as tFlowBounds", Math.abs(fFactBounds.x - tFlowBounds.x) <= 1 && Math.abs(fFactBounds.y - tFlowBounds.y) <= 1 &&
											Math.abs(fFactBounds.width - tFlowBounds.width) <= 1 && Math.abs(fFactBounds.height - tFlowBounds.height) <= 1);
			//assertTrue("Doesn't get the same output", fFactBounds.x == tFlowBounds.x );
		}

		// These tests run all creation types -- flow, textFlowfactory and string factory
		private static var testsToRun:Array = [
			"testSimpleText",
			"testMultipleLines",
			"testTrailingSpaces",
			"testWidthNoHeight",
			"testHeightNoWidth",
			"testEmptyText",
			"testPaddingLeftAndTop",
			"testPaddingRightAndBottom",
			"testMultipleColumns",
			"testStartIndent",
			"testEndIndent",
			"testNegTextIndent",
			"testSpaceBefore",
			"testSpaceAfter"
			];

		// These tests run flow &  textFlowfactory creation types (they don't work on string factory)
		private static var testsToRunOnFlowAndTFFactory:Array = [
			"testInlineAtStartOfFlow",
			"testInlineAtStartOfFlowBigText",
		//	"testInlineOnFirstLineInContainer",
		//	"testInlineOnFirstLineOfSecondContainer",
		//	"testInlineOnMiddleLineCentered"
			];

		public static function suite(testConfig:TestConfig, ts:TestSuiteExtended):void
		{
   			// These tests run on all creation types
   			var methodName:String;
   			var creationType:String;
   			var measureType:String;
   			var lineBreak:String;
   			for each (methodName in testsToRun)
   			{
   				for each (measureType in measureTypes)
	   				for each (lineBreak in lineBreakArray)
		  				addTestCase(ts, testConfig, methodName, measureType, lineBreak);

   			}

   			// These tests run on TextFlow and TextFlow Factory only

   			for each (methodName in testsToRunOnFlowAndTFFactory)
   			{
   				for each (measureType in measureTypes)
		   			for each (lineBreak in lineBreakArray)
			  			addTestCase(ts, testConfig, methodName, measureType, lineBreak);
   			}
   		}

 		private static function addTestCase(ts:TestSuiteExtended, testConfig:TestConfig, methodName:String, /*creationType:String,*/ measureType:String, lineBreak:String):void
 		{
			//ts.addTestDescriptor (new TestDescriptor (MeasurementGridTest,methodName, testConfig, creationType, measureType, lineBreak) );
			var testXML:XML = <TestCase>
								<TestData name="measureType">{measureType}</TestData>
								<TestData name="lineBreak">{lineBreak}</TestData>
								<TestData name="id">{methodName}-{measureType}-{lineBreak}</TestData>
							</TestCase>;

			ts.addTestDescriptor (new TestDescriptor (MeasurementGridTest,methodName, testConfig, testXML) );
 		}

		private const logicalWidth:Number = 200;
		private const logicalHeight:Number = 40;

		private function createDefaultTextLayoutFormat():TextLayoutFormat
		{
			var format:TextLayoutFormat = new TextLayoutFormat();
			format.fontFamily = "Arial";
			format.fontSize = 20;
			format.direction = _direction;
			format.blockProgression = _blockProgression;
			return format;
		}

		private function runTest(sampleText:String, format:TextLayoutFormat):void
		{
			var xOrigin:Number = 10;
			var yOrigin:Number = 10;
			var item:String;
			var tempBool:Boolean = false;

			_creationType = USE_FLOW;
			var textFlowArray:Array = createTextFlows(sampleText);
			if (notReadyGraphicsCount > 0)
			{
			/*	addEventListener("spriteInUse", addAsync(spriteHandler, 5000,
					[xOrigin, yOrigin, width, height, sampleText, format]), false, 0, true);  */
				addTestSet(xOrigin, yOrigin, width, height, textFlowArray, format, _creationType, _lineBreak, marginOfError);
			}
			else
			{
				addTestSet(xOrigin, yOrigin, width, height, textFlowArray, format, _creationType, _lineBreak, marginOfError);
				_creationType = USE_FACTORY_FLOW;
				addTestSet(xOrigin, yOrigin, width, height, textFlowArray, format, _creationType, _lineBreak, marginOfError);
			}
			
			// TCM converts graphics to textflow so no point in testing
			if (notReadyGraphicsCount == 0)
			{
				_creationType = USE_TCM;
				addTestSet(xOrigin, yOrigin, width, height, textFlowArray, format, _creationType, _lineBreak, marginOfError);
			}
			

			//notReadyGraphicsCount = 0;

			tempBool = false;
			for(var i:int = 0; i < testsToRunOnFlowAndTFFactory.length; i++)
			{
				if ( testsToRunOnFlowAndTFFactory[i] == methodName)
				{
					tempBool = true;
					break;
				}
			}

			if (!tempBool)
			{
				_creationType = USE_FACTORY_STRING;
				addTestSet(xOrigin, yOrigin, width, height, sampleText, format, _creationType, _lineBreak, marginOfError);
				/*
				assertTrue("sFactBounds doesn't have the same output as tFlowBounds", Math.abs(sFactBounds.x - tFlowBounds.x) <= 1 && Math.abs(sFactBounds.y - tFlowBounds.y) <= 1 &&
											Math.abs(sFactBounds.width - tFlowBounds.width) <= 1 && Math.abs(sFactBounds.height - tFlowBounds.height) <= 1);
				*/
			}


		}

		private function createTextFlows(text:String):Array
		{
			var textFlowArray:Array = [];
			var flowCount:int = verticalAlignArray.length * textAlignArray.length;
			for (var i:int = 0; i < flowCount; ++i)
				textFlowArray.push(createTextFlow(text));
			for (i = 0; i < flowCount; ++i)		// remove any dummy controllers
				textFlowArray[i].flowComposer.removeAllControllers();

			return textFlowArray;
		}

		private function createTextFlow(markup:String):TextFlow
		{
			if (markup.length <= 0 || markup.charAt(0) != "<")
				return TextConverter.importToFlow(markup, TextConverter.PLAIN_TEXT_FORMAT);

			var textFlow:TextFlow = TextConverter.importToFlow(markup, TextConverter.TEXT_LAYOUT_FORMAT);
			var flowNotReadyGraphicsCount:int = 0;

			// check for inlines
 			for (var leaf:FlowLeafElement = textFlow.getFirstLeaf(); leaf != null; leaf = leaf.getNextLeaf())
 				if (leaf is InlineGraphicElement && InlineGraphicElement(leaf).status != InlineGraphicElementStatus.READY)
 					flowNotReadyGraphicsCount++;
 			if (flowNotReadyGraphicsCount != 0)
 			{
	 			textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,statusChangeHandler,false,0,true);
	 			textFlow.flowComposer.addController(new ContainerController(new Sprite()));	// add dummy controller so we get status change events
	 			textFlow.flowComposer.updateAllControllers();
	 			notReadyGraphicsCount += flowNotReadyGraphicsCount;
 			}
			return textFlow;
		}

		// Track the completion of loading inlines, dispatch a completion event when its done
 		private function statusChangeHandler(obj:Event):void
 		{
 			var event:StatusChangeEvent = StatusChangeEvent(obj);
 			var textFlow:TextFlow = event.element.getTextFlow();
			switch (event.status)
			{
				case InlineGraphicElementStatus.LOADING:
				case InlineGraphicElementStatus.LOAD_PENDING:
				case InlineGraphicElementStatus.SIZE_PENDING:
					break;
				case InlineGraphicElementStatus.READY:
					notReadyGraphicsCount--;
					if (notReadyGraphicsCount <= 0)
					{
						textFlow.removeEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,statusChangeHandler);
						if (_creationType == USE_FLOW)
						{
							this.dispatchEvent(new Event("textFlowsReady"));
						}
						else if (_creationType == USE_FACTORY_FLOW)
						{
							this.dispatchEvent(new Event("flowFactsReady"));
						}
					}
					break;
				default:
					assertTrue("unexpected StatusChangeEvent status: "+event.status,false);
					break;
			}
 		}

 		private function labelVAlignColumns(xOrigin:Number, yOrigin:Number):void
		{
			var x:Number;
			var y:Number;

			x = xOrigin;
			for each (var verticalAlign:String in verticalAlignArray)
			{
				y = yOrigin;
				addLabel(x, yOrigin, labelWidth, labelHeight, verticalAlign);	//label
				x += w + horizontalGap;
			}
		}

		private function asyncAddTestSet(event:Event, data:Array):void
		{
			addTestSet(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8]);
		}

		private function addTestSet(xOrigin:Number, yOrigin:Number, compositionWidth:Number, compositionHeight:Number,
			text:Object, format:TextLayoutFormat, creationType:String, lineBreak:String, marginOfError:int):void
		{

			var x:Number = xOrigin;
			var y:Number = yOrigin;
			var lineBreak:String;
			var verticalAlign:String;
			var textAlign:String;

			var useString:Boolean = text is String;

			var flowIndex:int = 0;
			var sampleText:String = text as String;
			var textFlowArray:Array = text as Array;


			// Test against specified width and height
			if (_blockProgression == BlockProgression.TB)
			{
				// Labels for columns
				labelVAlignColumns(xOrigin, yOrigin);

				yOrigin += 30;
				x = xOrigin;
				for each (verticalAlign in verticalAlignArray)
				{
					y = yOrigin;
					for each (textAlign in textAlignArray)
					{
						addTextSprite(x, y, compositionWidth, compositionHeight, textAlign, verticalAlign, lineBreak, useString ? sampleText : textFlowArray[flowIndex++], format, creationType);
						y += h + verticalGap;
					}
					x += w + horizontalGap;
				}
				addLabel(x, yOrigin - 30, labelWidth, labelHeight, lineBreak);	//label
				y = yOrigin;
				for each (textAlign in textAlignArray)
				{
					addLabel(x, y, labelWidth, labelHeight, textAlign);
					y += h + verticalGap;
				}
			}
			else
			{
				var newColumn:Boolean = true;
				x = xOrigin;
				for each (verticalAlign in verticalAlignArray)
				{
					addLabel(x, yOrigin, labelWidth, labelHeight, verticalAlign);
					for each (textAlign in textAlignArray)
					{
						if (newColumn)
						{
							y = yOrigin + 20;
							newColumn = false;
						}
						addLabel(x, y, labelWidth, labelHeight, textAlign);
						addTextSprite(x, y + 20, compositionWidth, compositionHeight, textAlign, verticalAlign, lineBreak, useString ? sampleText:textFlowArray[flowIndex++], format, creationType);
						y += h + verticalGap;
						if (y > 400)
						{
							newColumn = true;
							x += w + horizontalGap;
						}
					}
					x += w + horizontalGap;
				}
			}

			this.dispatchEvent(new Event("spriteInUse"));
			// trace("Sprite is ready now!!!!!!!!!!");

		}

		private function addTextSprite(x:Number, y:Number, width:Number, height:Number, textAlign:String, verticalAlign:String, lineBreak:String, text:Object,
			format:TextLayoutFormat, creationType:String):void
		{
			switch (creationType)
			{
				case USE_FLOW:
					addTextFlowSprite(x, y, width, height, textAlign, verticalAlign, lineBreak, text as TextFlow, format);
					comparision(x, y, width, height, textAlign, verticalAlign, marginOfError, format);
					break;
				case USE_FACTORY_STRING:
					addTextFactoryFromStringSprite(x, y, width, height, textAlign, verticalAlign, lineBreak, text as String, format);
					comparision(x, y, width, height, textAlign, verticalAlign, marginOfError, format);
					break;
				case USE_FACTORY_FLOW:
					addTextFactoryFromFlowSprite(x, y, width, height, textAlign, verticalAlign, lineBreak, text as TextFlow, format);
					comparision(x, y, width, height, textAlign, verticalAlign, marginOfError, format);
					break;
				case USE_TCM:
					addTCMSprite(x, y, width, height, textAlign, verticalAlign, lineBreak, text as TextFlow, format);
					break;
			}
		}

		private function comparision(x:Number, y:Number, width:Number, height:Number, textAlign:String, verticalAlign:String, marginOfError:int, compareFormat:ITextLayoutFormat):void
        {

			if (isNaN(width) || isNaN(height))
				return;
			// these comparision tests barely work for TB and not at all for RL content.  Really their functioning at this time is conincidental
			// the general rule for contentBounds is that it is the size you can setting compositionHeight to contentBounds.height and compositionWidth to contentBounds.width
			// will give you the same line breaks and the same size of contentBounds.  That means it includes padding.  So when verifying center/bottom/justified text you must
			// to subtract off the padding values in order to verify these bounds calculations.  Its not happening here so this entire section should be revisited.
			if (compareFormat.blockProgression == BlockProgression.TB)
			{
				switch (verticalAlign)
	            {
	               case "top":
	                   //assertTrue("not top aligned", Math.abs(bounds.top) <= marginOfError);
	                   switch (textAlign)
	                   {
	                       case "left":
	                          assertTrue("not top-left aligned", Math.abs(compareBounds.y) <= marginOfError ||
	                          				Math.abs(compareBounds.left) <= marginOfError);
	                          break;
	                       case "center":
	                          assertTrue("not top-center aligned", Math.abs((compareBounds.y + compareBounds.height/2) - height/2) <= marginOfError ||
	                          				Math.abs((compareBounds.left + compareBounds.width/2) - width/2) <= marginOfError);
	                          break;
	                       case "right":
	                          assertTrue("not top-right aligned", Math.abs(compareBounds.bottom - height) <= marginOfError ||
	                          				Math.abs(compareBounds.y - height) <= marginOfError ||
	                          				Math.abs(compareBounds.left - width) <= marginOfError ||
	                          				Math.abs(compareBounds.right - width) <= marginOfError);
	                          break;
	                       case "start":
	                       	  if (_direction == Direction.LTR)
	                          assertTrue("not top-start-lrt aligned", Math.abs(compareBounds.y) <= marginOfError ||
	                          				Math.abs(compareBounds.left) <= marginOfError);
	                          else
	                          assertTrue("not top-start-rtl aligned", Math.abs(compareBounds.right - width) <= marginOfError ||
	                          				Math.abs(compareBounds.left - width) <= marginOfError);
	                          break;
	                       case "end":
	                          if (_direction == Direction.RTL)
	                          assertTrue("not top-end-rtl aligned", Math.abs(compareBounds.y) <= marginOfError ||
	                          				Math.abs(compareBounds.left) <= marginOfError);
	                          else
	                          assertTrue("not top-end-ltr aligned", Math.abs(compareBounds.y - height) <= marginOfError ||
	                          				Math.abs(compareBounds.left - width) <= marginOfError ||
	                          				Math.abs(compareBounds.right - width) <= marginOfError ||
	                          				Math.abs(compareBounds.bottom - height) <= marginOfError);
	                          break;

	                   }
	                   break;

	               case "middle":
	               	   //assertTrue("not middle aligned", Math.abs(compareBounds.y + compareBounds.height/2 - height/2) <= marginOfError);
	                   switch (textAlign)
	                   {
	                      case "left":
	                          assertTrue("not middle-left aligned", Math.abs(compareBounds.y) <= marginOfError ||
	                          				Math.abs(compareBounds.left) <= marginOfError);
	                          break;
	                       case "center":
	                          assertTrue("not middle-center aligned", Math.abs((compareBounds.y + compareBounds.height/2) - height/2) <= marginOfError ||
	                          				Math.abs((compareBounds.left + compareBounds.width/2) - width/2) <= marginOfError);
	                          break;
	                       case "right":
	                          assertTrue("not middle-right aligned", Math.abs(compareBounds.bottom - height) <= marginOfError ||
	                          				Math.abs(compareBounds.y - height) <= marginOfError ||
	                          				Math.abs(compareBounds.left - width) <= marginOfError ||
	                          				Math.abs(compareBounds.right - width) <= marginOfError);
	                          break;
	                       case "start":
	                       	  if (_direction == Direction.LTR)
	                          assertTrue("not middle-start-ltr aligned", Math.abs(compareBounds.y) <= marginOfError ||
	                          				Math.abs(compareBounds.left) <= marginOfError);
	                          else
	                          assertTrue("not middle-start-rtl aligned", Math.abs(compareBounds.right - width) <= marginOfError ||
	                          				Math.abs(compareBounds.left - width) <= marginOfError);
	                          break;
	                       case "end":
	                          if (_direction == Direction.RTL)
	                          assertTrue("not middle-end-rtl aligned", Math.abs(compareBounds.y) <= marginOfError ||
	                          				Math.abs(compareBounds.left) <= marginOfError);
	                          else
	                          assertTrue("not middle-end-ltr aligned", Math.abs(compareBounds.bottom - height) <= marginOfError ||
	                          				Math.abs(compareBounds.y - height) <= marginOfError ||
	                          				Math.abs(compareBounds.left - width) <= marginOfError ||
	                          				Math.abs(compareBounds.right - width) <= marginOfError);
	                          break;

	                   }
	                   break;

	               case "bottom":
	                   //assertTrue("not middle aligned", Math.abs(compareBounds.bottom - height) <= marginOfError);
	                   switch (textAlign)
	                   {
	                      case "left":
	                          assertTrue("not bottom-left aligned", Math.abs(compareBounds.y) <= marginOfError ||
	                          				Math.abs(compareBounds.left) <= marginOfError);
	                          break;
	                       case "center":
	                          assertTrue("not bottom-center aligned", Math.abs((compareBounds.y + compareBounds.height/2) - height/2) <= marginOfError ||
	                          				Math.abs((compareBounds.left + compareBounds.width/2) - width/2) <= marginOfError);
	                          break;
	                       case "right":
	                          assertTrue("not bottom-right aligned", Math.abs(compareBounds.bottom - height) <= marginOfError ||
	                          				Math.abs(compareBounds.y - height) <= marginOfError ||
	                          				Math.abs(compareBounds.left - width) <= marginOfError ||
	                          				Math.abs(compareBounds.right - width) <= marginOfError);
	                          break;
	                       case "start":
	                       	  if (_direction == Direction.LTR)
	                          assertTrue("not bottom-start-ltr aligned", Math.abs(compareBounds.y) <= marginOfError ||
	                          				Math.abs(compareBounds.left) <= marginOfError);
	                          else
	                          assertTrue("not bottom-start-rtl aligned", Math.abs(compareBounds.right - width) <= marginOfError ||
	                          				Math.abs(compareBounds.left - width) <= marginOfError);
	                          break;
	                       case "end":
	                          if (_direction == Direction.RTL)
	                          assertTrue("not bottom-end-rtl aligned", Math.abs(compareBounds.y) <= marginOfError ||
	                          				Math.abs(compareBounds.left) <= marginOfError);
	                          else
	                          assertTrue("not bottom-end-ltr aligned", Math.abs(compareBounds.bottom - height) <= marginOfError ||
	                          				Math.abs(compareBounds.y - height) <= marginOfError ||
	                          				Math.abs(compareBounds.left - width) <= marginOfError ||
	                          				Math.abs(compareBounds.right - width) <= marginOfError);
	                          break;

	                   }
	                   break;

	            }


			}

			if (compareFormat.blockProgression == BlockProgression.RL)
			{
				switch (verticalAlign)
				{
					case "top":
						//assertTrue("not top aligned", Math.abs(bounds.top) <= marginOfError);
						switch (textAlign)
						{
							case "left":
								assertTrue("not top-left aligned", Math.abs(compareBounds.y + compareBounds.height + paddingHeight - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
									Math.abs(compareBounds.height - width) <= marginOfError);

								break;
							case "center":
								assertTrue("not top-center aligned", Math.abs((Math.abs(compareBounds.height) + compareBounds.bottom + paddingHeight/2) - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - 23 - height) <= marginOfError);

								break;
							case "right":
								assertTrue("not top-right aligned", Math.abs(compareBounds.y + paddingHeight - height - 200) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
									Math.abs(compareBounds.y + compareBounds.height + paddingHeight - height) <= marginOfError);

								break;
							case "start":
								if (_direction == Direction.LTR)
									assertTrue("not top-start-lrt aligned", Math.abs(compareBounds.y + compareBounds.height + paddingHeight - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError);

								else
									assertTrue("not top-start-rtl aligned", Math.abs(compareBounds.y - height - paddingHeight) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError);

								break;
							case "end":
								if (_direction == Direction.RTL)
									assertTrue("not top-start-rtl aligned", Math.abs(compareBounds.y - height - paddingHeight) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError);

								else
									assertTrue("not top-start-lrt aligned", Math.abs(compareBounds.height + paddingHeight - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
									Math.abs(compareBounds.height + paddingHeight - 46 - height) <= marginOfError);

								break;

						}
						break;

					case "middle":
						//assertTrue("not middle aligned", Math.abs(compareBounds.y + compareBounds.height/2 - height/2) <= marginOfError);
						switch (textAlign)
						{
							case "left":
								assertTrue("not top-left aligned", Math.abs(compareBounds.y + compareBounds.height + paddingHeight - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError);

								break;
							case "center":
								assertTrue("not top-center aligned", Math.abs((Math.abs(compareBounds.height) + compareBounds.bottom + paddingHeight/2) - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - 23 - height) <= marginOfError);

								break;
							case "right":
								assertTrue("not top-right aligned", Math.abs(compareBounds.y + paddingHeight - height - 200) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
									Math.abs(compareBounds.y + compareBounds.height + paddingHeight - height) <= marginOfError);

								break;
							case "start":
								if (_direction == Direction.LTR)
									assertTrue("not top-start-lrt aligned", Math.abs(compareBounds.y + compareBounds.height + paddingHeight - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError);

								else
									assertTrue("not top-start-rtl aligned", Math.abs(compareBounds.y - height - paddingHeight) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError);

								break;
							case "end":
								if (_direction == Direction.RTL)
									assertTrue("not top-start-rtl aligned", Math.abs(compareBounds.y - height - paddingHeight) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError);

								else
									assertTrue("not top-start-lrt aligned", Math.abs(compareBounds.height + paddingHeight - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
										Math.abs(compareBounds.height + paddingHeight - 46 - height) <= marginOfError);

								break;

						}
						break;

					case "bottom":
						//assertTrue("not middle aligned", Math.abs(compareBounds.bottom - height) <= marginOfError);
						switch (textAlign)
						{
							case "left":
								assertTrue("not top-left aligned", Math.abs(compareBounds.y + compareBounds.height + paddingHeight - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError);

								break;
							case "center":
								assertTrue("not top-center aligned", Math.abs((Math.abs(compareBounds.height) + compareBounds.bottom + paddingHeight/2) - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - 23 - height) <= marginOfError);

								break;
							case "right":
								assertTrue("not top-right aligned", Math.abs(compareBounds.y + paddingHeight - height - 200) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
									Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
									Math.abs(compareBounds.y + compareBounds.height + paddingHeight - height) <= marginOfError);

								break;
							case "start":
								if (_direction == Direction.LTR)
									assertTrue("not top-start-lrt aligned", Math.abs(compareBounds.y + compareBounds.height + paddingHeight - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError);

								else
									assertTrue("not top-start-rtl aligned", Math.abs(compareBounds.y - height - paddingHeight) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError);

								break;
							case "end":
								if (_direction == Direction.RTL)
									assertTrue("not top-start-rtl aligned", Math.abs(compareBounds.y - height - paddingHeight) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError);

								else
									assertTrue("not top-start-lrt aligned", Math.abs(compareBounds.height + paddingHeight - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + paddingHeight - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 102 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 16 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) + 89 - height) <= marginOfError ||
										Math.abs(Math.abs(compareBounds.height) - 46 - height) <= marginOfError ||
										Math.abs(compareBounds.height + paddingHeight - 46 - height) <= marginOfError);

								break;

						}
						break;

				}


			}


        }


		private function addTextFactoryFromStringSprite(x:Number, y:Number, width:Number, height:Number, textAlign:String, verticalAlign:String, lineBreak:String, text:String,
			format:TextLayoutFormat):void
		{

			// trace("addTextFactoryFromStringSprite",x,y,width,height,textAlign,verticalAlign,lineBreak,text);
			sprite = new Sprite();
			sprite.x = x;
			sprite.y = y;

			var scratchFormat:TextLayoutFormat = new TextLayoutFormat(format);
			scratchFormat.textAlign = textAlign;
			scratchFormat.verticalAlign = verticalAlign;
			scratchFormat.lineBreak = lineBreak;

			stringFactory.compositionBounds = new Rectangle(0,0,width?width:NaN,height?height:NaN);
			stringFactory.text = text;
			stringFactory.textFlowFormat = scratchFormat;
			stringFactory.createTextLines(callback);
			addToCanvas(sprite);


			function callback(tl:TextLine):void
			{
				sprite.addChild(tl);
			}

			// composition compareBounds in black
			// contentBounds in red
			// put it in another sprite on top
			sprite = new Sprite();
			sprite.x = x;
			sprite.y = y;
			addToCanvas(sprite);

			compareBounds = stringFactory.getContentBounds();
			var g:Graphics = sprite.graphics;
			drawCircle(g, 0xff00, 0, 0, 3);
			strokeRect(g, 1, 0x0, 0, 0, width, height);
			strokeRect(g, 1, 0xFF0000, compareBounds.left, compareBounds.top, compareBounds.width, compareBounds.height);
			// trace("addTextFactoryFromStringSprite is running");
			sFactBounds = stringFactory.getContentBounds();

			if (kVerbose)
				trace(TestID,_creationType,textAlign,verticalAlign,lineBreak,width,height,sFactBounds);
			// trace("bounds",sFactBounds);


		}

		private function addTextFactoryFromFlowSprite(x:Number, y:Number, width:Number, height:Number, textAlign:String, verticalAlign:String, lineBreak:String, textFlow:TextFlow,
			format:ITextLayoutFormat):void
		{
			// trace("addTextFactoryFromFlowSprite",x,y,width,height,textAlign,verticalAlign,lineBreak);

			sprite = new Sprite();
			sprite.x = x;
			sprite.y = y;

			addToCanvas(sprite);

			textFlowFactory.compositionBounds = new Rectangle(0,0,width?width:NaN,height?height:NaN);

			// trace("RSLT",textFlowFactory.compositionBounds);

			// For factory using TextFlow use this...
			// If we got a TextFlow, just use it. Otherwise create one from the String.
			textFlow.format = format;
			textFlow.textAlign = textAlign;
			textFlow.verticalAlign = verticalAlign;
			textFlow.lineBreak = lineBreak;


			// trace(TextConverter.export(textFlow,TextConverter.TEXT_LAYOUT_FORMAT,ConversionType.STRING_TYPE));
			textFlowFactory.createTextLines(callback,textFlow);
			addToCanvas(sprite);

			function callback(tl:TextLine):void
			{
				sprite.addChild(tl);
			}

			// composition bounds in black
			// contentBounds in red
			// put it in another sprite on top
			sprite = new Sprite();
			sprite.x = x;
			sprite.y = y;
			addToCanvas(sprite);

			compareBounds = textFlowFactory.getContentBounds();
			var g:Graphics = sprite.graphics;
			drawCircle(g, 0xff00, 0, 0, 3);
			strokeRect(g, 1, 0x0, 0, 0, width, height);
			strokeRect(g, 1, 0xFF0000, compareBounds.left, compareBounds.top, compareBounds.width, compareBounds.height);
			// trace("addTextFactoryFromFlowSprite is running");
			fFactBounds = textFlowFactory.getContentBounds();

			if (kVerbose)
				trace(TestID,_creationType,textAlign,verticalAlign,lineBreak,width,height,fFactBounds);
			// trace("bounds",sFactBounds);
		}
		
		private function addTCMSprite(x:Number, y:Number, width:Number, height:Number, textAlign:String, verticalAlign:String, lineBreak:String, textFlow:TextFlow,
										   format:TextLayoutFormat):void
		{
			sprite = new Sprite();
			sprite.x = x;
			sprite.y = y;
			
			var tcm:TextContainerManager = new TextContainerManager(sprite);

			
			textFlow.format = format;
			textFlow.textAlign = textAlign;
			textFlow.verticalAlign = verticalAlign;
			textFlow.lineBreak = lineBreak;
			
			tcm.compositionHeight = height;
			tcm.compositionWidth = width;
			tcm.verticalScrollPolicy = scrollPolicy;
			tcm.horizontalScrollPolicy = scrollPolicy;
				
			tcm.updateContainer();
			
			assertTrue("MGT:addTCMSprite expected factoryComposer",tcm.composeState == TextContainerManager.COMPOSE_FACTORY);
			
			var firstBounds:Rectangle = tcm.getContentBounds();
			
			var g:Graphics = sprite.graphics;
			drawCircle(g, 0xff00, 0, 0, 3);
			strokeRect(g, 1, 0x0, 0, 0, width, height);
			strokeRect(g, 1, 0xFF0000, firstBounds.left, firstBounds.top, firstBounds.width, firstBounds.height);
			// trace("addTextFactoryFromFlowSprite is running");

			if (kVerbose)
				trace("1",TestID,_creationType,textAlign,verticalAlign,lineBreak,width,height,firstBounds);

			tcm.beginInteraction();
			tcm.endInteraction();
			
			assertTrue("MGT:addTCMSprite expected standardComposer",tcm.composeState == TextContainerManager.COMPOSE_COMPOSER);
			
			var secondBounds:Rectangle = tcm.getContentBounds();
			if (kVerbose)
				trace("2",TestID,_creationType,textAlign,verticalAlign,lineBreak,width,height,secondBounds);
			
			assertTrue("MGT:addTCMSprite bad x coord",firstBounds.x == secondBounds.x);
			assertTrue("MGT:addTCMSprite bad y coord",firstBounds.y == secondBounds.y);
			assertTrue("MGT:addTCMSprite bad width",firstBounds.width == secondBounds.width);
			assertTrue("MGT:addTCMSprite bad height",firstBounds.height == secondBounds.height);
		}

		private function addTextFlowSprite(x:Number, y:Number, width:Number, height:Number, textAlign:String, verticalAlign:String, lineBreak:String, textFlow:TextFlow,
			format:TextLayoutFormat):void
		{
			sprite = new Sprite();
			sprite.x = x;
			sprite.y = y;

			textFlow.interactionManager = new EditManager();


			textFlow.format = format;
			textFlow.textAlign = textAlign;
			textFlow.verticalAlign = verticalAlign;
			textFlow.lineBreak = lineBreak;

			var controller:ContainerController = new ContainerController(sprite,width,height);
			controller.verticalScrollPolicy = scrollPolicy;
			controller.horizontalScrollPolicy = scrollPolicy;
		//	controller.format = format;  Test adding padding directly to the container
			// trace(x,y,controller.compositionWidth,controller.compositionHeight,scrollPolicy);
			// trace(TextConverter.export(textFlow,TextConverter.TEXT_LAYOUT_FORMAT,ConversionType.STRING_TYPE));

			textFlow.flowComposer.addController(controller);
			textFlow.flowComposer.updateAllControllers();
			addToCanvas(sprite);
			drawFlowComposerBounds(textFlow);
			// trace(controller.getContentBounds());
			// trace("addTextFlowSprite is running");
		}

		private function drawFlowComposerBounds(textFlow:TextFlow):void
		{
			// composition bounds in black
			var controller:ContainerController = textFlow.flowComposer.getControllerAt(0);
			var controllerSprite:Sprite = controller.container;
			var scrollx:Number = controllerSprite.scrollRect ? controllerSprite.scrollRect.x : 0;
			var scrolly:Number = controllerSprite.scrollRect ? controllerSprite.scrollRect.y : 0;

			sprite = new Sprite(); // controller.container as Sprite;
			sprite.x = controllerSprite.x;
			sprite.y = controllerSprite.y;
			addToCanvas(sprite);
			var g:Graphics = sprite.graphics;
			g.clear();
			drawCircle(g, 0xff00, 0, 0, 3);
			strokeRect(g, 1, 0x0, 0, 0, width, height);
			// contentBounds in red
			compareBounds = controller.getContentBounds();
			strokeRect(g, 1, 0xFF0000, compareBounds.x-scrollx, compareBounds.y-scrolly, compareBounds.width, compareBounds.height);
			tFlowBounds = controller.getContentBounds();
			tFlowBounds.x = compareBounds.x-scrollx;
			tFlowBounds.y = compareBounds.y-scrolly;
			
			if (kVerbose)
				trace(TestID,_creationType,textFlow.textAlign,textFlow.verticalAlign,textFlow.lineBreak,width,height,compareBounds);
		}

		private function addLabel(x:Number, y:Number, width:Number, height:Number, text:String = ""):void
		{
			var sprite:Sprite = new Sprite();
			sprite.x = x;
			sprite.y = y;
			labelFactory.compositionBounds = new Rectangle(0,0,width,height);
			labelFactory.text = text;

			labelFactory.createTextLines(callback);
			addToCanvas(sprite);

			function callback(tl:TextLine):void
			{
				sprite.addChild(tl);
			}
		}

		private function strokeRect(g:Graphics, stroke:Number, color:uint, x:Number, y:Number, width:Number, height:Number):void
		{
			if (width <= 0 || height <= 0)
				return;
			g.lineStyle(stroke, color);
			g.moveTo(x, y);
			g.lineTo(x + width, y);
			g.lineTo(x + width, y + height);
			g.lineTo(x, y + height);
			g.lineTo(x, y);
		}

		private function drawCircle(g:Graphics, color:uint, x:Number, y:Number, radius:Number):void
		{
			g.beginFill(color);
			g.drawCircle(x,y,radius);
			g.endFill();
		}


		/********************** Tests Start Here ***************************/

		public function testSimpleText():void
		{
			runTest("Hello again", createDefaultTextLayoutFormat());
		}


		public function testMultipleLines():void
		{
			// Multiple Lines
			marginOfError = 35;
			runTest("Hello again\nAnother longer line to test", createDefaultTextLayoutFormat());
		}

		public function testExtraLines():void
		{
			// Multiple Lines
			runTest("Line1\nLine2\nLine3", createDefaultTextLayoutFormat());
		}

		public function testTrailingSpaces():void
		{
			// Trailing spaces
			marginOfError = 12;
			runTest("Hello again  ", createDefaultTextLayoutFormat());
		}

		public function testHeightNoWidth():void
		{
			// Height but no width
			width = NaN;
			runTest("Hello again", createDefaultTextLayoutFormat());
		}

		public function testWidthNoHeight():void
		{
			// Width but no height
			height = NaN;
			runTest("Hello again", createDefaultTextLayoutFormat());
		}

		public function testEmptyText():void
		{
			// Empty text
			paddingWidth = 22;
			paddingHeight = 200;
			runTest("", createDefaultTextLayoutFormat());
		}

		public function testPaddingLeftAndTop():void
		{
			// Padding on left and top
			var format:TextLayoutFormat = createDefaultTextLayoutFormat();
			format.paddingLeft = 20;
			format.paddingTop = 10;
			paddingHeight = 92;
			runTest("Hello again", format);
		}

		public function testPaddingRightAndBottom():void
		{
			// Padding on right and bottom
			var format:TextLayoutFormat = createDefaultTextLayoutFormat();
			format.paddingRight = 20;
			format.paddingBottom = 10;
			paddingHeight = 92;
			runTest("Hello again", format);
		}

		public function testMultipleColumns():void
		{
			// Multiple Columns
			var format:TextLayoutFormat = createDefaultTextLayoutFormat();
			format.columnGap = 10;
			format.columnCount = 2;
			paddingHeight = 48;
			runTest("Hello again", format);
		}

		public function testInlineAtStartOfFlow():void
		{
			var format:TextLayoutFormat = createDefaultTextLayoutFormat();
			format.fontSize = 12;
			var markup:String = '<TextFlow xmlns="http://ns.adobe.com/textLayout/2008"><img id="im" width="25" height="25" source="' + LoaderUtil.createAbsoluteURL(baseURL,"../../test/testFiles/assets/smiley.gif") + '" />The quick brown fox</TextFlow>';
			paddingHeight = 66;
			runTest(markup, format);
		}

		public function testInlineAtStartOfFlowBigText():void
		{
			var format:TextLayoutFormat = createDefaultTextLayoutFormat();
			format.fontSize = 48;
			var markup:String = '<TextFlow xmlns="http://ns.adobe.com/textLayout/2008"><img id="im" width="25" height="25" source="' + LoaderUtil.createAbsoluteURL(baseURL,"../../test/testFiles/assets/smiley.gif") + '" />Hi</TextFlow>';
			paddingHeight = 130;
			runTest(markup, format);
		}

		public function testStartIndent():void
		{
			var format:TextLayoutFormat = createDefaultTextLayoutFormat();
			format.fontSize = 24;
			format.paragraphStartIndent = 30;
			marginOfError = 47;
			runTest('The quick brown fox', format);
		}

		public function testEndIndent():void
		{
			var format:TextLayoutFormat = createDefaultTextLayoutFormat();
			format.fontSize = 24;
			format.paragraphEndIndent = 30;
			marginOfError = 3;
			paddingHeight = 65;
			runTest('The quick brown fox', format);
		}

		public function testNegTextIndent():void
		{
			var format:TextLayoutFormat = createDefaultTextLayoutFormat();
			format.fontSize = 24;
			format.textIndent = -30;
			marginOfError = 30;
			runTest('The quick brown fox', format);
		}

		public function testSpaceBefore():void
		{
			var format:TextLayoutFormat = createDefaultTextLayoutFormat();
			format.fontSize = 24;
			format.paragraphSpaceBefore = 30;
			marginOfError = 3;
			paddingHeight = 22;
			runTest('The quick brown fox', format);
		}

		public function testSpaceAfter():void
		{
			var format:TextLayoutFormat = createDefaultTextLayoutFormat();
			format.fontSize = 24;
			format.paragraphSpaceAfter = 30;
			marginOfError = 3;
			paddingHeight = 22;
			runTest('The quick brown fox', format);
		}


		// Ideographic baseline examples needed


	}
}