public void CanContains()
{
var q = new CappedQueue <int>(3);
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
q.Enqueue(4);
Assert.False(q.Contains(1));
Assert.True(q.Contains(2));
Assert.True(q.Contains(3));
Assert.True(q.Contains(4));
Assert.False(q.Contains(5));
var qq = new CappedQueue <string>(3);
qq.Enqueue("one");
qq.Enqueue("two");
qq.Enqueue(null);
Assert.True(qq.Contains("one"));
Assert.True(qq.Contains("two"));
Assert.True(qq.Contains(null));
Assert.False(qq.Contains("three"));
}
public void Foo2()
{
var queue = new CappedQueue<int>(5);
queue.Enqueue(10);
queue.Enqueue(20);
queue.Enqueue(30);
var average = queue.Average(x=>x);
}
public void Foo2()
{
var queue = new CappedQueue<int>(5);
queue.Enqueue(10);
queue.Enqueue(20);
queue.Enqueue(30);
var average = queue.Sum() / queue.Count();
}
public void Foo()
{
var queue = new CappedQueue<DateTime>(5);
queue.Enqueue(DateTime.Now); // each time the user press the key
queue.Enqueue(DateTime.Now); // each time the user press the key
queue.Enqueue(DateTime.Now); // each time the user press the key
TimeSpan diff = (queue.Last() / queue.Fisrt())/queue.Count();
}
public void CanCopyTo()
{
var q = new CappedQueue <int>(3);
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
var array = new int[5];
q.CopyTo(array, 2);
const int zero = default(int);
Assert.Equal(Seq(zero, zero, 1, 2, 3), array);
}
public void CanClear()
{
var q = new CappedQueue <int>(3);
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
q.Enqueue(4);
q.Clear();
q.Clear(); // idempotent
Assert.Equal(0, q.Count);
Assert.Equal(3, q.Capacity);
}
/// <summary>
/// Invoked when IP data is being delivered through the specified interface.
/// </summary>
/// <param name="ifc">The interface through which the data was received.</param>
/// <param name="data">A sequence of bytes received.</param>
/// <exception cref="ArgumentNullException">Thrown if either argument
/// is null.</exception>
void OnIpInput(Interface ifc, byte[] data)
{
ifc.ThrowIfNull("ifc");
data.ThrowIfNull("data");
WriteLine(ifc.FullName + " has received new IP packet.");
try {
var packet = IpPacket.Deserialize(data);
// This method is called in "interrupt context" and can execute
// on behalf of different NIC's simultaneously. The IP stack
// is usually single threaded however, so incoming packets are queued
// globally and processed sequentially.
if (inputQueue.Count == 0)
{
Simulation.Callback(nodalProcessingDelay, ProcessPackets);
}
try {
// Enqueue the packet and the interface through which it was
// received.
inputQueue.Enqueue(new Tuple <IpPacket, Interface>(packet, ifc));
} catch (InvalidOperationException) {
// If the host's input queue is full, we must drop the packet.
WriteLine("IP input queue overflow, dropping packet.");
// Send a "Source Quench" ICMP to the packet's originator.
SendIcmp(ifc, packet.Source, IcmpPacket.SourceQuench(packet));
}
} catch (SerializationException) {
WriteLine(ifc.FullName + " has detected a bad checksum, " +
"discarding IP packet.");
}
}
public void CanEnumerate()
{
var q = new CappedQueue <int>(3);
Assert.Empty(q);
q.Enqueue(1);
Assert.Single(q, 1);
q.Enqueue(2);
Assert.Equal(Seq(1, 2), q);
q.Enqueue(3);
Assert.Equal(Seq(1, 2, 3), q);
q.Enqueue(4);
Assert.Equal(Seq(2, 3, 4), q);
}
public void CanEnqueue()
{
var q1 = new CappedQueue <int>(1);
q1.Enqueue(1);
Assert.Equal(1, q1.Count);
Assert.Equal(1, q1.GetElement(0));
q1.Enqueue(2);
Assert.Equal(1, q1.Count);
Assert.Equal(2, q1.GetElement(0));
var q2 = new CappedQueue <int>(2);
q2.Enqueue(1);
q2.Enqueue(2);
q2.Enqueue(3);
Assert.Equal(2, q2.Count);
Assert.Equal(2, q2.GetElement(0));
Assert.Equal(3, q2.GetElement(1));
}
public void CanSetCapacity()
{
var q = new CappedQueue <int>(1);
q.Capacity = 2; // enlarge empty queue
Assert.Equal(0, q.Count);
Assert.Equal(2, q.Capacity);
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
Assert.Equal(2, q.GetElement(0));
Assert.Equal(3, q.GetElement(1));
q.Capacity = 3; // enlarge
Assert.Equal(3, q.Capacity);
Assert.Equal(2, q.Count);
Assert.Equal(2, q.GetElement(0));
Assert.Equal(3, q.GetElement(1));
q.Enqueue(4);
Assert.Equal(3, q.Count);
Assert.Equal(2, q.GetElement(0));
Assert.Equal(3, q.GetElement(1));
Assert.Equal(4, q.GetElement(2));
q.Capacity = 2; // shrink
Assert.Equal(2, q.Capacity);
Assert.Equal(2, q.Count);
Assert.Equal(3, q.GetElement(0));
Assert.Equal(4, q.GetElement(1));
}
/// <summary>
/// Wraps the specified data into an Ethernet frame and queues it
/// for transmission.
/// </summary>
/// <param name="destination">The MAC address of the destination
/// host.</param>
/// <param name="data">The data to transmit as part of the frame's
/// payload.</param>
/// <param name="type">The type of the data.</param>
public override void Output(MacAddress destination, byte[] data,
EtherType type = EtherType.IPv4)
{
destination.ThrowIfNull("destination");
data.ThrowIfNull("data");
// Start emptying the FIFO, if we're not already doing it.
if (emptyingFifo == false)
{
Simulation.Callback(0, EmptySendFifo);
}
// Enqueue the data.
sendFifo.Enqueue(new Frame(destination, MacAddress, data, type));
}
/// <summary>
/// Attempts to retrieve a random child among all children nodes and processes it.
/// This class has been somewhat tweaked for the context of this assignment.
/// It has a capped queue data structure in it which is defined as memory. Once a child node
/// is visited, the memory enqueues the child node's professor and if the memory is ever at its capacity
/// then the first thing inserted into it is popped of the queue, so that it can never hold memory
/// beyond its capacity.
/// </summary>
/// <returns></returns>
public override BehaviorResult Process()
{
switch (_currentRandom.Process())
{
case BehaviorResult.FAIL:
_memory.Enqueue(_currentRandom.Professor);
Agent.Memory = _memory.Q.ToList();
Result = BehaviorResult.FAIL;
return(Result);
case BehaviorResult.SUCCESS:
_memory.Enqueue(_currentRandom.Professor);
Agent.Memory = _memory.Q.ToList();
Result = BehaviorResult.SUCCESS;
return(Result);
case BehaviorResult.RUNNING:
Result = BehaviorResult.RUNNING;
return(Result);
}
Result = BehaviorResult.RUNNING;
return(Result);
}
