using Perforce.P4;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
 
namespace p4api.net.unit.test
{
	
	
	/// <summary>
	///This is a test class for StringListTest and is intended
	///to contain all StringListTest Unit Tests
	///</summary>
	[TestClass()]
	public class StringEnumTest
	{
		private TestContext testContextInstance;
 
		/// <summary>
		///Gets or sets the test context which provides
		///information about and functionality for the current test run.
		///</summary>
		public TestContext TestContext
		{
			get
			{
				return testContextInstance;
			}
			set
			{
				testContextInstance = value;
			}
		}
 
		#region Additional test attributes
		// 
		//You can use the following additional attributes as you write your tests:
		//
		//Use ClassInitialize to run code before running the first test in the class
		//[ClassInitialize()]
		//public static void MyClassInitialize(TestContext testContext)
		//{
		//}
		//
		//Use ClassCleanup to run code after all tests in a class have run
		//[ClassCleanup()]
		//public static void MyClassCleanup()
		//{
		//}
		//
		//Use TestInitialize to run code before running each test
		//[TestInitialize()]
		//public void MyTestInitialize()
		//{
		//}
		//
		//Use TestCleanup to run code after each test has run
		//[TestCleanup()]
		//public void MyTestCleanup()
		//{
		//}
		//
		#endregion
 
		enum myEnum { Alpha, beta, GAMMA, DeltaEpsilon };
 
		/// <summary>
		///A test for StringEnum Constructor
		///</summary>
		[TestMethod()]
		public void StringEnumConstructorTest()
		{
			Perforce.P4.StringEnum<myEnum> target = new StringEnum<myEnum>(myEnum.Alpha);
 
			Assert.AreEqual(myEnum.Alpha, (myEnum) target);
		}
 
		/// <summary>
		///A test for implicit cast from StringEnmum ==> T
		///</summary>
		[TestMethod()]
		public void ImplicitOperatiorTest1()
		{
			StringEnum<myEnum> target = new StringEnum<myEnum>(myEnum.Alpha);
 
			myEnum actual = target;
 
			Assert.AreEqual(myEnum.Alpha, actual);
		}
 
		/// <summary>
		///A test for implicit cast from T ==> StringEnmum
		///</summary>
		[TestMethod()]
		public void ImplicitOperatiorTest2()
		{
			StringEnum<myEnum> target = myEnum.Alpha;
 
			StringEnum<myEnum> expected = new StringEnum<myEnum>(myEnum.Alpha);
 
			Assert.AreEqual(expected, target);
		}
 
		/// <summary>
		///A test for implicit cast from string ==> StringEnmum
		///</summary>
		[TestMethod()]
		public void ImplicitOperatiorTest3()
		{
			StringEnum<myEnum> target = "Alpha";
 
			StringEnum<myEnum> expected = new StringEnum<myEnum>(myEnum.Alpha);
 
			Assert.AreEqual(expected, target);
		}
 
		/// <summary>
		///A test for equality and inequality operators
		///</summary>
		[TestMethod()]
		public void EqualityOperatiorTest()
		{
			StringEnum<myEnum> target = new StringEnum<myEnum>(myEnum.Alpha); ;
 
			StringEnum<myEnum> expected = new StringEnum<myEnum>(myEnum.Alpha);
			StringEnum<myEnum> notExpected = new StringEnum<myEnum>(myEnum.beta);
 
			myEnum expected2 = myEnum.Alpha;
			myEnum notExpected2 = myEnum.beta;
 
			Assert.IsTrue(expected == target);
			Assert.IsTrue(target == expected);
 
			Assert.IsTrue(notExpected != target);
			Assert.IsTrue(target != notExpected);
 
			Assert.IsTrue(expected2 == target);
			Assert.IsTrue(target == expected);
 
			Assert.IsTrue(notExpected2 != target);
			Assert.IsTrue(target != notExpected2);
		}
 
		/// <summary>
		///A test for ToString
		///</summary>
		[TestMethod()]
		public void ToStringTest()
		{
			StringEnum<myEnum> target = new StringEnum<myEnum>(myEnum.Alpha); ;
 
			string expected = "Alpha";
			string actual = target.ToString();
 
			Assert.AreEqual(expected, actual);
 
			target = new StringEnum<myEnum>(myEnum.beta); ;
 
			expected = "beta";
			actual = target.ToString();
 
			Assert.AreEqual(expected, actual);
 
			target = new StringEnum<myEnum>(myEnum.GAMMA); ;
 
			expected = "GAMMA";
			actual = target.ToString();
 
			Assert.AreEqual(expected, actual);
 
			target = new StringEnum<myEnum>(myEnum.DeltaEpsilon);
 
			expected = "DeltaEpsilon";
			actual = target.ToString();
 
			Assert.AreEqual(expected, actual);
		}
 
