public void Qos_Reserved1()
{
var headerBytes = GetHeaderBytes(6, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.Equal <MqttQos>(MqttQos.Reserved1, header.Qos);
}
public void HeaderRoundtrip()
{
MqttHeader inputHeader = new MqttHeader()
{
Duplicate = true,
Retain = false,
MessageSize = 1,
MessageType = MqttMessageType.Connect,
Qos = MqttQos.AtLeastOnce
};
MqttHeader outputHeader;
using (MemoryStream stream = new MemoryStream())
{
inputHeader.WriteTo(0, stream);
// the stream will be chock full-o-bytes, rewind it so we can read it back
stream.Seek(0, SeekOrigin.Begin);
outputHeader = new MqttHeader(stream);
}
Assert.Equal <bool>(inputHeader.Duplicate, outputHeader.Duplicate);
Assert.Equal <bool>(inputHeader.Retain, outputHeader.Retain);
Assert.Equal <MqttQos>(inputHeader.Qos, outputHeader.Qos);
Assert.Equal <MqttMessageType>(inputHeader.MessageType, outputHeader.MessageType);
}
public void MessageType_Disconnect()
{
var headerBytes = GetHeaderBytes(14 << 4, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.Equal <MqttMessageType>(MqttMessageType.Disconnect, header.MessageType);
}
public void Duplicate_True()
{
var headerBytes = GetHeaderBytes(8, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.True(header.Duplicate);
}
public void MessageType_UnsubsriptionAck()
{
var headerBytes = GetHeaderBytes(11 << 4, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.Equal <MqttMessageType>(MqttMessageType.UnsubscribeAck, header.MessageType);
}
public void Qos_AtLeastOnce()
{
var headerBytes = GetHeaderBytes(2, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.Equal <MqttQos>(MqttQos.AtLeastOnce, header.Qos);
}
public void MessageType_PublishComplete()
{
var headerBytes = GetHeaderBytes(7 << 4, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.Equal <MqttMessageType>(MqttMessageType.PublishComplete, header.MessageType);
}
public void CorruptHeader_InvalidMessageSize()
{
MqttHeader inputHeader = new MqttHeader()
{
Duplicate = true,
Retain = false,
MessageSize = 268435455, // the max message size, which we will fudge later in the test
MessageType = MqttMessageType.Connect,
Qos = MqttQos.AtLeastOnce
};
MqttHeader outputHeader;
using (MemoryStream stream = new MemoryStream())
{
inputHeader.WriteTo(268435455, stream);
// fudge the header by making the last bit of the 4th message size byte a 1, therefore making the header
// invalid because the last bit of the 4th size byte should always be 0 (according to the spec). It's how
// we know to stop processing the header when reading a full message).
stream.Seek(4, SeekOrigin.Begin);
byte existingByte = (byte)stream.ReadByte();
stream.Seek(4, SeekOrigin.Begin);
stream.WriteByte((byte)(existingByte | 0xFF));
stream.Seek(0, SeekOrigin.Begin);
Assert.Throws <InvalidHeaderException>(() => outputHeader = new MqttHeader(stream));
}
}
private void DataArrivedOnConnection(IAsyncResult result)
{
int bytesRead = networkStream.EndRead(result);
Collection <byte> messageBytes = new Collection <byte>();
messageBytes.Add(headerBytes[0]);
Collection <byte> lengthBytes = MqttHeader.ReadLengthBytes(networkStream);
int length = MqttHeader.CalculateLength(lengthBytes);
messageBytes.AddRange <byte>(lengthBytes);
// we've got the bytes that make up the header, inc the size, read the .
var remainingMessage = new byte[length];
int messageBytesRead = networkStream.Read(remainingMessage, 0, length);
if (messageBytesRead < length)
{
// we haven't got all the message, need to figure oput what to do.
}
messageBytes.AddRange <byte>(remainingMessage);
networkStream.BeginRead(headerBytes, 0, 1, DataArrivedOnConnection, null);
}
public void MessageType_PublishReceived()
{
var headerBytes = GetHeaderBytes(5 << 4, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.Equal <MqttMessageType>(MqttMessageType.PublishReceived, header.MessageType);
}
public void MessageType_Reserved1()
{
var headerBytes = GetHeaderBytes(0, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.Equal <MqttMessageType>(MqttMessageType.Reserved1, header.MessageType);
}
public void MessageType_ConnectAck()
{
var headerBytes = GetHeaderBytes(2 << 4, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.Equal <MqttMessageType>(MqttMessageType.ConnectAck, header.MessageType);
}
public void MessageType_PublishAck()
{
var headerBytes = GetHeaderBytes(4 << 4, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.Equal <MqttMessageType>(MqttMessageType.PublishAck, header.MessageType);
}
public void Retain_True()
{
var headerBytes = GetHeaderBytes(1, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.True(header.Retain);
}
public void MessageType_Subscribe()
{
var headerBytes = GetHeaderBytes(8 << 4, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.Equal <MqttMessageType>(MqttMessageType.Subscribe, header.MessageType);
}
public void Retain_False()
{
var headerBytes = GetHeaderBytes(0, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.False(header.Retain);
}
public void MessageType_PingResponse()
{
var headerBytes = GetHeaderBytes(13 << 4, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.Equal <MqttMessageType>(MqttMessageType.PingResponse, header.MessageType);
}
public void Qos_ExactlyOnce()
{
var headerBytes = GetHeaderBytes(4, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.Equal <MqttQos>(MqttQos.ExactlyOnce, header.Qos);
}
public void Duplicate_False()
{
var headerBytes = GetHeaderBytes(0, 0);
MqttHeader header = GetMqttHeader(headerBytes);
Assert.False(header.Duplicate);
}
/// <summary>
/// Test helper method to call Get Remaining Bytes with a specific value
/// </summary>
/// <param name="value">The value.</param>
/// <returns></returns>
private List <byte> CallGetRemainingBytesWithValue(int value)
{
// validates a payload size of a single byte using the example values supplied in the MQTT spec
MqttHeader header = new MqttHeader();
header.MessageSize = value;
MethodInfo mi = typeof(MqttHeader).GetMethod("GetRemainingLengthBytes", ReflectionBindingConstants.NonpublicMethod);
return((List <byte>)mi.Invoke(header, null));
}
public void CorruptHeader_Undersize()
{
MqttHeader outputHeader;
using (MemoryStream stream = new MemoryStream())
{
stream.WriteByte(0);
stream.Seek(0, SeekOrigin.Begin);
Assert.Throws <InvalidHeaderException>(() => outputHeader = new MqttHeader(stream));
}
}
public void UseAll()
{
MqttHeader header
= new MqttHeader()
.AsType(MqttMessageType.PublishComplete)
.WithQos(MqttQos.AtMostOnce)
.IsDuplicate()
.ShouldBeRetained();
Assert.Equal <MqttMessageType>(MqttMessageType.PublishComplete, header.MessageType);
Assert.True(header.Retain);
Assert.Equal <MqttQos>(MqttQos.AtMostOnce, header.Qos);
Assert.True(header.Duplicate);
}
public void SettingDuplicate()
{
MqttHeader header = new MqttHeader().IsDuplicate();
Assert.True(header.Duplicate);
}
public void SettingMessageType()
{
MqttHeader header = new MqttHeader().AsType(MqttMessageType.PublishComplete);
Assert.Equal <MqttMessageType>(MqttMessageType.PublishComplete, header.MessageType);
}
public void SettingRetain()
{
MqttHeader header = new MqttHeader().ShouldBeRetained();
Assert.True(header.Retain);
}
public void SettingQos()
{
MqttHeader header = new MqttHeader().WithQos(MqttQos.AtMostOnce);
Assert.Equal <MqttQos>(MqttQos.AtMostOnce, header.Qos);
}
public void PayloadSizeOutOfLowerRange()
{
MqttHeader header = new MqttHeader();
Assert.Throws <InvalidPayloadSizeException>(() => header.MessageSize = -1);
}
