ScrollViewUnitTests.cs

using System;
using System.Collections.Generic;
using System.Linq;

using NUnit.Framework;

namespace Xamarin.Forms.Core.UnitTests
{
	[TestFixture]
	public class ScrollViewUnitTests : BaseTestFixture
	{
		[SetUp]
		public override void Setup()
		{
			base.Setup ();
			Device.PlatformServices = new MockPlatformServices ();
		}

		[TearDown]
		public override void TearDown()
		{
			base.TearDown ();
			Device.PlatformServices = null;
		}

		[Test]
		public void TestConstructor ()
		{
			ScrollView scrollView = new ScrollView ();

			Assert.Null (scrollView.Content);

			View view = new View ();
			scrollView = new ScrollView {Content = view};

			Assert.AreEqual (view, scrollView.Content);
		}

		[Test]
		[TestCase (ScrollOrientation.Horizontal)]
		[TestCase (ScrollOrientation.Both)]
		public void GetsCorrectSizeRequestWithWrappingContent (ScrollOrientation orientation)
		{
			Device.PlatformServices = new MockPlatformServices(getNativeSizeFunc:null, useRealisticLabelMeasure:true);

			var scrollView = new ScrollView {
				IsPlatformEnabled = true,
				Orientation = orientation,
			};

			var hLayout = new StackLayout {
				IsPlatformEnabled = true,
				Orientation = StackOrientation.Horizontal,
				Children = {
					new Label {Text = "THIS IS A REALLY LONG STRING", IsPlatformEnabled = true},
					new Label {Text = "THIS IS A REALLY LONG STRING", IsPlatformEnabled = true},
					new Label {Text = "THIS IS A REALLY LONG STRING", IsPlatformEnabled = true},
					new Label {Text = "THIS IS A REALLY LONG STRING", IsPlatformEnabled = true},
					new Label {Text = "THIS IS A REALLY LONG STRING", IsPlatformEnabled = true},
				}
			};

			scrollView.Content = hLayout;

			var r = scrollView.GetSizeRequest (100, 100);

			Assert.AreEqual (10, r.Request.Height);
		}

		[Test]
		public void TestContentSizeChangedVertical ()
		{
			View view = new View {IsPlatformEnabled = true, WidthRequest = 100, HeightRequest = 100};

			ScrollView scroll = new ScrollView {Content = view};
			scroll.Layout (new Rectangle (0, 0, 50, 50));

			Assert.AreEqual (new Size (50, 100), scroll.ContentSize);

			bool changed = false;
			scroll.PropertyChanged += (sender, e) => {
				switch (e.PropertyName) {
				case "ContentSize":
					changed = true;
					break;
				}
			};

			view.HeightRequest = 200;

			Assert.True (changed);
			Assert.AreEqual (new Size (50, 200), scroll.ContentSize);
		}

		[Test]
		public void TestContentSizeChangedVerticalBidirectional ()
		{
			View view = new View { IsPlatformEnabled = true, WidthRequest = 100, HeightRequest = 100 };

			ScrollView scroll = new ScrollView { Content = view, Orientation = ScrollOrientation.Both };
			scroll.Layout (new Rectangle (0, 0, 50, 50));

			Assert.AreEqual (new Size (100, 100), scroll.ContentSize);

			bool changed = false;
			scroll.PropertyChanged += (sender, e) => {
				switch (e.PropertyName) {
					case "ContentSize":
						changed = true;
						break;
				}
			};

			view.HeightRequest = 200;

			Assert.True (changed);
			Assert.AreEqual (new Size (100, 200), scroll.ContentSize);
		}

		[Test]
		public void TestContentSizeChangedHorizontal ()
		{
			View view = new View {IsPlatformEnabled = true, WidthRequest = 100, HeightRequest = 100};

			var scroll = new ScrollView {
				Orientation = ScrollOrientation.Horizontal,
				Content = view
			};
			scroll.Layout (new Rectangle (0, 0, 50, 50));

			Assert.AreEqual (new Size (100, 50), scroll.ContentSize);

			bool changed = false;
			scroll.PropertyChanged += (sender, e) => {
				switch (e.PropertyName) {
				case "ContentSize":
					changed = true;
					break;
				}
			};

			view.WidthRequest = 200;
			
			Assert.True (changed);
			Assert.AreEqual (new Size (200, 50), scroll.ContentSize);
		}

		[Test]
		public void TestContentSizeChangedHorizontalBidirectional ()
		{
			View view = new View { IsPlatformEnabled = true, WidthRequest = 100, HeightRequest = 100 };

			var scroll = new ScrollView {
				Orientation = ScrollOrientation.Both,
				Content = view
			};
			scroll.Layout (new Rectangle (0, 0, 50, 50));

			Assert.AreEqual (new Size (100, 100), scroll.ContentSize);

			bool changed = false;
			scroll.PropertyChanged += (sender, e) => {
				switch (e.PropertyName) {
					case "ContentSize":
						changed = true;
						break;
				}
			};

			view.WidthRequest = 200;

			Assert.True (changed);
			Assert.AreEqual (new Size (200, 100), scroll.ContentSize);
		}

