| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one or more |
| // contributor license agreements. See the NOTICE file distributed with |
| // this work for additional information regarding copyright ownership. |
| // The ASF licenses this file to You under the Apache License, Version 2.0 |
| // (the "License"); you may not use this file except in compliance with |
| // the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| package UnitTest.Tests |
| { |
| import UnitTest.ExtendedClasses.TestSuiteExtended; |
| import UnitTest.ExtendedClasses.VellumTestCase; |
| import UnitTest.Fixtures.FileRepository; |
| import UnitTest.Fixtures.TestConfig; |
| |
| import flash.events.KeyboardEvent; |
| import flash.ui.KeyLocation; |
| |
| import flashx.textLayout.formats.BlockProgression; |
| import flashx.textLayout.container.ContainerController; |
| |
| |
| |
| public class HorizontalScrollingTest 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; |
| |
| public function HorizontalScrollingTest(methodName:String, testID:String, testConfig:TestConfig, testCaseXML:XML=null) |
| { |
| super(methodName, testID, testConfig, testCaseXML); |
| |
| // Note: These must correspond to a Watson product area (case-sensitive) |
| metaData.productArea = "UI"; |
| metaData.productSubArea = "Scrolling"; |
| } |
| |
| public static function suiteFromXML(testListXML:XML, testConfig:TestConfig, ts:TestSuiteExtended):void |
| { |
| FileRepository.readFile(testConfig.baseURL,"../../test/testFiles/markup/tlf/HORLTRHARD.xml"); |
| FileRepository.readFile(testConfig.baseURL,"../../test/testFiles/markup/tlf/VORLTRHARD.xml"); |
| FileRepository.readFile(testConfig.baseURL,"../../test/testFiles/markup/tlf/HORRTLHARD.xml"); |
| FileRepository.readFile(testConfig.baseURL,"../../test/testFiles/markup/tlf/VORRTLHARD.xml"); |
| var testCaseClass:Class = HorizontalScrollingTest; |
| VellumTestCase.suiteFromXML(testCaseClass, testListXML, testConfig, ts); |
| } |
| |
| public override function setUp():void |
| { |
| // Booga - Need to load up the test file here. |
| |
| super.setUp(); |
| } |
| |
| public override function tearDown():void |
| { |
| // Restore default configurations |
| super.tearDown(); |
| } |
| |
| |
| // 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; |
| |
| 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_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):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( END ); |
| 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( "endKeyScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| else |
| { |
| assertTrue( "endKeyScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| |
| } |
| |
| 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 End key to scroll to the end of the first line. |
| sendKeyboardGesture( END ); |
| // Hit the Home key to scroll to the end of the first line. |
| sendKeyboardGesture( 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( "homeKeyScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| else |
| { |
| assertTrue( "homeKeyScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| } |
| |
| public function cursorRightScrollingTest(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( END ); |
| // Hit the Home key to scroll to the end of the first line. |
| sendKeyboardGesture( HOME ); |
| // Move the cursor over to the right. |
| for (var i:Number = 0; i < 37; i++) |
| { |
| sendKeyboardGesture( RIGHT ); |
| } |
| var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0)); |
| // trace("cursorRightScrollingTestHP=" + tmpContainerController.horizontalScrollPosition); |
| // trace("cursorRightScrollingTestVP=" + tmpContainerController.verticalScrollPosition); |
| if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB) |
| { |
| assertTrue( "cursorRightScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| else |
| { |
| assertTrue( "cursorRightScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| } |
| |
| public function cursorLeftScrollingTest(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( END ); |
| // Move the cursor over to the right. |
| for (var i:Number = 0; i < 41; i++) |
| { |
| sendKeyboardGesture( LEFT ); |
| } |
| var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0)); |
| // trace("cursorLeftScrollingTestHP=" + tmpContainerController.horizontalScrollPosition); |
| // trace("cursorLeftScrollingTestVP=" + tmpContainerController.verticalScrollPosition); |
| if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB) |
| { |
| assertTrue( "cursorLeftScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| else |
| { |
| assertTrue( "cursorLeftScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| } |
| |
| public function dragRightScrollingTest(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( END ); |
| // Hit the Home key to scroll to the end of the first line. |
| sendKeyboardGesture( HOME ); |
| // Move the cursor to the selection that will cause a drag. |
| // Move the cursor over to the right. |
| for (var i:Number = 0; i < 36; i++) |
| { |
| sendKeyboardGesture( RIGHT ); |
| } |
| sendKeyboardGesture( SHIFT_RIGHT ); |
| var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0)); |
| // trace("dragRightScrollingTestHP=" + tmpContainerController.horizontalScrollPosition); |
| // trace("dragRightScrollingTestVP=" + tmpContainerController.verticalScrollPosition); |
| if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB) |
| { |
| assertTrue( "dragRightScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| else |
| { |
| assertTrue( "dragRightScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| } |
| |
| public function dragLeftScrollingTest(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( END ); |
| // Move the cursor to the selection that will cause a drag. |
| // Move the cursor over to the right. |
| for (var i:Number = 0; i < 40; i++) |
| { |
| sendKeyboardGesture( LEFT ); |
| } |
| sendKeyboardGesture( SHIFT_LEFT ); |
| var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0)); |
| // trace("dragLeftScrollingTestHP=" + tmpContainerController.horizontalScrollPosition); |
| // trace("dragLeftScrollingTestVP=" + tmpContainerController.verticalScrollPosition); |
| if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB) |
| { |
| assertTrue( "dragLeftScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| else |
| { |
| assertTrue( "dragLeftScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| } |
| |
| public function characterEntryEndOfFirstLineScrollingTest(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( END ); |
| // Type in ABC and confirm that it scrolls. |
| SelManager.insertText(" ABC"); |
| var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0)); |
| // trace("characterEntryEndOfFirstLineScrollingTestHP=" + tmpContainerController.horizontalScrollPosition); |
| // trace("characterEntryEndOfFirstLineScrollingTestVP=" + tmpContainerController.verticalScrollPosition); |
| if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB) |
| { |
| assertTrue( "characterEntryEndOfFirstLineScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| else |
| { |
| assertTrue( "characterEntryEndOfFirstLineScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| } |
| |
| public function characterEntryEndOfLastLineScrollingTest(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 last line. |
| sendKeyboardGesture( CTRL_END ); |
| // Type in ABC and confirm that it scrolls. |
| SelManager.insertText(" ABC"); |
| var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0)); |
| // trace("characterEntryEndOfLastLineScrollingTestHP=" + tmpContainerController.horizontalScrollPosition); |
| // trace("characterEntryEndOfLastLineScrollingTestVP=" + tmpContainerController.verticalScrollPosition); |
| if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB) |
| { |
| assertTrue( "characterEntryEndOfLastLineScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| else |
| { |
| assertTrue( "characterEntryEndOfLastLineScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| } |
| |
| public function spaceEntryEndOfFirstLineScrollingTest(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( END ); |
| // Type in ABC and confirm that it scrolls. |
| SelManager.insertText(" "); |
| var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0)); |
| // trace("spaceEntryEndOfFirstLineScrollingTestHP=" + tmpContainerController.horizontalScrollPosition); |
| // trace("spaceEntryEndOfFirstLineScrollingTestVP=" + tmpContainerController.verticalScrollPosition); |
| if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB) |
| { |
| assertTrue( "spaceEntryEndOfFirstLineScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| else |
| { |
| assertTrue( "spaceEntryEndOfFirstLineScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| } |
| |
| public function spaceEntryEndOfLastLineScrollingTest(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 last line. |
| sendKeyboardGesture( CTRL_END ); |
| // Type in ABC and confirm that it scrolls. |
| SelManager.insertText(" "); |
| var tmpContainerController:ContainerController = ContainerController(SelManager.textFlow.flowComposer.getControllerAt(0)); |
| // trace("spaceEntryEndOfLastLineScrollingTestHP=" + tmpContainerController.horizontalScrollPosition); |
| // trace("spaceEntryEndOfLastLineScrollingTestVP=" + tmpContainerController.verticalScrollPosition); |
| if (SelManager.textFlow.computedFormat.blockProgression == BlockProgression.TB) |
| { |
| assertTrue( "spaceEntryEndOfLastLineScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.verticalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| else |
| { |
| assertTrue( "spaceEntryEndOfLastLineScrollingTest Test Failed.",(scrollPos < Math.abs(tmpContainerController.horizontalScrollPosition) < (scrollPos + 1)) == true); |
| } |
| } |
| |
| 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); |
| // Hit the End key to scroll to the end of the first line. |
| sendKeyboardGesture( END ); |
| // Move the cursor to the selection that will cause a drag. |
| // Move the cursor over to the right. |
| for (var i:Number = 0; i < 40; i++) |
| { |
| sendKeyboardGesture( LEFT ); |
| } |
| for(i = 0; i < 3; 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); |
| } |
| } |
| |
| // Horizontal Orientation Left To Right Direction Scrolling Tests. |
| |
| public function HOLTR_endKeyScrollingTest():void |
| { |
| endKeyScrollingTest(19977); |
| } |
| |
| public function HOLTR_homeKeyScrollingTest():void |
| { |
| homeKeyScrollingTest(19); |
| } |
| |
| public function HOLTR_cursorRightScrollingTest():void |
| { |
| cursorRightScrollingTest(29); |
| } |
| |
| public function HOLTR_cursorLeftScrollingTest():void |
| { |
| cursorLeftScrollingTest(19960); |
| } |
| |
| public function HOLTR_dragRightScrollingTest():void |
| { |
| dragRightScrollingTest(29); |
| } |
| |
| public function HOLTR_dragLeftScrollingTest():void |
| { |
| dragLeftScrollingTest(19960); |
| } |
| |
| public function HOLTR_characterEntryEndOfFirstLineScrollingTest():void |
| { |
| characterEntryEndOfFirstLineScrollingTest(19977) |
| } |
| |
| public function HOLTR_characterEntryEndOfLastLineScrollingTest():void |
| { |
| characterEntryEndOfLastLineScrollingTest(25178); |
| } |
| |
| public function HOLTR_spaceEntryEndOfFirstLineScrollingTest():void |
| { |
| spaceEntryEndOfFirstLineScrollingTest(19977); |
| } |
| |
| public function HOLTR_spaceEntryEndOfLastLineScrollingTest():void |
| { |
| spaceEntryEndOfLastLineScrollingTest(25178); |
| } |
| |
| public function HOLTR_backspaceScrollingTest():void |
| { |
| backspaceScrollingTest(19936); |
| } |
| |
| // Vertical Orientation Left To Right Direction Scrolling Tests. |
| |
| public function VOLTR_endKeyScrollingTest():void |
| { |
| endKeyScrollingTest(20326); |
| } |
| |
| public function VOLTR_homeKeyScrollingTest():void |
| { |
| homeKeyScrollingTest(19); |
| } |
| |
| public function VOLTR_cursorRightScrollingTest():void |
| { |
| cursorRightScrollingTest(378); |
| } |
| |
| public function VOLTR_cursorLeftScrollingTest():void |
| { |
| cursorLeftScrollingTest(19960); |
| } |
| |
| public function VOLTR_dragRightScrollingTest():void |
| { |
| dragRightScrollingTest(378); |
| } |
| |
| public function VOLTR_dragLeftScrollingTest():void |
| { |
| dragLeftScrollingTest(19960); |
| } |
| |
| public function VOLTR_characterEntryEndOfFirstLineScrollingTest():void |
| { |
| characterEntryEndOfFirstLineScrollingTest(20326) |
| } |
| |
| public function VOLTR_characterEntryEndOfLastLineScrollingTest():void |
| { |
| characterEntryEndOfLastLineScrollingTest(25527); |
| } |
| |
| public function VOLTR_spaceEntryEndOfFirstLineScrollingTest():void |
| { |
| spaceEntryEndOfFirstLineScrollingTest(20326); |
| } |
| |
| public function VOLTR_spaceEntryEndOfLastLineScrollingTest():void |
| { |
| spaceEntryEndOfLastLineScrollingTest(25527); |
| } |
| |
| public function VOLTR_backspaceScrollingTest():void |
| { |
| backspaceScrollingTest(19936); |
| } |
| |
| |
| // Horizontal Orientation Left To Right Direction Scrolling Tests. |
| |
| public function HORTL_endKeyScrollingTest():void |
| { |
| endKeyScrollingTest(19977); |
| } |
| |
| public function HORTL_homeKeyScrollingTest():void |
| { |
| homeKeyScrollingTest(19); |
| } |
| |
| public function HORTL_cursorRightScrollingTest():void |
| { |
| cursorRightScrollingTest(29); |
| } |
| |
| public function HORTL_cursorLeftScrollingTest():void |
| { |
| cursorLeftScrollingTest(19960); |
| } |
| |
| public function HORTL_dragRightScrollingTest():void |
| { |
| dragRightScrollingTest(29); |
| } |
| |
| public function HORTL_dragLeftScrollingTest():void |
| { |
| dragLeftScrollingTest(19960); |
| } |
| |
| public function HORTL_characterEntryEndOfFirstLineScrollingTest():void |
| { |
| characterEntryEndOfFirstLineScrollingTest(19977) |
| } |
| |
| public function HORTL_characterEntryEndOfLastLineScrollingTest():void |
| { |
| characterEntryEndOfLastLineScrollingTest(25178); |
| } |
| |
| public function HORTL_spaceEntryEndOfFirstLineScrollingTest():void |
| { |
| spaceEntryEndOfFirstLineScrollingTest(19977); |
| } |
| |
| public function HORTL_spaceEntryEndOfLastLineScrollingTest():void |
| { |
| spaceEntryEndOfLastLineScrollingTest(25178); |
| } |
| |
| public function HORTL_backspaceScrollingTest():void |
| { |
| backspaceScrollingTest(19936); |
| } |
| |
| // Vertical Orientation Left To Right Direction Scrolling Tests. |
| |
| public function VORTL_endKeyScrollingTest():void |
| { |
| endKeyScrollingTest(20326); |
| } |
| |
| public function VORTL_homeKeyScrollingTest():void |
| { |
| homeKeyScrollingTest(19); |
| } |
| |
| public function VORTL_cursorRightScrollingTest():void |
| { |
| cursorRightScrollingTest(378); |
| } |
| |
| public function VORTL_cursorLeftScrollingTest():void |
| { |
| cursorLeftScrollingTest(19960); |
| } |
| |
| public function VORTL_dragRightScrollingTest():void |
| { |
| dragRightScrollingTest(378); |
| } |
| |
| public function VORTL_dragLeftScrollingTest():void |
| { |
| dragLeftScrollingTest(19960); |
| } |
| |
| public function VORTL_characterEntryEndOfFirstLineScrollingTest():void |
| { |
| characterEntryEndOfFirstLineScrollingTest(20326) |
| } |
| |
| public function VORTL_characterEntryEndOfLastLineScrollingTest():void |
| { |
| characterEntryEndOfLastLineScrollingTest(25527); |
| } |
| |
| public function VORTL_spaceEntryEndOfFirstLineScrollingTest():void |
| { |
| spaceEntryEndOfFirstLineScrollingTest(20326); |
| } |
| |
| public function VORTL_spaceEntryEndOfLastLineScrollingTest():void |
| { |
| spaceEntryEndOfLastLineScrollingTest(25527); |
| } |
| |
| public function VORTL_backspaceScrollingTest():void |
| { |
| backspaceScrollingTest(19936); |
| } |
| |
| |
| } |
| } |
