<?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="resources/ResourceManager/Methods/"  xmlns:mx="http://www.adobe.com/2006/mxml" xmlns="*" testSWF="ResourceManagerApp.mxml">

	<!-- this set of lines form 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.resources.IResourceManager;
		import mx.resources.ResourceManager;
		
		private var resourceManager:IResourceManager = ResourceManager.getInstance();
		
		public function testGetNumber(key:String, expectedValue:Number, locale:String = null):Boolean
		{
			// Special-case logic for when the resource value is NaN,
			// because you can't use === to check for NaN.
			if (expectedValue is Number && isNaN(expectedValue))
			{
				var resourceValue:* = resourceManager.getNumber('myResources', key, locale);
				return resourceValue is Number && isNaN(resourceValue);
			}

			return resourceManager.getNumber('myResources', key, locale) === expectedValue;
		}

	]]></mx:Script>
	
	<testCases>

		<TestCase frequency="all" testID="ResourceManager_getNumber_NO_SUCH_KEY" description="Tests that the getNumber() method of ResourceManager throws an Error when accessing a non-existent resource" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('NO_SUCH_KEY', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING" description="Tests the getNumber() method of ResourceManager for a resource value which is a typical String" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_LIST" description="Tests the getNumber() method of ResourceManager for a resource value which is a typical String of comma-separated items" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_LIST', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_EMPTY" description="Tests the getNumber() method of ResourceManager for a resource value which is an empty String" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_EMPTY', 0)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_NULL" description="Tests the getNumber() method of ResourceManager for a resource value which is the String 'null'" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_NULL', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_UNDEFINED" description="Tests the getNumber() method of ResourceManager for a resource value which is the String 'undefined'" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_UNDEFINED', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_TRUE_LOWERCASE" description="Tests the getNumber() method of ResourceManager for a resource value which is the String 'true'" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_TRUE_LOWERCASE', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_TRUE_MIXEDCASE" description="Tests the getNumber() method of ResourceManager for a resource value which is the String 'True'" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_TRUE_MIXEDCASE', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>
		
		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_TRUE_UPPERCASE" description="Tests the getNumber() method of ResourceManager for a resource value which is the String 'TRUE'" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_TRUE_UPPERCASE', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>
		
		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_FALSE_LOWERCASE" description="Tests the getNumber() method of ResourceManager for a resource value which is the String 'false'" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_FALSE_LOWERCASE', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>
		
		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_FALSE_MIXEDCASE" description="Tests the getNumber() method of ResourceManager for a resource value which is the String 'False'" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_FALSE_MIXEDCASE', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>
		
		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_FALSE_UPPERCASE" description="Tests the getNumber() method of ResourceManager for a resource value which is the String 'FALSE'" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_FALSE_UPPERCASE', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_NAN" description="Tests the getNumber() method of ResourceManager for a resource value which is the String 'NaN'" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_NAN', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_ZERO" description="Tests the getNumber() method of ResourceManager for a resource value which is the String '0'" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_ZERO', 0)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_POSITIVE_INTEGER" description="Tests the getNumber() method of ResourceManager for a resource value which is the String rep of a typical positive integer" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_POSITIVE_INTEGER', 3)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_NEGATIVE_INTEGER" description="Tests the getNumber() method of ResourceManager for a resource value which is the String rep of a typical negative integer" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_NEGATIVE_INTEGER', -3)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>
		
		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_FIXEDPOINT" description="Tests the getNumber() method of ResourceManager for a resource value which is the String rep of a typical fractional Number" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_FIXEDPOINT', 1.5)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_STRING_FLOATINGPOINT" description="Tests the getNumber() method of ResourceManager for a resource value which is the String rep of a typical fractional Number in exponential notation" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('STRING_FLOATINGPOINT', 5.0e-1)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_NULL" description="Tests the getNumber() method of ResourceManager for a resource value which is null" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('NULL', 0)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>
		
		<TestCase frequency="all" testID="ResourceManager_getNumber_UNDEFINED" description="Tests the getNumber() method of ResourceManager for a resource value which is undefined" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('UNDEFINED', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_TRUE" description="Tests the getNumber() method of ResourceManager for a resource value which is true" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('TRUE', 1)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_FALSE" description="Tests the getNumber() method of ResourceManager for a resource value which is false" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('FALSE', 0)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_NAN" description="Tests the getNumber() method of ResourceManager for a resource value which is NaN" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('NAN', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_ZERO" description="Tests the getNumber() method of ResourceManager for a resource value which is 0" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('ZERO', 0)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>
		
		<TestCase frequency="all" testID="ResourceManager_getNumber_POSITIVE_INTEGER" description="Tests the getNumber() method of ResourceManager for a resource value which is a typical positive integer" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('POSITIVE_INTEGER', 3)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_NEGATIVE_INTEGER" description="Tests the getNumber() method of ResourceManager for a resource value which is a typical negative integer" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('NEGATIVE_INTEGER', -3)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_FIXEDPOINT" description="Tests the getNumber() method of ResourceManager for a resource value which is a typical fractional Number" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('FIXEDPOINT', 1.5)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>
		
		<TestCase frequency="all" testID="ResourceManager_getNumber_FLOATINGPOINT" description="Tests the getNumber() method of ResourceManager for a resource value which is a typical fractional Number in exponential notation" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('FLOATINGPOINT', 5.0e-1)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>
		
		<TestCase frequency="all" testID="ResourceManager_getNumber_CLASS" description="Tests the getNumber() method of ResourceManager for a resource value which is a Class reference" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('CLASS', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>
		
		<TestCase frequency="all" testID="ResourceManager_getNumber_ARRAY" description="Tests the getNumber() method of ResourceManager for a resource value which is an Array of Strings" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('ARRAY', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>
		
		<TestCase frequency="all" testID="ResourceManager_getNumber_OBJECT" description="Tests the getNumber() method of ResourceManager for a resource value which is a plain Object" keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<AssertMethodValue method="value=testGetNumber('OBJECT', NaN)" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_localeParam_firstInLocaleChain_true" description="Tests the getNumber() method of ResourceManager for the ability to specify the locale." keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
			    <RunCode code="ResourceManager.getInstance().localeChain=['fr_FR','ja_JP']" />
				<AssertMethodValue method="value=testGetNumber('POSITIVE_INTEGER', 3, 'fr_FR')" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_localeParam_notFirstInLocaleChain_true" description="Tests the getNumber() method of ResourceManager for the ability to specify the locale." keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<RunCode code="ResourceManager.getInstance().localeChain=['fr_FR','ja_JP']" />
				<AssertMethodValue method="value=testGetNumber('POSITIVE_INTEGER', 2, 'ja_JP')" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>

		<TestCase frequency="all" testID="ResourceManager_getNumber_localeParam_localeMissing" description="Tests the getNumber() method of ResourceManager for the ability to specify the locale." keywords="[resources,ResourceManager,getNumber]">
			<setup>
				<RunCode code="application.setup()"/>
			</setup>
			<body>
				<RunCode code="ResourceManager.getInstance().localeChain=['fr_FR','ja_JP']" />
				<AssertMethodValue method="value=testGetNumber('POSITIVE_INTEGER', NaN, 'fu_BR')" value="true"/>
				<Pause timeout="1"/>
			</body>
		</TestCase>
		
	</testCases>

</UnitTester>

