From 17fdde66d94155fc62a034fa6658995bef6fd6e5 Mon Sep 17 00:00:00 2001
From: Jason Smith <jason.smith@xamarin.com>
Date: Tue, 22 Mar 2016 13:02:25 -0700
Subject: Initial import

---
 Xamarin.Forms.Core.UnitTests/StepperUnitTests.cs | 176 +++++++++++++++++++++++
 1 file changed, 176 insertions(+)
 create mode 100644 Xamarin.Forms.Core.UnitTests/StepperUnitTests.cs

(limited to 'Xamarin.Forms.Core.UnitTests/StepperUnitTests.cs')

diff --git a/Xamarin.Forms.Core.UnitTests/StepperUnitTests.cs b/Xamarin.Forms.Core.UnitTests/StepperUnitTests.cs
new file mode 100644
index 00000000..d011c7ab
--- /dev/null
+++ b/Xamarin.Forms.Core.UnitTests/StepperUnitTests.cs
@@ -0,0 +1,176 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using NUnit.Framework;
+
+namespace Xamarin.Forms.Core.UnitTests
+{
+	[TestFixture]
+	public class StepperUnitTests : BaseTestFixture
+	{
+		[Test]
+		public void TestConstructor ()
+		{
+			var stepper = new Stepper (120, 200, 150, 2);
+			
+			Assert.AreEqual (120, stepper.Minimum);
+			Assert.AreEqual (200, stepper.Maximum);
+			Assert.AreEqual (150, stepper.Value);
+			Assert.AreEqual (2, stepper.Increment);
+		}
+
+		[Test]
+		public void TestInvalidConstructor ()
+		{
+			Assert.Throws<ArgumentOutOfRangeException>(()=>new Stepper (100, 0, 50, 1));
+		}
+
+		[Test]
+		public void TestInvalidMaxValue ()
+		{
+			Stepper stepper = new Stepper ();
+			Assert.Throws<ArgumentException> (() => stepper.Maximum = stepper.Minimum - 1);
+		}
+
+		[Test]
+		public void TestInvalidMinValue ()
+		{
+			Stepper stepper = new Stepper ();
+			Assert.Throws<ArgumentException> (() => stepper.Minimum = stepper.Maximum + 1);
+		}
+
+		[Test]
+		public void TestValidMaxValue ()
+		{
+			Stepper stepper = new Stepper ();
+
+			stepper.Maximum = 2000;
+
+			Assert.AreEqual (2000, stepper.Maximum);
+		}
+
+		[Test]
+		public void TestValidMinValue ()
+		{
+			Stepper stepper = new Stepper ();
+			
+			stepper.Maximum = 2000;
+			stepper.Minimum = 200;
+			
+			Assert.AreEqual (200, stepper.Minimum);
+		}
+
+		[Test]
+		public void TestConstructorClampValue ()
+		{
+			Stepper stepper = new Stepper (0, 100, 2000, 1);
+
+			Assert.AreEqual (100, stepper.Value);
+
+			stepper = new Stepper (0, 100, -200, 1);
+			
+			Assert.AreEqual (0, stepper.Value);
+		}
+
+		[Test]
+		public void TestMinClampValue ()
+		{
+			Stepper stepper = new Stepper ();
+
+			bool minThrown = false;
+			bool valThrown = false;
+
+			stepper.PropertyChanged += (sender, e) => {
+				switch (e.PropertyName) {
+				case "Minimum":
+					minThrown = true;
+					break;
+				case "Value":
+					Assert.False (minThrown);
+					valThrown = true;
+					break;
+				}
+			};
+
+			stepper.Minimum = 10;
+
+			Assert.AreEqual (10, stepper.Minimum);
+			Assert.AreEqual (10, stepper.Value);
+			Assert.True (minThrown);
+			Assert.True (valThrown);
+		}
+
+		[Test]
+		public void TestMaxClampValue ()
+		{
+			Stepper stepper = new Stepper ();
+
+			stepper.Value = 50;
+
+			bool maxThrown = false;
+			bool valThrown = false;
+
+			stepper.PropertyChanged += (sender, e) => {
+				switch (e.PropertyName) {
+				case "Maximum":
+					maxThrown = true;
+					break;
+				case "Value":
+					Assert.False (maxThrown);
+					valThrown = true;
+					break;
+				}
+			};
+
+			stepper.Maximum = 25;
+
+			Assert.AreEqual (25, stepper.Maximum);
+			Assert.AreEqual (25, stepper.Value);
+			Assert.True (maxThrown);
+			Assert.True (valThrown);
+		}
+
+		[Test]
+		public void TestValueChangedEvent ()
+		{
+			var stepper = new Stepper ();
+
+			bool fired = false;
+			stepper.ValueChanged += (sender, arg) => fired = true;
+
+			stepper.Value = 50;
+
+			Assert.True (fired);
+		}
+
+		[TestCase (100.0, 0.5)]
+		[TestCase (10.0, 25.0)]
+		[TestCase (0, 39.5)]
+		public void StepperValueChangedEventArgs (double initialValue, double finalValue)
+		{
+			var stepper = new Stepper {
+				Maximum = 100,
+				Minimum = 0,
+				Increment = 0.5,
+				Value = initialValue
+			};
+
+			Stepper stepperFromSender = null;
+			var oldValue = 0.0;
+			var newValue = 0.0;
+
+			stepper.ValueChanged += (s, e) => {
+				stepperFromSender = (Stepper)s;
+				oldValue = e.OldValue;
+				newValue = e.NewValue;
+			};
+
+			stepper.Value = finalValue;
+
+			Assert.AreEqual (stepper, stepperFromSender);
+			Assert.AreEqual (initialValue, oldValue);
+			Assert.AreEqual (finalValue, newValue);
+		}
+	}
+}
-- 
cgit v1.2.3