public void MinimumPeriodInSeconds()
{
var poller = Substitute.For<IPoller<object>>();
var processor = Substitute.For<IProcessor<object>>();
var d = new Dequeue<object>(poller, processor);
Assert.AreEqual(15, d.MinimumPeriodInSeconds);
}
public async Task Run()
{
var data = new object();
var message = Substitute.For <IQueued <object> >();
message.Data().Returns(Task.FromResult(data));
message.Complete();
var poller = Substitute.For <IPoller <object> >();
poller.Poll().Returns(Task.FromResult(message));
var processor = Substitute.For <IProcessor <object> >();
processor.Process(data).Returns(Task.FromResult(true));
var d = new Dequeue <object>(poller, processor);
var result = await d.Run();
Assert.IsTrue(result);
message.Received().Data();
message.Received().Complete();
poller.Received().Poll();
processor.Received().Process(data);
}
static void Main(string[] args)
{
Dequeue <int> q = new Dequeue <int>();
for (int i = 1; i <= 12; i++)
{
q.insertFront(i);
}
q.printQueue();
q.deleteFront();
q.deleteFront();
q.insertFront(11);
q.insertFront(12);
q.printQueue();
q.deleteRear();
q.deleteRear();
q.insertRear(13);
q.insertRear(14);
q.printQueue();
}
public void MaximumPeriodInSeconds()
{
var poller = Substitute.For<IPoller<object>>();
var processor = Substitute.For<IProcessor<object>>();
var d = new Dequeue<object>(poller, processor);
Assert.AreEqual(BaseTimes.MaximumStorageTiming, d.MaximumPeriodInSeconds);
}
/// <summary>Removes all interactors from the queue, failing each.</summary>
/// <param name="interactors">The queue of interactors to complete.</param>
/// <param name="error">The error with which to complete each interactor.</param>
internal static void FailInteractors <T, TInner>(Dequeue <T> interactors, Exception error) where T : Interactor <TInner>
{
while (!interactors.IsEmpty)
{
interactors.DequeueHead().Fail(error ?? CreateInvalidCompletionException());
}
}
public void IsIBackoffRuns()
{
var poller = Substitute.For<IPoller<object>>();
var processor = Substitute.For<IProcessor<object>>();
var d = new Dequeue<object>(poller, processor);
Assert.IsNotNull(d as IDynamicRuns);
}
public void MaximumPeriodInSeconds()
{
var poller = Substitute.For <IPoller <object> >();
var processor = Substitute.For <IProcessor <object> >();
var d = new Dequeue <object>(poller, processor);
Assert.AreEqual(BaseTimes.DefaultMaximumTiming, d.MaximumPeriodInSeconds);
}
public void MinimumPeriodInSeconds()
{
var poller = Substitute.For <IPoller <object> >();
var processor = Substitute.For <IProcessor <object> >();
var d = new Dequeue <object>(poller, processor);
Assert.AreEqual(10, d.MinimumPeriodInSeconds);
}
public void DequeueCommandToJsonTest()
{
Dequeue dequeue = new Dequeue();
string json = dequeue.toJson();
Assert.IsNotNull(json);
Assert.AreEqual(json, "{\"Dequeue\":{}}");
}
static void Main(string[] args)
{
int[] integers = { 1, 2, 3, 4, 5 };
LinkedList<int> list = new LinkedList<int>(integers);
Stack<int> obj = new Stack<int>(list);
Console.WriteLine(obj.Contains(4));
Dequeue<int> newObj = new Dequeue<int>(list);
Console.WriteLine(obj.Contains(7));
}
static void Main(string[] args)
{
Dequeue<string> some = new Dequeue<string>();
some.AddToFront("aa");
some.AddToFront("bb");
some.AddToFront("cc");
Console.WriteLine(some.PeekFromEnd());
Console.WriteLine(some.PeekFromFront());
}
public void IsIBackoffRuns()
{
var poller = Substitute.For <IPoller <object> >();
var processor = Substitute.For <IProcessor <object> >();
var d = new Dequeue <object>(poller, processor);
Assert.IsNotNull(d as IDynamicRuns);
}
public async Task RunPollThrows()
{
var poller = Substitute.For <IPoller <object> >();
poller.Poll().ReturnsForAnyArgs <object>(x => { throw new ApplicationException(); });
var processor = Substitute.For <IProcessor <object> >();
var d = new Dequeue <object>(poller, processor);
Assert.That(async() => await d.Run(), Throws.TypeOf <ApplicationException>());
}
public void Start()
{
SuperScheduler = new SuperScheduler();
SuperScheduler.Initialize(MailSettings);
Dequeue = new Dequeue()
{
QueueSettings = QueueSettings,
MailSettings = MailSettings,
};
SuperScheduler.Start();
StartDequeueAsync();
}
public async Task Run()
{
var poller = Substitute.For<IPoller<object>>();
poller.Poll().Returns(Task.FromResult<IQueued<object>>(null));
var processor = Substitute.For<IProcessor<object>>();
var d = new Dequeue<object>(poller, processor);
var result = await d.Run();
Assert.IsFalse(result);
poller.Received().Poll();
}
public async Task Run()
{
var poller = Substitute.For <IPoller <object> >();
poller.Poll().Returns(Task.FromResult <IQueued <object> >(null));
var processor = Substitute.For <IProcessor <object> >();
var d = new Dequeue <object>(poller, processor);
var result = await d.Run();
Assert.IsFalse(result);
poller.Received().Poll();
}
static void Main(string[] args)
{
Dequeue<string> queue = new Dequeue<string>();
queue.AddToEnd("one");
queue.AddToEnd("two");
queue.AddToEnd("three");
queue.AddToFront("zero");
Console.WriteLine(queue.PeekFromFront());
Console.WriteLine(queue.PeekFromEnd());
if (queue.Contains("one"))
{
Console.WriteLine(true);
}
}
public async Task RunDataThrows()
{
var message = Substitute.For <IQueued <object> >();
message.Data().Returns(x => { throw new ApplicationException(); });
message.Complete();
var poller = Substitute.For <IPoller <object> >();
poller.Poll().Returns(Task.FromResult(message));
var processor = Substitute.For <IProcessor <object> >();
var d = new Dequeue <object>(poller, processor);
Assert.That(async() => await d.Run(), Throws.TypeOf <ApplicationException>());
}
public void EnqueueFirstShouldInsertAtBeginningOfQueue()
{
Dequeue <int> queue = new Dequeue <int>();
Assert.IsNotNull(queue, "Queue should not be null after construction");
Assert.AreEqual(0, queue.Count, "Count should be zero for new queue");
Assert.IsTrue(queue.IsEmpty, "Count should be considered empty");
queue.EnqueueFirst(17);
Assert.AreEqual(1, queue.Count, "Count should be 1 after enqueue");
Assert.IsFalse(queue.IsEmpty, "Queue should not be empty after enqueue");
Assert.AreEqual(17, queue.Peek(), "First item should be 17");
queue.EnqueueFirst(42);
Assert.AreEqual(2, queue.Count, "Count should be 2 after enqueue");
Assert.IsFalse(queue.IsEmpty, "Queue should not be empty after enqueue");
Assert.AreEqual(42, queue.Peek(), "First item should be 42");
}
public void RunProcessThrows()
{
var data = new object();
var message = Substitute.For <IQueued <object> >();
message.Data().Returns(Task.FromResult <object>(data));
var poller = Substitute.For <IPoller <object> >();
poller.Poll().Returns(Task.FromResult(message));
var processor = Substitute.For <IProcessor <object> >();
processor.Process(data).ReturnsForAnyArgs <object>(x => { throw new ApplicationException(); });
var d = new Dequeue <object>(poller, processor);
Assert.That(async() => await d.Run(), Throws.TypeOf <ApplicationException>());
}
public async Task RunDataNull()
{
var message = Substitute.For <IQueued <object> >();
message.Data().Returns(Task.FromResult <object>(null));
var poller = Substitute.For <IPoller <object> >();
poller.Poll().Returns(Task.FromResult(message));
var processor = Substitute.For <IProcessor <object> >();
var d = new Dequeue <object>(poller, processor);
var result = await d.Run();
Assert.IsTrue(result);
await poller.Received().Poll();
}
public void DequeueLastOnNonEmptyQueueShouldReturnLastElementAndDecreaseCountByOne()
{
Dequeue <int> queue = new Dequeue <int>();
queue.Enqueue(17);
queue.Enqueue(42);
Assert.AreEqual(2, queue.Count, "Count should be 2 after enqueue");
Assert.IsFalse(queue.IsEmpty, "Queue should not be empty after enqueue");
int value = queue.DequeueLast();
Assert.AreEqual(42, value, "dequeued value should be 42");
Assert.AreEqual(1, queue.Count, "Count should be 1 after dequeue");
Assert.IsFalse(queue.IsEmpty, "Queue should not be empty as count > 0");
value = queue.DequeueLast();
Assert.AreEqual(17, value, "dequeued value should be 17");
Assert.AreEqual(0, queue.Count, "Count should be 0 after dequeue");
Assert.IsTrue(queue.IsEmpty, "Queue should be empty as count = 0");
}
public void PeekLastOnNonEmptyQueueShouldReturnLastElementButNotChangeQueue()
{
Dequeue <int> queue = new Dequeue <int>();
queue.Enqueue(17);
int value = queue.PeekLast();
Assert.AreEqual(17, value, "Last value = 17");
Assert.AreEqual(1, queue.Count, "Count should be 1 after peek");
Assert.IsFalse(queue.IsEmpty, "Queue should not be empty as count > 0");
value = queue.PeekLast();
Assert.AreEqual(17, value, "Last value = 17");
Assert.AreEqual(1, queue.Count, "Count should be 1 after peek");
Assert.IsFalse(queue.IsEmpty, "Queue should not be empty as count > 0");
queue.Enqueue(42);
value = queue.PeekLast();
Assert.AreEqual(42, value, "Last value = 42");
Assert.AreEqual(2, queue.Count, "Count should be 2 after peek");
Assert.IsFalse(queue.IsEmpty, "Queue should not be empty as count > 0");
}
public void SetUp()
{
dq = new Dequeue <int>(4);
}
public void SetUp()
{
dq = new Dequeue<int>(4);
}
private List <ObservablePropertyStateChangedArgs> DequeueProperties()
{
return(Dequeue(propertyStateChangedQueue, x => (x.ObservableProperty, x.PropertyInfo.Name)));
}
public async Task RunProcessThrows()
{
var data = new object();
var message = Substitute.For<IQueued<object>>();
message.Data().Returns(Task.FromResult<object>(data));
var poller = Substitute.For<IPoller<object>>();
poller.Poll().Returns(Task.FromResult(message));
var processor = Substitute.For<IProcessor<object>>();
processor.Process(data).Returns(x => { throw new ApplicationException(); });
var d = new Dequeue<object>(poller, processor);
await d.Run();
}
public async Task RunPollThrows()
{
var poller = Substitute.For<IPoller<object>>();
poller.Poll().Returns(x => { throw new ApplicationException(); });
var processor = Substitute.For<IProcessor<object>>();
var d = new Dequeue<object>(poller, processor);
await d.Run();
}
public void PeekLastOnEmptyQueueShouldThrowException()
{
Dequeue <int> queue = new Dequeue <int>();
_ = Assert.Throws(typeof(QueueUnderflowException), () => queue.PeekLast(), "Peek on empty queue should throw exception");
}
public async void StartDequeueAsync()
{
await Dequeue.StartAsync();
}
/// <summary>
/// Create
/// </summary>
/// <param name="lexerConstants">Lexer constants / config</param>
/// <param name="errorListener">error listener for error capturing</param>
public Tokenizer(IEPLLexerConstants lexerConstants, IErrorListener errorListener)
{
tokens = new Dequeue <RawToken>();
this.lexerConstants = lexerConstants;
this.errorListener = errorListener;
}
public async Task Run()
{
var data = new object();
var message = Substitute.For<IQueued<object>>();
message.Data().Returns(Task.FromResult(data));
message.Complete();
var poller = Substitute.For<IPoller<object>>();
poller.Poll().Returns(Task.FromResult(message));
var processor = Substitute.For<IProcessor<object>>();
processor.Process(data).Returns(Task.FromResult(true));
var d = new Dequeue<object>(poller, processor);
var result = await d.Run();
Assert.IsTrue(result);
message.Received().Data();
message.Received().Complete();
poller.Received().Poll();
processor.Received().Process(data);
}
public void Dispose()
{
SuperScheduler?.Shutdown();
Dequeue.Dispose();
}
