com.fofx.observething 1.0.0

package/Tests/CollectionObservableTests.cs

@@ -0,0 +1,739 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using UnityEngine.TestTools;
+
+namespace ObserveThing.Tests
+{
+    public class CollectionObservableTests
+    {
+        [SetUp]
+        public void SetUp()
+        {
+            Settings.DefaultExceptionHandler = UnityEngine.Debug.LogException;
+        }
+
+        private T Peek<T>(IValueObservable<T> observable)
+        {
+            T result = default;
+            var observer = observable.Subscribe(x => result = x);
+            observer.Dispose();
+            return result;
+        }
+
+        private List<T> Peek<T>(IListObservable<T> observable)
+        {
+            List<T> result = new List<T>();
+            var observer = observable.Subscribe((index, x) => result.Add(x));
+            observer.Dispose();
+            return result;
+        }
+
+        private void AreEqual<T>(T expected, IValueObservable<T> observable)
+            => Assert.AreEqual(expected, Peek(observable));
+
+        private void AreEqual<T>(IEnumerable<T> expected, IEnumerable<IValueObservable<T>> actual)
+            => Assert.AreEqual(expected, actual.Select(x => Peek(x)));
+
+        private void AreEqual<T>(IEnumerable<T> expected, IValueObservable<T> observable)
+            => Assert.AreEqual(expected, observable);
+
+        [Test]
+        public void TestOrderBy()
+        {
+            int callCount = 0;
+            List<ObservableValue<int>> results = new List<ObservableValue<int>>();
+            Exception exception = default;
+            bool disposed = false;
+
+            var list = new ObservableList<ObservableValue<int>>();
+            var orderBy = list.ObservableOrderBy(x => x.AsObservable()).Subscribe(
+                onAdd: (index, value) =>
+                {
+                    callCount++;
+                    results.Insert(index, value);
+                },
+                onRemove: (index, value) =>
+                {
+                    callCount++;
+                    results.RemoveAt(index);
+                },
+                onError: exc => exception = exc,
+                onDispose: () => disposed = true
+            );
+
+            var v1 = new ObservableValue<int>(2);
+
+            list.Add(new ObservableValue<int>(1));
+            list.Add(v1);
+            list.Add(new ObservableValue<int>(13));
+            list.Add(new ObservableValue<int>(2));
+            list.Add(new ObservableValue<int>(4));
+
+            Assert.AreEqual(5, callCount);
+
+            AreEqual(new int[] { 1, 2, 2, 4, 13 }, results);
+
+            list.Remove(results[1]);
+
+            Assert.AreEqual(6, callCount);
+            AreEqual(new int[] { 1, 2, 4, 13 }, results);
+
+            results[1].value = 22;
+
+            Assert.AreEqual(8, callCount);
+            AreEqual(new int[] { 1, 4, 13, 22 }, results);
+
+            results[2].value = -33;
+
+            Assert.AreEqual(10, callCount);
+            AreEqual(new int[] { -33, 1, 4, 22 }, results);
+
+            var multiAdd = new ObservableValue<int>(3);
+
+            list.Add(multiAdd);
+            list.Add(multiAdd);
+            list.Add(multiAdd);
+            list.Add(multiAdd);
+            list.Add(multiAdd);
+
+            Assert.AreEqual(15, callCount);
+            AreEqual(new int[] { -33, 1, 3, 3, 3, 3, 3, 4, 22 }, results);
+
+            multiAdd.value = 10;
+
+            Assert.AreEqual(25, callCount);
+            AreEqual(new int[] { -33, 1, 4, 10, 10, 10, 10, 10, 22 }, results);
+
+            list.Remove(multiAdd);
+            list.Remove(multiAdd);
+
+            Assert.AreEqual(27, callCount);
+            AreEqual(new int[] { -33, 1, 4, 10, 10, 10, 22 }, results);
+
+            multiAdd.value = 1;
+
+            Assert.AreEqual(33, callCount);
+            AreEqual(new int[] { -33, 1, 1, 1, 1, 4, 22 }, results);
+
+            multiAdd.value = 5;
+
+            Assert.AreEqual(39, callCount);
+            AreEqual(new int[] { -33, 1, 4, 5, 5, 5, 22 }, results);
+
+            orderBy.Dispose();
+            Assert.IsTrue(disposed);
+
+            list.Remove(results[1]);
+            Assert.AreEqual(39, callCount);
+            AreEqual(new int[] { -33, 1, 4, 5, 5, 5, 22 }, results);
+        }
+
+        [Test]
+        public void TestOrderByExternalCollection()
+        {
+            ObservableList<string> source = new ObservableList<string>();
+            List<string> destination = new List<string>();
+
+            source
+                .ObservableSelect(x => x)
+                .ObservableOrderBy(x => source.ObservableIndexOf(x).ObservableSelect(x => x.found ? x.index : -1))
+                .Subscribe(
+                    onAdd: (index, value) => destination.Insert(index, value),
+                    onRemove: (index, value) => destination.RemoveAt(index)
+                );
+
+            source.Add("cat");
+            source.Add("dog");
+            source.Add("frog");
+
+            Assert.That(destination, Is.EqualTo(source));
+
+            source.Remove("dog");
+            source.Add("me");
+            source.Insert(0, "meee");
+
+            Assert.That(destination, Is.EqualTo(source));
+        }
+
+        public struct TestStruct
+        {
+            public int value;
+        }
+
+        [Test]
+        public void TestOrderByExternalStructCollection()
+        {
+            ObservableList<TestStruct> source = new ObservableList<TestStruct>();
+            List<TestStruct> destination = new List<TestStruct>();
+
+            source
+                .ObservableSelect(x => x)
+                .ObservableWhere(x => true)
+                .ObservableOrderBy(x => source.ObservableIndexOf(x).ObservableSelect(x => x.found ? x.index : -1))
+                .Subscribe(
+                    onAdd: (index, value) => destination.Insert(index, value),
+                    onRemove: (index, value) => destination.RemoveAt(index)
+                );
+
+            source.Add(new TestStruct() { value = 1 });
+            source.Add(new TestStruct() { value = 2 });
+            source.Add(new TestStruct() { value = 3 });
+
+            Assert.That(destination, Is.EqualTo(source));
+
+            source.Remove(new TestStruct() { value = 2 });
+            source.Add(new TestStruct() { value = 4 });
+            source.Insert(0, new TestStruct() { value = 10 });
+
+            Assert.That(destination, Is.EqualTo(source));
+        }
+
+        [Test]
+        public void TestWhere()
+        {
+            int callCount = 0;
+            List<ObservableValue<int>> results = new List<ObservableValue<int>>();
+            Exception exception = default;
+            bool disposed = false;
+
+            var list = new ObservableList<ObservableValue<int>>();
+            var where = list.ObservableWhere(x => x.ObservableSelect(x => x % 2 == 0)).Subscribe(
+                onAdd: x =>
+                {
+                    callCount++;
+                    results.Add(x);
+                },
+                onRemove: x =>
+                {
+                    callCount++;
+                    results.Remove(x);
+                },
+                exc => exception = exc,
+                () => disposed = true
+            );
+
+            var v1 = new ObservableValue<int>(1);
+            var v2 = new ObservableValue<int>(6);
+            var v3 = new ObservableValue<int>(13);
+            var v4 = new ObservableValue<int>(2);
+            var v5 = new ObservableValue<int>(4);
+
+            list.Add(v1);
+            list.Add(v2);
+            list.Add(v3);
+            list.Add(v4);
+            list.Add(v5);
+
+            Assert.AreEqual(3, callCount);
+            Assert.That(results, Is.EquivalentTo(new[] { v2, v4, v5 }));
+
+            list.Remove(v4);
+
+            Assert.AreEqual(4, callCount);
+            Assert.That(results, Is.EquivalentTo(new[] { v2, v5 }));
+
+            list.Remove(v3);
+
+            Assert.AreEqual(4, callCount);
+            Assert.That(results, Is.EquivalentTo(new[] { v2, v5 }));
+
+            list.Add(v3);
+
+            Assert.AreEqual(4, callCount);
+            Assert.That(results, Is.EquivalentTo(new[] { v2, v5 }));
+
+            var v6 = new ObservableValue<int>(8);
+
+            list.Add(v6);
+
+            Assert.AreEqual(5, callCount);
+            Assert.That(results, Is.EquivalentTo(new[] { v2, v5, v6 }));
+
+            v6.value = 7;
+
+            Assert.AreEqual(6, callCount);
+            Assert.That(results, Is.EquivalentTo(new[] { v2, v5 }));
+
+            v2.value = 8;
+
+            Assert.AreEqual(6, callCount);
+            Assert.That(results, Is.EquivalentTo(new[] { v2, v5 }));
+
+            where.Dispose();
+            Assert.IsTrue(disposed);
+
+            list.Remove(v2);
+
+            Assert.AreEqual(6, callCount);
+            Assert.That(results, Is.EquivalentTo(new[] { v2, v5 }));
+        }
+
+        [Test]
+        public void TestDistinct()
+        {
+            int callCount = 0;
+            List<int> results = new List<int>();
+            Exception exception = default;
+            bool disposed = false;
+
+            var list = new ObservableList<int>();
+            var distinct = list.ObservableDistinct().Subscribe(
+                onAdd: x =>
+                {
+                    callCount++;
+                    results.Add(x);
+                },
+                onRemove: x =>
+                {
+                    callCount++;
+                    results.Remove(x);
+                },
+                exc => exception = exc,
+                () => disposed = true
+            );
+
+            list.Add(1);
+            list.Add(6);
+            list.Add(6);
+            list.Add(6);
+            list.Add(13);
+            list.Add(2);
+            list.Add(4);
+            list.Add(4);
+
+            Assert.AreEqual(5, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 6, 2, 4, 13 }));
+
+            list.Remove(4);
+
+            Assert.AreEqual(5, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 6, 2, 4, 13 }));
+
+            list.Remove(1);
+
+            Assert.AreEqual(6, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 6, 2, 4, 13 }));
+
+            list.Add(13);
+
+            Assert.AreEqual(6, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 6, 2, 4, 13 }));
+
+            distinct.Dispose();
+            Assert.IsTrue(disposed);
+
+            list.Add(100);
+
+            Assert.AreEqual(6, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 6, 2, 4, 13 }));
+        }
+
+        [Test]
+        public void TestConcat()
+        {
+            int callCount = 0;
+            List<int> results = new List<int>();
+            Exception exception = default;
+            bool disposed = false;
+
+            var list1 = new ObservableList<int>();
+            var list2 = new ObservableList<int>();
+            var concat = list1.ObservableConcat(list2.AsObservable()).Subscribe(
+                onAdd: x =>
+                {
+                    callCount++;
+                    results.Add(x);
+                },
+                onRemove: x =>
+                {
+                    callCount++;
+                    results.Remove(x);
+                },
+                exc => exception = exc,
+                () => disposed = true
+            );
+
+            list1.Add(1);
+            list1.Add(2);
+            list1.Add(3);
+
+            list2.Add(4);
+            list2.Add(5);
+            list2.Add(6);
+
+            Assert.AreEqual(6, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 3, 4, 5, 6 }));
+
+            list2.Add(7);
+
+            Assert.AreEqual(7, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 3, 4, 5, 6, 7 }));
+
+            list2.Remove(4);
+
+            Assert.AreEqual(8, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 3, 5, 6, 7 }));
+
+            list1.Add(8);
+
+            Assert.AreEqual(9, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 3, 5, 6, 7, 8 }));
+
+            list1.Remove(3);
+
+            Assert.AreEqual(10, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 5, 6, 7, 8 }));
+
+            list2.Add(8);
+
+            Assert.AreEqual(11, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 5, 6, 7, 8, 8 }));
+
+            list1.Remove(8);
+
+            Assert.AreEqual(12, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 5, 6, 7, 8 }));
+
+            list1.Dispose();
+            Assert.IsTrue(disposed);
+
+            list2.Add(100);
+
+            Assert.AreEqual(12, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 5, 6, 7, 8 }));
+        }
+
+        [Test]
+        public void TestSelectMany()
+        {
+            int callCount = 0;
+            List<int> results = new List<int>();
+            Exception exception = default;
+            bool disposed = false;
+
+            var list = new ObservableList<ObservableList<int>>();
+            var selectMany = list.ObservableSelectMany(x => x.AsObservable()).Subscribe(
+                x =>
+                {
+                    callCount++;
+                    results.Add(x);
+                },
+                x =>
+                {
+                    callCount++;
+                    results.Remove(x);
+                },
+                exc => exception = exc,
+                () => disposed = true
+            );
+
+            var arr1 = new ObservableList<int>(new[] { 1, 2, 3 });
+            var arr2 = new ObservableList<int>(new[] { 4, 5, 6 });
+            var arr3 = new ObservableList<int>(new[] { 7, 8, 9 });
+
+            list.Add(arr1);
+            list.Add(arr2);
+            list.Add(arr3);
+
+            Assert.AreEqual(9, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }));
+
+            list.Remove(arr2);
+
+            Assert.AreEqual(12, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 3, 7, 8, 9 }));
+
+            list.Add(arr2);
+            list.Add(arr2);
+
+            Assert.AreEqual(18, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 8, 9 }));
+
+            arr1.Add(100);
+
+            Assert.AreEqual(19, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 8, 9, 100 }));
+
+            arr3.Remove(9);
+
+            Assert.AreEqual(20, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 8, 100 }));
+
+            arr2.Remove(5);
+
+            Assert.AreEqual(22, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 3, 4, 6, 4, 6, 7, 8, 100 }));
+
+            arr2.Add(44);
+
+            Assert.AreEqual(24, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 3, 4, 6, 4, 6, 7, 8, 100, 44, 44 }));
+
+            list.Dispose();
+            Assert.IsTrue(disposed);
+
+            Assert.Throws(typeof(ObjectDisposedException), () => list.Add(arr1));
+
+            Assert.AreEqual(24, callCount);
+            Assert.That(results, Is.EquivalentTo(new int[] { 1, 2, 3, 4, 6, 4, 6, 7, 8, 100, 44, 44 }));
+        }
+
+        [Test]
+        public void TestSelect()
+        {
+            var result = new List<string>();
+            var list = new ObservableList<int>();
+            bool disposed = false;
+            bool receivedCall = false;
+
+            var select = list.ObservableSelect(x => x.ToString()).Subscribe(
+                onAdd: x =>
+                {
+                    result.Add(x);
+                    receivedCall = true;
+                },
+                onRemove: x =>
+                {
+                    result.Remove(x);
+                    receivedCall = true;
+                },
+                onDispose: () => disposed = true
+            );
+
+            list.Add(1);
+            list.Add(1);
+            list.Add(2);
+            list.Add(3);
+            list.Add(4);
+            list.Add(45);
+
+            CollectionAssert.AreEquivalent(
+                Enumerable.Select(list, x => x.ToString()),
+                result
+            );
+
+            list.Remove(3);
+            list.Remove(3);
+            list.Add(1);
+            list.Add(45);
+            list.Remove(45);
+
+            CollectionAssert.AreEquivalent(
+                Enumerable.Select(list, x => x.ToString()),
+                result
+            );
+
+            list.Clear();
+
+            CollectionAssert.AreEquivalent(
+                Enumerable.Select(list, x => x.ToString()),
+                result
+            );
+
+            receivedCall = false;
+            select.Dispose();
+
+            list.Add(234);
+
+            Assert.IsTrue(disposed);
+            Assert.IsFalse(receivedCall);
+        }
+
+        [Test]
+        public void TestShallowCopy()
+        {
+            bool disposed = false;
+            bool callReceived = false;
+            var result = new List<float>();
+            var source = new ObservableList<ObservableValue<float>>(
+                new ObservableValue<float>(1),
+                new ObservableValue<float>(2),
+                new ObservableValue<float>(3)
+            );
+
+            var stream = source.ObservableUnwrap().Subscribe(
+                onAdd: (_, x) =>
+                {
+                    result.Add(x);
+                    callReceived = true;
+                },
+                onRemove: (_, x) =>
+                {
+                    result.Remove(x);
+                    callReceived = true;
+                },
+                onDispose: () => disposed = true
+            );
+
+            Assert.That(result, Is.EquivalentTo(new float[] { 1, 2, 3 }));
+
+            ((ObservableValue<float>)source[1]).value = 3;
+
+            Assert.That(result, Is.EquivalentTo(new float[] { 1, 3, 3 }));
+
+            var removed = source[1];
+            source.RemoveAt(1);
+
+            Assert.That(result, Is.EquivalentTo(new float[] { 1, 3 }));
+
+            ((ObservableValue<float>)removed).value = 100;
+
+            Assert.That(result, Is.EquivalentTo(new float[] { 1, 3 }));
+
+            source.Add(new ObservableValue<float>(55));
+            source.Add(new ObservableValue<float>(55));
+            source.Add(new ObservableValue<float>(1));
+
+            Assert.That(result, Is.EquivalentTo(new float[] { 1, 1, 3, 55, 55 }));
+
+            source.Clear();
+
+            Assert.That(result, Is.EquivalentTo(new float[] { }));
+
+            callReceived = false;
+            stream.Dispose();
+
+            source.Add(new ObservableValue<float>(100));
+            Assert.IsTrue(disposed);
+            Assert.IsFalse(callReceived);
+        }
+
+        public class TestElement
+        {
+            public ObservableValue<int> intValue = new ObservableValue<int>();
+            public ObservableValue<string> stringValue = new ObservableValue<string>();
+        }
+
+        [Test]
+        public void TestErrorLog()
+        {
+            var dict = new ObservableDictionary<int, string>();
+            var stream = dict.ObservableSelect(x =>
+            {
+                if (x.Key != 0)
+                    throw new Exception("Oh no! First");
+
+                return x.Key;
+
+            }).ObservableSelect(x =>
+            {
+                if (x != 0)
+                    throw new Exception("Oh no! Second");
+
+                return x;
+
+            }).Subscribe(onAdd: null, onRemove: null, onError: null, onDispose: null);
+
+            LogAssert.Expect(UnityEngine.LogType.Exception, "Exception: Oh no! First");
+            dict.Add(10, "cat");
+
+            LogAssert.Expect(UnityEngine.LogType.Exception, "Exception: Oh no! First");
+            dict.Add(11, "dog");
+        }
+
+        [Test]
+        public void TestFirst()
+        {
+            (bool found, ObservableValue<int> value) result = default;
+            bool receivedCall = false;
+            bool disposed = false;
+
+            var source = new ObservableList<ObservableValue<int>>(
+                new ObservableValue<int>(1),
+                new ObservableValue<int>(4),
+                new ObservableValue<int>(4),
+                new ObservableValue<int>(13)
+            );
+
+            var subscription = source.ObservableFirst(x => x.ObservableSelect(x => x == 4))
+                .Subscribe(
+                    onNext: x =>
+                    {
+                        result = new(x.found, x.value);
+                        receivedCall = true;
+                    },
+                    onDispose: () => disposed = true
+                );
+
+            Assert.IsTrue(result.found);
+            Assert.AreEqual(source[1], result.value);
+
+            source[1].value = 100;
+
+            Assert.IsTrue(result.found);
+            Assert.AreEqual(source[2], result.value);
+
+            source.RemoveAt(2);
+
+            Assert.IsFalse(result.found);
+            Assert.IsNull(result.value);
+
+            source[0].value = 4;
+
+            Assert.IsTrue(result.found);
+            Assert.AreEqual(source[0], result.value);
+
+            source.Dispose();
+
+            Assert.IsTrue(disposed);
+
+            receivedCall = false;
+            source[0].value = 0;
+
+            Assert.IsFalse(receivedCall);
+        }
+
+        [Test]
+        public void TestFirstOrDefault()
+        {
+            ObservableValue<int> result = default;
+            bool receivedCall = false;
+            bool disposed = false;
+
+            var source = new ObservableList<ObservableValue<int>>(
+                new ObservableValue<int>(1),
+                new ObservableValue<int>(4),
+                new ObservableValue<int>(4),
+                new ObservableValue<int>(13)
+            );
+
+            var subscription = source.ObservableFirstOrDefault(x => x.ObservableSelect(x => x == 4))
+                .Subscribe(
+                    onNext: x =>
+                    {
+                        result = x;
+                        receivedCall = true;
+                    },
+                    onDispose: () => disposed = true
+                );
+
+            Assert.IsNotNull(result);
+            Assert.AreEqual(source[1], result);
+
+            source[1].value = 100;
+
+            Assert.IsNotNull(result);
+            Assert.AreEqual(source[2], result);
+
+            source.RemoveAt(2);
+
+            Assert.IsNull(result);
+
+            source[0].value = 4;
+
+            Assert.IsNotNull(result);
+            Assert.AreEqual(source[0], result);
+
+            source.Dispose();
+
+            Assert.IsTrue(disposed);
+
+            receivedCall = false;
+            source[0].value = 0;
+
+            Assert.IsFalse(receivedCall);
+        }
+    }
+}