1
exercism fetch csharp sublist

SublistTest.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
using System.Collections.Generic;
using System.Linq;
using Xunit;

public class SublistTest
{
    [Fact]
    public void Empty_equals_empty()
    {
        var list1 = new List<int>();
        var list2 = new List<int>();
        Assert.Equal(SublistType.Equal, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Empty_is_a_sublist_of_anything()
    {
        var list1 = new List<int>();
        var list2 = new List<int> { 1, 2, 3, 4 };
        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Anything_is_a_superlist_of_empty()
    {
        var list1 = new List<int> { 1, 2, 3, 4 };
        var list2 = new List<int>();
        Assert.Equal(SublistType.Superlist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void One_is_not_two()
    {
        var list1 = new List<int> { 1 };
        var list2 = new List<int> { 2 };
        Assert.Equal(SublistType.Unequal, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Compare_larger_equal_lists()
    {
        var list1 = new List<char>(Enumerable.Repeat('x', 1000));
        var list2 = new List<char>(Enumerable.Repeat('x', 1000));
        Assert.Equal(SublistType.Equal, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Sublist_at_start()
    {
        var list1 = new List<int> { 1, 2, 3 };
        var list2 = new List<int> { 1, 2, 3, 4, 5 };
        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Sublist_in_middle()
    {
        var list1 = new List<int> { 4, 3, 2 };
        var list2 = new List<int> { 5, 4, 3, 2, 1 };
        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Sublist_at_end()
    {
        var list1 = new List<int> { 3, 4, 5 };
        var list2 = new List<int> { 1, 2, 3, 4, 5 };
        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Partially_matching_sublist_at_start()
    {
        var list1 = new List<int> { 1, 1, 2 };
        var list2 = new List<int> { 1, 1, 1, 2 };
        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Sublist_early_in_huge_list()
    {
        var list1 = new List<int> { 3, 4, 5 };
        var list2 = new List<int>(Enumerable.Range(1, 1000000));
        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Huge_sublist_not_in_huge_list()
    {
        var list1 = new List<int>(Enumerable.Range(10, 1000001));
        var list2 = new List<int>(Enumerable.Range(1, 1000000));
        Assert.Equal(SublistType.Unequal, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Superlist_at_start()
    {
        var list1 = new List<int> { 1, 2, 3, 4, 5 };
        var list2 = new List<int> { 1, 2, 3 };
        Assert.Equal(SublistType.Superlist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Superlist_in_middle()
    {
        var list1 = new List<int> { 5, 4, 3, 2, 1 };
        var list2 = new List<int> { 4, 3, 2 };
        Assert.Equal(SublistType.Superlist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Superlist_at_end()
    {
        var list1 = new List<int> { 1, 2, 3, 4, 5 };
        var list2 = new List<int> { 3, 4, 5 };
        Assert.Equal(SublistType.Superlist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Partially_matching_superlist_at_start()
    {
        var list1 = new List<int> { 1, 1, 1, 2 };
        var list2 = new List<int> { 1, 1, 2 };
        Assert.Equal(SublistType.Superlist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Superlist_early_in_huge_list()
    {
        var list1 = new List<int>(Enumerable.Range(1, 1000000));
        var list2 = new List<int> { 3, 4, 5 };
        Assert.Equal(SublistType.Superlist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Recurring_values_sublist()
    {
        var list1 = new List<int> { 1, 2, 1, 2, 3 };
        var list2 = new List<int> { 1, 2, 3, 1, 2, 1, 2, 3, 2, 1 };
        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
    }

    [Fact(Skip = "Remove to run test")]
    public void Recurring_values_unequal()
    {
        var list1 = new List<int> { 1, 2, 1, 2, 3 };
        var list2 = new List<int> { 1, 2, 3, 1, 2, 3, 2, 3, 2, 1 };
        Assert.Equal(SublistType.Unequal, Sublist.Classify(list1, list2));
    }
}