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;
6 using System.Collections.Generic;
7 using System.Linq;
8 using System.Text;
9 using System.Threading.Tasks;
10 using Xunit;
11 
12 namespace System.Linq.Tests
13 {
14     public class RepeatTests : EnumerableTests
15     {
16         [Fact]
Repeat_ProduceCorrectSequence()17         public void Repeat_ProduceCorrectSequence()
18         {
19             var repeatSequence = Enumerable.Repeat(1, 100);
20             int count = 0;
21             foreach (var val in repeatSequence)
22             {
23                 count++;
24                 Assert.Equal(1, val);
25             }
26 
27             Assert.Equal(100, count);
28         }
29 
30         [Fact]
Repeat_ToArray_ProduceCorrectResult()31         public void Repeat_ToArray_ProduceCorrectResult()
32         {
33             var array = Enumerable.Repeat(1, 100).ToArray();
34             Assert.Equal(array.Length, 100);
35             for (var i = 0; i < array.Length; i++)
36                 Assert.Equal(1, array[i]);
37         }
38 
39         [Fact]
Repeat_ToList_ProduceCorrectResult()40         public void Repeat_ToList_ProduceCorrectResult()
41         {
42             var list = Enumerable.Repeat(1, 100).ToList();
43             Assert.Equal(list.Count, 100);
44             for (var i = 0; i < list.Count; i++)
45                 Assert.Equal(1, list[i]);
46         }
47 
48         [Fact]
Repeat_ProduceSameObject()49         public void Repeat_ProduceSameObject()
50         {
51             object objectInstance = new object();
52             var array = Enumerable.Repeat(objectInstance, 100).ToArray();
53             Assert.Equal(array.Length, 100);
54             for (var i = 0; i < array.Length; i++)
55                 Assert.Same(objectInstance, array[i]);
56         }
57 
58         [Fact]
Repeat_WorkWithNullElement()59         public void Repeat_WorkWithNullElement()
60         {
61             object objectInstance = null;
62             var array = Enumerable.Repeat(objectInstance, 100).ToArray();
63             Assert.Equal(array.Length, 100);
64             for (var i = 0; i < array.Length; i++)
65                 Assert.Null(array[i]);
66         }
67 
68 
69         [Fact]
Repeat_ZeroCountLeadToEmptySequence()70         public void Repeat_ZeroCountLeadToEmptySequence()
71         {
72             var array = Enumerable.Repeat(1, 0).ToArray();
73             Assert.Equal(array.Length, 0);
74         }
75 
76         [Fact]
Repeat_ThrowExceptionOnNegativeCount()77         public void Repeat_ThrowExceptionOnNegativeCount()
78         {
79             AssertExtensions.Throws<ArgumentOutOfRangeException>("count", () => Enumerable.Repeat(1, -1));
80         }
81 
82 
83         [Fact]
Repeat_NotEnumerateAfterEnd()84         public void Repeat_NotEnumerateAfterEnd()
85         {
86             using (var repeatEnum = Enumerable.Repeat(1, 1).GetEnumerator())
87             {
88                 Assert.True(repeatEnum.MoveNext());
89                 Assert.False(repeatEnum.MoveNext());
90                 Assert.False(repeatEnum.MoveNext());
91             }
92         }
93 
94         [Fact]
Repeat_EnumerableAndEnumeratorAreSame()95         public void Repeat_EnumerableAndEnumeratorAreSame()
96         {
97             var repeatEnumerable = Enumerable.Repeat(1, 1);
98             using (var repeatEnumerator = repeatEnumerable.GetEnumerator())
99             {
100                 Assert.Same(repeatEnumerable, repeatEnumerator);
101             }
102         }
103 
104         [Fact]
Repeat_GetEnumeratorReturnUniqueInstances()105         public void Repeat_GetEnumeratorReturnUniqueInstances()
106         {
107             var repeatEnumerable = Enumerable.Repeat(1, 1);
108             using (var enum1 = repeatEnumerable.GetEnumerator())
109             using (var enum2 = repeatEnumerable.GetEnumerator())
110             {
111                 Assert.NotSame(enum1, enum2);
112             }
113         }
114 
115         [Fact]
SameResultsRepeatCallsIntQuery()116         public void SameResultsRepeatCallsIntQuery()
117         {
118             Assert.Equal(Enumerable.Repeat(-3, 0), Enumerable.Repeat(-3, 0));
119         }
120 
121         [Fact]
SameResultsRepeatCallsStringQuery()122         public void SameResultsRepeatCallsStringQuery()
123         {
124             Assert.Equal(Enumerable.Repeat("SSS", 99), Enumerable.Repeat("SSS", 99));
125         }
126 
127         [Fact]
CountOneSingleResult()128         public void CountOneSingleResult()
129         {
130             int[] expected = { -15 };
131 
132             Assert.Equal(expected, Enumerable.Repeat(-15, 1));
133         }
134 
135         [Fact]
RepeatArbitraryCorrectResults()136         public void RepeatArbitraryCorrectResults()
137         {
138             int[] expected = { 12, 12, 12, 12, 12, 12, 12, 12 };
139 
140             Assert.Equal(expected, Enumerable.Repeat(12, 8));
141         }
142 
143         [Fact]
RepeatNull()144         public void RepeatNull()
145         {
146             int?[] expected = { null, null, null, null };
147 
148             Assert.Equal(expected, Enumerable.Repeat((int?)null, 4));
149         }
150 
151         [Fact]
Take()152         public void Take()
153         {
154             Assert.Equal(Enumerable.Repeat(12, 8), Enumerable.Repeat(12, 12).Take(8));
155         }
156 
157         [Fact]
TakeExcessive()158         public void TakeExcessive()
159         {
160             Assert.Equal(Enumerable.Repeat("", 4), Enumerable.Repeat("", 4).Take(22));
161         }
162 
163         [Fact]
Skip()164         public void Skip()
165         {
166             Assert.Equal(Enumerable.Repeat(12, 8), Enumerable.Repeat(12, 12).Skip(4));
167         }
168 
169         [Fact]
SkipExcessive()170         public void SkipExcessive()
171         {
172             Assert.Empty(Enumerable.Repeat(12, 8).Skip(22));
173         }
174 
175         [Fact]
TakeCanOnlyBeOne()176         public void TakeCanOnlyBeOne()
177         {
178             Assert.Equal(new[] { 1 }, Enumerable.Repeat(1, 10).Take(1));
179             Assert.Equal(new[] { 1 }, Enumerable.Repeat(1, 10).Skip(1).Take(1));
180             Assert.Equal(new[] { 1 }, Enumerable.Repeat(1, 10).Take(3).Skip(2));
181             Assert.Equal(new[] { 1 }, Enumerable.Repeat(1, 10).Take(3).Take(1));
182         }
183 
184         [Fact]
SkipNone()185         public void SkipNone()
186         {
187             Assert.Equal(Enumerable.Repeat(12, 8), Enumerable.Repeat(12, 8).Skip(0));
188         }
189 
190         [Fact]
First()191         public void First()
192         {
193             Assert.Equal("Test", Enumerable.Repeat("Test", 42).First());
194         }
195 
196         [Fact]
FirstOrDefault()197         public void FirstOrDefault()
198         {
199             Assert.Equal("Test", Enumerable.Repeat("Test", 42).FirstOrDefault());
200         }
201 
202         [Fact]
Last()203         public void Last()
204         {
205             Assert.Equal("Test", Enumerable.Repeat("Test", 42).Last());
206         }
207 
208         [Fact]
LastOrDefault()209         public void LastOrDefault()
210         {
211             Assert.Equal("Test", Enumerable.Repeat("Test", 42).LastOrDefault());
212         }
213 
214         [Fact]
ElementAt()215         public void ElementAt()
216         {
217             Assert.Equal("Test", Enumerable.Repeat("Test", 42).ElementAt(13));
218         }
219 
220         [Fact]
ElementAtOrDefault()221         public void ElementAtOrDefault()
222         {
223             Assert.Equal("Test", Enumerable.Repeat("Test", 42).ElementAtOrDefault(13));
224         }
225 
226         [Fact]
ElementAtExcessive()227         public void ElementAtExcessive()
228         {
229             AssertExtensions.Throws<ArgumentOutOfRangeException>("index", () => Enumerable.Repeat(3, 3).ElementAt(100));
230         }
231 
232         [Fact]
ElementAtOrDefaultExcessive()233         public void ElementAtOrDefaultExcessive()
234         {
235             Assert.Equal(0, Enumerable.Repeat(3, 3).ElementAtOrDefault(100));
236         }
237 
238         [Fact]
Count()239         public void Count()
240         {
241             Assert.Equal(42, Enumerable.Repeat("Test", 42).Count());
242         }
243     }
244 }
245