C# NUnit子序列断言

NUnit有各种各样的方法来使用和相互测试集合。但我看不到一种方法来测试一个

IEnumerable

是否是另一个的子序列，即它是元素顺序与超集相同的子集

是我忽略了什么，还是我需要自己去实现

编辑：这是我心目中的测试

[TestCase(new[] { 1, 3, 5 }, new[] { 1, 2, 3, 4, 5, 6 })] // PASS
[TestCase(new[] { 1, 3, 5 }, new[] { 1, 3, 5 })] // PASS
[TestCase(new[] { 1, 3, 5 }, new[] { 1, 3, 3, 5 })] // PASS
[TestCase(new[] { 1, 3, 5 }, new[] { 1, 2, 4, 5 })] // FAIL
[TestCase(new[] { 1, 3, 5 }, new[] { 1, 5, 3 })] // FAIL
[TestCase(new[] { 1, 3, 5 }, new[] { 1, 5, 3, 5 })] // PASS
public void TestSubsequnce(IEnumerable<int> subsequence, IEnumerable<int> supersequence)
{
    AssertSubsequence(subsequence, supersequence, Comparer<int>.Default);
}

[TestCase（新[]{1,3,5}，新[]{1,2,3,4,5,6}）]//通过
[TestCase（新[]{1,3,5}，新[]{1,3,5}）]//通过
[TestCase（新[]{1,3,5}，新[]{1,3,3,5}）]//通过
[TestCase（新[]{1,3,5}，新[]{1,2,4,5}）]//失败
[TestCase（新[]{1,3,5}，新[]{1,5,3}）]//失败
[TestCase（新[]{1,3,5}，新[]{1,5,3,5}）]//通过
公共无效测试子序列（IEnumerable subsequence，IEnumerable superssequence）
{
AssertSubsequence（subsequence、superssequence、Comparer.Default）；
}

对于最坏情况下的

O（n log（n））

，这并不是最有效的算法，但下面介绍了如何做到这一点

[TestCase(new[] { 1, 3, 5 }, new[] { 1, 2, 3, 4, 5, 6 })]   // PASS
[TestCase(new[] { 1, 3, 5 }, new[] { 1, 3, 5 })]            // PASS
[TestCase(new[] { 1, 3, 5 }, new[] { 1, 3, 3, 5 })]         // PASS
[TestCase(new[] { 1, 3, 5 }, new[] { 1, 2, 4, 5 })]         // FAIL
[TestCase(new[] { 1, 3, 5 }, new[] { 1, 5, 3 })]            // FAIL
[TestCase(new[] { 1, 3, 5 }, new[] { 1, 5, 3, 5 })]         // PASS
public void TestSubsequnce(IEnumerable<int> subsequence, IEnumerable<int> supersequence)
{
    AssertSubsequenceWithGaps(subsequence, supersequence);
}

public static void AssertSubsequenceWithGaps(IEnumerable<int> subsequence, IEnumerable<int> supersequence)
{
    // iterating multiple times, cast sequences to List
    var listSub = subsequence.ToList();
    var listSuper = supersequence.ToList();

    int expected = listSub.Count;
    int innerPointer = 0;
    int actual = 0;
    for (int i = 0; i < listSub.Count; i++)
    {
        for ( /* start from where we left before */; innerPointer < listSuper.Count; innerPointer++)
        {
            var valueSub = listSub[i];
            var valueSuper = listSuper[innerPointer];
            if (valueSub == valueSuper)
            {
                actual++;
                break;
            }
        }
    }

    Assert.AreEqual(expected, actual);
}

[TestCase（新[]{1,3,5}，新[]{1,2,3,4,5,6}）]//通过
[TestCase（新[]{1,3,5}，新[]{1,3,5}）]//通过
[TestCase（新[]{1,3,5}，新[]{1,3,3,5}）]//通过
[TestCase（新[]{1,3,5}，新[]{1,2,4,5}）]//失败
[TestCase（新[]{1,3,5}，新[]{1,5,3}）]//失败
[TestCase（新[]{1,3,5}，新[]{1,5,3,5}）]//通过
公共无效测试子序列（IEnumerable subsequence，IEnumerable superssequence）
{
资产子序列间隙（子序列、超序列）；
}
公共静态无效资产SubSequenceWithGaps（IEnumerable subsequence，IEnumerable supersequence）
{
//多次迭代，将序列强制转换为列表
var listSub=subsequence.ToList（）；
var listSuper=supersequence.ToList（）；
int expected=listSub.Count；
int innerPointer=0；
int实际值=0；
for（int i=0；i

由于似乎没有现成的解决方案，下面是我在此期间提出的解决方案

private static void AssertSubsequence<T>(IEnumerable<T> subsequence, IEnumerable<T> superSequence, IComparer<T> comparer)
{
    var superEnumerator = superSequence.GetEnumerator();

    foreach (var subElement in subsequence)
    {
        if (!superEnumerator.MoveNext())
        {
            Assert.Fail("Expected a subsequence, but there is no match for {0} from the proposed subsequence.", subElement);
        }

        while (comparer.Compare(subElement, superEnumerator.Current) != 0)
        {
            if (!superEnumerator.MoveNext())
            {
                Assert.Fail("Expected a subsequence, but there is no match for {0} from the proposed subsequence", subElement);
            }
        }
    }
}

private static void AssertSubsequence（IEnumerable subsequence、IEnumerable superssequence、IComparer comparer comparer）
{
var superEnumerator=superSequence.GetEnumerator（）；
foreach（子序列中的var子元素）
{
如果（！superEnumerator.MoveNext（））
{
Assert.Fail（“应为子序列，但建议的子序列中的{0}不匹配。”，子元素）；
}
while（comparer.Compare（子元素，superEnumerator.Current）！=0）
{
如果（！superEnumerator.MoveNext（））
{
Assert.Fail（“应为子序列，但建议的子序列中的{0}不匹配”，子元素）；
}
}
}
}

即使在LINQ中也没有类似的方法。。。最近的事情是<代码>字符串。包含（如果你考虑一个<代码>字符串< /代码>是一个数组：<代码> char < /Calp> s）@ Orksii。