public void TestClass_SerializeDeserialize_Test()
{
PopReceipt key = PopReceipt.NewPopReceipt(0);
QueueItem <TestClass> qitc1 = new QueueItem <TestClass>(key, 0, tc1, TimeSpan.FromSeconds(30), DateTimeOffset.UtcNow.Add(TimeSpan.FromSeconds(30)), DateTimeOffset.UtcNow.Add(TimeSpan.FromMinutes(20)), DateTimeOffset.UtcNow, 0);
QueueItem <TestClass> qitc2;
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms, Encoding.Default, true))
{
QueueItemSerializer <TestClass> serializer = new QueueItemSerializer <TestClass>();
serializer.Write(qitc1, writer);
}
ms.Seek(0, SeekOrigin.Begin);
using (BinaryReader reader = new BinaryReader(ms, Encoding.Default, true))
{
QueueItemSerializer <TestClass> serializer = new QueueItemSerializer <TestClass>();
qitc2 = serializer.Read(reader);
}
}
Assert.IsNotNull(qitc2);
Assert.AreEqual(qitc1.Key, qitc2.Key);
Assert.AreEqual(qitc1.Queue, qitc2.Queue);
Assert.AreEqual(qitc1.DequeueCount, qitc2.DequeueCount);
Assert.IsTrue(qitc1.EnqueueTime.Subtract(qitc2.EnqueueTime).TotalSeconds < 1, "EnqueueTime is off by more than 1 second.");
Assert.IsTrue(qitc1.ExpirationTime.Subtract(qitc2.ExpirationTime).TotalSeconds < 1, "ExpirationTime is off by more than 1 second.");
Assert.IsTrue(qitc1.LeasedUntil.Subtract(qitc2.LeasedUntil).TotalSeconds < 1, "LeasedUntil is off by more than 1 second.");
Assert.AreEqual(qitc1.LeaseDuration, qitc2.LeaseDuration);
Assert.AreEqual(qitc1.Item.d_value, qitc2.Item.d_value);
Assert.AreEqual(qitc1.Item.i_value, qitc2.Item.i_value);
Assert.AreEqual(qitc1.Item.s_value, qitc2.Item.s_value);
}
public void QueueItemEquals_Test()
{
PopReceipt key = PopReceipt.NewPopReceipt(0);
DateTimeOffset now = DateTimeOffset.UtcNow;
TimeSpan lease = TimeSpan.FromMinutes(2);
DateTimeOffset leaseUntil = now.Add(lease);
TimeSpan expiration = TimeSpan.FromMinutes(10);
DateTimeOffset expiresAt = now.Add(expiration);
// Create some items
QueueItem <TestClass> qi1 = new QueueItem <TestClass>(key, 3, tc1, lease, leaseUntil, expiresAt, now, 2);
QueueItem <TestClass> qi1a = new QueueItem <TestClass>(key, 3, tc1, lease, leaseUntil, expiresAt, now, 2);
QueueItem <TestClass> qi2 = new QueueItem <TestClass>(key, 3, tc2, lease, leaseUntil, expiresAt, now, 2);
object o = qi1a;
// Test Equals codes paths.
Assert.IsFalse(qi1.Equals(null));
Assert.IsFalse(qi1.Equals("Not equal string"));
Assert.IsTrue(qi1.Equals(o));
Assert.IsTrue(qi1.Equals(qi1a));
Assert.IsFalse(qi1.Equals(qi2));
// Test equals/not equals operators.
Assert.IsFalse(qi1 == qi2);
Assert.IsFalse(qi1 != qi1a);
Assert.IsTrue(qi1 != qi2);
Assert.IsTrue(qi1 == qi1a);
}
public void PopReceipt_NewPopReceiptTests()
{
const string spr1 = "0000000000000000000000000000000000000000000000000000000000000000";
const string spr2 = "00000000000000fe000000000000000000000000000000000000000000000000";
const string spr3 = "7fffffffffffffff000000000000000000000000000000000000000000000000";
PopReceipt pr = PopReceipt.NewPopReceipt(0);
Assert.AreEqual(0, pr.Partition);
Assert.AreNotEqual(spr1, pr.ToString());
Console.WriteLine(pr);
pr = PopReceipt.NewPopReceipt(254);
Assert.AreEqual(254, pr.Partition);
Assert.AreNotEqual(spr2, pr.ToString());
Console.WriteLine(pr);
pr = PopReceipt.NewPopReceipt(long.MaxValue);
Assert.AreEqual(long.MaxValue, pr.Partition);
Assert.AreNotEqual(spr3, pr.ToString());
Console.WriteLine(pr);
}
public void QueueItemConstructorTest()
{
PopReceipt key = PopReceipt.NewPopReceipt(0);
DateTimeOffset now = DateTimeOffset.UtcNow;
TimeSpan lease = TimeSpan.FromMinutes(2);
DateTimeOffset leaseUntil = now.Add(lease);
TimeSpan expiration = TimeSpan.FromMinutes(10);
DateTimeOffset expiresAt = now.Add(expiration);
// Priority, lease duration, lease date/time, expiration date/time, enqueue date/time, dequeue count and item.
QueueItem <TestClass> qi3 = new QueueItem <TestClass>(key, 3, tc2, lease, leaseUntil, expiresAt, now, 2);
Assert.IsNotNull(qi3);
Assert.AreEqual(key, qi3.Key);
Assert.AreEqual(3, qi3.Queue);
Assert.IsTrue(leaseUntil.Subtract(qi3.LeasedUntil).TotalSeconds < 1);
Assert.AreEqual(lease, qi3.LeaseDuration);
Assert.IsTrue(DateTimeOffset.UtcNow.Subtract(qi3.EnqueueTime).TotalSeconds < 1);
Assert.IsTrue(DateTimeOffset.UtcNow.Add(expiration).Subtract(qi3.ExpirationTime).TotalSeconds < 1);
Assert.AreEqual <int>(2, qi3.DequeueCount);
Assert.AreEqual(tc2, qi3.Item);
}
public void QueueItemValidateInterfaces()
{
// Create an empty QueueItem and compare it to the default.
QueueItem <TestClass> qiDefault = default(QueueItem <TestClass>);
Assert.IsTrue(QueueItem <TestClass> .Default.Equals(qiDefault));
// Create an initialized item.
PopReceipt key = PopReceipt.NewPopReceipt(0);
DateTimeOffset now = DateTimeOffset.UtcNow;
TimeSpan lease = TimeSpan.FromMinutes(2);
DateTimeOffset leaseUntil = now.Add(lease);
TimeSpan expiration = TimeSpan.FromMinutes(10);
DateTimeOffset expiresAt = now.Add(expiration);
// Validate the item can be cast to the supported interfaces.
QueueItem <TestClass> qi1 = new QueueItem <TestClass>(key, 3, tc2, lease, leaseUntil, expiresAt, now, 2);
IEquatable <QueueItem <TestClass> > ie = (IEquatable <QueueItem <TestClass> >)qi1;
Assert.IsNotNull(ie);
// and use the interfaces.
Assert.IsFalse(ie.Equals(qiDefault));
}
public void PopReceipt_NewPopoReceiptException()
{
PopReceipt.NewPopReceipt(-1);
}
