blob: 76f7047cc147c08a8ab0c121a1b408aa4ce93617 [file] [log] [blame]
////////////////////////////////////////////////////////////////////////////////
//
// 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.TestDescriptor;
import UnitTest.ExtendedClasses.TestSuiteExtended;
import UnitTest.ExtendedClasses.VellumTestCase;
import UnitTest.Fixtures.TestConfig;
import flash.display.Sprite;
import flashx.textLayout.debug.assert;
import flashx.textLayout.formats.Category;
import flashx.textLayout.formats.FormatValue;
import flashx.textLayout.formats.TextLayoutFormat;
import flashx.textLayout.property.*;
/** Base class for All*AttributeTest */
public class AllAttributeTest extends VellumTestCase
{
// test specific configuration
protected var testProp:Property;
protected var testValue:*;
protected var expectedValue:*;
public function AllAttributeTest(methodName:String, testID:String, testConfig:TestConfig, prop:Property, testValue:*, expectedValue:*)
{
super (methodName, testID, testConfig);
// assert(testValue != null,"null?");
testProp = prop;
this.testValue = testValue;
this.expectedValue = expectedValue;
// Note: These must correspond to a Watson product area (case-sensitive)
metaData.productArea = "Text Attributes";
}
/* ************************************************************** */
/* Use Format description and Property classes to generate testcases for Format in description
/* ************************************************************** */
/** Build testcases for all properties in the description. Depending on the property type iterate over possible values and test. */
static internal function testAllProperties(ts:TestSuiteExtended, testConfig:TestConfig, description:Object, category:String, testClass:Class, methodName:String):void
{
testAllNumberPropsFromMinToMax(ts, testConfig, description, category, testClass, methodName);
testAllIntPropsFromMinToMax(ts, testConfig, description, category, testClass, methodName);
testAllNumberOrPercentPropsFromMinToMax(ts, testConfig, description, category, testClass, methodName);
testAllBooleanProps(ts, testConfig, description, category, testClass, methodName);
testAllEnumProps(ts, testConfig, description, category, testClass, methodName);
testAllSharedValues(ts, testConfig, description, category, testClass, methodName);
}
/**
* 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.
*/
static internal function testAllNumberPropsFromMinToMax(ts:TestSuiteExtended, testConfig:TestConfig, description:Object, category:String, testClass:Class, methodName:String):void
{
for each (var prop:Property in description)
{
var handler:NumberPropertyHandler = prop.findHandler(NumberPropertyHandler) as NumberPropertyHandler;
if (handler && prop.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;;)
{
var expectedValue:* = value < minVal ? undefined : (value > maxVal ? undefined : value);
// include in the minmalTest values below the range, min value, max value and values above the range
includeInMinimalTestSuite = (value <= minVal || value >= maxVal)
ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, value, expectedValue, includeInMinimalTestSuite) );
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.
*/
static internal function testAllIntPropsFromMinToMax(ts:TestSuiteExtended, testConfig:TestConfig, description:Object, category:String, testClass:Class, methodName:String):void
{
for each (var prop:Property in description)
{
if (prop.category == category)
{
var handler:IntPropertyHandler = prop.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;;)
{
var expectedValue:* = value < minVal ? undefined : (value > maxVal ? undefined : value);
// include in the minmalTest values below the range, min value, max value and values above the range
includeInMinimalTestSuite = (value <= minVal || value >= maxVal)
ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, value, expectedValue, includeInMinimalTestSuite) );
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.
*/
static internal function testAllNumberOrPercentPropsFromMinToMax(ts:TestSuiteExtended, testConfig:TestConfig, description:Object, category:String, testClass:Class, methodName:String):void
{
for each (var prop:Property in description)
{
if (prop.category == category)
{
var numberHandler:NumberPropertyHandler = prop.findHandler(NumberPropertyHandler) as NumberPropertyHandler;
var percentHandler:PercentPropertyHandler = prop.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;;)
{
var expectedValue:* = value < minVal ? undefined : (value > maxVal ? undefined : value);
// include in the minmalTest values below the range, min value, max value and values above the range
includeInMinimalTestSuite = (value <= minVal || value >= maxVal)
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) );
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.
*/
static internal function testAllBooleanProps(ts:TestSuiteExtended, testConfig:TestConfig, description:Object, category:String, testClass:Class, methodName:String):void
{
for each (var prop:Property in description)
{
if (prop.category == category && prop.findHandler(BooleanPropertyHandler) != null)
{
ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, true, true, true) );
ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, false, false, true) );
}
}
}
/**
* This builds testcases for properties in attributes in description that are Enumerated types types. A testcase is generated
* for each possible enumerated value
*/
static internal function testAllEnumProps(ts:TestSuiteExtended, testConfig:TestConfig, description:Object, category:String, testClass:Class, methodName:String):void
{
var range:Object;
var value:Object;
for each (var prop:Property in description)
{
// new code
if (prop.category == category)
{
var handler:EnumPropertyHandler = prop.findHandler(EnumPropertyHandler) as EnumPropertyHandler;
if (handler)
{
range = handler.range;
for (value in range)
{
if ( value != FormatValue.INHERIT )
ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, value, value, true) );
}
ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, "foo", undefined, true) );
}
}
}
}
/**
* This builds testcases for setting all properties in description to inherit, null, undefined and an object.
*/
static internal function testAllSharedValues(ts:TestSuiteExtended, testConfig:TestConfig, description:Object, category:String, testClass:Class, methodName:String):void
{
for each (var prop:Property in description)
{
if (prop.category == category)
{
ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, FormatValue.INHERIT, FormatValue.INHERIT, true) );
// try an object, null and undefined
ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, new Sprite(), undefined, false) );
ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, null, undefined, false) );
ts.addTestDescriptor( new TestDescriptor (testClass, methodName, testConfig, null, prop, undefined, undefined, false) );
ts.addTestDescriptor( new TestDescriptor (testClass,"clearFormatTest", testConfig, null, prop, undefined, undefined, false));
}
}
}
public function clearFormatTest():void
{
SelManager.selectAll();
var applyFormat:TextLayoutFormat = new TextLayoutFormat();
applyFormat[testProp.name] = testProp.defaultValue;
var clearFormat:TextLayoutFormat = new TextLayoutFormat();
clearFormat[testProp.name] = FormatValue.INHERIT;
switch(testProp.category)
{
case Category.CHARACTER:
SelManager.applyFormat(applyFormat,null,null);
AllCharAttributeTest.validateCharacterPropertyOnEntireFlow(SelManager.textFlow,testProp,testProp.defaultValue);
SelManager.clearFormat(clearFormat,null,null);
AllCharAttributeTest.validateCharacterPropertyOnEntireFlow(SelManager.textFlow,testProp,undefined);
break;
case Category.PARAGRAPH:
SelManager.applyFormat(null,applyFormat,null);
AllParaAttributeTest.validateParagraphPropertyOnEntireFlow(SelManager.textFlow,testProp,testProp.defaultValue);
SelManager.clearFormat(null,clearFormat,null);
AllParaAttributeTest.validateParagraphPropertyOnEntireFlow(SelManager.textFlow,testProp,undefined);
break;
case Category.CONTAINER:
SelManager.applyFormat(null,null,applyFormat);
AllContAttributeTest.validateContainerPropertyOnEntireFlow(SelManager.textFlow,testProp,testProp.defaultValue);
SelManager.clearFormat(null,null,clearFormat);
AllContAttributeTest.validateContainerPropertyOnEntireFlow(SelManager.textFlow,testProp,undefined);
break;
}
}
private var errorHandlerCount:int = 0;
public function errorHandler(p:Property,value:Object):void
{
errorHandlerCount++;
}
protected function assignmentHelper(target:Object):void
{
Property.errorHandler = errorHandler;
errorHandlerCount = 0;
try {
target[testProp.name] = testValue;
}
catch (e:Error)
{
Property.errorHandler = Property.defaultErrorHandler;
assertTrue("Unexpected error in AllAttributeTest.assignmentHelper", false);
throw(e);
}
Property.errorHandler = Property.defaultErrorHandler;
if (expectedValue == undefined && testValue != undefined)
{
// expect an error
assertTrue("Error expected but no error in AllAttributeTest.assignmentHelper",errorHandlerCount == 1);
}
else
{
// no error
assertTrue("Error not expected but error found in AllAttributeTest.assignmentHelper",errorHandlerCount == 0);
}
}
}
}