Migrate AllParaAttributeTest to FU 4
Project: http://git-wip-us.apache.org/repos/asf/flex-tlf/repo Commit: http://git-wip-us.apache.org/repos/asf/flex-tlf/commit/b22063ca Tree: http://git-wip-us.apache.org/repos/asf/flex-tlf/tree/b22063ca Diff: http://git-wip-us.apache.org/repos/asf/flex-tlf/diff/b22063ca Branch: refs/heads/develop Commit: b22063cae5f5d437b271c17ce719365d8bb298ea Parents: 2b0067b Author: piotrz <[email protected]> Authored: Tue May 27 08:10:00 2014 +0200 Committer: piotrz <[email protected]> Committed: Tue May 27 08:10:00 2014 +0200 ---------------------------------------------------------------------- .../ExtendedClasses/TestSuiteExtended.as | 2 - automation_tests/src/AllTestsSuite.as | 3 +- .../src/UnitTest/Tests/AllAttributeTest.as | 223 ---------- .../src/UnitTest/Tests/AllCharAttributeTest.as | 318 +++++++++++++- .../src/UnitTest/Tests/AllParaAttributeTest.as | 409 +++++++++++++++---- 5 files changed, 638 insertions(+), 317 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/flex-tlf/blob/b22063ca/automation_core/src/UnitTest/ExtendedClasses/TestSuiteExtended.as ---------------------------------------------------------------------- diff --git a/automation_core/src/UnitTest/ExtendedClasses/TestSuiteExtended.as b/automation_core/src/UnitTest/ExtendedClasses/TestSuiteExtended.as index 81137a3..91ce0cf 100644 --- a/automation_core/src/UnitTest/ExtendedClasses/TestSuiteExtended.as +++ b/automation_core/src/UnitTest/ExtendedClasses/TestSuiteExtended.as @@ -18,8 +18,6 @@ //////////////////////////////////////////////////////////////////////////////// package UnitTest.ExtendedClasses { - import UnitTest.ExtendedClasses.*; - import flash.events.Event; import flexunit.framework.*; http://git-wip-us.apache.org/repos/asf/flex-tlf/blob/b22063ca/automation_tests/src/AllTestsSuite.as ---------------------------------------------------------------------- diff --git a/automation_tests/src/AllTestsSuite.as b/automation_tests/src/AllTestsSuite.as index 2134fcd..2ca5aab 100644 --- a/automation_tests/src/AllTestsSuite.as +++ b/automation_tests/src/AllTestsSuite.as @@ -22,6 +22,7 @@ package import UnitTest.Tests.AccessibilityMethodsTest; import UnitTest.Tests.AllCharAttributeTest; import UnitTest.Tests.AllEventTest; + import UnitTest.Tests.AllParaAttributeTest; import UnitTest.Tests.AttributeTest; import UnitTest.Tests.BoxTest; import UnitTest.Tests.ContainerTypeTest; @@ -42,7 +43,7 @@ package public var operationTest:OperationTest; public var scrollingTest:ScrollingTest; public var allAttributeTest:AllCharAttributeTest; - // public var allParagraphTest:AllParaAttributeTest; + public var allParagraphTest:AllParaAttributeTest; } } http://git-wip-us.apache.org/repos/asf/flex-tlf/blob/b22063ca/automation_tests/src/UnitTest/Tests/AllAttributeTest.as ---------------------------------------------------------------------- diff --git a/automation_tests/src/UnitTest/Tests/AllAttributeTest.as b/automation_tests/src/UnitTest/Tests/AllAttributeTest.as index 4402025..39d161d 100644 --- a/automation_tests/src/UnitTest/Tests/AllAttributeTest.as +++ b/automation_tests/src/UnitTest/Tests/AllAttributeTest.as @@ -21,8 +21,6 @@ package UnitTest.Tests import UnitTest.ExtendedClasses.VellumTestCase; import UnitTest.Fixtures.TestConfig; - import flash.display.Sprite; - import flashx.textLayout.elements.FlowLeafElement; import flashx.textLayout.elements.TextFlow; import flashx.textLayout.formats.Category; @@ -39,8 +37,6 @@ package UnitTest.Tests protected var testProp:Property; protected var testValue:*; protected var expectedValue:*; - protected var description:Object; - protected var category:String; public function AllAttributeTest(methodName:String, testID:String, testConfig:TestConfig, prop:Property, testValue:*, expectedValue:*) { @@ -55,225 +51,6 @@ package UnitTest.Tests metaData.productArea = "Text Attributes"; } - /** - * This builds testcases for properties in description that are Number types. For each number property - * testcases are built to set the value to the below the minimum value, step from the minimum value to the maximum value - * and then above the maximum value. - */ - protected function testAllNumberPropsFromMinToMax(testConfig:TestConfig, description:Object, category:String):void - { - for each (testProp in description) - { - var handler:NumberPropertyHandler = testProp.findHandler(NumberPropertyHandler) as NumberPropertyHandler; - - if (handler && testProp.category == category) - { - var minVal:Number = handler.minValue; - var maxVal:Number = handler.maxValue; - assertTrue(true, minVal < maxVal); - var delta:Number = (maxVal - minVal) / 10; - var includeInMinimalTestSuite:Boolean; - - for (var value:Number = minVal - delta; ;) - { - expectedValue = value < minVal ? undefined : (value > maxVal ? undefined : value); - testValue = value; - // include in the minmalTest values below the range, min value, max value and values above the range - includeInMinimalTestSuite = (value <= minVal || value >= maxVal) - - runOneCharacterAttributeTest(); - - if (value > maxVal) - break; - value += delta; - } - } - } - } - - /** - * This builds testcases for properties in attributes in description that are Int types. For each number property - * testcases are built to set the value to the below the minimum value, step from the minimum value to the maximum value - * and then above the maximum value. - */ - protected function testAllIntPropsFromMinToMax(testConfig:TestConfig, description:Object, category:String):void - { - for each (testProp in description) - { - if (testProp.category == category) - { - var handler:IntPropertyHandler = testProp.findHandler(IntPropertyHandler) as IntPropertyHandler; - if (handler) - { - var minVal:int = handler.minValue; - var maxVal:int = handler.maxValue; - assertTrue(true, minVal < maxVal); - var delta:int = (maxVal - minVal) / 10; - var includeInMinimalTestSuite:Boolean; - - for (var value:Number = minVal - delta; ;) - { - expectedValue = value < minVal ? undefined : (value > maxVal ? undefined : value); - testValue = value; - // include in the minmalTest values below the range, min value, max value and values above the range - includeInMinimalTestSuite = (value <= minVal || value >= maxVal) - - runOneCharacterAttributeTest(); - - if (value > maxVal) - break; - value += delta; - } - } - } - } - } - - /** - * This builds testcases for properties in description that are NumberOrPercent types. For each number property - * testcases are built to set the value to the below the minimum value, step from the minimum value to the maximum value - * and then above the maximum value. This is done first using the min/max number values and then the min/max percent values. - */ - protected function testAllNumberOrPercentPropsFromMinToMax(testConfig:TestConfig, description:Object, category:String):void - { - for each (testProp in description) - { - if (testProp.category == category) - { - var numberHandler:NumberPropertyHandler = testProp.findHandler(NumberPropertyHandler) as NumberPropertyHandler; - var percentHandler:PercentPropertyHandler = testProp.findHandler(PercentPropertyHandler) as PercentPropertyHandler; - if (numberHandler && percentHandler) - { - var minVal:Number = numberHandler.minValue; - var maxVal:Number = numberHandler.maxValue; - assertTrue(true, minVal < maxVal); - var delta:Number = (maxVal - minVal) / 10; - var includeInMinimalTestSuite:Boolean; - - for (var value:Number = minVal - delta; ;) - { - expectedValue = value < minVal ? undefined : (value > maxVal ? undefined : value); - testValue = value; - - // include in the minmalTest values below the range, min value, max value and values above the range - includeInMinimalTestSuite = (value <= minVal || value >= maxVal) - - runOneCharacterAttributeTest(); - //ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, value, expectedValue, includeInMinimalTestSuite) ); - - if (value > maxVal) - break; - value += delta; - } - - // repeat with percent values - minVal = percentHandler.minValue; - maxVal = percentHandler.maxValue; - assertTrue(true, minVal < maxVal); - delta = (maxVal - minVal) / 10; - - for (value = minVal - delta; ;) - { - expectedValue = value < minVal ? undefined : (value > maxVal ? undefined : value.toString() + "%"); - //ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, value.toString()+"%", expectedValue, true) ); - - testValue = value.toString() + "%"; - - runOneCharacterAttributeTest(); - - if (value > maxVal) - break; - value += delta; - } - } - } - } - } - - /** - * This builds testcases for properties in attributes in description that are Boolean types. A testcase is generated - * for true and false for the value. - */ - protected function testAllBooleanProps(testConfig:TestConfig, description:Object, category:String):void - { - for each (testProp in description) - { - if (testProp.category == category && testProp.findHandler(BooleanPropertyHandler) != null) - { - expectedValue = testValue = true; - runOneCharacterAttributeTest(); - - expectedValue = testValue = false; - runOneCharacterAttributeTest(); - } - } - } - - /** - * This builds testcases for properties in attributes in description that are Enumerated types types. A testcase is generated - * for each possible enumerated value - */ - protected function testAllEnumProps(testConfig:TestConfig, description:Object, category:String):void - { - var range:Object = null; - var value:Object = null; - - for each (testProp in description) - { - // new code - if (testProp.category == category) - { - var handler:EnumPropertyHandler = testProp.findHandler(EnumPropertyHandler) as EnumPropertyHandler; - if (handler) - { - range = handler.range; - for (value in range) - { - if (value != FormatValue.INHERIT) - { - expectedValue = testValue = value; - runOneCharacterAttributeTest(); - } - } - expectedValue = undefined; - testValue = "foo"; - runOneCharacterAttributeTest(); - } - - } - } - } - - /** - * This builds testcases for setting all properties in description to inherit, null, undefined and an object. - */ - protected function testAllSharedValues(testConfig:TestConfig, description:Object, category:String):void - { - for each (testProp in description) - { - if (testProp.category == category) - { - - testValue = expectedValue = FormatValue.INHERIT; - runOneCharacterAttributeTest(); - - testValue = new Sprite(); - expectedValue = undefined; - runOneCharacterAttributeTest(); - - testValue = null; - expectedValue = undefined; - runOneCharacterAttributeTest(); - - testValue = expectedValue = undefined; - runOneCharacterAttributeTest(); - - testValue = expectedValue = undefined; - clearFormatTest(); - } - } - } - public function clearFormatTest():void { SelManager.selectAll(); http://git-wip-us.apache.org/repos/asf/flex-tlf/blob/b22063ca/automation_tests/src/UnitTest/Tests/AllCharAttributeTest.as ---------------------------------------------------------------------- diff --git a/automation_tests/src/UnitTest/Tests/AllCharAttributeTest.as b/automation_tests/src/UnitTest/Tests/AllCharAttributeTest.as index a9e1561..943ba54 100644 --- a/automation_tests/src/UnitTest/Tests/AllCharAttributeTest.as +++ b/automation_tests/src/UnitTest/Tests/AllCharAttributeTest.as @@ -20,11 +20,25 @@ package UnitTest.Tests { import UnitTest.Fixtures.TestConfig; + import flash.display.Sprite; + + import flashx.textLayout.elements.FlowLeafElement; + import flashx.textLayout.elements.TextFlow; + import flashx.textLayout.formats.Category; + import flashx.textLayout.formats.FormatValue; import flashx.textLayout.formats.TextLayoutFormat; + import flashx.textLayout.property.BooleanPropertyHandler; + import flashx.textLayout.property.EnumPropertyHandler; + import flashx.textLayout.property.IntPropertyHandler; + import flashx.textLayout.property.NumberPropertyHandler; + import flashx.textLayout.property.PercentPropertyHandler; import flashx.textLayout.tlf_internal; + import org.flexunit.asserts.assertTrue; + import flashx.textLayout.property.Property; + use namespace tlf_internal; public class AllCharAttributeTest extends AllAttributeTest @@ -42,27 +56,311 @@ package UnitTest.Tests override public function setUpTest():void { super.setUpTest(); + } + + [After] + override public function tearDownTest():void + { + super.tearDownTest(); testProp = null; expectedValue = null; testValue = null; } - [After] - override public function tearDownTest():void + /** + * This builds testcases for properties in description that are Number types. For each number property + * testcases are built to set the value to the below the minimum value, step from the minimum value to the maximum value + * and then above the maximum value. + */ + [Test] + public function testAllNumberPropsFromMinToMax():void { - super.tearDownTest(); + for each (testProp in TextLayoutFormat.description) + { + var handler:NumberPropertyHandler = testProp.findHandler(NumberPropertyHandler) as NumberPropertyHandler; + + if (handler && testProp.category == Category.CHARACTER) + { + var minVal:Number = handler.minValue; + var maxVal:Number = handler.maxValue; + assertTrue(true, minVal < maxVal); + var delta:Number = (maxVal - minVal) / 10; + var includeInMinimalTestSuite:Boolean; + + for (var value:Number = minVal - delta; ;) + { + expectedValue = value < minVal ? undefined : (value > maxVal ? undefined : value); + testValue = value; + // include in the minmalTest values below the range, min value, max value and values above the range + includeInMinimalTestSuite = (value <= minVal || value >= maxVal) + + runOneCharacterAttributeTest(); + + if (value > maxVal) + break; + value += delta; + } + } + } } + + /** + * This builds testcases for properties in attributes in description that are Int types. For each number property + * testcases are built to set the value to the below the minimum value, step from the minimum value to the maximum value + * and then above the maximum value. + */ [Test] - public function propertiesCharacterTests():void + public function testAllIntPropsFromMinToMax():void { - testAllNumberPropsFromMinToMax(TestConfig.getInstance(), TextLayoutFormat.description, Category.CHARACTER); - testAllIntPropsFromMinToMax(TestConfig.getInstance(), TextLayoutFormat.description, Category.CHARACTER); - testAllNumberOrPercentPropsFromMinToMax(TestConfig.getInstance(), TextLayoutFormat.description, Category.CHARACTER); - testAllBooleanProps(TestConfig.getInstance(), TextLayoutFormat.description, Category.CHARACTER); - testAllEnumProps(TestConfig.getInstance(), TextLayoutFormat.description, Category.CHARACTER); - testAllSharedValues(TestConfig.getInstance(), TextLayoutFormat.description, Category.CHARACTER); + for each (testProp in TextLayoutFormat.description) + { + if (testProp.category == Category.CHARACTER) + { + var handler:IntPropertyHandler = testProp.findHandler(IntPropertyHandler) as IntPropertyHandler; + if (handler) + { + var minVal:int = handler.minValue; + var maxVal:int = handler.maxValue; + assertTrue(true, minVal < maxVal); + var delta:int = (maxVal - minVal) / 10; + var includeInMinimalTestSuite:Boolean; + + for (var value:Number = minVal - delta; ;) + { + expectedValue = value < minVal ? undefined : (value > maxVal ? undefined : value); + testValue = value; + // include in the minmalTest values below the range, min value, max value and values above the range + includeInMinimalTestSuite = (value <= minVal || value >= maxVal) + + runOneCharacterAttributeTest(); + + if (value > maxVal) + break; + value += delta; + } + } + } + } + } + + /** + * This builds testcases for properties in description that are NumberOrPercent types. For each number property + * testcases are built to set the value to the below the minimum value, step from the minimum value to the maximum value + * and then above the maximum value. This is done first using the min/max number values and then the min/max percent values. + */ + [Test] + public function testAllNumberOrPercentPropsFromMinToMax():void + { + for each (testProp in TextLayoutFormat.description) + { + if (testProp.category == Category.CHARACTER) + { + var numberHandler:NumberPropertyHandler = testProp.findHandler(NumberPropertyHandler) as NumberPropertyHandler; + var percentHandler:PercentPropertyHandler = testProp.findHandler(PercentPropertyHandler) as PercentPropertyHandler; + if (numberHandler && percentHandler) + { + var minVal:Number = numberHandler.minValue; + var maxVal:Number = numberHandler.maxValue; + assertTrue(true, minVal < maxVal); + var delta:Number = (maxVal - minVal) / 10; + var includeInMinimalTestSuite:Boolean; + + for (var value:Number = minVal - delta; ;) + { + expectedValue = value < minVal ? undefined : (value > maxVal ? undefined : value); + testValue = value; + + // include in the minmalTest values below the range, min value, max value and values above the range + includeInMinimalTestSuite = (value <= minVal || value >= maxVal) + + runOneCharacterAttributeTest(); + //ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, value, expectedValue, includeInMinimalTestSuite) ); + + if (value > maxVal) + break; + value += delta; + } + + // repeat with percent values + minVal = percentHandler.minValue; + maxVal = percentHandler.maxValue; + assertTrue(true, minVal < maxVal); + delta = (maxVal - minVal) / 10; + + for (value = minVal - delta; ;) + { + expectedValue = value < minVal ? undefined : (value > maxVal ? undefined : value.toString() + "%"); + //ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, value.toString()+"%", expectedValue, true) ); + + testValue = value.toString() + "%"; + + runOneCharacterAttributeTest(); + + if (value > maxVal) + break; + value += delta; + } + } + } + } + } + + /** + * This builds testcases for properties in attributes in description that are Boolean types. A testcase is generated + * for true and false for the value. + */ + [Test] + public function testAllBooleanProps():void + { + for each (testProp in TextLayoutFormat.description) + { + if (testProp.category == Category.CHARACTER && testProp.findHandler(BooleanPropertyHandler) != null) + { + expectedValue = testValue = true; + runOneCharacterAttributeTest(); + + expectedValue = testValue = false; + runOneCharacterAttributeTest(); + } + } + } + + + /** + * This builds testcases for properties in attributes in description that are Enumerated types types. A testcase is generated + * for each possible enumerated value + */ + [Test] + public function testAllEnumProps():void + { + var range:Object = null; + var value:Object = null; + + for each (testProp in TextLayoutFormat.description) + { + // new code + if (testProp.category == Category.CHARACTER) + { + var handler:EnumPropertyHandler = testProp.findHandler(EnumPropertyHandler) as EnumPropertyHandler; + if (handler) + { + range = handler.range; + for (value in range) + { + if (value != FormatValue.INHERIT) + { + expectedValue = testValue = value; + runOneCharacterAttributeTest(); + } + } + expectedValue = undefined; + testValue = "foo"; + runOneCharacterAttributeTest(); + } + + } + } + } + + /** + * This builds testcases for setting all properties in description to inherit, null, undefined and an object. + */ + [Test] + public function testAllSharedValues():void + { + for each (testProp in TextLayoutFormat.description) + { + if (testProp.category == Category.CHARACTER) + { + + testValue = expectedValue = FormatValue.INHERIT; + runOneCharacterAttributeTest(); + + testValue = new Sprite(); + expectedValue = undefined; + runOneCharacterAttributeTest(); + + testValue = null; + expectedValue = undefined; + runOneCharacterAttributeTest(); + + testValue = expectedValue = undefined; + runOneCharacterAttributeTest(); + + testValue = expectedValue = undefined; + clearFormatTest(); + } + } + } + + /** + * Generic function to run one character attribute test. Uses the selection manager to set the attributes on the entire flow at the span level + * to value and then validates that the value is expectedValue. + */ + private function runOneCharacterAttributeTest():void + { + if (testProp == null) + return; // must be set + + SelManager.selectAll(); + + // Test direct change on single leaf + var leaf:FlowLeafElement = SelManager.textFlow.findLeaf(SelManager.absoluteStart); + var originalValue:* = leaf[testProp.name]; + + assignmentHelper(leaf); + + var expectedResult:*; + if (expectedValue === undefined) + expectedResult = testValue === undefined || testValue === null ? undefined : originalValue; + else + expectedResult = expectedValue; + + assertTrue("FlowLeafElement does not have the expected value after direct change", leaf[testProp.name] == expectedResult); + leaf[testProp.name] = originalValue; + + var ca:TextLayoutFormat = new TextLayoutFormat(); + assignmentHelper(ca); + SelManager.applyLeafFormat(ca); + + // expect that all FlowLeafElements have expectedValue as the properties value + if (expectedValue !== undefined) + assertTrue("not all FlowLeafElements have the expected value", validateCharacterPropertyOnEntireFlow(SelManager.textFlow, testProp, expectedValue)); + } + + + // support function to walk all FlowLeafElements and verify that prop is val + private function validateCharacterPropertyOnEntireFlow(textFlow:TextFlow, prop:Property, val:*):Boolean + { + var idx:int = 0; + var elem:FlowLeafElement = textFlow.getFirstLeaf(); + assertTrue("either the first FlowLeafElement is null or the textFlow length is zero", elem != null || textFlow.textLength == 0); + while (elem) + { + // error if elements have zero length + assertTrue("The FlowLeafElement has zero length", elem.textLength != 0); + + // expect all values of prop to be supplied val + if (elem.format[prop.name] !== val || elem[prop.name] !== val) + return false; + + // inherit is never computed + if ((val == FormatValue.INHERIT && elem.computedFormat[prop.name] == val) || elem.computedFormat[prop.name] === undefined) + return false; + + // skip to the next element + var nextElem:FlowLeafElement = elem.getNextLeaf(); + var absoluteEnd:int = elem.getAbsoluteStart() + elem.textLength; + if (nextElem == null) + assertTrue("absoluteEnd of the last FlowLeafElement is not the end of the textFlow", absoluteEnd == textFlow.textLength); + else + assertTrue("the end of this FlowLeafElement does not equal the start of the next", absoluteEnd == nextElem.getAbsoluteStart()); + + elem = nextElem; + } + return true; } } } http://git-wip-us.apache.org/repos/asf/flex-tlf/blob/b22063ca/automation_tests/src/UnitTest/Tests/AllParaAttributeTest.as ---------------------------------------------------------------------- diff --git a/automation_tests/src/UnitTest/Tests/AllParaAttributeTest.as b/automation_tests/src/UnitTest/Tests/AllParaAttributeTest.as index a351514..e7d5a73 100644 --- a/automation_tests/src/UnitTest/Tests/AllParaAttributeTest.as +++ b/automation_tests/src/UnitTest/Tests/AllParaAttributeTest.as @@ -18,90 +18,337 @@ //////////////////////////////////////////////////////////////////////////////// package UnitTest.Tests { - import UnitTest.ExtendedClasses.TestSuiteExtended; - import UnitTest.Fixtures.TestConfig; - - import flashx.textLayout.formats.Category; - import flashx.textLayout.formats.FormatValue; - import flashx.textLayout.formats.TextLayoutFormat; - import flashx.textLayout.elements.FlowLeafElement; - import flashx.textLayout.elements.TextFlow; - import flashx.textLayout.elements.ParagraphElement; - import flashx.textLayout.property.Property; - import flashx.textLayout.tlf_internal; + import UnitTest.Fixtures.TestConfig; + + import flash.display.Sprite; + + import flashx.textLayout.elements.FlowLeafElement; + import flashx.textLayout.elements.ParagraphElement; + + import flashx.textLayout.elements.TextFlow; + + import flashx.textLayout.formats.Category; + import flashx.textLayout.formats.FormatValue; + import flashx.textLayout.formats.TextLayoutFormat; + import flashx.textLayout.property.BooleanPropertyHandler; + import flashx.textLayout.property.EnumPropertyHandler; + import flashx.textLayout.property.IntPropertyHandler; + import flashx.textLayout.property.NumberPropertyHandler; + import flashx.textLayout.property.PercentPropertyHandler; + import flashx.textLayout.property.Property; + import flashx.textLayout.tlf_internal; import org.flexunit.asserts.assertTrue; use namespace tlf_internal; - public class AllParaAttributeTest extends AllAttributeTest - { - public function AllParaAttributeTest(methodName:String, testID:String, testConfig:TestConfig, prop:Property, value:*, expected:*) - { - super (methodName, testID, testConfig, prop, value, expected); - - // Note: These must correspond to a Watson product area (case-sensitive) - metaData.productArea = "Text Attributes"; - metaData.productSubArea = "Paragraph Attributes"; - } - - public static function suite(testConfig:TestConfig, ts:TestSuiteExtended):void - { - testAllProperties(ts, testConfig, TextLayoutFormat.description, Category.PARAGRAPH, AllParaAttributeTest, "runOneParagraphAttributeTest"); - } - - /** - * Generic function to run one character attribute test. Uses the selection manager to set the attributes on the entire flow at the span level - * to value and then validates that the value is expectedValue. - */ - public function runOneParagraphAttributeTest():void - { - if (testProp == null) - return; // must be set - - SelManager.selectAll(); - - var ca:TextLayoutFormat = new TextLayoutFormat(); - assignmentHelper(ca); - SelManager.applyParagraphFormat(ca); - - // expect that all FlowLeafElements have expectedValue as the properties value - if (expectedValue !== undefined) - assertTrue("not all ParagraphElements have the expected value", validateParagraphPropertyOnEntireFlow(SelManager.textFlow,testProp,expectedValue)); - } - - // support function to walk all FlowLeafElements and verify that prop is val - static public function validateParagraphPropertyOnEntireFlow(textFlow:TextFlow, prop:Property,val:*):Boolean - { - var idx:int = 0; - var elem:FlowLeafElement = textFlow.getFirstLeaf(); - assertTrue("either the first FlowLeafElement is null or the textFlow length is zero", elem != null || textFlow.textLength == 0); - while (elem) - { - // error if elements have zero length - assertTrue("The FlowLeafElement has zero length", elem.textLength != 0); - - var para:ParagraphElement = elem.getParagraph(); - - // expect all values of prop to be supplied val - if (para.format[prop.name] !== val) - return false; - - // inherit is never computed - if ((val == FormatValue.INHERIT && para.computedFormat[prop.name] == val) || para.computedFormat[prop.name] === undefined) - return false; - - // skip to the next element - var nextElem:FlowLeafElement = elem.getNextLeaf(); - var absoluteEnd:int = elem.getAbsoluteStart() + elem.textLength; - if (nextElem == null) - assertTrue("absoluteEnd of the last FlowLeafElement is not the end of the textFlow", absoluteEnd == textFlow.textLength); - else - assertTrue("the end of this FlowLeafElement does not equal the start of the next", absoluteEnd == nextElem.getAbsoluteStart()); - - elem = nextElem; - } - return true; - } - } + public class AllParaAttributeTest extends AllAttributeTest + { + public function AllParaAttributeTest() + { + super("", "AllParaAttributeTest", TestConfig.getInstance(), null, null, null); + + // Note: These must correspond to a Watson product area (case-sensitive) + metaData.productArea = "Text Attributes"; + metaData.productSubArea = "Paragraph Attributes"; + } + + + [Before] + override public function setUpTest():void + { + super.setUpTest(); + } + + [After] + override public function tearDownTest():void + { + super.tearDownTest(); + + testProp = null; + expectedValue = null; + testValue = null; + } + + /** + * This builds testcases for properties in description that are Number types. For each number property + * testcases are built to set the value to the below the minimum value, step from the minimum value to the maximum value + * and then above the maximum value. + */ + [Test] + public function testAllNumberPropsFromMinToMax():void + { + for each (testProp in TextLayoutFormat.description) + { + var handler:NumberPropertyHandler = testProp.findHandler(NumberPropertyHandler) as NumberPropertyHandler; + + if (handler && testProp.category == Category.PARAGRAPH) + { + var minVal:Number = handler.minValue; + var maxVal:Number = handler.maxValue; + assertTrue(true, minVal < maxVal); + var delta:Number = (maxVal - minVal) / 10; + var includeInMinimalTestSuite:Boolean; + + for (var value:Number = minVal - delta; ;) + { + expectedValue = value < minVal ? undefined : (value > maxVal ? undefined : value); + testValue = value; + // include in the minmalTest values below the range, min value, max value and values above the range + includeInMinimalTestSuite = (value <= minVal || value >= maxVal) + + runOneParagraphAttributeTest(); + + if (value > maxVal) + break; + value += delta; + } + } + } + } + + + /** + * This builds testcases for properties in attributes in description that are Int types. For each number property + * testcases are built to set the value to the below the minimum value, step from the minimum value to the maximum value + * and then above the maximum value. + */ + [Test] + public function testAllIntPropsFromMinToMax():void + { + for each (testProp in TextLayoutFormat.description) + { + if (testProp.category == Category.PARAGRAPH) + { + var handler:IntPropertyHandler = testProp.findHandler(IntPropertyHandler) as IntPropertyHandler; + if (handler) + { + var minVal:int = handler.minValue; + var maxVal:int = handler.maxValue; + assertTrue(true, minVal < maxVal); + var delta:int = (maxVal - minVal) / 10; + var includeInMinimalTestSuite:Boolean; + + for (var value:Number = minVal - delta; ;) + { + expectedValue = value < minVal ? undefined : (value > maxVal ? undefined : value); + testValue = value; + // include in the minmalTest values below the range, min value, max value and values above the range + includeInMinimalTestSuite = (value <= minVal || value >= maxVal) + + runOneParagraphAttributeTest(); + + if (value > maxVal) + break; + value += delta; + } + } + } + } + } + + /** + * This builds testcases for properties in description that are NumberOrPercent types. For each number property + * testcases are built to set the value to the below the minimum value, step from the minimum value to the maximum value + * and then above the maximum value. This is done first using the min/max number values and then the min/max percent values. + */ + [Test] + public function testAllNumberOrPercentPropsFromMinToMax():void + { + for each (testProp in TextLayoutFormat.description) + { + if (testProp.category == Category.PARAGRAPH) + { + var numberHandler:NumberPropertyHandler = testProp.findHandler(NumberPropertyHandler) as NumberPropertyHandler; + var percentHandler:PercentPropertyHandler = testProp.findHandler(PercentPropertyHandler) as PercentPropertyHandler; + if (numberHandler && percentHandler) + { + var minVal:Number = numberHandler.minValue; + var maxVal:Number = numberHandler.maxValue; + assertTrue(true, minVal < maxVal); + var delta:Number = (maxVal - minVal) / 10; + var includeInMinimalTestSuite:Boolean; + + for (var value:Number = minVal - delta; ;) + { + expectedValue = value < minVal ? undefined : (value > maxVal ? undefined : value); + testValue = value; + + // include in the minmalTest values below the range, min value, max value and values above the range + includeInMinimalTestSuite = (value <= minVal || value >= maxVal) + + runOneParagraphAttributeTest(); + //ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, value, expectedValue, includeInMinimalTestSuite) ); + + if (value > maxVal) + break; + value += delta; + } + + // repeat with percent values + minVal = percentHandler.minValue; + maxVal = percentHandler.maxValue; + assertTrue(true, minVal < maxVal); + delta = (maxVal - minVal) / 10; + + for (value = minVal - delta; ;) + { + expectedValue = value < minVal ? undefined : (value > maxVal ? undefined : value.toString() + "%"); + //ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, value.toString()+"%", expectedValue, true) ); + + testValue = value.toString() + "%"; + + runOneParagraphAttributeTest(); + + if (value > maxVal) + break; + value += delta; + } + } + } + } + } + + /** + * This builds testcases for properties in attributes in description that are Boolean types. A testcase is generated + * for true and false for the value. + */ + [Test] + public function testAllBooleanProps():void + { + for each (testProp in TextLayoutFormat.description) + { + if (testProp.category == Category.PARAGRAPH && testProp.findHandler(BooleanPropertyHandler) != null) + { + expectedValue = testValue = true; + runOneParagraphAttributeTest(); + + expectedValue = testValue = false; + runOneParagraphAttributeTest(); + } + } + } + + + /** + * This builds testcases for properties in attributes in description that are Enumerated types types. A testcase is generated + * for each possible enumerated value + */ + [Test] + public function testAllEnumProps():void + { + var range:Object = null; + var value:Object = null; + + for each (testProp in TextLayoutFormat.description) + { + // new code + if (testProp.category == Category.PARAGRAPH) + { + var handler:EnumPropertyHandler = testProp.findHandler(EnumPropertyHandler) as EnumPropertyHandler; + if (handler) + { + range = handler.range; + for (value in range) + { + if (value != FormatValue.INHERIT) + { + expectedValue = testValue = value; + runOneParagraphAttributeTest(); + } + } + expectedValue = undefined; + testValue = "foo"; + runOneParagraphAttributeTest(); + } + + } + } + } + + /** + * This builds testcases for setting all properties in description to inherit, null, undefined and an object. + */ + [Test] + public function testAllSharedValues():void + { + for each (testProp in TextLayoutFormat.description) + { + if (testProp.category == Category.PARAGRAPH) + { + + testValue = expectedValue = FormatValue.INHERIT; + runOneParagraphAttributeTest(); + + testValue = new Sprite(); + expectedValue = undefined; + runOneParagraphAttributeTest(); + + testValue = null; + expectedValue = undefined; + runOneParagraphAttributeTest(); + + testValue = expectedValue = undefined; + runOneParagraphAttributeTest(); + + testValue = expectedValue = undefined; + clearFormatTest(); + } + } + } + + /** + * Generic function to run one character attribute test. Uses the selection manager to set the attributes on the entire flow at the span level + * to value and then validates that the value is expectedValue. + */ + public function runOneParagraphAttributeTest():void + { + if (testProp == null) + return; // must be set + + SelManager.selectAll(); + + var ca:TextLayoutFormat = new TextLayoutFormat(); + assignmentHelper(ca); + SelManager.applyParagraphFormat(ca); + + // expect that all FlowLeafElements have expectedValue as the properties value + if (expectedValue !== undefined) + assertTrue("not all ParagraphElements have the expected value", validateParagraphPropertyOnEntireFlow(SelManager.textFlow,testProp,expectedValue)); + } + + // support function to walk all FlowLeafElements and verify that prop is val + static public function validateParagraphPropertyOnEntireFlow(textFlow:TextFlow, prop:Property,val:*):Boolean + { + var idx:int = 0; + var elem:FlowLeafElement = textFlow.getFirstLeaf(); + assertTrue("either the first FlowLeafElement is null or the textFlow length is zero", elem != null || textFlow.textLength == 0); + while (elem) + { + // error if elements have zero length + assertTrue("The FlowLeafElement has zero length", elem.textLength != 0); + + var para:ParagraphElement = elem.getParagraph(); + + // expect all values of prop to be supplied val + if (para.format[prop.name] !== val) + return false; + + // inherit is never computed + if ((val == FormatValue.INHERIT && para.computedFormat[prop.name] == val) || para.computedFormat[prop.name] === undefined) + return false; + + // skip to the next element + var nextElem:FlowLeafElement = elem.getNextLeaf(); + var absoluteEnd:int = elem.getAbsoluteStart() + elem.textLength; + if (nextElem == null) + assertTrue("absoluteEnd of the last FlowLeafElement is not the end of the textFlow", absoluteEnd == textFlow.textLength); + else + assertTrue("the end of this FlowLeafElement does not equal the start of the next", absoluteEnd == nextElem.getAbsoluteStart()); + + elem = nextElem; + } + return true; + } + } }
