Splitting exception tests.

Ix.NET/Source/System.Interactive.Tests/Tests.Exceptions.cs → Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Catch.cs

@@ -9,7 +9,7 @@ using Xunit;
 
 namespace Tests
 {
-    public partial class Tests
+    public class Catch : Tests
     {
         [Fact]
         public void Catch_Arguments()
@@ -206,187 +206,8 @@ namespace Tests
             AssertThrows<MyException>(() => e.MoveNext(), ex => ex == e3);
         }
 
-        [Fact]
-        public void Finally_Arguments()
-        {
-            AssertThrows<ArgumentNullException>(() => EnumerableEx.Finally<int>(null, () => { }));
-            AssertThrows<ArgumentNullException>(() => EnumerableEx.Finally<int>(new[] { 1 }, null));
-        }
-
-        [Fact]
-        public void Finally1()
-        {
-            var done = false;
-
-            var xs = Enumerable.Range(0, 2).Finally(() => done = true);
-            Assert.False(done);
-
-            var e = xs.GetEnumerator();
-            Assert.False(done);
-
-            HasNext(e, 0);
-            Assert.False(done);
-
-            HasNext(e, 1);
-            Assert.False(done);
-
-            NoNext(e);
-            Assert.True(done);
-        }
-
-        [Fact]
-        public void Finally2()
+        private sealed class MyException : Exception
         {
-            var done = false;
-
-            var xs = Enumerable.Range(0, 2).Finally(() => done = true);
-            Assert.False(done);
-
-            var e = xs.GetEnumerator();
-            Assert.False(done);
-
-            HasNext(e, 0);
-            Assert.False(done);
-
-            e.Dispose();
-            Assert.True(done);
-        }
-
-        [Fact]
-        public void Finally3()
-        {
-            var done = false;
-
-            var ex = new MyException();
-            var xs = EnumerableEx.Throw<int>(ex).Finally(() => done = true);
-            Assert.False(done);
-
-            var e = xs.GetEnumerator();
-            Assert.False(done);
-
-            try
-            {
-                HasNext(e, 0);
-                Assert.True(false);
-            }
-            catch (MyException ex_)
-            {
-                Assert.Same(ex, ex_);
-            }
-
-            Assert.True(done);
-        }
-
-        [Fact]
-        public void OnErrorResumeNext_Arguments()
-        {
-            AssertThrows<ArgumentNullException>(() => EnumerableEx.OnErrorResumeNext<int>(null, new[] { 1 }));
-            AssertThrows<ArgumentNullException>(() => EnumerableEx.OnErrorResumeNext<int>(new[] { 1 }, null));
-            AssertThrows<ArgumentNullException>(() => EnumerableEx.OnErrorResumeNext<int>(default(IEnumerable<int>[])));
-            AssertThrows<ArgumentNullException>(() => EnumerableEx.OnErrorResumeNext<int>(default(IEnumerable<IEnumerable<int>>)));
-        }
-
-        [Fact]
-        public void OnErrorResumeNext1()
-        {
-            var xs = new[] { 1, 2 };
-            var ys = new[] { 3, 4 };
-
-            var res = xs.OnErrorResumeNext(ys);
-            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
-        }
-
-        [Fact]
-        public void OnErrorResumeNext2()
-        {
-            var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw<int>(new MyException()));
-            var ys = new[] { 3, 4 };
-
-            var res = xs.OnErrorResumeNext(ys);
-            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
-        }
-
-        [Fact]
-        public void OnErrorResumeNext3()
-        {
-            var xs = new[] { 1, 2 };
-            var ys = new[] { 3, 4 };
-            var zs = new[] { 5, 6 };
-
-            var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs);
-            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 }));
-        }
-
-        [Fact]
-        public void OnErrorResumeNext4()
-        {
-            var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw<int>(new MyException()));
-            var ys = new[] { 3, 4 };
-            var zs = new[] { 5, 6 };
-
-            var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs);
-            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 }));
-        }
-
-        [Fact]
-        public void OnErrorResumeNext5()
-        {
-            var xs = new[] { 1, 2 };
-            var ys = new[] { 3, 4 };
-
-            var res = new[] { xs, ys }.OnErrorResumeNext();
-            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
-        }
-
-        [Fact]
-        public void OnErrorResumeNext6()
-        {
-            var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw<int>(new MyException()));
-            var ys = new[] { 3, 4 };
-
-            var res = new[] { xs, ys }.OnErrorResumeNext();
-            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
-        }
-
-        [Fact]
-        public void Retry_Arguments()
-        {
-            AssertThrows<ArgumentNullException>(() => EnumerableEx.Retry<int>(null));
-            AssertThrows<ArgumentNullException>(() => EnumerableEx.Retry<int>(null, 5));
-            AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.Retry<int>(new[] { 1 }, -1));
-        }
-
-        [Fact]
-        public void Retry1()
-        {
-            var xs = Enumerable.Range(0, 10);
-
-            var res = xs.Retry();
-            Assert.True(Enumerable.SequenceEqual(res, xs));
-        }
-
-        [Fact]
-        public void Retry2()
-        {
-            var xs = Enumerable.Range(0, 10);
-
-            var res = xs.Retry(2);
-            Assert.True(Enumerable.SequenceEqual(res, xs));
-        }
-
-        [Fact]
-        public void Retry3()
-        {
-            var ex = new MyException();
-            var xs = Enumerable.Range(0, 2).Concat(EnumerableEx.Throw<int>(ex));
-
-            var res = xs.Retry(2);
-            var e = res.GetEnumerator();
-            HasNext(e, 0);
-            HasNext(e, 1);
-            HasNext(e, 0);
-            HasNext(e, 1);
-            AssertThrows<MyException>(() => e.MoveNext(), ex_ => ex == ex_);
         }
     }
 }

Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Finally.cs

