ListProxyTests.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using NUnit.Framework;

namespace Xamarin.Forms.Core.UnitTests
{
	[TestFixture]
	public class ListProxyTests : 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 ListCount()
		{
			var list = new List<string> { "foo", "bar" };
			var proxy = new ListProxy (list);

			Assert.AreEqual (list.Count, proxy.Count);
			list.Add ("baz");
			Assert.AreEqual (list.Count, proxy.Count);
		}

		[Test]
		public void CollectionCount()
		{
			var list = new Collection<string> { "foo", "bar" };
			var proxy = new ListProxy (list);

			Assert.AreEqual (list.Count, proxy.Count);
			list.Add ("baz");
			Assert.AreEqual (list.Count, proxy.Count);
		}

		[Test]
		[Description ("Count should ensure that the window is created if neccessary")]
		public void EnumerableInitialCount()
		{
			var enumerable = Enumerable.Range (0, 100);
			var proxy = new ListProxy (enumerable, 10);

			Assert.AreEqual (10, proxy.Count);
		}

		[Test]
		public void EnumerableCount()
		{
			var enumerable = Enumerable.Range (0, 100);
			var proxy = new ListProxy (enumerable, 10);

			int changed = 0;
			proxy.CountChanged += (o, e) => changed++;

			var enumerator = proxy.GetEnumerator();
			enumerator.MoveNext();

			Assert.AreEqual (10, proxy.Count);
			Assert.AreEqual (1, changed);

			enumerator.MoveNext();

			Assert.AreEqual (10, proxy.Count);
			Assert.AreEqual (1, changed);

			while (enumerator.MoveNext()) {
			}

			enumerator.Dispose();

			Assert.AreEqual (100, proxy.Count);
			Assert.AreEqual (19, changed);

			using (enumerator = proxy.GetEnumerator()) {

				Assert.AreEqual (100, proxy.Count);

				while (enumerator.MoveNext())
					Assert.AreEqual (100, proxy.Count);

				Assert.AreEqual (100, proxy.Count);
			}

			Assert.AreEqual (19, changed);
		}

		[Test]
		public void InsideWindowSize()
		{
			var numbers = Enumerable.Range (0, 100);
			var proxy = new ListProxy (numbers, 10);

			int i = (int)proxy[5];
			Assert.That (i, Is.EqualTo (5));
		}

		[Test]
		public void IndexOutsideWindowSize()
		{
			var numbers = Enumerable.Range (0, 100);
			var proxy = new ListProxy (numbers, 10);

			int i = (int)proxy[50];
			Assert.That (i, Is.EqualTo (50));
		}

		[Test]
		public void IndexInsideToOutsideWindowSize()
		{
			var numbers = Enumerable.Range (0, 100);
			var proxy = new ListProxy (numbers, 10);

			int i = (int)proxy[5];
			Assert.That (i, Is.EqualTo (5));

			i = (int)proxy[50];
			Assert.That (i, Is.EqualTo (50));
		}

		[Test]
		public void IndexOutsideToPreWindowSize()
		{
			var numbers = Enumerable.Range (0, 100);
			var proxy = new ListProxy (numbers, 10);

			int i = (int)proxy[50];
			Assert.That (i, Is.EqualTo (50));

			i = (int)proxy[5];
			Assert.That (i, Is.EqualTo (5));
		}

		[Test]
		public void EnumerableIndexOutOfRange()
		{
			var numbers = Enumerable.Range (0, 100);
			var proxy = new ListProxy (numbers);

			Assert.That (() => proxy[100], Throws.InstanceOf<ArgumentOutOfRangeException>());
		}

