public void EnqueueTest()
{
Queue queue = new QueueArray();
queue.Enqueue(5);
queue.Enqueue("this");
queue.Enqueue(15.5);
object[] outputQueue = getQueueArray(queue);
Assert.AreEqual(10, outputQueue.Count());
Assert.AreEqual(5, outputQueue[0]);
Assert.AreEqual("this", outputQueue[1]);
Assert.AreEqual(15.5, outputQueue[2]);
Assert.IsNull(outputQueue[3]);
Assert.IsNull(outputQueue[9]);
queue = new QueueArray(3);
queue.Enqueue(5);
queue.Enqueue(7);
queue.Enqueue(9);
queue.Enqueue(11);
queue.Enqueue(13);
outputQueue = getQueueArray(queue);
Assert.AreEqual(5, outputQueue[0]);
Assert.AreEqual(7, outputQueue[1]);
Assert.AreEqual(9, outputQueue[2]);
Assert.AreEqual(11, outputQueue[3]);
Assert.AreEqual(13, outputQueue[4]);
Assert.AreEqual(null, outputQueue[5]);
}
public void AdditionalTest()
{
Queue queue = new QueueArray(3);
queue.Enqueue(5);
queue.Enqueue(7);
queue.Enqueue(9);
queue.Enqueue(11);
Assert.AreEqual(5, queue.Peek());
Assert.AreEqual(5, queue.Dequeue());
queue.Enqueue(13);
Assert.AreEqual(7, queue.Peek());
queue.Enqueue(15);
Assert.AreEqual(7, queue.Peek());
Assert.AreEqual(7, queue.Dequeue());
Assert.AreEqual(9, queue.Dequeue());
queue.Enqueue(17);
Assert.AreEqual(11, queue.Peek());
queue.Enqueue(19);
queue.Enqueue(21);
Assert.AreEqual(11, queue.Peek());
queue.Enqueue(23);
Assert.AreEqual(11, queue.Dequeue());
Assert.AreEqual(13, queue.Dequeue());
Assert.AreEqual(15, queue.Dequeue());
Assert.AreEqual(17, queue.Dequeue());
Assert.AreEqual(19, queue.Dequeue());
Assert.AreEqual(21, queue.Dequeue());
Assert.AreEqual(23, queue.Dequeue());
}
[TestMethod] //получение элемента из пустой очереди
public void TakeEmptyTest()
{
int n = 3;
QueueArray<object> data = new QueueArray<object>(n);
data.Dequeue();
}
[TestMethod] //получение элемента из пустой очереди
public void TakeEmptyTest()
{
int n = 3;
QueueArray <object> data = new QueueArray <object>(n);
data.Take();
}
public void QueueArray_Basic()
{
QueueArray <int> queue = new QueueArray <int>();
queue.Enqueue(0);
queue.Enqueue(1);
queue.Enqueue(2);
CollectionAssert.AreEqual(new int[] { 0, 1, 2 }, queue.ToArray());
Assert.AreEqual(3, queue.Count);
Assert.AreEqual(0, queue[0]);
Assert.AreEqual(1, queue[1]);
Assert.AreEqual(2, queue[2]);
Assert.AreEqual(0, queue.Peek());
Assert.AreEqual(3, queue.Count);
Assert.AreEqual(0, queue.Dequeue());
CollectionAssert.AreEqual(new int[] { 1, 2 }, queue.ToArray());
Assert.AreEqual(2, queue.Count);
Assert.AreEqual(1, queue[0]);
Assert.AreEqual(2, queue[1]);
Assert.AreEqual(1, queue.Dequeue());
CollectionAssert.AreEqual(new int[] { 2 }, queue.ToArray());
Assert.AreEqual(1, queue.Count);
Assert.AreEqual(2, queue[0]);
Assert.AreEqual(2, queue.Dequeue());
CollectionAssert.AreEqual(new int[] { }, queue.ToArray());
Assert.AreEqual(0, queue.Count);
}
void Start()
{
//Default close console
m_parentPanel.SetActive(false);
m_commandHistory = new QueueArray <string> (30);
m_commandHistoryCache = null;
m_commandHistoryIndex = 0;
}
[TestMethod] //Тест заполнения очереди
public void AddTest()
{
int n = 3;
QueueArray <object> data = new QueueArray <object>(n);
data.Add(8);
data.Add(6);
data.Add(10);
}
[TestMethod] //заполнение очереди
public void AddTest()
{
int n = 3;
QueueArray<object> data = new QueueArray<object>(n);
data.Add(8);
data.Add(6);
data.Add(10);
}
public void Enqueue()
{
IQueue <Person> queue = new QueueArray <Person>();
foreach (Person person in RandomTestData)
{
queue.Enqueue(person);
}
}
public void EnqueueWithCapacity()
{
IQueue <Person> queue = new QueueArray <Person>(RandomTestData.Length);
foreach (Person person in RandomTestData)
{
queue.Enqueue(person);
}
}
public void Get_GetFromEmptyQueueShouldNotWork()
{
// Arrange
QueueArray <int> sut = new QueueArray <int>();
// Act
// Assert
Assert.Throws <DataStructureIsEmptyOnReadExeption>(() => sut.Get());
}
public void EnqueueWithCapacity()
{
IQueue <int> queue = new QueueArray <int>(EnqueueCount);
int enqueueCount = EnqueueCount;
for (int i = 0; i < enqueueCount; i++)
{
queue.Enqueue(i);
}
}
[TestMethod] //IDisposable
public void DisposeTest()
{
int n = 3;
QueueArray <object> data = new QueueArray <object>(n);
data.Add(8);
data.Add(6);
data.Add(10);
data.Dispose();
}
[TestMethod] //IEnumerable
public void EnumerableTest()
{
int n = 3;
QueueArray <object> data = new QueueArray <object>(n);
data.Add(8);
data.Add(6);
data.Add(10);
data.GetEnumerator();
}
[TestMethod] public void Enqueue_Dequeue_Testing()
{
void Test <T>(T[] values)
{
Towel.Algorithms.Sort.Shuffle(values);
IQueue <T> stack = new QueueArray <T>();
values.Stepper(x => stack.Enqueue(x));
values.Stepper(x => x.Equals(stack.Dequeue()));
}
[TestMethod] public void Enqueue_Dequeue_Testing()
{
void Test <T>(T[] values)
{
Towel.Sort.Shuffle(values);
IQueue <T> queue = new QueueArray <T>();
values.Stepper(x => queue.Enqueue(x));
values.Stepper(x => x.Equals(queue.Dequeue()));
}
private TimeSpan bkTaskInterval; // Channel background task interval
/// <summary>
/// Constructor.
/// </summary>
/// <param name="context">The <see cref="BindingContext" /> holding the information necessary to construct the channel stack.</param>
internal InputChannelListener(BindingContext context)
: base(context)
{
this.maxReceiveQueueSize = ServiceModelHelper.MaxAcceptedMessages; // $todo(jeff.lill): Hardcoded
this.bkTaskInterval = ServiceModelHelper.DefaultBkTaskInterval; // This too
this.msgQueue = new LimitedQueue <Message>(maxReceiveQueueSize);
this.waitQueue = new QueueArray <AsyncResult <bool, InputChannel> >();
this.receiveQueue = new QueueArray <AsyncResult <Message, InputChannel> >();
}
[TestMethod] //получение первого элемента
public void TakeTest()
{
int n = 3;
QueueArray<object> data = new QueueArray<object>(n);
data.Add(8);
data.Add(6);
data.Add(10);
data.Dequeue();
}
[TestMethod] //IEnumerable
public void EnumerableTest()
{
int n = 3;
QueueArray<object> data = new QueueArray<object>(n);
data.Add(8);
data.Add(6);
data.Add(10);
data.GetEnumerator();
}
[TestMethod] //IDisposable
public void DisposeTest()
{
int n = 3;
QueueArray<object> data = new QueueArray<object>(n);
data.Add(8);
data.Add(6);
data.Add(10);
data.Dispose();
}
private TimeSpan bkTaskInterval; // Channel background task interval
/// <summary>
/// Constructor.
/// </summary>
/// <param name="context">The <see cref="BindingContext" /> holding the information necessary to construct the channel stack.</param>
internal ReplyChannelListener(BindingContext context)
: base(context)
{
this.maxRequestQueueSize = ServiceModelHelper.MaxAcceptedMessages; // $todo(jeff.lill): Hardcoded
this.maxRequestQueueTime = ServiceModelHelper.MaxRequestQueueTime; //
this.bkTaskInterval = ServiceModelHelper.DefaultBkTaskInterval; //
this.requestQueue = new LimitedQueue <RequestInfo>(maxRequestQueueSize);
this.waitQueue = new QueueArray <AsyncResult <bool, ReplyChannel> >();
this.receiveQueue = new QueueArray <AsyncResult <RequestInfo, ReplyChannel> >();
}
public void DefaultConstructorTest()
{
Queue queue = new QueueArray();
object[] outputQueue = getQueueArray(queue);
Assert.AreEqual(10, outputQueue.Length);
for (int i = 0; i < outputQueue.Length; i++)
{
Assert.IsNull(outputQueue[i]);
}
}
public void QueueSizeIncreases()
{
var queue = new QueueArray <int>();
var size = 100;
for (int i = 0; i < size; i++)
{
queue.Enqueue(i);
}
Assert.AreEqual(size, queue.Size());
}
public void IsEmpty_EmptyQueueShouldReturnTrue()
{
// Arrange
QueueArray <int> sut = new QueueArray <int>();
bool expected = true;
// Act
bool actual = sut.IsEmpty();
// Assert
Assert.Equal(expected, actual);
}
public void Indexer_SetFromWrongIndexShouldThrowExeption()
{
// Arrange
QueueArray <double> sut = new QueueArray <double>();
sut.Add(1);
sut.Add(2);
// Act
// Assert
Assert.Throws <IndexOutOfRangeException>(() => sut[5] = 10);
}
public void TestQueue()
{
var queue = new QueueArray <int>();
queue.Enqueue(10);
Assert.Equal(1, queue.Count);
queue.Enqueue(20);
Assert.Equal(2, queue.Count);
Assert.False(queue.IsEmpty);
Assert.Equal(10, queue.Dequeue());
Assert.Equal(20, queue.Dequeue());
Assert.True(queue.IsEmpty);
}
public void EmptyQueueDequeueUnderflow()
{
var queue = new QueueArray <int>();
try
{
queue.Dequeue();
}
catch (InvalidOperationException ex)
{
Assert.AreEqual("The Queue is empty.", ex.Message);
}
}
/// <summary>Creates a shallow clone of this data structure.</summary>
/// <returns>A shallow clone of this data structure.</returns>
public DataStructure <T> Clone()
{
QueueArray <T> clone = new QueueArray <T>();
clone._queue = new T[this._queue.Length];
for (int i = 0; i < this._count; i++)
{
clone._queue[i] = this._queue[i];
}
clone._minimumCapacity = this._minimumCapacity;
clone._count = this._count;
clone._start = this._start;
return(clone);
}
public void Filter_FilterShouldWork()
{
// Arrange
QueueArray <string> sut = new QueueArray <string> {
"abc", "125", "253", "one"
};
string[] expected = { "one" };
// Act
IEnumerable <string> actual = sut.Filter(item => item == "one");
// Assert
Assert.Equal(expected, actual);
}
public void QueueArray_InsertAt()
{
QueueArray <int> queue = new QueueArray <int>();
queue.InsertAt(0, 0);
CollectionAssert.AreEqual(new int[] { 0 }, queue.ToArray());
queue.InsertAt(1, 1);
CollectionAssert.AreEqual(new int[] { 0, 1 }, queue.ToArray());
queue.InsertAt(2, 2);
CollectionAssert.AreEqual(new int[] { 0, 1, 2 }, queue.ToArray());
queue.InsertAt(0, -2);
CollectionAssert.AreEqual(new int[] { -2, 0, 1, 2 }, queue.ToArray());
queue.InsertAt(1, -1);
CollectionAssert.AreEqual(new int[] { -2, -1, 0, 1, 2 }, queue.ToArray());
}
public void Filter_FilterShouldWork()
{
// Arrange
QueueArray <double> sut = new QueueArray <double> {
4.3, 2.7, 4.25, 5.28, 1.3, double.MinValue
};
double[] expected = { double.MinValue, 1.3, 2.7 };
// Act
IEnumerable <double> actual = sut.Filter(item => item < 4.1);
// Assert
Assert.Equal(expected, actual);
}
public void Clear_ClearQueueArrayWithSomeNumbersShoulWork()
{
// Arrange
QueueArray <int> sut = new QueueArray <int>();
int expected = 0;
// Act
sut.Add(int.MaxValue);
sut.Add(int.MinValue);
sut.Add(42);
sut.Clear();
int actual = sut.Size();
// Assert
Assert.Equal(expected, actual);
}
public void Add_AddManyNumbersToQueueArrayShouldWork(int count)
{
// Arrange
QueueArray <int> sut = new QueueArray <int>();
int expected = count;
// Act
for (int i = 0; i < count; i++)
{
sut.Add(i);
}
int actual = sut.Size();
// Assert
Assert.Equal(expected, actual);
}
public void MultipleEnqueueDequeueReturnValues()
{
var queue = new QueueArray <int>();
var size = 50;
for (int i = 0; i < size; i++)
{
queue.Enqueue(i);
}
for (int i = 0; i < size; i++)
{
var dequeued = queue.Dequeue();
Assert.AreEqual(i, dequeued);
}
}
public void StackSizeDecreases()
{
var queue = new QueueArray <int>();
var size = 100;
for (int i = 0; i < size; i++)
{
queue.Enqueue(i);
}
for (int i = 0; i < size; i++)
{
queue.Dequeue();
}
Assert.AreEqual(0, queue.Size());
}
