Skip to content

Commit d12a525

Browse files
aalmadaaalmada
authored
Add Lease<> type (#380)
* Add Lease<> type * Check for disposed object in GetEnumerator() * Fix Length * Fix Reset() * Add AsEnumerable() and AsValueEnumerable() * Fix unit tests
1 parent c3fa93a commit d12a525

File tree

76 files changed

+463
-268
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

76 files changed

+463
-268
lines changed

‎NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/LargeArrayBuilder.Tests.cs‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -43,15 +43,17 @@ public void ToArray_MemoryPool_Must_Succeed(int count)
4343
var expected = Enumerable
4444
.Range(0, count)
4545
.ToArray();
46-
using var builder = new LargeArrayBuilder<int>(ArrayPool<int>.Shared, false);
46+
// ReSharper disable once ConvertToUsingDeclaration
47+
using var builder = new LargeArrayBuilder<int>(pool, false);
4748
for (var index = 0; index < count; index++)
4849
builder.Add(expected[index]);
4950

5051
// Act
5152
using var result = builder.ToArray(pool, false);
5253

5354
// Assert
54-
_ = result.Memory.Must()
55+
_ = result.Must()
56+
.BeEnumerableOf<int>()
5557
.BeEqualTo(expected);
5658
}
5759
}

‎NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArray.ReadOnlyList.Tests.cs‎

Lines changed: 19 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -51,14 +51,16 @@ public void ToArray_MemoryPool_Must_Succeed(int[] source, int skip, int take)
5151
.ToArray();
5252

5353
// Act
54+
// ReSharper disable once ConvertToUsingDeclaration
5455
using var result = wrapped.AsValueEnumerable()
5556
.Skip(skip)
5657
.Take(take)
5758
.ToArray(pool);
5859

5960
// Assert
60-
_ = result.Memory
61-
.SequenceEqual(expected);
61+
_ = result.Must()
62+
.BeEnumerableOf<int>()
63+
.BeEqualTo(expected);
6264
}
6365

6466
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -116,8 +118,9 @@ public void ToArray_Predicate_MemoryPool_Must_Succeed(int[] source, int skip, in
116118
.ToArray(pool);
117119

118120
// Assert
119-
_ = result.Memory
120-
.SequenceEqual(expected);
121+
_ = result.Must()
122+
.BeEnumerableOf<int>()
123+
.BeEqualTo(expected);
121124
}
122125

123126
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -175,8 +178,9 @@ public void ToArray_PredicateAt_MemoryPool_Must_Succeed(int[] source, int skip,
175178
.ToArray(pool);
176179

177180
// Assert
178-
_ = result.Memory
179-
.SequenceEqual(expected);
181+
_ = result.Must()
182+
.BeEnumerableOf<int>()
183+
.BeEqualTo(expected);
180184
}
181185

182186
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -233,8 +237,9 @@ public void ToArray_Selector_MemoryPool_Must_Succeed(int[] source, int skip, int
233237
.ToArray(pool);
234238

235239
// Assert
236-
_ = result.Memory
237-
.SequenceEqual(expected);
240+
_ = result.Must()
241+
.BeEnumerableOf<string>()
242+
.BeEqualTo(expected);
238243
}
239244

240245
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -291,8 +296,9 @@ public void ToArray_SelectorAt_MemoryPool_Must_Succeed(int[] source, int skip, i
291296
.ToArray(pool);
292297

293298
// Assert
294-
_ = result.Memory
295-
.SequenceEqual(expected);
299+
_ = result.Must()
300+
.BeEnumerableOf<string>()
301+
.BeEqualTo(expected);
296302
}
297303

298304
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -353,8 +359,9 @@ public void ToArray_Predicate_Selector_MemoryPool_Must_Succeed(int[] source, int
353359
.ToArray(pool);
354360

355361
// Assert
356-
_ = result.Memory
357-
.SequenceEqual(expected);
362+
_ = result.Must()
363+
.BeEnumerableOf<string>()
364+
.BeEqualTo(expected);
358365
}
359366
}
360367
}