		[Test]
		public void TestContentSizeDidNotChangeNeither()
		{
			View view = new View { IsPlatformEnabled = true, WidthRequest = 100, HeightRequest = 100 };

			var scroll = new ScrollView
			{
				Orientation = ScrollOrientation.Neither,
				Content = view
			};

			var originalBounds = new Rectangle(0, 0, 50, 50);

			scroll.Layout(originalBounds);

			Assert.That(originalBounds.Size, Is.EqualTo(scroll.ContentSize));

			bool changed = false;
			scroll.PropertyChanged += (sender, e) => {
				switch (e.PropertyName)
				{
					case "ContentSize":
						changed = true;
						break;
				}
			};

			view.WidthRequest = 200;

			Assert.That(changed, Is.False);
			Assert.That(originalBounds.Size, Is.EqualTo(scroll.ContentSize));
		}

		[Test]
		public void TestContentSizeClamping ()
		{
			View view = new View {IsPlatformEnabled = true, WidthRequest = 100, HeightRequest = 100};

			var scroll = new ScrollView {
				Orientation = ScrollOrientation.Horizontal,
				Content = view,
			};
			scroll.Layout (new Rectangle (0, 0, 50, 50));

			bool changed = false;
			scroll.PropertyChanged += (sender, e) => {
				switch (e.PropertyName) {
				case "ContentSize":
					changed = true;
					break;
				}
			};

			view.HeightRequest = 200;
			
			Assert.False (changed);
			Assert.AreEqual (new Size (100, 50), scroll.ContentSize);
		}

		[Test]
		public void TestChildChanged ()
		{
			ScrollView scrollView = new ScrollView ();

			bool changed = false;
			scrollView.PropertyChanged += (sender, e) => {
				switch (e.PropertyName) {
				case "Content":
					changed = true;
					break;
				}
			};
			View view = new View ();
			scrollView.Content = view;
			
			Assert.True (changed);
		}

		[Test]
		public void TestChildDoubleSet ()
		{
			var scrollView = new ScrollView ();

			bool changed = false;
			scrollView.PropertyChanged += (sender, args) => {
				if (args.PropertyName == "Content")
					changed = true;
			};

			var child = new View ();
			scrollView.Content = child;

			Assert.True (changed);
			Assert.AreEqual (child, scrollView.Content);

			changed = false;

			scrollView.Content = child;

			Assert.False (changed);

			scrollView.Content = null;

			Assert.True (changed);
			Assert.Null (scrollView.Content);
		}

		[Test]
		public void TestOrientation ()
		{
			var scrollView = new ScrollView ();

			Assert.AreEqual (ScrollOrientation.Vertical, scrollView.Orientation);

			bool signaled = false;
			scrollView.PropertyChanged += (sender, args) => {
				if (args.PropertyName == "Orientation")
					signaled = true;
			};

			scrollView.Orientation = ScrollOrientation.Horizontal;

			Assert.AreEqual (ScrollOrientation.Horizontal, scrollView.Orientation);
			Assert.True (signaled);

			scrollView.Orientation = ScrollOrientation.Both;
			Assert.AreEqual (ScrollOrientation.Both, scrollView.Orientation);
			Assert.True (signaled);

			scrollView.Orientation = ScrollOrientation.Neither;
			Assert.AreEqual(ScrollOrientation.Neither, scrollView.Orientation);
			Assert.True(signaled);
		}

		[Test]
		public void TestOrientationDoubleSet ()
		{
			var scrollView = new ScrollView ();

			bool signaled = false;
			scrollView.PropertyChanged += (sender, args) => {
				if (args.PropertyName == "Orientation")
					signaled = true;
			};

			scrollView.Orientation = scrollView.Orientation;

			Assert.False (signaled);
		}


		[Test]
		public void TestScrollTo()
		{
			var scrollView = new ScrollView ();

			var item = new View {   };
			scrollView.Content = new StackLayout { Children = { item } };

			bool requested = false;
			((IScrollViewController) scrollView).ScrollToRequested += (sender, args) => {
				requested = true;
				Assert.AreEqual(args.ScrollY,100);
				Assert.AreEqual(args.ScrollX,0);
				Assert.Null (args.Item);
				Assert.That (args.ShouldAnimate, Is.EqualTo (true));
			};

			scrollView.ScrollToAsync (0,100, true);
			Assert.That (requested, Is.True);
		}

		[Test]
		public void TestScrollWasNotFiredOnNeither()
		{
			var scrollView = new ScrollView
			{
				Orientation = ScrollOrientation.Neither
			};

			var item = new View { };
			scrollView.Content = new StackLayout { Children = { item } };

			bool requested = false;
			((IScrollViewController)scrollView).ScrollToRequested += (sender, args) => {
				requested = true;
			};

			scrollView.ScrollToAsync(0, 100, true);
			Assert.That(requested, Is.False);
		}

