fluentassertions Issue Tracker Rss Feed

Commented Unassigned: CollectionAssertions.Equal does not handle null properly [12490]

dennisdoomen — Thu, 23 May 2013 18:45:30 GMT

I have the following situation:

string[] expected = null;
string[] result = null;

result.Should().Equal(expected) // Throws Exception

"Expected collection to be equal, but found <null>."

Since the result is equal to the expected, this should not throw an exception.
Comments: We'll include your Pull Request. We never ran into this ourselves because our collections are never allowed to be _null_ (because of our coding guidelines).

Commented Issue: Inconsistent ShouldBeEquivalentTo() behaviour for collections of complex types [12484]

dennisdoomen — Thu, 23 May 2013 18:43:03 GMT

I'm having trouble comparing lists of objects that come back in an indeterminate order. I thought `ShouldBeEquivalentTo()` would take care of this for me, but it doesn't seem to :(
Check out the comments in following sample class for a more thorough description.
```
using System.Collections.Generic;
using FluentAssertions;
using NUnit.Framework;

namespace CrazyMo.Tests
{
[TestFixture]
public class ShouldBeEquivalentToTests
{
public class SomeClass
{
public int SomeInt { get; set; }
}
[Test]
public void DoSomethingAwesome_Scenario_ExpectedResult()
{
SomeClass some1 = new SomeClass { SomeInt = 1 };
SomeClass someOther1 = new SomeClass { SomeInt = 1 };
some1.ShouldBeEquivalentTo(someOther1); // This works

IEnumerable<int> someInts = new List<int> {1, 2};
IEnumerable<int> someOtherInts = new List<int> {2, 1};
someInts.Should().BeEquivalentTo(someOtherInts); // This works
someInts.Should().BeEquivalentTo(2, 1); // This works

IEnumerable<SomeClass> actual = new List<SomeClass>
{
new SomeClass{SomeInt = 1},
new SomeClass{SomeInt = 2}
};

// This does work
actual.ShouldBeEquivalentTo(new List<SomeClass>{
new SomeClass { SomeInt = 1 },
new SomeClass { SomeInt = 2 }
});

// The following is in reverse order, just like someOtherInts above.
// This doesn't work, but should?
actual.ShouldBeEquivalentTo(new List<SomeClass>
{
new SomeClass{SomeInt = 2},
new SomeClass{SomeInt = 1}
});
// This is similar to BeEquivalentTo(2, 1) above, but doesn't work.
// It's even in the correct order.
actual.Should().BeEquivalentTo(
new SomeClass { SomeInt = 1 },
new SomeClass { SomeInt = 2 }
);

}
}
}
```
Comments: BTW, ignoring the order is already part of the Release-2.1 branch.

Commented Issue: Inconsistent ShouldBeEquivalentTo() behaviour for collections of complex types [12484]

dennisdoomen — Thu, 23 May 2013 18:42:18 GMT

I'm having trouble comparing lists of objects that come back in an indeterminate order. I thought `ShouldBeEquivalentTo()` would take care of this for me, but it doesn't seem to :(
Check out the comments in following sample class for a more thorough description.
```
using System.Collections.Generic;
using FluentAssertions;
using NUnit.Framework;

namespace CrazyMo.Tests
{
[TestFixture]
public class ShouldBeEquivalentToTests
{
public class SomeClass
{
public int SomeInt { get; set; }
}
[Test]
public void DoSomethingAwesome_Scenario_ExpectedResult()
{
SomeClass some1 = new SomeClass { SomeInt = 1 };
SomeClass someOther1 = new SomeClass { SomeInt = 1 };
some1.ShouldBeEquivalentTo(someOther1); // This works

IEnumerable<int> someInts = new List<int> {1, 2};
IEnumerable<int> someOtherInts = new List<int> {2, 1};
someInts.Should().BeEquivalentTo(someOtherInts); // This works
someInts.Should().BeEquivalentTo(2, 1); // This works

IEnumerable<SomeClass> actual = new List<SomeClass>
{
new SomeClass{SomeInt = 1},
new SomeClass{SomeInt = 2}
};

// This does work
actual.ShouldBeEquivalentTo(new List<SomeClass>{
new SomeClass { SomeInt = 1 },
new SomeClass { SomeInt = 2 }
});

// The following is in reverse order, just like someOtherInts above.
// This doesn't work, but should?
actual.ShouldBeEquivalentTo(new List<SomeClass>
{
new SomeClass{SomeInt = 2},
new SomeClass{SomeInt = 1}
});
// This is similar to BeEquivalentTo(2, 1) above, but doesn't work.
// It's even in the correct order.
actual.Should().BeEquivalentTo(
new SomeClass { SomeInt = 1 },
new SomeClass { SomeInt = 2 }
);

}
}
}
```
Comments: Using IComparable, IComparable<T> and IEquatable<T> is not safe. You would be relying on the implementation for determining the equality of two classes. In most cases, only one or two properties are used to determine if two objects are functionally equivalent. The Equal() overload that takes a predicate already exists in 2.0.

Commented Issue: Inconsistent ShouldBeEquivalentTo() behaviour for collections of complex types [12484]

tommck — Thu, 23 May 2013 18:11:22 GMT

I'm having trouble comparing lists of objects that come back in an indeterminate order. I thought `ShouldBeEquivalentTo()` would take care of this for me, but it doesn't seem to :(
Check out the comments in following sample class for a more thorough description.
```
using System.Collections.Generic;
using FluentAssertions;
using NUnit.Framework;

namespace CrazyMo.Tests
{
[TestFixture]
public class ShouldBeEquivalentToTests
{
public class SomeClass
{
public int SomeInt { get; set; }
}
[Test]
public void DoSomethingAwesome_Scenario_ExpectedResult()
{
SomeClass some1 = new SomeClass { SomeInt = 1 };
SomeClass someOther1 = new SomeClass { SomeInt = 1 };
some1.ShouldBeEquivalentTo(someOther1); // This works

IEnumerable<int> someInts = new List<int> {1, 2};
IEnumerable<int> someOtherInts = new List<int> {2, 1};
someInts.Should().BeEquivalentTo(someOtherInts); // This works
someInts.Should().BeEquivalentTo(2, 1); // This works

IEnumerable<SomeClass> actual = new List<SomeClass>
{
new SomeClass{SomeInt = 1},
new SomeClass{SomeInt = 2}
};

// This does work
actual.ShouldBeEquivalentTo(new List<SomeClass>{
new SomeClass { SomeInt = 1 },
new SomeClass { SomeInt = 2 }
});

// The following is in reverse order, just like someOtherInts above.
// This doesn't work, but should?
actual.ShouldBeEquivalentTo(new List<SomeClass>
{
new SomeClass{SomeInt = 2},
new SomeClass{SomeInt = 1}
});
// This is similar to BeEquivalentTo(2, 1) above, but doesn't work.
// It's even in the correct order.
actual.Should().BeEquivalentTo(
new SomeClass { SomeInt = 1 },
new SomeClass { SomeInt = 2 }
);

}
}
}
```
Comments: Additionally, you could allow the "Equal" method on a collection to have a 2nd parameter for a compare expression/function. That would be useful as well.

Commented Issue: Inconsistent ShouldBeEquivalentTo() behaviour for collections of complex types [12484]

tommck — Thu, 23 May 2013 18:07:52 GMT

I'm having trouble comparing lists of objects that come back in an indeterminate order. I thought `ShouldBeEquivalentTo()` would take care of this for me, but it doesn't seem to :(
Check out the comments in following sample class for a more thorough description.
```
using System.Collections.Generic;
using FluentAssertions;
using NUnit.Framework;

namespace CrazyMo.Tests
{
[TestFixture]
public class ShouldBeEquivalentToTests
{
public class SomeClass
{
public int SomeInt { get; set; }
}
[Test]
public void DoSomethingAwesome_Scenario_ExpectedResult()
{
SomeClass some1 = new SomeClass { SomeInt = 1 };
SomeClass someOther1 = new SomeClass { SomeInt = 1 };
some1.ShouldBeEquivalentTo(someOther1); // This works

IEnumerable<int> someInts = new List<int> {1, 2};
IEnumerable<int> someOtherInts = new List<int> {2, 1};
someInts.Should().BeEquivalentTo(someOtherInts); // This works
someInts.Should().BeEquivalentTo(2, 1); // This works

IEnumerable<SomeClass> actual = new List<SomeClass>
{
new SomeClass{SomeInt = 1},
new SomeClass{SomeInt = 2}
};

// This does work
actual.ShouldBeEquivalentTo(new List<SomeClass>{
new SomeClass { SomeInt = 1 },
new SomeClass { SomeInt = 2 }
});

// The following is in reverse order, just like someOtherInts above.
// This doesn't work, but should?
actual.ShouldBeEquivalentTo(new List<SomeClass>
{
new SomeClass{SomeInt = 2},
new SomeClass{SomeInt = 1}
});
// This is similar to BeEquivalentTo(2, 1) above, but doesn't work.
// It's even in the correct order.
actual.Should().BeEquivalentTo(
new SomeClass { SomeInt = 1 },
new SomeClass { SomeInt = 2 }
);

}
}
}
```
Comments: You could also look for the standard "IComparable" or "IComparable<T>" interface implementations and, if so, you could then use those to determine sorting order. Also, you can use the above or IEquatable<T> to determine things that are equal.

Created Unassigned: CollectionAssertions.Equal does not handle null properly [12490]

tommck — Thu, 23 May 2013 13:56:15 GMT

Commented Unassigned: XElement.Should().Match() [12489]

dennisdoomen — Thu, 09 May 2013 05:04:19 GMT

Because there are a lot more things to test than just both attributes and elements.
Currently I use something like this:
``` C#
XElement.As<XNode>().Should().Match<XElement>(x => x.Name == "foo")
```
Comments: Sounds like a good idea.

Created Unassigned: XElement.Should().Match() [12489]

felixdd — Wed, 08 May 2013 21:33:46 GMT

Because there are a lot more things to test than just both attributes and elements.
Currently I use something like this:
``` C#
XElement.As<XNode>().Should().Match<XElement>(x => x.Name == "foo")
```

Created Unassigned: string.Should().NotBeNullOrWhitespace(); [12488]

denzilla — Tue, 07 May 2013 08:07:09 GMT

Can a method for NullOrWhitespace be added to String assertions please? A NullOrEmpty already exists, but not one for whitespace.

Cheers

Commented Issue: Windows phone throwing non descript exceptions [12470]

waten — Tue, 16 Apr 2013 10:23:19 GMT

Given the following code.

[TestMethod]
public void InitialiseSession()
{
false.Should().BeTrue();
}

Results in :
New exception: "Could not find windows phone test framework.".

I'm using the latest test framework from toolkit (https://nuget.org/packages/WPToolkitTestFx)

Expected results: "True excepted ... "

Comments: Late reply but I was referring to the new MSTest-based unit test framework brought in with the VS2012 Update 2.

Created Unassigned: NullReferenceException caused by AttributeBasedFormatter on Mono 3.0.6 [12487]

StreamWriter — Fri, 05 Apr 2013 20:00:14 GMT

```
(true).Should().BeFalse();
```

results in

```
System.NullReferenceException : Object reference not set to an instance of an object

at FluentAssertions.Formatting.AttributeBasedFormatter.<FindCustomFormatters>b__4 (System.Type type) [0x00000] in <filename unknown>:0
at System.Linq.Enumerable+<CreateSelectManyIterator>c__Iterator29`3[System.Type,System.Reflection.MethodInfo,<>f__AnonymousType0`2[System.Type,System.Reflection.MethodInfo]].MoveNext () [0x00059] in /private/tmp/source/bockbuild/profiles/mono-mac-release/build-root/mono-3.0.6/_build/mono-3.0.6.git/mcs/class/System.Core/System.Linq/Enumerable.cs:2335
```

Obviously, AttributeBasedFormatter.GetExportedTypes(Assembly) sometimes returns an array that contains null references in Mono, because a ReflectionTypeLoadException is thrown whose Types property contains some null values.

We can easily fix that in AttributeBaseFormatter.FindCustomFormatters():

```
IEnumerable<MethodInfo> source =
from type in AttributeBasedFormatter.AllTypes
where type != null // FIX
from method in type.GetMethods(24)
where method.get_IsStatic()
where method.HasAttribute<ValueFormatterAttribute>()
where method.GetParameters().Count<ParameterInfo>() == 1
select method;
return source.ToArray<MethodInfo>();
```

Created Issue: Misleading AllDeclaredPublicPropertiesSelectionRule class [12486]

toyners — Thu, 04 Apr 2013 09:33:48 GMT

I would expect this class to provide a list of public properties only. However under the hood, in the SelectProperties method, it is calling GetNonPrivateProperties which can return protected, internal & public properties.

Edited Issue: WP8: Extend ShouldThrow() to Func [12485]

dennisdoomen — Wed, 03 Apr 2013 18:38:11 GMT

As fixed for the issue below in WinRT:

http://fluentassertions.codeplex.com/workitem/12148

It would be really useful to be fixed as well for Windows Phone 8. Most of the functionality is also async, so testing must be adpated accordingly.

Thank you very much!

Created Issue: WP8: Extend ShouldThrow() to Func [12485]

masantiago — Wed, 03 Apr 2013 08:59:11 GMT

Edited Issue: DateTimeOffset support [12464]

mopdam — Tue, 02 Apr 2013 18:02:46 GMT

It would be great if FA supported DateTimeOffset in the same way it supported DateTime.

Commented Issue: Inconsistent ShouldBeEquivalentTo() behaviour for collections of complex types [12484]

dennisdoomen — Mon, 01 Apr 2013 17:46:26 GMT

I'm having trouble comparing lists of objects that come back in an indeterminate order. I thought `ShouldBeEquivalentTo()` would take care of this for me, but it doesn't seem to :(
Check out the comments in following sample class for a more thorough description.
```
using System.Collections.Generic;
using FluentAssertions;
using NUnit.Framework;

namespace CrazyMo.Tests
{
[TestFixture]
public class ShouldBeEquivalentToTests
{
public class SomeClass
{
public int SomeInt { get; set; }
}
[Test]
public void DoSomethingAwesome_Scenario_ExpectedResult()
{
SomeClass some1 = new SomeClass { SomeInt = 1 };
SomeClass someOther1 = new SomeClass { SomeInt = 1 };
some1.ShouldBeEquivalentTo(someOther1); // This works

IEnumerable<int> someInts = new List<int> {1, 2};
IEnumerable<int> someOtherInts = new List<int> {2, 1};
someInts.Should().BeEquivalentTo(someOtherInts); // This works
someInts.Should().BeEquivalentTo(2, 1); // This works

IEnumerable<SomeClass> actual = new List<SomeClass>
{
new SomeClass{SomeInt = 1},
new SomeClass{SomeInt = 2}
};

// This does work
actual.ShouldBeEquivalentTo(new List<SomeClass>{
new SomeClass { SomeInt = 1 },
new SomeClass { SomeInt = 2 }
});

// The following is in reverse order, just like someOtherInts above.
// This doesn't work, but should?
actual.ShouldBeEquivalentTo(new List<SomeClass>
{
new SomeClass{SomeInt = 2},
new SomeClass{SomeInt = 1}
});
// This is similar to BeEquivalentTo(2, 1) above, but doesn't work.
// It's even in the correct order.
actual.Should().BeEquivalentTo(
new SomeClass { SomeInt = 1 },
new SomeClass { SomeInt = 2 }
);

}
}
}
```
Comments: I'm going to ignore the order of items in collections by default starting with 2.1.0.

Edited Issue: Inconsistent ShouldBeEquivalentTo() behaviour for collections of complex types [12484]

dennisdoomen — Mon, 01 Apr 2013 17:46:26 GMT

Edited Feature: String comparison with 'ignore whitespace' [12423]

dennisdoomen — Mon, 01 Apr 2013 17:44:47 GMT

The "Should().BeEquivalentTo()" ignores casing, but it would be great to have an option for ignoring whitespace and tab/carriage return/newline characters as well

Closed Issue: FluentAssertions 2.0: objects, which are inherited from collections, are always compared as collections even that a comparison only by specified properties was requested. [12471]

dennisdoomen — Mon, 01 Apr 2013 17:42:15 GMT

In our project we have classes inherited from collections. These classes have own properties and we should compare their instances only by specified properties and ignore data in collections. But the Fluent Assertion's object comparer always compares objects as collections first.

Is this a bug? If not then how to compare similar objects only by specified properties?

Code to test the specified problem.

using System;
using System.Collections.Generic;
using FluentAssertions;
using NUnit.Framework;

namespace FluentAssertionsTests
{
[TestFixture]
public class Tests
{
public class TestCollection : List<int>
{
public TestCollection()
{
Uid = Guid.NewGuid();
}

public int CollectionId { get; set; }

public Guid Uid { get; set; }
}

[Test]
public void DifferentCollectionsObjectGraphComparisonTest()
{
var actual = new TestCollection {CollectionId = 1};
actual.Add(1);
var expected = new TestCollection {CollectionId = 1};
expected.Add(2);
// this test failed with "Expected item[0] to be 2, but found 1."
actual.ShouldBeEquivalentTo(expected, options => options.Including(p => p.CollectionId));
}

[Test]
public void ObjectGraphComparisonTest()
{
var actual = new TestCollection {CollectionId = 1};
var expected = new TestCollection {CollectionId = 1};
// this test success
actual.ShouldBeEquivalentTo(expected, options => options.Including(p => p.CollectionId));

actual.Uid.Should().NotBe(expected.Uid);
// this test success but should be failed because objects has a different Uid
actual.ShouldBeEquivalentTo(expected, options => options.Including(p => p.Uid));
// this test success but should be failed because objects has a different Uid
actual.ShouldBeEquivalentTo(expected);
}

[Test]
public void DifferentCollectionsPropertyComparisonTest()
{
var actual = new TestCollection {CollectionId = 1};
actual.Add(1);
var expected = new TestCollection {CollectionId = 1};
expected.Add(2);
// this test failed with "Expected item[0] to be 2, but found 1."
actual.ShouldHave().Properties(p => p.CollectionId).EqualTo(expected);
}

[Test]
public void ObjectPropertyComparisonTest()
{
var actual = new TestCollection {CollectionId = 1};
var expected = new TestCollection {CollectionId = 1};
// this test success
actual.ShouldHave().Properties(p => p.CollectionId).EqualTo(expected);

actual.Uid.Should().NotBe(expected.Uid);
// this test success but should be failed because objects has a different Uid
actual.ShouldHave().Properties(p => p.Uid).EqualTo(expected);
// this test success but should be failed because objects has a different Uid
actual.ShouldHave().AllProperties().EqualTo(expected);
}
}
}
Comments: Behavior is by design.

Commented Issue: FluentAssertions 2.0: objects, which are inherited from collections, are always compared as collections even that a comparison only by specified properties was requested. [12471]

dennisdoomen — Mon, 01 Apr 2013 17:42:04 GMT