Is Assert.DoesNotContain(object, IEnumerable) supposed to call the GetEnumerator of items in collection?

[AristurtleDev]

I'm hitting this weird issue with using Assert.DoesNotContain and I'm not sure if it's because my expectation is wrong or if something weird is happening. I made a dotnet fiddle to show the thing that is happening. You can find it at https://dotnetfiddle.net/wdGwBz

I'll do my best to explain what's going on here.

Let's say I have class DataField. DataField contains an internal list of Subfield elements and implements IEnumerable so the consumer can iterate the collection of Subfield elements

public class DataField : IEnumerable
{
	private List<Subfield> _subfields = new();
	
	public string Tag { get; }
	public char Indicator1 { get; }
	public char Indicator2 { get; }
	
	public DataField(string tag, char indicator1, char indicator2, List<Subfield> subfields) =>
		(Tag, Indicator1, Indicator2, _subfields) = (tag, indicator1, indicator2, subfields);
		
	public IEnumerator GetEnumerator() => _subfields.GetEnumerator();
	
	//	Explicit override of ToString
	public override string ToString()
	{
		StringBuilder builder = new();
		builder.Append(Tag).Append(" ");
		builder.Append(Indicator1).Append(" ");
		builder.Append(Indicator2).Append(" ");
		builder.AppendJoin(' ', _subfields);
		return builder.ToString();
	}
	
	//	Expclit override of Equals using ToString() value to check for equality
	public override bool Equals(object? obj)
	{
		if(obj is DataField other)
		{
			return this.ToString() == other.ToString();
		}
		
		return false;
	}
	
	public override int GetHashCode() => this.ToString().GetHashCode();
}

The Subfield class is rather simple and looks like this

public class Subfield
{
	public char Code { get; }
	public string Value { get; }
	
	public Subfield(char code, string value) => (Code, Value) = (code, value);
	
	public override string ToString() => $"{Code}| {Value}";
}

So I make two instances of Datafield like so

List<Subfield> subfields = new();
subfields.Add(new('a', "Test"));
DataField field001 = new("001", '1', '2', subfields);
DataField field999 = new("999", '1', '2', subfields);

Then, i add only field001 to a collection

List<DataField> actual = new() { field001 };

Now I want to Assert that the collection does not contain field999

Assert.DoesNotContain<DataField>(field999, actual);

My expectation is that this would pass. However, it is not passing at all. Instead, what is happen is the DataField.GetEnumerator() is being called for each DataField element in actual, casted as an Array that contains the ToString of the Subfield elements that were returned in the GetEnumerator, as well as GetEnumerator being called on the field001 instance. This causes the list to actually contain field999 because they both contain the same Subfield instance even though they have completely different other properties.

You can see this in the output in the console

Unhandled exception. Xunit.Sdk.DoesNotContainException: Assert.DoesNotContain() Failure
Found:    DataField [a| Test]
In value: List<DataField> [[a| Test]]

The List<DataField> in the output above contains an [a| Test] array.

My question is, is the called to GetEnumerator supposed to happen and I'm just doing the wrong thing here? Or is this a bug and I'm not crazy?

[AristurtleDev]

Looks like an issue (Issue #2612 )was opened for this because of my confusion, but I'll mention that the response on twitter suggested using IEquatable<T> to resolve this for now.

https://twitter.com/xunit/status/1586419335207464961