diff --git a/automation_tests/src/AllTestsSuite.as b/automation_tests/src/AllTestsSuite.as
index 708c768..1e8206a 100644
--- a/automation_tests/src/AllTestsSuite.as
+++ b/automation_tests/src/AllTestsSuite.as
@@ -47,6 +47,7 @@
     import UnitTest.Tests.TabTest;
     import UnitTest.Tests.TextFlowEditTest;
     import UnitTest.Tests.UndoRedoTest;
+    import UnitTest.Tests.VerticalScrollingTest;
     import UnitTest.Tests.WritingModeTest;
 
     [Suite(order=1)]
@@ -82,6 +83,7 @@
         public var importApiTest:ImportAPITest;
         public var keyboardGestureTest:KeyboardGestureTest;
         public var spacingTest:SpacingTest;
+        public var verticalScrollingTest:VerticalScrollingTest;
     }
 
 }
diff --git a/automation_tests/src/UnitTest/Tests/VerticalScrollingTest.as b/automation_tests/src/UnitTest/Tests/VerticalScrollingTest.as
index 86ec159..e698d39 100644
--- a/automation_tests/src/UnitTest/Tests/VerticalScrollingTest.as
+++ b/automation_tests/src/UnitTest/Tests/VerticalScrollingTest.as
@@ -18,1125 +18,1246 @@
 ////////////////////////////////////////////////////////////////////////////////
 package UnitTest.Tests
 {
-	import UnitTest.ExtendedClasses.TestSuiteExtended;
-	import UnitTest.ExtendedClasses.VellumTestCase;
-	import UnitTest.Fixtures.FileRepository;
-	import UnitTest.Fixtures.TestConfig;
+    import UnitTest.ExtendedClasses.TestConfigurationLoader;
+    import UnitTest.ExtendedClasses.VellumTestCase;
+    import UnitTest.Fixtures.TestCaseVo;
+    import UnitTest.Fixtures.TestConfig;
 
-	import flash.events.KeyboardEvent;
-	import flash.events.MouseEvent;
-	import flash.ui.KeyLocation;
+    import flash.events.KeyboardEvent;
+    import flash.events.MouseEvent;
+    import flash.ui.KeyLocation;
 
-	import flashx.textLayout.container.ContainerController;
-	import flashx.textLayout.formats.BlockProgression;
-	import flashx.textLayout.elements.TextFlow;
+    import flashx.textLayout.container.ContainerController;
+    import flashx.textLayout.elements.TextFlow;
+    import flashx.textLayout.formats.BlockProgression;
 
     import org.flexunit.asserts.assertTrue;
 
-
+    [TestCase(order=30)]
+    [RunWith("org.flexunit.runners.Parameterized")]
     public class VerticalScrollingTest extends VellumTestCase
-	{
-		// List of available keyboard gestures
-		// Note that on Mac: CTRL == COMMAND
-		//              and: ALT == OPTION
-		// These are directly mapped in flash player
-		private static const CTRL_BACKSPACE:int   = 100;
-   		private static const CTRL_DELETE:int      = 101;
-   		private static const OPT_BACKSPACE:int    = 102;
-   		private static const OPT_DELETE:int       = 103;
-   		private static const CTRL_LEFT:int        = 104;
-   		private static const CTRL_RIGHT:int       = 105;
-   		private static const CTRL_UP:int          = 106;
-   		private static const CTRL_DOWN:int        = 107;
-   		private static const OPT_LEFT:int         = 108;
-   		private static const OPT_RIGHT:int        = 109;
-   		private static const OPT_UP:int           = 110;
-   		private static const OPT_DOWN:int         = 111;
-   		private static const SHIFT_CTRL_LEFT:int  = 112;
-   		private static const SHIFT_CTRL_RIGHT:int = 113;
-   		private static const SHIFT_CTRL_UP:int    = 114;
-   		private static const SHIFT_CTRL_DOWN:int  = 115;
-   		private static const SHIFT_OPT_LEFT:int   = 116;
-   		private static const SHIFT_OPT_RIGHT:int  = 117;
-   		private static const SHIFT_OPT_UP:int     = 118;
-   		private static const SHIFT_OPT_DOWN:int   = 119;
-   		private static const HOME:int             = 120;
-   		private static const END:int              = 121;
-   		private static const SHIFT_HOME:int       = 122;
-   		private static const SHIFT_END:int        = 123;
-   		private static const CTRL_HOME:int        = 124;
-   		private static const CTRL_END:int         = 125;
-   		private static const SHIFT_CTRL_HOME:int  = 126;
-   		private static const SHIFT_CTRL_END:int   = 127;
-   		private static const PG_UP:int            = 128;
-   		private static const PG_DOWN:int          = 129;
-   		private static const SHIFT_PG_UP:int      = 130;
-   		private static const SHIFT_PG_DOWN:int    = 131;
-   		private static const UP:int          	  = 132;
-   		private static const DOWN:int     	      = 133;
-   		private static const LEFT:int     		  = 134;
-   		private static const RIGHT:int    		  = 135;
+    {
+        // List of available keyboard gestures
+        // Note that on Mac: CTRL == COMMAND
+        //              and: ALT == OPTION
+        // These are directly mapped in flash player
+        private static const CTRL_BACKSPACE:int = 100;
+        private static const CTRL_DELETE:int = 101;
+        private static const OPT_BACKSPACE:int = 102;
+        private static const OPT_DELETE:int = 103;
+        private static const CTRL_LEFT:int = 104;
+        private static const CTRL_RIGHT:int = 105;
+        private static const CTRL_UP:int = 106;
+        private static const CTRL_DOWN:int = 107;
+        private static const OPT_LEFT:int = 108;
+        private static const OPT_RIGHT:int = 109;
+        private static const OPT_UP:int = 110;
+        private static const OPT_DOWN:int = 111;
+        private static const SHIFT_CTRL_LEFT:int = 112;
+        private static const SHIFT_CTRL_RIGHT:int = 113;
+        private static const SHIFT_CTRL_UP:int = 114;
+        private static const SHIFT_CTRL_DOWN:int = 115;
+        private static const SHIFT_OPT_LEFT:int = 116;
+        private static const SHIFT_OPT_RIGHT:int = 117;
+        private static const SHIFT_OPT_UP:int = 118;
+        private static const SHIFT_OPT_DOWN:int = 119;
+        private static const HOME:int = 120;
+        private static const END:int = 121;
+        private static const SHIFT_HOME:int = 122;
+        private static const SHIFT_END:int = 123;
+        private static const CTRL_HOME:int = 124;
+        private static const CTRL_END:int = 125;
+        private static const SHIFT_CTRL_HOME:int = 126;
+        private static const SHIFT_CTRL_END:int = 127;
+        private static const PG_UP:int = 128;
+        private static const PG_DOWN:int = 129;
+        private static const SHIFT_PG_UP:int = 130;
+        private static const SHIFT_PG_DOWN:int = 131;
+        private static const UP:int = 132;
+        private static const DOWN:int = 133;
+        private static const LEFT:int = 134;
+        private static const RIGHT:int = 135;
 
-   		private static const SHIFT_RIGHT:int	  = 136;
-   		private static const SHIFT_LEFT:int    	  = 137;
-   		private static const SHIFT_UP:int		  = 138;
-   		private static const SHIFT_DOWN:int    	  = 139;
+        private static const SHIFT_RIGHT:int = 136;
+        private static const SHIFT_LEFT:int = 137;
+        private static const SHIFT_UP:int = 138;
+        private static const SHIFT_DOWN:int = 139;
 
-		private var i:Number;
 
-		public function VerticalScrollingTest(methodName:String, testID:String, testConfig:TestConfig, testCaseXML:XML=null)
-		{
-			super(methodName, testID, testConfig, testCaseXML);
+        [DataPoints(loader=HOLTR_endKeyScrollingTestLoader)]
+        [ArrayElementType("UnitTest.Fixtures.TestCaseVo")]
+        public static var HOLTRTestDp:Array;
 
-			// Note: These must correspond to a Watson product area (case-sensitive)
-			metaData.productArea = "UI";
-			metaData.productSubArea = "Scrolling";
-		}
+        public static var HOLTR_endKeyScrollingTestLoader:TestConfigurationLoader = new TestConfigurationLoader("../../test/testCases/VerticalScrollingTests.xml", "HOLTR_endKeyScrollingTest");
 
-		public static function suiteFromXML(testListXML:XML, testConfig:TestConfig, ts:TestSuiteExtended):void
- 		{
-			FileRepository.readFile(testConfig.baseURL,"../../test/testFiles/markup/tlf/HORLTRAUTO.xml");
-			FileRepository.readFile(testConfig.baseURL,"../../test/testFiles/markup/tlf/VORLTRAUTO.xml");
-			FileRepository.readFile(testConfig.baseURL,"../../test/testFiles/markup/tlf/HORRTLAUTO.xml");
-			FileRepository.readFile(testConfig.baseURL,"../../test/testFiles/markup/tlf/VORRTLAUTO.xml");
-			FileRepository.readFile(testConfig.baseURL,"../../test/testFiles/markup/tlf/VSAUTO.xml");
- 			var testCaseClass:Class = VerticalScrollingTest;
- 			VellumTestCase.suiteFromXML(testCaseClass, testListXML, testConfig, ts);
- 		}
+        [DataPoints(loader=VOLTR_endKeyScrollingTestLoader)]
+        [ArrayElementType("UnitTest.Fixtures.TestCaseVo")]
+        public static var VOLTRTestDp:Array;
 
-   		public override function setUpTest():void
-   		{
-			// Booga - Need to load up the test file here.
+        public static var VOLTR_endKeyScrollingTestLoader:TestConfigurationLoader = new TestConfigurationLoader("../../test/testCases/VerticalScrollingTests.xml", "VOLTR_endKeyScrollingTest");
 
-			super.setUpTest();
-   		}
+        [DataPoints(loader=HORTL_endKeyScrollingTestLoader)]
+        [ArrayElementType("UnitTest.Fixtures.TestCaseVo")]
+        public static var HORTLTestDp:Array;
 
-   		public override function tearDownTest():void
-   		{
-   			// Restore default configurations
-   			super.tearDownTest();
-   		}
+        public static var HORTL_endKeyScrollingTestLoader:TestConfigurationLoader = new TestConfigurationLoader("../../test/testCases/VerticalScrollingTests.xml", "HORTL_endKeyScrollingTest");
 
+        [DataPoints(loader=VORTL_endKeyScrollingTestLoader)]
+        [ArrayElementType("UnitTest.Fixtures.TestCaseVo")]
+        public static var VORTLTestDp:Array;
 
-   		// Send a keyboard gesture using values listed above
-   		// Code folding extremely recommended here
-   		private function sendKeyboardGesture( type:int ): void
-   		{
-   			var charCode:int;
-   			var keyCode:int;
-   			var ctrlDown:Boolean = false;
-   			var shiftDown:Boolean = false;
-   			var altDown:Boolean = false;
+        public static var VORTL_endKeyScrollingTestLoader:TestConfigurationLoader = new TestConfigurationLoader("../../test/testCases/VerticalScrollingTests.xml", "VORTL_endKeyScrollingTest");
 
-   			var leftCode:int = 37;
-   			var rightCode:int = 39;
-   			var upCode:int = 38;
-   			var downCode:int = 40;
+        public function VerticalScrollingTest()
+        {
+            super("", "HorizontalScrollingTest", TestConfig.getInstance());
 
-   			// Arrow keys behave differently on Right to Left Blockprogression
-   			// For the sake of test simplicity, I am translating the directions here
-   			if( SelManager.textFlow.computedFormat.blockProgression == BlockProgression.RL )
-   			{
-   				leftCode = 38;
-   				rightCode = 40;
-   				upCode = 39;
-   				downCode = 37;
-   			}
-   			switch( type )
-   			{
-   				case CTRL_BACKSPACE:
-   					charCode = 8;
-   					keyCode  = 8;
-   					ctrlDown = true;
-   					break;
-   				case CTRL_DELETE:
-   					charCode = 127;
-   					keyCode  = 46;
-   					ctrlDown = true;
-   					break;
-   				case OPT_BACKSPACE:
-   					charCode = 8;
-   					keyCode  = 8;
-   					altDown = true;
-   					break;
-   				case OPT_DELETE:
-   					charCode = 127;
-   					keyCode  = 46;
-   					altDown = true;
-   					break;
-   				case CTRL_LEFT:
-   					charCode = 0;
-   					keyCode  = leftCode;
-   					ctrlDown = true;
-   					break;
-   				case CTRL_RIGHT:
-   					charCode = 0;
-   					keyCode  = rightCode;
-   					ctrlDown = true;
-   					break;
-   				case CTRL_UP:
-   					charCode = 0;
-   					keyCode  = upCode;
-   					ctrlDown = true;
-   					break;
-   				case CTRL_DOWN:
-   					charCode = 0;
-   					keyCode  = downCode;
-   					ctrlDown = true;
-   					break;
-   				case OPT_LEFT:
-   					charCode = 0;
-   					keyCode  = leftCode;
-   					altDown = true;
-   					break;
-   				case OPT_RIGHT:
-   					charCode = 0;
-   					keyCode  = rightCode;
-   					altDown = true;
-   					break;
-   				case OPT_UP:
-   					charCode = 0;
-   					keyCode  = upCode;
-   					altDown = true;
-   					break;
-   				case OPT_DOWN:
-   					charCode = 0;
-   					keyCode  = downCode;
-   					altDown = true;
-   					break;
-   				case SHIFT_LEFT:
-   					charCode = 0;
-   					keyCode  = leftCode;
-   					ctrlDown = false;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_RIGHT:
-   					charCode = 0;
-   					keyCode  = rightCode;
-   					ctrlDown = false;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_UP:
-   					charCode = 0;
-   					keyCode  = upCode;
-   					ctrlDown = false;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_DOWN:
-   					charCode = 0;
-   					keyCode  = downCode;
-   					ctrlDown = false;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_CTRL_LEFT:
-   					charCode = 0;
-   					keyCode  = leftCode;
-   					ctrlDown = true;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_CTRL_RIGHT:
-   					charCode = 0;
-   					keyCode  = rightCode;
-   					ctrlDown = true;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_CTRL_UP:
-   					charCode = 0;
-   					keyCode  = upCode;
-   					ctrlDown = true;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_CTRL_DOWN:
-   					charCode = 0;
-   					keyCode  = downCode;
-   					ctrlDown = true;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_OPT_LEFT:
-   					charCode = 0;
-   					keyCode  = leftCode;
-   					ctrlDown = true;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_OPT_RIGHT:
-   					charCode = 0;
-   					keyCode  = rightCode;
-   					ctrlDown = true;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_OPT_UP:
-   					charCode = 0;
-   					keyCode  = upCode;
-   					ctrlDown = true;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_OPT_DOWN:
-   					charCode = 0;
-   					keyCode  = downCode;
-   					altDown = true;
-   					shiftDown = true;
-   					break;
-   				case HOME:
-   					charCode = 0;
-   					keyCode  = 36;
-   					break;
-   				case END:
-   					charCode = 0;
-   					keyCode  = 35;
-   					break;
-   				case SHIFT_HOME:
-   					charCode = 0;
-   					keyCode  = 36;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_END:
-   					charCode = 0;
-   					keyCode  = 35;
-   					shiftDown = true;
-   					break;
-   				case CTRL_HOME:
-   					charCode = 0;
-   					keyCode  = 36;
-   					ctrlDown = true;
-   					break;
-   				case CTRL_END:
-   					charCode = 0;
-   					keyCode  = 35;
-   					ctrlDown = true;
-   					break;
-   				case SHIFT_CTRL_HOME:
-   					charCode = 0;
-   					keyCode  = 36;
-   					shiftDown = true;
-   					ctrlDown = true;
-   					break;
-   				case SHIFT_CTRL_END:
-   					charCode = 0;
-   					keyCode  = 35;
-   					shiftDown = true;
-   					ctrlDown = true;
-   					break;
-   				case PG_UP:
-   					charCode = 0;
-   					keyCode  = 33;
-   					break;
-   				case PG_DOWN:
-   					charCode = 0;
-   					keyCode  = 34;
-   					break;
-   				case SHIFT_PG_UP:
-   					charCode = 0;
-   					keyCode  = 33;
-   					shiftDown = true;
-   					break;
-   				case SHIFT_PG_DOWN:
-   					charCode = 0;
-   					keyCode  = 34;
-   					shiftDown = true;
-   					break;
-   				case UP:
-   					charCode = 0;
-   					keyCode  = upCode;
-   					break;
-   				case DOWN:
-   					charCode = 0;
-   					keyCode  = downCode;
-   					break;
-   				case LEFT:
-   					charCode = 0;
-   					keyCode  = leftCode;
-   					break;
-   				case RIGHT:
-   					charCode = 0;
-   					keyCode  = rightCode;
-   					break;
-   				default:
-   					return;
-   			}
+            metaData = {};
 
-   			var kEvent:KeyboardEvent = new KeyboardEvent( KeyboardEvent.KEY_DOWN,
-				true, false, charCode, keyCode, KeyLocation.STANDARD, ctrlDown, altDown, shiftDown);
-			TestFrame.container["dispatchEvent"](kEvent);
-   		}
+            // Note: These must correspond to a Watson product area (case-sensitive)
+            metaData.productArea = "UI";
+            metaData.productSubArea = "Scrolling";
+        }
 
-		public function endKeyScrollingTest(scrollPos:Number):void
-		{
-			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Hit the CTRL + Home key to scroll to the end of the first line.
-			sendKeyboardGesture( CTRL_HOME );
-			// Hit the CTRL + End key to scroll to the end of the first line.
-			sendKeyboardGesture( CTRL_END );
-			// Check to make sure that it scrolled.
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("endKeyScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("endKeyScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "EndKey Scrolling Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "EndKey Scrolling Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        [After]
+        public override function tearDownTest():void
+        {
+            // Restore default configurations
+            super.tearDownTest();
+        }
 
-		public function homeKeyScrollingTest(scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Hit the CTRL + End key to scroll to the end of the first line.
-			sendKeyboardGesture( CTRL_END );
-			// Hit the CTRL + Home key to scroll to the end of the first line.
-			sendKeyboardGesture( CTRL_HOME );
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("homeKeyScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("homeKeyScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "HomeKey Scrolling Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "HomeKey Scrolling Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        // Horizontal Orientation Left To Right Direction Scrolling Tests.
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_endKeyScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            endKeyScrollingTest(647, testCaseVo);
+        }
 
-		public function cursorUpScrollingTest(lines:Number, scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Hit the End key to scroll to the end of the text.
-			sendKeyboardGesture( CTRL_END );
-			// Move the cursor over to the right.
-			for (var i:Number = 0; i < lines; i++)
-			{
-				sendKeyboardGesture( UP );
-			}
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("cursorUpScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("cursorUpScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "cursorUpScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "cursorUpScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_homeKeyScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            homeKeyScrollingTest(4, testCaseVo);
+        }
 
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_cursorUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            cursorUpScrollingTest(13, 645, testCaseVo);
+        }
 
-		public function cursorDownScrollingTest(lines:Number, scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Hit the CTRL + HOME key to scroll to the end of the first line.
-			sendKeyboardGesture( CTRL_HOME );
-			// Move the cursor over to the right.
-			for (var i:Number = 0; i < lines; i++)
-			{
-				sendKeyboardGesture( DOWN );
-			}
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("cursorDownScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("cursorDownScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "cursorDownScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "cursorDownScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_cursorDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            cursorDownScrollingTest(13, 5, testCaseVo);
+        }
 
-		public function dragUpScrollingTest(lines:Number, scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Hit the End key to scroll to the end of the text.
-			sendKeyboardGesture( CTRL_END );
-			// Move the cursor over to the right.
-			for (var i:Number = 0; i < lines; i++)
-			{
-				sendKeyboardGesture( UP );
-			}
-			sendKeyboardGesture( SHIFT_UP );
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("dragUpScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("dragUpScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "dragUpScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "dragUpScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_dragUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            dragUpScrollingTest(12, 645, testCaseVo);
+        }
 
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_dragDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            dragDownScrollingTest(12, 5, testCaseVo);
+        }
 
-		public function dragDownScrollingTest(lines:Number, scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Hit the CTRL + HOME key to scroll to the end of the first line.
-			sendKeyboardGesture( CTRL_HOME );
-			// Move the cursor over to the right.
-			for (var i:Number = 0; i < lines; i++)
-			{
-				sendKeyboardGesture( DOWN );
-			}
-			sendKeyboardGesture( SHIFT_DOWN );
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("dragDownScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("dragDownScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "dragDownScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "dragDownScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_characterEntryEndOfTextScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            characterEntryEndOfTextScrollingTest(647, testCaseVo);
+        }
 
-		public function characterEntryEndOfTextScrollingTest(scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Hit the End key to scroll to the end of the first line.
-			sendKeyboardGesture( CTRL_END );
-			// Type in ABC and confirm that it scrolls.
-			SelManager.insertText(" It was the best of times, it was the worst of times. I hope this thing scrolls like I expect it to scroll or this test will fail. ;)");
-			//SelManager.flushPendingOperations();
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("characterEntryEndOfTextScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("characterEntryEndOfTextScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "characterEntryEndOfTextScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "characterEntryEndOfTextScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_spaceEntryMiddleOfTextScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            spaceEntryMiddleOfTextScrollingTest(5, testCaseVo);
+        }
 
-		public function spaceEntryMiddleOfTextScrollingTest(scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Hit the CTRL + HOME key to scroll to the beginning of the text.
-			sendKeyboardGesture( CTRL_HOME );
-			// Move down to the middle of the text.
-			for (var i:Number = 0; i < 13; i++)
-			{
-				sendKeyboardGesture( DOWN );
-			}
-			sendKeyboardGesture( END )
-			// Type in ABC and confirm that it scrolls.
-			SelManager.insertText("                                                                                       ");
-			//SelManager.flushPendingOperations();
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("spaceEntryMiddleOfTextScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("spaceEntryMiddleOfTextScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "spaceEntryMiddleOfTextScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "spaceEntryMiddleOfTextScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_deleteScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            deleteScrollingTest(0, testCaseVo);
+        }
 
-		public function deleteScrollingTest(scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Make sure we are at the start of the first line.
-			sendKeyboardGesture( CTRL_HOME );
-			// Delete to force it to scroll up.
-			for(i = 0; i < 60; i++)
-			{
-				SelManager.deleteNextCharacter();
-			}
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("deleteScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("deleteScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "deleteScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "deleteScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_backspaceScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            backspaceScrollingTest(0, testCaseVo);
+        }
 
-		public function backspaceScrollingTest(scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Move to the second line.
-			sendKeyboardGesture( DOWN );
-			// Hit the End key to scroll to the end of the second line.
-			sendKeyboardGesture( END );
-			// Backspace to force it to scroll up.
-			for(i = 0; i < 60; i++)
-			{
-				SelManager.deletePreviousCharacter();
-			}
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("backspaceScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("backspaceScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "backspaceScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "backspaceScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_pageUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            pageUpScrollingTest(229, testCaseVo);
+        }
 
-		public function pageUpScrollingTest(scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Make sure we are at the start of the first line.
-			sendKeyboardGesture( CTRL_END );
-			// Do a page up.
-			sendKeyboardGesture( PG_UP );
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("pageUpScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("pageUpScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "pageUpScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "pageUpScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_pageDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            pageDownScrollingTest(417, testCaseVo);
+        }
 
-		public function pageDownScrollingTest(scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Make sure we are at the start of the first line.
-			sendKeyboardGesture( CTRL_HOME );
-			// Do a page down.
-			sendKeyboardGesture( PG_DOWN );
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("pageDownScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("pageDownScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "pageDownScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "pageDownScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_mousewheelUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelUpScrollingTest(587, testCaseVo);
+        }
 
-		public function mousewheelUpScrollingTest(scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Make sure we are at the start of the first line.
-			sendKeyboardGesture( CTRL_END );
-			// Do a mousewheel up.
-			var mEvent:MouseEvent = new MouseEvent(MouseEvent.MOUSE_WHEEL,true, false, 0,0,null,false,false,false,false,3);
-			TestFrame.container["dispatchEvent"](mEvent);
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("mousewheelUpScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("mousewheelUpScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "mousewheelUpScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "mousewheelUpScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_mousewheelUpScrollingNoInteractionTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelUpScrollingNoInteractionTest(587, testCaseVo);
+        }
 
-		public function mousewheelUpScrollingNoInteractionTest(scrollPos:Number):void
-		{
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Make sure we are at the start of the first line.
-			sendKeyboardGesture( CTRL_END );
-			var textFlow:TextFlow = SelManager.textFlow;		// save it for later
-			SelManager.textFlow.interactionManager = null;		// turn off editing
-			
-			// Do a mousewheel up.
-			var mEvent:MouseEvent = new MouseEvent(MouseEvent.MOUSE_WHEEL,true, false, 0,0,null,false,false,false,false,3);
-			TestFrame.container["dispatchEvent"](mEvent);
-			
-			textFlow.interactionManager = SelManager;
-			
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "mousewheelUpScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "mousewheelUpScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			
-			//to avoid tear down assertion
-			SelManager.selectRange(0,0);
-		}
-		
-		public function mousewheelDownScrollingTest(scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Make sure we are at the start of the first line.
-			sendKeyboardGesture( CTRL_HOME );
-			// Do a mousewheel down.
-			var mEvent:MouseEvent = new MouseEvent(MouseEvent.MOUSE_WHEEL,true, false, 0,0,null,false,false,false,false,-3);
-			TestFrame.container["dispatchEvent"](mEvent);
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("mousewheelDownScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("mousewheelDownScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "mousewheelDownScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "mousewheelDownScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
-		
-		public function mousewheelDownScrollingNoInteractionTest(scrollPos:Number):void
-		{
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Make sure we are at the start of the first line.
-			sendKeyboardGesture( CTRL_HOME );
-			// Do a mousewheel down.
-			var textFlow:TextFlow = SelManager.textFlow;		// save it for later
-			SelManager.textFlow.interactionManager = null;		// turn off editing
-			var mEvent:MouseEvent = new MouseEvent(MouseEvent.MOUSE_WHEEL,true, false, 0,0,null,false,false,false,false,-3);
-			TestFrame.container["dispatchEvent"](mEvent);
-			
-			textFlow.interactionManager = SelManager;
-			
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-			
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "mousewheelDownScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "mousewheelDownScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			
-			//to avoid tear down assertion
-			SelManager.selectRange(0,0);
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_mousewheelDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelDownScrollingTest(60, testCaseVo);
+        }
 
-		public function autoScrollVisibleScrollingTest(scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Make sure we are at the end of the text.
-			sendKeyboardGesture( CTRL_END );
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-			tmpContainerController.verticalScrollPolicy = "auto";
-			// Type in enough text to make the scroll bars appear.
-			SelManager.insertText(" It was the best of times, it was the worst of times.");
-			//var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("autoScrollVisibleScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("autoScrollVisibleScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "autoScrollVisibleScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "autoScrollVisibleScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        [Test(dataProvider=HOLTRTestDp)]
+        public function HOLTR_mousewheelDownScrollingNoInteractionTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelDownScrollingNoInteractionTest(60, testCaseVo);
+        }
 
-		public function autoScrollHideScrollingTest(scrollPos:Number):void
-		{
-   			// Success or failure will be determined by the bitmap snapshot.
-			// Move the cursor to the beginning of the first line.
-			SelManager.selectRange(0,0);
-			// Make sure we are at the end of the text.
-			sendKeyboardGesture( CTRL_END );
-			// Delete enough characters so scroll bars disappear.
-			for(i = 0; i < 60; i++)
-			{
-				SelManager.deletePreviousCharacter();
-			}
-			var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
-		//	trace("autoScrollHideScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
-		//	trace("autoScrollHideScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
-			if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
-			{
-				assertTrue( "autoScrollHideScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
-			}
-			else
-			{
-				assertTrue( "autoScrollHideScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
-			}
-		}
+        // Vertical Orientation Left To Right Direction Scrolling Tests.
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_endKeyScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            endKeyScrollingTest(1094, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_homeKeyScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            homeKeyScrollingTest(0, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_cursorUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            cursorUpScrollingTest(24, 1059, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_cursorDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            cursorDownScrollingTest(24, 35, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_dragUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            dragUpScrollingTest(23, 1059, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_dragDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            dragDownScrollingTest(23, 35, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_characterEntryEndOfTextScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            characterEntryEndOfTextScrollingTest(1094, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_spaceEntryMiddleOfTextScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            spaceEntryMiddleOfTextScrollingTest(0, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_deleteScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            deleteScrollingTest(0, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_backspaceScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            backspaceScrollingTest(0, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_pageUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            pageUpScrollingTest(0, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_pageDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            pageDownScrollingTest(722, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_mousewheelUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelUpScrollingTest(1034, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_mousewheelUpScrollingNoInteractionTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelUpScrollingNoInteractionTest(1034, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_mousewheelDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelDownScrollingTest(60, testCaseVo);
+        }
+
+        [Test(dataProvider=VOLTRTestDp)]
+        public function VOLTR_mousewheelDownScrollingNoInteractionTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelDownScrollingNoInteractionTest(60, testCaseVo);
+        }
+
+        // Horizontal Orientation Left To Right Direction Scrolling Tests.
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_endKeyScrollingTest(testCaseVo:TestCaseVo):void
+        {
+
+            endKeyScrollingTest(647, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_homeKeyScrollingTest(testCaseVo:TestCaseVo):void
+        {
+
+            homeKeyScrollingTest(4, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_cursorUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+
+            cursorUpScrollingTest(13, 645, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_cursorDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+
+            cursorDownScrollingTest(13, 5, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_dragUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+
+            dragUpScrollingTest(12, 645, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_dragDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            dragDownScrollingTest(12, 5, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_characterEntryEndOfTextScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            characterEntryEndOfTextScrollingTest(647, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_spaceEntryMiddleOfTextScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            spaceEntryMiddleOfTextScrollingTest(5, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_deleteScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            deleteScrollingTest(0, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_backspaceScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            backspaceScrollingTest(0, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_pageUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            pageUpScrollingTest(229, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_pageDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            pageDownScrollingTest(417, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_mousewheelUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelUpScrollingTest(587, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_mousewheelUpScrollingNoInteractionTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelUpScrollingNoInteractionTest(587, testCaseVo);
+        }
+
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_mousewheelDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelDownScrollingTest(60, testCaseVo);
+        }
 
+        [Test(dataProvider=HORTLTestDp)]
+        public function HORTL_mousewheelDownScrollingNoInteractionTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelDownScrollingNoInteractionTest(60, testCaseVo);
+        }
 
-		// Horizontal Orientation Left To Right Direction Scrolling Tests.
+        // Vertical Orientation Left To Right Direction Scrolling Tests.
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_endKeyScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            endKeyScrollingTest(1094, testCaseVo);
+        }
 
-		public function HOLTR_endKeyScrollingTest():void
-		{
-			endKeyScrollingTest(647);
-		}
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_homeKeyScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            homeKeyScrollingTest(0, testCaseVo);
+        }
 
-		public function HOLTR_homeKeyScrollingTest():void
-		{
-			homeKeyScrollingTest(4);
-		}
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_cursorUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            cursorUpScrollingTest(24, 1059, testCaseVo);
+        }
 
-		public function HOLTR_cursorUpScrollingTest():void
-		{
-			cursorUpScrollingTest(13,645);
-		}
+        public function VORTL_cursorDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            cursorDownScrollingTest(24, 35, testCaseVo);
+        }
 
-		public function HOLTR_cursorDownScrollingTest():void
-		{
-			cursorDownScrollingTest(13,5);
-		}
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_dragUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            dragUpScrollingTest(23, 1059, testCaseVo);
+        }
 
-		public function HOLTR_dragUpScrollingTest():void
-		{
-			dragUpScrollingTest(12,645);
-		}
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_dragDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            dragDownScrollingTest(23, 35, testCaseVo);
+        }
 
-		public function HOLTR_dragDownScrollingTest():void
-		{
-			dragDownScrollingTest(12,5);
-		}
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_characterEntryEndOfTextScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            characterEntryEndOfTextScrollingTest(1094, testCaseVo);
+        }
 
-		public function HOLTR_characterEntryEndOfTextScrollingTest():void
-		{
-			characterEntryEndOfTextScrollingTest(647)
-		}
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_spaceEntryMiddleOfTextScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            spaceEntryMiddleOfTextScrollingTest(0, testCaseVo);
+        }
 
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_deleteScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            deleteScrollingTest(0, testCaseVo);
+        }
 
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_backspaceScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            backspaceScrollingTest(0, testCaseVo);
+        }
 
-		public function HOLTR_spaceEntryMiddleOfTextScrollingTest():void
-		{
-			spaceEntryMiddleOfTextScrollingTest(5);
-		}
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_pageUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            pageUpScrollingTest(0, testCaseVo);
+        }
 
-		public function HOLTR_deleteScrollingTest():void
-		{
-			deleteScrollingTest(0);
-		}
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_pageDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            pageDownScrollingTest(722, testCaseVo);
+        }
 
-		public function HOLTR_backspaceScrollingTest():void
-		{
-			backspaceScrollingTest(0);
-		}
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_mousewheelUpScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelUpScrollingTest(1034, testCaseVo);
+        }
 
-		public function HOLTR_pageUpScrollingTest():void
-		{
-			pageUpScrollingTest(229);
-		}
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_mousewheelUpScrollingNoInteractionTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelUpScrollingNoInteractionTest(1034, testCaseVo);
+        }
 
-		public function HOLTR_pageDownScrollingTest():void
-		{
-			pageDownScrollingTest(417);
-		}
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_mousewheelDownScrollingTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelDownScrollingTest(60, testCaseVo);
+        }
 
-		public function HOLTR_mousewheelUpScrollingTest():void
-		{
-			mousewheelUpScrollingTest(587);
-		}
-		public function HOLTR_mousewheelUpScrollingNoInteractionTest():void
-		{
-			mousewheelUpScrollingNoInteractionTest(587);
-		}
+        [Test(dataProvider=VORTLTestDp)]
+        public function VORTL_mousewheelDownScrollingNoInteractionTest(testCaseVo:TestCaseVo):void
+        {
+            mousewheelDownScrollingNoInteractionTest(60, testCaseVo);
+        }
 
-		public function HOLTR_mousewheelDownScrollingTest():void
-		{
-			mousewheelDownScrollingTest(60);
-		}
-		public function HOLTR_mousewheelDownScrollingNoInteractionTest():void
-		{
-			mousewheelDownScrollingNoInteractionTest(60);
-		}
+        /**
+         * Send a keyboard gesture using values listed above
+         * Code folding extremely recommended here
+         * @param type
+         */
+        private function sendKeyboardGesture(type:int):void
+        {
+            var charCode:int;
+            var keyCode:int;
+            var ctrlDown:Boolean = false;
+            var shiftDown:Boolean = false;
+            var altDown:Boolean = false;
 
-		// Vertical Orientation Left To Right Direction Scrolling Tests.
+            var leftCode:int = 37;
+            var rightCode:int = 39;
+            var upCode:int = 38;
+            var downCode:int = 40;
 
-		public function VOLTR_endKeyScrollingTest():void
-		{
-			endKeyScrollingTest(1094);
-		}
+            // Arrow keys behave differently on Right to Left Blockprogression
+            // For the sake of test simplicity, I am translating the directions here
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.RL)
+            {
+                leftCode = 38;
+                rightCode = 40;
+                upCode = 39;
+                downCode = 37;
+            }
+            switch (type)
+            {
+                case CTRL_BACKSPACE:
+                    charCode = 8;
+                    keyCode = 8;
+                    ctrlDown = true;
+                    break;
+                case CTRL_DELETE:
+                    charCode = 127;
+                    keyCode = 46;
+                    ctrlDown = true;
+                    break;
+                case OPT_BACKSPACE:
+                    charCode = 8;
+                    keyCode = 8;
+                    altDown = true;
+                    break;
+                case OPT_DELETE:
+                    charCode = 127;
+                    keyCode = 46;
+                    altDown = true;
+                    break;
+                case CTRL_LEFT:
+                    charCode = 0;
+                    keyCode = leftCode;
+                    ctrlDown = true;
+                    break;
+                case CTRL_RIGHT:
+                    charCode = 0;
+                    keyCode = rightCode;
+                    ctrlDown = true;
+                    break;
+                case CTRL_UP:
+                    charCode = 0;
+                    keyCode = upCode;
+                    ctrlDown = true;
+                    break;
+                case CTRL_DOWN:
+                    charCode = 0;
+                    keyCode = downCode;
+                    ctrlDown = true;
+                    break;
+                case OPT_LEFT:
+                    charCode = 0;
+                    keyCode = leftCode;
+                    altDown = true;
+                    break;
+                case OPT_RIGHT:
+                    charCode = 0;
+                    keyCode = rightCode;
+                    altDown = true;
+                    break;
+                case OPT_UP:
+                    charCode = 0;
+                    keyCode = upCode;
+                    altDown = true;
+                    break;
+                case OPT_DOWN:
+                    charCode = 0;
+                    keyCode = downCode;
+                    altDown = true;
+                    break;
+                case SHIFT_LEFT:
+                    charCode = 0;
+                    keyCode = leftCode;
+                    ctrlDown = false;
+                    shiftDown = true;
+                    break;
+                case SHIFT_RIGHT:
+                    charCode = 0;
+                    keyCode = rightCode;
+                    ctrlDown = false;
+                    shiftDown = true;
+                    break;
+                case SHIFT_UP:
+                    charCode = 0;
+                    keyCode = upCode;
+                    ctrlDown = false;
+                    shiftDown = true;
+                    break;
+                case SHIFT_DOWN:
+                    charCode = 0;
+                    keyCode = downCode;
+                    ctrlDown = false;
+                    shiftDown = true;
+                    break;
+                case SHIFT_CTRL_LEFT:
+                    charCode = 0;
+                    keyCode = leftCode;
+                    ctrlDown = true;
+                    shiftDown = true;
+                    break;
+                case SHIFT_CTRL_RIGHT:
+                    charCode = 0;
+                    keyCode = rightCode;
+                    ctrlDown = true;
+                    shiftDown = true;
+                    break;
+                case SHIFT_CTRL_UP:
+                    charCode = 0;
+                    keyCode = upCode;
+                    ctrlDown = true;
+                    shiftDown = true;
+                    break;
+                case SHIFT_CTRL_DOWN:
+                    charCode = 0;
+                    keyCode = downCode;
+                    ctrlDown = true;
+                    shiftDown = true;
+                    break;
+                case SHIFT_OPT_LEFT:
+                    charCode = 0;
+                    keyCode = leftCode;
+                    ctrlDown = true;
+                    shiftDown = true;
+                    break;
+                case SHIFT_OPT_RIGHT:
+                    charCode = 0;
+                    keyCode = rightCode;
+                    ctrlDown = true;
+                    shiftDown = true;
+                    break;
+                case SHIFT_OPT_UP:
+                    charCode = 0;
+                    keyCode = upCode;
+                    ctrlDown = true;
+                    shiftDown = true;
+                    break;
+                case SHIFT_OPT_DOWN:
+                    charCode = 0;
+                    keyCode = downCode;
+                    altDown = true;
+                    shiftDown = true;
+                    break;
+                case HOME:
+                    charCode = 0;
+                    keyCode = 36;
+                    break;
+                case END:
+                    charCode = 0;
+                    keyCode = 35;
+                    break;
+                case SHIFT_HOME:
+                    charCode = 0;
+                    keyCode = 36;
+                    shiftDown = true;
+                    break;
+                case SHIFT_END:
+                    charCode = 0;
+                    keyCode = 35;
+                    shiftDown = true;
+                    break;
+                case CTRL_HOME:
+                    charCode = 0;
+                    keyCode = 36;
+                    ctrlDown = true;
+                    break;
+                case CTRL_END:
+                    charCode = 0;
+                    keyCode = 35;
+                    ctrlDown = true;
+                    break;
+                case SHIFT_CTRL_HOME:
+                    charCode = 0;
+                    keyCode = 36;
+                    shiftDown = true;
+                    ctrlDown = true;
+                    break;
+                case SHIFT_CTRL_END:
+                    charCode = 0;
+                    keyCode = 35;
+                    shiftDown = true;
+                    ctrlDown = true;
+                    break;
+                case PG_UP:
+                    charCode = 0;
+                    keyCode = 33;
+                    break;
+                case PG_DOWN:
+                    charCode = 0;
+                    keyCode = 34;
+                    break;
+                case SHIFT_PG_UP:
+                    charCode = 0;
+                    keyCode = 33;
+                    shiftDown = true;
+                    break;
+                case SHIFT_PG_DOWN:
+                    charCode = 0;
+                    keyCode = 34;
+                    shiftDown = true;
+                    break;
+                case UP:
+                    charCode = 0;
+                    keyCode = upCode;
+                    break;
+                case DOWN:
+                    charCode = 0;
+                    keyCode = downCode;
+                    break;
+                case LEFT:
+                    charCode = 0;
+                    keyCode = leftCode;
+                    break;
+                case RIGHT:
+                    charCode = 0;
+                    keyCode = rightCode;
+                    break;
+                default:
+                    return;
+            }
 
-		public function VOLTR_homeKeyScrollingTest():void
-		{
-			homeKeyScrollingTest(0);
-		}
+            var kEvent:KeyboardEvent = new KeyboardEvent(KeyboardEvent.KEY_DOWN,
+                    true, false, charCode, keyCode, KeyLocation.STANDARD, ctrlDown, altDown, shiftDown);
+            TestFrame.container["dispatchEvent"](kEvent);
+        }
 
-		public function VOLTR_cursorUpScrollingTest():void
-		{
-			cursorUpScrollingTest(24,1059);
-		}
+        public function endKeyScrollingTest(scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function VOLTR_cursorDownScrollingTest():void
-		{
-			cursorDownScrollingTest(24,35);
-		}
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Hit the CTRL + Home key to scroll to the end of the first line.
+            sendKeyboardGesture(CTRL_HOME);
+            // Hit the CTRL + End key to scroll to the end of the first line.
+            sendKeyboardGesture(CTRL_END);
+            // Check to make sure that it scrolled.
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("endKeyScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("endKeyScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("EndKey Scrolling Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("EndKey Scrolling Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
-		public function VOLTR_dragUpScrollingTest():void
-		{
-			dragUpScrollingTest(23,1059);
-		}
+        public function homeKeyScrollingTest(scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function VOLTR_dragDownScrollingTest():void
-		{
-			dragDownScrollingTest(23,35);
-		}
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Hit the CTRL + End key to scroll to the end of the first line.
+            sendKeyboardGesture(CTRL_END);
+            // Hit the CTRL + Home key to scroll to the end of the first line.
+            sendKeyboardGesture(CTRL_HOME);
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("homeKeyScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("homeKeyScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("HomeKey Scrolling Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("HomeKey Scrolling Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
-		public function VOLTR_characterEntryEndOfTextScrollingTest():void
-		{
-			characterEntryEndOfTextScrollingTest(1094);
-		}
+        public function cursorUpScrollingTest(lines:Number, scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Hit the End key to scroll to the end of the text.
+            sendKeyboardGesture(CTRL_END);
+            // Move the cursor over to the right.
+            for (var i:Number = 0; i < lines; i++)
+            {
+                sendKeyboardGesture(UP);
+            }
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("cursorUpScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("cursorUpScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("cursorUpScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("cursorUpScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
 
-		public function VOLTR_spaceEntryMiddleOfTextScrollingTest():void
-		{
-			spaceEntryMiddleOfTextScrollingTest(0);
-		}
+        }
 
-		public function VOLTR_deleteScrollingTest():void
-		{
-			deleteScrollingTest(0);
-		}
+        public function cursorDownScrollingTest(lines:Number, scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function VOLTR_backspaceScrollingTest():void
-		{
-			backspaceScrollingTest(0);
-		}
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Hit the CTRL + HOME key to scroll to the end of the first line.
+            sendKeyboardGesture(CTRL_HOME);
+            // Move the cursor over to the right.
+            for (var i:Number = 0; i < lines; i++)
+            {
+                sendKeyboardGesture(DOWN);
+            }
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("cursorDownScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("cursorDownScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("cursorDownScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("cursorDownScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
-		public function VOLTR_pageUpScrollingTest():void
-		{
-			pageUpScrollingTest(0);
-		}
+        public function dragUpScrollingTest(lines:Number, scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function VOLTR_pageDownScrollingTest():void
-		{
-			pageDownScrollingTest(722);
-		}
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Hit the End key to scroll to the end of the text.
+            sendKeyboardGesture(CTRL_END);
+            // Move the cursor over to the right.
+            for (var i:Number = 0; i < lines; i++)
+            {
+                sendKeyboardGesture(UP);
+            }
+            sendKeyboardGesture(SHIFT_UP);
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("dragUpScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("dragUpScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("dragUpScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("dragUpScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
 
-		public function VOLTR_mousewheelUpScrollingTest():void
-		{
-			mousewheelUpScrollingTest(1034);
-		}
-		public function VOLTR_mousewheelUpScrollingNoInteractionTest():void
-		{
-			mousewheelUpScrollingNoInteractionTest(1034);
-		}
+        }
 
-		public function VOLTR_mousewheelDownScrollingTest():void
-		{
-			mousewheelDownScrollingTest(60);
-		}
-		public function VOLTR_mousewheelDownScrollingNoInteractionTest():void
-		{
-			mousewheelDownScrollingNoInteractionTest(60);
-		}
+        public function dragDownScrollingTest(lines:Number, scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		// Horizontal Orientation Left To Right Direction Scrolling Tests.
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Hit the CTRL + HOME key to scroll to the end of the first line.
+            sendKeyboardGesture(CTRL_HOME);
+            // Move the cursor over to the right.
+            for (var i:Number = 0; i < lines; i++)
+            {
+                sendKeyboardGesture(DOWN);
+            }
+            sendKeyboardGesture(SHIFT_DOWN);
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("dragDownScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("dragDownScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("dragDownScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("dragDownScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
-		public function HORTL_endKeyScrollingTest():void
-		{
-			endKeyScrollingTest(647);
-		}
+        public function characterEntryEndOfTextScrollingTest(scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function HORTL_homeKeyScrollingTest():void
-		{
-			homeKeyScrollingTest(4);
-		}
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Hit the End key to scroll to the end of the first line.
+            sendKeyboardGesture(CTRL_END);
+            // Type in ABC and confirm that it scrolls.
+            SelManager.insertText(" It was the best of times, it was the worst of times. I hope this thing scrolls like I expect it to scroll or this test will fail. ;)");
+            //SelManager.flushPendingOperations();
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("characterEntryEndOfTextScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("characterEntryEndOfTextScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("characterEntryEndOfTextScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("characterEntryEndOfTextScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
-		public function HORTL_cursorUpScrollingTest():void
-		{
-			cursorUpScrollingTest(13,645);
-		}
+        public function spaceEntryMiddleOfTextScrollingTest(scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function HORTL_cursorDownScrollingTest():void
-		{
-			cursorDownScrollingTest(13,5);
-		}
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Hit the CTRL + HOME key to scroll to the beginning of the text.
+            sendKeyboardGesture(CTRL_HOME);
+            // Move down to the middle of the text.
+            for (var i:Number = 0; i < 13; i++)
+            {
+                sendKeyboardGesture(DOWN);
+            }
+            sendKeyboardGesture(END);
+            // Type in ABC and confirm that it scrolls.
+            SelManager.insertText("                                                                                       ");
+            //SelManager.flushPendingOperations();
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("spaceEntryMiddleOfTextScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("spaceEntryMiddleOfTextScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("spaceEntryMiddleOfTextScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("spaceEntryMiddleOfTextScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
-		public function HORTL_dragUpScrollingTest():void
-		{
-			dragUpScrollingTest(12,645);
-		}
+        public function deleteScrollingTest(scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function HORTL_dragDownScrollingTest():void
-		{
-			dragDownScrollingTest(12,5);
-		}
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Make sure we are at the start of the first line.
+            sendKeyboardGesture(CTRL_HOME);
+            // Delete to force it to scroll up.
+            for (var i:int = 0; i < 60; i++)
+            {
+                SelManager.deleteNextCharacter();
+            }
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("deleteScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("deleteScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("deleteScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("deleteScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
-		public function HORTL_characterEntryEndOfTextScrollingTest():void
-		{
-			characterEntryEndOfTextScrollingTest(647)
-		}
+        public function backspaceScrollingTest(scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function HORTL_spaceEntryMiddleOfTextScrollingTest():void
-		{
-			spaceEntryMiddleOfTextScrollingTest(5);
-		}
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Move to the second line.
+            sendKeyboardGesture(DOWN);
+            // Hit the End key to scroll to the end of the second line.
+            sendKeyboardGesture(END);
+            // Backspace to force it to scroll up.
+            for (var i:int = 0; i < 60; i++)
+            {
+                SelManager.deletePreviousCharacter();
+            }
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("backspaceScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("backspaceScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("backspaceScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("backspaceScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
-		public function HORTL_deleteScrollingTest():void
-		{
-			deleteScrollingTest(0);
-		}
+        public function pageUpScrollingTest(scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function HORTL_backspaceScrollingTest():void
-		{
-			backspaceScrollingTest(0);
-		}
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Make sure we are at the start of the first line.
+            sendKeyboardGesture(CTRL_END);
+            // Do a page up.
+            sendKeyboardGesture(PG_UP);
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("pageUpScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("pageUpScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("pageUpScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("pageUpScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
-		public function HORTL_pageUpScrollingTest():void
-		{
-			pageUpScrollingTest(229);
-		}
+        public function pageDownScrollingTest(scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function HORTL_pageDownScrollingTest():void
-		{
-			pageDownScrollingTest(417);
-		}
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Make sure we are at the start of the first line.
+            sendKeyboardGesture(CTRL_HOME);
+            // Do a page down.
+            sendKeyboardGesture(PG_DOWN);
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("pageDownScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("pageDownScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("pageDownScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("pageDownScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
-		public function HORTL_mousewheelUpScrollingTest():void
-		{
-			mousewheelUpScrollingTest(587);
-		}
-		public function HORTL_mousewheelUpScrollingNoInteractionTest():void
-		{
-			mousewheelUpScrollingNoInteractionTest(587);
-		}
+        public function mousewheelUpScrollingTest(scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function HORTL_mousewheelDownScrollingTest():void
-		{
-			mousewheelDownScrollingTest(60);
-		}
-		
-		
-		public function HORTL_mousewheelDownScrollingNoInteractionTest():void
-		{
-			mousewheelDownScrollingNoInteractionTest(60);
-		}
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Make sure we are at the start of the first line.
+            sendKeyboardGesture(CTRL_END);
+            // Do a mousewheel up.
+            var mEvent:MouseEvent = new MouseEvent(MouseEvent.MOUSE_WHEEL, true, false, 0, 0, null, false, false, false, false, 3);
+            TestFrame.container["dispatchEvent"](mEvent);
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("mousewheelUpScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("mousewheelUpScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("mousewheelUpScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("mousewheelUpScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
-		// Vertical Orientation Left To Right Direction Scrolling Tests.
+        public function mousewheelUpScrollingNoInteractionTest(scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function VORTL_endKeyScrollingTest():void
-		{
-			endKeyScrollingTest(1094);
-		}
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Make sure we are at the start of the first line.
+            sendKeyboardGesture(CTRL_END);
+            var textFlow:TextFlow = SelManager.textFlow;		// save it for later
+            SelManager.textFlow.interactionManager = null;		// turn off editing
 
-		public function VORTL_homeKeyScrollingTest():void
-		{
-			homeKeyScrollingTest(0);
-		}
+            // Do a mousewheel up.
+            var mEvent:MouseEvent = new MouseEvent(MouseEvent.MOUSE_WHEEL, true, false, 0, 0, null, false, false, false, false, 3);
+            TestFrame.container["dispatchEvent"](mEvent);
 
-		public function VORTL_cursorUpScrollingTest():void
-		{
-			cursorUpScrollingTest(24,1059);
-		}
+            textFlow.interactionManager = SelManager;
 
-		public function VORTL_cursorDownScrollingTest():void
-		{
-			cursorDownScrollingTest(24,35);
-		}
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("mousewheelUpScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("mousewheelUpScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
 
-		public function VORTL_dragUpScrollingTest():void
-		{
-			dragUpScrollingTest(23,1059);
-		}
+            //to avoid tear down assertion
+            SelManager.selectRange(0, 0);
+        }
 
-		public function VORTL_dragDownScrollingTest():void
-		{
-			dragDownScrollingTest(23,35);
-		}
+        public function mousewheelDownScrollingTest(scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function VORTL_characterEntryEndOfTextScrollingTest():void
-		{
-			characterEntryEndOfTextScrollingTest(1094);
-		}
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Make sure we are at the start of the first line.
+            sendKeyboardGesture(CTRL_HOME);
+            // Do a mousewheel down.
+            var mEvent:MouseEvent = new MouseEvent(MouseEvent.MOUSE_WHEEL, true, false, 0, 0, null, false, false, false, false, -3);
+            TestFrame.container["dispatchEvent"](mEvent);
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("mousewheelDownScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("mousewheelDownScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("mousewheelDownScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("mousewheelDownScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
+        public function mousewheelDownScrollingNoInteractionTest(scrollPos:Number, testCaseVo:TestCaseVo):void
+        {
+            TestData.fileName = testCaseVo.fileName;
+            super.setUpTest();
 
-		public function VORTL_spaceEntryMiddleOfTextScrollingTest():void
-		{
-			spaceEntryMiddleOfTextScrollingTest(0);
-		}
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Make sure we are at the start of the first line.
+            sendKeyboardGesture(CTRL_HOME);
+            // Do a mousewheel down.
+            var textFlow:TextFlow = SelManager.textFlow;		// save it for later
+            SelManager.textFlow.interactionManager = null;		// turn off editing
+            var mEvent:MouseEvent = new MouseEvent(MouseEvent.MOUSE_WHEEL, true, false, 0, 0, null, false, false, false, false, -3);
+            TestFrame.container["dispatchEvent"](mEvent);
 
-		public function VORTL_deleteScrollingTest():void
-		{
-			deleteScrollingTest(0);
-		}
+            textFlow.interactionManager = SelManager;
 
-		public function VORTL_backspaceScrollingTest():void
-		{
-			backspaceScrollingTest(0);
-		}
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
 
-		public function VORTL_pageUpScrollingTest():void
-		{
-			pageUpScrollingTest(0);
-		}
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("mousewheelDownScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("mousewheelDownScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
 
-		public function VORTL_pageDownScrollingTest():void
-		{
-			pageDownScrollingTest(722);
-		}
+            //to avoid tear down assertion
+            SelManager.selectRange(0, 0);
+        }
 
-		public function VORTL_mousewheelUpScrollingTest():void
-		{
-			mousewheelUpScrollingTest(1034);
-		}
-		
-		public function VORTL_mousewheelUpScrollingNoInteractionTest():void
-		{
-			mousewheelUpScrollingNoInteractionTest(1034);
-		}
-		
-		public function VORTL_mousewheelDownScrollingTest():void
-		{
-			mousewheelDownScrollingTest(60);
-		}
-		
-		public function VORTL_mousewheelDownScrollingNoInteractionTest():void
-		{
-			mousewheelDownScrollingNoInteractionTest(60);
-		}
+        public function autoScrollVisibleScrollingTest(scrollPos:Number):void
+        {
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Make sure we are at the end of the text.
+            sendKeyboardGesture(CTRL_END);
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            tmpContainerController.verticalScrollPolicy = "auto";
+            // Type in enough text to make the scroll bars appear.
+            SelManager.insertText(" It was the best of times, it was the worst of times.");
+            //var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("autoScrollVisibleScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("autoScrollVisibleScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("autoScrollVisibleScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("autoScrollVisibleScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
 
-	}
+        public function autoScrollHideScrollingTest(scrollPos:Number):void
+        {
+            // Success or failure will be determined by the bitmap snapshot.
+            // Move the cursor to the beginning of the first line.
+            SelManager.selectRange(0, 0);
+            // Make sure we are at the end of the text.
+            sendKeyboardGesture(CTRL_END);
+            // Delete enough characters so scroll bars disappear.
+            for (var i:int = 0; i < 60; i++)
+            {
+                SelManager.deletePreviousCharacter();
+            }
+            var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0));
+            //	trace("autoScrollHideScrollingTestHP=" + tmpContainerController.horizontalScrollPosition);
+            //	trace("autoScrollHideScrollingTestVP=" + tmpContainerController.verticalScrollPosition);
+            if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB)
+            {
+                assertTrue("autoScrollHideScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true);
+            }
+            else
+            {
+                assertTrue("autoScrollHideScrollingTest Test Failed.", (scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true);
+            }
+        }
+    }
 }