A game about forced loneliness, made by TACStudios
tacstudios.tngl.sh
1using NUnit.Framework;
2using System;
3using System.Collections;
4using System.Collections.Generic;
5using Unity.Burst;
6using Unity.Collections;
7using Unity.Collections.Tests;
8using Unity.Collections.LowLevel.Unsafe;
9using Unity.Jobs;
10using Unity.Mathematics;
11
12//------------------------------------------------------------------------------
13// <auto-generated>
14// This code was generated by a tool.
15//
16// TextTransform Packages/com.unity.collections/Unity.Collections.Tests/NativeSortTests.tt
17//
18// Changes to this file may cause incorrect behavior and will be lost if
19// the code is regenerated.
20// </auto-generated>
21//------------------------------------------------------------------------------
22
23[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortExtension.DefaultComparer<int>>))]
24[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortExtension.DefaultComparer<int>>.SegmentSort))]
25[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortExtension.DefaultComparer<int>>.SegmentSortMerge))]
26[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.DescendingComparer<int>>))]
27[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.DescendingComparer<int>>.SegmentSort))]
28[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.DescendingComparer<int>>.SegmentSortMerge))]
29
30[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.BrokenComparer0<int>>))]
31[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.BrokenComparer0<int>>.SegmentSort))]
32[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.BrokenComparer0<int>>.SegmentSortMerge))]
33[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.BrokenComparer1<int>>))]
34[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.BrokenComparer1<int>>.SegmentSort))]
35[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.BrokenComparer1<int>>.SegmentSortMerge))]
36[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.BrokenComparer2<int>>))]
37[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.BrokenComparer2<int>>.SegmentSort))]
38[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.BrokenComparer2<int>>.SegmentSortMerge))]
39[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.BrokenComparer3<int>>))]
40[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.BrokenComparer3<int>>.SegmentSort))]
41[assembly: RegisterGenericJobType(typeof(SortJob<int, NativeSortTests.BrokenComparer3<int>>.SegmentSortMerge))]
42
43internal class NativeSortTests : CollectionsTestCommonBase
44{
45 internal struct DescendingComparer<T> : IComparer<T> where T : IComparable<T>
46 {
47 public int Compare(T x, T y) => y.CompareTo(x);
48 }
49
50 internal struct BrokenComparer0<T> : IComparer<T> where T : IComparable<T>
51 {
52 public int Compare(T x, T y)
53 {
54 int result = y.CompareTo(x);
55 return result < 0 ? -1 : 1;
56 }
57 }
58
59 internal struct BrokenComparer1<T> : IComparer<T> where T : IComparable<T>
60 {
61 public int Compare(T x, T y)
62 {
63 int result = y.CompareTo(x);
64 return result > 0 ? 1 : -1;
65 }
66 }
67
68 internal struct BrokenComparer2<T> : IComparer<T> where T : IComparable<T>
69 {
70 public int Compare(T x, T y)
71 {
72 int result = y.CompareTo(x);
73 return math.max(0, result);
74 }
75 }
76
77 internal struct BrokenComparer3<T> : IComparer<T> where T : IComparable<T>
78 {
79 public int Compare(T x, T y)
80 {
81 int result = y.CompareTo(x);
82 return math.min(0, result);
83 }
84 }
85
86 [Test]
87 public void NativeArraySlice_BinarySearch()
88 {
89 var init = new int[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53 };
90 var container = new NativeArray<int>(16, Allocator.Persistent);
91 var slice = new NativeSlice<int>(container, 0, container.Length);
92 var arrayRo = container.AsReadOnly();
93 container.CopyFrom(init);
94
95 for (int i = 0, num = container.Length; i < num; ++i)
96 {
97 Assert.AreEqual(i, container.BinarySearch(container[i]));
98 Assert.AreEqual(i, slice.BinarySearch(container[i]));
99 Assert.AreEqual(i, arrayRo.BinarySearch(container[i]));
100 }
101
102 container.Dispose();
103 }
104
105 struct BinarySearch_Job : IJob
106 {
107 [ReadOnly]
108 public NativeArray<int> array;
109
110 [ReadOnly]
111 public NativeSlice<int> slice;
112
113 [ReadOnly]
114 public NativeArray<int>.ReadOnly arrayRo;
115
116 [ReadOnly]
117 public NativeList<int> nativeList;
118
119 public void Execute()
120 {
121 for (int i = 0, num = array.Length; i < num; ++i)
122 {
123 Assert.AreEqual(i, array.BinarySearch(array[i]));
124 Assert.AreEqual(i, slice.BinarySearch(array[i]));
125 Assert.AreEqual(i, arrayRo.BinarySearch(array[i]));
126 Assert.AreEqual(i, nativeList.BinarySearch(array[i]));
127 }
128 }
129 }
130
131 [Test]
132 public void BinarySearch_From_Job()
133 {
134 var init = new int[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53 };
135 var container = new NativeArray<int>(16, Allocator.Persistent);
136 var slice = new NativeSlice<int>(container, 0, container.Length);
137 var arrayRo = container.AsReadOnly();
138 container.CopyFrom(init);
139
140 var nativeList = new NativeList<int>(16, Allocator.Persistent);
141 nativeList.CopyFrom(container);
142
143 new BinarySearch_Job
144 {
145 array = container,
146 slice = slice,
147 arrayRo = arrayRo,
148 nativeList = nativeList,
149
150 }.Run();
151
152 container.Dispose();
153 nativeList.Dispose();
154 }
155
156 [Test]
157 public void NativeArraySlice_BinarySearch_NotFound()
158 {
159 {
160 var container = new NativeArray<int>(1, Allocator.Temp);
161 var slice = new NativeSlice<int>(container, 0, container.Length);
162 var arrayRo = container.AsReadOnly();
163
164 Assert.AreEqual(container.Length, 1);
165 Assert.AreEqual(-2, container.BinarySearch(1));
166 Assert.AreEqual(-2, slice.BinarySearch(1));
167 Assert.AreEqual(-2, arrayRo.BinarySearch(1));
168
169 slice[0] = 1;
170
171 Assert.AreEqual(0, container.BinarySearch(1));
172 Assert.AreEqual(0, slice.BinarySearch(1));
173 Assert.AreEqual(0, arrayRo.BinarySearch(1));
174
175 Assert.AreEqual(-1, container.BinarySearch(-2));
176 Assert.AreEqual(-1, slice.BinarySearch(-2));
177 Assert.AreEqual(-1, arrayRo.BinarySearch(-2));
178
179 Assert.AreEqual(-2, container.BinarySearch(2));
180 Assert.AreEqual(-2, slice.BinarySearch(2));
181 Assert.AreEqual(-2, arrayRo.BinarySearch(2));
182
183 container.Dispose();
184 }
185
186 {
187 var init = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
188 var container = new NativeArray<int>(16, Allocator.Temp);
189 var slice = new NativeSlice<int>(container, 0, container.Length);
190 var arrayRo = container.AsReadOnly();
191
192 container.CopyFrom(init);
193
194 for (int i = 0, num = container.Length; i < num; ++i)
195 {
196 Assert.AreEqual(~container.Length, container.BinarySearch(i + 16));
197 Assert.AreEqual(~slice.Length, slice.BinarySearch(i + 16));
198 Assert.AreEqual(~arrayRo.Length, arrayRo.BinarySearch(i + 16));
199 }
200
201 container.Dispose();
202 }
203
204 {
205 var init = new int[] { 0, 2, 4, 6, 8, 10, 12, 14 };
206 var container = new NativeArray<int>(8, Allocator.Temp);
207 var slice = new NativeSlice<int>(container, 0, container.Length);
208 var arrayRo = container.AsReadOnly();
209
210 container.CopyFrom(init);
211
212 for (int i = 0, num = container.Length; i < num; ++i)
213 {
214 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, container.BinarySearch(i * 2 + 1));
215 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, slice.BinarySearch(i * 2 + 1));
216 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, arrayRo.BinarySearch(i * 2 + 1));
217 }
218
219 container.Dispose();
220 }
221 }
222
223 [Test]
224 public void NativeArraySlice_BinarySearch_NotFound_Reference_ArrayList()
225 {
226 {
227 var reference = new ArrayList();
228 reference.Add(0);
229 var container = new NativeArray<int>(1, Allocator.Temp);
230 var slice = new NativeSlice<int>(container, 0, container.Length);
231 var arrayRo = container.AsReadOnly();
232
233 Assert.AreEqual(container.Length, 1);
234 Assert.AreEqual(-2, reference.BinarySearch(1));
235 Assert.AreEqual(-2, container.BinarySearch(1));
236 Assert.AreEqual(-2, slice.BinarySearch(1));
237 Assert.AreEqual(-2, arrayRo.BinarySearch(1));
238
239 reference[0] = 1;
240 slice[0] = 1;
241
242 Assert.AreEqual(0, reference.BinarySearch(1));
243 Assert.AreEqual(0, container.BinarySearch(1));
244 Assert.AreEqual(0, slice.BinarySearch(1));
245 Assert.AreEqual(0, arrayRo.BinarySearch(1));
246
247 Assert.AreEqual(-1, reference.BinarySearch(-2));
248 Assert.AreEqual(-1, container.BinarySearch(-2));
249 Assert.AreEqual(-1, slice.BinarySearch(-2));
250 Assert.AreEqual(-1, arrayRo.BinarySearch(-2));
251
252 Assert.AreEqual(-2, reference.BinarySearch(2));
253 Assert.AreEqual(-2, container.BinarySearch(2));
254 Assert.AreEqual(-2, slice.BinarySearch(2));
255 Assert.AreEqual(-2, arrayRo.BinarySearch(2));
256 }
257
258 {
259 var init = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
260 var container = new NativeArray<int>(16, Allocator.Temp);
261 var slice = new NativeSlice<int>(container, 0, container.Length);
262 var arrayRo = container.AsReadOnly();
263
264 container.CopyFrom(init);
265 var reference = new ArrayList(init);
266
267 for (int i = 0, num = container.Length; i < num; ++i)
268 {
269 Assert.AreEqual(~reference.Count, reference.BinarySearch(i + 16));
270 Assert.AreEqual(~container.Length, container.BinarySearch(i + 16));
271 Assert.AreEqual(~slice.Length, slice.BinarySearch(i + 16));
272 Assert.AreEqual(~arrayRo.Length, arrayRo.BinarySearch(i + 16));
273 }
274 }
275
276 {
277 var init = new int[] { 0, 2, 4, 6, 8, 10, 12, 14 };
278 var container = new NativeArray<int>(8, Allocator.Temp);
279 var slice = new NativeSlice<int>(container, 0, container.Length);
280 var arrayRo = container.AsReadOnly();
281
282 container.CopyFrom(init);
283 var reference = new ArrayList(init);
284
285 for (int i = 0, num = container.Length; i < num; ++i)
286 {
287 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, reference.BinarySearch(i * 2 + 1));
288 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, container.BinarySearch(i * 2 + 1));
289 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, slice.BinarySearch(i * 2 + 1));
290 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, arrayRo.BinarySearch(i * 2 + 1));
291 }
292 }
293 }
294
295
296
297 [Test]
298 public void NativeList_BinarySearch()
299 {
300 using (var container = new NativeList<int>(16, Allocator.Persistent) { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53 })
301 {
302 for (int i = 0, num = container.Length; i < num; ++i)
303 {
304 Assert.AreEqual(i, container.BinarySearch(container[i]));
305 }
306 }
307 }
308
309 [Test]
310 public void NativeList_BinarySearch_NotFound()
311 {
312 {
313 var container = new NativeList<int>(1, Allocator.Temp);
314 Assert.AreEqual(-1, container.BinarySearch(1));
315
316 container.Add(1);
317
318 Assert.AreEqual(0, container.BinarySearch(1));
319 Assert.AreEqual(-1, container.BinarySearch(-2));
320 Assert.AreEqual(-2, container.BinarySearch(2));
321 }
322
323 using (var container = new NativeList<int>(16, Allocator.Temp) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 })
324 {
325 for (int i = 0, num = container.Length; i < num; ++i)
326 {
327 Assert.AreEqual(~container.Length, container.BinarySearch(i + 16));
328 }
329 }
330
331 using (var container = new NativeList<int>(8, Allocator.Temp) { 0, 2, 4, 6, 8, 10, 12, 14 })
332 {
333 for (int i = 0, num = container.Length; i < num; ++i)
334 {
335 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, container.BinarySearch(i * 2 + 1));
336 }
337 }
338 }
339
340 [Test]
341 public void NativeList_BinarySearch_NotFound_Reference_ArrayList()
342 {
343 {
344 var reference = new ArrayList();
345 var container = new NativeList<int>(1, Allocator.Temp);
346 Assert.AreEqual(-1, reference.BinarySearch(1));
347 Assert.AreEqual(-1, container.BinarySearch(1));
348
349 reference.Add(1);
350 container.Add(1);
351
352 Assert.AreEqual(0, reference.BinarySearch(1));
353 Assert.AreEqual(0, container.BinarySearch(1));
354
355 Assert.AreEqual(-1, reference.BinarySearch(-2));
356 Assert.AreEqual(-1, container.BinarySearch(-2));
357
358 Assert.AreEqual(-2, reference.BinarySearch(2));
359 Assert.AreEqual(-2, container.BinarySearch(2));
360 }
361
362 using (var container = new NativeList<int>(16, Allocator.Temp) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 })
363 {
364 var reference = new ArrayList() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
365
366 for (int i = 0, num = container.Length; i < num; ++i)
367 {
368 Assert.AreEqual(~reference.Count, reference.BinarySearch(i + 16));
369 Assert.AreEqual(~container.Length, container.BinarySearch(i + 16));
370 }
371 }
372
373 using (var container = new NativeList<int>(8, Allocator.Temp) { 0, 2, 4, 6, 8, 10, 12, 14 })
374 {
375 var reference = new ArrayList() { 0, 2, 4, 6, 8, 10, 12, 14 };
376
377 for (int i = 0, num = container.Length; i < num; ++i)
378 {
379 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, reference.BinarySearch(i * 2 + 1));
380 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, container.BinarySearch(i * 2 + 1));
381 }
382 }
383 }
384
385 [Test]
386 public void NativeList_GenericSortJob_NoBurst()
387 {
388 NativeList_GenericSortJob();
389 }
390
391 [BurstCompile]
392 public static void Bursted_NativeList_GenericSortJob()
393 {
394 NativeList_GenericSortJob();
395 }
396
397 [Test]
398 public void NativeList_GenericSortJob_Burst()
399 {
400 Bursted_NativeList_GenericSortJob();
401 }
402
403 public static void NativeList_GenericSortJob()
404 {
405 using (var container = new NativeList<int>(5, Allocator.Persistent))
406 {
407 for (var i = 0; i < 5; ++i)
408 {
409 container.Add(4 - i);
410 }
411
412 container.Sort();
413
414 for (var i = 0; i < 5; ++i)
415 {
416 Assert.AreEqual(i, container[i]);
417 }
418 }
419
420 using (var container = new NativeList<int>(5, Allocator.Persistent))
421 {
422 for (var i = 0; i < 5; ++i)
423 {
424 container.Add(4 - i);
425 }
426
427 container.SortJob().Schedule().Complete();
428
429 for (var i = 0; i < 5; ++i)
430 {
431 Assert.AreEqual(i, container[i]);
432 }
433 }
434 }
435
436 [Test]
437 [TestRequiresDotsDebugOrCollectionChecks]
438 public void NativeList_GenericSortJobCustomComparer_NoBurst()
439 {
440 NativeList_GenericSortJobCustomComparer();
441 }
442
443 [BurstCompile]
444 public static void Bursted_NativeList_GenericSortJobCustomComparer()
445 {
446 NativeList_GenericSortJobCustomComparer();
447 }
448
449 [Test]
450 [TestRequiresDotsDebugOrCollectionChecks]
451 public void NativeList_GenericSortJobCustomComparer_Burst()
452 {
453 Bursted_NativeList_GenericSortJobCustomComparer();
454 }
455
456 public static void NativeList_GenericSortJobCustomComparer()
457 {
458 var num = 35;
459 using (var container = new NativeList<int>(num, Allocator.Persistent))
460 {
461 for (var i = 0; i < num; ++i)
462 {
463 container.Add(i);
464 }
465
466 Assert.Throws<InvalidOperationException>(() => container.Sort(new BrokenComparer0<int>()));
467 Assert.Throws<InvalidOperationException>(() => container.Sort(new BrokenComparer1<int>()));
468 Assert.Throws<InvalidOperationException>(() => container.Sort(new BrokenComparer2<int>()));
469 Assert.Throws<InvalidOperationException>(() => container.Sort(new BrokenComparer3<int>()));
470
471 container.Sort(new DescendingComparer<int>());
472
473 for (var i = 0; i < num; ++i)
474 {
475 Assert.AreEqual(num - 1 - i, container[i]);
476 }
477 }
478
479 using (var container = new NativeList<int>(num, Allocator.Persistent))
480 {
481 for (var i = 0; i < num; ++i)
482 {
483 container.Add(i);
484 }
485
486 Assert.Throws<InvalidOperationException>(() => container.SortJob(new BrokenComparer0<int>()).Schedule().Complete());
487 Assert.Throws<InvalidOperationException>(() => container.SortJob(new BrokenComparer1<int>()).Schedule().Complete());
488 Assert.Throws<InvalidOperationException>(() => container.SortJob(new BrokenComparer2<int>()).Schedule().Complete());
489 Assert.Throws<InvalidOperationException>(() => container.SortJob(new BrokenComparer3<int>()).Schedule().Complete());
490
491 container.SortJob(new DescendingComparer<int>()).Schedule().Complete();
492
493 for (var i = 0; i < num; ++i)
494 {
495 Assert.AreEqual(num - 1 - i, container[i]);
496 }
497 }
498 }
499
500 [Test]
501 public void UnsafeList_BinarySearch()
502 {
503 using (var container = new UnsafeList<int>(16, Allocator.Persistent) { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53 })
504 {
505 for (int i = 0, num = container.Length; i < num; ++i)
506 {
507 Assert.AreEqual(i, container.BinarySearch(container[i]));
508 }
509 }
510 }
511
512 [Test]
513 public void UnsafeList_BinarySearch_NotFound()
514 {
515 {
516 var container = new UnsafeList<int>(1, Allocator.Temp);
517 Assert.AreEqual(-1, container.BinarySearch(1));
518
519 container.Add(1);
520
521 Assert.AreEqual(0, container.BinarySearch(1));
522 Assert.AreEqual(-1, container.BinarySearch(-2));
523 Assert.AreEqual(-2, container.BinarySearch(2));
524 }
525
526 using (var container = new UnsafeList<int>(16, Allocator.Temp) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 })
527 {
528 for (int i = 0, num = container.Length; i < num; ++i)
529 {
530 Assert.AreEqual(~container.Length, container.BinarySearch(i + 16));
531 }
532 }
533
534 using (var container = new UnsafeList<int>(8, Allocator.Temp) { 0, 2, 4, 6, 8, 10, 12, 14 })
535 {
536 for (int i = 0, num = container.Length; i < num; ++i)
537 {
538 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, container.BinarySearch(i * 2 + 1));
539 }
540 }
541 }
542
543 [Test]
544 public void UnsafeList_BinarySearch_NotFound_Reference_ArrayList()
545 {
546 {
547 var reference = new ArrayList();
548 var container = new UnsafeList<int>(1, Allocator.Temp);
549 Assert.AreEqual(-1, reference.BinarySearch(1));
550 Assert.AreEqual(-1, container.BinarySearch(1));
551
552 reference.Add(1);
553 container.Add(1);
554
555 Assert.AreEqual(0, reference.BinarySearch(1));
556 Assert.AreEqual(0, container.BinarySearch(1));
557
558 Assert.AreEqual(-1, reference.BinarySearch(-2));
559 Assert.AreEqual(-1, container.BinarySearch(-2));
560
561 Assert.AreEqual(-2, reference.BinarySearch(2));
562 Assert.AreEqual(-2, container.BinarySearch(2));
563 }
564
565 using (var container = new UnsafeList<int>(16, Allocator.Temp) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 })
566 {
567 var reference = new ArrayList() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
568
569 for (int i = 0, num = container.Length; i < num; ++i)
570 {
571 Assert.AreEqual(~reference.Count, reference.BinarySearch(i + 16));
572 Assert.AreEqual(~container.Length, container.BinarySearch(i + 16));
573 }
574 }
575
576 using (var container = new UnsafeList<int>(8, Allocator.Temp) { 0, 2, 4, 6, 8, 10, 12, 14 })
577 {
578 var reference = new ArrayList() { 0, 2, 4, 6, 8, 10, 12, 14 };
579
580 for (int i = 0, num = container.Length; i < num; ++i)
581 {
582 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, reference.BinarySearch(i * 2 + 1));
583 Assert.AreEqual(~(i + 1) /* ~index of first greatest value searched */, container.BinarySearch(i * 2 + 1));
584 }
585 }
586 }
587
588 [Test]
589 public void UnsafeList_GenericSortJob_NoBurst()
590 {
591 UnsafeList_GenericSortJob();
592 }
593
594 [BurstCompile]
595 public static void Bursted_UnsafeList_GenericSortJob()
596 {
597 UnsafeList_GenericSortJob();
598 }
599
600 [Test]
601 public void UnsafeList_GenericSortJob_Burst()
602 {
603 Bursted_UnsafeList_GenericSortJob();
604 }
605
606 public static void UnsafeList_GenericSortJob()
607 {
608 using (var container = new UnsafeList<int>(5, Allocator.Persistent))
609 {
610 for (var i = 0; i < 5; ++i)
611 {
612 container.Add(4 - i);
613 }
614
615 container.Sort();
616
617 for (var i = 0; i < 5; ++i)
618 {
619 Assert.AreEqual(i, container[i]);
620 }
621 }
622
623 using (var container = new UnsafeList<int>(5, Allocator.Persistent))
624 {
625 for (var i = 0; i < 5; ++i)
626 {
627 container.Add(4 - i);
628 }
629
630 container.SortJob().Schedule().Complete();
631
632 for (var i = 0; i < 5; ++i)
633 {
634 Assert.AreEqual(i, container[i]);
635 }
636 }
637 }
638
639 [Test]
640 [TestRequiresDotsDebugOrCollectionChecks]
641 public void UnsafeList_GenericSortJobCustomComparer_NoBurst()
642 {
643 UnsafeList_GenericSortJobCustomComparer();
644 }
645
646 [BurstCompile]
647 public static void Bursted_UnsafeList_GenericSortJobCustomComparer()
648 {
649 UnsafeList_GenericSortJobCustomComparer();
650 }
651
652 [Test]
653 [TestRequiresDotsDebugOrCollectionChecks]
654 public void UnsafeList_GenericSortJobCustomComparer_Burst()
655 {
656 Bursted_UnsafeList_GenericSortJobCustomComparer();
657 }
658
659 public static void UnsafeList_GenericSortJobCustomComparer()
660 {
661 var num = 35;
662 using (var container = new UnsafeList<int>(num, Allocator.Persistent))
663 {
664 for (var i = 0; i < num; ++i)
665 {
666 container.Add(i);
667 }
668
669 Assert.Throws<InvalidOperationException>(() => container.Sort(new BrokenComparer0<int>()));
670 Assert.Throws<InvalidOperationException>(() => container.Sort(new BrokenComparer1<int>()));
671 Assert.Throws<InvalidOperationException>(() => container.Sort(new BrokenComparer2<int>()));
672 Assert.Throws<InvalidOperationException>(() => container.Sort(new BrokenComparer3<int>()));
673
674 container.Sort(new DescendingComparer<int>());
675
676 for (var i = 0; i < num; ++i)
677 {
678 Assert.AreEqual(num - 1 - i, container[i]);
679 }
680 }
681
682 using (var container = new UnsafeList<int>(num, Allocator.Persistent))
683 {
684 for (var i = 0; i < num; ++i)
685 {
686 container.Add(i);
687 }
688
689 Assert.Throws<InvalidOperationException>(() => container.SortJob(new BrokenComparer0<int>()).Schedule().Complete());
690 Assert.Throws<InvalidOperationException>(() => container.SortJob(new BrokenComparer1<int>()).Schedule().Complete());
691 Assert.Throws<InvalidOperationException>(() => container.SortJob(new BrokenComparer2<int>()).Schedule().Complete());
692 Assert.Throws<InvalidOperationException>(() => container.SortJob(new BrokenComparer3<int>()).Schedule().Complete());
693
694 container.SortJob(new DescendingComparer<int>()).Schedule().Complete();
695
696 for (var i = 0; i < num; ++i)
697 {
698 Assert.AreEqual(num - 1 - i, container[i]);
699 }
700 }
701 }
702
703
704 [Test]
705 public void FixedList32Bytes_GenericSort()
706 {
707 var container = new FixedList32Bytes<int>();
708
709 for (var i = 0; i < 5; ++i)
710 {
711 container.Add(i);
712 }
713
714 container.Sort(new DescendingComparer<int>());
715
716 for (var i = 0; i < 5; ++i)
717 {
718 Assert.AreEqual(4 - i, container[i]);
719 }
720 }
721
722
723 [Test]
724 public void FixedList64Bytes_GenericSort()
725 {
726 var container = new FixedList64Bytes<int>();
727
728 for (var i = 0; i < 5; ++i)
729 {
730 container.Add(i);
731 }
732
733 container.Sort(new DescendingComparer<int>());
734
735 for (var i = 0; i < 5; ++i)
736 {
737 Assert.AreEqual(4 - i, container[i]);
738 }
739 }
740
741
742 [Test]
743 public void FixedList128Bytes_GenericSort()
744 {
745 var container = new FixedList128Bytes<int>();
746
747 for (var i = 0; i < 5; ++i)
748 {
749 container.Add(i);
750 }
751
752 container.Sort(new DescendingComparer<int>());
753
754 for (var i = 0; i < 5; ++i)
755 {
756 Assert.AreEqual(4 - i, container[i]);
757 }
758 }
759
760
761 [Test]
762 public void FixedList512Bytes_GenericSort()
763 {
764 var container = new FixedList512Bytes<int>();
765
766 for (var i = 0; i < 5; ++i)
767 {
768 container.Add(i);
769 }
770
771 container.Sort(new DescendingComparer<int>());
772
773 for (var i = 0; i < 5; ++i)
774 {
775 Assert.AreEqual(4 - i, container[i]);
776 }
777 }
778
779
780 [Test]
781 public void FixedList4096Bytes_GenericSort()
782 {
783 var container = new FixedList4096Bytes<int>();
784
785 for (var i = 0; i < 5; ++i)
786 {
787 container.Add(i);
788 }
789
790 container.Sort(new DescendingComparer<int>());
791
792 for (var i = 0; i < 5; ++i)
793 {
794 Assert.AreEqual(4 - i, container[i]);
795 }
796 }
797
798 unsafe static void IntroSortNoComparerCheck<T, U>(T* array, int length, U comp)
799 where T : unmanaged
800 where U : IComparer<T>
801 {
802 NativeSortExtension.IntroSort_R<T, U>(array, 0, length - 1, 2 * CollectionHelper.Log2Floor(length), comp);
803 }
804
805 [Test]
806 [TestRequiresDotsDebugOrCollectionChecks]
807 public unsafe void NativeList_BrokenCustomComparerDoesNotCrash()
808 {
809 var rng = new Unity.Mathematics.Random(1);
810
811 var num = 10000;
812 using (var container = new NativeList<int>(num, Allocator.Persistent))
813 {
814 for (var i = 0; i < num; ++i)
815 {
816 container.Add(rng.NextInt());
817 }
818
819 Assert.DoesNotThrow(() => IntroSortNoComparerCheck(container.GetUnsafePtr(), container.Length, new BrokenComparer0<int>()));
820 }
821
822 using (var container = new NativeList<int>(num, Allocator.Persistent))
823 {
824 for (var i = 0; i < num; ++i)
825 {
826 container.Add(rng.NextInt());
827 }
828
829 Assert.DoesNotThrow(() => IntroSortNoComparerCheck(container.GetUnsafePtr(), container.Length, new BrokenComparer1<int>()));
830 }
831
832 using (var container = new NativeList<int>(num, Allocator.Persistent))
833 {
834 for (var i = 0; i < num; ++i)
835 {
836 container.Add(rng.NextInt());
837 }
838
839 Assert.DoesNotThrow(() => IntroSortNoComparerCheck(container.GetUnsafePtr(), container.Length, new BrokenComparer2<int>()));
840 }
841
842 using (var container = new NativeList<int>(num, Allocator.Persistent))
843 {
844 for (var i = 0; i < num; ++i)
845 {
846 container.Add(rng.NextInt());
847 }
848
849 Assert.DoesNotThrow(() => IntroSortNoComparerCheck(container.GetUnsafePtr(), container.Length, new BrokenComparer3<int>()));
850 }
851 }
852}