@@ -0,0 +1,88 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information. 
+
+using System;
+using System.Linq;
+using Xunit;
+
+namespace Tests
+{
+    public class Finally : Tests
+    {
+        [Fact]
+        public void Finally_Arguments()
+        {
+            AssertThrows<ArgumentNullException>(() => EnumerableEx.Finally<int>(null, () => { }));
+            AssertThrows<ArgumentNullException>(() => EnumerableEx.Finally<int>(new[] { 1 }, null));
+        }
+
+        [Fact]
+        public void Finally1()
+        {
+            var done = false;
+
+            var xs = Enumerable.Range(0, 2).Finally(() => done = true);
+            Assert.False(done);
+
+            var e = xs.GetEnumerator();
+            Assert.False(done);
+
+            HasNext(e, 0);
+            Assert.False(done);
+
+            HasNext(e, 1);
+            Assert.False(done);
+
+            NoNext(e);
+            Assert.True(done);
+        }
+
+        [Fact]
+        public void Finally2()
+        {
+            var done = false;
+
+            var xs = Enumerable.Range(0, 2).Finally(() => done = true);
+            Assert.False(done);
+
+            var e = xs.GetEnumerator();
+            Assert.False(done);
+
+            HasNext(e, 0);
+            Assert.False(done);
+
+            e.Dispose();
+            Assert.True(done);
+        }
+
+        [Fact]
+        public void Finally3()
+        {
+            var done = false;
+
+            var ex = new MyException();
+            var xs = EnumerableEx.Throw<int>(ex).Finally(() => done = true);
+            Assert.False(done);
+
+            var e = xs.GetEnumerator();
+            Assert.False(done);
+
+            try
+            {
+                HasNext(e, 0);
+                Assert.True(false);
+            }
+            catch (MyException ex_)
+            {
+                Assert.Same(ex, ex_);
+            }
+
+            Assert.True(done);
+        }
+
+        private sealed class MyException : Exception
+        {
+        }
+    }
+}

Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/OnErrorResumeNext.cs

