automation_tests/src/UnitTest/Tests/EventOverrideTest.as - flex-tlf - Git at Google

 ////////////////////////////////////////////////////////////////////////////////
 //
 //  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.TestSuiteExtended;
 	import UnitTest.ExtendedClasses.VellumTestCase;
 	import UnitTest.Fixtures.TestConfig;

 	import flash.events.*;
 	import flash.ui.KeyLocation;

 	import flashx.textLayout.edit.EditManager;
 	import flashx.textLayout.elements.TextFlow;
 	import flashx.undo.UndoManager;

 	public class EventOverrideTest extends VellumTestCase
 	{
 		public function EventOverrideTest(methodName:String, testID:String, testConfig:TestConfig, testCaseXML:XML=null)
 		{
 			super(methodName, testID, testConfig, testCaseXML);

 			if ( TestData.eventOverride )
    			{
    				TestID = TestID + ":" + TestData.eventOverride;
    			}

    			// Note: These must correspond to a Watson product area (case-sensitive)
    			metaData.productArea = "Editing";
 		}

 		public static function suiteFromXML(testListXML:XML, testConfig:TestConfig, ts:TestSuiteExtended):void
  		{
  			var testCaseClass:Class = EventOverrideTest;
  			VellumTestCase.suiteFromXML(testCaseClass, testListXML, testConfig, ts);
  		}

    		public override function setUp():void
    		{
    			/*if ( TestData.eventOverride )
    			{
    				TextFlow.defaultConfiguration.manageEventListeners = false;
    			}*/

    			super.setUp();

    			if ( TestData.overrideEditManager == "true" )
    			{
 	   			var testManager:EditManager = new TestEditManager(new UndoManager());
 	   			SelManager.textFlow.interactionManager = testManager;
 	   			SelManager = testManager;
 	   			SelManager.selectRange(0,0);
 	   		}
    		}

    		public override function tearDown():void
    		{
    			/*if ( TestData.eventOverride )
    			{
 	   			TextFlow.defaultConfiguration.manageEventListeners = true;
 	   			// Make sure we leave without a broken TextFlow
 				loadTestFile("empty.xml");
    			}*/

    			if ( TestData.overrideEditManager == "true" )
    			{
 	   			var newManager:EditManager = new EditManager(new UndoManager());
 	   			SelManager.textFlow.interactionManager = newManager;
 	   			SelManager = newManager;
 	   		}
    		}

    		// Returns the string from begIdx through and including endIdx
    		private function getText( begIdx:int, endIdx:int ): String
    		{
    			var outString:String = "";

    			for ( var x:int = begIdx; x < endIdx; x++ )
    			{
    				outString += SelManager.textFlow.getCharAtPosition(x);
    			}

    			return outString;
    		}

    		// Returns the text contents of the entire textflow
    		private function getAllText(): String
    		{
    			var begIdx:int = SelManager.textFlow.parentRelativeStart;
    			var endIdx:int = SelManager.textFlow.parentRelativeEnd-1;
    			var outString:String = "";

    			for ( var x:int = begIdx; x < endIdx; x++ )
    			{
    				outString += SelManager.textFlow.getCharAtPosition(x);
    			}

    			return outString;
    		}

 /******* Framework for event override tests (Not using derived editmanager ***********************/
 /** Removing for expected ARB-related updates - probably to be removed permanently
  *
    		private function eventFromText( textID:String, addListener:Boolean, removeListener:Boolean = false ):Event
    		{
 			var outEvent:Event;

 			switch ( textID )
 			{
 				case "MOUSE_DOWN":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( MouseEvent.MOUSE_DOWN, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( MouseEvent.MOUSE_DOWN, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new MouseEvent( MouseEvent.MOUSE_DOWN, true, false, 0, 0 );
 						return outEvent;
 					}
 					break;
 				case "MOUSE_OVER":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( MouseEvent.MOUSE_OVER, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( MouseEvent.MOUSE_OVER, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new MouseEvent( MouseEvent.MOUSE_OVER, true, false, 0, 0 );
 						return outEvent;
 					}
 					break;
 				case "MOUSE_OUT":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( MouseEvent.MOUSE_OUT, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( MouseEvent.MOUSE_OUT, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new MouseEvent( MouseEvent.MOUSE_OUT, true, false, 0, 0 );
 						return outEvent;
 					}
 					break;
 				case "MOUSE_WHEEL":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( MouseEvent.MOUSE_WHEEL, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( MouseEvent.MOUSE_WHEEL, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new MouseEvent( MouseEvent.MOUSE_WHEEL, true, false, 0, 0 );
 						return outEvent;
 					}
 					break;
 				case "DOUBLE_CLICK":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( MouseEvent.DOUBLE_CLICK, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( MouseEvent.DOUBLE_CLICK, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new MouseEvent( MouseEvent.DOUBLE_CLICK, true, false, 0, 0 );
 						return outEvent;
 					}
 					break;
 				case "KEY_DOWN":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( KeyboardEvent.KEY_DOWN, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( KeyboardEvent.KEY_DOWN, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false,
 											 8, 8, KeyLocation.STANDARD, true, false, false);
 						return outEvent;
 					}
 					break;
 				case "FOCUS_IN":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( FocusEvent.FOCUS_IN, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( FocusEvent.FOCUS_IN, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new FocusEvent( FocusEvent.FOCUS_IN );
 						return outEvent;
 					}
 					break;
 				case "FOCUS_OUT":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( FocusEvent.FOCUS_OUT, eventHandler );
 					}
 					else
 					if (addListener)
 					{
 						SelManager.textFlow.addEventListener( FocusEvent.FOCUS_OUT, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new FocusEvent( FocusEvent.FOCUS_OUT );
 						return outEvent;
 					}
 					break;
 				case "TEXT_INPUT":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( TextEvent.TEXT_INPUT, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( TextEvent.TEXT_INPUT, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new TextEvent( TextEvent.TEXT_INPUT, false, true, "WONTSEEME" );
 						return outEvent;
 					}
 					break;
 				case "ACTIVATE":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( Event.ACTIVATE, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( Event.ACTIVATE, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new Event( Event.ACTIVATE );
 						return outEvent;
 					}
 					break;
 				case "DEACTIVATE":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( Event.DEACTIVATE, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( Event.DEACTIVATE, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new Event( Event.DEACTIVATE );
 						return outEvent;
 					}
 					break;
 				case "MENU_SELECT":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( ContextMenuEvent.MENU_SELECT, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( ContextMenuEvent.MENU_SELECT, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new ContextMenuEvent( ContextMenuEvent.MENU_SELECT );
 						return outEvent;
 					}
 					break;
 				case "SELECT_ALL":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( Event.SELECT_ALL, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( Event.SELECT_ALL, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new Event( Event.SELECT_ALL );
 						return outEvent;
 					}
 					break;
 				case "COPY":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( Event.COPY, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( Event.COPY, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new Event( Event.COPY );
 						return outEvent;
 					}
 					break;
 				case "CUT":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( Event.CUT, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( Event.CUT, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new Event( Event.CUT );
 						return outEvent;
 					}
 					break;
 				case "PASTE":
 					if ( removeListener )
 					{
 						SelManager.textFlow.removeEventListener( Event.PASTE, eventHandler );
 					}
 					else if (addListener)
 					{
 						SelManager.textFlow.addEventListener( Event.PASTE, eventHandler, false, 0, true );
 						return null;
 					}
 					else
 					{
 						outEvent = new Event( Event.PASTE );
 						return outEvent;
 					}
 					break;
 			}

 			return null;
    		}

    		// Generic event handler
    		// How can this be made more even specific?
    		private function eventHandler( event:Event ):void
    		{
    			SelManager.insertText("EVENT");
    		}

    		// Generic test case for all event overrides
    		public function testEventOverride():void
    		{
    			SelManager.insertText("StillHere");
    			SelManager.selectRange(9,9);

    			// Add event listener
    			eventFromText( TestData.eventOverride, true );

    			var newEvent:Event = eventFromText( TestData.eventOverride, false );
    			assertTrue( "Test Case Failure: Unable to find event specified in XML",
    						newEvent != null );
    			SelManager.textFlow.dispatchEvent(newEvent);

    			SelManager.flushPendingOperations();
    			assertTrue( TestData.eventOverride + " event was not executed after override",
 						getAllText() == "StillHereEVENT" );
 			assertTrue( TestData.eventOverride + " event shouldn't change selection",
 						SelManager.activePosition == 14 && SelManager.anchorPosition == 14 );

 			// Remove event listener
 			eventFromText( TestData.eventOverride, false, true );
    		}
 */
 /************** TESTS USING DERIVED EDITMANAGER **************************************************/

    		public function keyDownDerivedTest():void
    		{
    			SelManager.insertText("StillHere");
    			SelManager.selectRange(9,9);

    			// Send a Ctrl-Backspace
    			var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN,
 				true, false, 8, 8, KeyLocation.STANDARD, true, false, false);
 			TestFrame.container["dispatchEvent"](kEvent);

 			SelManager.flushPendingOperations();

 			assertTrue( "Keyboard event executed normally when overridden",
 						getText(0,9) == "StillHere" );

 			assertTrue( "Keyboard event override was not executed",
 						getAllText() == "StillHereKEYDOWN" );
    		}

    		public function mouseDownDerivedTest():void
    		{
    			var kEvent:MouseEvent = new MouseEvent( MouseEvent.MOUSE_DOWN, true, false, 0, 0 );
 			TestFrame.container["dispatchEvent"](kEvent);

 			SelManager.flushPendingOperations();

 			assertTrue( "Mouse Down event override was not executed",
 						getAllText() == "MOUSEDOWN" );
    		}

    		public function mouseMoveDerivedTest():void
    		{
    			(SelManager as TestEditManager).mouseMoved = false;
    			var kEvent:MouseEvent = new MouseEvent( MouseEvent.MOUSE_DOWN, true, false, 0, 0 );
 			TestFrame.container["dispatchEvent"](kEvent);
    			var mEvent:MouseEvent = new MouseEvent( MouseEvent.MOUSE_MOVE, true, false,
    											 20, 20 );
 			TestFrame.container["dispatchEvent"](mEvent);

 			SelManager.flushPendingOperations();

 			assertTrue( "Mouse Move event override was not executed",
 						getAllText() == "MOUSEDOWNMOUSEMOVE" );
    		}

    		public function textEventDerivedTest():void
    		{
    			// Send 'a' string
    			var kEvent:TextEvent = new TextEvent( TextEvent.TEXT_INPUT, false, false, "a" );
 			TestFrame.container["dispatchEvent"](kEvent);

 			SelManager.flushPendingOperations();

 			assertTrue( "Text Event override was not executed",
 						getAllText() == "TEXTEVENT" );
    		}

    		public function focusInDerivedTest():void
    		{
    			var kEvent:FocusEvent = new FocusEvent( FocusEvent.FOCUS_IN );
 			TestFrame.container["dispatchEvent"](kEvent);

 			SelManager.flushPendingOperations();

 			assertTrue( "Focus In override was not executed",
 						getAllText() == "FOCUSIN" );
    		}

    		public function focusOutDerivedTest():void
    		{
    			var kEvent:FocusEvent = new FocusEvent( FocusEvent.FOCUS_OUT );
 			TestFrame.container["dispatchEvent"](kEvent);

 			SelManager.flushPendingOperations();

 			assertTrue( "Focus Out override was not executed",
 						getAllText() == "FOCUSOUT" );
    		}

    		public function activateDerivedTest():void
    		{
    			var kEvent:Event = new Event( Event.ACTIVATE );
 			TestFrame.container["dispatchEvent"](kEvent);

 			SelManager.flushPendingOperations();

 			assertTrue( "Activate override was not executed",
 						getAllText() == "ACTIVATE" );
    		}

    		public function deactivateDerivedTest():void
    		{
    			var kEvent:Event = new Event( Event.DEACTIVATE );
 			TestFrame.container["dispatchEvent"](kEvent);

 			SelManager.flushPendingOperations();

 			assertTrue( "Deactivate override was not executed",
 						getAllText() == "DEACTIVATE" );
    		}

    		public function deleteNextDerivedTest():void
    		{
    			(SelManager as TestEditManager).useDefaultKeyDown = true;

    			var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false, 127, 46 );
 			TestFrame.container["dispatchEvent"](kEvent);

 			SelManager.flushPendingOperations();

 			assertTrue( "Delete Next override was not executed by pressing 'Delete'",
 						getAllText() == "DELETENEXT" );

 			(SelManager as TestEditManager).useDefaultKeyDown = false;
    		}

    		public function deletePreviousDerivedTest():void
    		{
    			(SelManager as TestEditManager).useDefaultKeyDown = true;

    			var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false, 8, 8 );
 			TestFrame.container["dispatchEvent"](kEvent);

 			SelManager.flushPendingOperations();

 			assertTrue( "Delete Previous override was not executed by pressing 'Backspace'",
 						getAllText() == "DELETEPREVIOUS" );

 			(SelManager as TestEditManager).useDefaultKeyDown = false;
    		}

    		public function deleteNextWordDerivedTest():void
    		{
    			(SelManager as TestEditManager).useDefaultKeyDown = true;

    			var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false, 127, 46, 0, true );
 			TestFrame.container["dispatchEvent"](kEvent);

 			SelManager.flushPendingOperations();

 			assertTrue( "Delete Next override was not executed by pressing 'Ctrl-Delete'",
 						getAllText() == "DELETENEXTWORD" );

 			(SelManager as TestEditManager).useDefaultKeyDown = false;
    		}

    		public function deletePreviousWordDerivedTest():void
    		{
    			(SelManager as TestEditManager).useDefaultKeyDown = true;

    			var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false, 8, 8, 0, true );
 			TestFrame.container["dispatchEvent"](kEvent);

 			SelManager.flushPendingOperations();

 			assertTrue( "Delete Previous override was not executed by pressing 'Ctrl-Backspace'",
 						getAllText() == "DELETEPREVIOUSWORD" );

 			(SelManager as TestEditManager).useDefaultKeyDown = false;
    		}
 	}
 }

 /********Editmanager for overriding events - Internal Helper Class**********************************/

 import flashx.textLayout.edit.EditManager;
 import flashx.undo.IUndoManager;
 import flash.events.KeyboardEvent;
 import flash.events.MouseEvent;
 import flash.events.TextEvent;
 import flash.events.FocusEvent;
 import flash.events.Event;
 import flashx.textLayout.edit.SelectionState;

 internal class TestEditManager extends EditManager
 {
 	public var mouseMoved:Boolean;
 	public var useDefaultKeyDown:Boolean;

 	public function TestEditManager(undo:IUndoManager = null)
 	{
 		super(undo);

 		useDefaultKeyDown = false;

 		// Don't react to this event and ruin a different test
 		mouseMoved = true;
 	}

 	public override function keyDownHandler(event:KeyboardEvent):void
 	{
 		if ( useDefaultKeyDown == true )
 			super.keyDownHandler(event);
 		else
 			insertText("KEYDOWN");
 	}

 	public override function mouseDownHandler(event:MouseEvent):void
 	{ insertText("MOUSEDOWN"); }

 	public override function mouseMoveHandler(event:MouseEvent):void
 	{
 		// Don't react to this event more than once
 		if ( !mouseMoved)
 		{
 			insertText("MOUSEMOVE");
 			mouseMoved = true;
 		}
 	}

 	public override function textInputHandler(event:TextEvent):void
 	{ insertText("TEXTEVENT"); }

 	public override function focusInHandler(event:FocusEvent):void
 	{ insertText("FOCUSIN"); }

 	public override function focusOutHandler(event:FocusEvent):void
 	{ insertText("FOCUSOUT"); }

 	public override function activateHandler(event:Event):void
 	{ insertText("ACTIVATE"); }

 	public override function deactivateHandler(event:Event):void
 	{ insertText("DEACTIVATE"); }

 	/***** EDITMANAGER OVERRIDES *****/

 	public override function deleteNextCharacter(operationState:SelectionState=null):void
 	{ insertText("DELETENEXT"); }

 	public override function deletePreviousCharacter(operationState:SelectionState=null):void
 	{ insertText("DELETEPREVIOUS"); }

 	public override function deleteNextWord(operationState:SelectionState=null):void
 	{ insertText("DELETENEXTWORD"); }

 	public override function deletePreviousWord(operationState:SelectionState=null):void
 	{ insertText("DELETEPREVIOUSWORD"); }

 }
	////////////////////////////////////////////////////////////////////////////////
	//
	// 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.TestSuiteExtended;
	import UnitTest.ExtendedClasses.VellumTestCase;
	import UnitTest.Fixtures.TestConfig;

	import flash.events.*;
	import flash.ui.KeyLocation;

	import flashx.textLayout.edit.EditManager;
	import flashx.textLayout.elements.TextFlow;
	import flashx.undo.UndoManager;

	public class EventOverrideTest extends VellumTestCase
	{
	public function EventOverrideTest(methodName:String, testID:String, testConfig:TestConfig, testCaseXML:XML=null)
	{
	super(methodName, testID, testConfig, testCaseXML);

	if ( TestData.eventOverride )
	{
	TestID = TestID + ":" + TestData.eventOverride;
	}

	// Note: These must correspond to a Watson product area (case-sensitive)
	metaData.productArea = "Editing";
	}

	public static function suiteFromXML(testListXML:XML, testConfig:TestConfig, ts:TestSuiteExtended):void
	{
	var testCaseClass:Class = EventOverrideTest;
	VellumTestCase.suiteFromXML(testCaseClass, testListXML, testConfig, ts);
	}

	public override function setUp():void
	{
	/*if ( TestData.eventOverride )
	{
	TextFlow.defaultConfiguration.manageEventListeners = false;
	}*/

	super.setUp();

	if ( TestData.overrideEditManager == "true" )
	{
	var testManager:EditManager = new TestEditManager(new UndoManager());
	SelManager.textFlow.interactionManager = testManager;
	SelManager = testManager;
	SelManager.selectRange(0,0);
	}
	}

	public override function tearDown():void
	{
	/*if ( TestData.eventOverride )
	{
	TextFlow.defaultConfiguration.manageEventListeners = true;
	// Make sure we leave without a broken TextFlow
	loadTestFile("empty.xml");
	}*/

	if ( TestData.overrideEditManager == "true" )
	{
	var newManager:EditManager = new EditManager(new UndoManager());
	SelManager.textFlow.interactionManager = newManager;
	SelManager = newManager;
	}
	}

	// Returns the string from begIdx through and including endIdx
	private function getText( begIdx:int, endIdx:int ): String
	{
	var outString:String = "";

	for ( var x:int = begIdx; x < endIdx; x++ )
	{
	outString += SelManager.textFlow.getCharAtPosition(x);
	}

	return outString;
	}

	// Returns the text contents of the entire textflow
	private function getAllText(): String
	{
	var begIdx:int = SelManager.textFlow.parentRelativeStart;
	var endIdx:int = SelManager.textFlow.parentRelativeEnd-1;
	var outString:String = "";

	for ( var x:int = begIdx; x < endIdx; x++ )
	{
	outString += SelManager.textFlow.getCharAtPosition(x);
	}

	return outString;
	}

	/***** Framework for event override tests (Not using derived editmanager *********************/
	/** Removing for expected ARB-related updates - probably to be removed permanently
	*
	private function eventFromText( textID:String, addListener:Boolean, removeListener:Boolean = false ):Event
	{
	var outEvent:Event;

	switch ( textID )
	{
	case "MOUSE_DOWN":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( MouseEvent.MOUSE_DOWN, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( MouseEvent.MOUSE_DOWN, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new MouseEvent( MouseEvent.MOUSE_DOWN, true, false, 0, 0 );
	return outEvent;
	}
	break;
	case "MOUSE_OVER":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( MouseEvent.MOUSE_OVER, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( MouseEvent.MOUSE_OVER, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new MouseEvent( MouseEvent.MOUSE_OVER, true, false, 0, 0 );
	return outEvent;
	}
	break;
	case "MOUSE_OUT":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( MouseEvent.MOUSE_OUT, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( MouseEvent.MOUSE_OUT, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new MouseEvent( MouseEvent.MOUSE_OUT, true, false, 0, 0 );
	return outEvent;
	}
	break;
	case "MOUSE_WHEEL":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( MouseEvent.MOUSE_WHEEL, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( MouseEvent.MOUSE_WHEEL, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new MouseEvent( MouseEvent.MOUSE_WHEEL, true, false, 0, 0 );
	return outEvent;
	}
	break;
	case "DOUBLE_CLICK":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( MouseEvent.DOUBLE_CLICK, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( MouseEvent.DOUBLE_CLICK, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new MouseEvent( MouseEvent.DOUBLE_CLICK, true, false, 0, 0 );
	return outEvent;
	}
	break;
	case "KEY_DOWN":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( KeyboardEvent.KEY_DOWN, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( KeyboardEvent.KEY_DOWN, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false,
	8, 8, KeyLocation.STANDARD, true, false, false);
	return outEvent;
	}
	break;
	case "FOCUS_IN":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( FocusEvent.FOCUS_IN, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( FocusEvent.FOCUS_IN, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new FocusEvent( FocusEvent.FOCUS_IN );
	return outEvent;
	}
	break;
	case "FOCUS_OUT":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( FocusEvent.FOCUS_OUT, eventHandler );
	}
	else
	if (addListener)
	{
	SelManager.textFlow.addEventListener( FocusEvent.FOCUS_OUT, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new FocusEvent( FocusEvent.FOCUS_OUT );
	return outEvent;
	}
	break;
	case "TEXT_INPUT":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( TextEvent.TEXT_INPUT, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( TextEvent.TEXT_INPUT, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new TextEvent( TextEvent.TEXT_INPUT, false, true, "WONTSEEME" );
	return outEvent;
	}
	break;
	case "ACTIVATE":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( Event.ACTIVATE, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( Event.ACTIVATE, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new Event( Event.ACTIVATE );
	return outEvent;
	}
	break;
	case "DEACTIVATE":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( Event.DEACTIVATE, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( Event.DEACTIVATE, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new Event( Event.DEACTIVATE );
	return outEvent;
	}
	break;
	case "MENU_SELECT":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( ContextMenuEvent.MENU_SELECT, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( ContextMenuEvent.MENU_SELECT, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new ContextMenuEvent( ContextMenuEvent.MENU_SELECT );
	return outEvent;
	}
	break;
	case "SELECT_ALL":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( Event.SELECT_ALL, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( Event.SELECT_ALL, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new Event( Event.SELECT_ALL );
	return outEvent;
	}
	break;
	case "COPY":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( Event.COPY, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( Event.COPY, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new Event( Event.COPY );
	return outEvent;
	}
	break;
	case "CUT":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( Event.CUT, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( Event.CUT, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new Event( Event.CUT );
	return outEvent;
	}
	break;
	case "PASTE":
	if ( removeListener )
	{
	SelManager.textFlow.removeEventListener( Event.PASTE, eventHandler );
	}
	else if (addListener)
	{
	SelManager.textFlow.addEventListener( Event.PASTE, eventHandler, false, 0, true );
	return null;
	}
	else
	{
	outEvent = new Event( Event.PASTE );
	return outEvent;
	}
	break;
	}

	return null;
	}

	// Generic event handler
	// How can this be made more even specific?
	private function eventHandler( event:Event ):void
	{
	SelManager.insertText("EVENT");
	}

	// Generic test case for all event overrides
	public function testEventOverride():void
	{
	SelManager.insertText("StillHere");
	SelManager.selectRange(9,9);

	// Add event listener
	eventFromText( TestData.eventOverride, true );

	var newEvent:Event = eventFromText( TestData.eventOverride, false );
	assertTrue( "Test Case Failure: Unable to find event specified in XML",
	newEvent != null );
	SelManager.textFlow.dispatchEvent(newEvent);

	SelManager.flushPendingOperations();
	assertTrue( TestData.eventOverride + " event was not executed after override",
	getAllText() == "StillHereEVENT" );
	assertTrue( TestData.eventOverride + " event shouldn't change selection",
	SelManager.activePosition == 14 && SelManager.anchorPosition == 14 );

	// Remove event listener
	eventFromText( TestData.eventOverride, false, true );
	}
	*/
	/************ TESTS USING DERIVED EDITMANAGER ************************************************/

	public function keyDownDerivedTest():void
	{
	SelManager.insertText("StillHere");
	SelManager.selectRange(9,9);

	// Send a Ctrl-Backspace
	var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN,
	true, false, 8, 8, KeyLocation.STANDARD, true, false, false);
	TestFrame.container["dispatchEvent"](kEvent);

	SelManager.flushPendingOperations();

	assertTrue( "Keyboard event executed normally when overridden",
	getText(0,9) == "StillHere" );

	assertTrue( "Keyboard event override was not executed",
	getAllText() == "StillHereKEYDOWN" );
	}

	public function mouseDownDerivedTest():void
	{
	var kEvent:MouseEvent = new MouseEvent( MouseEvent.MOUSE_DOWN, true, false, 0, 0 );
	TestFrame.container["dispatchEvent"](kEvent);

	SelManager.flushPendingOperations();

	assertTrue( "Mouse Down event override was not executed",
	getAllText() == "MOUSEDOWN" );
	}

	public function mouseMoveDerivedTest():void
	{
	(SelManager as TestEditManager).mouseMoved = false;
	var kEvent:MouseEvent = new MouseEvent( MouseEvent.MOUSE_DOWN, true, false, 0, 0 );
	TestFrame.container["dispatchEvent"](kEvent);
	var mEvent:MouseEvent = new MouseEvent( MouseEvent.MOUSE_MOVE, true, false,
	20, 20 );
	TestFrame.container["dispatchEvent"](mEvent);

	SelManager.flushPendingOperations();

	assertTrue( "Mouse Move event override was not executed",
	getAllText() == "MOUSEDOWNMOUSEMOVE" );
	}

	public function textEventDerivedTest():void
	{
	// Send 'a' string
	var kEvent:TextEvent = new TextEvent( TextEvent.TEXT_INPUT, false, false, "a" );
	TestFrame.container["dispatchEvent"](kEvent);

	SelManager.flushPendingOperations();

	assertTrue( "Text Event override was not executed",
	getAllText() == "TEXTEVENT" );
	}

	public function focusInDerivedTest():void
	{
	var kEvent:FocusEvent = new FocusEvent( FocusEvent.FOCUS_IN );
	TestFrame.container["dispatchEvent"](kEvent);

	SelManager.flushPendingOperations();

	assertTrue( "Focus In override was not executed",
	getAllText() == "FOCUSIN" );
	}

	public function focusOutDerivedTest():void
	{
	var kEvent:FocusEvent = new FocusEvent( FocusEvent.FOCUS_OUT );
	TestFrame.container["dispatchEvent"](kEvent);

	SelManager.flushPendingOperations();

	assertTrue( "Focus Out override was not executed",
	getAllText() == "FOCUSOUT" );
	}

	public function activateDerivedTest():void
	{
	var kEvent:Event = new Event( Event.ACTIVATE );
	TestFrame.container["dispatchEvent"](kEvent);

	SelManager.flushPendingOperations();

	assertTrue( "Activate override was not executed",
	getAllText() == "ACTIVATE" );
	}

	public function deactivateDerivedTest():void
	{
	var kEvent:Event = new Event( Event.DEACTIVATE );
	TestFrame.container["dispatchEvent"](kEvent);

	SelManager.flushPendingOperations();

	assertTrue( "Deactivate override was not executed",
	getAllText() == "DEACTIVATE" );
	}

	public function deleteNextDerivedTest():void
	{
	(SelManager as TestEditManager).useDefaultKeyDown = true;

	var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false, 127, 46 );
	TestFrame.container["dispatchEvent"](kEvent);

	SelManager.flushPendingOperations();

	assertTrue( "Delete Next override was not executed by pressing 'Delete'",
	getAllText() == "DELETENEXT" );

	(SelManager as TestEditManager).useDefaultKeyDown = false;
	}

	public function deletePreviousDerivedTest():void
	{
	(SelManager as TestEditManager).useDefaultKeyDown = true;

	var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false, 8, 8 );
	TestFrame.container["dispatchEvent"](kEvent);

	SelManager.flushPendingOperations();

	assertTrue( "Delete Previous override was not executed by pressing 'Backspace'",
	getAllText() == "DELETEPREVIOUS" );

	(SelManager as TestEditManager).useDefaultKeyDown = false;
	}

	public function deleteNextWordDerivedTest():void
	{
	(SelManager as TestEditManager).useDefaultKeyDown = true;

	var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false, 127, 46, 0, true );
	TestFrame.container["dispatchEvent"](kEvent);

	SelManager.flushPendingOperations();

	assertTrue( "Delete Next override was not executed by pressing 'Ctrl-Delete'",
	getAllText() == "DELETENEXTWORD" );

	(SelManager as TestEditManager).useDefaultKeyDown = false;
	}

	public function deletePreviousWordDerivedTest():void
	{
	(SelManager as TestEditManager).useDefaultKeyDown = true;

	var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN, true, false, 8, 8, 0, true );
	TestFrame.container["dispatchEvent"](kEvent);

	SelManager.flushPendingOperations();

	assertTrue( "Delete Previous override was not executed by pressing 'Ctrl-Backspace'",
	getAllText() == "DELETEPREVIOUSWORD" );

	(SelManager as TestEditManager).useDefaultKeyDown = false;
	}
	}
	}

	/******Editmanager for overriding events - Internal Helper Class********************************/

	import flashx.textLayout.edit.EditManager;
	import flashx.undo.IUndoManager;
	import flash.events.KeyboardEvent;
	import flash.events.MouseEvent;
	import flash.events.TextEvent;
	import flash.events.FocusEvent;
	import flash.events.Event;
	import flashx.textLayout.edit.SelectionState;

	internal class TestEditManager extends EditManager
	{
	public var mouseMoved:Boolean;
	public var useDefaultKeyDown:Boolean;

	public function TestEditManager(undo:IUndoManager = null)
	{
	super(undo);

	useDefaultKeyDown = false;

	// Don't react to this event and ruin a different test
	mouseMoved = true;
	}

	public override function keyDownHandler(event:KeyboardEvent):void
	{
	if ( useDefaultKeyDown == true )
	super.keyDownHandler(event);
	else
	insertText("KEYDOWN");
	}

	public override function mouseDownHandler(event:MouseEvent):void
	{ insertText("MOUSEDOWN"); }

	public override function mouseMoveHandler(event:MouseEvent):void
	{
	// Don't react to this event more than once
	if ( !mouseMoved)
	{
	insertText("MOUSEMOVE");
	mouseMoved = true;
	}
	}

	public override function textInputHandler(event:TextEvent):void
	{ insertText("TEXTEVENT"); }

	public override function focusInHandler(event:FocusEvent):void
	{ insertText("FOCUSIN"); }

	public override function focusOutHandler(event:FocusEvent):void
	{ insertText("FOCUSOUT"); }

	public override function activateHandler(event:Event):void
	{ insertText("ACTIVATE"); }

	public override function deactivateHandler(event:Event):void
	{ insertText("DEACTIVATE"); }

	/*** EDITMANAGER OVERRIDES ***/

	public override function deleteNextCharacter(operationState:SelectionState=null):void
	{ insertText("DELETENEXT"); }

	public override function deletePreviousCharacter(operationState:SelectionState=null):void
	{ insertText("DELETEPREVIOUS"); }

	public override function deleteNextWord(operationState:SelectionState=null):void
	{ insertText("DELETENEXTWORD"); }

	public override function deletePreviousWord(operationState:SelectionState=null):void
	{ insertText("DELETEPREVIOUSWORD"); }

	}