diff --git a/Directory.Packages.props b/Directory.Packages.props
index f0264e296..6f28a4337 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -3,6 +3,9 @@
+
+
+
@@ -10,8 +13,5 @@
-
-
-
\ No newline at end of file
diff --git a/README.md b/README.md
index 401ec0128..bc9e7264c 100644
--- a/README.md
+++ b/README.md
@@ -132,7 +132,7 @@ xFunc is released under MIT License.
[Azure Pipelines](https://azure.microsoft.com/en-us/services/devops/pipelines/)
[Coverlet](https://github.com/coverlet-coverage/coverlet)
[ReportGenerator](https://github.com/danielpalme/ReportGenerator)
-[xUnit](https://github.com/xunit/xunit)
+[NUnit](https://github.com/nunit/nunit)
[NSubstitute](https://github.com/nsubstitute/NSubstitute)
[docfx](https://github.com/dotnet/docfx)
[BenchmarkDotNet](https://github.com/dotnet/BenchmarkDotNet)
diff --git a/xFunc.Tests/Analyzers/DifferentiatorTests/DifferentiatorTest.cs b/xFunc.Tests/Analyzers/DifferentiatorTests/DifferentiatorTest.cs
index ea534ab06..bc0a83314 100644
--- a/xFunc.Tests/Analyzers/DifferentiatorTests/DifferentiatorTest.cs
+++ b/xFunc.Tests/Analyzers/DifferentiatorTests/DifferentiatorTest.cs
@@ -26,85 +26,85 @@ private IExpression Differentiate(IExpression exp, Variable variable, Expression
#region Common
- [Fact]
+ [Test]
public void NumberTest()
{
var exp = Differentiate(new Number(10));
- Assert.Equal(zero, exp);
+ Assert.That(exp, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void AngleNumberTest()
{
var exp = Differentiate(new Angle(AngleValue.Degree(10)));
- Assert.Equal(zero, exp);
+ Assert.That(exp, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void PowerNumberTest()
{
var exp = Differentiate(new Power(PowerValue.Watt(10)));
- Assert.Equal(zero, exp);
+ Assert.That(exp, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void TemperatureNumberTest()
{
var exp = Differentiate(TemperatureValue.Celsius(10).AsExpression());
- Assert.Equal(zero, exp);
+ Assert.That(exp, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void MassNumberTest()
{
var exp = Differentiate(MassValue.Kilogram(10).AsExpression());
- Assert.Equal(zero, exp);
+ Assert.That(exp, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void LengthNumberTest()
{
var exp = Differentiate(LengthValue.Kilometer(10).AsExpression());
- Assert.Equal(zero, exp);
+ Assert.That(exp, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void TimeNumberTest()
{
var exp = Differentiate(TimeValue.Second(10).AsExpression());
- Assert.Equal(zero, exp);
+ Assert.That(exp, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void AreaNumberTest()
{
var exp = Differentiate(AreaValue.Meter(10).AsExpression());
- Assert.Equal(zero, exp);
+ Assert.That(exp, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void VolumeNumberTest()
{
var exp = Differentiate(VolumeValue.Meter(10).AsExpression());
- Assert.Equal(zero, exp);
+ Assert.That(exp, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void VariableNullTest()
{
Assert.Throws(() => Differentiate(new Number(10), null));
}
- [Fact]
+ [Test]
public void AbsDerivativeTest1()
{
var exp = Differentiate(new Abs(Variable.X));
@@ -113,10 +113,10 @@ public void AbsDerivativeTest1()
new Div(Variable.X, new Abs(Variable.X))
);
- Assert.Equal(expected, exp);
+ Assert.That(exp, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AbsPartialDerivativeTest1()
{
var exp = new Abs(new Mul(Variable.X, Variable.Y));
@@ -129,10 +129,10 @@ public void AbsPartialDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AbsPartialDerivativeTest2()
{
var exp = new Abs(new Mul(Variable.X, Variable.Y));
@@ -145,28 +145,28 @@ public void AbsPartialDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AbsPartialDerivativeTest3()
{
var deriv = Differentiate(new Abs(Variable.X), Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void AddDerivativeTest1()
{
var exp = new Add(new Mul(Number.Two, Variable.X), new Number(3));
var deriv = Differentiate(exp);
var expected = new Mul(Number.Two, Number.One);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AddDerivativeTest2()
{
var exp = new Add(
@@ -179,10 +179,10 @@ public void AddDerivativeTest2()
new Mul(new Number(3), Number.One)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AddPartialDerivativeTest1()
{
var exp = new Add(
@@ -192,10 +192,10 @@ public void AddPartialDerivativeTest1()
var deriv = Differentiate(exp);
var expected = new Add(new Mul(Number.One, Variable.Y), Number.One);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AddPartialDerivativeTest2()
{
var exp = new Add(
@@ -205,19 +205,19 @@ public void AddPartialDerivativeTest2()
var deriv = Differentiate(exp, Variable.Y);
var expected = new Add(new Mul(Variable.X, Number.One), Number.One);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AddPartialDerivativeTest3()
{
var exp = new Add(Variable.X, Number.One);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void DivDerivativeTest1()
{
var exp = new Div(Number.One, Variable.X);
@@ -227,10 +227,10 @@ public void DivDerivativeTest1()
new Pow(Variable.X, Number.Two)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void DivDerivativeTest2()
{
// sin(x) / x
@@ -244,10 +244,10 @@ public void DivDerivativeTest2()
new Pow(Variable.X, Number.Two)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void DivPartialDerivativeTest1()
{
// (y + x ^ 2) / x
@@ -275,10 +275,10 @@ public void DivPartialDerivativeTest1()
new Pow(Variable.X, Number.Two)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void DivPartialDerivativeTest2()
{
var exp = new Div(Variable.Y, Variable.X);
@@ -288,40 +288,40 @@ public void DivPartialDerivativeTest2()
new Pow(Variable.X, Number.Two)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void DivPartialDerivativeTest3()
{
var exp = new Div(Variable.Y, Variable.X);
var deriv = Differentiate(exp, Variable.Y);
var expected = new Div(Number.One, Variable.X);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void DivPartialDerivativeTest4()
{
// (x + 1) / x
var exp = new Div(new Add(Variable.X, Number.One), Variable.X);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void ExpDerivativeTest1()
{
var exp = new Exp(Variable.X);
var deriv = Differentiate(exp);
var expected = new Mul(Number.One, new Exp(Variable.X));
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExpDerivativeTest2()
{
var exp = new Exp(new Mul(Number.Two, Variable.X));
@@ -331,10 +331,10 @@ public void ExpDerivativeTest2()
new Exp(new Mul(Number.Two, Variable.X))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExpPartialDerivativeTest1()
{
var exp = new Exp(new Mul(Variable.X, Variable.Y));
@@ -344,10 +344,10 @@ public void ExpPartialDerivativeTest1()
new Exp(new Mul(Variable.X, Variable.Y))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExpPartialDerivativeTest2()
{
var exp = new Exp(new Mul(Variable.X, Variable.Y));
@@ -357,19 +357,19 @@ public void ExpPartialDerivativeTest2()
new Exp(new Mul(Variable.X, Variable.Y))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExpPartialDerivativeTest3()
{
var exp = new Exp(Variable.X);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void LnDerivativeTest1()
{
var exp = new Ln(new Mul(Number.Two, Variable.X));
@@ -379,10 +379,10 @@ public void LnDerivativeTest1()
new Mul(Number.Two, Variable.X)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void LnPartialDerivativeTest1()
{
// ln(xy)
@@ -393,10 +393,10 @@ public void LnPartialDerivativeTest1()
new Mul(Variable.X, Variable.Y)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void LnPartialDerivativeTest2()
{
// ln(xy)
@@ -407,19 +407,19 @@ public void LnPartialDerivativeTest2()
new Mul(Variable.X, Variable.Y)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void LnPartialDerivativeTest3()
{
var exp = new Ln(Variable.Y);
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void LgDerivativeTest1()
{
var exp = new Lg(new Mul(Number.Two, Variable.X));
@@ -429,10 +429,10 @@ public void LgDerivativeTest1()
new Mul(new Mul(Number.Two, Variable.X), new Ln(new Number(10)))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void LgPartialDerivativeTest1()
{
// lg(2xy)
@@ -446,20 +446,20 @@ public void LgPartialDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void LgPartialDerivativeTest2()
{
// lg(2xy)
var exp = new Lg(Variable.X);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void LbDerivativeTest1()
{
var exp = new Lb(new Mul(Number.Two, Variable.X));
@@ -469,10 +469,10 @@ public void LbDerivativeTest1()
new Mul(new Mul(Number.Two, Variable.X), new Ln(Number.Two))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void LbPartialDerivativeTest1()
{
// lb(2xy)
@@ -486,30 +486,30 @@ public void LbPartialDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void LbPartialDerivativeTest2()
{
// lb(2xy)
var exp = new Lb(Variable.X);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void LogDerivativeTest1()
{
var exp = new Log(Number.Two, Variable.X);
var deriv = Differentiate(exp);
var expected = new Div(Number.One, new Mul(Variable.X, new Ln(Number.Two)));
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void LogDerivativeTest3()
{
var exp = new Log(Variable.X, Number.Two);
@@ -521,10 +521,10 @@ public void LogDerivativeTest3()
new Pow(new Ln(Variable.X), Number.Two)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void LogPartialDerivativeTest1()
{
var exp = new Log(Number.Two, Variable.X);
@@ -534,29 +534,29 @@ public void LogPartialDerivativeTest1()
new Mul(Variable.X, new Ln(Number.Two))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void LogPartialDerivativeTest2()
{
var exp = new Log(Number.Two, Variable.X);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void MulDerivativeTest1()
{
var exp = new Mul(Number.Two, Variable.X);
var deriv = Differentiate(exp);
var expected = new Mul(Number.Two, Number.One);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void MulPartialDerivativeTest1()
{
// (x + 1) * (y + x)
@@ -570,10 +570,10 @@ public void MulPartialDerivativeTest1()
new Mul(new Add(Variable.X, Number.One), Number.One)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void MulPartialDerivativeTest2()
{
// (y + 1) * (3 + x)
@@ -584,10 +584,10 @@ public void MulPartialDerivativeTest2()
var deriv = Differentiate(exp, Variable.Y);
var expected = new Mul(Number.One, new Add(new Number(3), Variable.X));
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void MulPartialDerivativeTest3()
{
// (x + 1) * (y + x)
@@ -598,10 +598,10 @@ public void MulPartialDerivativeTest3()
var deriv = Differentiate(exp, Variable.Y);
var expected = new Mul(new Add(Variable.X, Number.One), Number.One);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void MulPartialDerivativeTest4()
{
// (x + 1) * (3 + x)
@@ -611,10 +611,10 @@ public void MulPartialDerivativeTest4()
);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact(DisplayName = "x ^ 3")]
+ [Test]
public void PowDerivativeTest1()
{
var exp = new Pow(Variable.X, new Number(3));
@@ -624,10 +624,10 @@ public void PowDerivativeTest1()
new Mul(new Number(3), new Pow(Variable.X, new Sub(new Number(3), Number.One)))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact(DisplayName = "2 ^ (3x)")]
+ [Test]
public void PowDerivativeTest2()
{
var exp = new Pow(Number.Two, new Mul(new Number(3), Variable.X));
@@ -640,10 +640,10 @@ public void PowDerivativeTest2()
new Mul(new Number(3), Number.One)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact(DisplayName = "x ^ x")]
+ [Test]
public void PowXbyX()
{
var exp = new Pow(Variable.X, Variable.X);
@@ -655,10 +655,10 @@ public void PowXbyX()
new Mul(Variable.X, new Div(Number.One, Variable.X)))
);
- Assert.Equal(expected, result);
+ Assert.That(result, Is.EqualTo(expected));
}
- [Fact(DisplayName = "x ^ 2x")]
+ [Test]
public void PowXby2X()
{
var exp = new Pow(Variable.X, new Mul(Number.Two, Variable.X));
@@ -670,10 +670,10 @@ public void PowXby2X()
new Mul(new Mul(Number.Two, Variable.X), new Div(Number.One, Variable.X)))
);
- Assert.Equal(expected, result);
+ Assert.That(result, Is.EqualTo(expected));
}
- [Fact(DisplayName = "x ^ sin(x)")]
+ [Test]
public void PowXbySinX()
{
var exp = new Pow(Variable.X, new Sin(Variable.X));
@@ -686,10 +686,10 @@ public void PowXbySinX()
)
);
- Assert.Equal(expected, result);
+ Assert.That(result, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void PowPartialDerivativeTest1()
{
// (yx) ^ 3
@@ -706,10 +706,10 @@ public void PowPartialDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void PowPartialDerivativeTest2()
{
// (yx) ^ 3
@@ -726,19 +726,19 @@ public void PowPartialDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void PowPartialDerivativeTest3()
{
var exp = new Pow(Variable.X, new Number(3));
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void RootDerivativeTest1()
{
var exp = new Root(Variable.X, new Number(3));
@@ -754,10 +754,10 @@ public void RootDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void RootPartialDerivativeTest1()
{
var exp = new Root(new Mul(Variable.X, Variable.Y), new Number(3));
@@ -773,19 +773,19 @@ public void RootPartialDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void RootPartialDerivativeTest2()
{
var exp = new Root(Variable.Y, new Number(3));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void SqrtDerivativeTest1()
{
var exp = new Sqrt(new Mul(Number.Two, Variable.X));
@@ -795,10 +795,10 @@ public void SqrtDerivativeTest1()
new Mul(Number.Two, new Sqrt(new Mul(Number.Two, Variable.X)))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void SqrtPartialDerivativeTest1()
{
// sqrt(2xy)
@@ -816,19 +816,19 @@ public void SqrtPartialDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void SqrtPartialDerivativeTest2()
{
var exp = new Sqrt(Variable.Y);
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void SubDerivativeTest1()
{
// x - sin(x)
@@ -839,100 +839,100 @@ public void SubDerivativeTest1()
new Mul(new Cos(Variable.X), Number.One)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void SubPartialDerivativeTest1()
{
var exp = new Sub(new Mul(Variable.X, Variable.Y), Variable.Y);
var deriv = Differentiate(exp, Variable.Y);
var expected = new Sub(new Mul(Variable.X, Number.One), Number.One);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void SubPartialDerivativeTest2()
{
var exp = new Sub(Variable.X, Variable.Y);
var deriv = Differentiate(exp);
- Assert.Equal(Number.One, deriv);
+ Assert.That(deriv, Is.EqualTo(Number.One));
}
- [Fact]
+ [Test]
public void SubPartialDerivativeTest3()
{
var exp = new Sub(Variable.X, Variable.Y);
var deriv = Differentiate(exp, Variable.Y);
var expected = new UnaryMinus(Number.One);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void SubPartialDerivativeTest4()
{
var exp = new Sub(Variable.X, Number.One);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void UnaryMinusTest()
{
var exp = new UnaryMinus(new Sin(Variable.X));
var deriv = Differentiate(exp);
var expected = new UnaryMinus(new Mul(new Cos(Variable.X), Number.One));
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void UnaryMinusTest2()
{
var exp = new UnaryMinus(new Sin(new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void DiffVarTest()
{
var exp = new Mul(Variable.X, Variable.Y);
var deriv = Differentiate(exp);
var expected = new Mul(Number.One, Variable.Y);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void VarTest()
{
var exp = Variable.Y;
var deriv = Differentiate(exp);
- Assert.Equal(Variable.Y, deriv);
+ Assert.That(deriv, Is.EqualTo(Variable.Y));
}
#endregion Common
#region Trigonometric
- [Fact]
+ [Test]
public void SinDerivativeTest1()
{
var exp = new Sin(Variable.X);
var deriv = Differentiate(exp);
var expected = new Mul(new Cos(Variable.X), Number.One);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void SinDerivativeTest2()
{
var exp = new Sin(new Mul(Number.Two, Variable.X));
@@ -942,10 +942,10 @@ public void SinDerivativeTest2()
new Mul(Number.Two, Number.One)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void SinPartialDerivativeTest1()
{
var exp = new Sin(new Mul(Variable.X, Variable.Y));
@@ -955,10 +955,10 @@ public void SinPartialDerivativeTest1()
new Mul(Number.One, Variable.Y)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void SinPartialDerivativeTest2()
{
var exp = new Sin(new Mul(Variable.X, Variable.Y));
@@ -968,29 +968,29 @@ public void SinPartialDerivativeTest2()
new Mul(Variable.X, Number.One)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void SinPartialDerivativeTest3()
{
var exp = new Sin(Variable.Y);
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void CosDerivativeTest1()
{
var exp = new Cos(Variable.X);
var deriv = Differentiate(exp);
var expected = new UnaryMinus(new Mul(new Sin(Variable.X), Number.One));
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void CosDerivativeTest2()
{
var exp = new Cos(new Mul(Number.Two, Variable.X));
@@ -1002,10 +1002,10 @@ public void CosDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void CosPartialDerivativeTest1()
{
var exp = new Cos(new Mul(Variable.X, Variable.Y));
@@ -1017,10 +1017,10 @@ public void CosPartialDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void CosPartialDerivativeTest2()
{
var exp = new Cos(new Mul(Variable.X, Variable.Y));
@@ -1032,29 +1032,29 @@ public void CosPartialDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void CosPartialDerivativeTest3()
{
var exp = new Cos(Variable.X);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void TanDerivativeTest1()
{
var exp = new Tan(Variable.X);
var deriv = Differentiate(exp);
var expected = new Div(Number.One, new Pow(new Cos(Variable.X), Number.Two));
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void TanDerivativeTest2()
{
var exp = new Tan(new Mul(Number.Two, Variable.X));
@@ -1064,10 +1064,10 @@ public void TanDerivativeTest2()
new Pow(new Cos(new Mul(Number.Two, Variable.X)), Number.Two)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void TanPartialDerivativeTest1()
{
var exp = new Tan(new Mul(Variable.X, Variable.Y));
@@ -1077,10 +1077,10 @@ public void TanPartialDerivativeTest1()
new Pow(new Cos(new Mul(Variable.X, Variable.Y)), Number.Two)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void TanPartialDerivativeTest2()
{
var exp = new Tan(new Mul(Variable.X, Variable.Y));
@@ -1090,19 +1090,19 @@ public void TanPartialDerivativeTest2()
new Pow(new Cos(new Mul(Variable.X, Variable.Y)), Number.Two)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void TanPartialDerivativeTest3()
{
var exp = new Tan(Variable.X);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void CotDerivativeTest1()
{
var exp = new Cot(Variable.X);
@@ -1111,10 +1111,10 @@ public void CotDerivativeTest1()
new Div(Number.One, new Pow(new Sin(Variable.X), Number.Two))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void CotDerivativeTest2()
{
var exp = new Cot(new Mul(Number.Two, Variable.X));
@@ -1126,10 +1126,10 @@ public void CotDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void CotPartialDerivativeTest1()
{
var exp = new Cot(new Mul(Variable.X, Variable.Y));
@@ -1141,10 +1141,10 @@ public void CotPartialDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void CotPartialDerivativeTest2()
{
var exp = new Cot(new Mul(Variable.X, Variable.Y));
@@ -1156,19 +1156,19 @@ public void CotPartialDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void CotPartialDerivativeTest3()
{
var exp = new Cot(Variable.X);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void SecDerivativeTest1()
{
var exp = new Sec(new Mul(Number.Two, Variable.X));
@@ -1181,19 +1181,19 @@ public void SecDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void SecDerivativeZeroTest()
{
var exp = new Sec(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void CscDerivativeTest()
{
var exp = new Csc(new Mul(Number.Two, Variable.X));
@@ -1206,10 +1206,10 @@ public void CscDerivativeTest()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArcsinDerivativeTest1()
{
var exp = new Arcsin(Variable.X);
@@ -1219,10 +1219,10 @@ public void ArcsinDerivativeTest1()
new Sqrt(new Sub(Number.One, new Pow(Variable.X, Number.Two)))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArcsinDerivativeTest2()
{
var exp = new Arcsin(new Mul(Number.Two, Variable.X));
@@ -1237,10 +1237,10 @@ public void ArcsinDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArcsinPartialDerivativeTest1()
{
var exp = new Arcsin(new Mul(Variable.X, Variable.Y));
@@ -1255,10 +1255,10 @@ public void ArcsinPartialDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArcsinPartialDerivativeTest2()
{
var exp = new Arcsin(new Mul(Variable.X, Variable.Y));
@@ -1273,19 +1273,19 @@ public void ArcsinPartialDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArcsinPartialDerivativeTest3()
{
var exp = new Arcsin(Variable.X);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void ArccosDerivativeTest1()
{
var exp = new Arccos(Variable.X);
@@ -1297,10 +1297,10 @@ public void ArccosDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArccosDerivativeTest2()
{
var exp = new Arccos(new Mul(Number.Two, Variable.X));
@@ -1317,10 +1317,10 @@ public void ArccosDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArccosPartialDerivativeTest1()
{
var exp = new Arccos(new Mul(Variable.X, Variable.Y));
@@ -1337,10 +1337,10 @@ public void ArccosPartialDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArccosPartialDerivativeTest2()
{
var exp = new Arccos(new Mul(Variable.X, Variable.Y));
@@ -1356,19 +1356,19 @@ public void ArccosPartialDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArccosPartialDerivativeTest3()
{
var exp = new Arccos(Variable.X);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void ArctanDerivativeTest1()
{
var exp = new Arctan(Variable.X);
@@ -1378,10 +1378,10 @@ public void ArctanDerivativeTest1()
new Add(Number.One, new Pow(Variable.X, Number.Two))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArctanDerivativeTest2()
{
var exp = new Arctan(new Mul(Number.Two, Variable.X));
@@ -1394,10 +1394,10 @@ public void ArctanDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArctanPartialDerivativeTest1()
{
var exp = new Arctan(new Mul(Variable.X, Variable.Y));
@@ -1410,10 +1410,10 @@ public void ArctanPartialDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArctanPartialDerivativeTest2()
{
var exp = new Arctan(new Mul(Variable.X, Variable.Y));
@@ -1426,19 +1426,19 @@ public void ArctanPartialDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArctanPartialDerivativeTest3()
{
var exp = new Arctan(Variable.X);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void ArccotDerivativeTest1()
{
var exp = new Arccot(Variable.X);
@@ -1450,10 +1450,10 @@ public void ArccotDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArccotDerivativeTest2()
{
var exp = new Arccot(new Mul(Number.Two, Variable.X));
@@ -1468,10 +1468,10 @@ public void ArccotDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArccotPartialDerivativeTest1()
{
var exp = new Arccot(new Mul(Variable.X, Variable.Y));
@@ -1484,10 +1484,10 @@ public void ArccotPartialDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArccotPartialDerivativeTest2()
{
var exp = new Arccot(new Mul(Variable.X, Variable.Y));
@@ -1502,19 +1502,19 @@ public void ArccotPartialDerivativeTest2()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArccotPartialDerivativeTest3()
{
var exp = new Arccot(Variable.X);
var deriv = Differentiate(exp, Variable.Y);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void ArcsecDerivativeTest1()
{
var exp = new Arcsec(new Mul(Number.Two, Variable.X));
@@ -1532,19 +1532,19 @@ public void ArcsecDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArcsecDerivativeZeroTest()
{
var exp = new Arcsec(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void ArccscDerivativeTest1()
{
var exp = new Arccsc(new Mul(Number.Two, Variable.X));
@@ -1563,23 +1563,23 @@ public void ArccscDerivativeTest1()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArccscDerivativeZeroTest()
{
var exp = new Arccsc(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
#endregion Trigonometric
#region Hyperbolic
- [Fact]
+ [Test]
public void SinhDerivativeTest()
{
var exp = new Sinh(new Mul(Number.Two, Variable.X));
@@ -1589,19 +1589,19 @@ public void SinhDerivativeTest()
new Cosh(new Mul(Number.Two, Variable.X))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void SinhDerivativeZeroTest()
{
var exp = new Sinh(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void CoshDerivativeTest()
{
var exp = new Cosh(new Mul(Number.Two, Variable.X));
@@ -1611,19 +1611,19 @@ public void CoshDerivativeTest()
new Sinh(new Mul(Number.Two, Variable.X))
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void CoshDerivativeZeroTest()
{
var exp = new Cosh(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void TanhDerivativeTest()
{
var exp = new Tanh(new Mul(Number.Two, Variable.X));
@@ -1633,19 +1633,19 @@ public void TanhDerivativeTest()
new Pow(new Cosh(new Mul(Number.Two, Variable.X)), Number.Two)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void TanhDerivativeZeroTest()
{
var exp = new Tanh(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void CothDerivativeTest()
{
var exp = new Coth(new Mul(Number.Two, Variable.X));
@@ -1657,19 +1657,19 @@ public void CothDerivativeTest()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void CothDerivativeZeroTest()
{
var exp = new Coth(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void SechDerivativeTest()
{
var exp = new Sech(new Mul(Number.Two, Variable.X));
@@ -1684,19 +1684,19 @@ public void SechDerivativeTest()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void SechDerivativeZeroTest()
{
var exp = new Sech(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void CschDerivativeTest()
{
var exp = new Csch(new Mul(Number.Two, Variable.X));
@@ -1711,19 +1711,19 @@ public void CschDerivativeTest()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void CschDerivativeZeroTest()
{
var exp = new Csch(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void ArsinehDerivativeTest()
{
var exp = new Arsinh(new Mul(Number.Two, Variable.X));
@@ -1738,19 +1738,19 @@ public void ArsinehDerivativeTest()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArsinehDerivativeZeroTest()
{
var exp = new Arsinh(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void ArcoshDerivativeTest()
{
var exp = new Arcosh(new Mul(Number.Two, Variable.X));
@@ -1765,19 +1765,19 @@ public void ArcoshDerivativeTest()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArcoshDerivativeZeroTest()
{
var exp = new Arcosh(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void ArtanhDerivativeTest()
{
var exp = new Artanh(new Mul(Number.Two, Variable.X));
@@ -1790,19 +1790,19 @@ public void ArtanhDerivativeTest()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArtanhDerivativeZeroTest()
{
var exp = new Artanh(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void ArcothDerivativeTest()
{
var exp = new Arcoth(new Mul(Number.Two, Variable.X));
@@ -1815,19 +1815,19 @@ public void ArcothDerivativeTest()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArcothDerivativeZeroTest()
{
var exp = new Arcoth(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void ArsechDerivativeTest()
{
var exp = new Arsech(new Mul(Number.Two, Variable.X));
@@ -1847,10 +1847,10 @@ public void ArsechDerivativeTest()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArcschDerivativeTest()
{
var exp = new Arcsch(new Mul(Number.Two, Variable.X));
@@ -1870,21 +1870,21 @@ public void ArcschDerivativeTest()
)
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ArcschDerivativeZeroTest()
{
var exp = new Arcsch(new Mul(Number.Two, new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
#endregion Hyperbolic
- [Fact]
+ [Test]
public void DerivSimplify()
{
var simp = new Simplifier();
@@ -1892,20 +1892,20 @@ public void DerivSimplify()
var deriv = Differentiate(exp);
var expected = new Mul(new Cos(Variable.X), Number.One);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void DerivSimplify2()
{
var simp = new Simplifier();
var exp = new Simplify(simp, new Sin(new Variable("z")));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void DoubleDiffTest()
{
var diff = new Differentiator();
@@ -1925,10 +1925,10 @@ public void DoubleDiffTest()
new UnaryMinus(new Mul(new Sin(Variable.X), Number.One)), Number.One
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void DoubleDiffNoVarTest()
{
var diff = new Differentiator();
@@ -1937,10 +1937,10 @@ public void DoubleDiffNoVarTest()
var exp = new Derivative(diff, simp, new Derivative(diff, simp, new Sin(Number.One)));
var deriv = Differentiate(exp);
- Assert.Equal(zero, deriv);
+ Assert.That(deriv, Is.EqualTo(zero));
}
- [Fact]
+ [Test]
public void TripleDiffTest()
{
var diff = new Differentiator();
@@ -1967,10 +1967,10 @@ public void TripleDiffTest()
Number.One
);
- Assert.Equal(expected, deriv);
+ Assert.That(deriv, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void NotSupportedTest()
{
Assert.Throws(() => Differentiate(new Fact(Variable.X)));
diff --git a/xFunc.Tests/Analyzers/DifferentiatorTests/NullArgumentTest.cs b/xFunc.Tests/Analyzers/DifferentiatorTests/NullArgumentTest.cs
index 0e23bed51..6f59c1d26 100644
--- a/xFunc.Tests/Analyzers/DifferentiatorTests/NullArgumentTest.cs
+++ b/xFunc.Tests/Analyzers/DifferentiatorTests/NullArgumentTest.cs
@@ -3,7 +3,7 @@
using System.Collections.Immutable;
using System.Reflection;
-using Xunit.Sdk;
+using NUnit.Framework.Internal;
namespace xFunc.Tests.Analyzers.DifferentiatorTests;
@@ -31,88 +31,88 @@ private void TestNullExp(Type type, object exp = null)
throw;
}
- throw new XunitException("The exception is expected.");
+ throw new NUnitException("The exception is expected.");
}
- [Theory]
- [InlineData(typeof(Abs))]
- [InlineData(typeof(Add))]
- [InlineData(typeof(Derivative))]
- [InlineData(typeof(Div))]
- [InlineData(typeof(Exp))]
- [InlineData(typeof(Lb))]
- [InlineData(typeof(Lg))]
- [InlineData(typeof(Ln))]
- [InlineData(typeof(Log))]
- [InlineData(typeof(Mul))]
- [InlineData(typeof(Number))]
- [InlineData(typeof(Angle))]
- [InlineData(typeof(Pow))]
- [InlineData(typeof(Root))]
- [InlineData(typeof(Simplify))]
- [InlineData(typeof(Sqrt))]
- [InlineData(typeof(Sub))]
- [InlineData(typeof(UnaryMinus))]
- [InlineData(typeof(Variable))]
- [InlineData(typeof(Arccos))]
- [InlineData(typeof(Arccot))]
- [InlineData(typeof(Arccsc))]
- [InlineData(typeof(Arcsec))]
- [InlineData(typeof(Arcsin))]
- [InlineData(typeof(Arctan))]
- [InlineData(typeof(Cos))]
- [InlineData(typeof(Cot))]
- [InlineData(typeof(Csc))]
- [InlineData(typeof(Sec))]
- [InlineData(typeof(Sin))]
- [InlineData(typeof(Tan))]
- [InlineData(typeof(Arcosh))]
- [InlineData(typeof(Arcoth))]
- [InlineData(typeof(Arcsch))]
- [InlineData(typeof(Arsech))]
- [InlineData(typeof(Arsinh))]
- [InlineData(typeof(Artanh))]
- [InlineData(typeof(Cosh))]
- [InlineData(typeof(Coth))]
- [InlineData(typeof(Csch))]
- [InlineData(typeof(Sech))]
- [InlineData(typeof(Sinh))]
- [InlineData(typeof(Tanh))]
+ [Test]
+ [TestCase(typeof(Abs))]
+ [TestCase(typeof(Add))]
+ [TestCase(typeof(Derivative))]
+ [TestCase(typeof(Div))]
+ [TestCase(typeof(Exp))]
+ [TestCase(typeof(Lb))]
+ [TestCase(typeof(Lg))]
+ [TestCase(typeof(Ln))]
+ [TestCase(typeof(Log))]
+ [TestCase(typeof(Mul))]
+ [TestCase(typeof(Number))]
+ [TestCase(typeof(Angle))]
+ [TestCase(typeof(Pow))]
+ [TestCase(typeof(Root))]
+ [TestCase(typeof(Simplify))]
+ [TestCase(typeof(Sqrt))]
+ [TestCase(typeof(Sub))]
+ [TestCase(typeof(UnaryMinus))]
+ [TestCase(typeof(Variable))]
+ [TestCase(typeof(Arccos))]
+ [TestCase(typeof(Arccot))]
+ [TestCase(typeof(Arccsc))]
+ [TestCase(typeof(Arcsec))]
+ [TestCase(typeof(Arcsin))]
+ [TestCase(typeof(Arctan))]
+ [TestCase(typeof(Cos))]
+ [TestCase(typeof(Cot))]
+ [TestCase(typeof(Csc))]
+ [TestCase(typeof(Sec))]
+ [TestCase(typeof(Sin))]
+ [TestCase(typeof(Tan))]
+ [TestCase(typeof(Arcosh))]
+ [TestCase(typeof(Arcoth))]
+ [TestCase(typeof(Arcsch))]
+ [TestCase(typeof(Arsech))]
+ [TestCase(typeof(Arsinh))]
+ [TestCase(typeof(Artanh))]
+ [TestCase(typeof(Cosh))]
+ [TestCase(typeof(Coth))]
+ [TestCase(typeof(Csch))]
+ [TestCase(typeof(Sech))]
+ [TestCase(typeof(Sinh))]
+ [TestCase(typeof(Tanh))]
public void TestExpressionNullArgument(Type type)
=> TestNullExp(type);
- [Theory]
- [InlineData(typeof(Abs))]
- [InlineData(typeof(Exp))]
- [InlineData(typeof(Lb))]
- [InlineData(typeof(Lg))]
- [InlineData(typeof(Ln))]
- [InlineData(typeof(Sqrt))]
- [InlineData(typeof(UnaryMinus))]
- [InlineData(typeof(Arccos))]
- [InlineData(typeof(Arccot))]
- [InlineData(typeof(Arccsc))]
- [InlineData(typeof(Arcsec))]
- [InlineData(typeof(Arcsin))]
- [InlineData(typeof(Arctan))]
- [InlineData(typeof(Cos))]
- [InlineData(typeof(Cot))]
- [InlineData(typeof(Csc))]
- [InlineData(typeof(Sec))]
- [InlineData(typeof(Sin))]
- [InlineData(typeof(Tan))]
- [InlineData(typeof(Arcosh))]
- [InlineData(typeof(Arcoth))]
- [InlineData(typeof(Arcsch))]
- [InlineData(typeof(Arsech))]
- [InlineData(typeof(Arsinh))]
- [InlineData(typeof(Artanh))]
- [InlineData(typeof(Cosh))]
- [InlineData(typeof(Coth))]
- [InlineData(typeof(Csch))]
- [InlineData(typeof(Sech))]
- [InlineData(typeof(Sinh))]
- [InlineData(typeof(Tanh))]
+ [Test]
+ [TestCase(typeof(Abs))]
+ [TestCase(typeof(Exp))]
+ [TestCase(typeof(Lb))]
+ [TestCase(typeof(Lg))]
+ [TestCase(typeof(Ln))]
+ [TestCase(typeof(Sqrt))]
+ [TestCase(typeof(UnaryMinus))]
+ [TestCase(typeof(Arccos))]
+ [TestCase(typeof(Arccot))]
+ [TestCase(typeof(Arccsc))]
+ [TestCase(typeof(Arcsec))]
+ [TestCase(typeof(Arcsin))]
+ [TestCase(typeof(Arctan))]
+ [TestCase(typeof(Cos))]
+ [TestCase(typeof(Cot))]
+ [TestCase(typeof(Csc))]
+ [TestCase(typeof(Sec))]
+ [TestCase(typeof(Sin))]
+ [TestCase(typeof(Tan))]
+ [TestCase(typeof(Arcosh))]
+ [TestCase(typeof(Arcoth))]
+ [TestCase(typeof(Arcsch))]
+ [TestCase(typeof(Arsech))]
+ [TestCase(typeof(Arsinh))]
+ [TestCase(typeof(Artanh))]
+ [TestCase(typeof(Cosh))]
+ [TestCase(typeof(Coth))]
+ [TestCase(typeof(Csch))]
+ [TestCase(typeof(Sech))]
+ [TestCase(typeof(Sinh))]
+ [TestCase(typeof(Tanh))]
public void TestUnaryContextNullArgument(Type type)
{
var exp = Create(type, Variable.X);
@@ -120,14 +120,14 @@ public void TestUnaryContextNullArgument(Type type)
Assert.Throws(() => exp.Analyze(differentiator, null));
}
- [Theory]
- [InlineData(typeof(Add))]
- [InlineData(typeof(Div))]
- [InlineData(typeof(Log))]
- [InlineData(typeof(Mul))]
- [InlineData(typeof(Pow))]
- [InlineData(typeof(Root))]
- [InlineData(typeof(Sub))]
+ [Test]
+ [TestCase(typeof(Add))]
+ [TestCase(typeof(Div))]
+ [TestCase(typeof(Log))]
+ [TestCase(typeof(Mul))]
+ [TestCase(typeof(Pow))]
+ [TestCase(typeof(Root))]
+ [TestCase(typeof(Sub))]
public void TestBinaryContextNullArgument(Type type)
{
var exp = Create(type, Variable.X, Variable.X);
@@ -135,7 +135,7 @@ public void TestBinaryContextNullArgument(Type type)
Assert.Throws(() => exp.Analyze(differentiator, null));
}
- [Fact]
+ [Test]
public void DerivContextArgumentTest()
{
var exp = new Derivative(differentiator, new Simplifier(), Variable.X);
@@ -143,7 +143,7 @@ public void DerivContextArgumentTest()
Assert.Throws(() => differentiator.Analyze(exp, null));
}
- [Fact]
+ [Test]
public void NumberContextArgumentTest()
{
var exp = Number.One;
@@ -151,7 +151,7 @@ public void NumberContextArgumentTest()
Assert.Throws(() => differentiator.Analyze(exp, null));
}
- [Fact]
+ [Test]
public void AngleContextArgumentTest()
{
var exp = AngleValue.Degree(10).AsExpression();
@@ -159,7 +159,7 @@ public void AngleContextArgumentTest()
Assert.Throws(() => differentiator.Analyze(exp, null));
}
- [Fact]
+ [Test]
public void SimplifyContextArgumentTest()
{
var exp = new Simplify(new Simplifier(), Variable.X);
@@ -167,7 +167,7 @@ public void SimplifyContextArgumentTest()
Assert.Throws(() => differentiator.Analyze(exp, null));
}
- [Fact]
+ [Test]
public void VariableContextArgumentTest()
{
var exp = Variable.X;
@@ -175,7 +175,7 @@ public void VariableContextArgumentTest()
Assert.Throws(() => differentiator.Analyze(exp, null));
}
- [Fact]
+ [Test]
public void CallExpressionContextNullArgument()
{
var exp = new CallExpression(
@@ -185,7 +185,7 @@ public void CallExpressionContextNullArgument()
Assert.Throws(() => exp.Analyze(differentiator, null));
}
- [Fact]
+ [Test]
public void LambdaExpressionContextNullArgument()
{
var exp = Variable.X.ToLambdaExpression(Variable.X.Name);
diff --git a/xFunc.Tests/Analyzers/Formatters/CommonFormatterTest.cs b/xFunc.Tests/Analyzers/Formatters/CommonFormatterTest.cs
index c93832e1e..da5166d0d 100644
--- a/xFunc.Tests/Analyzers/Formatters/CommonFormatterTest.cs
+++ b/xFunc.Tests/Analyzers/Formatters/CommonFormatterTest.cs
@@ -11,47 +11,47 @@ public class CommonFormatterTest
{
#region Common
- [Fact]
+ [Test]
public void AbsToStringTest()
{
var exp = new Abs(new Number(5));
- Assert.Equal("abs(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("abs(5)"));
}
- [Fact]
+ [Test]
public void AddToStringTest()
{
var exp = new Add(new Number(5), Number.Zero);
- Assert.Equal("5 + 0", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5 + 0"));
}
- [Fact]
+ [Test]
public void AddToStringBinTest()
{
var exp = new Mul(Variable.X, new Add(new Number(5), Number.Zero));
- Assert.Equal("x * (5 + 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x * (5 + 0)"));
}
- [Fact]
+ [Test]
public void CeilToStringTest()
{
var ceil = new Ceil(new Number(5.55555555));
- Assert.Equal("ceil(5.55555555)", ceil.ToString());
+ Assert.That(ceil.ToString(), Is.EqualTo("ceil(5.55555555)"));
}
- [Fact]
+ [Test]
public void DefineToStringTest()
{
var exp = new Assign(Variable.X, Number.Zero);
- Assert.Equal("x := 0", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x := 0"));
}
- [Fact]
+ [Test]
public void DelToStringTest()
{
var exp = new Del(
@@ -66,487 +66,487 @@ public void DelToStringTest()
)
);
- Assert.Equal("del(((2 * x1) + (x2 ^ 2)) + (x3 ^ 3))", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("del(((2 * x1) + (x2 ^ 2)) + (x3 ^ 3))"));
}
- [Fact]
+ [Test]
public void DerivativeToStringExpTest()
{
var deriv = new Derivative(new Differentiator(), new Simplifier(), new Sin(Variable.X));
- Assert.Equal("deriv(sin(x))", deriv.ToString());
+ Assert.That(deriv.ToString(), Is.EqualTo("deriv(sin(x))"));
}
- [Fact]
+ [Test]
public void DerivativeToStringVarTest()
{
var deriv = new Derivative(new Differentiator(), new Simplifier(), new Sin(Variable.X), Variable.X);
- Assert.Equal("deriv(sin(x), x)", deriv.ToString());
+ Assert.That(deriv.ToString(), Is.EqualTo("deriv(sin(x), x)"));
}
- [Fact]
+ [Test]
public void DerivativeToStringPointTest()
{
var deriv = new Derivative(new Differentiator(), new Simplifier(), new Sin(Variable.X), Variable.X, Number.One);
- Assert.Equal("deriv(sin(x), x, 1)", deriv.ToString());
+ Assert.That(deriv.ToString(), Is.EqualTo("deriv(sin(x), x, 1)"));
}
- [Fact]
+ [Test]
public void DivToStringTest()
{
var exp = new Div(new Number(5), Number.Zero);
- Assert.Equal("5 / 0", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5 / 0"));
}
- [Fact]
+ [Test]
public void DivToStringBinTest()
{
var exp = new Mul(Variable.X, new Div(new Number(5), Number.Zero));
- Assert.Equal("x * (5 / 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x * (5 / 0)"));
}
- [Fact]
+ [Test]
public void ExpToStringTest()
{
var exp = new Exp(new Number(5));
- Assert.Equal("exp(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("exp(5)"));
}
- [Fact]
+ [Test]
public void FactToStringTest()
{
var exp = new Fact(new Number(5));
- Assert.Equal("5!", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5!"));
}
- [Fact]
+ [Test]
public void FloorToStringTest()
{
var exp = new Floor(new Number(5.55555555));
- Assert.Equal("floor(5.55555555)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("floor(5.55555555)"));
}
- [Fact]
+ [Test]
public void TruncToStringTest()
{
var exp = new Trunc(new Number(5.55555555));
- Assert.Equal("trunc(5.55555555)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("trunc(5.55555555)"));
}
- [Fact]
+ [Test]
public void FracToStringTest()
{
var exp = new Frac(new Number(5.55555555));
- Assert.Equal("frac(5.55555555)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("frac(5.55555555)"));
}
- [Fact]
+ [Test]
public void GCDToStringTest()
{
var exp = new GCD(new Number(5), Number.Zero);
- Assert.Equal("gcd(5, 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("gcd(5, 0)"));
}
- [Fact]
+ [Test]
public void LCMToStringTest()
{
var exp = new LCM(new Number(5), Number.Zero);
- Assert.Equal("lcm(5, 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("lcm(5, 0)"));
}
- [Fact]
+ [Test]
public void LbToStringTest()
{
var exp = new Lb(new Number(5));
- Assert.Equal("lb(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("lb(5)"));
}
- [Fact]
+ [Test]
public void LgToStringTest()
{
var exp = new Lg(new Number(5));
- Assert.Equal("lg(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("lg(5)"));
}
- [Fact]
+ [Test]
public void LnToStringTest()
{
var exp = new Ln(new Number(5));
- Assert.Equal("ln(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("ln(5)"));
}
- [Fact]
+ [Test]
public void LogToStringTest()
{
var exp = new Log(Number.Zero, new Number(5));
- Assert.Equal("log(0, 5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("log(0, 5)"));
}
- [Fact]
+ [Test]
public void ModToStringTest()
{
var exp = new Mod(new Number(5), Number.Zero);
- Assert.Equal("5 % 0", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5 % 0"));
}
- [Fact]
+ [Test]
public void ModToStringBinTest()
{
var exp = new Mul(Variable.X, new Mod(new Number(5), Number.Zero));
- Assert.Equal("x * (5 % 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x * (5 % 0)"));
}
- [Fact]
+ [Test]
public void MulToStringTest()
{
var exp = new Mul(new Number(5), Number.Zero);
- Assert.Equal("5 * 0", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5 * 0"));
}
- [Fact]
+ [Test]
public void MulToStringAddTest()
{
var exp = new Add(Variable.X, new Mul(new Number(5), Number.Zero));
- Assert.Equal("x + (5 * 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x + (5 * 0)"));
}
- [Fact]
+ [Test]
public void MulToStringSubTest()
{
var exp = new Sub(Variable.X, new Mul(new Number(5), Number.Zero));
- Assert.Equal("x - (5 * 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x - (5 * 0)"));
}
- [Fact]
+ [Test]
public void MulToStringMulTest()
{
var exp = new Mul(Variable.X, new Mul(new Number(5), Number.Zero));
- Assert.Equal("x * (5 * 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x * (5 * 0)"));
}
- [Fact]
+ [Test]
public void MulToStringDivTest()
{
var exp = new Div(Variable.X, new Mul(new Number(5), Number.Zero));
- Assert.Equal("x / (5 * 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x / (5 * 0)"));
}
- [Fact]
+ [Test]
public void NumberTest()
{
var exp = new Number(3.3);
- Assert.Equal("3.3", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("3.3"));
}
- [Fact]
+ [Test]
public void AngleNumberTest()
{
var exp = AngleValue.Degree(10).AsExpression();
- Assert.Equal("10 degree", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("10 degree"));
}
- [Fact]
+ [Test]
public void PowerNumberTest()
{
var exp = PowerValue.Watt(10).AsExpression();
- Assert.Equal("10 W", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("10 W"));
}
- [Fact]
+ [Test]
public void TemperatureNumberTest()
{
var exp = TemperatureValue.Celsius(10).AsExpression();
- Assert.Equal("10 °C", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("10 °C"));
}
- [Fact]
+ [Test]
public void MassNumberTest()
{
var exp = MassValue.Gram(10).AsExpression();
- Assert.Equal("10 g", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("10 g"));
}
- [Fact]
+ [Test]
public void LengthNumberTest()
{
var exp = LengthValue.Meter(10).AsExpression();
- Assert.Equal("10 m", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("10 m"));
}
- [Fact]
+ [Test]
public void TimeNumberTest()
{
var exp = TimeValue.Second(10).AsExpression();
- Assert.Equal("10 s", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("10 s"));
}
- [Fact]
+ [Test]
public void AreaNumberTest()
{
var exp = AreaValue.Meter(10).AsExpression();
- Assert.Equal("10 m^2", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("10 m^2"));
}
- [Fact]
+ [Test]
public void VolumeNumberTest()
{
var exp = VolumeValue.Meter(10).AsExpression();
- Assert.Equal("10 m^3", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("10 m^3"));
}
- [Fact]
+ [Test]
public void ToDegreeTest()
{
var exp = new ToDegree(new Number(10));
- Assert.Equal("todegree(10)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("todegree(10)"));
}
- [Fact]
+ [Test]
public void ToRadianTest()
{
var exp = new ToRadian(new Number(10));
- Assert.Equal("toradian(10)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("toradian(10)"));
}
- [Fact]
+ [Test]
public void ToGradianTest()
{
var exp = new ToGradian(new Number(10));
- Assert.Equal("togradian(10)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("togradian(10)"));
}
- [Fact]
+ [Test]
public void ToNumberTest()
{
var exp = new ToNumber(AngleValue.Degree(10).AsExpression());
- Assert.Equal("tonumber(10 degree)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("tonumber(10 degree)"));
}
- [Fact]
+ [Test]
public void NumberSubTest()
{
var exp = new Sub(Number.One, new Number(-3.3));
- Assert.Equal("1 - -3.3", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("1 - -3.3"));
}
- [Fact]
+ [Test]
public void PowToStringTest()
{
var exp = new Pow(new Number(5), Number.Zero);
- Assert.Equal("5 ^ 0", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5 ^ 0"));
}
- [Fact]
+ [Test]
public void PowToStringAddTest()
{
var exp = new Add(Variable.X, new Pow(new Number(5), Number.Zero));
- Assert.Equal("x + (5 ^ 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x + (5 ^ 0)"));
}
- [Fact]
+ [Test]
public void PowToStringSubTest()
{
var exp = new Sub(Variable.X, new Pow(new Number(5), Number.Zero));
- Assert.Equal("x - (5 ^ 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x - (5 ^ 0)"));
}
- [Fact]
+ [Test]
public void PowToStringMulTest()
{
var exp = new Mul(Variable.X, new Pow(new Number(5), Number.Zero));
- Assert.Equal("x * (5 ^ 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x * (5 ^ 0)"));
}
- [Fact]
+ [Test]
public void PowToStringDivTest()
{
var exp = new Div(Variable.X, new Pow(new Number(5), Number.Zero));
- Assert.Equal("x / (5 ^ 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x / (5 ^ 0)"));
}
- [Fact]
+ [Test]
public void RootToStringTest()
{
var exp = new Root(new Number(5), Number.Zero);
- Assert.Equal("root(5, 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("root(5, 0)"));
}
- [Fact]
+ [Test]
public void RoundToStringTest()
{
var exp = new Round(new Number(5), Number.Zero);
- Assert.Equal("round(5, 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("round(5, 0)"));
}
- [Fact]
+ [Test]
public void SimplifyToStringTest()
{
var exp = new Simplify(new Simplifier(), new Sin(Variable.X));
- Assert.Equal("simplify(sin(x))", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("simplify(sin(x))"));
}
- [Fact]
+ [Test]
public void SqrtToStringTest()
{
var exp = new Sqrt(new Number(5));
- Assert.Equal("sqrt(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("sqrt(5)"));
}
- [Fact]
+ [Test]
public void SubToStringTest()
{
var exp = new Sub(new Number(5), Number.Zero);
- Assert.Equal("5 - 0", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5 - 0"));
}
- [Fact]
+ [Test]
public void SubToStringSubTest()
{
var exp = new Sub(Variable.X, new Sub(new Number(5), Number.Zero));
- Assert.Equal("x - (5 - 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x - (5 - 0)"));
}
- [Fact]
+ [Test]
public void SubToStringDivTest()
{
var exp = new Div(Variable.X, new Sub(new Number(5), Number.Zero));
- Assert.Equal("x / (5 - 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x / (5 - 0)"));
}
- [Fact]
+ [Test]
public void UnaryMinusToStringTest()
{
var exp = new UnaryMinus(new Number(5));
- Assert.Equal("-5", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("-5"));
}
- [Fact]
+ [Test]
public void UnaryMinusToStringBinTest()
{
var exp = new UnaryMinus(new Add(new Number(5), Number.Zero));
- Assert.Equal("-(5 + 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("-(5 + 0)"));
}
- [Fact]
+ [Test]
public void UnaryMinusToStringSubTest()
{
var exp = new Sub(Number.Zero, new UnaryMinus(new Number(5)));
- Assert.Equal("0 - -5", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("0 - -5"));
}
- [Fact]
+ [Test]
public void UndefineToStringTest()
{
var exp = new Unassign(Variable.X);
- Assert.Equal("undef(x)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("undef(x)"));
}
- [Fact]
+ [Test]
public void LambdaExpressionToStringArgTest()
{
var exp = new Add(Variable.X, Variable.Y)
.ToLambdaExpression(Variable.X, Variable.Y);
- Assert.Equal("(x, y) => x + y", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("(x, y) => x + y"));
}
- [Fact]
+ [Test]
public void CallExpressionToStringArgTest()
{
var exp = new CallExpression(
new Variable("f"),
new IExpression[] { new Number(5), Number.Two }.ToImmutableArray());
- Assert.Equal("f(5, 2)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("f(5, 2)"));
}
- [Fact]
+ [Test]
public void InlineCallExpressionToStringArgTest()
{
var exp = new CallExpression(
Variable.X.ToLambdaExpression(Variable.X.Name),
new IExpression[] { new Number(5) }.ToImmutableArray());
- Assert.Equal("((x) => x)(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("((x) => x)(5)"));
}
- [Fact]
+ [Test]
public void VariableTest()
{
var exp = Variable.X;
- Assert.Equal("x", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x"));
}
- [Fact]
+ [Test]
public void DelegateExpressionTest()
{
- var exp = new DelegateExpression(param => 0d);
+ var exp = new DelegateExpression(_ => 0d);
- Assert.Equal("{Delegate Expression}", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("{Delegate Expression}"));
}
- [Fact]
+ [Test]
public void StringExpressionTest()
{
var exp = new StringExpression("hello");
- Assert.Equal("'hello'", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("'hello'"));
}
- [Fact]
+ [Test]
public void ConvertTest()
{
var exp = new xFunc.Maths.Expressions.Units.Convert(
@@ -555,491 +555,491 @@ public void ConvertTest()
new StringExpression("rad")
);
- Assert.Equal("convert(90 degree, 'rad')", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("convert(90 degree, 'rad')"));
}
- [Fact]
+ [Test]
public void RationalTest()
{
var exp = new Rational(Number.One, Number.Two);
- Assert.Equal("1 // 2", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("1 // 2"));
}
- [Fact]
+ [Test]
public void ToRationalTest()
{
var exp = new ToRational(Number.Two);
- Assert.Equal("torational(2)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("torational(2)"));
}
#endregion Common
#region Complex Numbers
- [Fact]
+ [Test]
public void ComplexNumberPositiveNegativeToStringTest()
{
var complex = new ComplexNumber(3, -2);
- Assert.Equal("3-2i", complex.ToString());
+ Assert.That(complex.ToString(), Is.EqualTo("3-2i"));
}
- [Fact]
+ [Test]
public void ComplexNumberNegativePositiveToStringTest()
{
var complex = new ComplexNumber(-3, 2);
- Assert.Equal("-3+2i", complex.ToString());
+ Assert.That(complex.ToString(), Is.EqualTo("-3+2i"));
}
- [Fact]
+ [Test]
public void ComplexNumberTwoPositiveToStringTest()
{
var complex = new ComplexNumber(3, 2);
- Assert.Equal("3+2i", complex.ToString());
+ Assert.That(complex.ToString(), Is.EqualTo("3+2i"));
}
- [Fact]
+ [Test]
public void ComplexNumberTwoNegativeToStringTest()
{
var complex = new ComplexNumber(-3, -2);
- Assert.Equal("-3-2i", complex.ToString());
+ Assert.That(complex.ToString(), Is.EqualTo("-3-2i"));
}
- [Fact]
+ [Test]
public void ComplexNumberOnlyRealPartToStringTest()
{
var complex = new ComplexNumber(-3, 0);
- Assert.Equal("-3", complex.ToString());
+ Assert.That(complex.ToString(), Is.EqualTo("-3"));
}
- [Fact]
+ [Test]
public void ComplexNumberOnlyImaginaryPartToStringTest()
{
var complex = new ComplexNumber(0, -2);
- Assert.Equal("-2i", complex.ToString());
+ Assert.That(complex.ToString(), Is.EqualTo("-2i"));
}
- [Fact]
+ [Test]
public void ComplexNumberBinaryToStringTest()
{
var exp = new Add(new ComplexNumber(3, 2), new ComplexNumber(3, 2));
- Assert.Equal("3+2i + 3+2i", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("3+2i + 3+2i"));
}
- [Fact]
+ [Test]
public void ComplexNumberAbsToStringTest()
{
var exp = new Abs(new ComplexNumber(3, 2));
- Assert.Equal("abs(3+2i)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("abs(3+2i)"));
}
- [Fact]
+ [Test]
public void ComplexNumberIToStringTest()
{
var exp = new ComplexNumber(0, 1);
- Assert.Equal("i", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("i"));
}
- [Fact]
+ [Test]
public void ComplexNumberNegativeIToStringTest()
{
var exp = new ComplexNumber(0, -1);
- Assert.Equal("-i", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("-i"));
}
- [Fact]
+ [Test]
public void ConjugateToStringTest()
{
var complex = new Complex(3.1, 2.5);
var exp = new Conjugate(new ComplexNumber(complex));
- Assert.Equal("conjugate(3.1+2.5i)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("conjugate(3.1+2.5i)"));
}
- [Fact]
+ [Test]
public void ImToStringTest()
{
var complex = new Complex(3.1, 2.5);
var exp = new Im(new ComplexNumber(complex));
- Assert.Equal("im(3.1+2.5i)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("im(3.1+2.5i)"));
}
- [Fact]
+ [Test]
public void PhaseToStringTest()
{
var complex = new Complex(3.1, 2.5);
var exp = new Phase(new ComplexNumber(complex));
- Assert.Equal("phase(3.1+2.5i)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("phase(3.1+2.5i)"));
}
- [Fact]
+ [Test]
public void ReciprocalToStringTest()
{
var complex = new Complex(3.1, 2.5);
var exp = new Reciprocal(new ComplexNumber(complex));
- Assert.Equal("reciprocal(3.1+2.5i)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("reciprocal(3.1+2.5i)"));
}
- [Fact]
+ [Test]
public void ReToStringTest()
{
var complex = new Complex(3.1, 2.5);
var exp = new Re(new ComplexNumber(complex));
- Assert.Equal("re(3.1+2.5i)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("re(3.1+2.5i)"));
}
- [Fact]
+ [Test]
public void ToComplexToStringTest()
{
var exp = new ToComplex(Number.Two);
- Assert.Equal("tocomplex(2)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("tocomplex(2)"));
}
#endregion
#region Trigonometric
- [Fact]
+ [Test]
public void ArccosToStringTest()
{
var exp = new Arccos(new Number(5));
- Assert.Equal("arccos(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("arccos(5)"));
}
- [Fact]
+ [Test]
public void ArccotToStringTest()
{
var exp = new Arccot(new Number(5));
- Assert.Equal("arccot(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("arccot(5)"));
}
- [Fact]
+ [Test]
public void ArccscToStringTest()
{
var exp = new Arccsc(new Number(5));
- Assert.Equal("arccsc(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("arccsc(5)"));
}
- [Fact]
+ [Test]
public void ArcsecToStringTest()
{
var exp = new Arcsec(new Number(5));
- Assert.Equal("arcsec(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("arcsec(5)"));
}
- [Fact]
+ [Test]
public void ArcsinToStringTest()
{
var exp = new Arcsin(new Number(5));
- Assert.Equal("arcsin(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("arcsin(5)"));
}
- [Fact]
+ [Test]
public void ArctanToStringTest()
{
var exp = new Arctan(new Number(5));
- Assert.Equal("arctan(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("arctan(5)"));
}
- [Fact]
+ [Test]
public void CosToStringTest()
{
var exp = new Cos(new Number(5));
- Assert.Equal("cos(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("cos(5)"));
}
- [Fact]
+ [Test]
public void CotToStringTest()
{
var exp = new Cot(new Number(5));
- Assert.Equal("cot(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("cot(5)"));
}
- [Fact]
+ [Test]
public void CscToStringTest()
{
var exp = new Csc(new Number(5));
- Assert.Equal("csc(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("csc(5)"));
}
- [Fact]
+ [Test]
public void SecToStringTest()
{
var exp = new Sec(new Number(5));
- Assert.Equal("sec(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("sec(5)"));
}
- [Fact]
+ [Test]
public void SinToStringTest()
{
var exp = new Sin(new Number(5));
- Assert.Equal("sin(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("sin(5)"));
}
- [Fact]
+ [Test]
public void TanToStringTest()
{
var exp = new Tan(new Number(5));
- Assert.Equal("tan(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("tan(5)"));
}
#endregion
#region Hyperbolic
- [Fact]
+ [Test]
public void ArcoshToStringTest()
{
var exp = new Arcosh(new Number(5));
- Assert.Equal("arcosh(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("arcosh(5)"));
}
- [Fact]
+ [Test]
public void ArcothToStringTest()
{
var exp = new Arcoth(new Number(5));
- Assert.Equal("arcoth(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("arcoth(5)"));
}
- [Fact]
+ [Test]
public void ArcschToStringTest()
{
var exp = new Arcsch(new Number(5));
- Assert.Equal("arcsch(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("arcsch(5)"));
}
- [Fact]
+ [Test]
public void ArsechToStringTest()
{
var exp = new Arsech(new Number(5));
- Assert.Equal("arsech(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("arsech(5)"));
}
- [Fact]
+ [Test]
public void ArsinhToStringTest()
{
var exp = new Arsinh(new Number(5));
- Assert.Equal("arsinh(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("arsinh(5)"));
}
- [Fact]
+ [Test]
public void ArtanhToStringTest()
{
var exp = new Artanh(new Number(5));
- Assert.Equal("artanh(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("artanh(5)"));
}
- [Fact]
+ [Test]
public void CoshToStringTest()
{
var exp = new Cosh(new Number(5));
- Assert.Equal("cosh(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("cosh(5)"));
}
- [Fact]
+ [Test]
public void CothToStringTest()
{
var exp = new Coth(new Number(5));
- Assert.Equal("coth(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("coth(5)"));
}
- [Fact]
+ [Test]
public void CschToStringTest()
{
var exp = new Csch(new Number(5));
- Assert.Equal("csch(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("csch(5)"));
}
- [Fact]
+ [Test]
public void SechToStringTest()
{
var exp = new Sech(new Number(5));
- Assert.Equal("sech(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("sech(5)"));
}
- [Fact]
+ [Test]
public void SinhToStringTest()
{
var exp = new Sinh(new Number(5));
- Assert.Equal("sinh(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("sinh(5)"));
}
- [Fact]
+ [Test]
public void TanhToStringTest()
{
var exp = new Tanh(new Number(5));
- Assert.Equal("tanh(5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("tanh(5)"));
}
#endregion
#region Logical and Bitwise
- [Fact]
+ [Test]
public void BoolToStringTest()
{
var exp = Bool.False;
- Assert.Equal("False", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("False"));
}
- [Fact]
+ [Test]
public void AndAndToStringTest()
{
var exp = new And(Bool.True, new And(Bool.True, Bool.True));
- Assert.Equal("True and (True and True)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True and (True and True)"));
}
- [Fact]
+ [Test]
public void OrToStringTest()
{
var exp = new Or(Bool.True, Bool.True);
- Assert.Equal("True or True", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True or True"));
}
- [Fact]
+ [Test]
public void OrOrToStringTest()
{
var exp = new Or(Bool.True, new Or(Bool.True, Bool.True));
- Assert.Equal("True or (True or True)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True or (True or True)"));
}
- [Fact]
+ [Test]
public void XOrToStringTest()
{
var exp = new XOr(Bool.True, Bool.True);
- Assert.Equal("True xor True", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True xor True"));
}
- [Fact]
+ [Test]
public void XOrXOrToStringTest()
{
var exp = new XOr(Bool.True, new XOr(Bool.True, Bool.True));
- Assert.Equal("True xor (True xor True)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True xor (True xor True)"));
}
- [Fact]
+ [Test]
public void NotToStringTest()
{
var exp = new Not(Bool.True);
- Assert.Equal("not(True)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("not(True)"));
}
- [Fact]
+ [Test]
public void EqualityToStringTest1()
{
var eq = new Equality(Bool.True, Bool.False);
- Assert.Equal("True <=> False", eq.ToString());
+ Assert.That(eq.ToString(), Is.EqualTo("True <=> False"));
}
- [Fact]
+ [Test]
public void EqualityToStringTest2()
{
var eq = new And(new Equality(Bool.True, Bool.False), Bool.False);
- Assert.Equal("(True <=> False) and False", eq.ToString());
+ Assert.That(eq.ToString(), Is.EqualTo("(True <=> False) and False"));
}
- [Fact]
+ [Test]
public void ImplicationToStringTest1()
{
var eq = new Implication(Bool.True, Bool.False);
- Assert.Equal("True => False", eq.ToString());
+ Assert.That(eq.ToString(), Is.EqualTo("True => False"));
}
- [Fact]
+ [Test]
public void ImplicationToStringTest2()
{
var eq = new And(new Implication(Bool.True, Bool.False), Bool.False);
- Assert.Equal("(True => False) and False", eq.ToString());
+ Assert.That(eq.ToString(), Is.EqualTo("(True => False) and False"));
}
- [Fact]
+ [Test]
public void NAndToStringTest1()
{
var eq = new NAnd(Bool.True, Bool.False);
- Assert.Equal("True nand False", eq.ToString());
+ Assert.That(eq.ToString(), Is.EqualTo("True nand False"));
}
- [Fact]
+ [Test]
public void NAndToStringTest2()
{
var eq = new And(new NAnd(Bool.True, Bool.False), Bool.False);
- Assert.Equal("(True nand False) and False", eq.ToString());
+ Assert.That(eq.ToString(), Is.EqualTo("(True nand False) and False"));
}
- [Fact]
+ [Test]
public void NOrToStringTest1()
{
var eq = new NOr(Bool.True, Bool.False);
- Assert.Equal("True nor False", eq.ToString());
+ Assert.That(eq.ToString(), Is.EqualTo("True nor False"));
}
- [Fact]
+ [Test]
public void NOrToStringTest2()
{
var eq = new And(new NOr(Bool.True, Bool.False), Bool.False);
- Assert.Equal("(True nor False) and False", eq.ToString());
+ Assert.That(eq.ToString(), Is.EqualTo("(True nor False) and False"));
}
#endregion
#region Matrix
- [Fact]
+ [Test]
public void MatrixToStringTest()
{
var matrix = new Matrix(new[]
@@ -1048,10 +1048,10 @@ public void MatrixToStringTest()
new Matrices.Vector(new IExpression[] { new Number(4), Number.Zero })
});
- Assert.Equal("{{1, -2}, {4, 0}}", matrix.ToString());
+ Assert.That(matrix.ToString(), Is.EqualTo("{{1, -2}, {4, 0}}"));
}
- [Fact]
+ [Test]
public void DeterminantToStringTest()
{
var matrix = new Matrix(new[]
@@ -1062,10 +1062,10 @@ public void DeterminantToStringTest()
var det = new Determinant(matrix);
- Assert.Equal("det({{1, -2}, {4, 0}})", det.ToString());
+ Assert.That(det.ToString(), Is.EqualTo("det({{1, -2}, {4, 0}})"));
}
- [Fact]
+ [Test]
public void InverseToStringTest()
{
var matrix = new Matrix(new[]
@@ -1076,30 +1076,30 @@ public void InverseToStringTest()
var exp = new Inverse(matrix);
- Assert.Equal("inverse({{1, -2}, {4, 0}})", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("inverse({{1, -2}, {4, 0}})"));
}
- [Fact]
+ [Test]
public void DotProductToStringTest()
{
var left = new Matrices.Vector(new IExpression[] { Number.One, new Number(-2) });
var right = new Matrices.Vector(new IExpression[] { new Number(4), Number.Zero });
var exp = new DotProduct(left, right);
- Assert.Equal("dotProduct({1, -2}, {4, 0})", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("dotProduct({1, -2}, {4, 0})"));
}
- [Fact]
+ [Test]
public void CrossProductToStringTest()
{
var left = new Matrices.Vector(new IExpression[] { Number.One, new Number(-2) });
var right = new Matrices.Vector(new IExpression[] { new Number(4), Number.Zero });
var exp = new CrossProduct(left, right);
- Assert.Equal("crossProduct({1, -2}, {4, 0})", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("crossProduct({1, -2}, {4, 0})"));
}
- [Fact]
+ [Test]
public void TransposeToStringTest()
{
var matrix = new Matrix(new[]
@@ -1110,452 +1110,452 @@ public void TransposeToStringTest()
var exp = new Transpose(matrix);
- Assert.Equal("transpose({{1, -2}, {4, 0}})", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("transpose({{1, -2}, {4, 0}})"));
}
#endregion
#region Statistical
- [Fact]
+ [Test]
public void AvgToStringTest()
{
var sum = new Avg(new IExpression[] { Number.One, Number.Two });
- Assert.Equal("avg(1, 2)", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("avg(1, 2)"));
}
- [Fact]
+ [Test]
public void AvgToStringTest2()
{
var sum = new Avg(new IExpression[] { new Matrices.Vector(new IExpression[] { Number.One, Number.Two }) });
- Assert.Equal("avg({1, 2})", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("avg({1, 2})"));
}
- [Fact]
+ [Test]
public void CountToStringTest()
{
var sum = new Count(new IExpression[] { Number.One, Number.Two });
- Assert.Equal("count(1, 2)", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("count(1, 2)"));
}
- [Fact]
+ [Test]
public void CountToStringTest2()
{
var sum = new Count(new IExpression[] { new Matrices.Vector(new IExpression[] { Number.One, Number.Two }) });
- Assert.Equal("count({1, 2})", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("count({1, 2})"));
}
- [Fact]
+ [Test]
public void ToStringTest()
{
var sum = new Max(new IExpression[] { Number.One, Number.Two });
- Assert.Equal("max(1, 2)", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("max(1, 2)"));
}
- [Fact]
+ [Test]
public void ToStringTest2()
{
var sum = new Max(new IExpression[] { new Matrices.Vector(new IExpression[] { Number.One, Number.Two }) });
- Assert.Equal("max({1, 2})", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("max({1, 2})"));
}
- [Fact]
+ [Test]
public void MinToStringTest()
{
var sum = new Min(new IExpression[] { Number.One, Number.Two });
- Assert.Equal("min(1, 2)", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("min(1, 2)"));
}
- [Fact]
+ [Test]
public void MinToStringTest2()
{
var sum = new Min(new IExpression[] { new Matrices.Vector(new IExpression[] { Number.One, Number.Two }) });
- Assert.Equal("min({1, 2})", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("min({1, 2})"));
}
- [Fact]
+ [Test]
public void ProductToStringTest()
{
var sum = new Product(new IExpression[] { Number.One, Number.Two });
- Assert.Equal("product(1, 2)", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("product(1, 2)"));
}
- [Fact]
+ [Test]
public void ProductToStringTest2()
{
var sum = new Product(new IExpression[] { new Matrices.Vector(new IExpression[] { Number.One, Number.Two }) });
- Assert.Equal("product({1, 2})", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("product({1, 2})"));
}
- [Fact]
+ [Test]
public void StdevpToStringTest()
{
var sum = new Stdevp(new IExpression[] { Number.One, Number.Two });
- Assert.Equal("stdevp(1, 2)", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("stdevp(1, 2)"));
}
- [Fact]
+ [Test]
public void StdevpToStringTest2()
{
var sum = new Stdevp(new IExpression[] { new Matrices.Vector(new IExpression[] { Number.One, Number.Two }) });
- Assert.Equal("stdevp({1, 2})", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("stdevp({1, 2})"));
}
- [Fact]
+ [Test]
public void StdevToStringTest()
{
var sum = new Stdev(new IExpression[] { Number.One, Number.Two });
- Assert.Equal("stdev(1, 2)", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("stdev(1, 2)"));
}
- [Fact]
+ [Test]
public void StdevToStringTest2()
{
var sum = new Stdev(new IExpression[] { new Matrices.Vector(new IExpression[] { Number.One, Number.Two }) });
- Assert.Equal("stdev({1, 2})", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("stdev({1, 2})"));
}
- [Fact]
+ [Test]
public void SumToStringTest()
{
var sum = new Sum(new IExpression[] { Number.One, Number.Two });
- Assert.Equal("sum(1, 2)", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("sum(1, 2)"));
}
- [Fact]
+ [Test]
public void SumToStringTest2()
{
var sum = new Sum(new IExpression[] { new Matrices.Vector(new IExpression[] { Number.One, Number.Two }) });
- Assert.Equal("sum({1, 2})", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("sum({1, 2})"));
}
- [Fact]
+ [Test]
public void VarpToStringTest()
{
var sum = new Varp(new IExpression[] { Number.One, Number.Two });
- Assert.Equal("varp(1, 2)", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("varp(1, 2)"));
}
- [Fact]
+ [Test]
public void VarpToStringTest2()
{
var sum = new Varp(new IExpression[] { new Matrices.Vector(new IExpression[] { Number.One, Number.Two }) });
- Assert.Equal("varp({1, 2})", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("varp({1, 2})"));
}
- [Fact]
+ [Test]
public void VarToStringTest()
{
var sum = new Var(new IExpression[] { Number.One, Number.Two });
- Assert.Equal("var(1, 2)", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("var(1, 2)"));
}
- [Fact]
+ [Test]
public void VarToStringTest2()
{
var sum = new Var(new IExpression[] { new Matrices.Vector(new IExpression[] { Number.One, Number.Two }) });
- Assert.Equal("var({1, 2})", sum.ToString());
+ Assert.That(sum.ToString(), Is.EqualTo("var({1, 2})"));
}
#endregion
#region Programming
- [Fact]
+ [Test]
public void AddAssignToString()
{
var exp = new AddAssign(Variable.X, new Number(5));
- Assert.Equal("x += 5", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x += 5"));
}
- [Fact]
+ [Test]
public void SubAssignToString()
{
var exp = new SubAssign(Variable.X, new Number(5));
- Assert.Equal("x -= 5", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x -= 5"));
}
- [Fact]
+ [Test]
public void MulAssignToString()
{
var exp = new MulAssign(Variable.X, new Number(5));
- Assert.Equal("x *= 5", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x *= 5"));
}
- [Fact]
+ [Test]
public void DivAssignToString()
{
var exp = new DivAssign(Variable.X, new Number(5));
- Assert.Equal("x /= 5", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x /= 5"));
}
- [Fact]
+ [Test]
public void IncToString()
{
var exp = new Inc(Variable.X);
- Assert.Equal("x++", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x++"));
}
- [Fact]
+ [Test]
public void DecToString()
{
var exp = new Dec(Variable.X);
- Assert.Equal("x--", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("x--"));
}
- [Fact]
+ [Test]
public void CondAndToString()
{
var exp = new ConditionalAnd(Bool.True, Bool.True);
- Assert.Equal("True && True", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True && True"));
}
- [Fact]
+ [Test]
public void CondAndCondAndToString()
{
var exp = new ConditionalAnd(Bool.True, new ConditionalAnd(Bool.True, Bool.True));
- Assert.Equal("True && (True && True)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True && (True && True)"));
}
- [Fact]
+ [Test]
public void CondOrToString()
{
var exp = new ConditionalOr(Bool.True, Bool.True);
- Assert.Equal("True || True", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True || True"));
}
- [Fact]
+ [Test]
public void CondOrCondOrToString()
{
var exp = new ConditionalOr(Bool.True, new ConditionalOr(Bool.True, Bool.True));
- Assert.Equal("True || (True || True)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True || (True || True)"));
}
- [Fact]
+ [Test]
public void EqualToString()
{
var exp = new Equal(new Number(5), new Number(5));
- Assert.Equal("5 == 5", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5 == 5"));
}
- [Fact]
+ [Test]
public void EqualEqualToString()
{
var exp = new Equal(Bool.True, new Equal(new Number(5), new Number(5)));
- Assert.Equal("True == (5 == 5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True == (5 == 5)"));
}
- [Fact]
+ [Test]
public void NotEqualToString()
{
var exp = new NotEqual(new Number(5), new Number(5));
- Assert.Equal("5 != 5", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5 != 5"));
}
- [Fact]
+ [Test]
public void NotEqualNotEqualToString()
{
var exp = new NotEqual(Bool.True, new NotEqual(new Number(5), new Number(5)));
- Assert.Equal("True != (5 != 5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True != (5 != 5)"));
}
- [Fact]
+ [Test]
public void LessToString()
{
var exp = new LessThan(new Number(5), new Number(5));
- Assert.Equal("5 < 5", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5 < 5"));
}
- [Fact]
+ [Test]
public void LessLessToString()
{
var exp = new ConditionalAnd(Bool.True, new LessThan(new Number(5), new Number(5)));
- Assert.Equal("True && (5 < 5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True && (5 < 5)"));
}
- [Fact]
+ [Test]
public void LessOrEqualToString()
{
var exp = new LessOrEqual(new Number(5), new Number(5));
- Assert.Equal("5 <= 5", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5 <= 5"));
}
- [Fact]
+ [Test]
public void LessOrEqualLessOrEqualToString()
{
var exp = new ConditionalAnd(Bool.True, new LessOrEqual(new Number(5), new Number(5)));
- Assert.Equal("True && (5 <= 5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True && (5 <= 5)"));
}
- [Fact]
+ [Test]
public void GreatToString()
{
var exp = new GreaterThan(new Number(5), new Number(5));
- Assert.Equal("5 > 5", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5 > 5"));
}
- [Fact]
+ [Test]
public void GreatGreatToString()
{
var exp = new ConditionalAnd(Bool.True, new GreaterThan(new Number(5), new Number(5)));
- Assert.Equal("True && (5 > 5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True && (5 > 5)"));
}
- [Fact]
+ [Test]
public void GreatOrEqualToString()
{
var exp = new GreaterOrEqual(new Number(5), new Number(5));
- Assert.Equal("5 >= 5", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("5 >= 5"));
}
- [Fact]
+ [Test]
public void GreatOrEqualGreatOrEqualToString()
{
var exp = new ConditionalAnd(Bool.True, new GreaterOrEqual(new Number(5), new Number(5)));
- Assert.Equal("True && (5 >= 5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("True && (5 >= 5)"));
}
- [Fact]
+ [Test]
public void IfToString()
{
var exp = new If(new Equal(new Number(5), new Number(5)), new Number(5));
- Assert.Equal("if(5 == 5, 5)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("if(5 == 5, 5)"));
}
- [Fact]
+ [Test]
public void IfElseToString()
{
var exp = new If(new Equal(new Number(5), new Number(5)), new Number(5), Number.Zero);
- Assert.Equal("if(5 == 5, 5, 0)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("if(5 == 5, 5, 0)"));
}
- [Fact]
+ [Test]
public void ForToString()
{
var exp = new For(new Number(5), new Assign(Variable.X, Number.Zero), new Equal(new Number(5), new Number(5)), new AddAssign(Variable.X, Number.One));
- Assert.Equal("for(5, x := 0, 5 == 5, x += 1)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("for(5, x := 0, 5 == 5, x += 1)"));
}
- [Fact]
+ [Test]
public void WhileToString()
{
var exp = new While(new Number(5), new Equal(new Number(5), new Number(5)));
- Assert.Equal("while(5, (5 == 5))", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("while(5, (5 == 5))"));
}
- [Fact]
+ [Test]
public void SignToString()
{
var exp = new Sign(new Number(-5));
var str = exp.ToString();
- Assert.Equal("sign(-5)", str);
+ Assert.That(str, Is.EqualTo("sign(-5)"));
}
- [Fact]
+ [Test]
public void LeftShiftTest()
{
var exp = new LeftShift(Number.One, new Number(10));
var str = exp.ToString();
- Assert.Equal("1 << 10", str);
+ Assert.That(str, Is.EqualTo("1 << 10"));
}
- [Fact]
+ [Test]
public void RightShiftTest()
{
var exp = new RightShift(Number.One, new Number(10));
var str = exp.ToString();
- Assert.Equal("1 >> 10", str);
+ Assert.That(str, Is.EqualTo("1 >> 10"));
}
- [Fact]
+ [Test]
public void LeftShiftAssignTest()
{
var exp = new LeftShiftAssign(Variable.X, new Number(10));
var str = exp.ToString();
- Assert.Equal("x <<= 10", str);
+ Assert.That(str, Is.EqualTo("x <<= 10"));
}
- [Fact]
+ [Test]
public void RightShiftAssignTest()
{
var exp = new RightShiftAssign(Variable.X, new Number(10));
var str = exp.ToString();
- Assert.Equal("x >>= 10", str);
+ Assert.That(str, Is.EqualTo("x >>= 10"));
}
- [Fact]
+ [Test]
public void ToBinTest()
{
var exp = new ToBin(new Number(10));
- Assert.Equal("tobin(10)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("tobin(10)"));
}
- [Fact]
+ [Test]
public void ToOctTest()
{
var exp = new ToOct(new Number(10));
- Assert.Equal("tooct(10)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("tooct(10)"));
}
- [Fact]
+ [Test]
public void ToHexTest()
{
var exp = new ToHex(new Number(10));
- Assert.Equal("tohex(10)", exp.ToString());
+ Assert.That(exp.ToString(), Is.EqualTo("tohex(10)"));
}
#endregion
diff --git a/xFunc.Tests/Analyzers/SimplifierTests/AddSimplifierTest.cs b/xFunc.Tests/Analyzers/SimplifierTests/AddSimplifierTest.cs
index ce270ed4d..33d6ff244 100644
--- a/xFunc.Tests/Analyzers/SimplifierTests/AddSimplifierTest.cs
+++ b/xFunc.Tests/Analyzers/SimplifierTests/AddSimplifierTest.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.SimplifierTests;
public class AddSimplifierTest : BaseSimplifierTest
{
- [Fact(DisplayName = "2 + x")]
+ [Test]
public void Order1()
{
var add = new Add(Number.Two, Variable.X);
@@ -14,7 +14,7 @@ public void Order1()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "0 + 1")]
+ [Test]
public void AddFirstZero()
{
var add = new Add(Number.Zero, Number.One);
@@ -23,7 +23,7 @@ public void AddFirstZero()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "1 + 0")]
+ [Test]
public void AddSecondZero()
{
var add = new Add(Number.One, Number.Zero);
@@ -32,7 +32,7 @@ public void AddSecondZero()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "3 + 2")]
+ [Test]
public void AddTwoNumbers()
{
var add = new Add(new Number(3), Number.Two);
@@ -41,7 +41,7 @@ public void AddTwoNumbers()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "90 + 2 rad")]
+ [Test]
public void AddNumberAngle()
{
var add = new Add(
@@ -53,7 +53,7 @@ public void AddNumberAngle()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "90 deg + 2")]
+ [Test]
public void AddAngleNumber()
{
var add = new Add(
@@ -65,7 +65,7 @@ public void AddAngleNumber()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "90 deg + 2 rad")]
+ [Test]
public void AddTwoAngles()
{
var add = new Add(
@@ -77,7 +77,7 @@ public void AddTwoAngles()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 + 10 W")]
+ [Test]
public void AddNumberAndPower()
{
var add = new Add(
@@ -89,7 +89,7 @@ public void AddNumberAndPower()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 W + 10")]
+ [Test]
public void AddPowerAndNumber()
{
var add = new Add(
@@ -101,7 +101,7 @@ public void AddPowerAndNumber()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 W + 10 kW")]
+ [Test]
public void AddTwoPowers()
{
var add = new Add(
@@ -113,7 +113,7 @@ public void AddTwoPowers()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 + 10 C°")]
+ [Test]
public void AddNumberAndTemperature()
{
var add = new Add(
@@ -125,7 +125,7 @@ public void AddNumberAndTemperature()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 C° + 10")]
+ [Test]
public void AddTemperatureAndNumber()
{
var add = new Add(
@@ -137,7 +137,7 @@ public void AddTemperatureAndNumber()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 C° + 10 K")]
+ [Test]
public void AddTwoTemperatures()
{
var add = new Add(
@@ -149,7 +149,7 @@ public void AddTwoTemperatures()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 + 10 g")]
+ [Test]
public void AddNumberAndMass()
{
var add = new Add(
@@ -161,7 +161,7 @@ public void AddNumberAndMass()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 g + 10")]
+ [Test]
public void AddMassAndNumber()
{
var add = new Add(
@@ -173,7 +173,7 @@ public void AddMassAndNumber()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 g + 10 kg")]
+ [Test]
public void AddTwoMasses()
{
var add = new Add(
@@ -185,7 +185,7 @@ public void AddTwoMasses()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 + 10 m")]
+ [Test]
public void AddNumberAndLength()
{
var add = new Add(
@@ -197,7 +197,7 @@ public void AddNumberAndLength()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 m + 10")]
+ [Test]
public void AddLengthAndNumber()
{
var add = new Add(
@@ -209,7 +209,7 @@ public void AddLengthAndNumber()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 km + 10 m")]
+ [Test]
public void AddTwoLengths()
{
var add = new Add(
@@ -221,7 +221,7 @@ public void AddTwoLengths()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 + 10 s")]
+ [Test]
public void AddNumberAndTime()
{
var add = new Add(
@@ -233,7 +233,7 @@ public void AddNumberAndTime()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 s + 10")]
+ [Test]
public void AddTimeAndNumber()
{
var add = new Add(
@@ -245,7 +245,7 @@ public void AddTimeAndNumber()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 min + 10 s")]
+ [Test]
public void AddTwoTimeValues()
{
var add = new Add(
@@ -257,7 +257,7 @@ public void AddTwoTimeValues()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 + 10 m^2")]
+ [Test]
public void AddNumberAndArea()
{
var add = new Add(
@@ -269,7 +269,7 @@ public void AddNumberAndArea()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 m^2 + 10")]
+ [Test]
public void AddAreaAndNumber()
{
var add = new Add(
@@ -281,7 +281,7 @@ public void AddAreaAndNumber()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 km^2 + 500000 m^2")]
+ [Test]
public void AddTwoAreaValues()
{
var add = new Add(
@@ -293,7 +293,7 @@ public void AddTwoAreaValues()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 + 10 m^3")]
+ [Test]
public void AddNumberAndVolume()
{
var add = new Add(
@@ -305,7 +305,7 @@ public void AddNumberAndVolume()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "10 m^3 + 10")]
+ [Test]
public void AddVolumeAndNumber()
{
var add = new Add(
@@ -317,7 +317,7 @@ public void AddVolumeAndNumber()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "1 m^3 + 500000 cm^3")]
+ [Test]
public void AddTwoVolumeValues()
{
var add = new Add(
@@ -329,7 +329,7 @@ public void AddTwoVolumeValues()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "-x + 2")]
+ [Test]
public void AddFirstUnaryMinus()
{
var add = new Add(new UnaryMinus(Variable.X), Number.Two);
@@ -338,7 +338,7 @@ public void AddFirstUnaryMinus()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "2 + (-x)")]
+ [Test]
public void AddSecondUnaryMinus()
{
var add = new Add(Number.Two, new UnaryMinus(Variable.X));
@@ -347,7 +347,7 @@ public void AddSecondUnaryMinus()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "2 + (2 + x)")]
+ [Test]
public void AddDiffNumAdd_NumAddVar_()
{
var add = new Add(Number.Two, new Add(Number.Two, Variable.X));
@@ -356,7 +356,7 @@ public void AddDiffNumAdd_NumAddVar_()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "2 + (x + 2)")]
+ [Test]
public void AddDiffNumAdd_VarAddNum_()
{
var add = new Add(Number.Two, new Add(Variable.X, Number.Two));
@@ -365,7 +365,7 @@ public void AddDiffNumAdd_VarAddNum_()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "(2 + x) + 2")]
+ [Test]
public void AddDiff_NumAddVar_AddNum()
{
var add = new Add(new Add(Number.Two, Variable.X), Number.Two);
@@ -374,7 +374,7 @@ public void AddDiff_NumAddVar_AddNum()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "(x + 2) + 2")]
+ [Test]
public void AddDiff_VarAddNum_AddNum()
{
var add = new Add(new Add(Variable.X, Number.Two), Number.Two);
@@ -383,7 +383,7 @@ public void AddDiff_VarAddNum_AddNum()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "2 + (2 - x)")]
+ [Test]
public void AddDiffNum_NumSubVar_()
{
var add = new Add(Number.Two, new Sub(Number.Two, Variable.X));
@@ -392,7 +392,7 @@ public void AddDiffNum_NumSubVar_()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "2 + (x - 2)")]
+ [Test]
public void AddDiffNum_VarSubNum_()
{
var add = new Add(Number.Two, new Sub(Variable.X, Number.Two));
@@ -401,7 +401,7 @@ public void AddDiffNum_VarSubNum_()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "(2 - x) + 2")]
+ [Test]
public void AddDiff_NumSubVar_AddNum()
{
var add = new Add(new Sub(Number.Two, Variable.X), Number.Two);
@@ -410,7 +410,7 @@ public void AddDiff_NumSubVar_AddNum()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "(x - 2) + 2")]
+ [Test]
public void AddDiff_VarSubNum_AddNum()
{
var add = new Add(new Sub(Variable.X, Number.Two), Number.Two);
@@ -419,7 +419,7 @@ public void AddDiff_VarSubNum_AddNum()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "x + x")]
+ [Test]
public void AddSaveVars1()
{
var exp = new Add(Variable.X, Variable.X);
@@ -428,7 +428,7 @@ public void AddSaveVars1()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "2x + x")]
+ [Test]
public void AddSaveVars2()
{
var exp = new Add(new Mul(Number.Two, Variable.X), Variable.X);
@@ -437,7 +437,7 @@ public void AddSaveVars2()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "2 * (x + y) + (x + y)")]
+ [Test]
public void AddComplexX()
{
var exp = new Add(
@@ -448,7 +448,7 @@ public void AddComplexX()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "x + 2x")]
+ [Test]
public void AddSaveVars3()
{
var exp = new Add(Variable.X, new Mul(Number.Two, Variable.X));
@@ -457,7 +457,7 @@ public void AddSaveVars3()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "x + x * 2")]
+ [Test]
public void AddSaveVars4()
{
var exp = new Add(Variable.X, new Mul(Variable.X, Number.Two));
@@ -466,7 +466,7 @@ public void AddSaveVars4()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "2x + 3x")]
+ [Test]
public void AddSaveVars5()
{
var exp = new Add(
@@ -478,7 +478,7 @@ public void AddSaveVars5()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "2 * (x + y) + 3 * (x + y)")]
+ [Test]
public void AddComplexX2()
{
var exp = new Add(
@@ -493,7 +493,7 @@ public void AddComplexX2()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "-x + x")]
+ [Test]
public void AddSaveVars6()
{
var exp = new Add(new UnaryMinus(Variable.X), Variable.X);
@@ -502,7 +502,7 @@ public void AddSaveVars6()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "-x + 2x")]
+ [Test]
public void AddSaveVars7()
{
var exp = new Add(
@@ -514,7 +514,7 @@ public void AddSaveVars7()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "x * 2 + x")]
+ [Test]
public void AddSaveVars8()
{
var exp = new Add(new Mul(Variable.X, Number.Two), Variable.X);
@@ -523,7 +523,7 @@ public void AddSaveVars8()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "x * 2 + x * 3")]
+ [Test]
public void AddSaveVars9()
{
var exp = new Add(
@@ -535,7 +535,7 @@ public void AddSaveVars9()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "3x + -2x")]
+ [Test]
public void AddSaveVars10()
{
var exp = new Add(
@@ -547,7 +547,7 @@ public void AddSaveVars10()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "3x + -4x")]
+ [Test]
public void AddSaveVars11()
{
var exp = new Add(
@@ -559,7 +559,7 @@ public void AddSaveVars11()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "-2x + x * 3")]
+ [Test]
public void AddSameVars12()
{
var exp = new Add(
@@ -571,7 +571,7 @@ public void AddSameVars12()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "x * 3 + -2x")]
+ [Test]
public void AddSameVars13()
{
var exp = new Add(
@@ -583,7 +583,7 @@ public void AddSameVars13()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void AddArgumentSimplified()
{
var exp = new Add(
diff --git a/xFunc.Tests/Analyzers/SimplifierTests/AngleSimplifierTest.cs b/xFunc.Tests/Analyzers/SimplifierTests/AngleSimplifierTest.cs
index 1674b73c0..667b94ace 100644
--- a/xFunc.Tests/Analyzers/SimplifierTests/AngleSimplifierTest.cs
+++ b/xFunc.Tests/Analyzers/SimplifierTests/AngleSimplifierTest.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.SimplifierTests;
public class AngleSimplifierTest : BaseSimplifierTest
{
- [Fact]
+ [Test]
public void ToDegreeNumber()
{
var exp = new ToDegree(new Number(10));
@@ -14,7 +14,7 @@ public void ToDegreeNumber()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void DegreeToDegree()
{
var exp = new ToDegree(AngleValue.Degree(10).AsExpression());
@@ -23,7 +23,7 @@ public void DegreeToDegree()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void RadianToDegree()
{
var exp = new ToDegree(AngleValue.Radian(Math.PI).AsExpression());
@@ -32,7 +32,7 @@ public void RadianToDegree()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void ToDegreeArgumentSimplified()
{
var exp = new ToDegree(
@@ -45,7 +45,7 @@ public void ToDegreeArgumentSimplified()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void ToDegreeNotSimplified()
{
var exp = new ToDegree(Variable.X);
@@ -53,7 +53,7 @@ public void ToDegreeNotSimplified()
SimplifyTest(exp, exp);
}
- [Fact]
+ [Test]
public void ToRadianNumber()
{
var exp = new ToRadian(new Number(10));
@@ -62,7 +62,7 @@ public void ToRadianNumber()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void RadianToRadian()
{
var exp = new ToRadian(AngleValue.Radian(10).AsExpression());
@@ -71,7 +71,7 @@ public void RadianToRadian()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void DegreeToRadian()
{
var exp = new ToRadian(AngleValue.Degree(180).AsExpression());
@@ -80,7 +80,7 @@ public void DegreeToRadian()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void ToRadianArgumentSimplified()
{
var exp = new ToRadian(
@@ -93,7 +93,7 @@ public void ToRadianArgumentSimplified()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void ToRadianNotSimplified()
{
var exp = new ToRadian(Variable.X);
@@ -101,7 +101,7 @@ public void ToRadianNotSimplified()
SimplifyTest(exp, exp);
}
- [Fact]
+ [Test]
public void ToGradianNumber()
{
var exp = new ToGradian(new Number(10));
@@ -110,7 +110,7 @@ public void ToGradianNumber()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void GradianToGradian()
{
var exp = new ToGradian(AngleValue.Gradian(10).AsExpression());
@@ -119,7 +119,7 @@ public void GradianToGradian()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void DegreeToGradian()
{
var exp = new ToGradian(AngleValue.Degree(180).AsExpression());
@@ -128,7 +128,7 @@ public void DegreeToGradian()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void ToGradianArgumentSimplified()
{
var exp = new ToGradian(
@@ -141,7 +141,7 @@ public void ToGradianArgumentSimplified()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void ToGradianNotSimplified()
{
var exp = new ToGradian(Variable.X);
diff --git a/xFunc.Tests/Analyzers/SimplifierTests/BaseSimplifierTest.cs b/xFunc.Tests/Analyzers/SimplifierTests/BaseSimplifierTest.cs
index 1e0c3ddf2..4a8790223 100644
--- a/xFunc.Tests/Analyzers/SimplifierTests/BaseSimplifierTest.cs
+++ b/xFunc.Tests/Analyzers/SimplifierTests/BaseSimplifierTest.cs
@@ -2,7 +2,7 @@
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System.Reflection;
-using Xunit.Sdk;
+using NUnit.Framework.Internal;
namespace xFunc.Tests.Analyzers.SimplifierTests;
@@ -19,7 +19,7 @@ protected void SimplifyTest(IExpression exp, IExpression expected)
{
var simple = exp.Analyze(simplifier);
- Assert.Equal(expected, simple);
+ Assert.That(simple, Is.EqualTo(expected));
}
protected void TestNullExp(Type type)
@@ -38,6 +38,6 @@ protected void TestNullExp(Type type)
throw;
}
- throw new XunitException("The exception is expected.");
+ throw new NUnitException("The exception is expected.");
}
}
\ No newline at end of file
diff --git a/xFunc.Tests/Analyzers/SimplifierTests/DivSimplifierTest.cs b/xFunc.Tests/Analyzers/SimplifierTests/DivSimplifierTest.cs
index b60ea0f5e..73a8382c3 100644
--- a/xFunc.Tests/Analyzers/SimplifierTests/DivSimplifierTest.cs
+++ b/xFunc.Tests/Analyzers/SimplifierTests/DivSimplifierTest.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.SimplifierTests;
public class DivSimplifierTest : BaseSimplifierTest
{
- [Fact(DisplayName = "0 / x")]
+ [Test]
public void DivZero()
{
var div = new Div(Number.Zero, Variable.X);
@@ -14,7 +14,7 @@ public void DivZero()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "x / 0")]
+ [Test]
public void DivByZero()
{
var div = new Div(Variable.X, Number.Zero);
@@ -22,7 +22,7 @@ public void DivByZero()
Assert.Throws(() => SimplifyTest(div, null));
}
- [Fact(DisplayName = "0 / 0")]
+ [Test]
public void ZeroDivByZero()
{
var div = new Div(Number.Zero, Number.Zero);
@@ -31,7 +31,7 @@ public void ZeroDivByZero()
Assert.True(actual.Value.IsNaN);
}
- [Fact(DisplayName = "x / 1")]
+ [Test]
public void DivByOne()
{
var div = new Div(Variable.X, Number.One);
@@ -40,7 +40,7 @@ public void DivByOne()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "8 / 2")]
+ [Test]
public void DivTwoNumbers()
{
var div = new Div(new Number(8), Number.Two);
@@ -49,7 +49,7 @@ public void DivTwoNumbers()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "90 deg / 2")]
+ [Test]
public void DivAngleNumber()
{
var div = new Div(
@@ -61,7 +61,7 @@ public void DivAngleNumber()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "90 W / 2")]
+ [Test]
public void DivPowerByNumber()
{
var div = new Div(
@@ -73,7 +73,7 @@ public void DivPowerByNumber()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "90 C° / 2")]
+ [Test]
public void DivTemperatureByNumber()
{
var div = new Div(
@@ -85,7 +85,7 @@ public void DivTemperatureByNumber()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "90 g / 2")]
+ [Test]
public void DivMassByNumber()
{
var div = new Div(
@@ -97,7 +97,7 @@ public void DivMassByNumber()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "90 m / 2")]
+ [Test]
public void DivLengthByNumber()
{
var div = new Div(
@@ -109,7 +109,7 @@ public void DivLengthByNumber()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "90 s / 2")]
+ [Test]
public void DivTimeByNumber()
{
var div = new Div(
@@ -121,7 +121,7 @@ public void DivTimeByNumber()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "90 m^2 / 2")]
+ [Test]
public void DivAreaByNumber()
{
var div = new Div(
@@ -133,7 +133,7 @@ public void DivAreaByNumber()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "90 m^3 / 2")]
+ [Test]
public void DivVolumeByNumber()
{
var div = new Div(
@@ -145,7 +145,7 @@ public void DivVolumeByNumber()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "(2 * x) / 4")]
+ [Test]
public void DivDiff_NumMulVar_DivNum()
{
var div = new Div(new Mul(Number.Two, Variable.X), new Number(4));
@@ -154,7 +154,7 @@ public void DivDiff_NumMulVar_DivNum()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "(x * 2) / 4")]
+ [Test]
public void DivDiff_VarMulNum_DivNum()
{
var div = new Div(new Mul(Variable.X, Number.Two), new Number(4));
@@ -163,7 +163,7 @@ public void DivDiff_VarMulNum_DivNum()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "2 / (2 * x)")]
+ [Test]
public void DivDiffNumDiv_NumMulVar_()
{
var div = new Div(Number.Two, new Mul(Number.Two, Variable.X));
@@ -172,7 +172,7 @@ public void DivDiffNumDiv_NumMulVar_()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "2 / (2 * x)")]
+ [Test]
public void DivDiffNumDiv_VarMulNum_()
{
var div = new Div(Number.Two, new Mul(Variable.X, Number.Two));
@@ -181,7 +181,7 @@ public void DivDiffNumDiv_VarMulNum_()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "(2 / x) / 2")]
+ [Test]
public void DivDiff_NumDivVar_DivNum()
{
var div = new Div(new Div(Number.Two, Variable.X), Number.Two);
@@ -190,7 +190,7 @@ public void DivDiff_NumDivVar_DivNum()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "(x / 2) / 2")]
+ [Test]
public void DivDiff_VarDivNum_DivNum()
{
var div = new Div(new Div(Variable.X, Number.Two), Number.Two);
@@ -199,7 +199,7 @@ public void DivDiff_VarDivNum_DivNum()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "2 / (2 / x)")]
+ [Test]
public void DivDiffNumDiv_NumDivVar_()
{
var div = new Div(Number.Two, new Div(Number.Two, Variable.X));
@@ -208,7 +208,7 @@ public void DivDiffNumDiv_NumDivVar_()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "2 / (x / 2)")]
+ [Test]
public void DivDiffNumDiv_VarDivNum_()
{
var div = new Div(Number.Two, new Div(Variable.X, Number.Two));
@@ -217,7 +217,7 @@ public void DivDiffNumDiv_VarDivNum_()
SimplifyTest(div, expected);
}
- [Fact(DisplayName = "x / x")]
+ [Test]
public void DivSameVars()
{
var div = new Div(Variable.X, Variable.X);
@@ -226,7 +226,7 @@ public void DivSameVars()
SimplifyTest(div, expected);
}
- [Fact]
+ [Test]
public void DivArgumentSimplified()
{
var exp = new Div(
diff --git a/xFunc.Tests/Analyzers/SimplifierTests/LogSimplifierTest.cs b/xFunc.Tests/Analyzers/SimplifierTests/LogSimplifierTest.cs
index 46d41b06d..41e8f7569 100644
--- a/xFunc.Tests/Analyzers/SimplifierTests/LogSimplifierTest.cs
+++ b/xFunc.Tests/Analyzers/SimplifierTests/LogSimplifierTest.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.SimplifierTests;
public class LogSimplifierTest : BaseSimplifierTest
{
- [Fact]
+ [Test]
public void Log()
{
var log = new Log(Variable.X, Variable.X);
@@ -14,7 +14,7 @@ public void Log()
SimplifyTest(log, expected);
}
- [Fact]
+ [Test]
public void LogNotSimplified()
{
var log = new Log(new Number(3), new Number(11));
@@ -22,7 +22,7 @@ public void LogNotSimplified()
SimplifyTest(log, log);
}
- [Fact]
+ [Test]
public void LogArgumentSimplified()
{
var log = new Log(Variable.X, new Add(Number.One, Number.One));
@@ -31,7 +31,7 @@ public void LogArgumentSimplified()
SimplifyTest(log, expected);
}
- [Fact]
+ [Test]
public void Ln()
{
var ln = new Ln(new Variable("e"));
@@ -40,7 +40,7 @@ public void Ln()
SimplifyTest(ln, expected);
}
- [Fact]
+ [Test]
public void LnArgumentSimplified()
{
var log = new Ln(new Add(Number.Two, Number.Two));
@@ -49,7 +49,7 @@ public void LnArgumentSimplified()
SimplifyTest(log, expected);
}
- [Fact]
+ [Test]
public void LnNotSimplified()
{
var ln = new Ln(new Variable("z"));
@@ -57,7 +57,7 @@ public void LnNotSimplified()
SimplifyTest(ln, ln);
}
- [Fact]
+ [Test]
public void Lg()
{
var log = new Lg(new Number(10));
@@ -66,7 +66,7 @@ public void Lg()
SimplifyTest(log, expected);
}
- [Fact]
+ [Test]
public void LgArgumentSimplified()
{
var log = new Lg(new Add(Number.Two, Number.Two));
@@ -75,7 +75,7 @@ public void LgArgumentSimplified()
SimplifyTest(log, expected);
}
- [Fact]
+ [Test]
public void LgNotSimplified()
{
var log = new Lg(new Number(101));
@@ -83,7 +83,7 @@ public void LgNotSimplified()
SimplifyTest(log, log);
}
- [Fact]
+ [Test]
public void Lb()
{
var log = new Lb(Number.Two);
@@ -92,7 +92,7 @@ public void Lb()
SimplifyTest(log, expected);
}
- [Fact]
+ [Test]
public void LbArgumentSimplified()
{
var log = new Lb(new Add(Number.Two, Number.Two));
@@ -101,7 +101,7 @@ public void LbArgumentSimplified()
SimplifyTest(log, expected);
}
- [Fact]
+ [Test]
public void LbNotSimplified()
{
var log = new Lb(new Number(3));
diff --git a/xFunc.Tests/Analyzers/SimplifierTests/MulSimplifierTest.cs b/xFunc.Tests/Analyzers/SimplifierTests/MulSimplifierTest.cs
index e2f33b51c..268560345 100644
--- a/xFunc.Tests/Analyzers/SimplifierTests/MulSimplifierTest.cs
+++ b/xFunc.Tests/Analyzers/SimplifierTests/MulSimplifierTest.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.SimplifierTests;
public class MulSimplifierTest : BaseSimplifierTest
{
- [Fact(DisplayName = "x * 2")]
+ [Test]
public void Order1()
{
var add = new Mul(Variable.X, Number.Two);
@@ -14,7 +14,7 @@ public void Order1()
SimplifyTest(add, expected);
}
- [Fact(DisplayName = "0 * 10")]
+ [Test]
public void MulByFirstZero()
{
var mul = new Mul(Number.Zero, new Number(10));
@@ -23,7 +23,7 @@ public void MulByFirstZero()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "10 * 0")]
+ [Test]
public void MulBySecondZero()
{
var mul = new Mul(new Number(10), Number.Zero);
@@ -32,7 +32,7 @@ public void MulBySecondZero()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "1 * 10")]
+ [Test]
public void MulFirstOne()
{
var mul = new Mul(Number.One, new Number(10));
@@ -41,7 +41,7 @@ public void MulFirstOne()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "10 * 1")]
+ [Test]
public void MulSecondOne()
{
var mul = new Mul(new Number(10), Number.One);
@@ -50,7 +50,7 @@ public void MulSecondOne()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "-1 * 10")]
+ [Test]
public void MulFirstMinusOne()
{
var mul = new Mul(new Number(-1), new Number(10));
@@ -59,7 +59,7 @@ public void MulFirstMinusOne()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "10 * -1")]
+ [Test]
public void MulSecondMinusOne()
{
var mul = new Mul(new Number(10), new Number(-1));
@@ -68,7 +68,7 @@ public void MulSecondMinusOne()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 * 3")]
+ [Test]
public void MulTwoNumbers()
{
var mul = new Mul(Number.Two, new Number(3));
@@ -77,7 +77,7 @@ public void MulTwoNumbers()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "90 * 2 deg")]
+ [Test]
public void MulNumberAngle()
{
var mul = new Mul(
@@ -89,7 +89,7 @@ public void MulNumberAngle()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "90 deg * 2")]
+ [Test]
public void MulAngleNumber()
{
var mul = new Mul(
@@ -101,7 +101,7 @@ public void MulAngleNumber()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "10 * 2 W")]
+ [Test]
public void MulNumberByPower()
{
var mul = new Mul(
@@ -113,7 +113,7 @@ public void MulNumberByPower()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 W * 10")]
+ [Test]
public void MulPowerByNumber()
{
var mul = new Mul(
@@ -125,7 +125,7 @@ public void MulPowerByNumber()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "10 * 2 C°")]
+ [Test]
public void MulNumberByTemperature()
{
var mul = new Mul(
@@ -137,7 +137,7 @@ public void MulNumberByTemperature()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 C° * 10")]
+ [Test]
public void MulTemperatureByNumber()
{
var mul = new Mul(
@@ -149,7 +149,7 @@ public void MulTemperatureByNumber()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "10 * 2 g")]
+ [Test]
public void MulNumberByMass()
{
var mul = new Mul(
@@ -161,7 +161,7 @@ public void MulNumberByMass()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 g * 10")]
+ [Test]
public void MulMassByNumber()
{
var mul = new Mul(
@@ -173,7 +173,7 @@ public void MulMassByNumber()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "10 * 2 m")]
+ [Test]
public void MulNumberByLength()
{
var mul = new Mul(
@@ -185,7 +185,7 @@ public void MulNumberByLength()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 m * 10")]
+ [Test]
public void MulLengthByNumber()
{
var mul = new Mul(
@@ -197,7 +197,7 @@ public void MulLengthByNumber()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 m * 2 m")]
+ [Test]
public void MulLengthByLength()
{
var mul = new Mul(
@@ -209,7 +209,7 @@ public void MulLengthByLength()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 m^2 * 2 m")]
+ [Test]
public void MulAreaByLength()
{
var mul = new Mul(
@@ -221,7 +221,7 @@ public void MulAreaByLength()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 m * 2 m^2")]
+ [Test]
public void MulLengthByArea()
{
var mul = new Mul(
@@ -233,7 +233,7 @@ public void MulLengthByArea()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "10 * 2 s")]
+ [Test]
public void MulNumberByTime()
{
var mul = new Mul(
@@ -245,7 +245,7 @@ public void MulNumberByTime()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 s * 10")]
+ [Test]
public void MulTimeByNumber()
{
var mul = new Mul(
@@ -257,7 +257,7 @@ public void MulTimeByNumber()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "10 * 2 m^2")]
+ [Test]
public void MulNumberByArea()
{
var mul = new Mul(
@@ -269,7 +269,7 @@ public void MulNumberByArea()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 m^2 * 10")]
+ [Test]
public void MulAreaByNumber()
{
var mul = new Mul(
@@ -281,7 +281,7 @@ public void MulAreaByNumber()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "10 * 2 m^3")]
+ [Test]
public void MulNumberByVolume()
{
var mul = new Mul(
@@ -293,7 +293,7 @@ public void MulNumberByVolume()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 m^3 * 10")]
+ [Test]
public void MulVolumeByNumber()
{
var mul = new Mul(
@@ -305,7 +305,7 @@ public void MulVolumeByNumber()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 * (2 * x)")]
+ [Test]
public void MulDiffNumMul_NumMulVar_()
{
var mul = new Mul(Number.Two, new Mul(Number.Two, Variable.X));
@@ -314,7 +314,7 @@ public void MulDiffNumMul_NumMulVar_()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 * (x * 2)")]
+ [Test]
public void MulDiffNumMul_VarMulNum_()
{
var mul = new Mul(Number.Two, new Mul(Variable.X, Number.Two));
@@ -323,7 +323,7 @@ public void MulDiffNumMul_VarMulNum_()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "(2 * x) * 2")]
+ [Test]
public void MulDiff_NumMulVar_MulNum()
{
var mul = new Mul(new Mul(Number.Two, Variable.X), Number.Two);
@@ -332,7 +332,7 @@ public void MulDiff_NumMulVar_MulNum()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "(x * 2) * 2")]
+ [Test]
public void MulDiff_VarMulNum_MulNum()
{
var mul = new Mul(new Mul(Variable.X, Number.Two), Number.Two);
@@ -341,7 +341,7 @@ public void MulDiff_VarMulNum_MulNum()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 * (2 / x)")]
+ [Test]
public void MulDiffNumMul_NumDivVar_()
{
var mul = new Mul(Number.Two, new Div(Number.Two, Variable.X));
@@ -350,7 +350,7 @@ public void MulDiffNumMul_NumDivVar_()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 * (x / 2)")]
+ [Test]
public void MulDiffNumMul_VarDivNum_()
{
var mul = new Mul(Number.Two, new Div(Variable.X, Number.Two));
@@ -359,7 +359,7 @@ public void MulDiffNumMul_VarDivNum_()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "(2 / x) * 2")]
+ [Test]
public void MulDiff_NumDivVar_MulNum()
{
var mul = new Mul(new Div(Number.Two, Variable.X), Number.Two);
@@ -368,7 +368,7 @@ public void MulDiff_NumDivVar_MulNum()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "(x / 2) * 2")]
+ [Test]
public void MulDiff_VarDivNum_MulNum()
{
var mul = new Mul(new Div(Variable.X, Number.Two), Number.Two);
@@ -377,7 +377,7 @@ public void MulDiff_VarDivNum_MulNum()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "x * x")]
+ [Test]
public void MulSameVar1()
{
var mul = new Mul(Variable.X, Variable.X);
@@ -386,7 +386,7 @@ public void MulSameVar1()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2x * x")]
+ [Test]
public void MulSameVar2()
{
var mul = new Mul(new Mul(Number.Two, Variable.X), Variable.X);
@@ -395,7 +395,7 @@ public void MulSameVar2()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 * (x + y) * (x + y)")]
+ [Test]
public void MulComplexX()
{
var mul = new Mul(
@@ -410,7 +410,7 @@ public void MulComplexX()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2x * 3x")]
+ [Test]
public void MulSameVar3()
{
var mul = new Mul(
@@ -422,7 +422,7 @@ public void MulSameVar3()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2 * (x + y) * 3 * (x + y)")]
+ [Test]
public void MulComplexX2()
{
var mul = new Mul(
@@ -437,7 +437,7 @@ public void MulComplexX2()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "x * 2x")]
+ [Test]
public void MulSameVar4()
{
var mul = new Mul(Variable.X, new Mul(Number.Two, Variable.X));
@@ -446,7 +446,7 @@ public void MulSameVar4()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "x * (x * 2)")]
+ [Test]
public void MulSameVar5()
{
var mul = new Mul(Variable.X, new Mul(Variable.X, Number.Two));
@@ -455,7 +455,7 @@ public void MulSameVar5()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2x * x")]
+ [Test]
public void MulSameVar6()
{
var mul = new Mul(new Mul(Number.Two, Variable.X), Variable.X);
@@ -464,7 +464,7 @@ public void MulSameVar6()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "(x * 2) * x")]
+ [Test]
public void MulSameVar7()
{
var mul = new Mul(new Mul(Variable.X, Number.Two), Variable.X);
@@ -473,7 +473,7 @@ public void MulSameVar7()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2x * 3x")]
+ [Test]
public void MulSameVar8()
{
var mul = new Mul(
@@ -485,7 +485,7 @@ public void MulSameVar8()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "(x * 2) * (x * 3)")]
+ [Test]
public void MulSameVar9()
{
var mul = new Mul(
@@ -497,7 +497,7 @@ public void MulSameVar9()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2x * -2x")]
+ [Test]
public void MulSameVar10()
{
var mul = new Mul(
@@ -509,7 +509,7 @@ public void MulSameVar10()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2x * -3x")]
+ [Test]
public void MulSameVar11()
{
var mul = new Mul(
@@ -521,7 +521,7 @@ public void MulSameVar11()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "2x * x * (-3)")]
+ [Test]
public void MulSameVar12()
{
var mul = new Mul(
@@ -533,7 +533,7 @@ public void MulSameVar12()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "x * 2 * -3x")]
+ [Test]
public void MulSameVar13()
{
var mul = new Mul(
@@ -545,7 +545,7 @@ public void MulSameVar13()
SimplifyTest(mul, expected);
}
- [Fact(DisplayName = "cos(cos(x)) * -sin(x)")]
+ [Test]
public void MulNegativeRightParamTest1()
{
var mul = new Mul(
@@ -560,7 +560,7 @@ public void MulNegativeRightParamTest1()
SimplifyTest(mul, expected);
}
- [Fact]
+ [Test]
public void MulArgumentSimplified()
{
var exp = new Mul(
@@ -572,7 +572,7 @@ public void MulArgumentSimplified()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "x * (1 / x)")]
+ [Test]
public void MulDiv1()
{
var exp = new Mul(
@@ -584,7 +584,7 @@ public void MulDiv1()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "(2 * x) * (1 / x)")]
+ [Test]
public void MulDiv2()
{
var exp = new Mul(
@@ -596,7 +596,7 @@ public void MulDiv2()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "(x * 2) * (1 / x)")]
+ [Test]
public void MulDiv3()
{
var exp = new Mul(
diff --git a/xFunc.Tests/Analyzers/SimplifierTests/PowerSimplifierTest.cs b/xFunc.Tests/Analyzers/SimplifierTests/PowerSimplifierTest.cs
index 87a4bd681..616d55e2d 100644
--- a/xFunc.Tests/Analyzers/SimplifierTests/PowerSimplifierTest.cs
+++ b/xFunc.Tests/Analyzers/SimplifierTests/PowerSimplifierTest.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.SimplifierTests;
public class PowerSimplifierTest : BaseSimplifierTest
{
- [Fact]
+ [Test]
public void PowerXZero()
{
var pow = new Pow(Variable.X, Number.Zero);
@@ -14,7 +14,7 @@ public void PowerXZero()
SimplifyTest(pow, expected);
}
- [Fact]
+ [Test]
public void PowerZeroX()
{
var pow = new Pow(Number.Zero, Variable.X);
@@ -23,7 +23,7 @@ public void PowerZeroX()
SimplifyTest(pow, expected);
}
- [Fact]
+ [Test]
public void PowerOne()
{
var pow = new Pow(Variable.X, Number.One);
@@ -32,7 +32,7 @@ public void PowerOne()
SimplifyTest(pow, expected);
}
- [Fact]
+ [Test]
public void PowerArgumentSimplified()
{
var pow = new Pow(Variable.X, new Add(Number.One, Number.One));
@@ -41,7 +41,7 @@ public void PowerArgumentSimplified()
SimplifyTest(pow, expected);
}
- [Fact]
+ [Test]
public void PowerNotSimplified()
{
var pow = new Pow(Variable.X, Variable.X);
@@ -49,7 +49,7 @@ public void PowerNotSimplified()
SimplifyTest(pow, pow);
}
- [Fact]
+ [Test]
public void PowLog()
{
var pow = new Pow(
@@ -60,7 +60,7 @@ public void PowLog()
SimplifyTest(pow, expected);
}
- [Fact]
+ [Test]
public void PowLg()
{
var pow = new Pow(
@@ -71,7 +71,7 @@ public void PowLg()
SimplifyTest(pow, expected);
}
- [Fact]
+ [Test]
public void PowLn()
{
var pow = new Pow(
@@ -82,7 +82,7 @@ public void PowLn()
SimplifyTest(pow, expected);
}
- [Fact]
+ [Test]
public void PowLb()
{
var pow = new Pow(
@@ -93,7 +93,7 @@ public void PowLb()
SimplifyTest(pow, expected);
}
- [Fact]
+ [Test]
public void RootOne()
{
var root = new Root(Variable.X, Number.One);
@@ -102,7 +102,7 @@ public void RootOne()
SimplifyTest(root, expected);
}
- [Fact]
+ [Test]
public void RootArgumentSimplified()
{
var root = new Root(Variable.X, new Add(Number.One, Number.One));
@@ -111,7 +111,7 @@ public void RootArgumentSimplified()
SimplifyTest(root, expected);
}
- [Fact]
+ [Test]
public void RootNotSimplified()
{
var root = new Root(Variable.X, new Number(5));
@@ -119,7 +119,7 @@ public void RootNotSimplified()
SimplifyTest(root, root);
}
- [Fact]
+ [Test]
public void Exp()
{
var exp = new Exp(new Number(30));
@@ -127,7 +127,7 @@ public void Exp()
SimplifyTest(exp, exp);
}
- [Fact]
+ [Test]
public void ExpLn()
{
var exp = new Exp(new Ln(new Number(30)));
@@ -136,7 +136,7 @@ public void ExpLn()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void ExpArgumentSimplified()
{
var exp = new Exp(new Add(Number.One, Number.One));
diff --git a/xFunc.Tests/Analyzers/SimplifierTests/SimplifierTest.cs b/xFunc.Tests/Analyzers/SimplifierTests/SimplifierTest.cs
index 18c48f882..5bd9c7204 100644
--- a/xFunc.Tests/Analyzers/SimplifierTests/SimplifierTest.cs
+++ b/xFunc.Tests/Analyzers/SimplifierTests/SimplifierTest.cs
@@ -7,7 +7,7 @@ namespace xFunc.Tests.Analyzers.SimplifierTests;
public class SimplifierTest : BaseSimplifierTest
{
- [Fact]
+ [Test]
public void DoubleUnary()
{
var un = new UnaryMinus(new UnaryMinus(Variable.X));
@@ -16,7 +16,7 @@ public void DoubleUnary()
SimplifyTest(un, expected);
}
- [Fact]
+ [Test]
public void UnaryNumber()
{
var un = new UnaryMinus(Number.One);
@@ -25,7 +25,7 @@ public void UnaryNumber()
SimplifyTest(un, expected);
}
- [Fact]
+ [Test]
public void UnaryNumberArgumentSimplified()
{
var un = new UnaryMinus(
@@ -38,7 +38,7 @@ public void UnaryNumberArgumentSimplified()
SimplifyTest(un, expected);
}
- [Fact]
+ [Test]
public void UnaryNumberNotSimplified()
{
var un = new UnaryMinus(Variable.X);
@@ -46,7 +46,7 @@ public void UnaryNumberNotSimplified()
SimplifyTest(un, un);
}
- [Fact]
+ [Test]
public void Define()
{
var define = new Assign(Variable.X, new Add(Number.Two, Number.Two));
@@ -55,7 +55,7 @@ public void Define()
SimplifyTest(define, expected);
}
- [Fact]
+ [Test]
public void DefineNotSimplifierTest()
{
var define = new Assign(Variable.X, Number.Two);
@@ -63,7 +63,7 @@ public void DefineNotSimplifierTest()
SimplifyTest(define, define);
}
- [Fact]
+ [Test]
public void Simplify()
{
var simp = new Simplify(simplifier, new Pow(Variable.X, Number.Zero));
@@ -72,7 +72,7 @@ public void Simplify()
SimplifyTest(simp, expected);
}
- [Fact]
+ [Test]
public void Deriv()
{
var diff = new Differentiator();
@@ -83,7 +83,7 @@ public void Deriv()
SimplifyTest(simp, expected);
}
- [Fact]
+ [Test]
public void DerivNotSimplifiedTest()
{
var differentiator = new Differentiator();
@@ -93,7 +93,7 @@ public void DerivNotSimplifiedTest()
SimplifyTest(exp, exp);
}
- [Fact]
+ [Test]
public void DiffTest()
{
var exp = new Count(new IExpression[] { new Add(Number.Two, Number.Two) });
@@ -102,7 +102,7 @@ public void DiffTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void UnaryMinusNumberTest()
{
var exp = new Abs(new UnaryMinus(Variable.X));
@@ -111,7 +111,7 @@ public void UnaryMinusNumberTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void AbsAbsTest()
{
var exp = new Abs(new Abs(Variable.X));
@@ -120,7 +120,7 @@ public void AbsAbsTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void AbsAbsAbsTest()
{
var exp = new Abs(new Abs(new Abs(Variable.X)));
@@ -129,7 +129,7 @@ public void AbsAbsAbsTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void AbsArgumentSimplifiedTest()
{
var exp = new Abs(new Add(Number.One, Number.One));
@@ -138,7 +138,7 @@ public void AbsArgumentSimplifiedTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void MatrixTest()
{
var exp = new Matrix(new[]
@@ -159,7 +159,7 @@ public void MatrixTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void MatrixNotSimplifiedTest()
{
var exp = new Matrix(new[]
@@ -170,7 +170,7 @@ public void MatrixNotSimplifiedTest()
SimplifyTest(exp, exp);
}
- [Fact]
+ [Test]
public void AddAssignTest()
{
var exp = new AddAssign(Variable.X, new Add(Number.One, Number.Two));
@@ -179,7 +179,7 @@ public void AddAssignTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void AddAssignNotSimplifiedTest()
{
var exp = new AddAssign(Variable.X, Number.One);
@@ -187,7 +187,7 @@ public void AddAssignNotSimplifiedTest()
SimplifyTest(exp, exp);
}
- [Fact]
+ [Test]
public void CeilArgumentSimplifiedTest()
{
var exp = new Ceil(new Add(Number.One, Number.One));
@@ -196,7 +196,7 @@ public void CeilArgumentSimplifiedTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void CeilNotSimplifiedTest()
{
var exp = new Ceil(Number.One);
@@ -204,7 +204,7 @@ public void CeilNotSimplifiedTest()
SimplifyTest(exp, exp);
}
- [Fact]
+ [Test]
public void ModLeftSimplifiedTest()
{
var exp = new Mod(new Add(Number.One, Number.One), Number.One);
@@ -213,7 +213,7 @@ public void ModLeftSimplifiedTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void ModRightSimplifiedTest()
{
var exp = new Mod(Number.One, new Add(Number.One, Number.One));
@@ -222,7 +222,7 @@ public void ModRightSimplifiedTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void ModNotSimplifiedTest()
{
var exp = new Mod(Number.One, Number.One);
@@ -230,7 +230,7 @@ public void ModNotSimplifiedTest()
SimplifyTest(exp, exp);
}
- [Fact]
+ [Test]
public void CallExpressionSimplifiedTest()
{
var exp = new CallExpression(
@@ -243,7 +243,7 @@ public void CallExpressionSimplifiedTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void CallExpressionNotSimplifiedTest()
{
var exp = new CallExpression(
@@ -253,7 +253,7 @@ public void CallExpressionNotSimplifiedTest()
SimplifyTest(exp, exp);
}
- [Fact]
+ [Test]
public void LambdaExpressionSimplifiedTest()
{
var exp = new Lambda(new[] { "x" }, new Add(Variable.X, Number.Zero)).AsExpression();
@@ -262,7 +262,7 @@ public void LambdaExpressionSimplifiedTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void LambdaExpressionNotSimplifiedTest()
{
var exp = new Lambda(new[] { "x" }, Variable.X).AsExpression();
@@ -270,11 +270,11 @@ public void LambdaExpressionNotSimplifiedTest()
SimplifyTest(exp, exp);
}
- [Theory]
- [ClassData(typeof(AllExpressionsData))]
+ [Test]
+ [TestCaseSource(typeof(AllExpressionsData))]
public void TestNullException(Type type) => TestNullExp(type);
- [Fact]
+ [Test]
public void MulOrderingTest()
{
// 2 * (1 * (3 * (x ^ (3 - 1))))
diff --git a/xFunc.Tests/Analyzers/SimplifierTests/SubSimplifierTest.cs b/xFunc.Tests/Analyzers/SimplifierTests/SubSimplifierTest.cs
index 12d17a137..feb5c047c 100644
--- a/xFunc.Tests/Analyzers/SimplifierTests/SubSimplifierTest.cs
+++ b/xFunc.Tests/Analyzers/SimplifierTests/SubSimplifierTest.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.SimplifierTests;
public class SubSimplifierTest : BaseSimplifierTest
{
- [Fact(DisplayName = "0 - x")]
+ [Test]
public void SubFirstZero()
{
var sub = new Sub(Number.Zero, Variable.X);
@@ -14,7 +14,7 @@ public void SubFirstZero()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "x - 0")]
+ [Test]
public void SubSecondZero()
{
var sub = new Sub(Variable.X, Number.Zero);
@@ -23,7 +23,7 @@ public void SubSecondZero()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "3 - 2")]
+ [Test]
public void SubTwoNumbers()
{
var sub = new Sub(new Number(3), Number.Two);
@@ -32,7 +32,7 @@ public void SubTwoNumbers()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "90 - 2 deg")]
+ [Test]
public void SubNumberAngle()
{
var sub = new Sub(
@@ -44,7 +44,7 @@ public void SubNumberAngle()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "90 deg - 2")]
+ [Test]
public void SubAngleNumber()
{
var sub = new Sub(
@@ -56,7 +56,7 @@ public void SubAngleNumber()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "2 rad - 90 deg")]
+ [Test]
public void SubTwoAngles()
{
var sub = new Sub(
@@ -68,7 +68,7 @@ public void SubTwoAngles()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 - 10 W")]
+ [Test]
public void SubPowerFromNumber()
{
var sub = new Sub(
@@ -80,7 +80,7 @@ public void SubPowerFromNumber()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 W - 10")]
+ [Test]
public void SubNumberFromPower()
{
var sub = new Sub(
@@ -92,7 +92,7 @@ public void SubNumberFromPower()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 kW - 10 W")]
+ [Test]
public void SubPowerFromPower()
{
var sub = new Sub(
@@ -104,7 +104,7 @@ public void SubPowerFromPower()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 - 10 C°")]
+ [Test]
public void SubTemperatureFromNumber()
{
var sub = new Sub(
@@ -116,7 +116,7 @@ public void SubTemperatureFromNumber()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 C° - 10")]
+ [Test]
public void SubNumberFromTemperature()
{
var sub = new Sub(
@@ -128,7 +128,7 @@ public void SubNumberFromTemperature()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 K - 10 C°")]
+ [Test]
public void SubTemperatureFromTemperature()
{
var sub = new Sub(
@@ -140,7 +140,7 @@ public void SubTemperatureFromTemperature()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 - 10 g")]
+ [Test]
public void SubMassFromNumber()
{
var sub = new Sub(
@@ -152,7 +152,7 @@ public void SubMassFromNumber()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 g - 10")]
+ [Test]
public void SubNumberFromMass()
{
var sub = new Sub(
@@ -164,7 +164,7 @@ public void SubNumberFromMass()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 kg - 10 g")]
+ [Test]
public void SubMassFromMass()
{
var sub = new Sub(
@@ -176,7 +176,7 @@ public void SubMassFromMass()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 - 10 m")]
+ [Test]
public void SubLengthFromNumber()
{
var sub = new Sub(
@@ -188,7 +188,7 @@ public void SubLengthFromNumber()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 m - 10")]
+ [Test]
public void SubNumberFromLength()
{
var sub = new Sub(
@@ -200,7 +200,7 @@ public void SubNumberFromLength()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 km - 10 m")]
+ [Test]
public void SubLengthFromLength()
{
var sub = new Sub(
@@ -212,7 +212,7 @@ public void SubLengthFromLength()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 - 10 s")]
+ [Test]
public void SubTimeFromNumber()
{
var sub = new Sub(
@@ -224,7 +224,7 @@ public void SubTimeFromNumber()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 s - 10")]
+ [Test]
public void SubNumberFromTime()
{
var sub = new Sub(
@@ -236,7 +236,7 @@ public void SubNumberFromTime()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 min - 10 s")]
+ [Test]
public void SubTimeFromTime()
{
var sub = new Sub(
@@ -248,7 +248,7 @@ public void SubTimeFromTime()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 - 10 m^2")]
+ [Test]
public void SubAreaFromNumber()
{
var sub = new Sub(
@@ -260,7 +260,7 @@ public void SubAreaFromNumber()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 m^2 - 10")]
+ [Test]
public void SubNumberFromArea()
{
var sub = new Sub(
@@ -272,7 +272,7 @@ public void SubNumberFromArea()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 km^2 - 10 m^2")]
+ [Test]
public void SubAreaFromArea()
{
var sub = new Sub(
@@ -284,7 +284,7 @@ public void SubAreaFromArea()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 - 10 m^3")]
+ [Test]
public void SubVolumeFromNumber()
{
var sub = new Sub(
@@ -296,7 +296,7 @@ public void SubVolumeFromNumber()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 m^3 - 10")]
+ [Test]
public void SubNumberFromVolume()
{
var sub = new Sub(
@@ -308,7 +308,7 @@ public void SubNumberFromVolume()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "20 m^3 - 10 cm^3")]
+ [Test]
public void SubVolumeAndVolume()
{
var sub = new Sub(
@@ -320,7 +320,7 @@ public void SubVolumeAndVolume()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "2 - -x")]
+ [Test]
public void SubSecondUnaryMinus()
{
var sub = new Sub(Number.Two, new UnaryMinus(Variable.X));
@@ -329,7 +329,7 @@ public void SubSecondUnaryMinus()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "(2 + x) - 2")]
+ [Test]
public void SubDiff_NumAddVar_SubNum()
{
var sub = new Sub(new Add(Number.Two, Variable.X), Number.Two);
@@ -338,7 +338,7 @@ public void SubDiff_NumAddVar_SubNum()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "(x + 2) - 2")]
+ [Test]
public void SubDiff_VarAddNum_SubNum()
{
var sub = new Sub(new Add(Variable.X, Number.Two), Number.Two);
@@ -347,7 +347,7 @@ public void SubDiff_VarAddNum_SubNum()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "2 - (2 + x)")]
+ [Test]
public void SubDiffNumSub_NumAddVar_()
{
var sub = new Sub(Number.Two, new Add(Number.Two, Variable.X));
@@ -356,7 +356,7 @@ public void SubDiffNumSub_NumAddVar_()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "2 - (x + 2)")]
+ [Test]
public void SubDiffNumSub_VarAddNum_()
{
var sub = new Sub(Number.Two, new Add(Variable.X, Number.Two));
@@ -365,7 +365,7 @@ public void SubDiffNumSub_VarAddNum_()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "(2 - x) - 2")]
+ [Test]
public void SubDiff_NumSubVar_SubNum()
{
var sub = new Sub(new Sub(Number.Two, Variable.X), Number.Two);
@@ -374,7 +374,7 @@ public void SubDiff_NumSubVar_SubNum()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "(x - 2) - 2")]
+ [Test]
public void SubDiff_VarSubNum_SubNum()
{
var sub = new Sub(new Sub(Variable.X, Number.Two), Number.Two);
@@ -383,7 +383,7 @@ public void SubDiff_VarSubNum_SubNum()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "2 - (2 - x)")]
+ [Test]
public void SubDiffNumSub_NumSubVar_()
{
var sub = new Sub(Number.Two, new Sub(Number.Two, Variable.X));
@@ -392,7 +392,7 @@ public void SubDiffNumSub_NumSubVar_()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "2 - (x - 2)")]
+ [Test]
public void SubDiffNumSub_VarSubNum_()
{
var sub = new Sub(Number.Two, new Sub(Variable.X, Number.Two));
@@ -401,7 +401,7 @@ public void SubDiffNumSub_VarSubNum_()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "x - x")]
+ [Test]
public void SubSameVars1()
{
var sub = new Sub(Variable.X, Variable.X);
@@ -410,7 +410,7 @@ public void SubSameVars1()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "(x - x) - x")]
+ [Test]
public void SubSameVars2()
{
var sub = new Sub(new Sub(Variable.X, Variable.X), Variable.X);
@@ -419,7 +419,7 @@ public void SubSameVars2()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "2x - x")]
+ [Test]
public void SubSameVars3()
{
var sub = new Sub(new Mul(Number.Two, Variable.X), Variable.X);
@@ -428,7 +428,7 @@ public void SubSameVars3()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "x - 2x")]
+ [Test]
public void SubSameVars4()
{
var sub = new Sub(Variable.X, new Mul(Number.Two, Variable.X));
@@ -437,7 +437,7 @@ public void SubSameVars4()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "(x + y) - 2 * (x + y)")]
+ [Test]
public void SubComplexX()
{
var sub = new Sub(
@@ -449,7 +449,7 @@ public void SubComplexX()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "x - (x * 2)")]
+ [Test]
public void SubSameVars5()
{
var sub = new Sub(Variable.X, new Mul(Variable.X, Number.Two));
@@ -458,7 +458,7 @@ public void SubSameVars5()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "2 * (x + y) - (x + y)")]
+ [Test]
public void SubComplexX2()
{
var sub = new Sub(
@@ -470,7 +470,7 @@ public void SubComplexX2()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "2x - x")]
+ [Test]
public void SubSameVars6()
{
var sub = new Sub(new Mul(Number.Two, Variable.X), Variable.X);
@@ -479,7 +479,7 @@ public void SubSameVars6()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "(x * 2) - x")]
+ [Test]
public void SubSameVars7()
{
var sub = new Sub(new Mul(Variable.X, Number.Two), Variable.X);
@@ -488,7 +488,7 @@ public void SubSameVars7()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "3x - 2x")]
+ [Test]
public void SubSameVars8()
{
var sub = new Sub(
@@ -500,7 +500,7 @@ public void SubSameVars8()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "3 * (x + y) - 2 * (x + y)")]
+ [Test]
public void SubComplexX3()
{
var sub = new Sub(
@@ -512,7 +512,7 @@ public void SubComplexX3()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "(x * 3) - (x * 2)")]
+ [Test]
public void SubSameVars9()
{
var sub = new Sub(
@@ -524,7 +524,7 @@ public void SubSameVars9()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "(x * 4) - (x * 2)")]
+ [Test]
public void SubSameVars10()
{
var sub = new Sub(
@@ -536,7 +536,7 @@ public void SubSameVars10()
SimplifyTest(sub, expected);
}
- [Fact(DisplayName = "3x - x * 2")]
+ [Test]
public void AddSameVars11()
{
var exp = new Sub(
@@ -548,7 +548,7 @@ public void AddSameVars11()
SimplifyTest(exp, expected);
}
- [Fact(DisplayName = "x * 3 - 2x")]
+ [Test]
public void AddSameVars12()
{
var exp = new Sub(
@@ -560,7 +560,7 @@ public void AddSameVars12()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void SubArgumentSimplified()
{
var exp = new Sub(
diff --git a/xFunc.Tests/Analyzers/SimplifierTests/ToNumberSimplifierTest.cs b/xFunc.Tests/Analyzers/SimplifierTests/ToNumberSimplifierTest.cs
index c43feab4e..507845ed3 100644
--- a/xFunc.Tests/Analyzers/SimplifierTests/ToNumberSimplifierTest.cs
+++ b/xFunc.Tests/Analyzers/SimplifierTests/ToNumberSimplifierTest.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.SimplifierTests;
public class ToNumberSimplifierTest : BaseSimplifierTest
{
- [Fact]
+ [Test]
public void AngleToNumberTest()
{
var exp = new ToNumber(AngleValue.Degree(10).AsExpression());
@@ -14,7 +14,7 @@ public void AngleToNumberTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void PowerToNumberTest()
{
var exp = new ToNumber(PowerValue.Watt(10).AsExpression());
@@ -23,7 +23,7 @@ public void PowerToNumberTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void TemperatureToNumberTest()
{
var exp = new ToNumber(TemperatureValue.Celsius(10).AsExpression());
@@ -32,7 +32,7 @@ public void TemperatureToNumberTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void MassToNumberTest()
{
var exp = new ToNumber(MassValue.Gram(10).AsExpression());
@@ -41,7 +41,7 @@ public void MassToNumberTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void LengthToNumberTest()
{
var exp = new ToNumber(LengthValue.Meter(10).AsExpression());
@@ -50,7 +50,7 @@ public void LengthToNumberTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void TimeToNumberTest()
{
var exp = new ToNumber(TimeValue.Second(10).AsExpression());
@@ -59,7 +59,7 @@ public void TimeToNumberTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void AreaToNumberTest()
{
var exp = new ToNumber(AreaValue.Meter(10).AsExpression());
@@ -68,7 +68,7 @@ public void AreaToNumberTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void VolumeToNumberTest()
{
var exp = new ToNumber(VolumeValue.Meter(10).AsExpression());
@@ -77,7 +77,7 @@ public void VolumeToNumberTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void ToNumberArgumentSimplifiedTest()
{
var exp = new ToNumber(new Add(Number.One, Number.One));
@@ -86,7 +86,7 @@ public void ToNumberArgumentSimplifiedTest()
SimplifyTest(exp, expected);
}
- [Fact]
+ [Test]
public void ToNumberNotSimplifiedTest()
{
var exp = new ToNumber(Variable.X);
diff --git a/xFunc.Tests/Analyzers/SimplifierTests/TrigonometricSimplifierTest.cs b/xFunc.Tests/Analyzers/SimplifierTests/TrigonometricSimplifierTest.cs
index 25899bd9e..808cce38e 100644
--- a/xFunc.Tests/Analyzers/SimplifierTests/TrigonometricSimplifierTest.cs
+++ b/xFunc.Tests/Analyzers/SimplifierTests/TrigonometricSimplifierTest.cs
@@ -5,22 +5,22 @@ namespace xFunc.Tests.Analyzers.SimplifierTests;
public class TrigonometricSimplifierTest : BaseSimplifierTest
{
- [Theory]
- [InlineData(typeof(Arcsin), typeof(Sin))]
- [InlineData(typeof(Arccos), typeof(Cos))]
- [InlineData(typeof(Arctan), typeof(Tan))]
- [InlineData(typeof(Arccot), typeof(Cot))]
- [InlineData(typeof(Arcsec), typeof(Sec))]
- [InlineData(typeof(Arccsc), typeof(Csc))]
- [InlineData(typeof(Tan), typeof(Arctan))]
- [InlineData(typeof(Cot), typeof(Arccot))]
- [InlineData(typeof(Arsinh), typeof(Sinh))]
- [InlineData(typeof(Arcosh), typeof(Cosh))]
- [InlineData(typeof(Artanh), typeof(Tanh))]
- [InlineData(typeof(Arcoth), typeof(Coth))]
- [InlineData(typeof(Arsech), typeof(Sech))]
- [InlineData(typeof(Arcsch), typeof(Csch))]
- [InlineData(typeof(Sinh), typeof(Arsinh))]
+ [Test]
+ [TestCase(typeof(Arcsin), typeof(Sin))]
+ [TestCase(typeof(Arccos), typeof(Cos))]
+ [TestCase(typeof(Arctan), typeof(Tan))]
+ [TestCase(typeof(Arccot), typeof(Cot))]
+ [TestCase(typeof(Arcsec), typeof(Sec))]
+ [TestCase(typeof(Arccsc), typeof(Csc))]
+ [TestCase(typeof(Tan), typeof(Arctan))]
+ [TestCase(typeof(Cot), typeof(Arccot))]
+ [TestCase(typeof(Arsinh), typeof(Sinh))]
+ [TestCase(typeof(Arcosh), typeof(Cosh))]
+ [TestCase(typeof(Artanh), typeof(Tanh))]
+ [TestCase(typeof(Arcoth), typeof(Coth))]
+ [TestCase(typeof(Arsech), typeof(Sech))]
+ [TestCase(typeof(Arcsch), typeof(Csch))]
+ [TestCase(typeof(Sinh), typeof(Arsinh))]
public void InverseFunctionsTest(Type outer, Type inner)
{
var innerFunction = Create(inner, Variable.X);
@@ -85,24 +85,24 @@ public static IEnumerable GetInverseDomainTestData()
yield return new object[] { new Coth(new Arcoth(Number.Two)), Number.Two };
}
- [Theory]
- [MemberData(nameof(GetInverseDomainTestData))]
+ [Test]
+ [TestCaseSource(nameof(GetInverseDomainTestData))]
public void InverseDomainTest(IExpression exp, IExpression expected)
=> SimplifyTest(exp, expected);
- [Theory]
- [InlineData(typeof(Arcsin))]
- [InlineData(typeof(Arccos))]
- [InlineData(typeof(Arctan))]
- [InlineData(typeof(Arccot))]
- [InlineData(typeof(Arcsec))]
- [InlineData(typeof(Arccsc))]
- [InlineData(typeof(Sin))]
- [InlineData(typeof(Cos))]
- [InlineData(typeof(Tan))]
- [InlineData(typeof(Cot))]
- [InlineData(typeof(Sec))]
- [InlineData(typeof(Csc))]
+ [Test]
+ [TestCase(typeof(Arcsin))]
+ [TestCase(typeof(Arccos))]
+ [TestCase(typeof(Arctan))]
+ [TestCase(typeof(Arccot))]
+ [TestCase(typeof(Arcsec))]
+ [TestCase(typeof(Arccsc))]
+ [TestCase(typeof(Sin))]
+ [TestCase(typeof(Cos))]
+ [TestCase(typeof(Tan))]
+ [TestCase(typeof(Cot))]
+ [TestCase(typeof(Sec))]
+ [TestCase(typeof(Csc))]
public void SimplifyArgumentTest(Type type)
{
var exp = Create(type, new Add(Number.One, Number.Two));
@@ -111,12 +111,12 @@ public void SimplifyArgumentTest(Type type)
SimplifyTest(exp, expected);
}
- [Theory]
- [InlineData(typeof(Cosh))]
- [InlineData(typeof(Coth))]
- [InlineData(typeof(Csch))]
- [InlineData(typeof(Sech))]
- [InlineData(typeof(Tanh))]
+ [Test]
+ [TestCase(typeof(Cosh))]
+ [TestCase(typeof(Coth))]
+ [TestCase(typeof(Csch))]
+ [TestCase(typeof(Sech))]
+ [TestCase(typeof(Tanh))]
public void CoshCopy(Type expType)
{
var exp = Create(expType, new Add(Number.One, Number.One));
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/AbsTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/AbsTests.cs
index f746d582f..fa69c83c1 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/AbsTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/AbsTests.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class AbsTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestAbsNumber()
{
var exp = new Abs(new Number(-2));
@@ -13,7 +13,7 @@ public void TestAbsNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestAbsAngleNumber()
{
var exp = new Abs(AngleValue.Degree(1).AsExpression());
@@ -21,7 +21,7 @@ public void TestAbsAngleNumber()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestAbsPowerNumber()
{
var exp = new Abs(PowerValue.Watt(1).AsExpression());
@@ -29,7 +29,7 @@ public void TestAbsPowerNumber()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestAbsTemperatureNumber()
{
var exp = new Abs(TemperatureValue.Celsius(1).AsExpression());
@@ -37,7 +37,7 @@ public void TestAbsTemperatureNumber()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestAbsMassNumber()
{
var exp = new Abs(MassValue.Gram(1).AsExpression());
@@ -45,7 +45,7 @@ public void TestAbsMassNumber()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestAbsLengthNumber()
{
var exp = new Abs(LengthValue.Meter(1).AsExpression());
@@ -53,7 +53,7 @@ public void TestAbsLengthNumber()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestAbsTimeNumber()
{
var exp = new Abs(TimeValue.Second(1).AsExpression());
@@ -61,7 +61,7 @@ public void TestAbsTimeNumber()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestAbsAreaNumber()
{
var exp = new Abs(AreaValue.Meter(1).AsExpression());
@@ -69,7 +69,7 @@ public void TestAbsAreaNumber()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestAbsVolumeNumber()
{
var exp = new Abs(VolumeValue.Meter(1).AsExpression());
@@ -77,7 +77,7 @@ public void TestAbsVolumeNumber()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestAbsComplexNumber()
{
var exp = new Abs(new ComplexNumber(2, 2));
@@ -85,7 +85,7 @@ public void TestAbsComplexNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestAbsVariable()
{
var exp = new Abs(Variable.X);
@@ -93,7 +93,7 @@ public void TestAbsVariable()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestAbsVector()
{
var exp = new Abs(new Vector(new IExpression[] { Number.One }));
@@ -101,7 +101,7 @@ public void TestAbsVector()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestAbsRational()
{
var exp = new Abs(new Rational(new Number(1), new Number(2)));
@@ -109,7 +109,7 @@ public void TestAbsRational()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestAbsException()
{
var exp = new Abs(Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/AddTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/AddTests.cs
index 10dc39045..c3686339e 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/AddTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/AddTests.cs
@@ -7,7 +7,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class AddTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestAddTwoNumberTest()
{
var add = new Add(Number.One, Number.Two);
@@ -15,7 +15,7 @@ public void TestAddTwoNumberTest()
Test(add, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestAddNumberVarTest()
{
var add = new Add(Number.One, Variable.X);
@@ -23,7 +23,7 @@ public void TestAddNumberVarTest()
Test(add, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestAddComplicatedTest()
{
var add = new Add(new Mul(Number.One, Number.Two), Variable.X);
@@ -31,7 +31,7 @@ public void TestAddComplicatedTest()
Test(add, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestAddTwoVectorTest()
{
var add = new Add(
@@ -42,7 +42,7 @@ public void TestAddTwoVectorTest()
Test(add, ResultTypes.Vector);
}
- [Fact]
+ [Test]
public void TestAddTwoMatrixTest()
{
var add = new Add(
@@ -53,7 +53,7 @@ public void TestAddTwoMatrixTest()
Test(add, ResultTypes.Matrix);
}
- [Fact]
+ [Test]
public void TestAddNumberVectorTest()
{
var exp = new Add(
@@ -64,7 +64,7 @@ public void TestAddNumberVectorTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestAddBoolVectorException()
{
var exp = new Add(Bool.True, new Vector(new IExpression[] { Number.One }));
@@ -72,7 +72,7 @@ public void TestAddBoolVectorException()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestAddVectorNumberTest()
{
var exp = new Add(new Vector(new IExpression[] { Number.One }), Bool.True);
@@ -80,7 +80,7 @@ public void TestAddVectorNumberTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestAddNumberMatrixTest()
{
var exp = new Add(
@@ -91,7 +91,7 @@ public void TestAddNumberMatrixTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestAddMatrixNumberTest()
{
var exp = new Add(
@@ -102,7 +102,7 @@ public void TestAddMatrixNumberTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestAddVectorMatrixTest()
{
var exp = new Add(
@@ -113,7 +113,7 @@ public void TestAddVectorMatrixTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestAddMatrixVectorTest()
{
var exp = new Add(
@@ -124,7 +124,7 @@ public void TestAddMatrixVectorTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestAddNumberComplexNumberTest()
{
var add = new Add(Number.One, new ComplexNumber(2, 1));
@@ -132,7 +132,7 @@ public void TestAddNumberComplexNumberTest()
Test(add, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestAddBoolComplexNumberException()
{
var add = new Add(Bool.True, new ComplexNumber(2, 1));
@@ -140,7 +140,7 @@ public void TestAddBoolComplexNumberException()
TestBinaryException(add);
}
- [Fact]
+ [Test]
public void TestAddComplexNumberNumberTest()
{
var add = new Add(new ComplexNumber(1, 3), Number.Two);
@@ -148,7 +148,7 @@ public void TestAddComplexNumberNumberTest()
Test(add, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestAddComplexNumberBoolException()
{
var add = new Add(new ComplexNumber(1, 3), Bool.True);
@@ -156,7 +156,7 @@ public void TestAddComplexNumberBoolException()
TestBinaryException(add);
}
- [Fact]
+ [Test]
public void TestAddComplexNumberComplexNumberTest()
{
var add = new Add(new ComplexNumber(1, 3), new ComplexNumber(2, 5));
@@ -164,7 +164,7 @@ public void TestAddComplexNumberComplexNumberTest()
Test(add, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestAddNumberAllTest()
{
var exp = new Add(
@@ -176,7 +176,7 @@ public void TestAddNumberAllTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestAddComplexNumberAllTest()
{
var exp = new Add(
@@ -188,7 +188,7 @@ public void TestAddComplexNumberAllTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestAddVectorAllTest()
{
var exp = new Add(
@@ -200,7 +200,7 @@ public void TestAddVectorAllTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestAddMatrixAllTest()
{
var matrix = new Matrix(new[]
@@ -216,7 +216,7 @@ public void TestAddMatrixAllTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestAddBoolAndMatrixTest()
{
var matrix = new Matrix(new[]
@@ -228,7 +228,7 @@ public void TestAddBoolAndMatrixTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestAddMatrixAndBoolTest()
{
var matrix = new Matrix(new[]
@@ -240,7 +240,7 @@ public void TestAddMatrixAndBoolTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestAddNumberSqrtComplexTest()
{
var exp = new Add(Number.Two, new Sqrt(new Number(-9)));
@@ -248,7 +248,7 @@ public void TestAddNumberSqrtComplexTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestAddTwoVarTest()
{
var exp = new Add(Variable.X, Variable.X);
@@ -256,7 +256,7 @@ public void TestAddTwoVarTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestAddThreeVarTest()
{
var exp = new Add(new Add(Variable.X, Variable.X), Variable.X);
@@ -264,7 +264,7 @@ public void TestAddThreeVarTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestAddException()
{
var exp = new Add(Bool.False, Bool.False);
@@ -272,7 +272,7 @@ public void TestAddException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestAddNumberAngle()
{
var exp = new Add(
@@ -283,7 +283,7 @@ public void TestAddNumberAngle()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestAddAngleNumber()
{
var exp = new Add(
@@ -294,7 +294,7 @@ public void TestAddAngleNumber()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestAddAngleAngle()
{
var exp = new Add(
@@ -305,7 +305,7 @@ public void TestAddAngleAngle()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestAddNumberPower()
{
var exp = new Add(
@@ -316,7 +316,7 @@ public void TestAddNumberPower()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestAddPowerNumber()
{
var exp = new Add(
@@ -327,7 +327,7 @@ public void TestAddPowerNumber()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestAddPowerPower()
{
var exp = new Add(
@@ -338,7 +338,7 @@ public void TestAddPowerPower()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestAddNumberTemperature()
{
var exp = new Add(
@@ -349,7 +349,7 @@ public void TestAddNumberTemperature()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestAddTemperatureNumber()
{
var exp = new Add(
@@ -360,7 +360,7 @@ public void TestAddTemperatureNumber()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestAddTemperatureTemperature()
{
var exp = new Add(
@@ -371,7 +371,7 @@ public void TestAddTemperatureTemperature()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestAddNumberAndMass()
{
var exp = new Add(
@@ -382,7 +382,7 @@ public void TestAddNumberAndMass()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestAddMassAndNumber()
{
var exp = new Add(
@@ -393,7 +393,7 @@ public void TestAddMassAndNumber()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestAddMassAndMass()
{
var exp = new Add(
@@ -404,7 +404,7 @@ public void TestAddMassAndMass()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestAddNumberAndLength()
{
var exp = new Add(
@@ -415,7 +415,7 @@ public void TestAddNumberAndLength()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestAddLengthAndNumber()
{
var exp = new Add(
@@ -426,7 +426,7 @@ public void TestAddLengthAndNumber()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestAddLengthAndLength()
{
var exp = new Add(
@@ -437,7 +437,7 @@ public void TestAddLengthAndLength()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestAddNumberAndTime()
{
var exp = new Add(
@@ -448,7 +448,7 @@ public void TestAddNumberAndTime()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestAddTimeAndNumber()
{
var exp = new Add(
@@ -459,7 +459,7 @@ public void TestAddTimeAndNumber()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestAddTimeAndTime()
{
var exp = new Add(
@@ -470,7 +470,7 @@ public void TestAddTimeAndTime()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestAddNumberAndArea()
{
var exp = new Add(
@@ -481,7 +481,7 @@ public void TestAddNumberAndArea()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestAddAreaAndNumber()
{
var exp = new Add(
@@ -492,7 +492,7 @@ public void TestAddAreaAndNumber()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestAddAreaAndArea()
{
var exp = new Add(
@@ -503,7 +503,7 @@ public void TestAddAreaAndArea()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestAddNumberAndVolume()
{
var exp = new Add(
@@ -514,7 +514,7 @@ public void TestAddNumberAndVolume()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestAddVolumeAndNumber()
{
var exp = new Add(
@@ -525,7 +525,7 @@ public void TestAddVolumeAndNumber()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestAddVolumeAndVolume()
{
var exp = new Add(
@@ -536,7 +536,7 @@ public void TestAddVolumeAndVolume()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestAddRationalAndRational()
{
var exp = new Add(
@@ -547,7 +547,7 @@ public void TestAddRationalAndRational()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestAddNumberAndRational()
{
var exp = new Add(
@@ -558,7 +558,7 @@ public void TestAddNumberAndRational()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestAddRationalAndNumber()
{
var exp = new Add(
@@ -569,7 +569,7 @@ public void TestAddRationalAndNumber()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestAddStringToString()
{
var exp = new Add(
@@ -580,7 +580,7 @@ public void TestAddStringToString()
Test(exp, ResultTypes.String);
}
- [Fact]
+ [Test]
public void TestAddStringToNumber()
{
var exp = new Add(
@@ -591,7 +591,7 @@ public void TestAddStringToNumber()
Test(exp, ResultTypes.String);
}
- [Fact]
+ [Test]
public void TestAddNumberToString()
{
var exp = new Add(
@@ -629,8 +629,8 @@ public static IEnumerable GetDataForTestAddAngleAndBoolTest()
yield return new object[] { Bool.False, VolumeValue.Meter(90).AsExpression() };
}
- [Theory]
- [MemberData(nameof(GetDataForTestAddAngleAndBoolTest))]
+ [Test]
+ [TestCaseSource(nameof(GetDataForTestAddAngleAndBoolTest))]
public void TestAddAngleAndBoolTest(IExpression left, IExpression right)
{
var exp = new Add(left, right);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/CeilTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/CeilTests.cs
index ee69ae955..d8a968cb3 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/CeilTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/CeilTests.cs
@@ -2,7 +2,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class CeilTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestCeilNumber()
{
var exp = new Ceil(new Number(-2));
@@ -10,7 +10,7 @@ public void TestCeilNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestCeilAngle()
{
var exp = new Ceil(AngleValue.Degree(5.5).AsExpression());
@@ -18,7 +18,7 @@ public void TestCeilAngle()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestCeilPower()
{
var exp = new Ceil(PowerValue.Watt(5.5).AsExpression());
@@ -26,7 +26,7 @@ public void TestCeilPower()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestCeilTemperature()
{
var exp = new Ceil(TemperatureValue.Celsius(5.5).AsExpression());
@@ -34,7 +34,7 @@ public void TestCeilTemperature()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestCeilMass()
{
var exp = new Ceil(MassValue.Gram(5.5).AsExpression());
@@ -42,7 +42,7 @@ public void TestCeilMass()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestCeilLength()
{
var exp = new Ceil(LengthValue.Meter(5.5).AsExpression());
@@ -50,7 +50,7 @@ public void TestCeilLength()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestCeilTime()
{
var exp = new Ceil(TimeValue.Second(5.5).AsExpression());
@@ -58,7 +58,7 @@ public void TestCeilTime()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestCeilArea()
{
var exp = new Ceil(AreaValue.Meter(5.5).AsExpression());
@@ -66,7 +66,7 @@ public void TestCeilArea()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestCeilVolume()
{
var exp = new Ceil(VolumeValue.Meter(5.5).AsExpression());
@@ -74,7 +74,7 @@ public void TestCeilVolume()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestCeilVariable()
{
var exp = new Ceil(Variable.X);
@@ -82,7 +82,7 @@ public void TestCeilVariable()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestCeilException()
{
var exp = new Ceil(Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ComplexNumberTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ComplexNumberTests.cs
index 4287e41c5..acfdd86ae 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ComplexNumberTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ComplexNumberTests.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class ComplexNumberTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestComplexNumber()
{
var exp = new ComplexNumber(2, 2);
@@ -13,7 +13,7 @@ public void TestComplexNumber()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestConjugateUndefined()
{
var exp = new Conjugate(Variable.X);
@@ -21,7 +21,7 @@ public void TestConjugateUndefined()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestConjugateComplexNumber()
{
var exp = new Conjugate(new ComplexNumber(2, 3));
@@ -29,7 +29,7 @@ public void TestConjugateComplexNumber()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestConjugateException()
{
var exp = new Conjugate(Number.Two);
@@ -37,7 +37,7 @@ public void TestConjugateException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestImUndefined()
{
var exp = new Im(Variable.X);
@@ -45,7 +45,7 @@ public void TestImUndefined()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestImComplexNumber()
{
var exp = new Im(new ComplexNumber(2, 3));
@@ -53,7 +53,7 @@ public void TestImComplexNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestImException()
{
var exp = new Im(Number.Two);
@@ -61,7 +61,7 @@ public void TestImException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestPhaseUndefined()
{
var exp = new Phase(Variable.X);
@@ -69,7 +69,7 @@ public void TestPhaseUndefined()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestPhaseComplexNumber()
{
var exp = new Phase(new ComplexNumber(2, 3));
@@ -77,7 +77,7 @@ public void TestPhaseComplexNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestPhaseException()
{
var exp = new Phase(Number.Two);
@@ -85,7 +85,7 @@ public void TestPhaseException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestReUndefined()
{
var exp = new Re(Variable.X);
@@ -93,7 +93,7 @@ public void TestReUndefined()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestReComplexNumber()
{
var exp = new Re(new ComplexNumber(2, 3));
@@ -101,7 +101,7 @@ public void TestReComplexNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestReException()
{
var exp = new Re(Number.Two);
@@ -109,7 +109,7 @@ public void TestReException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestReciprocalUndefined()
{
var exp = new Reciprocal(Variable.X);
@@ -117,7 +117,7 @@ public void TestReciprocalUndefined()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestReciprocalComplexNumber()
{
var exp = new Reciprocal(new ComplexNumber(2, 3));
@@ -125,7 +125,7 @@ public void TestReciprocalComplexNumber()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestReciprocalException()
{
var exp = new Reciprocal(Number.Two);
@@ -133,15 +133,15 @@ public void TestReciprocalException()
TestException(exp);
}
- [Fact]
+ [Test]
public void ToComplexUndefined()
=> Test(new ToComplex(Variable.X), ResultTypes.ComplexNumber);
- [Fact]
+ [Test]
public void ToComplexNubmer()
=> Test(new ToComplex(Number.One), ResultTypes.ComplexNumber);
- [Fact]
+ [Test]
public void ToComplexException()
=> TestException(new ToComplex(Bool.False));
}
\ No newline at end of file
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/DivTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/DivTests.cs
index a022214e6..e7c082261 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/DivTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/DivTests.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class DivTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestDivNumberNumberTest()
{
var exp = new Div(Number.One, Number.Two);
@@ -13,7 +13,7 @@ public void TestDivNumberNumberTest()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestDivComplexNumberComplexNumberTest()
{
var exp = new Div(new ComplexNumber(3, 2), new ComplexNumber(2, 4));
@@ -21,7 +21,7 @@ public void TestDivComplexNumberComplexNumberTest()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestDivNumberComplexNumberTest()
{
var exp = new Div(new Number(3), new ComplexNumber(2, 4));
@@ -29,7 +29,7 @@ public void TestDivNumberComplexNumberTest()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestDivComplexNumberNumberTest()
{
var exp = new Div(new ComplexNumber(3, 2), Number.Two);
@@ -37,7 +37,7 @@ public void TestDivComplexNumberNumberTest()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestDivComplexNumberBoolException()
{
var exp = new Div(new ComplexNumber(3, 2), Bool.True);
@@ -45,7 +45,7 @@ public void TestDivComplexNumberBoolException()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestDivBoolComplexNumberException()
{
var exp = new Div(Bool.True, new ComplexNumber(3, 2));
@@ -53,7 +53,7 @@ public void TestDivBoolComplexNumberException()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestDivNumberBoolException()
{
var exp = new Div(new Number(3), Bool.True);
@@ -61,7 +61,7 @@ public void TestDivNumberBoolException()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestDivBoolNumberException()
{
var exp = new Div(Bool.True, new Number(3));
@@ -69,7 +69,7 @@ public void TestDivBoolNumberException()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestDivNumberSqrtComplexTest()
{
var exp = new Div(new Sqrt(new Number(-16)), Number.Two);
@@ -77,7 +77,7 @@ public void TestDivNumberSqrtComplexTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestDivTwoVarTest()
{
var exp = new Div(Variable.X, Variable.X);
@@ -85,7 +85,7 @@ public void TestDivTwoVarTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestDivNumberAndVarTest()
{
var exp = new Div(Number.One, Variable.X);
@@ -93,7 +93,7 @@ public void TestDivNumberAndVarTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestDivThreeVarTest()
{
var exp = new Div(new Add(Variable.X, Variable.X), Variable.X);
@@ -101,7 +101,7 @@ public void TestDivThreeVarTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestDivException()
{
var exp = new Div(Bool.False, Bool.False);
@@ -109,7 +109,7 @@ public void TestDivException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestDivAngleNumber()
{
var exp = new Div(
@@ -120,7 +120,7 @@ public void TestDivAngleNumber()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestDivPowerNumber()
{
var exp = new Div(
@@ -131,7 +131,7 @@ public void TestDivPowerNumber()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestDivTemperatureNumber()
{
var exp = new Div(
@@ -142,7 +142,7 @@ public void TestDivTemperatureNumber()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestDivMassNumber()
{
var exp = new Div(
@@ -153,7 +153,7 @@ public void TestDivMassNumber()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestDivLengthNumber()
{
var exp = new Div(
@@ -164,7 +164,7 @@ public void TestDivLengthNumber()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestDivTimeNumber()
{
var exp = new Div(
@@ -175,7 +175,7 @@ public void TestDivTimeNumber()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestDivAreaNumber()
{
var exp = new Div(
@@ -186,7 +186,7 @@ public void TestDivAreaNumber()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestDivVolumeNumber()
{
var exp = new Div(
@@ -197,7 +197,7 @@ public void TestDivVolumeNumber()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestDivRationalAndRational()
{
var exp = new Div(
@@ -208,7 +208,7 @@ public void TestDivRationalAndRational()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestDivNumberAndRational()
{
var exp = new Div(
@@ -219,7 +219,7 @@ public void TestDivNumberAndRational()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestDivRationalAndNumber()
{
var exp = new Div(
@@ -242,8 +242,8 @@ public static IEnumerable GetDataForTestDivAngleAndBoolTest()
yield return new object[] { VolumeValue.Meter(90).AsExpression() };
}
- [Theory]
- [MemberData(nameof(GetDataForTestDivAngleAndBoolTest))]
+ [Test]
+ [TestCaseSource(nameof(GetDataForTestDivAngleAndBoolTest))]
public void TestDivAngleAndBoolTest(IExpression left)
{
var exp = new Div(left, Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/FloorTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/FloorTests.cs
index a06c6feda..0d9a64f88 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/FloorTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/FloorTests.cs
@@ -2,7 +2,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class FloorTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestFloorUndefined()
{
var exp = new Floor(Variable.X);
@@ -10,7 +10,7 @@ public void TestFloorUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestFloorNumber()
{
var exp = new Floor(new Number(10));
@@ -18,7 +18,7 @@ public void TestFloorNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestFloorAngle()
{
var exp = new Floor(AngleValue.Degree(5.5).AsExpression());
@@ -26,7 +26,7 @@ public void TestFloorAngle()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestFloorPower()
{
var exp = new Floor(PowerValue.Watt(5.5).AsExpression());
@@ -34,7 +34,7 @@ public void TestFloorPower()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestFloorTemperature()
{
var exp = new Floor(TemperatureValue.Celsius(5.5).AsExpression());
@@ -42,7 +42,7 @@ public void TestFloorTemperature()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestFloorMass()
{
var exp = new Floor(MassValue.Gram(5.5).AsExpression());
@@ -50,7 +50,7 @@ public void TestFloorMass()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestFloorLength()
{
var exp = new Floor(LengthValue.Meter(5.5).AsExpression());
@@ -58,7 +58,7 @@ public void TestFloorLength()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestFloorTime()
{
var exp = new Floor(TimeValue.Second(5.5).AsExpression());
@@ -66,7 +66,7 @@ public void TestFloorTime()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestFloorArea()
{
var exp = new Floor(AreaValue.Meter(5.5).AsExpression());
@@ -74,7 +74,7 @@ public void TestFloorArea()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestFloorVolume()
{
var exp = new Floor(VolumeValue.Meter(5.5).AsExpression());
@@ -82,7 +82,7 @@ public void TestFloorVolume()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestFloorException()
{
var exp = new Floor(Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/FracTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/FracTests.cs
index 05f1c63d0..f9e096c89 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/FracTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/FracTests.cs
@@ -2,7 +2,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class FracTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestFracUndefined()
{
var exp = new Frac(Variable.X);
@@ -10,7 +10,7 @@ public void TestFracUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestFracNumber()
{
var exp = new Frac(new Number(10));
@@ -18,7 +18,7 @@ public void TestFracNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestFracAngle()
{
var exp = new Frac(AngleValue.Degree(5.5).AsExpression());
@@ -26,7 +26,7 @@ public void TestFracAngle()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestFracPower()
{
var exp = new Frac(PowerValue.Watt(5.5).AsExpression());
@@ -34,7 +34,7 @@ public void TestFracPower()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestFracTemperature()
{
var exp = new Frac(TemperatureValue.Celsius(5.5).AsExpression());
@@ -42,7 +42,7 @@ public void TestFracTemperature()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestFracMass()
{
var exp = new Frac(MassValue.Gram(5.5).AsExpression());
@@ -50,7 +50,7 @@ public void TestFracMass()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestFracLength()
{
var exp = new Frac(LengthValue.Meter(5.5).AsExpression());
@@ -58,7 +58,7 @@ public void TestFracLength()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestFracTime()
{
var exp = new Frac(TimeValue.Second(5.5).AsExpression());
@@ -66,7 +66,7 @@ public void TestFracTime()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestFracArea()
{
var exp = new Frac(AreaValue.Meter(5.5).AsExpression());
@@ -74,7 +74,7 @@ public void TestFracArea()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestFracVolume()
{
var exp = new Frac(VolumeValue.Meter(5.5).AsExpression());
@@ -82,7 +82,7 @@ public void TestFracVolume()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestFracException()
{
var exp = new Frac(Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/HyperbolicTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/HyperbolicTests.cs
index 00ca6ab36..eace92892 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/HyperbolicTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/HyperbolicTests.cs
@@ -5,19 +5,19 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class HyperbolicTests : TypeAnalyzerBaseTests
{
- [Theory]
- [InlineData(typeof(Arcosh))]
- [InlineData(typeof(Arcoth))]
- [InlineData(typeof(Arcsch))]
- [InlineData(typeof(Arsech))]
- [InlineData(typeof(Arsinh))]
- [InlineData(typeof(Artanh))]
- [InlineData(typeof(Cosh))]
- [InlineData(typeof(Coth))]
- [InlineData(typeof(Csch))]
- [InlineData(typeof(Sech))]
- [InlineData(typeof(Sinh))]
- [InlineData(typeof(Tanh))]
+ [Test]
+ [TestCase(typeof(Arcosh))]
+ [TestCase(typeof(Arcoth))]
+ [TestCase(typeof(Arcsch))]
+ [TestCase(typeof(Arsech))]
+ [TestCase(typeof(Arsinh))]
+ [TestCase(typeof(Artanh))]
+ [TestCase(typeof(Cosh))]
+ [TestCase(typeof(Coth))]
+ [TestCase(typeof(Csch))]
+ [TestCase(typeof(Sech))]
+ [TestCase(typeof(Sinh))]
+ [TestCase(typeof(Tanh))]
public void TestUndefined(Type type)
{
var exp = Create(type, Variable.X);
@@ -25,13 +25,13 @@ public void TestUndefined(Type type)
Test(exp, ResultTypes.Undefined);
}
- [Theory]
- [InlineData(typeof(Arcosh))]
- [InlineData(typeof(Arcoth))]
- [InlineData(typeof(Arcsch))]
- [InlineData(typeof(Arsech))]
- [InlineData(typeof(Arsinh))]
- [InlineData(typeof(Artanh))]
+ [Test]
+ [TestCase(typeof(Arcosh))]
+ [TestCase(typeof(Arcoth))]
+ [TestCase(typeof(Arcsch))]
+ [TestCase(typeof(Arsech))]
+ [TestCase(typeof(Arsinh))]
+ [TestCase(typeof(Artanh))]
public void TestAngleNumber(Type type)
{
var exp = Create(type, Number.Two);
@@ -39,13 +39,13 @@ public void TestAngleNumber(Type type)
Test(exp, ResultTypes.AngleNumber);
}
- [Theory]
- [InlineData(typeof(Cosh))]
- [InlineData(typeof(Coth))]
- [InlineData(typeof(Csch))]
- [InlineData(typeof(Sech))]
- [InlineData(typeof(Sinh))]
- [InlineData(typeof(Tanh))]
+ [Test]
+ [TestCase(typeof(Cosh))]
+ [TestCase(typeof(Coth))]
+ [TestCase(typeof(Csch))]
+ [TestCase(typeof(Sech))]
+ [TestCase(typeof(Sinh))]
+ [TestCase(typeof(Tanh))]
public void TestNumber(Type type)
{
var exp = Create(type, Number.Two);
@@ -53,19 +53,19 @@ public void TestNumber(Type type)
Test(exp, ResultTypes.Number);
}
- [Theory]
- [InlineData(typeof(Arcosh))]
- [InlineData(typeof(Arcoth))]
- [InlineData(typeof(Arcsch))]
- [InlineData(typeof(Arsech))]
- [InlineData(typeof(Arsinh))]
- [InlineData(typeof(Artanh))]
- [InlineData(typeof(Cosh))]
- [InlineData(typeof(Coth))]
- [InlineData(typeof(Csch))]
- [InlineData(typeof(Sech))]
- [InlineData(typeof(Sinh))]
- [InlineData(typeof(Tanh))]
+ [Test]
+ [TestCase(typeof(Arcosh))]
+ [TestCase(typeof(Arcoth))]
+ [TestCase(typeof(Arcsch))]
+ [TestCase(typeof(Arsech))]
+ [TestCase(typeof(Arsinh))]
+ [TestCase(typeof(Artanh))]
+ [TestCase(typeof(Cosh))]
+ [TestCase(typeof(Coth))]
+ [TestCase(typeof(Csch))]
+ [TestCase(typeof(Sech))]
+ [TestCase(typeof(Sinh))]
+ [TestCase(typeof(Tanh))]
public void TestComplexNumber(Type type)
{
var exp = Create(type, new ComplexNumber(2, 2));
@@ -73,19 +73,19 @@ public void TestComplexNumber(Type type)
Test(exp, ResultTypes.ComplexNumber);
}
- [Theory]
- [InlineData(typeof(Arcosh))]
- [InlineData(typeof(Arcoth))]
- [InlineData(typeof(Arcsch))]
- [InlineData(typeof(Arsech))]
- [InlineData(typeof(Arsinh))]
- [InlineData(typeof(Artanh))]
- [InlineData(typeof(Cosh))]
- [InlineData(typeof(Coth))]
- [InlineData(typeof(Csch))]
- [InlineData(typeof(Sech))]
- [InlineData(typeof(Sinh))]
- [InlineData(typeof(Tanh))]
+ [Test]
+ [TestCase(typeof(Arcosh))]
+ [TestCase(typeof(Arcoth))]
+ [TestCase(typeof(Arcsch))]
+ [TestCase(typeof(Arsech))]
+ [TestCase(typeof(Arsinh))]
+ [TestCase(typeof(Artanh))]
+ [TestCase(typeof(Cosh))]
+ [TestCase(typeof(Coth))]
+ [TestCase(typeof(Csch))]
+ [TestCase(typeof(Sech))]
+ [TestCase(typeof(Sinh))]
+ [TestCase(typeof(Tanh))]
public void TestParameterException(Type type)
{
var exp = Create(type, Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/LogTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/LogTests.cs
index a4ce30489..bd0725ebb 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/LogTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/LogTests.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class LogTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestLbUndefined()
{
var exp = new Lb(Variable.X);
@@ -13,7 +13,7 @@ public void TestLbUndefined()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestLbNumber()
{
var exp = new Lb(new Number(10));
@@ -21,7 +21,7 @@ public void TestLbNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestLbRational()
{
var exp = new Lb(new Rational(new Number(2), new Number(3)));
@@ -29,7 +29,7 @@ public void TestLbRational()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestLbException()
{
var exp = new Lb(Bool.False);
@@ -37,7 +37,7 @@ public void TestLbException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestLgUndefined()
{
var exp = new Lg(Variable.X);
@@ -45,7 +45,7 @@ public void TestLgUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestLgNumber()
{
var exp = new Lg(new Number(10));
@@ -53,7 +53,7 @@ public void TestLgNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestLgComplexNumber()
{
var exp = new Lg(new ComplexNumber(10, 10));
@@ -61,7 +61,7 @@ public void TestLgComplexNumber()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestLgRational()
{
var exp = new Lg(new Rational(new Number(2), new Number(3)));
@@ -69,7 +69,7 @@ public void TestLgRational()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestLgException()
{
var exp = new Lg(Bool.False);
@@ -77,7 +77,7 @@ public void TestLgException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestLnUndefined()
{
var exp = new Ln(Variable.X);
@@ -85,7 +85,7 @@ public void TestLnUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestLnNumber()
{
var exp = new Ln(new Number(10));
@@ -93,7 +93,7 @@ public void TestLnNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestLnComplexNumber()
{
var exp = new Ln(new ComplexNumber(10, 10));
@@ -101,7 +101,7 @@ public void TestLnComplexNumber()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestLnRational()
{
var exp = new Ln(new Rational(new Number(2), new Number(3)));
@@ -109,7 +109,7 @@ public void TestLnRational()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestLnException()
{
var exp = new Ln(Bool.False);
@@ -117,7 +117,7 @@ public void TestLnException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestLogNumberAndUndefined()
{
var exp = new Log(Number.Two, Variable.X);
@@ -125,7 +125,7 @@ public void TestLogNumberAndUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestLogUndefinedAndNumber()
{
var exp = new Log(Variable.X, Number.Two);
@@ -133,7 +133,7 @@ public void TestLogUndefinedAndNumber()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestLogNumber()
{
var exp = new Log(Number.Two, new Number(4));
@@ -141,7 +141,7 @@ public void TestLogNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestLogComplexNumber()
{
var exp = new Log(Number.Two, new ComplexNumber(8, 3));
@@ -149,7 +149,7 @@ public void TestLogComplexNumber()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestLogRational()
{
var exp = new Log(new Number(3), new Rational(new Number(2), new Number(3)));
@@ -157,7 +157,7 @@ public void TestLogRational()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestLogException()
{
var exp = new Log(Number.Two, Bool.False);
@@ -165,7 +165,7 @@ public void TestLogException()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestLogBaseIsNotNumber()
{
var exp = new Log(Bool.False, Number.Two);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/LogicalBitwiseTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/LogicalBitwiseTests.cs
index 0725d4880..a8f28926f 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/LogicalBitwiseTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/LogicalBitwiseTests.cs
@@ -5,10 +5,10 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class LogicalBitwiseTests : TypeAnalyzerBaseTests
{
- [Theory]
- [InlineData(typeof(And))]
- [InlineData(typeof(Or))]
- [InlineData(typeof(XOr))]
+ [Test]
+ [TestCase(typeof(And))]
+ [TestCase(typeof(Or))]
+ [TestCase(typeof(XOr))]
public void TestLeftUndefined(Type type)
{
var exp = Create(type, Variable.X, Number.One);
@@ -16,10 +16,10 @@ public void TestLeftUndefined(Type type)
Test(exp, ResultTypes.Undefined);
}
- [Theory]
- [InlineData(typeof(And))]
- [InlineData(typeof(Or))]
- [InlineData(typeof(XOr))]
+ [Test]
+ [TestCase(typeof(And))]
+ [TestCase(typeof(Or))]
+ [TestCase(typeof(XOr))]
public void TestRightUndefined(Type type)
{
var exp = Create(type, Number.One, Variable.X);
@@ -27,10 +27,10 @@ public void TestRightUndefined(Type type)
Test(exp, ResultTypes.Undefined);
}
- [Theory]
- [InlineData(typeof(And))]
- [InlineData(typeof(Or))]
- [InlineData(typeof(XOr))]
+ [Test]
+ [TestCase(typeof(And))]
+ [TestCase(typeof(Or))]
+ [TestCase(typeof(XOr))]
public void TestNumber(Type type)
{
var exp = Create(type, Number.One, Number.One);
@@ -38,10 +38,10 @@ public void TestNumber(Type type)
Test(exp, ResultTypes.Number);
}
- [Theory]
- [InlineData(typeof(And))]
- [InlineData(typeof(Or))]
- [InlineData(typeof(XOr))]
+ [Test]
+ [TestCase(typeof(And))]
+ [TestCase(typeof(Or))]
+ [TestCase(typeof(XOr))]
public void TestBool(Type type)
{
var exp = Create(type, Bool.True, Bool.True);
@@ -49,10 +49,10 @@ public void TestBool(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(And))]
- [InlineData(typeof(Or))]
- [InlineData(typeof(XOr))]
+ [Test]
+ [TestCase(typeof(And))]
+ [TestCase(typeof(Or))]
+ [TestCase(typeof(XOr))]
public void TestComplexAndNumber(Type type)
{
var exp = CreateBinary(type, new ComplexNumber(3, 2), Number.One);
@@ -60,10 +60,10 @@ public void TestComplexAndNumber(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(And))]
- [InlineData(typeof(Or))]
- [InlineData(typeof(XOr))]
+ [Test]
+ [TestCase(typeof(And))]
+ [TestCase(typeof(Or))]
+ [TestCase(typeof(XOr))]
public void TestNumberAndComplex(Type type)
{
var exp = CreateBinary(type, Number.One, new ComplexNumber(3, 2));
@@ -71,10 +71,10 @@ public void TestNumberAndComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(And))]
- [InlineData(typeof(Or))]
- [InlineData(typeof(XOr))]
+ [Test]
+ [TestCase(typeof(And))]
+ [TestCase(typeof(Or))]
+ [TestCase(typeof(XOr))]
public void TestComplexAndBool(Type type)
{
var exp = CreateBinary(type, new ComplexNumber(3, 2), Bool.False);
@@ -82,10 +82,10 @@ public void TestComplexAndBool(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(And))]
- [InlineData(typeof(Or))]
- [InlineData(typeof(XOr))]
+ [Test]
+ [TestCase(typeof(And))]
+ [TestCase(typeof(Or))]
+ [TestCase(typeof(XOr))]
public void TestBoolAndComplex(Type type)
{
var exp = CreateBinary(type, Bool.False, new ComplexNumber(3, 2));
@@ -93,10 +93,10 @@ public void TestBoolAndComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(And))]
- [InlineData(typeof(Or))]
- [InlineData(typeof(XOr))]
+ [Test]
+ [TestCase(typeof(And))]
+ [TestCase(typeof(Or))]
+ [TestCase(typeof(XOr))]
public void TestParamTypeException(Type type)
{
var exp = Create(type, new ComplexNumber(3, 2), new ComplexNumber(3, 2));
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/LogicalTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/LogicalTests.cs
index 0c61e14b9..1e7a34b34 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/LogicalTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/LogicalTests.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class LogicalTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestBoolValue()
{
var exp = Bool.False;
@@ -13,11 +13,11 @@ public void TestBoolValue()
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equality))]
- [InlineData(typeof(Implication))]
- [InlineData(typeof(NAnd))]
- [InlineData(typeof(NOr))]
+ [Test]
+ [TestCase(typeof(Equality))]
+ [TestCase(typeof(Implication))]
+ [TestCase(typeof(NAnd))]
+ [TestCase(typeof(NOr))]
public void TestUndefined(Type type)
{
var exp = CreateBinary(type, Variable.X, Variable.X);
@@ -25,11 +25,11 @@ public void TestUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equality))]
- [InlineData(typeof(Implication))]
- [InlineData(typeof(NAnd))]
- [InlineData(typeof(NOr))]
+ [Test]
+ [TestCase(typeof(Equality))]
+ [TestCase(typeof(Implication))]
+ [TestCase(typeof(NAnd))]
+ [TestCase(typeof(NOr))]
public void TestBoolUndefined(Type type)
{
var exp = CreateBinary(type, Bool.True, Variable.X);
@@ -37,11 +37,11 @@ public void TestBoolUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equality))]
- [InlineData(typeof(Implication))]
- [InlineData(typeof(NAnd))]
- [InlineData(typeof(NOr))]
+ [Test]
+ [TestCase(typeof(Equality))]
+ [TestCase(typeof(Implication))]
+ [TestCase(typeof(NAnd))]
+ [TestCase(typeof(NOr))]
public void TestUndefinedBool(Type type)
{
var exp = CreateBinary(type, Variable.X, Bool.True);
@@ -49,11 +49,11 @@ public void TestUndefinedBool(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equality))]
- [InlineData(typeof(Implication))]
- [InlineData(typeof(NAnd))]
- [InlineData(typeof(NOr))]
+ [Test]
+ [TestCase(typeof(Equality))]
+ [TestCase(typeof(Implication))]
+ [TestCase(typeof(NAnd))]
+ [TestCase(typeof(NOr))]
public void TestBool(Type type)
{
var exp = CreateBinary(type, Bool.False, Bool.True);
@@ -61,11 +61,11 @@ public void TestBool(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equality))]
- [InlineData(typeof(Implication))]
- [InlineData(typeof(NAnd))]
- [InlineData(typeof(NOr))]
+ [Test]
+ [TestCase(typeof(Equality))]
+ [TestCase(typeof(Implication))]
+ [TestCase(typeof(NAnd))]
+ [TestCase(typeof(NOr))]
public void TestComplexBool(Type type)
{
var exp = CreateBinary(type, new ComplexNumber(2, 3), Bool.False);
@@ -73,11 +73,11 @@ public void TestComplexBool(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equality))]
- [InlineData(typeof(Implication))]
- [InlineData(typeof(NAnd))]
- [InlineData(typeof(NOr))]
+ [Test]
+ [TestCase(typeof(Equality))]
+ [TestCase(typeof(Implication))]
+ [TestCase(typeof(NAnd))]
+ [TestCase(typeof(NOr))]
public void TestBoolComplex(Type type)
{
var exp = CreateBinary(type, Bool.False, new ComplexNumber(2, 3));
@@ -85,11 +85,11 @@ public void TestBoolComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equality))]
- [InlineData(typeof(Implication))]
- [InlineData(typeof(NAnd))]
- [InlineData(typeof(NOr))]
+ [Test]
+ [TestCase(typeof(Equality))]
+ [TestCase(typeof(Implication))]
+ [TestCase(typeof(NAnd))]
+ [TestCase(typeof(NOr))]
public void TestParamTypeException(Type type)
{
var exp = CreateBinary(type, new ComplexNumber(2, 3), new ComplexNumber(2, 3));
@@ -97,7 +97,7 @@ public void TestParamTypeException(Type type)
TestException(exp);
}
- [Fact]
+ [Test]
public void TestNotUndefined()
{
var exp = new Not(Variable.X);
@@ -105,7 +105,7 @@ public void TestNotUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestNotNumber()
{
var exp = new Not(Number.One);
@@ -113,7 +113,7 @@ public void TestNotNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestNotBoolean()
{
var exp = new Not(Bool.True);
@@ -121,7 +121,7 @@ public void TestNotBoolean()
Test(exp, ResultTypes.Boolean);
}
- [Fact]
+ [Test]
public void TestNotException()
{
var exp = new Not(new ComplexNumber(1, 2));
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/MatrixTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/MatrixTests.cs
index b3df9b955..536d5c8a1 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/MatrixTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/MatrixTests.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class MatrixTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestVectorUndefined()
{
var exp = new Vector(new IExpression[] { new Number(10), Variable.X });
@@ -13,7 +13,7 @@ public void TestVectorUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestVectorNumber()
{
var exp = new Vector(new IExpression[] { new Number(10), new Number(10), new Number(10) });
@@ -21,7 +21,7 @@ public void TestVectorNumber()
Test(exp, ResultTypes.Vector);
}
- [Fact]
+ [Test]
public void TestVectorException()
{
var exp = new Vector(new IExpression[] { new ComplexNumber(10), new Number(10) });
@@ -29,7 +29,7 @@ public void TestVectorException()
TestDiffParamException(exp);
}
- [Fact]
+ [Test]
public void TestMatrixVector()
{
var exp = new Matrix(new[]
@@ -41,7 +41,7 @@ public void TestMatrixVector()
Test(exp, ResultTypes.Matrix);
}
- [Fact]
+ [Test]
public void TestMatrixVectorUndefined()
{
var exp = new Matrix(new[]
@@ -52,7 +52,7 @@ public void TestMatrixVectorUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestDeterminantUndefined()
{
var exp = new Determinant(Variable.X);
@@ -60,7 +60,7 @@ public void TestDeterminantUndefined()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestDeterminantMatrix()
{
var matrix = new Matrix(new[]
@@ -73,7 +73,7 @@ public void TestDeterminantMatrix()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestDeterminantException()
{
var exp = new Determinant(new ComplexNumber(2, 2));
@@ -81,7 +81,7 @@ public void TestDeterminantException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestDeterminantsException2()
{
var exp = new Determinant(
@@ -96,7 +96,7 @@ public void TestDeterminantsException2()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestInverseUndefined()
{
var exp = new Inverse(Variable.X);
@@ -104,7 +104,7 @@ public void TestInverseUndefined()
Test(exp, ResultTypes.Matrix);
}
- [Fact]
+ [Test]
public void TestInverseMatrix()
{
var matrix = new Matrix(new[]
@@ -117,7 +117,7 @@ public void TestInverseMatrix()
Test(exp, ResultTypes.Matrix);
}
- [Fact]
+ [Test]
public void TestInverseException()
{
var exp = new Inverse(new ComplexNumber(2, 2));
@@ -125,7 +125,7 @@ public void TestInverseException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestInverseException2()
{
var exp = new Inverse(
@@ -140,7 +140,7 @@ public void TestInverseException2()
TestException(exp);
}
- [Fact]
+ [Test]
public void DotProductUndefined()
{
var exp = new DotProduct(Variable.X, Variable.X);
@@ -148,7 +148,7 @@ public void DotProductUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void DotProductLeftUndefined()
{
var exp = new DotProduct(Variable.X, new Vector(new IExpression[] { Number.One }));
@@ -156,7 +156,7 @@ public void DotProductLeftUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void DotProductRightUndefined()
{
var exp = new DotProduct(new Vector(new IExpression[] { Number.One }), Variable.X);
@@ -164,7 +164,7 @@ public void DotProductRightUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void DotProduct()
{
var exp = new DotProduct(
@@ -174,7 +174,7 @@ public void DotProduct()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void DotProductLeftException()
{
var exp = new DotProduct(
@@ -184,7 +184,7 @@ public void DotProductLeftException()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void DotProductRightException()
{
var exp = new DotProduct(
@@ -194,7 +194,7 @@ public void DotProductRightException()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void CrossProductUndefined()
{
var exp = new CrossProduct(Variable.X, Variable.X);
@@ -202,7 +202,7 @@ public void CrossProductUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void CrossProductLeftUndefined()
{
var exp = new CrossProduct(Variable.X, new Vector(new IExpression[] { Number.One }));
@@ -210,7 +210,7 @@ public void CrossProductLeftUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void CrossProductRightUndefined()
{
var exp = new CrossProduct(new Vector(new IExpression[] { Number.One }), Variable.X);
@@ -218,7 +218,7 @@ public void CrossProductRightUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void CrossProduct()
{
var exp = new CrossProduct(
@@ -228,7 +228,7 @@ public void CrossProduct()
Test(exp, ResultTypes.Vector);
}
- [Fact]
+ [Test]
public void CrossProductLeftException()
{
var exp = new CrossProduct(
@@ -238,7 +238,7 @@ public void CrossProductLeftException()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void CrossProductRightException()
{
var exp = new CrossProduct(
@@ -248,7 +248,7 @@ public void CrossProductRightException()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestTransposeUndefined()
{
var exp = new Transpose(Variable.X);
@@ -256,7 +256,7 @@ public void TestTransposeUndefined()
Test(exp, ResultTypes.Matrix);
}
- [Fact]
+ [Test]
public void TestTransposeMatrix()
{
var matrix = new Matrix(new[]
@@ -269,7 +269,7 @@ public void TestTransposeMatrix()
Test(exp, ResultTypes.Matrix);
}
- [Fact]
+ [Test]
public void TestTransposeException()
{
var exp = new Transpose(new ComplexNumber(2, 2));
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/MulTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/MulTests.cs
index aa6cc498e..1da13000b 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/MulTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/MulTests.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class MulTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestMulTwoNumberTest()
{
var mul = new Mul(Number.One, Number.Two);
@@ -13,7 +13,7 @@ public void TestMulTwoNumberTest()
Test(mul, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestMulNumberVarTest()
{
var mul = new Mul(Number.One, Variable.X);
@@ -21,7 +21,7 @@ public void TestMulNumberVarTest()
Test(mul, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestMulNumberBoolTest()
{
var mul = new Mul(Number.One, Bool.True);
@@ -29,7 +29,7 @@ public void TestMulNumberBoolTest()
TestBinaryException(mul);
}
- [Fact]
+ [Test]
public void TestMulBoolNumberTest()
{
var mul = new Mul(Bool.True, Number.One);
@@ -37,7 +37,7 @@ public void TestMulBoolNumberTest()
TestBinaryException(mul);
}
- [Fact]
+ [Test]
public void TestMulVarNumberTest()
{
var mul = new Mul(Variable.X, Number.One);
@@ -45,7 +45,7 @@ public void TestMulVarNumberTest()
Test(mul, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestMulTwoMatrixTest()
{
var mul = new Mul(
@@ -56,7 +56,7 @@ public void TestMulTwoMatrixTest()
Test(mul, ResultTypes.Matrix);
}
- [Fact]
+ [Test]
public void TestMulLeftMatrixRightException()
{
var mul = new Mul(
@@ -67,7 +67,7 @@ public void TestMulLeftMatrixRightException()
TestBinaryException(mul);
}
- [Fact]
+ [Test]
public void TestMulRightMatrixLeftException()
{
var mul = new Mul(
@@ -78,7 +78,7 @@ public void TestMulRightMatrixLeftException()
TestBinaryException(mul);
}
- [Fact]
+ [Test]
public void TestMulNumberVectorTest()
{
var mul = new Mul(
@@ -89,7 +89,7 @@ public void TestMulNumberVectorTest()
Test(mul, ResultTypes.Vector);
}
- [Fact]
+ [Test]
public void TestMulVectorNumber()
{
var mul = new Mul(
@@ -100,7 +100,7 @@ public void TestMulVectorNumber()
Test(mul, ResultTypes.Vector);
}
- [Fact]
+ [Test]
public void TestMulVectors()
{
var mul = new Mul(
@@ -111,7 +111,7 @@ public void TestMulVectors()
Test(mul, ResultTypes.Vector);
}
- [Fact]
+ [Test]
public void TestMulNumberMatrixTest()
{
var mul = new Mul(
@@ -122,7 +122,7 @@ public void TestMulNumberMatrixTest()
Test(mul, ResultTypes.Matrix);
}
- [Fact]
+ [Test]
public void TestMulMatrixAndNumberTest()
{
var mul = new Mul(
@@ -133,7 +133,7 @@ public void TestMulMatrixAndNumberTest()
Test(mul, ResultTypes.Matrix);
}
- [Fact]
+ [Test]
public void TestMulVectorMatrixTest()
{
var mul = new Mul(
@@ -144,7 +144,7 @@ public void TestMulVectorMatrixTest()
Test(mul, ResultTypes.Matrix);
}
- [Fact]
+ [Test]
public void TestMulMatrixAndVectorTest()
{
var mul = new Mul(
@@ -155,7 +155,7 @@ public void TestMulMatrixAndVectorTest()
Test(mul, ResultTypes.Matrix);
}
- [Fact]
+ [Test]
public void TestMulVectorBoolException()
{
var mul = new Mul(new Vector(new IExpression[] { Number.One }), Bool.False);
@@ -163,7 +163,7 @@ public void TestMulVectorBoolException()
TestBinaryException(mul);
}
- [Fact]
+ [Test]
public void TestMulBoolVectorException()
{
var mul = new Mul(Bool.False, new Vector(new IExpression[] { Number.One }));
@@ -171,7 +171,7 @@ public void TestMulBoolVectorException()
TestBinaryException(mul);
}
- [Fact]
+ [Test]
public void TestMulComplexNumberComplexNumberTest()
{
var exp = new Mul(new ComplexNumber(2, 5), new ComplexNumber(3, 2));
@@ -179,7 +179,7 @@ public void TestMulComplexNumberComplexNumberTest()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestMulComplexNumberNumberTest()
{
var exp = new Mul(new ComplexNumber(2, 5), Number.Two);
@@ -187,7 +187,7 @@ public void TestMulComplexNumberNumberTest()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestMulComplexNumberBoolTest()
{
var exp = new Mul(new ComplexNumber(2, 5), Bool.True);
@@ -195,7 +195,7 @@ public void TestMulComplexNumberBoolTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestMulNumberComplexNumberTest()
{
var exp = new Mul(Number.Two, new ComplexNumber(3, 2));
@@ -203,7 +203,7 @@ public void TestMulNumberComplexNumberTest()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestMulBoolComplexNumberTest()
{
var exp = new Mul(Bool.True, new ComplexNumber(2, 5));
@@ -211,7 +211,7 @@ public void TestMulBoolComplexNumberTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestMulException()
{
var exp = new Mul(Bool.False, Bool.True);
@@ -219,7 +219,7 @@ public void TestMulException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestMulNumberAngle()
{
var exp = new Mul(
@@ -230,7 +230,7 @@ public void TestMulNumberAngle()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestMulAngleNumber()
{
var exp = new Mul(
@@ -241,7 +241,7 @@ public void TestMulAngleNumber()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestMulNumberPower()
{
var exp = new Mul(
@@ -252,7 +252,7 @@ public void TestMulNumberPower()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestMulPowerNumber()
{
var exp = new Mul(
@@ -263,7 +263,7 @@ public void TestMulPowerNumber()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestMulNumberTemperature()
{
var exp = new Mul(
@@ -274,7 +274,7 @@ public void TestMulNumberTemperature()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestMulTemperatureNumber()
{
var exp = new Mul(
@@ -285,7 +285,7 @@ public void TestMulTemperatureNumber()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestMulNumberAndMass()
{
var exp = new Mul(
@@ -296,7 +296,7 @@ public void TestMulNumberAndMass()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestMulMassAndNumber()
{
var exp = new Mul(
@@ -307,7 +307,7 @@ public void TestMulMassAndNumber()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestMulNumberAndLength()
{
var exp = new Mul(
@@ -318,7 +318,7 @@ public void TestMulNumberAndLength()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestMulLengthAndNumber()
{
var exp = new Mul(
@@ -329,7 +329,7 @@ public void TestMulLengthAndNumber()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestMulLengthAndLength()
{
var exp = new Mul(
@@ -340,7 +340,7 @@ public void TestMulLengthAndLength()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestMulAreaAndLength()
{
var exp = new Mul(
@@ -351,7 +351,7 @@ public void TestMulAreaAndLength()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestMulLengthAndArea()
{
var exp = new Mul(
@@ -362,7 +362,7 @@ public void TestMulLengthAndArea()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestMulNumberAndTime()
{
var exp = new Mul(
@@ -373,7 +373,7 @@ public void TestMulNumberAndTime()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestMulTimeAndNumber()
{
var exp = new Mul(
@@ -384,7 +384,7 @@ public void TestMulTimeAndNumber()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestMulNumberAndArea()
{
var exp = new Mul(
@@ -395,7 +395,7 @@ public void TestMulNumberAndArea()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestMulAreaAndNumber()
{
var exp = new Mul(
@@ -406,7 +406,7 @@ public void TestMulAreaAndNumber()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestMulNumberAndVolume()
{
var exp = new Mul(
@@ -417,7 +417,7 @@ public void TestMulNumberAndVolume()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestMulVolumeAndNumber()
{
var exp = new Mul(
@@ -428,7 +428,7 @@ public void TestMulVolumeAndNumber()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestMulRationalAndRational()
{
var exp = new Mul(
@@ -439,7 +439,7 @@ public void TestMulRationalAndRational()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestMulNumberAndRational()
{
var exp = new Mul(
@@ -450,7 +450,7 @@ public void TestMulNumberAndRational()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestMulRationalAndNumber()
{
var exp = new Mul(
@@ -488,8 +488,8 @@ public static IEnumerable GetDataForTestMulAngleAndBoolTest()
yield return new object[] { Bool.False, VolumeValue.Meter(90).AsExpression() };
}
- [Theory]
- [MemberData(nameof(GetDataForTestMulAngleAndBoolTest))]
+ [Test]
+ [TestCaseSource(nameof(GetDataForTestMulAngleAndBoolTest))]
public void TestMulAngleAndBoolTest(IExpression left, IExpression right)
{
var exp = new Mul(left, right);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/NumericConvertionTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/NumericConvertionTests.cs
index a6d04629d..da8d9cb8f 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/NumericConvertionTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/NumericConvertionTests.cs
@@ -5,10 +5,10 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class NumericConvertionTests : TypeAnalyzerBaseTests
{
- [Theory]
- [InlineData(typeof(ToBin))]
- [InlineData(typeof(ToOct))]
- [InlineData(typeof(ToHex))]
+ [Test]
+ [TestCase(typeof(ToBin))]
+ [TestCase(typeof(ToOct))]
+ [TestCase(typeof(ToHex))]
public void UndefinedTest(Type type)
{
var exp = Create(type, Variable.X);
@@ -16,10 +16,10 @@ public void UndefinedTest(Type type)
Test(exp, ResultTypes.String);
}
- [Theory]
- [InlineData(typeof(ToBin))]
- [InlineData(typeof(ToOct))]
- [InlineData(typeof(ToHex))]
+ [Test]
+ [TestCase(typeof(ToBin))]
+ [TestCase(typeof(ToOct))]
+ [TestCase(typeof(ToHex))]
public void NumberTest(Type type)
{
var exp = Create(type, new Number(10));
@@ -27,10 +27,10 @@ public void NumberTest(Type type)
Test(exp, ResultTypes.String);
}
- [Theory]
- [InlineData(typeof(ToBin))]
- [InlineData(typeof(ToOct))]
- [InlineData(typeof(ToHex))]
+ [Test]
+ [TestCase(typeof(ToBin))]
+ [TestCase(typeof(ToOct))]
+ [TestCase(typeof(ToHex))]
public void BoolTest(Type type)
{
var exp = Create(type, Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/PowTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/PowTests.cs
index a84829da6..2d205a295 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/PowTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/PowTests.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class PowTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestPowComplexAndUndefined()
{
var exp = new Pow(new ComplexNumber(2, 2), Variable.X);
@@ -13,7 +13,7 @@ public void TestPowComplexAndUndefined()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestPowComplexAndNumber()
{
var exp = new Pow(new ComplexNumber(2, 4), new Number(4));
@@ -21,7 +21,7 @@ public void TestPowComplexAndNumber()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestPowComplexAndComplex()
{
var exp = new Pow(new ComplexNumber(4, 2), new ComplexNumber(2, 4));
@@ -29,7 +29,7 @@ public void TestPowComplexAndComplex()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestPowUndefinedAndNumber()
{
var exp = new Pow(Variable.X, Number.Two);
@@ -37,7 +37,7 @@ public void TestPowUndefinedAndNumber()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestPowNumberAndUndefined()
{
var exp = new Pow(Number.Two, Variable.X);
@@ -45,7 +45,7 @@ public void TestPowNumberAndUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestPowNumber()
{
var exp = new Pow(new Number(4), Number.Two);
@@ -53,7 +53,7 @@ public void TestPowNumber()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestNumberAndComplex()
{
var exp = new Pow(Number.Two, new ComplexNumber(2, 4));
@@ -61,7 +61,7 @@ public void TestNumberAndComplex()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestRationalAndNumber()
{
var exp = new Pow(
@@ -71,7 +71,7 @@ public void TestRationalAndNumber()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestPowException()
{
var exp = new Pow(Bool.False, Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/AssignmentOperatorsTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/AssignmentOperatorsTests.cs
index b161a4ae2..76b21bb0d 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/AssignmentOperatorsTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/AssignmentOperatorsTests.cs
@@ -5,13 +5,13 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests.ProgrammingTests;
public class AssignmentOperatorsTests : TypeAnalyzerBaseTests
{
- [Theory]
- [InlineData(typeof(AddAssign))]
- [InlineData(typeof(SubAssign))]
- [InlineData(typeof(MulAssign))]
- [InlineData(typeof(DivAssign))]
- [InlineData(typeof(LeftShiftAssign))]
- [InlineData(typeof(RightShiftAssign))]
+ [Test]
+ [TestCase(typeof(AddAssign))]
+ [TestCase(typeof(SubAssign))]
+ [TestCase(typeof(MulAssign))]
+ [TestCase(typeof(DivAssign))]
+ [TestCase(typeof(LeftShiftAssign))]
+ [TestCase(typeof(RightShiftAssign))]
public void TestAssignUndefined(Type type)
{
var exp = Create(type, Variable.X, Variable.X);
@@ -19,13 +19,13 @@ public void TestAssignUndefined(Type type)
Test(exp, ResultTypes.Number);
}
- [Theory]
- [InlineData(typeof(AddAssign))]
- [InlineData(typeof(SubAssign))]
- [InlineData(typeof(MulAssign))]
- [InlineData(typeof(DivAssign))]
- [InlineData(typeof(LeftShiftAssign))]
- [InlineData(typeof(RightShiftAssign))]
+ [Test]
+ [TestCase(typeof(AddAssign))]
+ [TestCase(typeof(SubAssign))]
+ [TestCase(typeof(MulAssign))]
+ [TestCase(typeof(DivAssign))]
+ [TestCase(typeof(LeftShiftAssign))]
+ [TestCase(typeof(RightShiftAssign))]
public void TestAssignNumber(Type type)
{
var exp = Create(type, Variable.X, new Number(10));
@@ -33,13 +33,13 @@ public void TestAssignNumber(Type type)
Test(exp, ResultTypes.Number);
}
- [Theory]
- [InlineData(typeof(AddAssign))]
- [InlineData(typeof(SubAssign))]
- [InlineData(typeof(MulAssign))]
- [InlineData(typeof(DivAssign))]
- [InlineData(typeof(LeftShiftAssign))]
- [InlineData(typeof(RightShiftAssign))]
+ [Test]
+ [TestCase(typeof(AddAssign))]
+ [TestCase(typeof(SubAssign))]
+ [TestCase(typeof(MulAssign))]
+ [TestCase(typeof(DivAssign))]
+ [TestCase(typeof(LeftShiftAssign))]
+ [TestCase(typeof(RightShiftAssign))]
public void TestAssignException(Type type)
{
var exp = Create(type, Variable.X, Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/ConditionalOperatorsTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/ConditionalOperatorsTests.cs
index b6073e401..8f54a4dfe 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/ConditionalOperatorsTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/ConditionalOperatorsTests.cs
@@ -5,9 +5,9 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests.ProgrammingTests;
public class ConditionalOperatorsTests : TypeAnalyzerBaseTests
{
- [Theory]
- [InlineData(typeof(ConditionalAnd))]
- [InlineData(typeof(ConditionalOr))]
+ [Test]
+ [TestCase(typeof(ConditionalAnd))]
+ [TestCase(typeof(ConditionalOr))]
public void TestUndefined(Type type)
{
var exp = CreateBinary(type, Variable.X, Variable.X);
@@ -15,9 +15,9 @@ public void TestUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(ConditionalAnd))]
- [InlineData(typeof(ConditionalOr))]
+ [Test]
+ [TestCase(typeof(ConditionalAnd))]
+ [TestCase(typeof(ConditionalOr))]
public void TestBoolUndefined(Type type)
{
var exp = CreateBinary(type, Bool.True, Variable.X);
@@ -25,9 +25,9 @@ public void TestBoolUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(ConditionalAnd))]
- [InlineData(typeof(ConditionalOr))]
+ [Test]
+ [TestCase(typeof(ConditionalAnd))]
+ [TestCase(typeof(ConditionalOr))]
public void TestUndefinedBool(Type type)
{
var exp = CreateBinary(type, Variable.X, Bool.True);
@@ -35,9 +35,9 @@ public void TestUndefinedBool(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(ConditionalAnd))]
- [InlineData(typeof(ConditionalOr))]
+ [Test]
+ [TestCase(typeof(ConditionalAnd))]
+ [TestCase(typeof(ConditionalOr))]
public void TestBool(Type type)
{
var exp = CreateBinary(type, Bool.False, Bool.True);
@@ -45,9 +45,9 @@ public void TestBool(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(ConditionalAnd))]
- [InlineData(typeof(ConditionalOr))]
+ [Test]
+ [TestCase(typeof(ConditionalAnd))]
+ [TestCase(typeof(ConditionalOr))]
public void TestComplexBool(Type type)
{
var exp = CreateBinary(type, new ComplexNumber(2, 3), Bool.False);
@@ -55,9 +55,9 @@ public void TestComplexBool(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(ConditionalAnd))]
- [InlineData(typeof(ConditionalOr))]
+ [Test]
+ [TestCase(typeof(ConditionalAnd))]
+ [TestCase(typeof(ConditionalOr))]
public void TestBoolComplex(Type type)
{
var exp = CreateBinary(type, Bool.False, new ComplexNumber(2, 3));
@@ -65,9 +65,9 @@ public void TestBoolComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(ConditionalAnd))]
- [InlineData(typeof(ConditionalOr))]
+ [Test]
+ [TestCase(typeof(ConditionalAnd))]
+ [TestCase(typeof(ConditionalOr))]
public void TestConditionalException(Type type)
{
var exp = CreateBinary(type, new ComplexNumber(2, 3), new ComplexNumber(2, 3));
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/EqualityOperatorsTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/EqualityOperatorsTests.cs
index 6ae79d88f..181cf56c6 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/EqualityOperatorsTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/EqualityOperatorsTests.cs
@@ -5,9 +5,9 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests.ProgrammingTests;
public class EqualityOperatorsTests : TypeAnalyzerBaseTests
{
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestUndefined(Type type)
{
var exp = Create(type, Variable.X, Variable.X);
@@ -15,9 +15,9 @@ public void TestUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestNumberAndUndefined(Type type)
{
var exp = Create(type, Number.One, Variable.X);
@@ -25,9 +25,9 @@ public void TestNumberAndUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestUndefinedAndNumber(Type type)
{
var exp = Create(type, Variable.X, Number.One);
@@ -35,9 +35,9 @@ public void TestUndefinedAndNumber(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestBoolAndUndefined(Type type)
{
var exp = Create(type, Bool.True, Variable.X);
@@ -45,9 +45,9 @@ public void TestBoolAndUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestUndefinedAndBool(Type type)
{
var exp = Create(type, Variable.X, Bool.True);
@@ -55,9 +55,9 @@ public void TestUndefinedAndBool(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestAngleAndUndefined(Type type)
{
var exp = Create(type, AngleValue.Degree(1).AsExpression(), Variable.X);
@@ -65,9 +65,9 @@ public void TestAngleAndUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestUndefinedAndAngle(Type type)
{
var exp = Create(type, Variable.X, AngleValue.Degree(1).AsExpression());
@@ -75,9 +75,9 @@ public void TestUndefinedAndAngle(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestPowerAndUndefined(Type type)
{
var exp = Create(type, PowerValue.Watt(1).AsExpression(), Variable.X);
@@ -85,9 +85,9 @@ public void TestPowerAndUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestUndefinedAndPower(Type type)
{
var exp = Create(type, Variable.X, PowerValue.Watt(1).AsExpression());
@@ -95,9 +95,9 @@ public void TestUndefinedAndPower(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestTemperatureAndUndefined(Type type)
{
var exp = Create(type, TemperatureValue.Celsius(1).AsExpression(), Variable.X);
@@ -105,9 +105,9 @@ public void TestTemperatureAndUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestUndefinedAndTemperature(Type type)
{
var exp = Create(type, Variable.X, TemperatureValue.Celsius(1).AsExpression());
@@ -115,9 +115,9 @@ public void TestUndefinedAndTemperature(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestMassAndUndefined(Type type)
{
var exp = Create(type, MassValue.Gram(1).AsExpression(), Variable.X);
@@ -125,9 +125,9 @@ public void TestMassAndUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestUndefinedAndMass(Type type)
{
var exp = Create(type, Variable.X, MassValue.Gram(1).AsExpression());
@@ -135,9 +135,9 @@ public void TestUndefinedAndMass(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestLengthAndUndefined(Type type)
{
var exp = Create(type, LengthValue.Centimeter(1).AsExpression(), Variable.X);
@@ -145,9 +145,9 @@ public void TestLengthAndUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestUndefinedAndLength(Type type)
{
var exp = Create(type, Variable.X, LengthValue.Centimeter(1).AsExpression());
@@ -155,9 +155,9 @@ public void TestUndefinedAndLength(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestTimeAndUndefined(Type type)
{
var exp = Create(type, TimeValue.Second(1).AsExpression(), Variable.X);
@@ -165,9 +165,9 @@ public void TestTimeAndUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestUndefinedAndTime(Type type)
{
var exp = Create(type, Variable.X, TimeValue.Second(1).AsExpression());
@@ -175,9 +175,9 @@ public void TestUndefinedAndTime(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestAreaAndUndefined(Type type)
{
var exp = Create(type, AreaValue.Meter(1).AsExpression(), Variable.X);
@@ -185,9 +185,9 @@ public void TestAreaAndUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestUndefinedAndArea(Type type)
{
var exp = Create(type, Variable.X, AreaValue.Meter(1).AsExpression());
@@ -195,9 +195,9 @@ public void TestUndefinedAndArea(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestVolumeAndUndefined(Type type)
{
var exp = Create(type, VolumeValue.Meter(1).AsExpression(), Variable.X);
@@ -205,9 +205,9 @@ public void TestVolumeAndUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestUndefinedAndVolume(Type type)
{
var exp = Create(type, Variable.X, VolumeValue.Meter(1).AsExpression());
@@ -215,9 +215,9 @@ public void TestUndefinedAndVolume(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestNumber(Type type)
{
var exp = Create(type, new Number(20), new Number(10));
@@ -225,9 +225,9 @@ public void TestNumber(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestBoolean(Type type)
{
var exp = Create(type, Bool.False, Bool.True);
@@ -235,9 +235,9 @@ public void TestBoolean(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestAngleNumber(Type type)
{
var exp = Create(type,
@@ -248,9 +248,9 @@ public void TestAngleNumber(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestPowerNumber(Type type)
{
var exp = Create(type,
@@ -261,9 +261,9 @@ public void TestPowerNumber(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestTemperatureNumber(Type type)
{
var exp = Create(type,
@@ -274,9 +274,9 @@ public void TestTemperatureNumber(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestMassNumber(Type type)
{
var exp = Create(type,
@@ -287,9 +287,9 @@ public void TestMassNumber(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestLengthNumber(Type type)
{
var exp = Create(type,
@@ -300,9 +300,9 @@ public void TestLengthNumber(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestTimeNumber(Type type)
{
var exp = Create(type,
@@ -313,9 +313,9 @@ public void TestTimeNumber(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestAreaNumber(Type type)
{
var exp = Create(type,
@@ -326,9 +326,9 @@ public void TestAreaNumber(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestVolumeNumber(Type type)
{
var exp = Create(type,
@@ -339,9 +339,9 @@ public void TestVolumeNumber(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestComplexAndNumber(Type type)
{
var exp = CreateBinary(type, new ComplexNumber(1, 2), new Number(20));
@@ -349,9 +349,9 @@ public void TestComplexAndNumber(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestNumberAndComplex(Type type)
{
var exp = CreateBinary(type, new Number(20), new ComplexNumber(1, 2));
@@ -359,9 +359,9 @@ public void TestNumberAndComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestComplexAndBool(Type type)
{
var exp = CreateBinary(type, new ComplexNumber(1, 2), Bool.True);
@@ -369,9 +369,9 @@ public void TestComplexAndBool(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestBoolAndComplex(Type type)
{
var exp = CreateBinary(type, Bool.False, new ComplexNumber(1, 2));
@@ -379,9 +379,9 @@ public void TestBoolAndComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestComplexAndAngle(Type type)
{
var exp = CreateBinary(type,
@@ -392,9 +392,9 @@ public void TestComplexAndAngle(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestAngleAndComplex(Type type)
{
var exp = CreateBinary(type,
@@ -405,9 +405,9 @@ public void TestAngleAndComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestComplexAndPower(Type type)
{
var exp = CreateBinary(type,
@@ -418,9 +418,9 @@ public void TestComplexAndPower(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestPowerAndComplex(Type type)
{
var exp = CreateBinary(type,
@@ -431,9 +431,9 @@ public void TestPowerAndComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestComplexAndTemperature(Type type)
{
var exp = CreateBinary(type,
@@ -444,9 +444,9 @@ public void TestComplexAndTemperature(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestTemperatureAndComplex(Type type)
{
var exp = CreateBinary(type,
@@ -457,9 +457,9 @@ public void TestTemperatureAndComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestComplexAndMass(Type type)
{
var exp = CreateBinary(type,
@@ -470,9 +470,9 @@ public void TestComplexAndMass(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestMassAndComplex(Type type)
{
var exp = CreateBinary(type,
@@ -483,9 +483,9 @@ public void TestMassAndComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestComplexAndLength(Type type)
{
var exp = CreateBinary(type,
@@ -496,9 +496,9 @@ public void TestComplexAndLength(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestLengthAndComplex(Type type)
{
var exp = CreateBinary(type,
@@ -509,9 +509,9 @@ public void TestLengthAndComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestComplexAndTime(Type type)
{
var exp = CreateBinary(type,
@@ -522,9 +522,9 @@ public void TestComplexAndTime(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestTimeAndComplex(Type type)
{
var exp = CreateBinary(type,
@@ -535,9 +535,9 @@ public void TestTimeAndComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestComplexAndArea(Type type)
{
var exp = CreateBinary(type,
@@ -548,9 +548,9 @@ public void TestComplexAndArea(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestAreaAndComplex(Type type)
{
var exp = CreateBinary(type,
@@ -561,9 +561,9 @@ public void TestAreaAndComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestComplexAndVolume(Type type)
{
var exp = CreateBinary(type,
@@ -574,9 +574,9 @@ public void TestComplexAndVolume(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestVolumeAndComplex(Type type)
{
var exp = CreateBinary(type,
@@ -587,9 +587,9 @@ public void TestVolumeAndComplex(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(Equal))]
- [InlineData(typeof(NotEqual))]
+ [Test]
+ [TestCase(typeof(Equal))]
+ [TestCase(typeof(NotEqual))]
public void TestInvalidArgsException(Type type)
{
var exp = Create(type, new ComplexNumber(2, 3), new ComplexNumber(2, 3));
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/ProgrammingTest.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/ProgrammingTest.cs
index c44735d82..8f4de714a 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/ProgrammingTest.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/ProgrammingTest.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests.ProgrammingTests;
public class ProgrammingTest : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestDec()
{
var exp = new Dec(Variable.X);
@@ -13,7 +13,7 @@ public void TestDec()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestForUndefined()
{
var exp = new For(Variable.X, Variable.X, Variable.X, Variable.X);
@@ -21,7 +21,7 @@ public void TestForUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestForNumber()
{
var exp = new For(Variable.X, Variable.X, Bool.False, Variable.X);
@@ -29,7 +29,7 @@ public void TestForNumber()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestForException()
{
var exp = new For(Variable.X, Variable.X, new ComplexNumber(2, 3), Variable.X);
@@ -37,7 +37,7 @@ public void TestForException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestIfUndefined()
{
var exp = new If(Variable.X, new Number(10));
@@ -45,7 +45,7 @@ public void TestIfUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestIfBool()
{
var exp = new If(Bool.False, new Number(10));
@@ -53,7 +53,7 @@ public void TestIfBool()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestIfElseBool()
{
var exp = new If(Bool.False, new Number(10), Number.Two);
@@ -61,7 +61,7 @@ public void TestIfElseBool()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestIfException()
{
var exp = new If(new ComplexNumber(2, 4), new Number(10));
@@ -69,7 +69,7 @@ public void TestIfException()
TestDiffParamException(exp);
}
- [Fact]
+ [Test]
public void TestInc()
{
var exp = new Inc(Variable.X);
@@ -78,7 +78,7 @@ public void TestInc()
}
- [Fact]
+ [Test]
public void TestWhileUndefined()
{
var exp = new While(Variable.X, Variable.X);
@@ -86,7 +86,7 @@ public void TestWhileUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestWhileNumber()
{
var exp = new While(Variable.X, Bool.False);
@@ -94,7 +94,7 @@ public void TestWhileNumber()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestWhileException()
{
var exp = new While(Variable.X, Number.One);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/RelationalOperatorsTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/RelationalOperatorsTests.cs
index 41b561303..8ad336fa4 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/RelationalOperatorsTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/RelationalOperatorsTests.cs
@@ -5,11 +5,11 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests.ProgrammingTests;
public class GreaterOrEqualTests : TypeAnalyzerBaseTests
{
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestUndefined(Type type)
{
var exp = CreateBinary(type, Variable.X, Variable.X);
@@ -17,11 +17,11 @@ public void TestUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestNumberUndefined(Type type)
{
var exp = CreateBinary(type, Number.One, Variable.X);
@@ -29,11 +29,11 @@ public void TestNumberUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestUndefinedNumber(Type type)
{
var exp = CreateBinary(type, Variable.X, Number.One);
@@ -41,11 +41,11 @@ public void TestUndefinedNumber(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestAngleUndefined(Type type)
{
var exp = CreateBinary(type, AngleValue.Degree(1).AsExpression(), Variable.X);
@@ -53,11 +53,11 @@ public void TestAngleUndefined(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestGUndefinedAngle(Type type)
{
var exp = CreateBinary(type, Variable.X, AngleValue.Degree(1).AsExpression());
@@ -65,11 +65,11 @@ public void TestGUndefinedAngle(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestNumber(Type type)
{
var exp = CreateBinary(type, new Number(10), new Number(10));
@@ -77,11 +77,11 @@ public void TestNumber(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestAngle(Type type)
{
var exp = CreateBinary(type,
@@ -92,11 +92,11 @@ public void TestAngle(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestPower(Type type)
{
var exp = CreateBinary(type,
@@ -107,11 +107,11 @@ public void TestPower(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestTemperature(Type type)
{
var exp = CreateBinary(type,
@@ -122,11 +122,11 @@ public void TestTemperature(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestMass(Type type)
{
var exp = CreateBinary(type,
@@ -137,11 +137,11 @@ public void TestMass(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestLength(Type type)
{
var exp = CreateBinary(type,
@@ -152,11 +152,11 @@ public void TestLength(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestTime(Type type)
{
var exp = CreateBinary(type,
@@ -167,11 +167,11 @@ public void TestTime(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestArea(Type type)
{
var exp = CreateBinary(type,
@@ -182,11 +182,11 @@ public void TestArea(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestVolume(Type type)
{
var exp = CreateBinary(type,
@@ -197,11 +197,11 @@ public void TestVolume(Type type)
Test(exp, ResultTypes.Boolean);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestBoolNumberException(Type type)
{
var exp = CreateBinary(type, Bool.True, new Number(10));
@@ -209,11 +209,11 @@ public void TestBoolNumberException(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestNumberBoolException(Type type)
{
var exp = CreateBinary(type, new Number(10), Bool.True);
@@ -221,11 +221,11 @@ public void TestNumberBoolException(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestBoolAngle(Type type)
{
var exp = CreateBinary(type,
@@ -236,11 +236,11 @@ public void TestBoolAngle(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestAngleBool(Type type)
{
var exp = CreateBinary(type,
@@ -251,11 +251,11 @@ public void TestAngleBool(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestBoolPower(Type type)
{
var exp = CreateBinary(type,
@@ -266,11 +266,11 @@ public void TestBoolPower(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestPowerBool(Type type)
{
var exp = CreateBinary(type,
@@ -281,11 +281,11 @@ public void TestPowerBool(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestBoolTemperature(Type type)
{
var exp = CreateBinary(type,
@@ -296,11 +296,11 @@ public void TestBoolTemperature(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestTemperatureBool(Type type)
{
var exp = CreateBinary(type,
@@ -311,11 +311,11 @@ public void TestTemperatureBool(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestBoolMass(Type type)
{
var exp = CreateBinary(type,
@@ -326,11 +326,11 @@ public void TestBoolMass(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestMassBool(Type type)
{
var exp = CreateBinary(type,
@@ -341,11 +341,11 @@ public void TestMassBool(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestBoolLength(Type type)
{
var exp = CreateBinary(type,
@@ -356,11 +356,11 @@ public void TestBoolLength(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestLengthBool(Type type)
{
var exp = CreateBinary(type,
@@ -371,11 +371,11 @@ public void TestLengthBool(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestBoolTime(Type type)
{
var exp = CreateBinary(type,
@@ -386,11 +386,11 @@ public void TestBoolTime(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestTimeBool(Type type)
{
var exp = CreateBinary(type,
@@ -401,11 +401,11 @@ public void TestTimeBool(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestBoolArea(Type type)
{
var exp = CreateBinary(type,
@@ -416,11 +416,11 @@ public void TestBoolArea(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestAreaBool(Type type)
{
var exp = CreateBinary(type,
@@ -431,11 +431,11 @@ public void TestAreaBool(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestBoolVolume(Type type)
{
var exp = CreateBinary(type,
@@ -446,11 +446,11 @@ public void TestBoolVolume(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestVolumeBool(Type type)
{
var exp = CreateBinary(type,
@@ -461,11 +461,11 @@ public void TestVolumeBool(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(GreaterThan))]
- [InlineData(typeof(GreaterOrEqual))]
- [InlineData(typeof(LessThan))]
- [InlineData(typeof(LessOrEqual))]
+ [Test]
+ [TestCase(typeof(GreaterThan))]
+ [TestCase(typeof(GreaterOrEqual))]
+ [TestCase(typeof(LessThan))]
+ [TestCase(typeof(LessOrEqual))]
public void TestRelationalOperatorException(Type type)
{
var exp = CreateBinary(type, Bool.True, Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/ShiftOperatorsTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/ShiftOperatorsTests.cs
index 0dbc2e374..1bbae8751 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/ShiftOperatorsTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ProgrammingTests/ShiftOperatorsTests.cs
@@ -5,9 +5,9 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests.ProgrammingTests;
public class ShiftOperatorsTests : TypeAnalyzerBaseTests
{
- [Theory]
- [InlineData(typeof(LeftShift))]
- [InlineData(typeof(RightShift))]
+ [Test]
+ [TestCase(typeof(LeftShift))]
+ [TestCase(typeof(RightShift))]
public void TestAssignUndefined(Type type)
{
var exp = Create(type, Variable.X, Variable.X);
@@ -15,9 +15,9 @@ public void TestAssignUndefined(Type type)
Test(exp, ResultTypes.Number);
}
- [Theory]
- [InlineData(typeof(LeftShift))]
- [InlineData(typeof(RightShift))]
+ [Test]
+ [TestCase(typeof(LeftShift))]
+ [TestCase(typeof(RightShift))]
public void TestAssignUndefinedNumber(Type type)
{
var exp = Create(type, Variable.X, Number.One);
@@ -25,9 +25,9 @@ public void TestAssignUndefinedNumber(Type type)
Test(exp, ResultTypes.Number);
}
- [Theory]
- [InlineData(typeof(LeftShift))]
- [InlineData(typeof(RightShift))]
+ [Test]
+ [TestCase(typeof(LeftShift))]
+ [TestCase(typeof(RightShift))]
public void TestAssignNumberUndefined(Type type)
{
var exp = Create(type, Number.One, Variable.X);
@@ -35,9 +35,9 @@ public void TestAssignNumberUndefined(Type type)
Test(exp, ResultTypes.Number);
}
- [Theory]
- [InlineData(typeof(LeftShift))]
- [InlineData(typeof(RightShift))]
+ [Test]
+ [TestCase(typeof(LeftShift))]
+ [TestCase(typeof(RightShift))]
public void TestAssignNumbers(Type type)
{
var exp = Create(type, Number.One, Number.One);
@@ -45,9 +45,9 @@ public void TestAssignNumbers(Type type)
Test(exp, ResultTypes.Number);
}
- [Theory]
- [InlineData(typeof(LeftShift))]
- [InlineData(typeof(RightShift))]
+ [Test]
+ [TestCase(typeof(LeftShift))]
+ [TestCase(typeof(RightShift))]
public void TestAssignLeftException(Type type)
{
var exp = CreateBinary(type, Bool.False, Number.One);
@@ -55,9 +55,9 @@ public void TestAssignLeftException(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(LeftShift))]
- [InlineData(typeof(RightShift))]
+ [Test]
+ [TestCase(typeof(LeftShift))]
+ [TestCase(typeof(RightShift))]
public void TestAssignRightException(Type type)
{
var exp = CreateBinary(type, Number.One, Bool.False);
@@ -65,9 +65,9 @@ public void TestAssignRightException(Type type)
TestBinaryException(exp);
}
- [Theory]
- [InlineData(typeof(LeftShift))]
- [InlineData(typeof(RightShift))]
+ [Test]
+ [TestCase(typeof(LeftShift))]
+ [TestCase(typeof(RightShift))]
public void TestAssignException(Type type)
{
var exp = Create(type, Bool.False, Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/RootTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/RootTests.cs
index 143e9b369..563f32fd8 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/RootTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/RootTests.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class RootTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestRootUndefined()
{
var exp = new Root(Variable.X, Variable.X);
@@ -13,7 +13,7 @@ public void TestRootUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestRootUndefinedAndNumber()
{
var exp = new Root(Variable.X, Number.Two);
@@ -21,7 +21,7 @@ public void TestRootUndefinedAndNumber()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestRootNumberAndUndefined()
{
var exp = new Root(Number.Two, Variable.X);
@@ -29,7 +29,7 @@ public void TestRootNumberAndUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestRootNumber()
{
var exp = new Root(new Number(4), Number.Two);
@@ -37,7 +37,7 @@ public void TestRootNumber()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestRootUndefinedAndBool()
{
var exp = new Root(Variable.X, Bool.False);
@@ -45,7 +45,7 @@ public void TestRootUndefinedAndBool()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestRootBoolAndUndefined()
{
var exp = new Root(Bool.False, Variable.X);
@@ -53,7 +53,7 @@ public void TestRootBoolAndUndefined()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestRootNumberAndBool()
{
var exp = new Root(Number.Two, Bool.False);
@@ -61,7 +61,7 @@ public void TestRootNumberAndBool()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestRootBoolAndNumber()
{
var exp = new Root(Bool.False, Number.Two);
@@ -69,7 +69,7 @@ public void TestRootBoolAndNumber()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestRootInvalidArgsException()
{
var exp = new Root(Bool.False, Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/RoundTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/RoundTests.cs
index 4e76413e2..7b8df23c1 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/RoundTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/RoundTests.cs
@@ -5,7 +5,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class RoundTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestRoundVariable()
{
var exp = new Round(Variable.X, new Number(10));
@@ -13,7 +13,7 @@ public void TestRoundVariable()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestRoundNumber()
{
var exp = new Round(new Number(10), new Number(10));
@@ -21,7 +21,7 @@ public void TestRoundNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestRoundAngleNumber()
{
var exp = new Round(AngleValue.Degree(10).AsExpression(), new Number(10));
@@ -29,7 +29,7 @@ public void TestRoundAngleNumber()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestRoundPowerNumber()
{
var exp = new Round(PowerValue.Watt(10).AsExpression(), new Number(10));
@@ -37,7 +37,7 @@ public void TestRoundPowerNumber()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestRoundTemperatureNumber()
{
var exp = new Round(TemperatureValue.Celsius(10).AsExpression(), new Number(10));
@@ -45,7 +45,7 @@ public void TestRoundTemperatureNumber()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestRoundMassNumber()
{
var exp = new Round(MassValue.Gram(10).AsExpression(), new Number(10));
@@ -53,7 +53,7 @@ public void TestRoundMassNumber()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestRoundLengthNumber()
{
var exp = new Round(LengthValue.Meter(10).AsExpression(), new Number(10));
@@ -61,7 +61,7 @@ public void TestRoundLengthNumber()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestRoundTimeNumber()
{
var exp = new Round(TimeValue.Second(10).AsExpression(), new Number(10));
@@ -69,7 +69,7 @@ public void TestRoundTimeNumber()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestRoundAreaNumber()
{
var exp = new Round(AreaValue.Meter(10).AsExpression(), new Number(10));
@@ -77,7 +77,7 @@ public void TestRoundAreaNumber()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestRoundVolumeNumber()
{
var exp = new Round(VolumeValue.Meter(10).AsExpression(), new Number(10));
@@ -85,7 +85,7 @@ public void TestRoundVolumeNumber()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestRoundWithUnsupportedPrecisionException()
{
var exp = new Round(new Number(10), new ComplexNumber(10));
@@ -93,7 +93,7 @@ public void TestRoundWithUnsupportedPrecisionException()
TestDiffParamException(exp);
}
- [Fact]
+ [Test]
public void TestRoundException()
{
var exp = new Round(new ComplexNumber(10), new Number(10));
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/SignTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/SignTests.cs
index e982f2380..024fbb4b6 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/SignTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/SignTests.cs
@@ -2,67 +2,67 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class SignTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestSignUndefined()
{
Test(new Sign(Variable.X), ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestSignNumber()
{
Test(new Sign(new Number(-5)), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestSignAngle()
{
Test(new Sign(AngleValue.Degree(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestSignPower()
{
Test(new Sign(PowerValue.Watt(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestSignTemperature()
{
Test(new Sign(TemperatureValue.Celsius(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestSignMass()
{
Test(new Sign(MassValue.Gram(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestSignLength()
{
Test(new Sign(LengthValue.Meter(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestSignTime()
{
Test(new Sign(TimeValue.Second(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestSignArea()
{
Test(new Sign(AreaValue.Meter(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestSignVolume()
{
Test(new Sign(VolumeValue.Meter(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestSignException()
{
TestException(new Sign(Bool.False));
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/StandardTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/StandardTests.cs
index 0d3aaf52b..999dc2196 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/StandardTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/StandardTests.cs
@@ -8,7 +8,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class StandardTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestDefineUndefined()
{
var exp = new Assign(Variable.X, new Number(-2));
@@ -16,7 +16,7 @@ public void TestDefineUndefined()
Test(exp, ResultTypes.String);
}
- [Fact]
+ [Test]
public void TestDelVector()
{
var diff = new Differentiator();
@@ -26,7 +26,7 @@ public void TestDelVector()
Test(exp, ResultTypes.Function);
}
- [Fact]
+ [Test]
public void TestDerivExpression()
{
var diff = new Differentiator();
@@ -36,7 +36,7 @@ public void TestDerivExpression()
Test(exp, ResultTypes.Function);
}
- [Fact]
+ [Test]
public void TestDerivExpressionWithVar()
{
var diff = new Differentiator();
@@ -46,7 +46,7 @@ public void TestDerivExpressionWithVar()
Test(exp, ResultTypes.Function);
}
- [Fact]
+ [Test]
public void TestDerivNumber()
{
var diff = new Differentiator();
@@ -56,7 +56,7 @@ public void TestDerivNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestExpUndefined()
{
var exp = new Exp(Variable.X);
@@ -64,7 +64,7 @@ public void TestExpUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestExpNumber()
{
var exp = new Exp(new Number(10));
@@ -72,7 +72,7 @@ public void TestExpNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestExpComplexNumber()
{
var exp = new Exp(new ComplexNumber(10, 10));
@@ -80,7 +80,7 @@ public void TestExpComplexNumber()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestExpException()
{
var exp = new Exp(Bool.False);
@@ -88,7 +88,7 @@ public void TestExpException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestFactUndefined()
{
var exp = new Fact(Variable.X);
@@ -96,7 +96,7 @@ public void TestFactUndefined()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestFactNumber()
{
var exp = new Fact(new Number(10));
@@ -104,7 +104,7 @@ public void TestFactNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestFactException()
{
var exp = new Fact(Bool.False);
@@ -112,7 +112,7 @@ public void TestFactException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestGCDUndefined()
{
var exp = new GCD(new Number(10), Variable.X);
@@ -120,7 +120,7 @@ public void TestGCDUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestGCDNumber()
{
var exp = new GCD(new IExpression[]
@@ -131,7 +131,7 @@ public void TestGCDNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestGCDException()
{
var exp = new GCD(new ComplexNumber(10), new Number(10));
@@ -139,7 +139,7 @@ public void TestGCDException()
TestDiffParamException(exp);
}
- [Fact]
+ [Test]
public void TestLCMUndefined()
{
var exp = new LCM(new Number(10), Variable.X);
@@ -147,7 +147,7 @@ public void TestLCMUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestLCMNumber()
{
var exp = new LCM(new IExpression[]
@@ -158,7 +158,7 @@ public void TestLCMNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestLCMException()
{
var exp = new LCM(new ComplexNumber(10), new Number(10));
@@ -166,7 +166,7 @@ public void TestLCMException()
TestDiffParamException(exp);
}
- [Fact]
+ [Test]
public void TestModUndefined()
{
var exp = new Mod(Variable.X, Variable.X);
@@ -174,7 +174,7 @@ public void TestModUndefined()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestModUndefinedAndNumber()
{
var exp = new Mod(Variable.X, Number.Two);
@@ -182,7 +182,7 @@ public void TestModUndefinedAndNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestModNumberAndUndefined()
{
var exp = new Mod(Number.Two, Variable.X);
@@ -190,7 +190,7 @@ public void TestModNumberAndUndefined()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestModNumber()
{
var exp = new Mod(new Number(4), Number.Two);
@@ -198,7 +198,7 @@ public void TestModNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestModNumberAndBool()
{
var exp = new Mod(new Number(4), Bool.True);
@@ -206,7 +206,7 @@ public void TestModNumberAndBool()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestModBoolAndNumber()
{
var exp = new Mod(Bool.False, Number.Two);
@@ -214,7 +214,7 @@ public void TestModBoolAndNumber()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestModUndefinedAndBool()
{
var exp = new Mod(Variable.X, Bool.False);
@@ -222,7 +222,7 @@ public void TestModUndefinedAndBool()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestModBoolAndUndefined()
{
var exp = new Mod(Bool.False, Variable.X);
@@ -230,7 +230,7 @@ public void TestModBoolAndUndefined()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestModException()
{
var exp = new Mod(Bool.False, Bool.False);
@@ -238,38 +238,38 @@ public void TestModException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestNumber()
{
Test(Number.One, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestSimplify()
{
var simp = new Simplifier();
Test(new Simplify(simp, Variable.X), ResultTypes.Function);
}
- [Fact]
+ [Test]
public void TestSqrt()
{
Test(new Sqrt(Variable.X), ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestUndefine()
{
Test(new Unassign(Variable.X), ResultTypes.String);
}
- [Fact]
+ [Test]
public void TestCallExpression()
{
Test(new CallExpression(new Variable("f"), ImmutableArray.Empty), ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestLambdaExpression()
{
var exp = Number.One.ToLambdaExpression();
@@ -277,85 +277,85 @@ public void TestLambdaExpression()
Test(exp, ResultTypes.Function);
}
- [Fact]
+ [Test]
public void TestVariable()
{
Test(new Sqrt(Variable.X), ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestDeletageExpression()
{
Test(new DelegateExpression(_ => null), ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestAngleNumber()
{
Test(AngleValue.Degree(10).AsExpression(), ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestToDegreeUndefined()
{
Test(new ToDegree(Variable.X), ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestToDegreeNumber()
{
Test(new ToDegree(new Number(10)), ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestToDegreeAngle()
{
Test(new ToDegree(AngleValue.Radian(10).AsExpression()), ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestToDegreeException()
{
TestException(new ToDegree(Bool.True));
}
- [Fact]
+ [Test]
public void TestToRadianNumber()
{
Test(new ToRadian(new Number(10)), ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestToRadianAngle()
{
Test(new ToRadian(AngleValue.Degree(10).AsExpression()), ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestToRadianException()
{
TestException(new ToRadian(Bool.True));
}
- [Fact]
+ [Test]
public void TestToGradianNumber()
{
Test(new ToGradian(new Number(10)), ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestToGradianAngle()
{
Test(new ToGradian(AngleValue.Radian(10).AsExpression()), ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestToGradianException()
{
TestException(new ToGradian(Bool.True));
}
- [Fact]
+ [Test]
public void TestStringExpression()
{
var exp = new StringExpression("hello");
@@ -363,7 +363,7 @@ public void TestStringExpression()
Test(exp, ResultTypes.String);
}
- [Fact]
+ [Test]
public void TestConvertVariable()
{
var exp = new Convert(
@@ -375,7 +375,7 @@ public void TestConvertVariable()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestConvert()
{
var exp = new Convert(
@@ -387,7 +387,7 @@ public void TestConvert()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestAngleConvert()
{
var exp = new Convert(
@@ -399,7 +399,7 @@ public void TestAngleConvert()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestPowerConvert()
{
var exp = new Convert(
@@ -411,7 +411,7 @@ public void TestPowerConvert()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestTemperatureConvert()
{
var exp = new Convert(
@@ -423,7 +423,7 @@ public void TestTemperatureConvert()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestMassConvert()
{
var exp = new Convert(
@@ -435,7 +435,7 @@ public void TestMassConvert()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestLengthConvert()
{
var exp = new Convert(
@@ -447,7 +447,7 @@ public void TestLengthConvert()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestTimeConvert()
{
var exp = new Convert(
@@ -459,7 +459,7 @@ public void TestTimeConvert()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestAreaConvert()
{
var exp = new Convert(
@@ -471,7 +471,7 @@ public void TestAreaConvert()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestVolumeConvert()
{
var exp = new Convert(
@@ -483,7 +483,7 @@ public void TestVolumeConvert()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestConvertException()
{
var exp = new Convert(
@@ -495,7 +495,7 @@ public void TestConvertException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestRational()
{
var exp = new Rational(Number.One, Number.Two);
@@ -503,7 +503,7 @@ public void TestRational()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestRationalLeftUndefined()
{
var exp = new Rational(Variable.X, Number.Two);
@@ -511,7 +511,7 @@ public void TestRationalLeftUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestRationalRightUndefined()
{
var exp = new Rational(Number.One, Variable.X);
@@ -519,7 +519,7 @@ public void TestRationalRightUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestRationalException()
{
var exp = new Rational(Bool.True, Bool.False);
@@ -527,7 +527,7 @@ public void TestRationalException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestRationalLeftException()
{
var exp = new Rational(Bool.True, Number.Two);
@@ -535,7 +535,7 @@ public void TestRationalLeftException()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestRationalRightException()
{
var exp = new Rational(Number.One, Bool.False);
@@ -543,7 +543,7 @@ public void TestRationalRightException()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestToRational()
{
var exp = new ToRational(Number.Two);
@@ -551,7 +551,7 @@ public void TestToRational()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestToRationalUndefined()
{
var exp = new ToRational(Variable.X);
@@ -559,7 +559,7 @@ public void TestToRationalUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestToRationalException()
{
var exp = new ToRational(Bool.False);
@@ -567,7 +567,7 @@ public void TestToRationalException()
TestException(exp);
}
- [Theory]
- [ClassData(typeof(AllExpressionsData))]
+ [Test]
+ [TestCaseSource(typeof(AllExpressionsData))]
public void TestNullException(Type type) => TestNullExp(type);
}
\ No newline at end of file
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/StatisticalTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/StatisticalTests.cs
index b66c38509..2f139fa11 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/StatisticalTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/StatisticalTests.cs
@@ -5,17 +5,17 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class StatisticalTests : TypeAnalyzerBaseTests
{
- [Theory]
- [InlineData(typeof(Avg))]
- [InlineData(typeof(Count))]
- [InlineData(typeof(Max))]
- [InlineData(typeof(Min))]
- [InlineData(typeof(Product))]
- [InlineData(typeof(Stdev))]
- [InlineData(typeof(Stdevp))]
- [InlineData(typeof(Sum))]
- [InlineData(typeof(Var))]
- [InlineData(typeof(Varp))]
+ [Test]
+ [TestCase(typeof(Avg))]
+ [TestCase(typeof(Count))]
+ [TestCase(typeof(Max))]
+ [TestCase(typeof(Min))]
+ [TestCase(typeof(Product))]
+ [TestCase(typeof(Stdev))]
+ [TestCase(typeof(Stdevp))]
+ [TestCase(typeof(Sum))]
+ [TestCase(typeof(Var))]
+ [TestCase(typeof(Varp))]
public void TestUndefined(Type type)
{
var exp = Create(type, new IExpression[] { Variable.X, Variable.Y });
@@ -23,17 +23,17 @@ public void TestUndefined(Type type)
Test(exp, ResultTypes.Undefined);
}
- [Theory]
- [InlineData(typeof(Avg))]
- [InlineData(typeof(Count))]
- [InlineData(typeof(Max))]
- [InlineData(typeof(Min))]
- [InlineData(typeof(Product))]
- [InlineData(typeof(Stdev))]
- [InlineData(typeof(Stdevp))]
- [InlineData(typeof(Sum))]
- [InlineData(typeof(Var))]
- [InlineData(typeof(Varp))]
+ [Test]
+ [TestCase(typeof(Avg))]
+ [TestCase(typeof(Count))]
+ [TestCase(typeof(Max))]
+ [TestCase(typeof(Min))]
+ [TestCase(typeof(Product))]
+ [TestCase(typeof(Stdev))]
+ [TestCase(typeof(Stdevp))]
+ [TestCase(typeof(Sum))]
+ [TestCase(typeof(Var))]
+ [TestCase(typeof(Varp))]
public void TestAvgNumber(Type type)
{
var exp = Create(type, new IExpression[] { new Number(3), Number.Two });
@@ -41,17 +41,17 @@ public void TestAvgNumber(Type type)
Test(exp, ResultTypes.Number);
}
- [Theory]
- [InlineData(typeof(Avg))]
- [InlineData(typeof(Count))]
- [InlineData(typeof(Max))]
- [InlineData(typeof(Min))]
- [InlineData(typeof(Product))]
- [InlineData(typeof(Stdev))]
- [InlineData(typeof(Stdevp))]
- [InlineData(typeof(Sum))]
- [InlineData(typeof(Var))]
- [InlineData(typeof(Varp))]
+ [Test]
+ [TestCase(typeof(Avg))]
+ [TestCase(typeof(Count))]
+ [TestCase(typeof(Max))]
+ [TestCase(typeof(Min))]
+ [TestCase(typeof(Product))]
+ [TestCase(typeof(Stdev))]
+ [TestCase(typeof(Stdevp))]
+ [TestCase(typeof(Sum))]
+ [TestCase(typeof(Var))]
+ [TestCase(typeof(Varp))]
public void TestVector(Type type)
{
var arguments = new IExpression[]
@@ -63,17 +63,17 @@ public void TestVector(Type type)
Test(exp, ResultTypes.Number);
}
- [Theory]
- [InlineData(typeof(Avg))]
- [InlineData(typeof(Count))]
- [InlineData(typeof(Max))]
- [InlineData(typeof(Min))]
- [InlineData(typeof(Product))]
- [InlineData(typeof(Stdev))]
- [InlineData(typeof(Stdevp))]
- [InlineData(typeof(Sum))]
- [InlineData(typeof(Var))]
- [InlineData(typeof(Varp))]
+ [Test]
+ [TestCase(typeof(Avg))]
+ [TestCase(typeof(Count))]
+ [TestCase(typeof(Max))]
+ [TestCase(typeof(Min))]
+ [TestCase(typeof(Product))]
+ [TestCase(typeof(Stdev))]
+ [TestCase(typeof(Stdevp))]
+ [TestCase(typeof(Sum))]
+ [TestCase(typeof(Var))]
+ [TestCase(typeof(Varp))]
public void TestOneParamException(Type type)
{
var exp = CreateDiff(type, new IExpression[] { Bool.False });
@@ -81,17 +81,17 @@ public void TestOneParamException(Type type)
TestDiffParamException(exp);
}
- [Theory]
- [InlineData(typeof(Avg))]
- [InlineData(typeof(Count))]
- [InlineData(typeof(Max))]
- [InlineData(typeof(Min))]
- [InlineData(typeof(Product))]
- [InlineData(typeof(Stdev))]
- [InlineData(typeof(Stdevp))]
- [InlineData(typeof(Sum))]
- [InlineData(typeof(Var))]
- [InlineData(typeof(Varp))]
+ [Test]
+ [TestCase(typeof(Avg))]
+ [TestCase(typeof(Count))]
+ [TestCase(typeof(Max))]
+ [TestCase(typeof(Min))]
+ [TestCase(typeof(Product))]
+ [TestCase(typeof(Stdev))]
+ [TestCase(typeof(Stdevp))]
+ [TestCase(typeof(Sum))]
+ [TestCase(typeof(Var))]
+ [TestCase(typeof(Varp))]
public void TestParamException(Type type)
{
var exp = CreateDiff(type, new IExpression[] { Bool.False, Bool.False });
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/SubTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/SubTests.cs
index 91261d3c8..8007147d1 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/SubTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/SubTests.cs
@@ -7,7 +7,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class SubTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void SubTwoNumberTest()
{
var sub = new Sub(Number.One, Number.Two);
@@ -15,7 +15,7 @@ public void SubTwoNumberTest()
Test(sub, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void SubNumberVarTest()
{
var sub = new Sub(Number.One, Variable.X);
@@ -23,7 +23,7 @@ public void SubNumberVarTest()
Test(sub, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void SubComplicatedTest()
{
var sub = new Sub(new Mul(Number.One, Number.Two), Variable.X);
@@ -31,7 +31,7 @@ public void SubComplicatedTest()
Test(sub, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void SubTwoVectorTest()
{
var sub = new Sub(
@@ -42,7 +42,7 @@ public void SubTwoVectorTest()
Test(sub, ResultTypes.Vector);
}
- [Fact]
+ [Test]
public void SubTwoMatrixTest()
{
var sub = new Sub(
@@ -53,7 +53,7 @@ public void SubTwoMatrixTest()
Test(sub, ResultTypes.Matrix);
}
- [Fact]
+ [Test]
public void SubNumberVectorTest()
{
var exp = new Sub(
@@ -64,7 +64,7 @@ public void SubNumberVectorTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void SubVectorNumberTest()
{
var exp = new Sub(
@@ -75,7 +75,7 @@ public void SubVectorNumberTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void SubNumberMatrixTest()
{
var exp = new Sub(
@@ -86,7 +86,7 @@ public void SubNumberMatrixTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void SubMatrixNumberTest()
{
var exp = new Sub(
@@ -97,7 +97,7 @@ public void SubMatrixNumberTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void SubVectorMatrixTest()
{
var exp = new Sub(
@@ -108,7 +108,7 @@ public void SubVectorMatrixTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void SubMatrixVectorTest()
{
var exp = new Sub(
@@ -119,7 +119,7 @@ public void SubMatrixVectorTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void SubNumberComplexNumberTest()
{
var sub = new Sub(Number.One, new ComplexNumber(2, 1));
@@ -127,7 +127,7 @@ public void SubNumberComplexNumberTest()
Test(sub, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void SubComplexNumberNumberTest()
{
var sub = new Sub(new ComplexNumber(1, 3), Number.Two);
@@ -135,7 +135,7 @@ public void SubComplexNumberNumberTest()
Test(sub, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void SubComplexNumberComplexNumberTest()
{
var sub = new Sub(new ComplexNumber(1, 3), new ComplexNumber(3, 5));
@@ -143,7 +143,7 @@ public void SubComplexNumberComplexNumberTest()
Test(sub, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void SubComplexNumberBoolException()
{
var sub = new Sub(new ComplexNumber(1, 3), Bool.True);
@@ -151,7 +151,7 @@ public void SubComplexNumberBoolException()
TestBinaryException(sub);
}
- [Fact]
+ [Test]
public void SubBoolComplexNumberException()
{
var sub = new Sub(Bool.True, new ComplexNumber(1, 3));
@@ -159,7 +159,7 @@ public void SubBoolComplexNumberException()
TestBinaryException(sub);
}
- [Fact]
+ [Test]
public void SubNumberAllTest()
{
var exp = new Sub(
@@ -171,7 +171,7 @@ public void SubNumberAllTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void SubComplexNumberAllTest()
{
var exp = new Sub(
@@ -183,7 +183,7 @@ public void SubComplexNumberAllTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void SubVectorVectorTest()
{
var left = new Vector(new IExpression[] { new Number(3) });
@@ -193,7 +193,7 @@ public void SubVectorVectorTest()
Test(exp, ResultTypes.Vector);
}
- [Fact]
+ [Test]
public void SubVectorBoolTest()
{
var vector = new Vector(new IExpression[] { Number.One });
@@ -202,7 +202,7 @@ public void SubVectorBoolTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void SubBoolVectorTest()
{
var vector = new Vector(new IExpression[] { Number.One });
@@ -211,7 +211,7 @@ public void SubBoolVectorTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void SubVectorAllTest()
{
var exp = new Sub(
@@ -223,7 +223,7 @@ public void SubVectorAllTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void SubMatrixAllTest()
{
var matrix = new Matrix(new[]
@@ -239,7 +239,7 @@ public void SubMatrixAllTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestSubBoolAndMatrixTest()
{
var matrix = new Matrix(new[]
@@ -251,7 +251,7 @@ public void TestSubBoolAndMatrixTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void TestSubMatrixAndBoolTest()
{
var matrix = new Matrix(new[]
@@ -263,7 +263,7 @@ public void TestSubMatrixAndBoolTest()
TestBinaryException(exp);
}
- [Fact]
+ [Test]
public void SubNumberComplexTest()
{
var exp = new Sub(Number.Two, new Sqrt(new Number(-9)));
@@ -271,7 +271,7 @@ public void SubNumberComplexTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void SubTwoVarTest()
{
var exp = new Sub(Variable.X, Variable.X);
@@ -279,7 +279,7 @@ public void SubTwoVarTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void SubThreeVarTest()
{
var exp = new Sub(new Add(Variable.X, Variable.X), Variable.X);
@@ -287,7 +287,7 @@ public void SubThreeVarTest()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestSubBoolsException()
{
var exp = new Sub(Bool.False, Bool.False);
@@ -295,7 +295,7 @@ public void TestSubBoolsException()
TestException(exp);
}
- [Fact]
+ [Test]
public void TestSubNumberAngle()
{
var exp = new Sub(
@@ -306,7 +306,7 @@ public void TestSubNumberAngle()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestSubAngleNumber()
{
var exp = new Sub(
@@ -317,7 +317,7 @@ public void TestSubAngleNumber()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestSubAngleAngle()
{
var exp = new Sub(
@@ -328,7 +328,7 @@ public void TestSubAngleAngle()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestSubNumberPower()
{
var exp = new Sub(
@@ -339,7 +339,7 @@ public void TestSubNumberPower()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestSubPowerNumber()
{
var exp = new Sub(
@@ -350,7 +350,7 @@ public void TestSubPowerNumber()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestSubPowerPower()
{
var exp = new Sub(
@@ -361,7 +361,7 @@ public void TestSubPowerPower()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestSubNumberTemperature()
{
var exp = new Sub(
@@ -372,7 +372,7 @@ public void TestSubNumberTemperature()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestSubTemperatureNumber()
{
var exp = new Sub(
@@ -383,7 +383,7 @@ public void TestSubTemperatureNumber()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestSubTemperatureTemperature()
{
var exp = new Sub(
@@ -394,7 +394,7 @@ public void TestSubTemperatureTemperature()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestSubNumberAndMass()
{
var exp = new Sub(
@@ -405,7 +405,7 @@ public void TestSubNumberAndMass()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestSubMassAndNumber()
{
var exp = new Sub(
@@ -416,7 +416,7 @@ public void TestSubMassAndNumber()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestSubMassAndMass()
{
var exp = new Sub(
@@ -427,7 +427,7 @@ public void TestSubMassAndMass()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestSubNumberAndLength()
{
var exp = new Sub(
@@ -438,7 +438,7 @@ public void TestSubNumberAndLength()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestSubLengthAndNumber()
{
var exp = new Sub(
@@ -449,7 +449,7 @@ public void TestSubLengthAndNumber()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestSubLengthAndLength()
{
var exp = new Sub(
@@ -460,7 +460,7 @@ public void TestSubLengthAndLength()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestSubNumberAndTime()
{
var exp = new Sub(
@@ -471,7 +471,7 @@ public void TestSubNumberAndTime()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestSubTimeAndNumber()
{
var exp = new Sub(
@@ -482,7 +482,7 @@ public void TestSubTimeAndNumber()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestSubTimeAndTime()
{
var exp = new Sub(
@@ -493,7 +493,7 @@ public void TestSubTimeAndTime()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestSubNumberAndArea()
{
var exp = new Sub(
@@ -504,7 +504,7 @@ public void TestSubNumberAndArea()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestSubAreaAndNumber()
{
var exp = new Sub(
@@ -515,7 +515,7 @@ public void TestSubAreaAndNumber()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestSubAreaAndArea()
{
var exp = new Sub(
@@ -526,7 +526,7 @@ public void TestSubAreaAndArea()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestSubNumberAndVolume()
{
var exp = new Sub(
@@ -537,7 +537,7 @@ public void TestSubNumberAndVolume()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestSubVolumeAndNumber()
{
var exp = new Sub(
@@ -548,7 +548,7 @@ public void TestSubVolumeAndNumber()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestSubVolumeAndVolume()
{
var exp = new Sub(
@@ -559,7 +559,7 @@ public void TestSubVolumeAndVolume()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestSubRationalAndRational()
{
var exp = new Sub(
@@ -570,7 +570,7 @@ public void TestSubRationalAndRational()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestSubNumberAndRational()
{
var exp = new Sub(
@@ -581,7 +581,7 @@ public void TestSubNumberAndRational()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestSubRationalAndNumber()
{
var exp = new Sub(
@@ -619,8 +619,8 @@ public static IEnumerable GetDataForTestSubAngleAndBoolTest()
yield return new object[] { Bool.False, VolumeValue.Meter(90).AsExpression() };
}
- [Theory]
- [MemberData(nameof(GetDataForTestSubAngleAndBoolTest))]
+ [Test]
+ [TestCaseSource(nameof(GetDataForTestSubAngleAndBoolTest))]
public void TestSubAngleAndBoolTest(IExpression left, IExpression right)
{
var exp = new Sub(left, right);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ToNumberTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ToNumberTests.cs
index 75bf14927..c1a88044c 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/ToNumberTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/ToNumberTests.cs
@@ -5,67 +5,67 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class ToNumberTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestToNumberUndefined()
{
Test(new ToNumber(Variable.X), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestAngleToNumber()
{
Test(new ToNumber(AngleValue.Degree(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestPowerToNumber()
{
Test(new ToNumber(PowerValue.Watt(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestTemperatureToNumber()
{
Test(new ToNumber(TemperatureValue.Celsius(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestMassToNumber()
{
Test(new ToNumber(MassValue.Gram(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestLengthToNumber()
{
Test(new ToNumber(LengthValue.Meter(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestTimeToNumber()
{
Test(new ToNumber(TimeValue.Second(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestAreaToNumber()
{
Test(new ToNumber(AreaValue.Meter(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestVolumeToNumber()
{
Test(new ToNumber(VolumeValue.Meter(10).AsExpression()), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestRationalToNumber()
{
Test(new ToNumber(new Rational(new Number(1), new Number(3))), ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestToNumberException()
{
TestException(new ToNumber(Bool.True));
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/TrigonometricTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/TrigonometricTests.cs
index 34a011fd3..1c70b7b72 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/TrigonometricTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/TrigonometricTests.cs
@@ -5,19 +5,19 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class TrigonometricTests : TypeAnalyzerBaseTests
{
- [Theory]
- [InlineData(typeof(Arccos))]
- [InlineData(typeof(Arccot))]
- [InlineData(typeof(Arccsc))]
- [InlineData(typeof(Arcsec))]
- [InlineData(typeof(Arcsin))]
- [InlineData(typeof(Arctan))]
- [InlineData(typeof(Cos))]
- [InlineData(typeof(Cot))]
- [InlineData(typeof(Csc))]
- [InlineData(typeof(Sec))]
- [InlineData(typeof(Sin))]
- [InlineData(typeof(Tan))]
+ [Test]
+ [TestCase(typeof(Arccos))]
+ [TestCase(typeof(Arccot))]
+ [TestCase(typeof(Arccsc))]
+ [TestCase(typeof(Arcsec))]
+ [TestCase(typeof(Arcsin))]
+ [TestCase(typeof(Arctan))]
+ [TestCase(typeof(Cos))]
+ [TestCase(typeof(Cot))]
+ [TestCase(typeof(Csc))]
+ [TestCase(typeof(Sec))]
+ [TestCase(typeof(Sin))]
+ [TestCase(typeof(Tan))]
public void TestUndefined(Type type)
{
var exp = Create(type, Variable.X);
@@ -25,13 +25,13 @@ public void TestUndefined(Type type)
Test(exp, ResultTypes.Undefined);
}
- [Theory]
- [InlineData(typeof(Arccos))]
- [InlineData(typeof(Arccot))]
- [InlineData(typeof(Arccsc))]
- [InlineData(typeof(Arcsec))]
- [InlineData(typeof(Arcsin))]
- [InlineData(typeof(Arctan))]
+ [Test]
+ [TestCase(typeof(Arccos))]
+ [TestCase(typeof(Arccot))]
+ [TestCase(typeof(Arccsc))]
+ [TestCase(typeof(Arcsec))]
+ [TestCase(typeof(Arcsin))]
+ [TestCase(typeof(Arctan))]
public void TestReserveNumber(Type type)
{
var exp = Create(type, Number.Two);
@@ -39,13 +39,13 @@ public void TestReserveNumber(Type type)
Test(exp, ResultTypes.AngleNumber);
}
- [Theory]
- [InlineData(typeof(Cos))]
- [InlineData(typeof(Cot))]
- [InlineData(typeof(Csc))]
- [InlineData(typeof(Sec))]
- [InlineData(typeof(Sin))]
- [InlineData(typeof(Tan))]
+ [Test]
+ [TestCase(typeof(Cos))]
+ [TestCase(typeof(Cot))]
+ [TestCase(typeof(Csc))]
+ [TestCase(typeof(Sec))]
+ [TestCase(typeof(Sin))]
+ [TestCase(typeof(Tan))]
public void TestNumber(Type type)
{
var exp = Create(type, Number.Two);
@@ -53,13 +53,13 @@ public void TestNumber(Type type)
Test(exp, ResultTypes.Number);
}
- [Theory]
- [InlineData(typeof(Cos))]
- [InlineData(typeof(Cot))]
- [InlineData(typeof(Csc))]
- [InlineData(typeof(Sec))]
- [InlineData(typeof(Sin))]
- [InlineData(typeof(Tan))]
+ [Test]
+ [TestCase(typeof(Cos))]
+ [TestCase(typeof(Cot))]
+ [TestCase(typeof(Csc))]
+ [TestCase(typeof(Sec))]
+ [TestCase(typeof(Sin))]
+ [TestCase(typeof(Tan))]
public void TestAngleNumber(Type type)
{
var exp = Create(type, AngleValue.Degree(10).AsExpression());
@@ -67,19 +67,19 @@ public void TestAngleNumber(Type type)
Test(exp, ResultTypes.Number);
}
- [Theory]
- [InlineData(typeof(Arccos))]
- [InlineData(typeof(Arccot))]
- [InlineData(typeof(Arccsc))]
- [InlineData(typeof(Arcsec))]
- [InlineData(typeof(Arcsin))]
- [InlineData(typeof(Arctan))]
- [InlineData(typeof(Cos))]
- [InlineData(typeof(Cot))]
- [InlineData(typeof(Csc))]
- [InlineData(typeof(Sec))]
- [InlineData(typeof(Sin))]
- [InlineData(typeof(Tan))]
+ [Test]
+ [TestCase(typeof(Arccos))]
+ [TestCase(typeof(Arccot))]
+ [TestCase(typeof(Arccsc))]
+ [TestCase(typeof(Arcsec))]
+ [TestCase(typeof(Arcsin))]
+ [TestCase(typeof(Arctan))]
+ [TestCase(typeof(Cos))]
+ [TestCase(typeof(Cot))]
+ [TestCase(typeof(Csc))]
+ [TestCase(typeof(Sec))]
+ [TestCase(typeof(Sin))]
+ [TestCase(typeof(Tan))]
public void TestComplexNumber(Type type)
{
var exp = Create(type, new ComplexNumber(2, 2));
@@ -87,19 +87,19 @@ public void TestComplexNumber(Type type)
Test(exp, ResultTypes.ComplexNumber);
}
- [Theory]
- [InlineData(typeof(Arccos))]
- [InlineData(typeof(Arccot))]
- [InlineData(typeof(Arccsc))]
- [InlineData(typeof(Arcsec))]
- [InlineData(typeof(Arcsin))]
- [InlineData(typeof(Arctan))]
- [InlineData(typeof(Cos))]
- [InlineData(typeof(Cot))]
- [InlineData(typeof(Csc))]
- [InlineData(typeof(Sec))]
- [InlineData(typeof(Sin))]
- [InlineData(typeof(Tan))]
+ [Test]
+ [TestCase(typeof(Arccos))]
+ [TestCase(typeof(Arccot))]
+ [TestCase(typeof(Arccsc))]
+ [TestCase(typeof(Arcsec))]
+ [TestCase(typeof(Arcsin))]
+ [TestCase(typeof(Arctan))]
+ [TestCase(typeof(Cos))]
+ [TestCase(typeof(Cot))]
+ [TestCase(typeof(Csc))]
+ [TestCase(typeof(Sec))]
+ [TestCase(typeof(Sin))]
+ [TestCase(typeof(Tan))]
public void TestParameterException(Type type)
{
var exp = Create(type, Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/TruncTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/TruncTests.cs
index b5fb0df6f..3a36866d2 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/TruncTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/TruncTests.cs
@@ -2,7 +2,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class TruncTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestTruncUndefined()
{
var exp = new Trunc(Variable.X);
@@ -10,7 +10,7 @@ public void TestTruncUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestTruncNumber()
{
var exp = new Trunc(new Number(10));
@@ -18,7 +18,7 @@ public void TestTruncNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestTruncAngle()
{
var exp = new Trunc(AngleValue.Degree(5.5).AsExpression());
@@ -26,7 +26,7 @@ public void TestTruncAngle()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestTruncPower()
{
var exp = new Trunc(PowerValue.Watt(5.5).AsExpression());
@@ -34,7 +34,7 @@ public void TestTruncPower()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestTruncTemperature()
{
var exp = new Trunc(TemperatureValue.Celsius(5.5).AsExpression());
@@ -42,7 +42,7 @@ public void TestTruncTemperature()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestTruncMass()
{
var exp = new Trunc(MassValue.Gram(5.5).AsExpression());
@@ -50,7 +50,7 @@ public void TestTruncMass()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestTruncLength()
{
var exp = new Trunc(LengthValue.Meter(5.5).AsExpression());
@@ -58,7 +58,7 @@ public void TestTruncLength()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestTimeLength()
{
var exp = new Trunc(TimeValue.Second(5.5).AsExpression());
@@ -66,7 +66,7 @@ public void TestTimeLength()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestAreaLength()
{
var exp = new Trunc(AreaValue.Meter(5.5).AsExpression());
@@ -74,7 +74,7 @@ public void TestAreaLength()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestVolumeLength()
{
var exp = new Trunc(VolumeValue.Meter(5.5).AsExpression());
@@ -82,7 +82,7 @@ public void TestVolumeLength()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestTruncException()
{
var exp = new Trunc(Bool.False);
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/TypeAnalyzerBaseTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/TypeAnalyzerBaseTests.cs
index 9354bed66..b2fa4471a 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/TypeAnalyzerBaseTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/TypeAnalyzerBaseTests.cs
@@ -2,7 +2,7 @@
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System.Reflection;
-using Xunit.Sdk;
+using NUnit.Framework.Internal;
namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
@@ -19,7 +19,7 @@ protected void Test(IExpression exp, ResultTypes expected)
{
var simple = exp.Analyze(analyzer);
- Assert.Equal(expected, simple);
+ Assert.That(simple, Is.EqualTo(expected));
}
protected void TestException(IExpression exp)
@@ -53,6 +53,6 @@ protected void TestNullExp(Type type)
throw;
}
- throw new XunitException("The exception is expected.");
+ throw new NUnitException("The exception is expected.");
}
}
\ No newline at end of file
diff --git a/xFunc.Tests/Analyzers/TypeAnalyzerTests/UnaryMinusTests.cs b/xFunc.Tests/Analyzers/TypeAnalyzerTests/UnaryMinusTests.cs
index ca06aff51..b831eee9f 100644
--- a/xFunc.Tests/Analyzers/TypeAnalyzerTests/UnaryMinusTests.cs
+++ b/xFunc.Tests/Analyzers/TypeAnalyzerTests/UnaryMinusTests.cs
@@ -2,7 +2,7 @@ namespace xFunc.Tests.Analyzers.TypeAnalyzerTests;
public class UnaryMinusTests : TypeAnalyzerBaseTests
{
- [Fact]
+ [Test]
public void TestUnaryMinusUndefined()
{
var exp = new UnaryMinus(Variable.X);
@@ -10,7 +10,7 @@ public void TestUnaryMinusUndefined()
Test(exp, ResultTypes.Undefined);
}
- [Fact]
+ [Test]
public void TestUnaryMinusNumber()
{
var exp = new UnaryMinus(new Number(10));
@@ -18,7 +18,7 @@ public void TestUnaryMinusNumber()
Test(exp, ResultTypes.Number);
}
- [Fact]
+ [Test]
public void TestUnaryMinusAngleNumber()
{
var exp = new UnaryMinus(AngleValue.Degree(10).AsExpression());
@@ -26,7 +26,7 @@ public void TestUnaryMinusAngleNumber()
Test(exp, ResultTypes.AngleNumber);
}
- [Fact]
+ [Test]
public void TestUnaryMinusPower()
{
var exp = new UnaryMinus(PowerValue.Watt(10).AsExpression());
@@ -34,7 +34,7 @@ public void TestUnaryMinusPower()
Test(exp, ResultTypes.PowerNumber);
}
- [Fact]
+ [Test]
public void TestUnaryMinusTemperature()
{
var exp = new UnaryMinus(TemperatureValue.Celsius(10).AsExpression());
@@ -42,7 +42,7 @@ public void TestUnaryMinusTemperature()
Test(exp, ResultTypes.TemperatureNumber);
}
- [Fact]
+ [Test]
public void TestUnaryMinusMass()
{
var exp = new UnaryMinus(MassValue.Gram(10).AsExpression());
@@ -50,7 +50,7 @@ public void TestUnaryMinusMass()
Test(exp, ResultTypes.MassNumber);
}
- [Fact]
+ [Test]
public void TestUnaryMinusLength()
{
var exp = new UnaryMinus(LengthValue.Meter(10).AsExpression());
@@ -58,7 +58,7 @@ public void TestUnaryMinusLength()
Test(exp, ResultTypes.LengthNumber);
}
- [Fact]
+ [Test]
public void TestUnaryMinusTime()
{
var exp = new UnaryMinus(TimeValue.Second(10).AsExpression());
@@ -66,7 +66,7 @@ public void TestUnaryMinusTime()
Test(exp, ResultTypes.TimeNumber);
}
- [Fact]
+ [Test]
public void TestUnaryMinusArea()
{
var exp = new UnaryMinus(AreaValue.Meter(10).AsExpression());
@@ -74,7 +74,7 @@ public void TestUnaryMinusArea()
Test(exp, ResultTypes.AreaNumber);
}
- [Fact]
+ [Test]
public void TestUnaryMinusVolume()
{
var exp = new UnaryMinus(VolumeValue.Meter(10).AsExpression());
@@ -82,7 +82,7 @@ public void TestUnaryMinusVolume()
Test(exp, ResultTypes.VolumeNumber);
}
- [Fact]
+ [Test]
public void TestUnaryMinusComplexNumber()
{
var exp = new UnaryMinus(new ComplexNumber(10, 10));
@@ -90,7 +90,7 @@ public void TestUnaryMinusComplexNumber()
Test(exp, ResultTypes.ComplexNumber);
}
- [Fact]
+ [Test]
public void TestUnaryMinusRationalNumber()
{
var exp = new UnaryMinus(new Rational(Number.One, Number.Two));
@@ -98,7 +98,7 @@ public void TestUnaryMinusRationalNumber()
Test(exp, ResultTypes.RationalNumber);
}
- [Fact]
+ [Test]
public void TestUnaryMinusException()
{
var exp = new UnaryMinus(Bool.False);
diff --git a/xFunc.Tests/BuilderTest.cs b/xFunc.Tests/BuilderTest.cs
index 46842c70b..ef9d39165 100644
--- a/xFunc.Tests/BuilderTest.cs
+++ b/xFunc.Tests/BuilderTest.cs
@@ -5,41 +5,41 @@ namespace xFunc.Tests;
public class BuilderTest
{
- [Fact]
+ [Test]
public void ExpCtorTest()
{
- var exp = new Builder((IExpression)Number.Two).Expression;
+ var exp = new Builder(Number.Two).Expression;
- Assert.Equal(exp, Number.Two);
+ Assert.That(exp, Is.EqualTo(Number.Two));
}
- [Fact]
+ [Test]
public void NumberCtorTest()
{
var exp = new Builder(2).Expression;
- Assert.Equal(exp, Number.Two);
+ Assert.That(exp, Is.EqualTo(Number.Two));
}
- [Fact]
+ [Test]
public void VariableCtorTest()
{
var exp = new Builder("x").Expression;
- Assert.Equal(exp, Variable.X);
+ Assert.That(exp, Is.EqualTo(Variable.X));
}
- [Fact]
+ [Test]
public void ExpressionTest()
{
var exp = new Builder(3)
.Custom(exp => new Sin(exp))
.Expression;
- Assert.Equal(exp, new Sin(new Number(3)));
+ Assert.That(exp, Is.EqualTo(new Sin(new Number(3))));
}
- [Fact]
+ [Test]
public void ExpressionNullTest()
{
var builder = new Builder(3);
@@ -47,7 +47,7 @@ public void ExpressionNullTest()
Assert.Throws(() => builder.Custom(null));
}
- [Fact]
+ [Test]
public void ExecuteTest()
{
var exp = new Builder(3)
@@ -56,10 +56,10 @@ public void ExecuteTest()
var expected = new NumberValue(5.0);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(expected, Is.EqualTo(exp.Execute()));
}
- [Fact]
+ [Test]
public void ExecuteWithParamsTest()
{
var exp = new Builder(3)
@@ -68,10 +68,10 @@ public void ExecuteWithParamsTest()
var expected = new NumberValue(5.0);
- Assert.Equal(expected, exp.Execute(new ExpressionParameters()));
+ Assert.That(expected, Is.EqualTo(exp.Execute(new ExpressionParameters())));
}
- [Fact]
+ [Test]
public void NullParamTest()
{
Assert.Throws(() => new Builder((IExpression)null));
@@ -79,420 +79,420 @@ public void NullParamTest()
#region Standart
- [Fact]
+ [Test]
public void AddExpTest()
{
- var builder = new Builder(3).Add((IExpression)Number.Two);
+ var builder = new Builder(3).Add(Number.Two);
- Assert.Equal(builder.Expression, new Add(new Number(3), Number.Two));
+ Assert.That(builder.Expression, Is.EqualTo(new Add(new Number(3), Number.Two)));
}
- [Fact]
+ [Test]
public void AddNumberTest()
{
var builder = new Builder(3).Add(2);
- Assert.Equal(builder.Expression, new Add(new Number(3), Number.Two));
+ Assert.That(builder.Expression, Is.EqualTo(new Add(new Number(3), Number.Two)));
}
- [Fact]
+ [Test]
public void AddVariableTest()
{
var builder = new Builder(3).Add("x");
- Assert.Equal(builder.Expression, new Add(new Number(3), Variable.X));
+ Assert.That(builder.Expression, Is.EqualTo(new Add(new Number(3), Variable.X)));
}
- [Fact]
+ [Test]
public void SubExpTest()
{
- var builder = new Builder(3).Sub((IExpression)Number.Two);
+ var builder = new Builder(3).Sub(Number.Two);
- Assert.Equal(builder.Expression, new Sub(new Number(3), Number.Two));
+ Assert.That(builder.Expression, Is.EqualTo(new Sub(new Number(3), Number.Two)));
}
- [Fact]
+ [Test]
public void SubNumberTest()
{
var builder = new Builder(3).Sub(2);
- Assert.Equal(builder.Expression, new Sub(new Number(3), Number.Two));
+ Assert.That(builder.Expression, Is.EqualTo(new Sub(new Number(3), Number.Two)));
}
- [Fact]
+ [Test]
public void SubVariableTest()
{
var builder = new Builder(3).Sub("x");
- Assert.Equal(builder.Expression, new Sub(new Number(3), Variable.X));
+ Assert.That(builder.Expression, Is.EqualTo(new Sub(new Number(3), Variable.X)));
}
- [Fact]
+ [Test]
public void MulExpTest()
{
- var builder = new Builder(3).Mul((IExpression)Number.Two);
+ var builder = new Builder(3).Mul(Number.Two);
- Assert.Equal(builder.Expression, new Mul(new Number(3), Number.Two));
+ Assert.That(builder.Expression, Is.EqualTo(new Mul(new Number(3), Number.Two)));
}
- [Fact]
+ [Test]
public void MulNumberTest()
{
var builder = new Builder(3).Mul(2);
- Assert.Equal(builder.Expression, new Mul(new Number(3), Number.Two));
+ Assert.That(builder.Expression, Is.EqualTo(new Mul(new Number(3), Number.Two)));
}
- [Fact]
+ [Test]
public void MulVariableTest()
{
var builder = new Builder(3).Mul("x");
- Assert.Equal(builder.Expression, new Mul(new Number(3), Variable.X));
+ Assert.That(builder.Expression, Is.EqualTo(new Mul(new Number(3), Variable.X)));
}
- [Fact]
+ [Test]
public void DivExpTest()
{
- var builder = new Builder(3).Div((IExpression)Number.Two);
+ var builder = new Builder(3).Div(Number.Two);
- Assert.Equal(builder.Expression, new Div(new Number(3), Number.Two));
+ Assert.That(builder.Expression, Is.EqualTo(new Div(new Number(3), Number.Two)));
}
- [Fact]
+ [Test]
public void DivNumberTest()
{
var builder = new Builder(3).Div(2);
- Assert.Equal(builder.Expression, new Div(new Number(3), Number.Two));
+ Assert.That(builder.Expression, Is.EqualTo(new Div(new Number(3), Number.Two)));
}
- [Fact]
+ [Test]
public void DivVariableTest()
{
var builder = new Builder(3).Div("x");
- Assert.Equal(builder.Expression, new Div(new Number(3), Variable.X));
+ Assert.That(builder.Expression, Is.EqualTo(new Div(new Number(3), Variable.X)));
}
- [Fact]
+ [Test]
public void PowExpTest()
{
- var builder = new Builder(3).Pow((IExpression)Number.Two);
+ var builder = new Builder(3).Pow(Number.Two);
- Assert.Equal(builder.Expression, new Pow(new Number(3), Number.Two));
+ Assert.That(builder.Expression, Is.EqualTo(new Pow(new Number(3), Number.Two)));
}
- [Fact]
+ [Test]
public void PowNumberTest()
{
var builder = new Builder(3).Pow(2);
- Assert.Equal(builder.Expression, new Pow(new Number(3), Number.Two));
+ Assert.That(builder.Expression, Is.EqualTo(new Pow(new Number(3), Number.Two)));
}
- [Fact]
+ [Test]
public void PowVariableTest()
{
var builder = new Builder(3).Pow("x");
- Assert.Equal(builder.Expression, new Pow(new Number(3), Variable.X));
+ Assert.That(builder.Expression, Is.EqualTo(new Pow(new Number(3), Variable.X)));
}
- [Fact]
+ [Test]
public void SqrtNumberTest()
{
var builder = new Builder(3).Sqrt();
- Assert.Equal(builder.Expression, new Sqrt(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Sqrt(new Number(3))));
}
- [Fact]
+ [Test]
public void RootExpTest()
{
- var builder = new Builder(3).Root((IExpression)Number.Two);
+ var builder = new Builder(3).Root(Number.Two);
- Assert.Equal(builder.Expression, new Root(new Number(3), Number.Two));
+ Assert.That(builder.Expression, Is.EqualTo(new Root(new Number(3), Number.Two)));
}
- [Fact]
+ [Test]
public void RootNumberTest()
{
var builder = new Builder(3).Root(2);
- Assert.Equal(builder.Expression, new Root(new Number(3), Number.Two));
+ Assert.That(builder.Expression, Is.EqualTo(new Root(new Number(3), Number.Two)));
}
- [Fact]
+ [Test]
public void RootVariableTest()
{
var builder = new Builder(3).Root("x");
- Assert.Equal(builder.Expression, new Root(new Number(3), Variable.X));
+ Assert.That(builder.Expression, Is.EqualTo(new Root(new Number(3), Variable.X)));
}
- [Fact]
+ [Test]
public void AbsNumberTest()
{
var builder = new Builder(3).Abs();
- Assert.Equal(builder.Expression, new Abs(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Abs(new Number(3))));
}
- [Fact]
+ [Test]
public void LogExpTest()
{
- var builder = new Builder(3).Log((IExpression)Number.Two);
+ var builder = new Builder(3).Log(Number.Two);
- Assert.Equal(builder.Expression, new Log(Number.Two, new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Log(Number.Two, new Number(3))));
}
- [Fact]
+ [Test]
public void LogNumberTest()
{
var builder = new Builder(3).Log(2);
- Assert.Equal(builder.Expression, new Log(Number.Two, new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Log(Number.Two, new Number(3))));
}
- [Fact]
+ [Test]
public void LogVariableTest()
{
var builder = new Builder(3).Log("x");
- Assert.Equal(builder.Expression, new Log(Variable.X, new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Log(Variable.X, new Number(3))));
}
- [Fact]
+ [Test]
public void LnNumberTest()
{
var builder = new Builder(3).Ln();
- Assert.Equal(builder.Expression, new Ln(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Ln(new Number(3))));
}
- [Fact]
+ [Test]
public void LgNumberTest()
{
var builder = new Builder(3).Lg();
- Assert.Equal(builder.Expression, new Lg(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Lg(new Number(3))));
}
- [Fact]
+ [Test]
public void LbNumberTest()
{
var builder = new Builder(3).Lb();
- Assert.Equal(builder.Expression, new Lb(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Lb(new Number(3))));
}
- [Fact]
+ [Test]
public void ExpNumberTest()
{
var builder = new Builder(3).Exp();
- Assert.Equal(builder.Expression, new Exp(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Exp(new Number(3))));
}
#endregion Standart
#region Trigonometric
- [Fact]
+ [Test]
public void SinTest()
{
var builder = new Builder(3).Sin();
- Assert.Equal(builder.Expression, new Sin(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Sin(new Number(3))));
}
- [Fact]
+ [Test]
public void CosTest()
{
var builder = new Builder(3).Cos();
- Assert.Equal(builder.Expression, new Cos(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Cos(new Number(3))));
}
- [Fact]
+ [Test]
public void TanTest()
{
var builder = new Builder(3).Tan();
- Assert.Equal(builder.Expression, new Tan(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Tan(new Number(3))));
}
- [Fact]
+ [Test]
public void CotTest()
{
var builder = new Builder(3).Cot();
- Assert.Equal(builder.Expression, new Cot(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Cot(new Number(3))));
}
- [Fact]
+ [Test]
public void SecTest()
{
var builder = new Builder(3).Sec();
- Assert.Equal(builder.Expression, new Sec(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Sec(new Number(3))));
}
- [Fact]
+ [Test]
public void CscTest()
{
var builder = new Builder(3).Csc();
- Assert.Equal(builder.Expression, new Csc(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Csc(new Number(3))));
}
- [Fact]
+ [Test]
public void ArcsinTest()
{
var builder = new Builder(3).Arcsin();
- Assert.Equal(builder.Expression, new Arcsin(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Arcsin(new Number(3))));
}
- [Fact]
+ [Test]
public void ArccosTest()
{
var builder = new Builder(3).Arccos();
- Assert.Equal(builder.Expression, new Arccos(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Arccos(new Number(3))));
}
- [Fact]
+ [Test]
public void ArctanTest()
{
var builder = new Builder(3).Arctan();
- Assert.Equal(builder.Expression, new Arctan(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Arctan(new Number(3))));
}
- [Fact]
+ [Test]
public void ArccotTest()
{
var builder = new Builder(3).Arccot();
- Assert.Equal(builder.Expression, new Arccot(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Arccot(new Number(3))));
}
- [Fact]
+ [Test]
public void ArcsecTest()
{
var builder = new Builder(3).Arcsec();
- Assert.Equal(builder.Expression, new Arcsec(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Arcsec(new Number(3))));
}
- [Fact]
+ [Test]
public void ArccscTest()
{
var builder = new Builder(3).Arccsc();
- Assert.Equal(builder.Expression, new Arccsc(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Arccsc(new Number(3))));
}
#endregion Trigonometric
#region Hyperbolic
- [Fact]
+ [Test]
public void SinhTest()
{
var builder = new Builder(3).Sinh();
- Assert.Equal(builder.Expression, new Sinh(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Sinh(new Number(3))));
}
- [Fact]
+ [Test]
public void CoshTest()
{
var builder = new Builder(3).Cosh();
- Assert.Equal(builder.Expression, new Cosh(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Cosh(new Number(3))));
}
- [Fact]
+ [Test]
public void TanhTest()
{
var builder = new Builder(3).Tanh();
- Assert.Equal(builder.Expression, new Tanh(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Tanh(new Number(3))));
}
- [Fact]
+ [Test]
public void CothTest()
{
var builder = new Builder(3).Coth();
- Assert.Equal(builder.Expression, new Coth(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Coth(new Number(3))));
}
- [Fact]
+ [Test]
public void SechTest()
{
var builder = new Builder(3).Sech();
- Assert.Equal(builder.Expression, new Sech(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Sech(new Number(3))));
}
- [Fact]
+ [Test]
public void CschTest()
{
var builder = new Builder(3).Csch();
- Assert.Equal(builder.Expression, new Csch(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Csch(new Number(3))));
}
- [Fact]
+ [Test]
public void ArsinhTest()
{
var builder = new Builder(3).Arsinh();
- Assert.Equal(builder.Expression, new Arsinh(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Arsinh(new Number(3))));
}
- [Fact]
+ [Test]
public void ArcoshTest()
{
var builder = new Builder(3).Arcosh();
- Assert.Equal(builder.Expression, new Arcosh(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Arcosh(new Number(3))));
}
- [Fact]
+ [Test]
public void ArtanhTest()
{
var builder = new Builder(3).Artanh();
- Assert.Equal(builder.Expression, new Artanh(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Artanh(new Number(3))));
}
- [Fact]
+ [Test]
public void ArcothTest()
{
var builder = new Builder(3).Arcoth();
- Assert.Equal(builder.Expression, new Arcoth(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Arcoth(new Number(3))));
}
- [Fact]
+ [Test]
public void ArsechTest()
{
var builder = new Builder(3).Arsech();
- Assert.Equal(builder.Expression, new Arsech(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Arsech(new Number(3))));
}
- [Fact]
+ [Test]
public void ArcschTest()
{
var builder = new Builder(3).Arcsch();
- Assert.Equal(builder.Expression, new Arcsch(new Number(3)));
+ Assert.That(builder.Expression, Is.EqualTo(new Arcsch(new Number(3))));
}
#endregion Hyperbolic
diff --git a/xFunc.Tests/Expressions/AbsTest.cs b/xFunc.Tests/Expressions/AbsTest.cs
index dd6b67ee5..8b29a6771 100644
--- a/xFunc.Tests/Expressions/AbsTest.cs
+++ b/xFunc.Tests/Expressions/AbsTest.cs
@@ -8,97 +8,97 @@ namespace xFunc.Tests.Expressions;
public class AbsTest : BaseExpressionTests
{
- [Fact]
+ [Test]
public void ExecuteTestNumber()
{
var exp = new Abs(new Number(-1));
var expected = new NumberValue(1.0);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestAngleNumber()
{
var exp = new Abs(AngleValue.Degree(-10).AsExpression());
var expected = AngleValue.Degree(10);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestPowerValue()
{
var exp = new Abs(PowerValue.Watt(-1).AsExpression());
var expected = PowerValue.Watt(1);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestTemperatureValue()
{
var exp = new Abs(TemperatureValue.Celsius(-1).AsExpression());
var expected = TemperatureValue.Celsius(1);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestMassValue()
{
var exp = new Abs(MassValue.Gram(-1).AsExpression());
var expected = MassValue.Gram(1);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestLengthValue()
{
var exp = new Abs(LengthValue.Meter(-1).AsExpression());
var expected = LengthValue.Meter(1);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestTimeValue()
{
var exp = new Abs(TimeValue.Second(-1).AsExpression());
var expected = TimeValue.Second(1);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestAreaValue()
{
var exp = new Abs(AreaValue.Meter(-1).AsExpression());
var expected = AreaValue.Meter(1);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestVolumeValue()
{
var exp = new Abs(VolumeValue.Meter(-1).AsExpression());
var expected = VolumeValue.Meter(1);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestComplexNumber()
{
var exp = new Abs(new ComplexNumber(4, 2));
var expected = Complex.Abs(new Complex(4, 2));
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestVector()
{
var exp = new Abs(new Vector(new IExpression[]
@@ -107,23 +107,23 @@ public void ExecuteTestVector()
}));
var expected = new NumberValue(11.2249721603218241567);
- Assert.Equal(expected, (NumberValue)exp.Execute());
+ Assert.That((NumberValue)exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestRational()
{
var exp = new Abs(new Rational(new Number(-1), new Number(3)));
var expected = new RationalValue(1, 3);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestException()
=> TestNotSupported(new Abs(Bool.False));
- [Fact]
+ [Test]
public void EqualsTest1()
{
Variable x1 = "x";
@@ -140,7 +140,7 @@ public void EqualsTest1()
Assert.True(abs1.Equals(abs1));
}
- [Fact]
+ [Test]
public void EqualsTest2()
{
Variable x1 = "x";
@@ -158,12 +158,12 @@ public void EqualsTest2()
Assert.False(abs1.Equals(null));
}
- [Fact]
+ [Test]
public void CloneTest()
{
var exp = new Abs(Number.Zero);
var clone = exp.Clone();
- Assert.Equal(exp, clone);
+ Assert.That(clone, Is.EqualTo(exp));
}
}
\ No newline at end of file
diff --git a/xFunc.Tests/Expressions/AddTest.cs b/xFunc.Tests/Expressions/AddTest.cs
index cabde1903..11b21d8e8 100644
--- a/xFunc.Tests/Expressions/AddTest.cs
+++ b/xFunc.Tests/Expressions/AddTest.cs
@@ -9,61 +9,61 @@ namespace xFunc.Tests.Expressions;
public class AddTest : BaseExpressionTests
{
- [Fact]
+ [Test]
public void ExecuteTestNumber1()
{
var exp = new Add(Number.One, Number.Two);
var expected = new NumberValue(3.0);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestNumber2()
{
var exp = new Add(new Number(-3), Number.Two);
var expected = new NumberValue(-1.0);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestComplexNumber()
{
var exp = new Add(new ComplexNumber(7, 3), new ComplexNumber(2, 4));
var expected = new Complex(9, 7);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestNumberComplexNumber()
{
var exp = new Add(new Number(7), new ComplexNumber(2, 4));
var expected = new Complex(9, 4);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestComplexNumberNumber()
{
var exp = new Add(new ComplexNumber(7, 3), Number.Two);
var expected = new Complex(9, 3);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTest6()
{
var exp = new Add(Number.Two, new Sqrt(new Number(-9)));
var expected = new Complex(2, 3);
- Assert.Equal(expected, exp.Execute());
+ Assert.That(exp.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AddTwoVectorsTest()
{
var vector1 = new Vector(new IExpression[] { Number.Two, new Number(3) });
@@ -73,10 +73,10 @@ public void AddTwoVectorsTest()
var expected = VectorValue.Create(new NumberValue(9), new NumberValue(4));
var result = add.Execute();
- Assert.Equal(expected, result);
+ Assert.That(result, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AddTwoMatricesTest()
{
var matrix1 = new Matrix(new[]
@@ -98,10 +98,10 @@ public void AddTwoMatricesTest()
});
var result = add.Execute();
- Assert.Equal(expected, result);
+ Assert.That(result, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void Add4MatricesTest()
{
var vector1 = new Vector(new IExpression[] { Number.One, Number.Two });
@@ -114,30 +114,30 @@ public void Add4MatricesTest()
var expected = VectorValue.Create(new NumberValue(4), new NumberValue(8));
- Assert.Equal(expected, add3.Execute());
+ Assert.That(add3.Execute(), Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AddNumberAndDegree()
{
var exp = new Add(Number.One, AngleValue.Degree(10).AsExpression());
var actual = exp.Execute();
var expected = AngleValue.Degree(11);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AddRadianAndNumber()
{
var exp = new Add(AngleValue.Radian(10).AsExpression(), Number.One);
var actual = exp.Execute();
var expected = AngleValue.Radian(11);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AddDegreeAndRadian()
{
var exp = new Add(
@@ -147,10 +147,10 @@ public void AddDegreeAndRadian()
var actual = exp.Execute();
var expected = AngleValue.Degree(190);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void AddGradianAndGradian()
{
var exp = new Add(
@@ -160,10 +160,10 @@ public void AddGradianAndGradian()
var actual = exp.Execute();
var expected = AngleValue.Gradian(30);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteNumberAndPower()
{
var exp = new Add(
@@ -173,10 +173,10 @@ public void ExecuteNumberAndPower()
var actual = exp.Execute();
var expected = PowerValue.Watt(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecutePowerAndNumber()
{
var exp = new Add(
@@ -186,10 +186,10 @@ public void ExecutePowerAndNumber()
var actual = exp.Execute();
var expected = PowerValue.Watt(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecutePowerAndPower()
{
var exp = new Add(
@@ -199,10 +199,10 @@ public void ExecutePowerAndPower()
var actual = exp.Execute();
var expected = PowerValue.Watt(3);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteNumberAndTemperature()
{
var exp = new Add(
@@ -212,10 +212,10 @@ public void ExecuteNumberAndTemperature()
var actual = exp.Execute();
var expected = TemperatureValue.Celsius(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTemperatureAndNumber()
{
var exp = new Add(
@@ -225,10 +225,10 @@ public void ExecuteTemperatureAndNumber()
var actual = exp.Execute();
var expected = TemperatureValue.Celsius(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTemperatureAndTemperature()
{
var exp = new Add(
@@ -238,10 +238,10 @@ public void ExecuteTemperatureAndTemperature()
var actual = exp.Execute();
var expected = TemperatureValue.Celsius(3);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteNumberAndMass()
{
var exp = new Add(
@@ -251,10 +251,10 @@ public void ExecuteNumberAndMass()
var actual = exp.Execute();
var expected = MassValue.Gram(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteMassAndNumber()
{
var exp = new Add(
@@ -264,10 +264,10 @@ public void ExecuteMassAndNumber()
var actual = exp.Execute();
var expected = MassValue.Gram(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteMassAndMass()
{
var exp = new Add(
@@ -277,10 +277,10 @@ public void ExecuteMassAndMass()
var actual = exp.Execute();
var expected = MassValue.Gram(3);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteNumberAndLength()
{
var exp = new Add(
@@ -290,10 +290,10 @@ public void ExecuteNumberAndLength()
var actual = exp.Execute();
var expected = LengthValue.Meter(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteLengthAndNumber()
{
var exp = new Add(
@@ -303,10 +303,10 @@ public void ExecuteLengthAndNumber()
var actual = exp.Execute();
var expected = LengthValue.Meter(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteLengthAndLength()
{
var exp = new Add(
@@ -316,10 +316,10 @@ public void ExecuteLengthAndLength()
var actual = exp.Execute();
var expected = LengthValue.Meter(3);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteNumberAndTime()
{
var exp = new Add(
@@ -329,10 +329,10 @@ public void ExecuteNumberAndTime()
var actual = exp.Execute();
var expected = TimeValue.Second(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTimeAndNumber()
{
var exp = new Add(
@@ -342,10 +342,10 @@ public void ExecuteTimeAndNumber()
var actual = exp.Execute();
var expected = TimeValue.Second(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTimeAndTime()
{
var exp = new Add(
@@ -355,10 +355,10 @@ public void ExecuteTimeAndTime()
var actual = exp.Execute();
var expected = TimeValue.Second(3);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteNumberAndArea()
{
var exp = new Add(
@@ -368,10 +368,10 @@ public void ExecuteNumberAndArea()
var actual = exp.Execute();
var expected = AreaValue.Meter(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteAreaAndNumber()
{
var exp = new Add(
@@ -381,10 +381,10 @@ public void ExecuteAreaAndNumber()
var actual = exp.Execute();
var expected = AreaValue.Meter(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTimeAndArea()
{
var exp = new Add(
@@ -394,10 +394,10 @@ public void ExecuteTimeAndArea()
var actual = exp.Execute();
var expected = AreaValue.Meter(3);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteNumberAndVolume()
{
var exp = new Add(
@@ -407,10 +407,10 @@ public void ExecuteNumberAndVolume()
var actual = exp.Execute();
var expected = VolumeValue.Meter(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteVolumeAndNumber()
{
var exp = new Add(
@@ -420,10 +420,10 @@ public void ExecuteVolumeAndNumber()
var actual = exp.Execute();
var expected = VolumeValue.Meter(2);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTimeAndVolume()
{
var exp = new Add(
@@ -433,10 +433,10 @@ public void ExecuteTimeAndVolume()
var actual = exp.Execute();
var expected = VolumeValue.Meter(3);
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteStringAndString()
{
var exp = new Add(
@@ -446,10 +446,10 @@ public void ExecuteStringAndString()
var actual = exp.Execute();
var expected = "ab";
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteStringAndNumber()
{
var exp = new Add(
@@ -459,10 +459,10 @@ public void ExecuteStringAndNumber()
var actual = exp.Execute();
var expected = "a1";
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteNumberAndString()
{
var exp = new Add(
@@ -472,10 +472,10 @@ public void ExecuteNumberAndString()
var actual = exp.Execute();
var expected = "1b";
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteRationalAndRational()
{
var exp = new Add(
@@ -485,10 +485,10 @@ public void ExecuteRationalAndRational()
var expected = new RationalValue(5, 2);
var actual = exp.Execute();
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteNumberAndRational()
{
var exp = new Add(
@@ -498,10 +498,10 @@ public void ExecuteNumberAndRational()
var expected = new RationalValue(3, 1);
var actual = exp.Execute();
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteRationalAndNumber()
{
var exp = new Add(
@@ -511,22 +511,22 @@ public void ExecuteRationalAndNumber()
var expected = new RationalValue(3, 2);
var actual = exp.Execute();
- Assert.Equal(expected, actual);
+ Assert.That(actual, Is.EqualTo(expected));
}
- [Fact]
+ [Test]
public void ExecuteTestException()
=> TestNotSupported(new Add(Bool.False, Bool.False));
- [Fact]
+ [Test]
public void ExecuteComplexNumberAndBool()
=> TestNotSupported(new Add(new ComplexNumber(7, 3), Bool.False));
- [Fact]
+ [Test]
public void ExecuteBoolAndComplexNumber()
=> TestNotSupported(new Add(Bool.False, new ComplexNumber(7, 3)));
- [Fact]
+ [Test]
public void AnalyzeNull()
{
var exp = new Add(Number.One, Number.One);
@@ -534,7 +534,7 @@ public void AnalyzeNull()
Assert.Throws(() => exp.Analyze