public void PopTest()
{
var arr = UnsafeStack.Allocate <int>(10);
for (int i = 1; i <= 10; i++)
{
UnsafeStack.Push(arr, i);
}
Assert.AreEqual(10, UnsafeStack.GetCount(arr));
var val = UnsafeStack.Pop <int>(arr);
Assert.AreEqual(10, val);
Assert.AreEqual(9, UnsafeStack.GetCount(arr));
// Reverse stack-iteration
for (int i = 9; i > 0; i--)
{
var num = UnsafeStack.Pop <int>(arr);
Assert.AreEqual(i, num);
}
Assert.AreEqual(0, UnsafeStack.GetCount(arr));
}
public void ConstructorTest()
{
var arr = UnsafeStack.Allocate <int>(10);
Assert.AreEqual(UnsafeStack.GetCount(arr), 0);
UnsafeStack.Free(arr);
}
public void InvalidTypeTest()
{
var arr = UnsafeStack.Allocate <int>(10);
Assert.Catch <AssertException>(() => { UnsafeStack.Push <float>(arr, 20); });
UnsafeStack.Free(arr);
}
public void ExpandTest()
{
var arr = UnsafeStack.Allocate <int>(8);
for (int i = 0; i < 10; i++)
{
UnsafeStack.Push(arr, i);
}
Assert.IsTrue(UnsafeStack.GetCapacity(arr) > 8);
UnsafeStack.Free(arr);
}
public void ContainsTest()
{
var arr = UnsafeStack.Allocate <int>(10);
for (int i = 1; i <= 10; i++)
{
UnsafeStack.Push(arr, i);
}
Assert.IsTrue(UnsafeStack.Contains(arr, 1));
Assert.IsTrue(UnsafeStack.Contains(arr, 10));
Assert.IsFalse(UnsafeStack.Contains(arr, 11));
}
public void MutateTest()
{
var arr = UnsafeStack.Allocate <int>(10);
for (int i = 0; i < 10; i++)
{
UnsafeStack.Push(arr, i);
}
for (int i = 9; i >= 0; i--)
{
Assert.AreEqual(i, UnsafeStack.Pop <int>(arr));
}
UnsafeStack.Free(arr);
}
public void IteratorTest()
{
var arr = UnsafeStack.Allocate <int>(10);
for (int i = 0; i < 10; i++)
{
UnsafeStack.Push(arr, i);
}
Assert.AreEqual(10, UnsafeStack.GetCount(arr));
int num = 9;
foreach (int i in UnsafeStack.GetEnumerator <int>(arr))
{
Assert.AreEqual(num--, i);
}
UnsafeStack.Free(arr);
}
public void CopyToTest()
{
var q = UnsafeStack.Allocate <int>(10);
for (int i = 0; i < 10; i++)
{
UnsafeStack.Push(q, i);
}
var arr = new int[10];
fixed(void *ptr = arr)
{
UnsafeStack.CopyTo <int>(q, ptr, 0);
}
int num = 10;
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(--num, arr[i]);
}
}
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)
UnsafeStack.CopyTo <T>(m_inner, ptr, arrayIndex);
}
public NativeStack(int capacity, bool fixedSize)
{
m_inner = UnsafeStack.Allocate <T>(capacity, fixedSize);
}
public NativeStack(int capacity)
{
m_inner = UnsafeStack.Allocate <T>(capacity);
}
public bool TryPush(T item)
{
return(UnsafeStack.TryPush <T>(m_inner, item));
}
public void Push(T item)
{
UnsafeStack.Push(m_inner, item);
}
public bool TryPop(out T item)
{
return(UnsafeStack.TryPop <T>(m_inner, out item));
}
public T Peek()
{
return(UnsafeStack.Peek <T>(m_inner));
}
static void Main(string[] args)
{
Console.WriteLine("Project is working with UnsafeStackAndLinkedList.dll\n");
// Working with unsafe code, implemented in class "UnsafeStack"
Console.WriteLine("_______Working with unsafe Stack_______\n");
UnsafeStack stack = new UnsafeStack();
stack.Init();
for (int i = 0; i < 13; i++)
{
stack.PushBack(i * i);
}
stack.ShowCurrent();
Console.WriteLine("Popping top elements: ");
for (int i = 0; i < 14; i++)
{
int temp = stack.Pop();
Console.Write(temp.ToString() + " ");
}
Console.WriteLine("Adding few more elements...");
for (int i = 0; i < 20; i++)
{
stack.PushBack(i * i * i);
}
stack.ShowCurrent();
// Show all elements without deleting
stack.ExtractAllStack();
// Working with DoublyLinkedList
Console.WriteLine("\n\n_______Working with DoublyLinkedList_______\n");
DoublyLinkedList linkedList = new DoublyLinkedList();
Random rand = new Random(12);
for (int i = 0; i < 5; i++)
{
linkedList.InsertAtHead(rand.Next(0, 10));
}
// few more elements
linkedList.InsertAtHead(1000);
linkedList.InsertAtHead(1200);
linkedList.InsertAtHead(333);
linkedList.InsertAtHead(2);
linkedList.InsertAtHead(124);
linkedList.InsertAtHead(34);
linkedList.InsertAtHead(424);
linkedList.InsertAtHead(1);
linkedList.Print();
linkedList.PrintReverse();
Console.WriteLine("\nDeleting few elements...\n");
linkedList.Delete(1000);
linkedList.Delete(333);
linkedList.Delete(34);
linkedList.Delete(124);
// Printing
Console.WriteLine();
linkedList.Print();
linkedList.PrintReverse();
}
public T Pop()
{
return(UnsafeStack.Pop <T>(m_inner));
}