‎NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArray.ReadOnlySpan.Tests.cs‎

Lines changed: 12 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,8 @@ public void ToArray_MemoryPool_Must_Succeed(int[] source)
2626
.ToArray(pool);
2727

2828
// Assert
29-
_ = result.Memory.Must()
29+
_ = result.Must()
30+
.BeEnumerableOf<int>()
3031
.BeEqualTo(expected);
3132
}
3233

@@ -77,7 +78,8 @@ public void ToArray_Predicate_MemoryPool_Must_Succeed(int[] source, Func<int, bo
7778
.ToArray(pool);
7879

7980
// Assert
80-
_ = result.Memory.Must()
81+
_ = result.Must()
82+
.BeEnumerableOf<int>()
8183
.BeEqualTo(expected);
8284
}
8385

@@ -128,7 +130,8 @@ public void ToArray_PredicateAt_MemoryPool_Must_Succeed(int[] source, Func<int,
128130
.ToArray(pool);
129131

130132
// Assert
131-
_ = result.Memory.Must()
133+
_ = result.Must()
134+
.BeEnumerableOf<int>()
132135
.BeEqualTo(expected);
133136
}
134137

@@ -178,7 +181,8 @@ public void ToArray_Selector_MemoryPool_Must_Succeed(int[] source, Func<int, str
178181
.ToArray(pool);
179182

180183
// Assert
181-
_ = result.Memory.Must()
184+
_ = result.Must()
185+
.BeEnumerableOf<string>()
182186
.BeEqualTo(expected);
183187
}
184188

@@ -228,7 +232,8 @@ public void ToArray_SelectorAt_MemoryPool_Must_Succeed(int[] source, Func<int, i
228232
.ToArray(pool);
229233

230234
// Assert
231-
_ = result.Memory.Must()
235+
_ = result.Must()
236+
.BeEnumerableOf<string>()
232237
.BeEqualTo(expected);
233238
}
234239

@@ -282,7 +287,8 @@ public void ToArray_Predicate_Selector_MemoryPool_Must_Succeed(int[] source, Fun
282287
.ToArray(pool);
283288

284289
// Assert
285-
_ = result.Memory.Must()
290+
_ = result.Must()
291+
.BeEnumerableOf<string>()
286292
.BeEqualTo(expected);
287293
}
288294
}

‎NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArray.ValueEnumerable.Tests.cs‎

Lines changed: 18 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -70,8 +70,9 @@ public void ToArray_MemoryPool_Must_Succeed(int[] source)
7070
.ToArray<Wrap.ValueEnumerableWrapper<int>, Wrap.Enumerator<int>, int>(pool);
7171

7272
// Assert
73-
_ = result.Memory
74-
.SequenceEqual(expected);
73+
_ = result.Must()
74+
.BeEnumerableOf<int>()
75+
.BeEqualTo(expected);
7576
}
7677

7778
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -120,8 +121,9 @@ public void ToArray_Predicate_MemoryPool_Must_Succeed(int[] source, Func<int, bo
120121
.ToArray(pool);
121122

122123
// Assert
123-
_ = result.Memory
124-
.SequenceEqual(expected);
124+
_ = result.Must()
125+
.BeEnumerableOf<int>()
126+
.BeEqualTo(expected);
125127
}
126128

127129
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -170,8 +172,9 @@ public void ToArray_PredicateAt_MemoryPool_With_ValidData_Must_Succeed(int[] sou
170172
.ToArray(pool);
171173

172174
// Assert
173-
_ = result.Memory
174-
.SequenceEqual(expected);
175+
_ = result.Must()
176+
.BeEnumerableOf<int>()
177+
.BeEqualTo(expected);
175178
}
176179

177180
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -220,8 +223,9 @@ public void ToArray_Selector_MemoryPool_With_ValidData_Must_Succeed(int[] source
220223
.ToArray(pool);
221224

222225
// Assert
223-
_ = result.Memory
224-
.SequenceEqual(expected);
226+
_ = result.Must()
227+
.BeEnumerableOf<string>()
228+
.BeEqualTo(expected);
225229
}
226230

