<?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="containers/ViewStack/Properties/"  xmlns:mx="http://www.adobe.com/2006/mxml" xmlns="*" testSWF="ViewStack_Basic.mxml">

	<!-- this set of lines ViewStack a template that must be in each unit test -->
	<mx:Script>
	<![CDATA[
	public static function init(o:DisplayObject):void
	{
	}					
	]]>
	</mx:Script>
	<mx:Metadata>
	<![CDATA[
		[Mixin]
	]]>
	</mx:Metadata>	
	<!-- end of set of lines that must be in each unit test -->

	<mx:Script>
	<![CDATA[

	import mx.containers.* 
 	import mx.controls.*
 	 
 	]]>
	</mx:Script>
	<testCases>
	<!-- 	properties 	-->
	

	<TestCase testID="VS_setup" keywords="[historyManagementEnabled, children, ViewStack]">
		 	<setup>
				<ResetComponent target="vs" className="VSComp"  waitEvent="updateComplete" waitTarget="vs"/>
				<SetProperty target="vs.viewS" propertyName="historyManagementEnabled" value="true" waitTarget="vs.viewS" waitEvent="updateComplete" />
			</setup>
			<body>
				<AssertPropertyValue target="vs.viewS" propertyName="historyManagementEnabled" value="true"/>
				<AssertPropertyValue target="vs.viewS" propertyName="selectedChild" valueExpression="value=application.vs.search" />
			</body>
	</TestCase>
 		
 	<TestCase testID="VS_selectedIndex" keywords="[selectedIndex, children, ViewStack]">
			<setup>
 				<ResetComponent target="vs" className="VSComp"  waitEvent="updateComplete" waitTarget="vs"/>
				<SetProperty target="vs.viewS" propertyName="selectedIndex" value="2" waitTarget="vs.viewS" waitEvent="updateComplete" />
			</setup>
			<body>
				<AssertPropertyValue target="vs.viewS" propertyName="selectedIndex" value="2"/>
				<SetProperty target="vs.viewS" propertyName="selectedIndex" value="0" waitTarget="vs.viewS" waitEvent="updateComplete" />
				<AssertPropertyValue target="vs.viewS" propertyName="selectedChild" valueExpression="value=application.vs.search" />
				<AssertPropertyValue target="vs.viewS" propertyName="selectedIndex" value="0"/>
				
				<SetProperty target="vs.viewS" propertyName="selectedIndex" value="1" waitTarget="vs.viewS" waitEvent="updateComplete" />
				<AssertPropertyValue target="vs.viewS" propertyName="selectedIndex" value="1"/>  
				<AssertPropertyValue target="vs.viewS" propertyName="selectedChild" valueExpression="value=application.vs.custInfo" />
			</body>
		</TestCase>

 		<TestCase testID="VS_selectedChild" keywords="[selectedIndex, children, ViewStack]">
			<setup>
 				<ResetComponent target="vs" className="VSComp"  waitEvent="updateComplete" waitTarget="vs"/>
				<SetProperty target="vs.viewS" propertyName="selectedIndex" value="2" waitTarget="vs.viewS" waitEvent="updateComplete" />
			</setup>
			<body>
				<AssertPropertyValue target="vs.viewS" propertyName="selectedIndex" value="2"/>
				<SetProperty target="vs.viewS" propertyName="selectedIndex" value="0" waitTarget="vs.viewS" waitEvent="updateComplete" />
				<AssertPropertyValue target="vs.viewS" propertyName="selectedChild" valueExpression="value=application.vs.search" />
				<AssertPropertyValue target="vs.viewS" propertyName="selectedIndex" value="0"/>
				
				<SetProperty target="vs.viewS" propertyName="selectedIndex" value="1" waitTarget="vs.viewS" waitEvent="updateComplete" />
				<AssertPropertyValue target="vs.viewS" propertyName="selectedIndex" value="1"/>  
				<AssertPropertyValue target="vs.viewS" propertyName="selectedChild" valueExpression="value=application.vs.custInfo" />
			</body>
		</TestCase>
 		<TestCase testID="VS_resizeToContent" keywords="[resizeToContent, children, ViewStack]">
			<setup>
 				<ResetComponent target="vs" className="VSComp"  waitEvent="updateComplete" waitTarget="vs"/>
				<SetProperty target="vs.viewS" propertyName="resizeToContent" value="true" waitTarget="vs.viewS" waitEvent="updateComplete" />
			</setup>
			<body>
				<AssertPropertyValue target="vs.viewS" propertyName="resizeToContent" value="true"/>
				<SetProperty target="vs.viewS" propertyName="selectedIndex" value="1" waitTarget="vs.viewS" waitEvent="updateComplete" />
				<AssertPropertyValue target="vs.viewS" propertyName="selectedIndex" value="1"/>  				
			</body>
		</TestCase>
 	</testCases>
</UnitTester>