		/// <summary>
		///A test for ToString(CASE)
		///</summary>
		[TestMethod()]
		public void ToStringTest2()
		{
			// lower
			StringEnum<myEnum> target = new StringEnum<myEnum>(myEnum.Alpha); ;
 
			string expected = "Alpha".ToLower();
			string actual = target.ToString(StringEnumCase.Lower);
 
			Assert.AreEqual(expected, actual);
 
			target = new StringEnum<myEnum>(myEnum.beta); ;
 
			expected = "beta".ToLower();
			actual = target.ToString(StringEnumCase.Lower);
 
			Assert.AreEqual(expected, actual);
 
			target = new StringEnum<myEnum>(myEnum.GAMMA); ;
 
			expected = "GAMMA".ToLower();
			actual = target.ToString(StringEnumCase.Lower);
 
			Assert.AreEqual(expected, actual);
 
			target = new StringEnum<myEnum>(myEnum.DeltaEpsilon);
 
			expected = "DeltaEpsilon".ToLower();
			actual = target.ToString(StringEnumCase.Lower);
 
			Assert.AreEqual(expected, actual);
 
			//upper
			target = new StringEnum<myEnum>(myEnum.Alpha); ;
 
			expected = "Alpha".ToUpper();
			actual = target.ToString(StringEnumCase.Upper);
 
			Assert.AreEqual(expected, actual);
 
			target = new StringEnum<myEnum>(myEnum.beta); ;
 
			expected = "beta".ToUpper();
			actual = target.ToString(StringEnumCase.Upper);
 
			Assert.AreEqual(expected, actual);
 
			target = new StringEnum<myEnum>(myEnum.GAMMA); ;
 
			expected = "GAMMA".ToUpper();
			actual = target.ToString(StringEnumCase.Upper);
 
			Assert.AreEqual(expected, actual);
 
			target = new StringEnum<myEnum>(myEnum.DeltaEpsilon);
 
			expected = "DeltaEpsilon".ToUpper();
			actual = target.ToString(StringEnumCase.Upper);
 
			Assert.AreEqual(expected, actual);
 
			//keep case
			target = new StringEnum<myEnum>(myEnum.Alpha); ;
 
			expected = "Alpha";
			actual = target.ToString(StringEnumCase.None);
 
			Assert.AreEqual(expected, actual);
 
			target = new StringEnum<myEnum>(myEnum.beta); ;
 
			expected = "beta";
			actual = target.ToString(StringEnumCase.None);
 
			Assert.AreEqual(expected, actual);
 
			target = new StringEnum<myEnum>(myEnum.GAMMA); ;
 
			expected = "GAMMA";
			actual = target.ToString(StringEnumCase.None);
 
			Assert.AreEqual(expected, actual);
 
			target = new StringEnum<myEnum>(myEnum.DeltaEpsilon);
 
			expected = "DeltaEpsilon";
			actual = target.ToString(StringEnumCase.None);
 
			Assert.AreEqual(expected, actual);
		}
 
		/// <summary>
		///A test for TryParse
		///</summary>
		[TestMethod()]
		public void TryParseTest()
		{
			StringEnum<myEnum> target = null;
 
			StringEnum<myEnum>.TryParse("Alpha", ref target);
 
			myEnum expected = myEnum.Alpha;
			myEnum actual = target; // cast to myEnum
 
			Assert.AreEqual(expected, actual);
 
			target = null;
 
			StringEnum<myEnum>.TryParse("beta", ref target);
 
			expected = myEnum.beta;
			actual = target; // cast to myEnum
 
			Assert.AreEqual(expected, actual);
 
			target = null;
 
			StringEnum<myEnum>.TryParse("GAMMA", ref target);
 
			expected = myEnum.GAMMA;
			actual = target; // cast to myEnum
 
			Assert.AreEqual(expected, actual);
 
			target = null;
 
			StringEnum<myEnum>.TryParse("DeltaEpsilon", ref target);
 
			expected = myEnum.DeltaEpsilon;
			actual = target; // cast to myEnum
 
			Assert.AreEqual(expected, actual);
 
			// this parse should not work and leave the target as null
			target = null;
 
			StringEnum<myEnum>.TryParse("badvaluestring", ref target);
 
			Assert.AreEqual(null, target);
		}
 
		/// <summary>
		///A test for TryParse with IgnoreCase
		///</summary>
		[TestMethod()]
		public void TryParseTest2()
		{
			StringEnum<myEnum> target = null;
 
			StringEnum<myEnum>.TryParse("Alpha", true, ref target);
 
			myEnum expected = myEnum.Alpha;
			myEnum actual = target; // cast to myEnum
 
			Assert.AreEqual(expected, actual);
 
			target = null;
 
			StringEnum<myEnum>.TryParse("ALPhA", true, ref target);
 
			expected = myEnum.Alpha;
			actual = target; // cast to myEnum
 
			Assert.AreEqual(expected, actual);
 
			target = null;
 
			StringEnum<myEnum>.TryParse("beta", true, ref target);
 
			expected = myEnum.beta;
			actual = target; // cast to myEnum
 
			Assert.AreEqual(expected, actual);
 
			target = null;
 
			StringEnum<myEnum>.TryParse("BETa", true, ref target);
 
			expected = myEnum.beta;
			actual = target; // cast to myEnum
 
			Assert.AreEqual(expected, actual);
 
			target = null;
 
			StringEnum<myEnum>.TryParse("GAMMA", true, ref target);
 
			expected = myEnum.GAMMA;
			actual = target; // cast to myEnum
 
			Assert.AreEqual(expected, actual);
 
			target = null;
 
			StringEnum<myEnum>.TryParse("gammA", true, ref target);
 
			expected = myEnum.GAMMA;
			actual = target; // cast to myEnum
 
			Assert.AreEqual(expected, actual);
 
			target = null;
 
			StringEnum<myEnum>.TryParse("DeltaEpsilon", true, ref target);
 
			expected = myEnum.DeltaEpsilon;
			actual = target; // cast to myEnum
 
			Assert.AreEqual(expected, actual);
 
			StringEnum<myEnum>.TryParse("DELTAepsilon", true, ref target);
 
			expected = myEnum.DeltaEpsilon;
			actual = target; // cast to myEnum
 
			Assert.AreEqual(expected, actual);
 
			// this parse should not work and leave the target as null
			target = null;
 
			StringEnum<myEnum>.TryParse("badvaluestring", true, ref target);
 
			Assert.AreEqual(null, target);
		}
	}
}