227231
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -270,8 +274,9 @@ public void ToArray_SelectorAt_MemoryPool_With_ValidData_Must_Succeed(int[] sour
270274
.ToArray(pool);
271275

272276
// Assert
273-
_ = result.Memory
274-
.SequenceEqual(expected);
277+
_ = result.Must()
278+
.BeEnumerableOf<string>()
279+
.BeEqualTo(expected);
275280
}
276281

277282
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -324,8 +329,9 @@ public void ToArray_Predicate_Selector_MemoryPool_With_ValidData_Must_Succeed(in
324329
.ToArray(pool);
325330

326331
// Assert
327-
_ = result.Memory
328-
.SequenceEqual(expected);
332+
_ = result.Must()
333+
.BeEnumerableOf<string>()
334+
.BeEqualTo(expected);
329335
}
330336
}
331337
}

‎NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArray.ValueReadOnlyCollection.Tests.cs‎

Lines changed: 9 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -70,8 +70,9 @@ public void ToArray_MemoryPool_Must_Succeed(int[] source)
7070
.ToArray(pool);
7171

7272
// Assert
73-
_ = result.Memory
74-
.SequenceEqual(expected);
73+
_ = result.Must()
74+
.BeEnumerableOf<int>()
75+
.BeEqualTo(expected);
7576
}
7677

7778
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -120,8 +121,9 @@ public void ToArray_Predicate_MemoryPool_With_ValidData_Must_Succeed(int[] sourc
120121
.ToArray(pool);
121122

122123
// Assert
123-
_ = result.Memory
124-
.SequenceEqual(expected);
124+
_ = result.Must()
125+
.BeEnumerableOf<string>()
126+
.BeEqualTo(expected);
125127
}
126128

127129
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -170,8 +172,9 @@ public void ToArray_SelectorAt_MemoryPool_With_ValidData_Must_Succeed(int[] sour
170172
.ToArray(pool);
171173

172174
// Assert
173-
_ = result.Memory
174-
.SequenceEqual(expected);
175+
_ = result.Must()
176+
.BeEnumerableOf<string>()
177+
.BeEqualTo(expected);
175178
}
176179

177180
}

‎NetFabric.Hyperlinq.UnitTests/Conversion/ToArray/ToArrayAsync.AsyncValueEnumerable.Tests.cs‎

Lines changed: 18 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -51,8 +51,9 @@ public async ValueTask ToArrayAsync_MemoryPool_Must_Succeed(int[] source)
5151
.ConfigureAwait(false);
5252

5353
// Assert
54-
_ = result.Memory
55-
.SequenceEqual(expected);
54+
_ = result.Must()
55+
.BeEnumerableOf<int>()
56+
.BeEqualTo(expected);
5657
}
5758

5859
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -103,8 +104,9 @@ public async ValueTask ToArrayAsync_Predicate_MemoryPool_Must_Succeed(int[] sour
103104
.ConfigureAwait(false);
104105

105106
// Assert
106-
_ = result.Memory
107-
.SequenceEqual(expected);
107+
_ = result.Must()
108+
.BeEnumerableOf<int>()
109+
.BeEqualTo(expected);
108110
}
109111

110112
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -155,8 +157,9 @@ public async ValueTask ToArrayAsync_PredicateAt_MemoryPool_Must_Succeed(int[] so
155157
.ConfigureAwait(false);
156158

157159
// Assert
158-
_ = result.Memory
159-
.SequenceEqual(expected);
160+
_ = result.Must()
161+
.BeEnumerableOf<int>()
162+
.BeEqualTo(expected);
160163
}
161164

162165
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -207,8 +210,9 @@ public async ValueTask ToArrayAsync_Selector_MemoryPool_Must_Succeed(int[] sourc
207210
.ConfigureAwait(false);
208211

209212
// Assert
210-
_ = result.Memory
211-
.SequenceEqual(expected);
213+
_ = result.Must()
214+
.BeEnumerableOf<string>()
215+
.BeEqualTo(expected);
212216
}
213217

