| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one or more |
| // contributor license agreements. See the NOTICE file distributed with |
| // this work for additional information regarding copyright ownership. |
| // The ASF licenses this file to You under the Apache License, Version 2.0 |
| // (the "License"); you may not use this file except in compliance with |
| // the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| package UnitTest.Tests |
| { |
| import UnitTest.ExtendedClasses.TestSuiteExtended; |
| import UnitTest.ExtendedClasses.VellumTestCase; |
| import UnitTest.Fixtures.TestConfig; |
| |
| import flash.display.DisplayObject; |
| import flash.display.Sprite; |
| import flash.geom.Point; |
| import flash.geom.Rectangle; |
| |
| import flashx.textLayout.compose.TextFlowLine; |
| import flashx.textLayout.elements.TextFlow; |
| import flashx.textLayout.formats.*; |
| import flashx.textLayout.tlf_internal; |
| |
| use namespace tlf_internal; |
| |
| public class ContainerAttributeTest extends VellumTestCase |
| { |
| private var testContainer:Boolean; |
| private var inputContainerAttrs:TextLayoutFormat; |
| private var outputContainerAttrs:ITextLayoutFormat; |
| private var initSize:Point; |
| |
| public function ContainerAttributeTest(methodName:String, testID:String, testConfig:TestConfig, testCaseXML:XML=null) |
| { |
| super(methodName, testID, testConfig, testCaseXML); |
| this.testContainer = (TestData.testContainer=="true"); |
| TestID = TestID + ":" + testContainer; |
| inputContainerAttrs = new TextLayoutFormat(); |
| |
| metaData.productArea = "Text Container"; |
| } |
| |
| public static function suiteFromXML(testListXML:XML, testConfig:TestConfig, ts:TestSuiteExtended):void |
| { |
| var testCaseClass:Class = ContainerAttributeTest; |
| VellumTestCase.suiteFromXML(testCaseClass, testListXML, testConfig, ts); |
| } |
| |
| public override function setUp():void |
| { |
| super.setUp(); |
| paddingRight = 0; |
| paddingLeft = 0; |
| SelManager.textFlow.paddingLeft = 0; |
| SelManager.textFlow.paddingRight = 0; |
| SelManager.selectAll(); |
| columnGap = 0; |
| columnWidth = FormatValue.AUTO; |
| columnCount = FormatValue.AUTO; |
| } |
| |
| public override function tearDown():void |
| { |
| if(initSize){ |
| size = initSize; |
| } |
| |
| super.tearDown(); |
| } |
| |
| private function set columnCount(count:Object):void |
| { |
| if(testContainer) |
| { |
| var ca:TextLayoutFormat = new TextLayoutFormat(TestFrame.format); |
| ca.columnCount = count; |
| TestFrame.format = ca; |
| } |
| else |
| { |
| inputContainerAttrs.columnCount = count; |
| SelManager.applyContainerFormat(inputContainerAttrs); |
| } |
| } |
| |
| private function get columnCount():Object |
| { |
| outputContainerAttrs = TestFrame.computedFormat; |
| return outputContainerAttrs.columnCount; |
| } |
| |
| private function set columnGap(gap:Object):void |
| { |
| if(testContainer) |
| { |
| var ca:TextLayoutFormat = new TextLayoutFormat(TestFrame.format); |
| ca.columnGap = gap; |
| TestFrame.format = ca; |
| } |
| else |
| { |
| inputContainerAttrs.columnGap = gap; |
| SelManager.applyContainerFormat(inputContainerAttrs); |
| } |
| } |
| |
| private function get columnGap():Object |
| { |
| outputContainerAttrs = TestFrame.computedFormat; |
| return outputContainerAttrs.columnGap; |
| } |
| |
| private function set columnWidth(width:Object):void |
| { |
| if(testContainer) |
| { |
| var ca:TextLayoutFormat = new TextLayoutFormat(TestFrame.format); |
| ca.columnWidth = width; |
| TestFrame.format = ca; |
| } |
| else |
| { |
| inputContainerAttrs.columnWidth = width; |
| SelManager.applyContainerFormat(inputContainerAttrs); |
| } |
| } |
| |
| private function get verticalAlign():Object |
| { |
| outputContainerAttrs = TestFrame.computedFormat; |
| return outputContainerAttrs.verticalAlign; |
| } |
| |
| private function set verticalAlign(align:Object):void |
| { |
| if(testContainer) |
| { |
| var ca:TextLayoutFormat = new TextLayoutFormat(TestFrame.format); |
| ca.verticalAlign = align as String; |
| TestFrame.format = ca; |
| |
| // Added as result of bug #1875477 |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| } |
| else |
| { |
| inputContainerAttrs.verticalAlign = align as String; |
| SelManager.applyContainerFormat(inputContainerAttrs); |
| } |
| } |
| |
| private function get columnWidth():Object |
| { |
| outputContainerAttrs = TestFrame.computedFormat; |
| return outputContainerAttrs.columnWidth; |
| } |
| |
| private function set paddingTop(padding:Object):void |
| { |
| if(testContainer) |
| { |
| var ca:TextLayoutFormat = new TextLayoutFormat(TestFrame.format); |
| ca.paddingTop = padding; |
| TestFrame.format = ca; |
| } |
| else |
| { |
| inputContainerAttrs.paddingTop = padding; |
| SelManager.applyContainerFormat(inputContainerAttrs); |
| } |
| } |
| |
| private function set paddingBottom(padding:Object):void |
| { |
| if(testContainer) |
| { |
| var ca:TextLayoutFormat = new TextLayoutFormat(TestFrame.format); |
| ca.paddingBottom = padding; |
| TestFrame.format = ca; |
| } |
| else |
| { |
| inputContainerAttrs.paddingBottom = padding; |
| SelManager.applyContainerFormat(inputContainerAttrs); |
| } |
| } |
| |
| private function set paddingRight(padding:Object):void |
| { |
| if(testContainer) |
| { |
| var ca:TextLayoutFormat = new TextLayoutFormat(TestFrame.format); |
| ca.paddingRight = padding; |
| TestFrame.format = ca; |
| } |
| else |
| { |
| inputContainerAttrs.paddingRight = padding; |
| SelManager.applyContainerFormat(inputContainerAttrs); |
| } |
| } |
| |
| private function set paddingLeft(padding:Object):void |
| { |
| if(testContainer) |
| { |
| var ca:TextLayoutFormat = new TextLayoutFormat(TestFrame.format); |
| ca.paddingLeft = padding; |
| TestFrame.format = ca; |
| } |
| else |
| { |
| inputContainerAttrs.paddingLeft = padding; |
| SelManager.applyContainerFormat(inputContainerAttrs); |
| } |
| } |
| |
| private function get testFrameWidth():Number |
| { |
| return TestFrame.compositionWidth; |
| } |
| private function get testFrameHeight():Number |
| { |
| return TestFrame.compositionHeight; |
| } |
| |
| private function get blockProgression():String |
| { |
| return TestFrame.rootElement.computedFormat.blockProgression; |
| } |
| |
| private function set blockProgression(mode:String):void |
| { |
| TestFrame.rootElement.blockProgression = mode; |
| TestFrame.textFlow.flowComposer.compose(); |
| } |
| |
| private function get size():Point |
| { |
| var width:Number = 0; |
| var height:Number = 0; |
| |
| if(TestFrame.container is DisplayObject) |
| { |
| var frame:DisplayObject = TestFrame.container as DisplayObject; |
| width = frame.width; |
| height = frame.height; |
| } |
| |
| return new Point(width,height); |
| } |
| |
| private function set size(dimension:Point):void |
| { |
| var containerAttr:TextLayoutFormat = new TextLayoutFormat(TestFrame.format); |
| containerAttr.columnCount = 1; |
| containerAttr.paddingLeft = 0; |
| containerAttr.paddingRight = 0; |
| containerAttr.paddingTop = 0; |
| containerAttr.paddingBottom = 0; |
| TestFrame.format = containerAttr; |
| |
| if (TestFrame.container is Sprite) |
| { |
| TextFlow(testApp.getTextFlow()).flowComposer.getControllerAt(0).setCompositionSize(dimension.x,dimension.y); |
| TextFlow(testApp.getTextFlow()).flowComposer.updateAllControllers(); |
| } |
| else |
| throw new Error("test does not know how to resize this container type"); // Above should be generalized? |
| } |
| |
| /** |
| * Set and get the firstBaselineOffset string values and test bound of numeric values. |
| */ |
| public function checkfirstBaselineOffset():void // KJT |
| { |
| |
| inputContainerAttrs.firstBaselineOffset = flashx.textLayout.formats.BaselineOffset.ASCENT; |
| assertTrue("expected: ascent. cascaded: " + String(inputContainerAttrs.firstBaselineOffset), |
| String(inputContainerAttrs.firstBaselineOffset) == flashx.textLayout.formats.BaselineOffset.ASCENT); |
| inputContainerAttrs.firstBaselineOffset = flashx.textLayout.formats.BaselineOffset.LINE_HEIGHT; |
| assertTrue("expected: leading. cascaded: " + String(inputContainerAttrs.firstBaselineOffset), |
| String(inputContainerAttrs.firstBaselineOffset) == flashx.textLayout.formats.BaselineOffset.LINE_HEIGHT); |
| for (var cter:uint = TextLayoutFormat.firstBaselineOffsetProperty.minValue; cter <= TextLayoutFormat.firstBaselineOffsetProperty.maxValue; cter+=33.33) |
| { |
| inputContainerAttrs.firstBaselineOffset = cter; |
| assertTrue("expected: " + cter + ". cascaded: " + inputContainerAttrs.firstBaselineOffset,inputContainerAttrs.firstBaselineOffset == cter); |
| } |
| |
| inputContainerAttrs.firstBaselineOffset = undefined; |
| } |
| |
| /** |
| * Set the gap, then change the width to see how the column count changes. |
| */ |
| public function checkColumnCountOnWidthChangeTest():void |
| { |
| var width:Number = testFrameWidth; |
| var cWidth:Number = width/10; |
| |
| columnGap = 0; |
| columnWidth = cWidth; |
| |
| var initCount:int = TestFrame.columnState.columnCount; |
| |
| columnWidth = cWidth*2; |
| |
| |
| var endCount:int = TestFrame.columnState.columnCount; |
| |
| assertTrue("expected " + Math.floor(initCount/2) + " but got " + endCount, |
| Math.floor(initCount/2) == endCount); |
| } |
| |
| /** |
| * Set the width, then change the column gap to see how the column count changes. |
| */ |
| public function checkColumnCountOnGapChangeTest():void |
| { |
| var width:Number = testFrameWidth; |
| var cWidth:Number = width/10; |
| |
| /*paddingRight = 0; |
| paddingLeft = 0; |
| SelManager.textFlow.paddingLeft = 0; |
| SelManager.textFlow.paddingRight = 0;*/ |
| columnGap = 0; |
| columnWidth = cWidth; |
| |
| var initCount:Number = TestFrame.columnState.columnCount; |
| |
| columnGap = cWidth/10; |
| |
| var endCount:Number = TestFrame.columnState.columnCount; |
| |
| assertTrue("expected " + (initCount - 1) + " but got " + endCount, |
| initCount - 1 == endCount); |
| } |
| |
| /** |
| * Set the column count, then change the column gap and see how the column width changes. |
| */ |
| public function checkColumnWidthOnGapChangeTest():void |
| { |
| var width:Number = testFrameWidth; |
| var cWidth:Number = width/10; |
| |
| /*paddingRight = 0; |
| paddingLeft = 0; |
| SelManager.textFlow.paddingLeft = 0; |
| SelManager.textFlow.paddingRight = 0;*/ |
| columnGap = 0; |
| columnCount = 10; |
| |
| var initColumn:Rectangle = TestFrame.columnState.getColumnAt(0); |
| var initWidth:Number = initColumn.width; |
| |
| columnGap = cWidth/9; |
| |
| var endColumn:Rectangle = TestFrame.columnState.getColumnAt(0); |
| var endWidth:Number = endColumn.width; |
| assertTrue("expected " + (initWidth - (initWidth/10)) + " but got " + endWidth, |
| ((initWidth - (initWidth/10)) - endWidth) < 0.01); |
| } |
| |
| /** |
| * Set the column gap, then change the column count to see how the column width changes. |
| */ |
| public function checkColumnWidthOnCountChangeTest():void |
| { |
| var bp:String = TestFrame.textFlow.computedFormat.blockProgression; |
| var width:Number = bp == BlockProgression.TB ? testFrameWidth : testFrameHeight; |
| var cWidth:Number = width/10; |
| |
| /*paddingRight = 0; |
| paddingLeft = 0; |
| SelManager.textFlow.paddingLeft = 0; |
| SelManager.textFlow.paddingRight = 0;*/ |
| columnGap = 0; |
| columnCount = 10; |
| |
| var initColumn:Rectangle = TestFrame.columnState.getColumnAt(0); |
| var initWidth:Number = bp == BlockProgression.TB ? initColumn.width : initColumn.height; |
| |
| columnCount = 5; |
| |
| var endColumn:Rectangle = TestFrame.columnState.getColumnAt(0); |
| var endWidth:Number = bp == BlockProgression.TB ? endColumn.width : endColumn.height; |
| |
| assertTrue("expected " + Math.floor(endWidth/2) + " but got " + initWidth, |
| Math.floor(endWidth/2) == Math.floor(initWidth)); |
| assertTrue("expected " + Math.floor(initWidth) + " but got " + Math.floor(cWidth), |
| Math.floor(initWidth) == Math.floor(cWidth)); |
| } |
| |
| /** |
| * Set the column count, then change the column width to see how the column gap changes. |
| */ |
| public function checkColumnGapOnWidthChangeTest():void |
| { |
| var width:Number = testFrameWidth; |
| |
| columnCount = 2; |
| columnWidth = width/3; |
| |
| var initColumn:Rectangle = TestFrame.columnState.getColumnAt(0); |
| var initGap:Number = width - initColumn.width * 2; |
| |
| assertTrue("expected init width to equal " + width/3 + ", but got " + columnWidth, |
| columnWidth == width/3); |
| assertTrue("expected init count to equal " + 2 + ", but got " + columnCount, |
| columnCount == 2); |
| assertTrue("expected init gap to equal " + width/3 + ", but got " + initGap, |
| Math.floor(initGap) == Math.floor(width/3)); |
| |
| columnWidth = width/2; |
| |
| var endColumn:Rectangle = TestFrame.columnState.getColumnAt(0); |
| var endGap:Number = width - endColumn.width * 2; |
| |
| assertTrue("expected " + Math.floor(width/2) + " but got " + Math.floor(endGap), |
| Math.floor(endGap) == 0); |
| } |
| |
| /** |
| * Set the column width, then change the column count to see how the column gap changes. |
| * NOTE: Currently commented out due to bug 1657149. |
| */ |
| public function checkColumnGapOnCountChangeTest():void |
| { |
| var width:Number = testFrameWidth; |
| |
| columnCount = 10; |
| var cWidth:Number = width/10; |
| //to get gap by reducing column width |
| columnWidth = cWidth - cWidth/9; |
| |
| var initColumn:Rectangle = TestFrame.columnState.getColumnAt(0); |
| var initGap:Number = cWidth - initColumn.width; |
| |
| //increase column count but no change to column count, gap should reduce |
| columnCount = 11; |
| cWidth = width/11; |
| |
| var endColumn:Rectangle = TestFrame.columnState.getColumnAt(0); |
| var endGap:Number = cWidth - endColumn.width; |
| assertTrue("Gap should reduce when column count increased and column width no change. ", |
| initGap > endGap); |
| } |
| |
| /** |
| * Slowly increase the padding at the top until it pushes a line off the screen |
| * then verify that the last line was the line pushed off the screen. |
| */ |
| public function topPaddingSqueezeTest():void |
| { |
| var length:int = SelManager.textFlow.flowComposer.numLines; |
| var last:TextFlowLine = SelManager.textFlow.flowComposer.getLineAt(length-1); |
| var size:int = last.textLength; |
| var count:int = TestFrame.textLength; |
| |
| for(var i:int = 0; i < 1000; i++){ |
| paddingTop = i; |
| TestFrame.textFlow.flowComposer.compose(); |
| |
| if(TestFrame.textLength == count - size){ |
| return; |
| } |
| } |
| assertTrue ("Expected " + size + "characters to be pushed off (the last line)" + |
| " but actually had " + (TestFrame.textLength - count) + "pushed off", |
| TestFrame.textLength != count - size); |
| } |
| |
| /** |
| * Slowly increase the padding at the bottom until it eats the last line |
| * then verify that the last line was the line eaten. |
| */ |
| public function bottomPaddingSqueezeTest():void |
| { |
| //FLEX: Why no lines? |
| var length:int = SelManager.textFlow.flowComposer.numLines; |
| var last:TextFlowLine = SelManager.textFlow.flowComposer.getLineAt(length-1); |
| var size:int = last.textLength; |
| var count:int = TestFrame.textLength; |
| |
| for(var i:int = 0; i < 1000; i++){ |
| paddingBottom = i; |
| TestFrame.textFlow.flowComposer.compose(); |
| |
| if(TestFrame.textLength == count - size){ |
| return; |
| } |
| } |
| assertTrue ("Expected " + size + "characters to be pushed off (the last line)" + |
| " but actually had " + (TestFrame.textLength - count) + "pushed off", |
| TestFrame.textLength != count - size); |
| } |
| |
| /** |
| * Increase the left padding until you force the flow to create a new line. |
| */ |
| public function leftPaddingSqueezeTest():void |
| { |
| var length:int = SelManager.textFlow.flowComposer.numLines; |
| |
| for(var i:int = 0; i < 1000; i++){ |
| paddingLeft = i; |
| TestFrame.textFlow.flowComposer.compose(); |
| |
| if(SelManager.textFlow.flowComposer.numLines > length){ |
| return; |
| } |
| } |
| assertTrue ("Increasing the left padding to 1000 did not add lines", |
| SelManager.textFlow.flowComposer.numLines <= length); |
| } |
| |
| /** |
| * Increase the right padding until you force the flow to create a new line. |
| */ |
| public function rightPaddingSqueezeTest():void |
| { |
| var length:int = SelManager.textFlow.flowComposer.numLines; |
| |
| for(var i:int = 0; i < 1000; i++){ |
| paddingRight = i; |
| TestFrame.textFlow.flowComposer.compose(); |
| |
| if(SelManager.textFlow.flowComposer.numLines > length){ |
| return; |
| } |
| } |
| assertTrue ("Increasing the right padding to 1000 did not add lines", |
| SelManager.textFlow.flowComposer.numLines <= length); |
| } |
| |
| public function writingModeBreakTest():void |
| { |
| // clear all padding on the textFlow for this test |
| SelManager.textFlow.paddingTop = 0; |
| SelManager.textFlow.paddingLeft = 0; |
| SelManager.textFlow.paddingRight = 0; |
| SelManager.textFlow.paddingBottom = 0; |
| |
| initSize = size; |
| size = new Point(200,200); |
| |
| var initCounts:Array = new Array(SelManager.textFlow.flowComposer.numLines); |
| |
| var initMode:String = blockProgression; |
| var nextMode:String = null; |
| |
| if(initMode == flashx.textLayout.formats.BlockProgression.TB){ |
| nextMode = flashx.textLayout.formats.BlockProgression.RL; |
| }else{ |
| nextMode = flashx.textLayout.formats.BlockProgression.TB; |
| } |
| |
| |
| var i:int = 0; |
| for(; i < SelManager.textFlow.flowComposer.numLines; i++){ |
| var line:TextFlowLine = SelManager.textFlow.flowComposer.getLineAt(i); |
| if (line.isDamaged()) |
| break; |
| initCounts[i] = line.textLength; |
| } |
| initCounts.length = i; |
| |
| blockProgression = nextMode; |
| SelManager.flushPendingOperations(); |
| |
| var endCounts:Array = new Array(SelManager.textFlow.flowComposer.numLines); |
| |
| i = 0; |
| for(; i < SelManager.textFlow.flowComposer.numLines; i++){ |
| line = SelManager.textFlow.flowComposer.getLineAt(i); |
| if (line.isDamaged()) |
| break; |
| endCounts[i] = line.textLength; |
| } |
| endCounts.length = i; |
| |
| var one:int = initCounts.length; |
| var two:int = endCounts.length; |
| |
| assertTrue("number of lines are not the same after changing writing direction in a square frame", |
| initCounts.length == endCounts.length); |
| for(i = 0; i < initCounts.length; i++){ |
| assertTrue("line length of line " + i + " changed after changing writing direction in a square frame", |
| initCounts[i] == endCounts[i]); |
| } |
| } |
| |
| /** |
| * This test exists solely for snapshotting. |
| */ |
| public function checkVerticalAlignTopTest():void |
| { |
| var division:int = |
| TestFrame.textFlow.computedFormat.blockProgression == |
| BlockProgression.RL ? |
| TestFrame.compositionWidth / 3 : |
| TestFrame.compositionHeight /3; |
| |
| SelManager.selectAll(); |
| SelManager.deleteNextCharacter(); |
| SelManager.flushPendingOperations(); |
| |
| SelManager.insertText("ABC"); |
| SelManager.selectRange(2,2); |
| SelManager.splitParagraph(); |
| SelManager.selectRange(1,1); |
| SelManager.splitParagraph(); |
| SelManager.flushPendingOperations(); |
| |
| verticalAlign = VerticalAlign.TOP; |
| SelManager.flushPendingOperations(); |
| |
| if( TestFrame.textFlow.computedFormat.blockProgression == |
| BlockProgression.RL |
| ){ |
| assertTrue( |
| "Vertical Alignment = TOP did not correctly place the first line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(1).x > -1*division && |
| SelManager.textFlow.flowComposer.findLineAtPosition(1).x < 0 |
| ); |
| assertTrue( |
| "Vertical Alignment = TOP did not correctly place the second line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).x > -1*division && |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).x < 0 |
| ); |
| assertTrue( |
| "Vertical Alignment = TOP did not correctly place the third line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(5).x > -1*division && |
| SelManager.textFlow.flowComposer.findLineAtPosition(5).x < 0 |
| ); |
| }else{ |
| assertTrue( |
| "Vertical Alignment = TOP did not correctly place the first line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(1).y < division |
| ); |
| assertTrue( |
| "Vertical Alignment = TOP did not correctly place the second line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).y < division |
| ); |
| assertTrue( |
| "Vertical Alignment = TOP did not correctly place the third line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(5).y < division |
| ); |
| } |
| } |
| |
| /** |
| * This test exists solely for snapshotting. |
| */ |
| public function checkVerticalAlignBottomTest():void |
| { |
| var division:int = |
| TestFrame.textFlow.computedFormat.blockProgression == |
| BlockProgression.RL ? |
| TestFrame.compositionWidth / 3 : |
| TestFrame.compositionHeight /3; |
| |
| SelManager.selectAll(); |
| SelManager.deleteNextCharacter(); |
| SelManager.flushPendingOperations(); |
| |
| SelManager.insertText("ABC"); |
| SelManager.selectRange(2,2); |
| SelManager.splitParagraph(); |
| SelManager.selectRange(1,1); |
| SelManager.splitParagraph(); |
| SelManager.flushPendingOperations(); |
| |
| verticalAlign = VerticalAlign.BOTTOM; |
| SelManager.flushPendingOperations(); |
| |
| var t1:int = SelManager.textFlow.flowComposer.findLineAtPosition(1).x; |
| var t2:int = SelManager.textFlow.flowComposer.findLineAtPosition(1).y; |
| |
| if( TestFrame.textFlow.computedFormat.blockProgression == |
| BlockProgression.RL |
| ){ |
| assertTrue( |
| "Vertical Alignment = BOTTOM did not correctly place the first line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(1).x < -2*division |
| ); |
| assertTrue( |
| "Vertical Alignment = BOTTOM did not correctly place the second line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).x < -2*division |
| ); |
| assertTrue( |
| "Vertical Alignment = BOTTOM did not correctly place the third line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(5).x < -2*division |
| ); |
| }else{ |
| assertTrue( |
| "Vertical Alignment = BOTTOM did not correctly place the first line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(1).y > 2*division |
| ); |
| assertTrue( |
| "Vertical Alignment = BOTTOM did not correctly place the second line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).y > 2*division |
| ); |
| assertTrue( |
| "Vertical Alignment = BOTTOM did not correctly place the third line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(5).y > 2*division |
| ); |
| } |
| } |
| |
| /** |
| * This test exists solely for snapshotting. |
| */ |
| public function checkVerticalAlignMiddleTest():void |
| { |
| var division:int = |
| TestFrame.textFlow.computedFormat.blockProgression == |
| BlockProgression.RL ? |
| TestFrame.compositionWidth / 3 : |
| TestFrame.compositionHeight /3; |
| |
| |
| SelManager.selectAll(); |
| SelManager.deleteNextCharacter(); |
| SelManager.flushPendingOperations(); |
| |
| SelManager.insertText("ABC"); |
| SelManager.selectRange(2,2); |
| SelManager.splitParagraph(); |
| SelManager.selectRange(1,1); |
| SelManager.splitParagraph(); |
| SelManager.flushPendingOperations(); |
| |
| verticalAlign = VerticalAlign.MIDDLE; |
| SelManager.flushPendingOperations(); |
| |
| if( TestFrame.textFlow.computedFormat.blockProgression == |
| BlockProgression.RL |
| ){ |
| assertTrue( |
| "Vertical Alignment = MIDDLE did not correctly place the first line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(1).x < -1*division && |
| SelManager.textFlow.flowComposer.findLineAtPosition(1).x > -2*division |
| ); |
| assertTrue( |
| "Vertical Alignment = MIDDLE did not correctly place the second line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).x < -1*division && |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).x > -2*division |
| ); |
| assertTrue( |
| "Vertical Alignment = MIDDLE did not correctly place the third line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(5).x < -1*division && |
| SelManager.textFlow.flowComposer.findLineAtPosition(5).x > -2*division |
| ); |
| }else{ |
| assertTrue( |
| "Vertical Alignment = MIDDLE did not correctly place the first line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(1).y > division && |
| SelManager.textFlow.flowComposer.findLineAtPosition(1).y < 2*division |
| ); |
| assertTrue( |
| "Vertical Alignment = MIDDLE did not correctly place the second line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).y > division && |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).y < 2*division |
| ); |
| assertTrue( |
| "Vertical Alignment = MIDDLE did not correctly place the third line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(5).y > division && |
| SelManager.textFlow.flowComposer.findLineAtPosition(5).y < 2*division |
| ); |
| } |
| } |
| |
| /** |
| * This test exists solely for snapshotting. |
| */ |
| public function checkVerticalAlignJustifyTest():void |
| { |
| var division:int = |
| TestFrame.textFlow.computedFormat.blockProgression == |
| BlockProgression.RL ? |
| TestFrame.compositionWidth / 3 : |
| TestFrame.compositionHeight /3; |
| |
| SelManager.selectAll(); |
| SelManager.deleteNextCharacter(); |
| SelManager.flushPendingOperations(); |
| |
| SelManager.insertText("ABC"); |
| SelManager.selectRange(2,2); |
| SelManager.splitParagraph(); |
| SelManager.selectRange(1,1); |
| SelManager.splitParagraph(); |
| SelManager.flushPendingOperations(); |
| |
| verticalAlign = VerticalAlign.JUSTIFY; |
| SelManager.flushPendingOperations(); |
| |
| if( TestFrame.textFlow.computedFormat.blockProgression == |
| BlockProgression.RL |
| ){ |
| assertTrue( |
| "Vertical Alignment = JUSTIFY did not correctly place the first line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(1).x > -1*division |
| ); |
| assertTrue( |
| "Vertical Alignment = JUSTIFY did not correctly place the second line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).x < -1*division && |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).x > -2*division |
| ); |
| assertTrue( |
| "Vertical Alignment = JUSTIFY did not correctly place the third line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(5).x < -2*division |
| ); |
| }else{ |
| assertTrue( |
| "Vertical Alignment = JUSTIFY did not correctly place the first line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(1).y < division |
| ); |
| assertTrue( |
| "Vertical Alignment = JUSTIFY did not correctly place the second line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).y > division && |
| SelManager.textFlow.flowComposer.findLineAtPosition(3).y < 2*division |
| ); |
| assertTrue( |
| "Vertical Alignment = JUSTIFY did not correctly place the third line.", |
| SelManager.textFlow.flowComposer.findLineAtPosition(5).y > 2*division |
| ); |
| } |
| } |
| |
| // non-empty flow, check if attribute changed after insertion point at position 0 |
| public function insertPos0CheckColumnWidthTest():void |
| { |
| var bp:String = TestFrame.textFlow.computedFormat.blockProgression; |
| var width:Number = bp == BlockProgression.TB ? testFrameWidth : testFrameHeight; |
| var cWidth:Number = width/10; |
| |
| columnGap = 0; |
| columnCount = 10; |
| |
| var initColumn:Rectangle = TestFrame.columnState.getColumnAt(0); |
| var initWidth:Number = bp == BlockProgression.TB ? initColumn.width : initColumn.height; |
| |
| SelManager.selectRange(0,0); |
| SelManager.insertText("BBB"); |
| SelManager.updateAllControllers(); |
| |
| var endColumn:Rectangle = TestFrame.columnState.getColumnAt(0); |
| var endWidth:Number = bp == BlockProgression.TB ? endColumn.width : endColumn.height; |
| |
| assertTrue("Container attribute got changed, expected column width " + initWidth + " but got " + cWidth, |
| initWidth == endWidth); |
| } |
| |
| //check if container attribute change after insertion in an empty flow |
| public function checkColumnCountEmptyFlowInsertTest():void |
| { |
| var width:Number = testFrameWidth; |
| var cWidth:Number = width/10; |
| |
| columnGap = 0; |
| columnWidth = cWidth; |
| |
| var initCount:Number = TestFrame.columnState.columnCount; |
| |
| //insert text in a empty flow |
| SelManager.selectAll(); |
| SelManager.deleteText(); |
| SelManager.insertText("AAAAAAAAAAAAAA"); |
| SelManager.updateAllControllers(); |
| |
| var endCount:Number = TestFrame.columnState.columnCount; |
| |
| assertTrue("container attribute has been changed, expected colume count is" + initCount + " but got " + endCount, |
| initCount == endCount ); |
| } |
| |
| // non-empty flow, check if attribute changed after insertion point at end position |
| public function insertAtEndOfFlowCheckColumnGapTest():void |
| { |
| var bp:String = TestFrame.textFlow.computedFormat.blockProgression; |
| var width:Number = testFrameWidth; |
| |
| columnCount = 2; |
| columnWidth = width/3; |
| |
| var initColumn:Rectangle = TestFrame.columnState.getColumnAt(0); |
| var initGap:Number = bp == BlockProgression.TB ? (width - initColumn.width * 2) : (width - initColumn.height * 2); |
| |
| var len:int = SelManager.textFlow.textLength; |
| SelManager.selectRange(len,len); |
| SelManager.insertText("BBB"); |
| SelManager.updateAllControllers(); |
| |
| var endColumn:Rectangle = TestFrame.columnState.getColumnAt(0); |
| var endGap:Number = bp == BlockProgression.TB ? (width - endColumn.width * 2) : (width - endColumn.height * 2); |
| |
| assertTrue("Container attribute got changed, expected column gap " + initGap + " but got " + endGap, |
| initGap == endGap); |
| } |
| |
| } |
| } |