public void ObserveTest13()
{
CoapConfig clientConfig = new CoapConfig()
{
NotificationReregistrationBackoff = 0
};
Pump = new MockMessagePump();
IEndPoint clientEndpoint = Pump.AddEndPoint("Client1", MockMessagePump.ClientAddress, clientConfig, new Type[] { typeof(ObserveLayer) });
clientEndpoint.Start();
CreateServer();
CoapClient coapClient = new CoapClient
{
EndPoint = clientEndpoint,
Uri = new Uri($"coap://{MockMessagePump.ServerAddress}{_resource.Uri}"),
Timeout = 0
};
Response lastResponse = null;
int count = 1;
_resource.UpdateContent($"First string {count - 1}");
AutoResetEvent trigger = new AutoResetEvent(false);
CoapObserveRelation relation = coapClient.ObserveAsync(
(r) => {
lastResponse = r;
trigger.Set();
});
AutoResetEvent reregistered = new AutoResetEvent(false);
relation.Request.Reregistering += (a, b) => {
reregistered.Set();
b.RefreshRequest.IsCancelled = true;
};
byte[] tokenBytes = relation.Request.Token;
bool dataSent = false;
int requestNo = 0;
int observerNo = 1;
while (true)
{
Thread.Sleep(1);
if (Pump.Queue.Count > 0)
{
MockQueueItem item = Pump.Queue.Peek();
switch (item.ItemType)
{
case MockQueueItem.QueueType.NetworkSend:
if (item.Request != null)
{
if (tokenBytes == null)
{
tokenBytes = relation.Request.Token;
}
Assert.IsTrue(item.Request.HasOption(OptionType.Observe));
Assert.AreEqual(0, item.Request.Observe);
CollectionAssert.AreEqual(tokenBytes, item.Request.Token);
switch (requestNo)
{
case 0:
Assert.IsFalse(item.Request.HasOption(OptionType.ETag));
break;
case 1:
case 2:
Assert.AreEqual(4, item.Request.ETags.ToArray().Length);
break;
}
requestNo += 1;
Debug.WriteLine($"Request: {item.Request}");
}
else if (item.Response != null)
{
Assert.IsTrue(item.Response.HasOption(OptionType.Observe));
Assert.AreEqual(observerNo, item.Response.Observe);
CollectionAssert.AreEqual(tokenBytes, item.Response.Token);
dataSent = true;
Debug.WriteLine($"Response: {item.Response} {item.Response.Observe}");
}
else
{
Assert.Fail();
}
break;
}
Pump.Pump();
}
else if (dataSent)
{
Assert.IsTrue(trigger.WaitOne(1000));
Assert.IsTrue(lastResponse.HasOption(OptionType.Observe));
Assert.AreEqual(observerNo, lastResponse.Observe);
dataSent = false;
lastResponse = null;
if (count == 4)
{
relation.UpdateETags(new byte[][] { new byte[] { 1 }, new byte[] { 3 }, new byte[] { 5 }, new byte[] { 7 } });
count += 1;
}
else if (count == 8)
{
Assert.IsTrue(reregistered.WaitOne(20 * 1000));
count += 1;
}
if (count == 9)
{
count += 1;
_resource.UpdateContent($"New string {count}");
observerNo += 1;
count += 1;
}
else if (count < 12)
{
_resource.UpdateContent($"New string {count}");
count += 1;
observerNo += 1;
}
else
{
break;
}
}
}
Assert.AreEqual(12, count);
}
public void ObserveTest1()
{
CoapConfig clientConfig = new CoapConfig();
Pump = new MockMessagePump();
IEndPoint clientEndpoint = Pump.AddEndPoint("Client1", MockMessagePump.ClientAddress, clientConfig, new Type[] { typeof(ObserveLayer) });
clientEndpoint.Start();
CreateServer();
CoapClient coapClient = new CoapClient {
EndPoint = clientEndpoint,
Uri = new Uri($"coap://{MockMessagePump.ServerAddress}{_resource.Uri}"),
Timeout = 0
};
Response lastResponse = null;
int count = 1;
_resource.UpdateContent($"First string {count-1}");
AutoResetEvent trigger = new AutoResetEvent(false);
CoapObserveRelation relation = coapClient.ObserveAsync(
(r) => {
lastResponse = r;
trigger.Set();
});
byte[] tokenBytes = relation.Request.Token;
bool dataSent = false;
while (true)
{
Thread.Sleep(1);
if (Pump.Queue.Count > 0)
{
MockQueueItem item = Pump.Queue.Peek();
switch (item.ItemType)
{
case MockQueueItem.QueueType.NetworkSend:
if (item.Request != null)
{
if (tokenBytes == null)
{
tokenBytes = relation.Request.Token;
}
Assert.IsTrue(item.Request.HasOption(OptionType.Observe));
Assert.AreEqual(0, item.Request.Observe);
CollectionAssert.AreEqual(tokenBytes, item.Request.Token);
}
else if (item.Response != null)
{
Assert.IsTrue(item.Response.HasOption(OptionType.Observe));
Assert.AreEqual(count, item.Response.Observe);
CollectionAssert.AreEqual(tokenBytes, item.Response.Token);
dataSent = true;
}
else
{
Assert.Fail();
}
break;
}
Pump.Pump();
}
else if (dataSent)
{
Assert.IsTrue(trigger.WaitOne(1000));
Assert.IsTrue(lastResponse.HasOption(OptionType.Observe));
Assert.AreEqual(count, lastResponse.Observe);
dataSent = false;
lastResponse = null;
if (count < 5)
{
_resource.UpdateContent($"New string {count}");
count += 1;
}
else
{
break;
}
}
}
Assert.AreEqual(5, count);
}
public void ObserveTest3()
{
CoapConfig clientConfig = new CoapConfig()
{
MaxRetransmit = 0
};
LogManager.Level = LogLevel.Debug;
Pump = new MockMessagePump();
IEndPoint clientEndpoint = Pump.AddEndPoint("Client1", MockMessagePump.ClientAddress, clientConfig, new Type[] { typeof(ObserveLayer), typeof(TokenLayer), typeof(ReliabilityLayer) });
clientEndpoint.Start();
CreateServer();
_config.NonTimeout = 100; // Change this value up - at 10 it cleans up the NON before the RST has a chance to get back.
CoapClient coapClient = new CoapClient {
EndPoint = clientEndpoint,
Uri = new Uri($"coap://{MockMessagePump.ServerAddress}{_resource.Uri}"),
Timeout = 0
};
Response lastResponse = null;
int count = 1;
_resource.UpdateContent($"First string {count - 1}");
AutoResetEvent trigger = new AutoResetEvent(false);
CoapObserveRelation relation = coapClient.ObserveAsync(
(r) => {
lastResponse = r;
trigger.Set();
});
int emptyCount = 0;
bool dataSent = false;
byte[] tokenBytes = relation.Request.Token;
while (true)
{
Thread.Sleep(1);
if (Pump.Queue.Count > 0)
{
MockQueueItem item = Pump.Queue.Peek();
switch (item.ItemType)
{
case MockQueueItem.QueueType.NetworkSend:
if (item.Request != null)
{
Debug.WriteLine($"Request: {item.Request}");
if (tokenBytes == null)
{
tokenBytes = relation.Request.Token;
}
Assert.IsTrue(item.Request.HasOption(OptionType.Observe));
Assert.AreEqual(0, item.Request.Observe);
CollectionAssert.AreEqual(tokenBytes, item.Request.Token);
}
else if (item.Response != null)
{
Debug.WriteLine($"Response: {item.Response}");
Assert.IsTrue(item.Response.HasOption(OptionType.Observe));
Assert.AreEqual(count, item.Response.Observe);
CollectionAssert.AreEqual(tokenBytes, item.Response.Token);
dataSent = true;
}
else
{
Debug.WriteLine($"RST: {item.EmptyMessage}");
emptyCount += 1;
dataSent = true;
}
break;
}
Pump.Pump();
}
else if (dataSent)
{
dataSent = false;
if (count >= 3)
{
Assert.IsNull(lastResponse);
}
else
{
Assert.IsTrue(trigger.WaitOne(10 * 1000));
Assert.IsNotNull(lastResponse);
Assert.IsTrue(lastResponse.HasOption(OptionType.Observe));
Assert.AreEqual(count, lastResponse.Observe);
lastResponse = null;
}
if (count < 5)
{
_resource.UpdateContent($"New string {count}");
count += 1;
if (count == 3)
{
relation.ReactiveCancel();
}
}
else
{
break;
}
}
else if (count == 5)
{
break;
}
else if (emptyCount != 0)
{
_resource.UpdateContent($"New string {count}");
count += 1;
}
}
Assert.AreEqual(1, emptyCount);
Assert.AreEqual(5, count);
}
public void ObserveTest2()
{
CoapConfig clientConfig = new CoapConfig()
{
NotificationReregistrationBackoff = 0
};
Pump = new MockMessagePump();
IEndPoint clientEndpoint = Pump.AddEndPoint("Client1", MockMessagePump.ClientAddress, clientConfig, new Type[] { typeof(ObserveLayer) });
clientEndpoint.Start();
CreateServer();
CoapClient coapClient = new CoapClient {
EndPoint = clientEndpoint,
Uri = new Uri($"coap://{MockMessagePump.ServerAddress}{_resource.Uri}"),
Timeout = 0
};
Response lastResponse = null;
int count = 1;
int clientObserveNo = 0;
_resource.UpdateContent($"First string {count - 1}");
AutoResetEvent trigger = new AutoResetEvent(false);
CoapObserveRelation relation = coapClient.ObserveAsync(
(r) => {
lastResponse = r;
trigger.Set();
});
AutoResetEvent reregistered = new AutoResetEvent(false);
relation.Request.Reregistering += (a, b) => {
reregistered.Set();
};
bool dataSent = false;
byte[] tokenBytes = relation.Request.Token;
while (true)
{
Thread.Sleep(1);
if (Pump.Queue.Count > 0)
{
MockQueueItem item = Pump.Queue.Peek();
switch (item.ItemType)
{
case MockQueueItem.QueueType.NetworkSend:
if (item.Request != null)
{
if (tokenBytes == null)
{
tokenBytes = relation.Request.Token;
}
Assert.IsTrue(item.Request.HasOption(OptionType.Observe));
Assert.AreEqual(clientObserveNo, item.Request.Observe);
CollectionAssert.AreEqual(tokenBytes, item.Request.Token);
clientObserveNo += 1;
}
else if (item.Response != null)
{
if (count < 4)
{
Assert.IsTrue(item.Response.HasOption(OptionType.Observe));
Assert.AreEqual(count, item.Response.Observe);
}
else
{
// Assert.IsFalse(item.Response.HasOption(OptionType.Observe));
}
CollectionAssert.AreEqual(tokenBytes, item.Response.Token);
dataSent = true;
}
else
{
Assert.Fail();
}
break;
}
Pump.Pump();
}
else if (dataSent)
{
dataSent = false;
if (count > 4)
{
Assert.IsNull(lastResponse);
}
else
{
Assert.IsTrue(trigger.WaitOne(1000));
Assert.IsNotNull(lastResponse);
if (count == 4)
{
Assert.IsFalse(lastResponse.HasOption(OptionType.Observe));
}
else
{
Assert.IsTrue(lastResponse.HasOption(OptionType.Observe));
Assert.AreEqual(count, lastResponse.Observe);
}
lastResponse = null;
}
if (count < 5)
{
if (count == 3)
{
relation.ProactiveCancel();
_resource.UpdateContent($"New string {count}");
}
else
{
_resource.UpdateContent($"New string {count}");
}
count += 1;
}
else
{
break;
}
}
else if (count == 5)
{
break;
}
}
Assert.AreEqual(2, clientObserveNo);
Assert.AreEqual(5, count);
// Total # of seconds is MaxAge = 1 + backoff = 0 + random(2, 15)
Assert.IsFalse(reregistered.WaitOne(17 * 1000));
}
private void CommonTestCode(Method method, bool longRequest, bool longResponse, int expectedClient, int expectedServer)
{
string requestText = null;
byte[] observeToken = new byte[] { 0xa, 0xa, 0xa };
int observeNum = 0;
string[] currentResourceContent = new string[2];
Type[] layerTypes = new Type[] { typeof(BlockwiseLayer) };
MockMessagePump pump = new MockMessagePump(layerTypes, ClientConfig, ServerConfig);
Request r = new Request(method);
if (method == Method.POST)
{
requestText = longRequest ? LongPostRequest : ShortPostRequest;
currentResourceContent[0] = longResponse ? LongPostResponse : ShortPostReponse;
r.PayloadString = requestText;
}
else
{
currentResourceContent[0] = longResponse ? LongGetResponse : ShortGetResponse;
if (Observe)
{
r.Observe = 1;
r.Token = observeToken;
}
}
pump.SendRequest(r);
if (Parallel)
{
Request r2 = new Request(method)
{
UriPath = "/resource2"
};
currentResourceContent[1] = longResponse ? LongGetResponse.Replace("get ", "getA") : ShortGetResponse + "P";
pump.SendRequest(r2);
}
int clientCount = 0;
int serverCount = 0;
int success = 0;
Exchange observeExchange = null;
while (pump.Pump())
{
MockQueueItem item = pump.Queue.Peek();
switch (item.ItemType)
{
// Check conditions of the request when ready to transmit it on the wire
case MockQueueItem.QueueType.ClientSendRequestNetwork:
if (Observe)
{
if (item.Request.HasOption(OptionType.Observe))
{
Assert.IsFalse(item.Request.HasOption(OptionType.Block2));
}
else
{
Assert.IsTrue(item.Request.Block2.NUM > 0);
}
}
clientCount += 1;
break;
// Check conditions of the response when ready to transmit it on the wire
case MockQueueItem.QueueType.ServerSendResponseNetwork:
if (Observe)
{
if (item.Response.HasOption(OptionType.Observe))
{
Assert.AreEqual(0, item.Response.Block2.NUM);
CollectionAssert.AreEqual(observeToken, item.Response.Token);
}
else
{
Assert.IsTrue(item.Response.Block2.NUM > 0);
CollectionAssert.AreNotEqual(observeToken, item.Response.Token);
}
}
serverCount += 1;
break;
// Server Resource is going to respond
case MockQueueItem.QueueType.ServerSendRequest:
pump.Queue.Dequeue();
if (method == Method.POST)
{
Assert.AreEqual(requestText, item.Request.PayloadString);
}
else
{
Assert.AreEqual(0, item.Request.PayloadSize);
}
Response s = new Response(StatusCode.Content);
s.PayloadString = currentResourceContent[0];
if (Parallel && item.Request.UriPath == "/resource2")
{
s.PayloadString = currentResourceContent[1];
}
if (Observe && item.Request.HasOption(OptionType.Observe))
{
s.Observe = 3;
observeExchange = item.Exchange;
s.Type = MessageType.NON;
}
item.Exchange.EndPoint.SendResponse(item.Exchange, s);
break;
case MockQueueItem.QueueType.ClientSendResponse:
pump.Queue.Dequeue();
if (Parallel && item.Exchange.Request.UriPath == "/resource2")
{
Assert.AreEqual(currentResourceContent[1], item.Response.PayloadString);
currentResourceContent[1] = currentResourceContent[0].Replace("get ", "get9");
}
else
{
Assert.AreEqual(currentResourceContent[0], item.Response.PayloadString);
currentResourceContent[0] = currentResourceContent[0].Replace("get ", "get3");
}
success += 1;
// For observe, send a second observe out
if (Observe && observeNum == 0)
{
observeNum += 1;
s = new Response(StatusCode.Content)
{
PayloadString = currentResourceContent[0],
Observe = 5,
Type = MessageType.NON
};
List <MockStack> stacks = pump.ServerStacks[MockMessagePump.ServerAddress];
stacks[0].MyEndPoint.SendResponse(observeExchange, s);
}
break;
}
}
if (Parallel || Observe)
{
Assert.AreEqual(2, success);
}
else
{
Assert.AreEqual(1, success);
}
Assert.AreEqual(expectedClient, clientCount);
Assert.AreEqual(expectedServer, serverCount);
}
public void BlockwiseTest7()
{
string response2 = LongGetResponse.Replace("get ", "get2");
string responseText;
Request r = new Request(Method.GET)
{
Destination = MockMessagePump.MulticastAddress
};
responseText = LongGetResponse;
MockMessagePump pump = new MockMessagePump(new Type[] { typeof(BlockwiseLayer) }, ClientConfig, ServerConfig);
int clientCount = 0;
int serverCount = 0;
int success = 0;
int sent = 0;
pump.SendRequest(r);
while (pump.Pump())
{
MockQueueItem item = pump.Queue.Peek();
switch (item.ItemType)
{
case MockQueueItem.QueueType.ClientSendRequestNetwork:
clientCount += 1;
break;
case MockQueueItem.QueueType.ServerSendResponseNetwork:
serverCount += 1;
break;
case MockQueueItem.QueueType.ServerSendRequest:
pump.Queue.Dequeue();
Assert.AreEqual(0, item.Request.PayloadSize);
Response s = new Response(StatusCode.Content);
s.PayloadString = (sent == 0) ? responseText : response2;
sent += 1;
item.Exchange.EndPoint.SendResponse(item.Exchange, s);
break;
case MockQueueItem.QueueType.ClientSendResponse:
pump.Queue.Dequeue();
if (item.Response.PayloadString == responseText)
{
Assert.IsTrue((success & 1) == 0);
success |= 1;
}
else if (item.Response.PayloadString == response2)
{
Assert.IsTrue((success & 2) == 0);
success |= 2;
}
else
{
Assert.Fail();
}
break;
}
}
Assert.AreEqual(3, success);
Assert.AreEqual(21, clientCount);
Assert.AreEqual(22, serverCount);
}