		class IntCollection
			: ICollection
		{
			readonly List<int> ints;

			public IntCollection (IEnumerable<int> ints)
			{
				this.ints = ints.ToList();
			}

			public IEnumerator GetEnumerator()
			{
				return ints.GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			public void CopyTo (Array array, int index)
			{
				throw new NotImplementedException();
			}

			public int Count { get { return ints.Count; }}

			public object SyncRoot
			{
				get { throw new NotImplementedException(); }
			}

			public bool IsSynchronized
			{
				get { throw new NotImplementedException(); }
			}

			public bool IsReadOnly { get { return true; } }
		}

		[Test]
		public void CollectionIndexOutOfRange()
		{
			var numbers = new IntCollection (Enumerable.Range (0, 100));
			var proxy = new ListProxy (numbers);

			Assert.That (() => proxy[100], Throws.InstanceOf<ArgumentOutOfRangeException>());
		}

		[Test]
		public void ListIndexOutOfRange()
		{
			var numbers = Enumerable.Range (0, 100).ToList();
			var proxy = new ListProxy (numbers);

			Assert.That (() => proxy[100], Throws.InstanceOf<ArgumentOutOfRangeException>());
		}

		[Test]
		public void CollectionChangedWhileEnumerating()
		{
			var c = new ObservableCollection<string> { "foo", "bar" };
			var p = new ListProxy (c);

			IEnumerator<object> e = p.GetEnumerator();
			Assert.IsTrue (e.MoveNext(), "Initial MoveNext() failed, test can't continue");

			c.Add ("baz");

			Assert.That (() => e.MoveNext(), Throws.InvalidOperationException,
				"MoveNext did not throw an exception when the underlying collection had changed");
		}

		[Test]
		public void SynchronizedCollectionAccess()
		{
			var collection = new ObservableCollection<string> { "foo" };
			var context = new object();

			var list = new ListProxy (collection);

			bool executed = false;
			BindingBase.EnableCollectionSynchronization (collection, context, (enumerable, o, method, access) => {
				executed = true;
				Assert.AreSame (collection, enumerable);
				Assert.AreSame (context, o);
				Assert.IsNotNull (method);
				Assert.IsFalse (access);

				lock (enumerable)
					method();
			});

			object value = list[0];

			Assert.IsTrue (executed, "Callback was not executed");
		}

		[Test]
		public void SynchronizedCollectionAdd()
		{
			bool invoked = false;
			Device.PlatformServices  = new MockPlatformServices (isInvokeRequired:true, invokeOnMainThread: action => {
				invoked = true;
				action();
			});

			var collection = new ObservableCollection<string> { "foo" };
			var context = new object();

			var list = new ListProxy (collection);
			
			Assert.IsFalse (invoked, "An invoke shouldn't be executed just setting up ListProxy");

			bool executed = false;
			BindingBase.EnableCollectionSynchronization (collection, context, (enumerable, o, method, access) => {
				executed = true;
				Assert.AreSame (collection, enumerable);
				Assert.AreSame (context, o);
				Assert.IsNotNull (method);
				Assert.IsFalse (access);

				lock (enumerable)
					method();
			});

			var mre = new ManualResetEvent (false);

			Task.Factory.StartNew (() => {
				lock (collection)
					collection.Add ("foo");

				mre.Set();
			}, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);

			mre.WaitOne (5000);

			Assert.IsTrue (executed, "Callback was not executed");
			Assert.IsTrue (invoked, "Callback was not executed on the UI thread");
		}

		[Test]
		public void ClearEnumerable()
		{
			var proxy = new ListProxy (Enumerable.Range (0, 100));
			var enumerator = proxy.GetEnumerator();
			enumerator.MoveNext();
			enumerator.MoveNext();

			proxy.Clear();

			Assert.AreEqual (100, proxy.Count);
			Assert.That (() => enumerator.MoveNext(), Throws.InvalidOperationException);
		}

		[Test]
		public void ClearCollection()
		{
			var proxy = new ListProxy (new IntCollection (Enumerable.Range (0, 100)));
			var enumerator = proxy.GetEnumerator();
			enumerator.MoveNext();
			enumerator.MoveNext();

			proxy.Clear();

			Assert.AreEqual (100, proxy.Count);
			Assert.That (() => enumerator.MoveNext(), Throws.InvalidOperationException);
		}

		[Test]
		public void ClearList()
		{
			var proxy = new ListProxy (Enumerable.Range (0, 100).ToList());
			var enumerator = proxy.GetEnumerator();
			enumerator.MoveNext();
			enumerator.MoveNext();

			proxy.Clear();

			Assert.AreEqual (100, proxy.Count);
			Assert.That (() => enumerator.MoveNext(), Throws.InvalidOperationException);
		}

		[Test]
		public void IndexOfValueTypeNonList()
		{
			var proxy = new ListProxy (Enumerable.Range (0, 100));
			Assert.AreEqual (1, proxy.IndexOf (1));
		}

		[Test]
		public void EnumeratorForEnumerable()
		{
			var proxy = new ListProxy (Enumerable.Range (0, 2));

			var enumerator = proxy.GetEnumerator();
			Assert.That (enumerator.Current, Is.Null);
			Assert.That (enumerator.MoveNext(), Is.True);
			Assert.That (enumerator.Current, Is.EqualTo (0));
			Assert.That (enumerator.MoveNext(), Is.True);
			Assert.That (enumerator.Current, Is.EqualTo (1));
			Assert.That (enumerator.MoveNext(), Is.False);
		}

		[Test]
		public void ProxyIsWeaklyHeldByINotifyCollectionChanged()
		{
			ObservableCollection<string> collection = new ObservableCollection<string>();

			WeakReference weakProxy = null;

			int i = 0;
			Action create = null;
			create = () => {
				if (i++ < 1024) {
					create();
					return;
				}

				var proxy = new ListProxy (collection);
				weakProxy = new WeakReference (proxy);
			};

			create();

			GC.Collect();
			GC.WaitForPendingFinalizers();
			GC.Collect();

			Assert.That (weakProxy.IsAlive, Is.False);
		}

		[Test]
		public void IEnumerableAddDoesNotReport0()
		{
			var custom = new CustomINCC();
			custom.Add ("test");
			custom.Add ("test2");

			var proxy = new ListProxy (custom);
			Assert.That (proxy.Count, Is.EqualTo (2));

			custom.Add ("testing");
			Assert.That (proxy.Count, Is.EqualTo (3));
		}

		class CustomINCC : IEnumerable<string>, INotifyCollectionChanged
		{
			public event NotifyCollectionChangedEventHandler CollectionChanged;
			List<string> Items = new List<string> ();

			public void Add (string s)
			{
				Items.Add(s);
				if (CollectionChanged != null)
					CollectionChanged (this, new NotifyCollectionChangedEventArgs (NotifyCollectionChangedAction.Add, s));
			}

			public IEnumerator<string> GetEnumerator ()
			{
				return Items.GetEnumerator ();
			}
			IEnumerator IEnumerable.GetEnumerator ()
			{
				return Items.GetEnumerator ();
			}
		}

		// Need a member to keep this reference around, otherwise it gets optimized
		// out early in Release mode during the WeakToWeak test
#pragma warning disable 0414 // Never accessed, it's just here to prevent GC
		ListProxy _proxyForWeakToWeakTest;
#pragma warning restore 0414

		[Test]
		public void WeakToWeak()
		{
			WeakCollectionChangedList list = new WeakCollectionChangedList();
			_proxyForWeakToWeakTest = new ListProxy(list);

			Assert.True(list.AddObject(), "GC hasn't run");

			GC.Collect();
			GC.WaitForPendingFinalizers();

			Assert.IsTrue(list.AddObject(), "GC run, but proxy should still hold a reference");

			_proxyForWeakToWeakTest = null;

			GC.Collect();
			GC.WaitForPendingFinalizers();

			Assert.IsFalse(list.AddObject(), "Proxy is gone and GC has run");
		}

		public class WeakCollectionChangedList : List<object>, INotifyCollectionChanged
		{
			List<WeakHandler> handlers = new List<WeakHandler>();

			public WeakCollectionChangedList()
			{

			}
			public event NotifyCollectionChangedEventHandler CollectionChanged
			{
				add { handlers.Add(new WeakHandler(this, value)); }
				remove { throw new NotImplementedException(); }
			}


			public bool AddObject()
			{
				bool invoked = false;
				var me = new object();
				Console.WriteLine($"Handler count is {handlers.Count}");
				foreach (var handler in handlers.ToList())
				{
					if (handler.IsActive)
					{
						invoked = true;
						handler.Handler.DynamicInvoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, me));
					}
					else
					{
						Console.WriteLine($"Handler is inactive");
						handlers.Remove(handler);
					}
				}

				return invoked;
			}

			class WeakHandler
			{
				WeakReference source;
				WeakReference originalHandler;

				public bool IsActive
				{
					get { return this.source != null && this.source.IsAlive && this.originalHandler != null && this.originalHandler.IsAlive; }
				}

				public NotifyCollectionChangedEventHandler Handler
				{
					get
					{
						if (this.originalHandler == null)
						{
							return default(NotifyCollectionChangedEventHandler);
						}
						else
						{
							return (NotifyCollectionChangedEventHandler)this.originalHandler.Target;
						}
					}
				}

				public WeakHandler(object source, NotifyCollectionChangedEventHandler originalHandler)
				{
					this.source = new WeakReference(source);
					this.originalHandler = new WeakReference(originalHandler);
				}
			}
		}
	}
}