public void PosInfinityNotEquals()
{
expectedMessage =
" Expected: Infinity" + Environment.NewLine +
" But was: 1.23d" + Environment.NewLine;
Ensure.AreEqual(Double.PositiveInfinity, 1.23, 0.0);
}
public void PosInfinityNotEqualsNegInfinity()
{
expectedMessage =
" Expected: Infinity" + Environment.NewLine +
" But was: -Infinity" + Environment.NewLine;
Ensure.AreEqual(Double.PositiveInfinity, Double.NegativeInfinity, 0.0);
}
public void EqualsNaNFails()
{
expectedMessage =
" Expected: 1.234d +/- 0.0d" + Environment.NewLine +
" But was: NaN" + Environment.NewLine;
Ensure.AreEqual(1.234, Double.NaN, 0.0);
}
public void NanEqualsFails()
{
expectedMessage =
" Expected: NaN" + Environment.NewLine +
" But was: 1.234d" + Environment.NewLine;
Ensure.AreEqual(Double.NaN, 1.234, 0.0);
}
public void EqualityTests()
{
int[] i3 = new int[] { 1, 2, 3 };
double[] d3 = new double[] { 1.0, 2.0, 3.0 };
int[] iunequal = new int[] { 1, 3, 2 };
// Classic Syntax
Ensure.AreEqual(4, 2 + 2);
Ensure.AreEqual(i3, d3);
Ensure.AreNotEqual(5, 2 + 2);
Ensure.AreNotEqual(i3, iunequal);
// Helper syntax
Ensure.That(2 + 2, Is.EqualTo(4));
Ensure.That(2 + 2 == 4);
Ensure.That(i3, Is.EqualTo(d3));
Ensure.That(2 + 2, Is.Not.EqualTo(5));
Ensure.That(i3, Is.Not.EqualTo(iunequal));
// Inherited syntax
EnsuranceHelper.Expect(2 + 2, EqualTo(4));
EnsuranceHelper.Expect(2 + 2 == 4);
EnsuranceHelper.Expect(i3, EqualTo(d3));
EnsuranceHelper.Expect(2 + 2, Not.EqualTo(5));
EnsuranceHelper.Expect(i3, Not.EqualTo(iunequal));
}
public override bool Execute()
{
Ensure.AreEqual(Dependency[0].Integer % 3, 1);
while (Dependency[0].Integer != Dependency.Count - 1)
{
AddDependency(InterpreterNames.Point3D);
}
var pointList = new Point3D[4];
var items = Dependency[0].Integer;
var compoundShape = new TopoDSCompound();
var shapeBuilder = new BRepBuilder();
shapeBuilder.MakeCompound(compoundShape);
var startIndex = 0;
while (startIndex < items - 1)
{
pointList[0] = Dependency[startIndex + 1].TransformedPoint3D;
pointList[1] = Dependency[startIndex + 2].TransformedPoint3D;
pointList[2] = Dependency[startIndex + 3].TransformedPoint3D;
pointList[3] = Dependency[startIndex + 4].TransformedPoint3D;
var shape = SplineUtils.BuildSplineWire(pointList);
shapeBuilder.Add(compoundShape, shape);
startIndex += 3;
}
Shape = compoundShape;
return(true);
}
private void ConnectInputs()
{
var inputFactory = ActionsGraph.InputContainer;
foreach (var dependencyName in _dependencies.Keys)
{
ActionsGraph[dependencyName].Disconnect();
}
//Ensure.AreEqual(Inputs.Count, 0);
if (Inputs.Count > 0)
{
DisconnectInputs();
}
foreach (var dependencyName in _dependencies.Keys)
{
Ensure.IsTrue(!Inputs.ContainsKey(dependencyName),
"Inputs should be cleared before repopulating");
var input = ActionsGraph[dependencyName];
input.HasDataNotify += OnReceiveInputData;
Inputs[dependencyName] = input;
if (input is PipeBase)
{
inputFactory.ConnectPipe(input.Name);
}
}
Ensure.AreEqual(Inputs.Count, _dependencies.Count);
foreach (var dependencyName in _dependencies.Keys)
{
ActionsGraph[dependencyName].OnConnect();
}
}
public void SinglePosInfinityNotEqualsNegInfinity()
{
expectedMessage =
" Expected: Infinity" + Environment.NewLine +
" But was: -Infinity" + Environment.NewLine;
Ensure.AreEqual(float.PositiveInfinity, float.NegativeInfinity, (float)0.0);
}
public void Bug575936Int32Int64Comparison()
{
long l64 = 0;
int i32 = 0;
Ensure.AreEqual(i32, l64);
}
public void EqualityTestsWithTolerance()
{
// CLassic syntax
Ensure.AreEqual(5.0d, 4.99d, 0.05d);
Ensure.AreEqual(5.0f, 4.99f, 0.05f);
// Helper syntax
Ensure.That(4.99d, Is.EqualTo(5.0d).Within(0.05d));
Ensure.That(4.0d, Is.Not.EqualTo(5.0d).Within(0.5d));
Ensure.That(4.99f, Is.EqualTo(5.0f).Within(0.05f));
Ensure.That(4.99m, Is.EqualTo(5.0m).Within(0.05m));
Ensure.That(3999999999u, Is.EqualTo(4000000000u).Within(5u));
Ensure.That(499, Is.EqualTo(500).Within(5));
Ensure.That(4999999999L, Is.EqualTo(5000000000L).Within(5L));
Ensure.That(5999999999ul, Is.EqualTo(6000000000ul).Within(5ul));
// Inherited syntax
EnsuranceHelper.Expect(4.99d, EqualTo(5.0d).Within(0.05d));
EnsuranceHelper.Expect(4.0d, Not.EqualTo(5.0d).Within(0.5d));
EnsuranceHelper.Expect(4.99f, EqualTo(5.0f).Within(0.05f));
EnsuranceHelper.Expect(4.99m, EqualTo(5.0m).Within(0.05m));
EnsuranceHelper.Expect(499u, EqualTo(500u).Within(5u));
EnsuranceHelper.Expect(499, EqualTo(500).Within(5));
EnsuranceHelper.Expect(4999999999L, EqualTo(5000000000L).Within(5L));
EnsuranceHelper.Expect(5999999999ul, EqualTo(6000000000ul).Within(5ul));
}
public void FloatNotEqualMessageDisplaysAllDigits()
{
string message = "";
try
{
float f1 = 36.125F;
float f2 = 36.125004F;
Ensure.AreEqual(f1, f2);
}
catch (EnsuranceException ex)
{
message = ex.Message;
}
if (message == "")
{
Ensure.Fail("Should have thrown an EnsuranceException");
}
int i = message.IndexOf('3');
int j = message.IndexOf('f', i);
string expected = message.Substring(i, j - i + 1);
i = message.IndexOf('3', j);
j = message.IndexOf('f', i);
string actual = message.Substring(i, j - i + 1);
Ensure.AreNotEqual(expected, actual);
}
/// <inheritdoc/>
public async Task <T> GetUserByIdAsync(Guid id)
{
// Sanity check input
id = Ensure.IsNotNull(() => id);
this.Logger.LogTrace($"Getting user with id {id} from Cosmos DB");
using var iterator = await this.WithRetriesAsync <FeedIterator <T>, CosmosException>(
() => this.container.GetItemLinqQueryable <T>()
.Where (user => id.ToString() == user.Id.ToString())
.Take (1)
.ToFeedIterator());
var feedResponse = await iterator.ReadNextAsync();
// There should be only one result
Ensure.IsFalse(() => iterator.HasMoreResults);
Ensure.AreEqual(() => 1, () => feedResponse.Count);
var maybeNullUser = feedResponse.Single(user => id.Equals(user.Id));
// Ensure user is not null
var user = Ensure.IsNotNull(() => maybeNullUser);
user.Validate();
this.Logger.LogInformation("Got 1 user from Cosmos DB");
return(user);
}
public void DoubleNotEqualMessageDisplaysAllDigits()
{
string message = "";
try
{
double d1 = 36.1;
double d2 = 36.099999999999994;
Ensure.AreEqual(d1, d2);
}
catch (EnsuranceException ex)
{
message = ex.Message;
}
if (message == "")
{
Ensure.Fail("Should have thrown an EnsuranceException");
}
int i = message.IndexOf('3');
int j = message.IndexOf('d', i);
string expected = message.Substring(i, j - i + 1);
i = message.IndexOf('3', j);
j = message.IndexOf('d', i);
string actual = message.Substring(i, j - i + 1);
Ensure.AreNotEqual(expected, actual);
}
public void DateTimeEqual()
{
DateTime dt1 = new DateTime(2005, 6, 1, 7, 0, 0);
DateTime dt2 = new DateTime(2005, 6, 1, 0, 0, 0) + TimeSpan.FromHours(7.0);
Ensure.AreEqual(dt1, dt2);
}
public void HandleException(Exception ex)
{
if (expectedMessage != null)
{
Ensure.AreEqual(expectedMessage, ex.Message);
}
}
/// <inheritdoc/>
public async Task <T> GetUserByEmailAsync(string email)
{
// Sanity check input
email = Ensure.IsNotNullOrWhitespace(() => email);
this.Logger.LogTrace($"Getting user with email {email} from Cosmos DB");
using var iterator = await this.WithRetriesAsync <FeedIterator <T>, CosmosException>(
() => this.container.GetItemLinqQueryable <T>()
#pragma warning disable CS8602 // All users in database will have email
.Where (user => user.Email.Equals(email))
#pragma warning restore CS8602
.Take (1)
.ToFeedIterator());
var feedResponse = await iterator.ReadNextAsync();
// There should be only one result
Ensure.IsFalse(() => iterator.HasMoreResults);
Ensure.AreEqual(() => 1, () => feedResponse.Count);
var maybeNullUser = feedResponse.Single(user => user.Email == email);
// Ensure user is not null
var user = Ensure.IsNotNull(() => maybeNullUser);
user.Validate();
this.Logger.LogInformation("Got 1 user from Cosmos DB");
return(user);
}
public void AreEqual_HandlesNull()
{
object[] set1 = new object[3];
object[] set2 = new object[3];
Ensure.AreEqual(set1, set2);
Ensure.AreEqual(set1, set2, new TestComparer());
}
public void String()
{
string s1 = "test";
string s2 = new StringBuilder(s1).ToString();
Ensure.IsTrue(s1.Equals(s2));
Ensure.AreEqual(s1, s2);
}
public void Byte()
{
byte val = 1;
byte expected = val;
byte actual = val;
Ensure.IsTrue(expected == actual);
Ensure.AreEqual(expected, actual);
}
public void Equals()
{
string nunitString = "Hello NUnit";
string expected = nunitString;
string actual = nunitString;
Ensure.IsTrue(expected == actual);
Ensure.AreEqual(expected, actual);
}
public void EnumsNotEqual()
{
MyEnum actual = MyEnum.a;
expectedMessage =
" Expected: c" + Environment.NewLine +
" But was: a" + Environment.NewLine;
Ensure.AreEqual(MyEnum.c, actual);
}
public void Short()
{
short val = 1;
short expected = val;
short actual = val;
Ensure.IsTrue(expected == actual);
Ensure.AreEqual(expected, actual);
}
public void Float()
{
float val = (float)1.0;
float expected = val;
float actual = val;
Ensure.IsTrue(expected == actual);
Ensure.AreEqual(expected, actual, (float)0.0);
}
public void UInt()
{
uint val = 1;
uint expected = val;
uint actual = val;
Ensure.IsTrue(expected == actual);
Ensure.AreEqual(expected, actual);
}
public void ArrayAndCollection_Failure()
{
int[] a = new int[] { 1, 2, 3 };
ArrayList b = new ArrayList();
b.Add(1);
b.Add(3);
Ensure.AreEqual(a, b);
}
public void DateTimeNotEqual()
{
DateTime dt1 = new DateTime(2005, 6, 1, 7, 0, 0);
DateTime dt2 = new DateTime(2005, 6, 1, 0, 0, 0);
expectedMessage =
" Expected: 2005-06-01 07:00:00.000" + Environment.NewLine +
" But was: 2005-06-01 00:00:00.000" + Environment.NewLine;
Ensure.AreEqual(dt1, dt2);
}
public void NullEqualsNull()
{
expectedMessage =
" Expected: not null" + Environment.NewLine +
" But was: null" + Environment.NewLine;
object obj1 = null;
object obj2 = null;
Ensure.AreEqual(obj1, obj2);
Ensure.AreNotEqual(obj1, obj2);
}
public void EqualsFail()
{
string junitString = "Goodbye JUnit";
string expected = "Hello NUnit";
expectedMessage =
" Expected string length 11 but was 13. Strings differ at index 0." + Environment.NewLine +
" Expected: \"Hello NUnit\"" + Environment.NewLine +
" But was: \"Goodbye JUnit\"" + Environment.NewLine +
" -----------^" + Environment.NewLine;
Ensure.AreEqual(expected, junitString);
}
private void RemoveButtonClick(object sender, RoutedEventArgs e)
{
Log.Info("After pressing Remove Layer button");
var toRemove = GetItemsToRemove();
Ensure.AreEqual(1, toRemove.Count);
var index = toRemove[0].Index;
var container = ExtractLayerContainer();
BeginUpdate();
container.RemoveLayer(index, _viewInfo.Document);
EndUpdate();
}
public void Decimal()
{
decimal expected = 100m;
decimal actual = 100.0m;
int integer = 100;
Ensure.IsTrue(expected == actual);
Ensure.AreEqual(expected, actual);
Ensure.IsTrue(expected == integer);
Ensure.AreEqual(expected, integer);
Ensure.IsTrue(actual == integer);
Ensure.AreEqual(actual, integer);
}
