IsSubset should return a better default AssertMessage

[LokiMidgard]

Description

The CollectionAssert.IsSubsetOf error message could have more information.

Currently it only says it failed. But what elements are missing is actually ommitted.

testfx/src/TestFramework/MSTest.Core/Assertions/CollectionAssert.cs

Lines 451 to 459 in 2166170

	public static void IsSubsetOf(ICollection subset, ICollection superset, string message, params object[] parameters)
	{
	Assert.CheckParameterNotNull(subset, "CollectionAssert.IsSubsetOf", "subset", string.Empty);
	Assert.CheckParameterNotNull(superset, "CollectionAssert.IsSubsetOf", "superset", string.Empty);
	if (!IsSubsetOfHelper(subset, superset))
	{
	Assert.HandleFail("CollectionAssert.IsSubsetOf", message, parameters);
	}
	}

The helper method seems to have the information but will not give that to the caller. (It takes a shourtcut on an error not searching for mor problems but even one element that is missing is an information for the tester)

testfx/src/TestFramework/MSTest.Core/Assertions/CollectionAssert.cs

Lines 1270 to 1306 in 2166170

	internal static bool IsSubsetOfHelper(ICollection subset, ICollection superset)
	{
	// $ CONSIDER: The current algorithm counts the number of occurrences of each
	// $ CONSIDER: element in each collection and then compares the count, resulting
	// $ CONSIDER: in an algorithm of ~n*log(n) + m*log(m) + n*log(m). It should be
	// $ CONSIDER: faster to sort both collections and do an element-by-element
	// $ CONSIDER: comparison, which should result in ~n*log(n) + m*log(m) + n.
	// Count the occurrences of each object in both collections.
	int subsetNulls;
	Dictionary<object, int> subsetElements = GetElementCounts(subset, out subsetNulls);
	int supersetNulls;
	Dictionary<object, int> supersetElements = GetElementCounts(superset, out supersetNulls);
	if (subsetNulls > supersetNulls)
	{
	return false;
	}
	// Compare the counts of each object in the subset to the count of that object
	// in the superset.
	foreach (object element in subsetElements.Keys)
	{
	int subsetCount;
	subsetElements.TryGetValue(element, out subsetCount);
	int supersetCount;
	supersetElements.TryGetValue(element, out supersetCount);
	if (subsetCount > supersetCount)
	{
	return false;
	}
	}
	// All the elements counts were OK.
	return true;
	}

Steps to reproduce

Write a Method that uses Assert.IsSubsetOf with an input that will fail

Expected behavior

Information what elements are missing in the collection.

Actual behavior

The Message only says something with the collection is wrong. CollectionAssert.IsSubsetOf failed.

Environment

• MSTest.TestAdapter (1.4.0)
• MSTest.TestFramework (1.4.0)

[jayaranigarg]

@LokiMidgard: Thank you for your feedback. This certainly makes sense. We will be happy to take contribution for the same if you would like to pick this up.

[LokiMidgard]

I'm not sure when I could get to this. This would propably be spontanius.

I have written an extension method for now to use in my project.

        public static void IsSubsetOf<T>(ICollection<T> subset, ICollection<T> superset, string? message)
        {
            var elementsLeft = subset.Except(superset).Select(x => $" * ({x})");
            var missingText = string.Join("\n", elementsLeft);

            if (missingText != string.Empty)
            {
                if (message is null)
                    HandleFail("\n"+missingText);
                else
                    HandleFail($"{message}\n{missingText}");
            }
        }

Compared with the method currently used the above propably has a problem with double values.

If I would implement this, I would tend to use the mechanic already present and write the output like this:

Assert Failed. x Elements were missing.
 [* Value1]
 [* Value2]
 [* Value3]
 [* More values were ommited.]
The collection contaed x elements.
 [* Value 1
 * Value 2
 * Value 3]

I would print up to 3 values that where not in the superset and all values for the superset if the collection does not contain more then 5.

I'm open for better suggestions.