maui-linux/Xamarin.Forms.Core.UnitTests/StepperUnitTests.cs

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);
		}
	}
}