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); }