214218
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -259,8 +263,9 @@ public async ValueTask ToArrayAsync_SelectorAt_MemoryPool_Must_Succeed(int[] sou
259263
.ConfigureAwait(false);
260264

261265
// Assert
262-
_ = result.Memory
263-
.SequenceEqual(expected);
266+
_ = result.Must()
267+
.BeEnumerableOf<string>()
268+
.BeEqualTo(expected);
264269
}
265270

266271
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -316,8 +321,9 @@ public async ValueTask ToArrayAsync_Predicate_Selector_MemoryPool_Must_Succeed(i
316321
.ConfigureAwait(false);
317322

318323
// Assert
319-
_ = result.Memory
320-
.SequenceEqual(expected);
324+
_ = result.Must()
325+
.BeEnumerableOf<string>()
326+
.BeEqualTo(expected);
321327
}
322328
}
323329
}

‎NetFabric.Hyperlinq.UnitTests/Set/Distinct/Distinct.ReadOnlySpan.Tests.cs‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,8 @@ public void Distinct_ToArray_MemoryPool_With_ValidData_Must_Succeed(int[] source
6868
.ToArray(ArrayPool<int>.Shared);
6969

7070
// Assert
71-
_ = result.Memory.Must()
71+
_ = result.Must()
72+
.BeEnumerableOf<int>()
7273
.BeEqualTo(expected);
7374
}
7475

‎NetFabric.Hyperlinq.UnitTests/Set/Distinct/Distinct.ValueEnumerable.Tests.cs‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -70,8 +70,9 @@ public void Distinct_ToArray_MemoryPool_With_ValidData_Must_Succeed(int[] source
7070
.ToArray(pool);
7171

7272
// Assert
73-
_ = result.Memory
74-
.SequenceEqual(expected);
73+
_ = result.Must()
74+
.BeEnumerableOf<int>()
75+
.BeEqualTo(expected);
7576
}
7677

7778
[Theory]

‎NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'1.AsyncEnumerable.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,7 @@ public ValueTask<TSource[]> ToArrayAsync()
6868
=> this.ToArrayAsync<AsyncValueEnumerable<TSource>, AsyncEnumerator, TSource>();
6969

7070
[MethodImpl(MethodImplOptions.AggressiveInlining)]
71-
public ValueTask<IMemoryOwner<TSource>> ToArrayAsync(ArrayPool<TSource> pool, CancellationToken cancellationToken = default, bool clearOnDispose = default)
71+
public ValueTask<Lease<TSource>> ToArrayAsync(ArrayPool<TSource> pool, CancellationToken cancellationToken = default, bool clearOnDispose = default)
7272
=> this.ToArrayAsync<AsyncValueEnumerable<TSource>, AsyncEnumerator, TSource>(pool, cancellationToken, clearOnDispose);
7373

7474
[MethodImpl(MethodImplOptions.AggressiveInlining)]

‎NetFabric.Hyperlinq/Conversion/AsAsyncValueEnumerable/AsAsyncValueEnumerable'6.AsyncEnumerable.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -83,7 +83,7 @@ public ValueTask<TSource[]> ToArrayAsync()
8383
=> this.ToArrayAsync<AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetAsyncEnumerator, TGetAsyncEnumerator2>, TEnumerator, TSource>();
8484

8585
[MethodImpl(MethodImplOptions.AggressiveInlining)]
86-
public ValueTask<IMemoryOwner<TSource>> ToArrayAsync(ArrayPool<TSource> pool, CancellationToken cancellationToken = default, bool clearOnDispose = default)
86+
public ValueTask<Lease<TSource>> ToArrayAsync(ArrayPool<TSource> pool, CancellationToken cancellationToken = default, bool clearOnDispose = default)
8787
=> this.ToArrayAsync<AsyncValueEnumerable<TEnumerable, TEnumerator, TEnumerator2, TSource, TGetAsyncEnumerator, TGetAsyncEnumerator2>, TEnumerator, TSource>(pool, cancellationToken, clearOnDispose);
8888

8989
[MethodImpl(MethodImplOptions.AggressiveInlining)]

0 commit comments

Comments
 (0)