@@ -0,0 +1,89 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information. 
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace Tests
+{
+    public class OnErrorResumeNext : Tests
+    {
+        [Fact]
+        public void OnErrorResumeNext_Arguments()
+        {
+            AssertThrows<ArgumentNullException>(() => EnumerableEx.OnErrorResumeNext<int>(null, new[] { 1 }));
+            AssertThrows<ArgumentNullException>(() => EnumerableEx.OnErrorResumeNext<int>(new[] { 1 }, null));
+            AssertThrows<ArgumentNullException>(() => EnumerableEx.OnErrorResumeNext<int>(default(IEnumerable<int>[])));
+            AssertThrows<ArgumentNullException>(() => EnumerableEx.OnErrorResumeNext<int>(default(IEnumerable<IEnumerable<int>>)));
+        }
+
+        [Fact]
+        public void OnErrorResumeNext1()
+        {
+            var xs = new[] { 1, 2 };
+            var ys = new[] { 3, 4 };
+
+            var res = xs.OnErrorResumeNext(ys);
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
+        }
+
+        [Fact]
+        public void OnErrorResumeNext2()
+        {
+            var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw<int>(new MyException()));
+            var ys = new[] { 3, 4 };
+
+            var res = xs.OnErrorResumeNext(ys);
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
+        }
+
+        [Fact]
+        public void OnErrorResumeNext3()
+        {
+            var xs = new[] { 1, 2 };
+            var ys = new[] { 3, 4 };
+            var zs = new[] { 5, 6 };
+
+            var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs);
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 }));
+        }
+
+        [Fact]
+        public void OnErrorResumeNext4()
+        {
+            var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw<int>(new MyException()));
+            var ys = new[] { 3, 4 };
+            var zs = new[] { 5, 6 };
+
+            var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs);
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 }));
+        }
+
+        [Fact]
+        public void OnErrorResumeNext5()
+        {
+            var xs = new[] { 1, 2 };
+            var ys = new[] { 3, 4 };
+
+            var res = new[] { xs, ys }.OnErrorResumeNext();
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
+        }
+
+        [Fact]
+        public void OnErrorResumeNext6()
+        {
+            var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw<int>(new MyException()));
+            var ys = new[] { 3, 4 };
+
+            var res = new[] { xs, ys }.OnErrorResumeNext();
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
+        }
+
+        private sealed class MyException : Exception
+        {
+        }
+    }
+}

Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Retry.cs

@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information. 
+
+using System;
+using System.Linq;
+using Xunit;
+
+namespace Tests
+{
+    public class Retry : Tests
+    {
+        [Fact]
+        public void Retry_Arguments()
+        {
+            AssertThrows<ArgumentNullException>(() => EnumerableEx.Retry<int>(null));
+            AssertThrows<ArgumentNullException>(() => EnumerableEx.Retry<int>(null, 5));
+            AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.Retry<int>(new[] { 1 }, -1));
+        }
+
+        [Fact]
+        public void Retry1()
+        {
+            var xs = Enumerable.Range(0, 10);
+
+            var res = xs.Retry();
+            Assert.True(Enumerable.SequenceEqual(res, xs));
+        }
+
+        [Fact]
+        public void Retry2()
+        {
+            var xs = Enumerable.Range(0, 10);
+
+            var res = xs.Retry(2);
+            Assert.True(Enumerable.SequenceEqual(res, xs));
+        }
+
+        [Fact]
+        public void Retry3()
+        {
+            var ex = new MyException();
+            var xs = Enumerable.Range(0, 2).Concat(EnumerableEx.Throw<int>(ex));
+
+            var res = xs.Retry(2);
+            var e = res.GetEnumerator();
+            HasNext(e, 0);
+            HasNext(e, 1);
+            HasNext(e, 0);
+            HasNext(e, 1);
+            AssertThrows<MyException>(() => e.MoveNext(), ex_ => ex == ex_);
+        }
+
+        private sealed class MyException : Exception
+        {
+        }
+    }
+}