GitVersion

GitVersion

Tests/MovingAvg/ALMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class ALMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		ALMA_Series c = new(a, 4);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(10, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		ALMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class ALMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		ALMA_Series c = new(a, 4);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(10, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		ALMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/BBANDS_Test.cs

@@ -1,56 +1,56 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class BBANDS_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		BBANDS_Series c = new(a, 4,2.5);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		Assert.Equal(a.Count, c.Mid.Count);
-		Assert.Equal(a.Count, c.Upper.Count);
-		Assert.Equal(a.Count, c.Lower.Count);
-		Assert.Equal(a.Count, c.PercentB.Count);
-		Assert.Equal(a.Count, c.Zscore.Count);
-		Assert.Equal(a.Count, c.Bandwidth.Count);
-
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-		Assert.Equal(a.Count, c.Mid.Count);
-		Assert.Equal(a.Count, c.Upper.Count);
-		Assert.Equal(a.Count, c.Lower.Count);
-		Assert.Equal(a.Count, c.PercentB.Count);
-		Assert.Equal(a.Count, c.Zscore.Count);
-		Assert.Equal(a.Count, c.Bandwidth.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		BBANDS_Series c = new(a, 4, 2.5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		Assert.Equal(a.Count, c.Mid.Count);
-		Assert.Equal(a.Count, c.Upper.Count);
-		Assert.Equal(a.Count, c.Lower.Count);
-		Assert.Equal(a.Count, c.PercentB.Count);
-		Assert.Equal(a.Count, c.Zscore.Count);
-		Assert.Equal(a.Count, c.Bandwidth.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-		Assert.Equal(a.Count, c.Mid.Count);
-		Assert.Equal(a.Count, c.Upper.Count);
-		Assert.Equal(a.Count, c.Lower.Count);
-		Assert.Equal(a.Count, c.PercentB.Count);
-		Assert.Equal(a.Count, c.Zscore.Count);
-		Assert.Equal(a.Count, c.Bandwidth.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class BBANDS_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		BBANDS_Series c = new(a, 4,2.5);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		Assert.Equal(a.Count, c.Mid.Count);
+		Assert.Equal(a.Count, c.Upper.Count);
+		Assert.Equal(a.Count, c.Lower.Count);
+		Assert.Equal(a.Count, c.PercentB.Count);
+		Assert.Equal(a.Count, c.Zscore.Count);
+		Assert.Equal(a.Count, c.Bandwidth.Count);
+
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+		Assert.Equal(a.Count, c.Mid.Count);
+		Assert.Equal(a.Count, c.Upper.Count);
+		Assert.Equal(a.Count, c.Lower.Count);
+		Assert.Equal(a.Count, c.PercentB.Count);
+		Assert.Equal(a.Count, c.Zscore.Count);
+		Assert.Equal(a.Count, c.Bandwidth.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		BBANDS_Series c = new(a, 4, 2.5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		Assert.Equal(a.Count, c.Mid.Count);
+		Assert.Equal(a.Count, c.Upper.Count);
+		Assert.Equal(a.Count, c.Lower.Count);
+		Assert.Equal(a.Count, c.PercentB.Count);
+		Assert.Equal(a.Count, c.Zscore.Count);
+		Assert.Equal(a.Count, c.Bandwidth.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+		Assert.Equal(a.Count, c.Mid.Count);
+		Assert.Equal(a.Count, c.Upper.Count);
+		Assert.Equal(a.Count, c.Lower.Count);
+		Assert.Equal(a.Count, c.PercentB.Count);
+		Assert.Equal(a.Count, c.Zscore.Count);
+		Assert.Equal(a.Count, c.Bandwidth.Count);
+	}
+}

Tests/MovingAvg/DEMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class DEMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		DEMA_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		DEMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class DEMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		DEMA_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		DEMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/EMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class EMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		EMA_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		EMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class EMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		EMA_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		EMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/HEMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class HEMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		HEMA_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		HEMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class HEMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		HEMA_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		HEMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/HMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class HMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		HMA_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		HMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class HMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		HMA_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		HMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/JMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class JMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		JMA_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		JMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class JMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		JMA_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		JMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/KAMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class KAMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		KAMA_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		KAMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class KAMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		KAMA_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		KAMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/MACD_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class MACD_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		MACD_Series c = new(a, 26,12,9);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		MACD_Series c = new(a, 26,12,9);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class MACD_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		MACD_Series c = new(a, 26,12,9);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		MACD_Series c = new(a, 26,12,9);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/RMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class RMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		RMA_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		RMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class RMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		RMA_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		RMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/RSI_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class RSI_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		RSI_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		RSI_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class RSI_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		RSI_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		RSI_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/SMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class SMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		SMA_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		SMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class SMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		SMA_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		SMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/SMMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class SMMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		SMMA_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		SMMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class SMMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		SMMA_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		SMMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/TEMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class TEMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		TEMA_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		TEMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class TEMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		TEMA_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		TEMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/WMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class WMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		WMA_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		WMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class WMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		WMA_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		WMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/MovingAvg/ZLEMA_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace MovingAvg;
-public class ZLEMA_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		ZLEMA_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		ZLEMA_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class ZLEMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		ZLEMA_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		ZLEMA_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}