public void CopyToTest() { var set = UnsafeSortedSet.Allocate <int>(10); // Fill set for (int i = 10; i >= 0; i--) { UnsafeSortedSet.Add(set, i); } var count = UnsafeSortedSet.GetCount(set); int *arr = stackalloc int[count]; UnsafeSortedSet.CopyTo <int>(set, arr, 0); // Check int num = 0; for (int i = 0; i < count; i++) { Assert.AreEqual(i, arr[num++]); } UnsafeSortedSet.Free(set); }
public void AddRandomTest() { var set = UnsafeSortedSet.Allocate <int>(10); Random r = new Random(); for (int i = 0; i < 10; i++) { UnsafeSortedSet.Add <int>(set, r.Next()); } int *arr = stackalloc int[10]; UnsafeSortedSet.CopyTo <int>(set, arr, 0); // Validate values are from low to high int last = arr[0]; for (int i = 1; i < 10; i++) { Assert.IsTrue(last <= arr[i]); last = arr[i++]; } UnsafeSortedSet.Free(set); }
public void InvalidTypeTest() { var set = UnsafeSortedSet.Allocate <int>(10); Assert.Catch <AssertException>(() => { UnsafeSortedSet.Add <float>(set, 4); }); UnsafeSortedSet.Free(set); }
public void ConstructorTest() { var set = UnsafeSortedSet.Allocate <int>(10); Assert.AreEqual(0, UnsafeSortedSet.GetCount(set)); Assert.AreEqual(10, UnsafeSortedSet.GetCapacity(set)); UnsafeSortedSet.Free(set); }
public void ClearTest() { var set = UnsafeSortedSet.Allocate <int>(16, fixedSize: false); // Add some random data Random r = new Random(); for (int i = 0; i < 10; i++) { UnsafeSortedSet.Add <int>(set, r.Next()); } // Verify data has been added Assert.AreEqual(10, UnsafeSortedSet.GetCount(set)); Assert.AreEqual(16, UnsafeSortedSet.GetCapacity(set)); // Clear set and verify it's cleared UnsafeSortedSet.Clear(set); Assert.AreEqual(0, UnsafeSortedSet.GetCount(set)); Assert.AreEqual(16, UnsafeSortedSet.GetCapacity(set)); // Validate we can still add data and have it be valid // Add data to cleared set for (int i = 10; i >= 0; i--) { UnsafeSortedSet.Add(set, i); } var count = UnsafeSortedSet.GetCount(set); int *arr = stackalloc int[count]; UnsafeSortedSet.CopyTo <int>(set, arr, 0); // Validate data has been written int num = 0; for (int i = 0; i < count; i++) { Assert.AreEqual(i, arr[num++]); } Assert.AreEqual(count, UnsafeSortedSet.GetCount(set)); Assert.AreEqual(16, UnsafeSortedSet.GetCapacity(set)); UnsafeSortedSet.Free(set); }
public void ExpandTest() { var set = UnsafeSortedSet.Allocate <int>(8, fixedSize: false); // Valid adds for (int i = 0; i < 8; i++) { UnsafeSortedSet.Add(set, i + 1); } Assert.AreEqual(8, UnsafeSortedSet.GetCount(set)); Assert.AreEqual(8, UnsafeSortedSet.GetCapacity(set)); UnsafeSortedSet.Add(set, 42); Assert.AreEqual(9, UnsafeSortedSet.GetCount(set)); Assert.AreEqual(16, UnsafeSortedSet.GetCapacity(set)); UnsafeSortedSet.Free(set); }
public void ExpandFailedTest() { var set = UnsafeSortedSet.Allocate <int>(8, true); // Valid adds for (int i = 0; i < 8; i++) { UnsafeSortedSet.Add(set, i + 1); } Assert.AreEqual(8, UnsafeSortedSet.GetCount(set)); Assert.AreEqual(8, UnsafeSortedSet.GetCapacity(set)); Assert.Throws <InvalidOperationException>(() => { UnsafeSortedSet.Add(set, 42); }); UnsafeSortedSet.Free(set); }
public void IteratorTest() { var set = UnsafeSortedSet.Allocate <int>(10); // Fill set for (int i = 10; i >= 0; i--) { // Add in reverse order UnsafeSortedSet.Add(set, i); } var enumerator = UnsafeSortedSet.GetEnumerator <int>(set); for (int i = 0; i < 10; i++) { enumerator.MoveNext(); Assert.AreEqual(i, enumerator.Current); } UnsafeSortedSet.Free(set); }
public void RemoveTest() { var set = UnsafeSortedSet.Allocate <int>(10); Assert.IsFalse(UnsafeSortedSet.Remove <int>(set, 1)); UnsafeSortedSet.Add(set, 1); UnsafeSortedSet.Add(set, 7); UnsafeSortedSet.Add(set, 51); UnsafeSortedSet.Add(set, 13); Assert.IsFalse(UnsafeSortedSet.Remove <int>(set, 3)); Assert.IsTrue(UnsafeSortedSet.Remove <int>(set, 1)); Assert.IsTrue(UnsafeSortedSet.Remove <int>(set, 7)); Assert.IsTrue(UnsafeSortedSet.Remove <int>(set, 13)); Assert.IsTrue(UnsafeSortedSet.Remove <int>(set, 51)); Assert.IsFalse(UnsafeSortedSet.Remove <int>(set, 13)); UnsafeSortedSet.Free(set); }
public void CopyTo(T[] array, int arrayIndex) { if (array == null) { throw new ArgumentNullException(nameof(array)); } if ((uint)arrayIndex > array.Length) { throw new ArgumentOutOfRangeException(nameof(arrayIndex)); } if (array.Length - arrayIndex < Count) { throw new ArgumentException("Insufficient space in the target location to copy the information."); } if (array.Length == 0) { return; fixed(void *ptr = array) UnsafeSortedSet.CopyTo <T>(m_inner, ptr, arrayIndex); }
public void Clear() { UnsafeSortedSet.Clear(m_inner); }
public void Add(T item) { UnsafeSortedSet.Add <T>(m_inner, item); }
public NativeSortedSet(int capacity, bool fixedSize) { m_inner = UnsafeSortedSet.Allocate <T>(capacity, fixedSize); }
public NativeSortedSet(int capacity) { m_inner = UnsafeSortedSet.Allocate <T>(capacity, false); }
public bool Remove(T item) { return(UnsafeSortedSet.Remove <T>(m_inner, item)); }
public bool Contains(T item) { return(UnsafeSortedSet.Contains <T>(m_inner, item)); }