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 PopReceipt_ValidateInterfaces()
{
// Create a PopReceipt instances.
PopReceipt pr = new PopReceipt();
PopReceipt pr1 = new PopReceipt(sTestPopReceipt1);
PopReceipt emptyPR = new PopReceipt(sEmptyPopReceipt);
// Check that is the empty PopReceipt.
Assert.AreEqual <PopReceipt>(PopReceipt.Empty, pr);
// Validate that the instance can be case to each of the interfaces.
IFormattable iFormattable = pr as IFormattable;
Assert.IsNotNull(iFormattable);
IComparable <PopReceipt> iComparablePR = pr as IComparable <PopReceipt>;
Assert.IsNotNull(iComparablePR);
IEquatable <PopReceipt> iEquatablePR
= pr as IEquatable <PopReceipt>;
Assert.IsNotNull(iEquatablePR);
// Use each interface's methods.
string sPR = iFormattable.ToString();
Assert.AreEqual <string>(sEmptyPopReceipt, sPR);
Assert.AreEqual <int>(-1, iComparablePR.CompareTo(pr1));
Assert.IsFalse(iEquatablePR.Equals(pr1));
Assert.IsTrue(iEquatablePR.Equals(emptyPR));
}
public async Task <HttpResponseMessage> DeleteItemAsync(PopReceipt key)
{
// Delete the items with the passed keys, returning the items.
var result = await _qpo.DeleteItemAsync(key, CancellationToken.None);
return(Request.CreateResponse(HttpStatusCode.OK, result, new JsonMediaTypeFormatter()));
}
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_ToStringTests()
{
PopReceipt pr1 = new PopReceipt(sEmptyPopReceipt);
PopReceipt pr2 = new PopReceipt(sTestPopReceipt1);
Assert.AreEqual(sTestPopReceipt1, pr2.ToString(null));
Assert.AreEqual(sTestPopReceipt1, pr2.ToString(null, null));
Assert.AreEqual(sTestPopReceipt1.ToUpperInvariant(), pr2.ToString("G"));
Console.WriteLine(pr2.ToString());
Console.WriteLine(pr2.ToString("G"));
}
public void PopReceipt_EqualityTests()
{
PopReceipt pr1 = new PopReceipt(sTestPopReceipt1);
PopReceipt pr1a = new PopReceipt(sTestPopReceipt1);
PopReceipt pr2 = new PopReceipt(sTestPopReceipt2);
// Test Equals
Assert.IsFalse(pr1.Equals(null));
Assert.IsFalse(pr1.Equals(pr2));
Assert.IsFalse(pr1.Equals(sTestPopReceipt2));
Assert.IsFalse(pr1.Equals(PopReceipt.Empty));
// Test CompareTo
Assert.AreEqual(1, pr1.CompareTo((object)null));
Assert.AreEqual(1, pr1.CompareTo(pr2));
Assert.AreEqual(-1, pr2.CompareTo(pr1));
Assert.AreEqual(0, pr1.CompareTo(pr1a));
}
public void PopReceipt_ConstructorTests()
{
// Create default PopReceipt and ensure it is the empty one.
PopReceipt pr0 = new PopReceipt();
Assert.AreEqual(PopReceipt.Empty, pr0);
Assert.AreEqual(sEmptyPopReceipt, pr0.ToString());
// Create a PopReceipt based on a string and round trip it to ensure they are the same.
PopReceipt testPR2 = new PopReceipt(sTestPopReceipt1);
string sPR2 = testPR2.ToString("g");
Assert.AreEqual(sTestPopReceipt1, sPR2);
// Convert into a byte array.
byte[] bPR2 = testPR2.ToByteArray();
PopReceipt pr1 = new PopReceipt(bPR2);
Assert.AreEqual(testPR2, pr1);
Assert.AreEqual(sTestPopReceipt1, pr1.ToString());
}
public void PopReceipt_StaicOperationTests()
{
PopReceipt pr1 = new PopReceipt(sTestPopReceipt1);
PopReceipt pr1a = new PopReceipt(sTestPopReceipt1);
PopReceipt pr2 = new PopReceipt(sTestPopReceipt2);
PopReceipt pr3 = new PopReceipt(sTestPopReceipt3);
Assert.IsTrue(pr1a == pr1);
Assert.IsTrue(pr1 != pr2);
Assert.IsFalse(pr1a == pr2);
Assert.IsFalse(pr1a != pr1);
Assert.IsTrue(sTestPopReceipt1 == pr1);
Assert.IsTrue(sTestPopReceipt1 != pr2);
Assert.IsFalse(sTestPopReceipt1 == pr2);
Assert.IsFalse(sTestPopReceipt1 != pr1);
Assert.IsTrue(pr1a == sTestPopReceipt1);
Assert.IsTrue(pr1 != sTestPopReceipt2);
Assert.IsFalse(pr1a == sTestPopReceipt2);
Assert.IsFalse(pr1a != sTestPopReceipt1);
}
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);
}
public void PopReceipt_ToStringException()
{
PopReceipt pr = new PopReceipt(sTestPopReceipt1);
pr.ToString("u");
}
public void PopReceipt_StringConstructorException()
{
PopReceipt pr = new PopReceipt(sInvalidPopReceipt);
}
public void PopReceipt_ByteConstructorException()
{
byte[] b = new byte[15];
PopReceipt pr = new PopReceipt(b);
}