		[Test]
		public void TestScrollToNotAnimated()
		{
			var scrollView = new ScrollView ();

			var item = new View {   };
			scrollView.Content = new StackLayout { Children = { item } };

			bool requested = false;
			((IScrollViewController) scrollView).ScrollToRequested += (sender, args) => {
				requested = true;
				Assert.AreEqual(args.ScrollY,100);
				Assert.AreEqual(args.ScrollX,0);
				Assert.Null (args.Item);
				Assert.That (args.ShouldAnimate, Is.EqualTo (false));
			};

			scrollView.ScrollToAsync (0,100, false);
			Assert.That (requested, Is.True);
		}

		[Test]
		public void TestScrollToElement ()
		{
			var scrollView = new ScrollView ();

			var item = new Label {  Text = "Test" };
			scrollView.Content = new StackLayout { Children = { item } };

			bool requested = false;
			((IScrollViewController) scrollView).ScrollToRequested += (sender, args) => {
				requested = true;

				Assert.That (args.Element, Is.SameAs (item));
				Assert.That (args.Position, Is.EqualTo (ScrollToPosition.Center));
				Assert.That (args.ShouldAnimate, Is.EqualTo (true));
			};

			scrollView.ScrollToAsync (item, ScrollToPosition.Center, true);
			Assert.That (requested, Is.True);
		}

		[Test]
		public void TestScrollToElementNotAnimated ()
		{
			var scrollView = new ScrollView ();

			var item = new Label {  Text = "Test" };
			scrollView.Content = new StackLayout { Children = { item } };

			bool requested = false;
			((IScrollViewController) scrollView).ScrollToRequested += (sender, args) => {
				requested = true;

				Assert.That (args.Element, Is.SameAs (item));
				Assert.That (args.Position, Is.EqualTo (ScrollToPosition.Center));
				Assert.That (args.ShouldAnimate, Is.EqualTo (false));
			};

			scrollView.ScrollToAsync (item, ScrollToPosition.Center, false);
			Assert.That (requested, Is.True);
		}

		[Test]
		public void TestScrollToInvalid ()
		{
			var scrollView = new ScrollView ();

			Assert.That (() => scrollView.ScrollToAsync (new VisualElement(), ScrollToPosition.Center, true), Throws.ArgumentException);
			Assert.That (() => scrollView.ScrollToAsync (null, (ScrollToPosition) 500, true), Throws.ArgumentException);
		}

		[Test]
		public void SetScrollPosition ()
		{
			var scroll = new ScrollView();
			IScrollViewController controller = scroll;
			controller.SetScrolledPosition (100, 100);

			Assert.That (scroll.ScrollX, Is.EqualTo (100));
			Assert.That (scroll.ScrollY, Is.EqualTo (100));
		}

		[Test]
		public void TestScrollContentMarginHorizontal()
		{
			View view = new View { IsPlatformEnabled = true, Margin = 100, WidthRequest = 100, HeightRequest = 100 };

			var scroll = new ScrollView
			{
				Content = view,
				Orientation = ScrollOrientation.Horizontal,
			};
			scroll.Layout(new Rectangle(0, 0, 100, 100));

			Assert.AreEqual(new Size(300, 100), scroll.ContentSize);
			Assert.AreEqual(100, scroll.Height);
			Assert.AreEqual(100, scroll.Width);
		}

		[Test]
		public void TestScrollContentMarginVertical()
		{
			View view = new View { IsPlatformEnabled = true, Margin = 100, WidthRequest = 100, HeightRequest = 100 };

			var scroll = new ScrollView
			{
				Content = view,
				Orientation = ScrollOrientation.Vertical,
			};
			scroll.Layout(new Rectangle(0, 0, 100, 100));

			Assert.AreEqual(new Size(100, 300), scroll.ContentSize);
			Assert.AreEqual(100, scroll.Height);
			Assert.AreEqual(100, scroll.Width);
		}

		[Test]
		public void TestScrollContentMarginBiDirectional()
		{
			View view = new View { IsPlatformEnabled = true, Margin = 100, WidthRequest = 100, HeightRequest = 100 };

			var scroll = new ScrollView
			{
				Content = view,
				Orientation = ScrollOrientation.Both,
			};
			scroll.Layout(new Rectangle(0, 0, 100, 100));

			Assert.AreEqual(new Size(300, 300), scroll.ContentSize);
			Assert.AreEqual(100, scroll.Height);
			Assert.AreEqual(100, scroll.Width);
		}

		[Test]
		public void TestBackToBackBiDirectionalScroll()
		{
			var scrollView = new ScrollView
			{
				Orientation = ScrollOrientation.Both,
				Content = new Grid
				{
					WidthRequest = 1000,
					HeightRequest = 1000
				}
			};

			var y100Count = 0;

			((IScrollViewController)scrollView).ScrollToRequested += (sender, args) =>
			{
				if (args.ScrollY == 100)
				{
					++y100Count;
				}
			};

			scrollView.ScrollToAsync(100, 100, true);
			Assert.AreEqual(y100Count, 1);

			scrollView.ScrollToAsync(0, 100, true);
			Assert.AreEqual(y100Count, 2);
		}
	}
}