<?xml version="1.0" encoding="utf-8"?>
<!--

  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.

-->
<UnitTester testDir="SkinningImprovements/Styles/"  xmlns:mx="http://www.adobe.com/2006/mxml" xmlns="*" testSWF="SkinImprovements_Padding_Basic.mxml">

	<!-- this set of lines form a template that must be in each unit test -->
	<mx:Script>
	<![CDATA[
	import mx.managers.SystemManager;

	public static function init(o:DisplayObject):void
	{

	}
	
	
	public function setLabelPlacement1():void{
		application.componentPaddingBasic.pTN.selectedIndex=5;
		//application.labelPlacementCombo.selectedIndex=0;
		application.componentPaddingBasic.hgap.value=12;
		application.componentPaddingBasic.vgap.value=5;
	}
	public function setLabelPlacement2():void{
		application.componentPaddingBasic.pTN.selectedIndex=4;
		//application.labelPlacementCombo.selectedIndex=1;
		application.componentPaddingBasic.hgap.value=5;
		application.componentPaddingBasic.vgap.value=12;
	}
	public function setLabelPlacement3():void{
		application.componentPaddingBasic.pTN.selectedIndex=5;
		//application.labelPlacementCombo.selectedIndex=2;
		application.componentPaddingBasic.hgap.value=10;
		application.componentPaddingBasic.vgap.value=10;
	}
	public function setLabelPlacement4():void{
		application.componentPaddingBasic.pTN.selectedIndex=4;
		//application.labelPlacementCombo.selectedIndex=3;
		application.componentPaddingBasic.hgap.value=4;
		application.componentPaddingBasic.vgap.value=4;
	}
	]]>
	</mx:Script>
	<mx:Metadata>
	<![CDATA[
		[Mixin]
	]]>
	</mx:Metadata>
	<!-- end of set of lines that must be in each unit test -->

	<testCases>
		<TestCase testID="Test_Padding_LabelPlacement1" description="Skinning Improvements phase I being validated." keywords="[SkinImprovement, Padding, highlight]">
			<setup>
				<ResetComponent target="componentPaddingBasic" className="component_Padding_Basic" waitEvent="updateComplete" />
				
				<RunCode code="setLabelPlacement1()" timeout="1000" />

			</setup>
			<body>
				<Pause timeout="200" />
			    	<CompareBitmap target="" url="../Styles/Baselines/Padding_Basic1.png" />
			</body>
		</TestCase>
		<TestCase testID="Test_Padding_LabelPlacement2" description="Skinning Improvements phase I being validated." keywords="[SkinImprovement, Padding, highlight, change, headerHeight]">
			<setup>
				<ResetComponent target="componentPaddingBasic" className="component_Padding_Basic" waitEvent="updateComplete" />
			
				<RunCode code="setLabelPlacement2()" timeout="1000"  />

			</setup>
			<body>
				<Pause timeout="200" />
			    	<CompareBitmap target="" url="../Styles/Baselines/Padding_Basic2.png" />
			</body>
		</TestCase>
		<TestCase testID="Test_Padding_LabelPlacement3" description="Skinning Improvements phase I being validated." keywords="[SkinImprovement, Padding, highlight, change, headerHeight]">
			<setup>
				<ResetComponent target="componentPaddingBasic" className="component_Padding_Basic" waitEvent="updateComplete" />
				
				<RunCode code="setLabelPlacement3()" timeout="1000" />

			</setup>
			<body>
				<Pause timeout="200" />
			    	<CompareBitmap target="" url="../Styles/Baselines/Padding_Basic3.png" />
			</body>
		</TestCase>
		<TestCase testID="Test_Padding_LabelPlacement4" description="Skinning Improvements phase I being validated." keywords="[SkinImprovement, Padding, highlight, change, headerHeight]">
			<setup>
				<ResetComponent target="componentPaddingBasic" className="component_Padding_Basic" waitEvent="updateComplete" />
				
				<RunCode code="setLabelPlacement4()" timeout="1000" />

			</setup>
			<body>
				<Pause timeout="200" />
			    	<CompareBitmap target="" url="../Styles/Baselines/Padding_Basic4.png" />
			</body>
		</TestCase>
	</testCases>
</UnitTester>
