1 // Licensed to the .NET Foundation under one or more agreements.
2 // The .NET Foundation licenses this file to you under the MIT license.
3 // See the LICENSE file in the project root for more information.
4 
5 using System.Collections.Generic;
6 using Xunit;
7 
8 namespace System.Collections.Tests
9 {
10     public class SortedSet_Generic_Tests_string : SortedSet_Generic_Tests<string>
11     {
CreateT(int seed)12         protected override string CreateT(int seed)
13         {
14             int stringLength = seed % 10 + 5;
15             Random rand = new Random(seed);
16             byte[] bytes = new byte[stringLength];
17             rand.NextBytes(bytes);
18             return Convert.ToBase64String(bytes);
19         }
20     }
21 
22     public class SortedSet_Generic_Tests_int : SortedSet_Generic_Tests<int>
23     {
CreateT(int seed)24         protected override int CreateT(int seed)
25         {
26             Random rand = new Random(seed);
27             return rand.Next();
28         }
29 
30         protected override bool DefaultValueAllowed => true;
31 
32         [Fact]
SortedSet_Generic_GetViewBetween_MinMax()33         public void SortedSet_Generic_GetViewBetween_MinMax()
34         {
35             var set = (SortedSet<int>)CreateSortedSet(new[] { 1, 3, 5, 7, 9 }, 5, 5);
36             SortedSet<int> view = set.GetViewBetween(4, 8);
37 
38             Assert.True(set.Contains(1));
39             Assert.True(set.Contains(3));
40             Assert.True(set.Contains(5));
41             Assert.True(set.Contains(7));
42             Assert.True(set.Contains(9));
43 
44             Assert.False(view.Contains(1));
45             Assert.False(view.Contains(3));
46             Assert.True(view.Contains(5));
47             Assert.True(view.Contains(7));
48             Assert.False(view.Contains(9));
49 
50             Assert.Equal(1, set.Min);
51             Assert.Equal(9, set.Max);
52 
53             Assert.Equal(5, view.Min);
54             Assert.Equal(7, view.Max);
55         }
56 
57         [Fact]
SortedSet_Generic_IntersectWith_SupersetEnumerableWithDups()58         public void SortedSet_Generic_IntersectWith_SupersetEnumerableWithDups()
59         {
60             var set = (SortedSet<int>)CreateSortedSet(new[] { 1, 3, 5, 7, 9 }, 5, 5);
61             set.IntersectWith(new[] { 5, 7, 3, 7, 11, 7, 5, 2 });
62 
63             Assert.Equal(new[] { 3, 5, 7 }, set);
64         }
65 
66         [Fact]
SortedSet_Generic_GetViewBetween_MinMax_Exhaustive()67         public void SortedSet_Generic_GetViewBetween_MinMax_Exhaustive()
68         {
69             var set = (SortedSet<int>)CreateSortedSet(new[] { 7, 11, 3, 1, 5, 9, 13 }, 7, 7);
70             for (int i = 0; i < 14; i++)
71             {
72                 for (int j = i; j < 14; j ++)
73                 {
74                     SortedSet<int> view = set.GetViewBetween(i, j);
75 
76                     if (j < i || (j == i && i % 2 == 0) )
77                     {
78                         Assert.Equal(default(int), view.Min);
79                         Assert.Equal(default(int), view.Max);
80                     }
81                     else
82                     {
83                         Assert.Equal(i + ((i+1) % 2), view.Min);
84                         Assert.Equal(j - ((j+1) % 2), view.Max);
85                     }
86                 }
87             }
88         }
89     }
90 
91     public class SortedSet_Generic_Tests_int_With_NullComparer : SortedSet_Generic_Tests_int
92     {
GetIComparer()93         protected override IComparer<int> GetIComparer() => null;
94     }
95 
96     [OuterLoop]
97     public class SortedSet_Generic_Tests_EquatableBackwardsOrder : SortedSet_Generic_Tests<EquatableBackwardsOrder>
98     {
CreateT(int seed)99         protected override EquatableBackwardsOrder CreateT(int seed)
100         {
101             Random rand = new Random(seed);
102             return new EquatableBackwardsOrder(rand.Next());
103         }
104 
GenericISetFactory()105         protected override ISet<EquatableBackwardsOrder> GenericISetFactory()
106         {
107             return new SortedSet<EquatableBackwardsOrder>();
108         }
109     }
110 
111     [OuterLoop]
112     public class SortedSet_Generic_Tests_int_With_Comparer_SameAsDefaultComparer : SortedSet_Generic_Tests<int>
113     {
GetIEqualityComparer()114         protected override IEqualityComparer<int> GetIEqualityComparer()
115         {
116             return new Comparer_SameAsDefaultComparer();
117         }
118 
GetIComparer()119         protected override IComparer<int> GetIComparer()
120         {
121             return new Comparer_SameAsDefaultComparer();
122         }
123 
CreateT(int seed)124         protected override int CreateT(int seed)
125         {
126             Random rand = new Random(seed);
127             return rand.Next();
128         }
129 
GenericISetFactory()130         protected override ISet<int> GenericISetFactory()
131         {
132             return new SortedSet<int>(new Comparer_SameAsDefaultComparer());
133         }
134     }
135 
136     [OuterLoop]
137     public class SortedSet_Generic_Tests_int_With_Comparer_HashCodeAlwaysReturnsZero : SortedSet_Generic_Tests<int>
138     {
GetIEqualityComparer()139         protected override IEqualityComparer<int> GetIEqualityComparer()
140         {
141             return new Comparer_HashCodeAlwaysReturnsZero();
142         }
143 
GetIComparer()144         protected override IComparer<int> GetIComparer()
145         {
146             return new Comparer_HashCodeAlwaysReturnsZero();
147         }
148 
CreateT(int seed)149         protected override int CreateT(int seed)
150         {
151             Random rand = new Random(seed);
152             return rand.Next();
153         }
154 
GenericISetFactory()155         protected override ISet<int> GenericISetFactory()
156         {
157             return new SortedSet<int>(new Comparer_HashCodeAlwaysReturnsZero());
158         }
159     }
160 
161     [OuterLoop]
162     public class SortedSet_Generic_Tests_int_With_Comparer_ModOfInt : SortedSet_Generic_Tests<int>
163     {
GetIEqualityComparer()164         protected override IEqualityComparer<int> GetIEqualityComparer()
165         {
166             return new Comparer_ModOfInt(15000);
167         }
168 
GetIComparer()169         protected override IComparer<int> GetIComparer()
170         {
171             return new Comparer_ModOfInt(15000);
172         }
173 
CreateT(int seed)174         protected override int CreateT(int seed)
175         {
176             Random rand = new Random(seed);
177             return rand.Next();
178         }
179 
GenericISetFactory()180         protected override ISet<int> GenericISetFactory()
181         {
182             return new SortedSet<int>(new Comparer_ModOfInt(15000));
183         }
184     }
185 
186     [OuterLoop]
187     public class SortedSet_Generic_Tests_int_With_Comparer_AbsOfInt : SortedSet_Generic_Tests<int>
188     {
GetIEqualityComparer()189         protected override IEqualityComparer<int> GetIEqualityComparer()
190         {
191             return new Comparer_AbsOfInt();
192         }
193 
GetIComparer()194         protected override IComparer<int> GetIComparer()
195         {
196             return new Comparer_AbsOfInt();
197         }
198 
CreateT(int seed)199         protected override int CreateT(int seed)
200         {
201             Random rand = new Random(seed);
202             return rand.Next();
203         }
204 
GenericISetFactory()205         protected override ISet<int> GenericISetFactory()
206         {
207             return new SortedSet<int>(new Comparer_AbsOfInt());
208         }
209     }
210 }
211