automation_tests/src/UnitTest/Tests/VerticalScrollingTest.as

////////////////////////////////////////////////////////////////////////////////
//
//  Licensed to the Apache Software Foundation (ASF) under one or more
//  contributor license agreements.  See the NOTICE file distributed with
//  this work for additional information regarding copyright ownership.
//  The ASF licenses this file to You under the Apache License, Version 2.0
//  (the "License"); you may not use this file except in compliance with
//  the License.  You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//
////////////////////////////////////////////////////////////////////////////////
package UnitTest.Tests
{
    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 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;

        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;


        [DataPoints(loader=HOLTR_endKeyScrollingTestLoader)]
        [ArrayElementType("UnitTest.Fixtures.TestCaseVo")]
        public static var HOLTRTestDp:Array;

        public static var HOLTR_endKeyScrollingTestLoader:TestConfigurationLoader = new TestConfigurationLoader("../../test/testCases/VerticalScrollingTests.xml", "HOLTR_endKeyScrollingTest");

        [DataPoints(loader=VOLTR_endKeyScrollingTestLoader)]
        [ArrayElementType("UnitTest.Fixtures.TestCaseVo")]
        public static var VOLTRTestDp:Array;

        public static var VOLTR_endKeyScrollingTestLoader:TestConfigurationLoader = new TestConfigurationLoader("../../test/testCases/VerticalScrollingTests.xml", "VOLTR_endKeyScrollingTest");

        [DataPoints(loader=HORTL_endKeyScrollingTestLoader)]
        [ArrayElementType("UnitTest.Fixtures.TestCaseVo")]
        public static var HORTLTestDp:Array;

        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;

        public static var VORTL_endKeyScrollingTestLoader:TestConfigurationLoader = new TestConfigurationLoader("../../test/testCases/VerticalScrollingTests.xml", "VORTL_endKeyScrollingTest");

        public function VerticalScrollingTest()
        {
            super("", "HorizontalScrollingTest", TestConfig.getInstance());

            metaData = {};

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

        [After]
        public override function tearDownTest():void
        {
            // Restore default configurations
            super.tearDownTest();
        }

        // Horizontal Orientation Left To Right Direction Scrolling Tests.
        [Test(dataProvider=HOLTRTestDp)]
        public function HOLTR_endKeyScrollingTest(testCaseVo:TestCaseVo):void
        {
            endKeyScrollingTest(647, testCaseVo);
        }

        [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);
        }

        [Test(dataProvider=HOLTRTestDp)]
        public function HOLTR_cursorDownScrollingTest(testCaseVo:TestCaseVo):void
        {
            cursorDownScrollingTest(13, 5, testCaseVo);
        }

        [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);
        }

        [Test(dataProvider=HOLTRTestDp)]
        public function HOLTR_characterEntryEndOfTextScrollingTest(testCaseVo:TestCaseVo):void
        {
            characterEntryEndOfTextScrollingTest(647, testCaseVo);
        }

        [Test(dataProvider=HOLTRTestDp)]
        public function HOLTR_spaceEntryMiddleOfTextScrollingTest(testCaseVo:TestCaseVo):void
        {
            spaceEntryMiddleOfTextScrollingTest(5, testCaseVo);
        }

        [Test(dataProvider=HOLTRTestDp)]
        public function HOLTR_deleteScrollingTest(testCaseVo:TestCaseVo):void
        {
            deleteScrollingTest(0, testCaseVo);
        }

        [Test(dataProvider=HOLTRTestDp)]
        public function HOLTR_backspaceScrollingTest(testCaseVo:TestCaseVo):void
        {
            backspaceScrollingTest(0, testCaseVo);
        }

        [Test(dataProvider=HOLTRTestDp)]
        public function HOLTR_pageUpScrollingTest(testCaseVo:TestCaseVo):void
        {
            pageUpScrollingTest(229, testCaseVo);
        }

        [Test(dataProvider=HOLTRTestDp)]
        public function HOLTR_pageDownScrollingTest(testCaseVo:TestCaseVo):void
        {
            pageDownScrollingTest(417, testCaseVo);
        }

        [Test(dataProvider=HOLTRTestDp)]
        public function HOLTR_mousewheelUpScrollingTest(testCaseVo:TestCaseVo):void
        {
            mousewheelUpScrollingTest(587, testCaseVo);
        }

        [Test(dataProvider=HOLTRTestDp)]
        public function HOLTR_mousewheelUpScrollingNoInteractionTest(testCaseVo:TestCaseVo):void
        {
            mousewheelUpScrollingNoInteractionTest(587, testCaseVo);
        }

        [Test(dataProvider=HOLTRTestDp)]
        public function HOLTR_mousewheelDownScrollingTest(testCaseVo:TestCaseVo):void
        {
            mousewheelDownScrollingTest(60, testCaseVo);
        }

        [Test(dataProvider=HOLTRTestDp)]
        public function HOLTR_mousewheelDownScrollingNoInteractionTest(testCaseVo:TestCaseVo):void
        {
            mousewheelDownScrollingNoInteractionTest(60, testCaseVo);
        }

        // 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);
        }

        // Vertical Orientation Left To Right Direction Scrolling Tests.
        [Test(dataProvider=VORTLTestDp)]
        public function VORTL_endKeyScrollingTest(testCaseVo:TestCaseVo):void
        {
            endKeyScrollingTest(1094, testCaseVo);
        }

        [Test(dataProvider=VORTLTestDp)]
        public function VORTL_homeKeyScrollingTest(testCaseVo:TestCaseVo):void
        {
            homeKeyScrollingTest(0, testCaseVo);
        }

        [Test(dataProvider=VORTLTestDp)]
        public function VORTL_cursorUpScrollingTest(testCaseVo:TestCaseVo):void
        {
            cursorUpScrollingTest(24, 1059, testCaseVo);
        }

        public function VORTL_cursorDownScrollingTest(testCaseVo:TestCaseVo):void
        {
            cursorDownScrollingTest(24, 35, testCaseVo);
        }

        [Test(dataProvider=VORTLTestDp)]
        public function VORTL_dragUpScrollingTest(testCaseVo:TestCaseVo):void
        {
            dragUpScrollingTest(23, 1059, testCaseVo);
        }

        [Test(dataProvider=VORTLTestDp)]
        public function VORTL_dragDownScrollingTest(testCaseVo:TestCaseVo):void
        {
            dragDownScrollingTest(23, 35, testCaseVo);
        }

        [Test(dataProvider=VORTLTestDp)]
        public function VORTL_characterEntryEndOfTextScrollingTest(testCaseVo:TestCaseVo):void
        {
            characterEntryEndOfTextScrollingTest(1094, testCaseVo);
        }

        [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);
        }

        [Test(dataProvider=VORTLTestDp)]
        public function VORTL_pageUpScrollingTest(testCaseVo:TestCaseVo):void
        {
            pageUpScrollingTest(0, testCaseVo);
        }

        [Test(dataProvider=VORTLTestDp)]
        public function VORTL_pageDownScrollingTest(testCaseVo:TestCaseVo):void
        {
            pageDownScrollingTest(722, testCaseVo);
        }

        [Test(dataProvider=VORTLTestDp)]
        public function VORTL_mousewheelUpScrollingTest(testCaseVo:TestCaseVo):void
        {
            mousewheelUpScrollingTest(1034, testCaseVo);
        }

        [Test(dataProvider=VORTLTestDp)]
        public function VORTL_mousewheelUpScrollingNoInteractionTest(testCaseVo:TestCaseVo):void
        {
            mousewheelUpScrollingNoInteractionTest(1034, testCaseVo);
        }

        [Test(dataProvider=VORTLTestDp)]
        public function VORTL_mousewheelDownScrollingTest(testCaseVo:TestCaseVo):void
        {
            mousewheelDownScrollingTest(60, testCaseVo);
        }

        [Test(dataProvider=VORTLTestDp)]
        public function VORTL_mousewheelDownScrollingNoInteractionTest(testCaseVo:TestCaseVo):void
        {
            mousewheelDownScrollingNoInteractionTest(60, testCaseVo);
        }

        /**
         * 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;

            var leftCode:int = 37;
            var rightCode:int = 39;
            var upCode:int = 38;
            var downCode:int = 40;

            // 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;
            }

            var kEvent:KeyboardEvent = new KeyboardEvent(KeyboardEvent.KEY_DOWN,
                    true, false, charCode, keyCode, KeyLocation.STANDARD, ctrlDown, altDown, shiftDown);
            TestFrame.container["dispatchEvent"](kEvent);
        }

        public function endKeyScrollingTest(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 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 homeKeyScrollingTest(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 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 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 cursorDownScrollingTest(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 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 dragUpScrollingTest(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);
            }
            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 dragDownScrollingTest(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 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 characterEntryEndOfTextScrollingTest(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 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 spaceEntryMiddleOfTextScrollingTest(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 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 deleteScrollingTest(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);
            // 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 backspaceScrollingTest(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);
            // 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 pageUpScrollingTest(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);
            // 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 pageDownScrollingTest(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);
            // 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 mousewheelUpScrollingTest(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);
            // 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);
            }
        }

        public function mousewheelUpScrollingNoInteractionTest(scrollPos:Number, testCaseVo:TestCaseVo):void
        {
            TestData.fileName = testCaseVo.fileName;
            super.setUpTest();

            // 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, 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);
            // 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();

            // 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);
        }

        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);
            }
        }
    }
}