我试图断言一个对象与另一个对象“相等”。
对象只是具有大量公共属性的类的实例。有没有一种简单的方法让NUnit基于属性断言相等？
这是我目前的解决方案，但我认为可能有更好的方法：
Assert.AreEqual(LeftObject.Property1, RightObject.Property1)
Assert.AreEqual(LeftObject.Property2, RightObject.Property2)
Assert.AreEqual(LeftObject.Property3, RightObject.Property3)
...
Assert.AreEqual(LeftObject.PropertyN, RightObject.PropertyN)
我想要的是与CollectionEquivalentConstraint一样的精神，其中NUnit验证两个集合的内容是否相同。
答案 0 :(得分：114)
如果由于任何原因无法覆盖Equals，则可以构建一个辅助方法，通过反射迭代公共属性并断言每个属性。像这样：
public static class AssertEx
{
public static void PropertyValuesAreEquals(object actual, object expected)
{
PropertyInfo[] properties = expected.GetType().GetProperties();
foreach (PropertyInfo property in properties)
{
object expectedValue = property.GetValue(expected, null);
object actualValue = property.GetValue(actual, null);
if (actualValue is IList)
AssertListsAreEquals(property, (IList)actualValue, (IList)expectedValue);
else if (!Equals(expectedValue, actualValue))
Assert.Fail("Property {0}.{1} does not match. Expected: {2} but was: {3}", property.DeclaringType.Name, property.Name, expectedValue, actualValue);
}
}
private static void AssertListsAreEquals(PropertyInfo property, IList actualList, IList expectedList)
{
if (actualList.Count != expectedList.Count)
Assert.Fail("Property {0}.{1} does not match. Expected IList containing {2} elements but was IList containing {3} elements", property.PropertyType.Name, property.Name, expectedList.Count, actualList.Count);
for (int i = 0; i < actualList.Count; i++)
if (!Equals(actualList[i], expectedList[i]))
Assert.Fail("Property {0}.{1} does not match. Expected IList with element {1} equals to {2} but was IList with element {1} equals to {3}", property.PropertyType.Name, property.Name, expectedList[i], actualList[i]);
}
}
答案 1 :(得分：99)
请勿仅为测试目的而重写等于。这很乏味并影响域逻辑。 取而代之的是，
您的对象没有其他逻辑。没有额外的测试任务。
只需使用这个简单的方法：
public static void AreEqualByJson(object expected, object actual)
{
var serializer = new System.Web.Script.Serialization.JavaScriptSerializer();
var expectedJson = serializer.Serialize(expected);
var actualJson = serializer.Serialize(actual);
Assert.AreEqual(expectedJson, actualJson);
}
似乎效果很好。测试运行结果信息将显示包含的JSON字符串比较（对象图），因此您可以直接看到错误。
还要注意！如果您有更大的复杂对象并且只想比较它们的一部分，您可以（使用LINQ作为序列数据）创建要与上面一起使用的匿名对象方法
public void SomeTest()
{
var expect = new { PropA = 12, PropB = 14 };
var sut = loc.Resolve<SomeSvc>();
var bigObjectResult = sut.Execute(); // This will return a big object with loads of properties
AssExt.AreEqualByJson(expect, new { bigObjectResult.PropA, bigObjectResult.PropB });
}
答案 2 :(得分：81)
尝试使用FluentAssertions库：
dto.ShouldHave(). AllProperties().EqualTo(customer);
http://www.fluentassertions.com/
也可以使用NuGet进行安装。
答案 3 :(得分：47)
覆盖对象的.Equals，然后在单元测试中，您可以简单地执行此操作：
Assert.AreEqual(LeftObject, RightObject);
当然，这可能意味着您只需将所有单独的比较移动到.Equals方法，但它允许您将该实现重用于多个测试，并且可能有必要让对象应该能够与兄弟姐妹无论如何。
答案 4 :(得分：34)
我不想仅仅为了启用测试而重写Equals。不要忘记，如果你确实覆盖了Equals，你也应该覆盖GetHashCode，或者如果你在字典中使用你的对象，你可能会得到意想不到的结果。
我喜欢上面的反思方法，因为它适合将来添加属性。
对于一个快速而简单的解决方案，但是通常最简单的方法是创建一个帮助方法来测试对象是否相等，或者在一个类上实现IEqualityComparer，这个类对您的测试保密。使用IEqualityComparer解决方案时，您不需要为GetHashCode的实现而烦恼。例如：
// Sample class. This would be in your main assembly.
class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
// Unit tests
[TestFixture]
public class PersonTests
{
private class PersonComparer : IEqualityComparer<Person>
{
public bool Equals(Person x, Person y)
{
if (x == null && y == null)
{
return true;
}
if (x == null || y == null)
{
return false;
}
return (x.Name == y.Name) && (x.Age == y.Age);
}
public int GetHashCode(Person obj)
{
throw new NotImplementedException();
}
}
[Test]
public void Test_PersonComparer()
{
Person p1 = new Person { Name = "Tom", Age = 20 }; // Control data
Person p2 = new Person { Name = "Tom", Age = 20 }; // Same as control
Person p3 = new Person { Name = "Tom", Age = 30 }; // Different age
Person p4 = new Person { Name = "Bob", Age = 20 }; // Different name.
Assert.IsTrue(new PersonComparer().Equals(p1, p2), "People have same values");
Assert.IsFalse(new PersonComparer().Equals(p1, p3), "People have different ages.");
Assert.IsFalse(new PersonComparer().Equals(p1, p4), "People have different names.");
}
}
答案 5 :(得分：13)
我尝试过这里提到的几种方法。大多数涉及序列化对象和进行字符串比较。虽然超级简单且通常非常有效，但我发现当您遇到故障并且报告此类内容时会出现短暂的错误：
Expected string length 2326 but was 2342. Strings differ at index 1729.
找出差异所在的位置至少可以说是痛苦。
使用FluentAssertions＆＃39; object graph comparisons（即a.ShouldBeEquivalentTo(b)），你得到了回复：
Expected property Name to be "Foo" but found "Bar"
那更好。 Get FluentAssertions现在，您以后会感到高兴（如果您赞成这一点，请另请注意dkl's answer首次建议使用FluentAssertions。
答案 6 :(得分：9)
我同意ChrisYoxall - 在主要代码中实现Equals仅仅是为了测试目的并不好。
如果你正在实现Equals，因为某些应用程序逻辑需要它，那么这很好，但是保持纯粹的测试代码不会混淆东西（同样检查相同的测试语义可能与你的应用程序需要的不同）
简而言之，请保持仅限测试的代码。
对于大多数类，使用反射的属性的简单浅层比较应该足够了，尽管如果对象具有复杂属性，则可能需要递归。如果参考，请注意循环引用或类似内容。
狡猾
答案 7 :(得分：4)
Property constraints允许一个比OP原始解决方案更具可读性的解决方案，它可以产生更好的失败消息。它不是通用的，但如果你不需要为太多的课程做这件事，那么这是一个非常合适的解决方案。
Assert.That(ActualObject, Has.Property("Prop1").EqualTo(ExpectedObject.Prop1)
& Has.Property("Prop2").EqualTo(ExpectedObject.Prop2)
& Has.Property("Prop3").EqualTo(ExpectedObject.Prop3)
// ...
不像实现Equals那样具有通用性，但确实提供了比
Assert.AreEqual(ExpectedObject, ActualObject);
答案 8 :(得分：3)
Max Wikstrom的JSON解决方案（上图）对我来说最有意义，它简短，干净，最重要的是它有效。就个人而言，我更喜欢将JSON转换实现为一个单独的方法，并将断言放回到单元测试中，就像这样......
帮助方法：
public string GetObjectAsJson(object obj)
{
System.Web.Script.Serialization.JavaScriptSerializer oSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
return oSerializer.Serialize(obj);
}
UNIT TEST：
public void GetDimensionsFromImageTest()
{
Image Image = new Bitmap(10, 10);
ImageHelpers_Accessor.ImageDimensions expected = new ImageHelpers_Accessor.ImageDimensions(10,10);
ImageHelpers_Accessor.ImageDimensions actual;
actual = ImageHelpers_Accessor.GetDimensionsFromImage(Image);
/*USING IT HERE >>>*/
Assert.AreEqual(GetObjectAsJson(expected), GetObjectAsJson(actual));
}
仅供参考 - 您可能需要在解决方案中添加对System.Web.Extensions的引用。
答案 9 :(得分：1)
https://github.com/kbilsted/StatePrinter专门用于将对象图转储为字符串表示，目的是编写简单的单元测试。
鉴于
class A
{
public DateTime X;
public DateTime Y { get; set; }
public string Name;
}
您可以以类型安全的方式，并使用visual studio的自动完成包含或排除字段。
var printer = new Stateprinter();
printer.Configuration.Projectionharvester().Exclude<A>(x => x.X, x => x.Y);
var sut = new A { X = DateTime.Now, Name = "Charly" };
var expected = @"new A(){ Name = ""Charly""}";
printer.Assert.PrintIsSame(expected, sut);
答案 10 :(得分：1)
这是一个非常古老的主题，但我想知道为什么没有提出答案的原因NUnit.Framework.Is.EqualTo和NUnit.Framework.Is.NotEqualTo？
如：
Assert.That(LeftObject, Is.EqualTo(RightObject));
和
Assert.That(LeftObject, Is.Not.EqualTo(RightObject));
答案 11 :(得分：1)
查看以下链接。它是代码项目的解决方案，我也使用过它。它可以很好地比较对象。
http://www.codeproject.com/Articles/22709/Testing-Equality-of-Two-Objects?msg=5189539#xx5189539xx
答案 12 :(得分：1)
只需从Nuget安装ExpectedObjects，就可以轻松比较两个对象的属性值，集合的每个对象值，两个组合对象的值以及匿名类型的部分比较属性值。
我在github上有一些例子：https://github.com/hatelove/CompareObjectEquals
以下是一些包含比较对象场景的示例：
{
setCookie("userName", form.nameBox.value);
return true;
}
参考：
答案 13 :(得分：1)
我会以@Juanma的答案为基础。但是，我认为这不应该用单元测试断言来实现。这是一个非常适合在某些情况下可以通过非测试代码使用的实用程序。
我写了一篇关于此事的文章http://timoch.com/blog/2013/06/unit-test-equality-is-not-domain-equality/
我的建议如下：
/// <summary>
/// Returns the names of the properties that are not equal on a and b.
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns>An array of names of properties with distinct
/// values or null if a and b are null or not of the same type
/// </returns>
public static string[] GetDistinctProperties(object a, object b) {
if (object.ReferenceEquals(a, b))
return null;
if (a == null)
return null;
if (b == null)
return null;
var aType = a.GetType();
var bType = b.GetType();
if (aType != bType)
return null;
var props = aType.GetProperties();
if (props.Any(prop => prop.GetIndexParameters().Length != 0))
throw new ArgumentException("Types with index properties not supported");
return props
.Where(prop => !Equals(prop.GetValue(a, null), prop.GetValue(b, null)))
.Select(prop => prop.Name).ToArray();
}
将此与NUnit一起使用
Expect(ReflectionUtils.GetDistinctProperties(tile, got), Empty);
在不匹配时产生以下消息。
Expected: <empty>
But was: < "MagmaLevel" >
at NUnit.Framework.Assert.That(Object actual, IResolveConstraint expression, String message, Object[] args)
at Undermine.Engine.Tests.TileMaps.BasicTileMapTests.BasicOperations() in BasicTileMapTests.cs: line 29
答案 14 :(得分：1)
另一个选择是通过实现NUnit abstract Constraint类来编写自定义约束。使用辅助类来提供一点语法糖，所得到的测试代码是令人愉快的简洁和可读的，例如
Assert.That( LeftObject, PortfolioState.Matches( RightObject ) );
举一个极端的例子，考虑具有“只读”的课程。成员，不是IEquatable，即使您想要，也无法更改受测试的课程：
public class Portfolio // Somewhat daft class for pedagogic purposes...
{
// Cannot be instanitated externally, instead has two 'factory' methods
private Portfolio(){ }
// Immutable properties
public string Property1 { get; private set; }
public string Property2 { get; private set; } // Cannot be accessed externally
public string Property3 { get; private set; } // Cannot be accessed externally
// 'Factory' method 1
public static Portfolio GetPortfolio(string p1, string p2, string p3)
{
return new Portfolio()
{
Property1 = p1,
Property2 = p2,
Property3 = p3
};
}
// 'Factory' method 2
public static Portfolio GetDefault()
{
return new Portfolio()
{
Property1 = "{{NONE}}",
Property2 = "{{NONE}}",
Property3 = "{{NONE}}"
};
}
}
Constraint课程的合同要求我们覆盖Matches和WriteDescriptionTo（如果出现不匹配的情况，则会覆盖预期值），但也会覆盖WriteActualValueTo （实际价值的叙述）是有道理的：
public class PortfolioEqualityConstraint : Constraint
{
Portfolio expected;
string expectedMessage = "";
string actualMessage = "";
public PortfolioEqualityConstraint(Portfolio expected)
{
this.expected = expected;
}
public override bool Matches(object actual)
{
if ( actual == null && expected == null ) return true;
if ( !(actual is Portfolio) )
{
expectedMessage = "<Portfolio>";
actualMessage = "null";
return false;
}
return Matches((Portfolio)actual);
}
private bool Matches(Portfolio actual)
{
if ( expected == null && actual != null )
{
expectedMessage = "null";
expectedMessage = "non-null";
return false;
}
if ( ReferenceEquals(expected, actual) ) return true;
if ( !( expected.Property1.Equals(actual.Property1)
&& expected.Property2.Equals(actual.Property2)
&& expected.Property3.Equals(actual.Property3) ) )
{
expectedMessage = expected.ToStringForTest();
actualMessage = actual.ToStringForTest();
return false;
}
return true;
}
public override void WriteDescriptionTo(MessageWriter writer)
{
writer.WriteExpectedValue(expectedMessage);
}
public override void WriteActualValueTo(MessageWriter writer)
{
writer.WriteExpectedValue(actualMessage);
}
}
加上助手类：
public static class PortfolioState
{
public static PortfolioEqualityConstraint Matches(Portfolio expected)
{
return new PortfolioEqualityConstraint(expected);
}
public static string ToStringForTest(this Portfolio source)
{
return String.Format("Property1 = {0}, Property2 = {1}, Property3 = {2}.",
source.Property1, source.Property2, source.Property3 );
}
}
使用示例：
[TestFixture]
class PortfolioTests
{
[Test]
public void TestPortfolioEquality()
{
Portfolio LeftObject
= Portfolio.GetDefault();
Portfolio RightObject
= Portfolio.GetPortfolio("{{GNOME}}", "{{NONE}}", "{{NONE}}");
Assert.That( LeftObject, PortfolioState.Matches( RightObject ) );
}
}
答案 15 :(得分：0)
反序列化这两个类，并进行字符串比较。
修改 效果很好，这是我从NUnit获得的输出;
Test 'Telecom.SDP.SBO.App.Customer.Translator.UnitTests.TranslateEaiCustomerToDomain_Tests.TranslateNew_GivenEaiCustomer_ShouldTranslateToDomainCustomer_Test("ApprovedRatingInDb")' failed:
Expected string length 2841 but was 5034. Strings differ at index 443.
Expected: "...taClasses" />\r\n <ContactMedia />\r\n <Party i:nil="true" /..."
But was: "...taClasses" />\r\n <ContactMedia>\r\n <ContactMedium z:Id="..."
----------------------------------------------^
TranslateEaiCustomerToDomain_Tests.cs(201,0): at Telecom.SDP.SBO.App.Customer.Translator.UnitTests.TranslateEaiCustomerToDomain_Tests.Assert_CustomersAreEqual(Customer expectedCustomer, Customer actualCustomer)
TranslateEaiCustomerToDomain_Tests.cs(114,0): at Telecom.SDP.SBO.App.Customer.Translator.UnitTests.TranslateEaiCustomerToDomain_Tests.TranslateNew_GivenEaiCustomer_ShouldTranslateToDomainCustomer_Test(String custRatingScenario)
编辑二： 这两个对象可以相同，但属性序列化的顺序不同。因此XML是不同的。 DOH！
编辑三： 这确实有效。我在测试中使用它。但是，您必须按照测试代码添加项目的顺序将项目添加到集合属性中。
答案 16 :(得分：0)
对两个字符串进行字符串化和比较
Assert.AreEqual（JSON.stringify（LeftObject），JSON.stringify（RightObject））
答案 17 :(得分：0)
我结束了写一个简单的表达工厂：
public static class AllFieldsEqualityComprision<T>
{
public static Comparison<T> Instance { get; } = GetInstance();
private static Comparison<T> GetInstance()
{
var type = typeof(T);
ParameterExpression[] parameters =
{
Expression.Parameter(type, "x"),
Expression.Parameter(type, "y")
};
var result = type.GetProperties().Aggregate<PropertyInfo, Expression>(
Expression.Constant(true),
(acc, prop) =>
Expression.And(acc,
Expression.Equal(
Expression.Property(parameters[0], prop.Name),
Expression.Property(parameters[1], prop.Name))));
var areEqualExpression = Expression.Condition(result, Expression.Constant(0), Expression.Constant(1));
return Expression.Lambda<Comparison<T>>(areEqualExpression, parameters).Compile();
}
}
并使用它：
Assert.That(
expectedCollection,
Is.EqualTo(actualCollection)
.Using(AllFieldsEqualityComprision<BusinessCategoryResponse>.Instance));
这非常有用，因为我必须比较这些对象的集合。你可以在其他地方使用这个比较：）
以下是示例：https://gist.github.com/Pzixel/b63fea074864892f9aba8ffde312094f
答案 18 :(得分：0)
我知道这是一个非常老的问题，但是NUnit仍然对此没有本地支持。但是，如果您喜欢BDD风格的测试（ala Jasmine），您会对NExpect（https://github.com/fluffynuts/NExpect，从NuGet获得它）感到惊讶，它已经在其中进行了深度相等性测试。
（免责声明：我是NExpect的作者）
答案 19 :(得分：-1)
@php
$armas = old('st_arma');
@endphp
@if(!empty($armas) && count($armas) > 0)
@foreach($armas as $key => $arma)
<div class="columns armas" id="remover_arma_{{$key}}">
<label class="div1 label" for="st_tipo">Arma:</label>
<input type="input" name="st_arma[]" id="st_arma" value="{{$arma}}">
</div>
@endforeach
@endif