[TestMethod] //получение элемента из пустго стека
public void PopEmptyTest()
{
int n = 3;
StackArray<object> data = new StackArray<object>(n);
data.Pop();
}
public void FullStackArrayTests0()
{
var stackArray = new StackArray <int>(5);
for (var i = 0; i < 5; i++)
{
Assert.True(stackArray.Count == i);
stackArray.Push(i * 2);
}
Assert.True(stackArray.IsFull);
Assert.False(stackArray.IsEmpty);
Assert.Throws <InvalidOperationException>(() => stackArray.Push(10));
Assert.Throws <InvalidOperationException>(() => stackArray.Push(12));
Assert.True(stackArray.Peek() == 8);
Assert.True(stackArray.Pop() == 8);
Assert.True(stackArray.Count == 4);
Assert.True(stackArray.Length == 5);
Assert.False(stackArray.IsFull);
Assert.False(stackArray.IsEmpty);
stackArray.Push(8);
Assert.True(stackArray.Peek() == 8);
Assert.Throws <InvalidOperationException>(() => stackArray.Push(10));
Assert.True(stackArray.IsFull);
Assert.False(stackArray.IsEmpty);
Assert.True(stackArray.Length == 5);
Assert.True(stackArray.Count == 5);
}
public ElementHandlerResult AddChild(StackArray <string> openElements, string childName)
{
if (Array.IndexOf(closers, childName) == -1)
{
return(ElementHandlerResult.Continue);
}
for (var index = openElements.Count; index > 0; index--)
{
var openElement = openElements[index - 1];
if (Array.IndexOf(parents, openElement) != -1)
{
return(ElementHandlerResult.Continue);
}
if (openElement.Equals(Name))
{
break;
}
}
if (Array.IndexOf(closers, childName) != -1)
{
if (Array.IndexOf(peers, childName) != -1)
{
return(ElementHandlerResult.CloseElementAndBreak);
}
return(ElementHandlerResult.CloseElement);
}
return(ElementHandlerResult.Continue);
}
private static void printStack(StackArray <int> stack)
{
foreach (var item in stack)
{
Console.WriteLine(item);
}
}
[TestMethod] //получение элемента из пустго стека
public void PopEmptyTest()
{
int n = 3;
StackArray <object> data = new StackArray <object>(n);
data.Pop();
}
static void Main(string[] args)
{
Console.WriteLine("Array based stack");
IStack stk = new StackArray(4);
DemoStack(stk);
Console.WriteLine("Double Linked List based stack");
stk = new StackDoublyLinkedList();
DemoStack(stk);
Console.WriteLine("Circular Linked List based stack");
stk = new StackCircularLinkedList();
DemoStack(stk);
int[] Input = { 10, 9, 8, 4, 13, 7, 12, 4, 6, 2 };
for (int i = 0; i < Input.Length; i++)
{
Console.Write(Input[i] + " ");
}
Console.WriteLine("");
int[] Span = ArraySpan.CalculateSpan(Input);
for (int i = 0; i < Span.Length; i++)
{
Console.Write(Span[i] + " ");
}
Console.ReadLine();
}
static void Main(string[] args)
{
var ht = new HashTable<int, int>();
var ll = new MyLinkedList<int>();
var stackLL = new StackLL<int>();
var stackArr = new StackArray<int>();
var queueArr = new QueueArr<int>();
}
public ElementHandlerResult AddChild(StackArray <string> openElements, string childName)
{
if (!HtmlConverter.IsInlineElement(childName))
{
return(ElementHandlerResult.CloseElement);
}
return(ElementHandlerResult.Continue);
}
public void EmptyStackExceptionTest()
{
IStack stack = new Stack();
stack.Pop();
stack = new StackArray();
stack.Pop();
}
// StackArray
[Benchmark] public void StackArray_Push()
{
IStack <Person> stack = new StackArray <Person>();
foreach (Person person in RandomTestData)
{
stack.Push(person);
}
}
[Benchmark] public void StackArray_PushWithCapacity()
{
IStack <Person> stack = new StackArray <Person>(RandomTestData.Length);
foreach (Person person in RandomTestData)
{
stack.Push(person);
}
}
[TestMethod] //Тест заполнения стека
public void PushTest()
{
int n = 3;
StackArray <object> data = new StackArray <object>(n);
data.Push(8);
data.Push(6);
data.Push(10);
}
[TestMethod] //Тест заполнения стека
public void PushTest()
{
int n = 3;
StackArray<object> data = new StackArray<object>(n);
data.Push(8);
data.Push(6);
data.Push(10);
}
public void Add()
{
IStack <Person> stack = new StackArray <Person>();
foreach (Person person in RandomTestData)
{
stack.Push(person);
}
}
public void PushElements()
{
var stack = new StackArray <int>();
for (int i = 0; i < MAX_SIZE; i++)
{
stack.Push(i);
}
}
public void ConstructorTest()
{
Stack stack = new StackArray(12);
int initialSize = getInitialSize(stack);
Assert.AreEqual(12, initialSize);
int stackSize = getArraySize(stack);
Assert.AreEqual(initialSize, stackSize);
}
public void DefaultConstructorTest()
{
var stack = new StackArray();
int initialSize = getInitialSize(stack);
Assert.AreEqual(10, initialSize);
int stackSize = getArraySize(stack);
Assert.AreEqual(initialSize, stackSize);
}
public void ResizeTest()
{
var stack = new StackArray();
for (var i = 0; i < 1000; ++i)
{
stack.Push(i);
}
Assert.AreEqual(999, stack.Pop());
}
public void PushWithCapacity()
{
IStack <int> stack = new StackArray <int>(PushCount);
int pushCount = PushCount;
for (int i = 0; i < pushCount; i++)
{
stack.Push(i);
}
}
public void Get_GetFromEmptyStack()
{
// Arrange
StackArray <int> sut = new StackArray <int>();
// Act
// Assert
Assert.Throws <DataStructureIsEmptyOnReadExeption>(() => sut.Get());
}
[TestMethod] //IDisposable
public void DisposeTest()
{
int n = 3;
StackArray<object> data = new StackArray<object>(n);
data.Push(8);
data.Push(6);
data.Push(10);
data.Dispose();
}
[TestMethod] //IEnumerable
public void EnumerableTest()
{
int n = 3;
StackArray<object> data = new StackArray<object>(n);
data.Push(8);
data.Push(6);
data.Push(10);
data.GetEnumerator();
}
[TestMethod] //IEnumerable
public void EnumerableTest()
{
int n = 3;
StackArray <object> data = new StackArray <object>(n);
data.Push(8);
data.Push(6);
data.Push(10);
data.GetEnumerator();
}
[TestMethod] //IDisposable
public void DisposeTest()
{
int n = 3;
StackArray <object> data = new StackArray <object>(n);
data.Push(8);
data.Push(6);
data.Push(10);
data.Dispose();
}
public void StackSizeIncreases()
{
var stack = new StackArray <int>();
for (int i = 0; i < MAX_SIZE; i++)
{
stack.Push(i);
}
Assert.AreEqual(MAX_SIZE, stack.Size());
}
static void Main(string[] args)
{
var s = new StackArray(5);
s.push(12);
s.push(11);
s.push(113);
s.push(413);
s.push(4131);
s.display();
}
[TestMethod] public void Push_Pop_Testing()
{
void Test <T>(T[] values)
{
Towel.Sort.Shuffle(values);
IStack <T> stack = new StackArray <T>();
values.Stepper(x => stack.Push(x));
Array.Reverse(values);
values.Stepper(x => x.Equals(stack.Pop()));
}
public void Implement_Stack_Using_Array()
{
StackArray stack = new StackArray(100, output);
stack.push(2);
stack.push(3);
Assert.Equal(3, stack.pop());
stack.push(4);
Assert.Equal(4, stack.pop());
stack.printStack();
}
public void TestStack()
{
var stack = new StackArray <int>();
stack.Push(10);
stack.Push(20);
Assert.Equal(2, stack.Count);
Assert.False(stack.IsEmpty);
Assert.Equal(20, stack.Pop());
Assert.Equal(10, stack.Pop());
Assert.True(stack.IsEmpty);
}
public void IsEmpty_EmptyStackArrayShouldReturnTrue()
{
// Arrange
StackArray <int> sut = new StackArray <int>();
bool expected = true;
// Act
bool actual = sut.IsEmpty();
// Assert
Assert.Equal(expected, actual);
}
// methods
#region public StackArray<T> Clone()
/// <summary>Creates a shallow clone of this data structure.</summary>
/// <returns>A shallow clone of this data structure.</returns>
public StackArray <T> Clone()
{
StackArray <T> clone = new StackArray <T>();
clone._stack = new T[this._stack.Length];
for (int i = 0; i < this._count; i++)
{
clone._stack[i] = this._stack[i];
}
clone._minimumCapacity = this._minimumCapacity;
clone._count = this._count;
return(clone);
}
public void Indexer_SetFromWrongIndexShouldThrowExeption()
{
// Arrange
StackArray <double> sut = new StackArray <double>();
sut.Add(1);
sut.Add(2);
// Act
// Assert
Assert.Throws <IndexOutOfRangeException>(() => sut[5] = 10);
}
public void PopReturnsValue()
{
var stack = new StackArray <int>();
for (int i = 0; i < MAX_SIZE; i++)
{
stack.Push(i);
}
for (int i = MAX_SIZE - 1; i > 0; i--)
{
Assert.AreEqual(i, stack.Pop());
}
}
private StackArray<Struct, S005<Struct>> InitArray(StackArray<Struct, S005<Struct>> array)
{
for (var i = 0; i < 5; i++)
{
var s = new Struct();
s.Number = i;
var gcMemory = GC.GetTotalMemory(false);
array[i] = s;
Assert.AreEqual(gcMemory, GC.GetTotalMemory(false), "Set index is allocating on heap.");
}
return array;
}
public void Filter_FilterShouldWork()
{
// Arrange
StackArray <int> sut = new StackArray <int> {
2, 8, 7, 12, 23, 14, 1, 25, 17, 5
};
int[] expected = { 5, 14, 12, 7, 8 };
// Act
IEnumerable <int> actual = sut.Filter(item => item >= 5 && item <= 14);
// Assert
Assert.Equal(expected, actual);
}
public void StackSizeDecreases()
{
var stack = new StackArray <int>();
for (int i = 0; i < MAX_SIZE; i++)
{
stack.Push(i);
}
for (int i = MAX_SIZE; i > 0; i--)
{
stack.Pop();
}
Assert.AreEqual(0, stack.Size());
}
public void Clear_ClearStackWithSomeElementsShouldWork()
{
// Arrange
StackArray <int> sut = new StackArray <int>();
int expected = 0;
// Act
sut.Add(42);
sut.Add(17);
sut.Add(int.MaxValue);
sut.Clear();
int actual = sut.Size();
// Assert
Assert.Equal(expected, actual);
}
public void Initialize()
{
stack = new StackArray();
}
