From c1e8af61510397a12c4a5885c74cdf7faf41cba5 Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Tue, 9 Aug 2022 16:30:39 -0400
Subject: Rough start to unit testing

---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 24 ++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
new file mode 100644
index 000000000..8c85344db
--- /dev/null
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -0,0 +1,24 @@
+//
+//  SDLProtocolReceivedMessageProcessorSpec.m
+//  SmartDeviceLinkTests
+//
+//  Created by George Miller on 8/9/22.
+//  Copyright © 2022 smartdevicelink. All rights reserved.
+//
+
+#import <Quick/Quick.h>
+#import <Nimble/Nimble.h>
+
+#import <Foundation/Foundation.h>
+
+
+
+QuickSpecBegin(SDLProtocolReceivedMessageProcessorSpec)
+
+describe(@"Awesome Test", ^{
+    it(@"Should Be Awesome", ^{
+        expect(1 + 1).to(equal(2));
+    });
+});
+
+QuickSpecEnd
-- 
cgit v1.2.1


From c29471855d8187b613d2e5e54a0d1cdb7d3a4163 Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Thu, 11 Aug 2022 13:06:15 -0400
Subject: rough draft for one test.

theoretically you copy/pasta to make the other tests.
---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 55 ++++++++++++++++++++--
 1 file changed, 50 insertions(+), 5 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 8c85344db..4e86487f1 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -6,19 +6,64 @@
 //  Copyright © 2022 smartdevicelink. All rights reserved.
 //
 
+#import <Foundation/Foundation.h>
+
 #import <Quick/Quick.h>
 #import <Nimble/Nimble.h>
 
-#import <Foundation/Foundation.h>
-
+#import "SDLProtocol.h"
+#import "SDLProtocolReceivedMessageProcessor.h"
+#import "SDLV2ProtocolHeader.h"
+#import "SDLV2ProtocolMessage.h"
 
 
 QuickSpecBegin(SDLProtocolReceivedMessageProcessorSpec)
 
-describe(@"Awesome Test", ^{
-    it(@"Should Be Awesome", ^{
-        expect(1 + 1).to(equal(2));
+describe(@"State Machine START_STATE", ^{
+    
+    __block SDLProtocolReceivedMessageProcessor *testReceiveProcessor;
+    __block SDLProtocolMessage *testMessage;
+    __block SDLProtocolHeader *testHeader;
+    __block NSMutableData *testPayloadBuffer;
+    __block NSMutableData *testHeaderBuffer;
+    
+    beforeEach(^{
+        testReceiveProcessor = [[SDLProtocolReceivedMessageProcessor alloc] init];
+    });
+    
+    it(@"can pass a good message", ^{
+        // setup the test
+        UInt8 version = 1;
+        BOOL encrypted = 0;
+        UInt8 frameType = 0;
+        UInt32 datasize = 0;
+        Byte firstByte = ((version & 0x0f) << 4) + (encrypted << 3) + (frameType & 0x07);
+        const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (datasize >> 24) & 0xff, (datasize >> 16) & 0xff, (datasize >> 8) & 0xff, (datasize) & 0xff };
+        [testHeaderBuffer appendBytes:&testBytes length:8];
+        UInt32 messageID = 0;
+        Byte messageIDBytes[4] = {(messageID >> 24) & 0xff, (messageID >> 16) & 0xff, (messageID >> 8) & 0xff, (messageID) & 0xff};
+        [testHeaderBuffer appendBytes:&messageIDBytes length:4];
+        Byte testPayloadByte;
+        for(int i=0;i<datasize;i++){
+            testPayloadByte = 0xba;
+            [testPayloadBuffer appendBytes:&testPayloadByte length:1];
+        }
+        
+        if (testHeaderBuffer != nil){
+            testHeader = [SDLProtocolHeader headerForVersion:version];
+            [testHeader parse:testHeaderBuffer];
+            testMessage = [SDLProtocolMessage messageWithHeader:testHeader andPayload:testPayloadBuffer];
+        }
+
+        // run test
+        [testReceiveProcessor processReceiveBuffer:testMessage.data withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            expect(header).to(equal(testHeader));
+            expect(payload).to(equal(testPayloadBuffer));
+        }];
+        //TODO - how will tests end for cases where it doesn't call the block?
     });
+    
+    
 });
 
 QuickSpecEnd
-- 
cgit v1.2.1


From 9193531872fc24c9387fcdd732d5bbc0da6305ff Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Thu, 11 Aug 2022 16:33:02 -0400
Subject: Fixed tests after input from Joel

---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 72 +++++++++++++++++++++-
 1 file changed, 69 insertions(+), 3 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 4e86487f1..21c52602f 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -17,9 +17,76 @@
 #import "SDLV2ProtocolMessage.h"
 
 
+
+@interface SDLProtocolReceivedMessageProcessor(){}
+// State management
+@property (assign, nonatomic) NSUInteger state; //todo - I changed type to avoid issues with the enum
+
+// Message assembly state
+@property (strong, nonatomic) SDLProtocolHeader *header;
+@property (strong, nonatomic) NSMutableData *headerBuffer;
+@property (strong, nonatomic) NSMutableData *payloadBuffer;
+
+// Error checking
+@property (assign, nonatomic) UInt8 version;
+@property (assign, nonatomic) BOOL encrypted;
+@property (assign, nonatomic) SDLFrameType frameType;
+@property (assign, nonatomic) UInt32 dataLength;
+@property (assign, nonatomic) UInt32 dataBytesRemaining;
+@end
+
 QuickSpecBegin(SDLProtocolReceivedMessageProcessorSpec)
 
-describe(@"State Machine START_STATE", ^{
+describe(@"The recieved message processor", ^{
+    __block SDLProtocolReceivedMessageProcessor *testProcessor = nil;
+    __block NSMutableData *testBuffer;
+    
+    beforeEach(^{
+        testProcessor = [[SDLProtocolReceivedMessageProcessor alloc] init];
+        testBuffer = [NSMutableData data];
+    });
+    
+
+    context(@"When it recieves a byte while in the START_STATE", ^{
+        it(@"transitions to SERVICE_TYPE_STATE if the byte is valid", ^{
+            testProcessor.state = 0x00;
+            //Byte testByte = 17;
+            Byte testByte = 0x11;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                //do nothing?
+            }];
+            expect(testProcessor.state).to(equal(0x01));
+        });
+        it(@"transitions to ERROR_STATE if the byte is notvalid", ^{
+            testProcessor.state = 0x00;
+            //Byte testByte = 17;
+            Byte testByte = 0x00;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                //do nothing?
+            }];
+            expect(testProcessor.state).to(equal(-1));  //TODO - this doesn't work right
+        });
+    });
+    context(@"When it recieves a valid byte while in the SERVICE_TYPE_STATE", ^{
+        it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
+            testProcessor.state = 0x01;
+            Byte testByte = 0x0b;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                //do nothing?
+            }];
+            expect(testProcessor.state).to(equal(0x02));
+        });
+    });
+});
+
+
+describe(@"FAIL State Machine START_STATE", ^{
     
     __block SDLProtocolReceivedMessageProcessor *testReceiveProcessor;
     __block SDLProtocolMessage *testMessage;
@@ -31,7 +98,7 @@ describe(@"State Machine START_STATE", ^{
         testReceiveProcessor = [[SDLProtocolReceivedMessageProcessor alloc] init];
     });
     
-    it(@"can pass a good message", ^{
+    it(@"can pass a good message version 1, frame type ", ^{
         // setup the test
         UInt8 version = 1;
         BOOL encrypted = 0;
@@ -63,7 +130,6 @@ describe(@"State Machine START_STATE", ^{
         //TODO - how will tests end for cases where it doesn't call the block?
     });
     
-    
 });
 
 QuickSpecEnd
-- 
cgit v1.2.1


From 92fd7ce4de56f335d55fa34d82c374f6d61d09f4 Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Fri, 12 Aug 2022 13:38:31 -0400
Subject: created a bunch of unit tests

---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 376 ++++++++++++++++-----
 1 file changed, 295 insertions(+), 81 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 21c52602f..006da6049 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -16,11 +16,26 @@
 #import "SDLV2ProtocolHeader.h"
 #import "SDLV2ProtocolMessage.h"
 
-
+typedef NS_ENUM(NSInteger, ProcessorState) {
+    START_STATE = 0x0,
+    SERVICE_TYPE_STATE = 0x01,
+    CONTROL_FRAME_INFO_STATE = 0x02,
+    SESSION_ID_STATE = 0x03,
+    DATA_SIZE_1_STATE = 0x04,
+    DATA_SIZE_2_STATE = 0x05,
+    DATA_SIZE_3_STATE = 0x06,
+    DATA_SIZE_4_STATE = 0x07,
+    MESSAGE_1_STATE = 0x08,
+    MESSAGE_2_STATE = 0x09,
+    MESSAGE_3_STATE = 0x0A,
+    MESSAGE_4_STATE = 0x0B,
+    DATA_PUMP_STATE = 0x0C,
+    ERROR_STATE = -1,
+};
 
 @interface SDLProtocolReceivedMessageProcessor(){}
 // State management
-@property (assign, nonatomic) NSUInteger state; //todo - I changed type to avoid issues with the enum
+@property (assign, nonatomic) ProcessorState state;
 
 // Message assembly state
 @property (strong, nonatomic) SDLProtocolHeader *header;
@@ -37,7 +52,7 @@
 
 QuickSpecBegin(SDLProtocolReceivedMessageProcessorSpec)
 
-describe(@"The recieved message processor", ^{
+describe(@"The processor", ^{
     __block SDLProtocolReceivedMessageProcessor *testProcessor = nil;
     __block NSMutableData *testBuffer;
     
@@ -45,91 +60,290 @@ describe(@"The recieved message processor", ^{
         testProcessor = [[SDLProtocolReceivedMessageProcessor alloc] init];
         testBuffer = [NSMutableData data];
     });
-    
-
-    context(@"When it recieves a byte while in the START_STATE", ^{
-        it(@"transitions to SERVICE_TYPE_STATE if the byte is valid", ^{
-            testProcessor.state = 0x00;
-            //Byte testByte = 17;
-            Byte testByte = 0x11;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                //do nothing?
-            }];
-            expect(testProcessor.state).to(equal(0x01));
-        });
-        it(@"transitions to ERROR_STATE if the byte is notvalid", ^{
-            testProcessor.state = 0x00;
-            //Byte testByte = 17;
-            Byte testByte = 0x00;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                //do nothing?
-            }];
-            expect(testProcessor.state).to(equal(-1));  //TODO - this doesn't work right
+    context(@"in START_STATE", ^{
+        context(@"recieves a byte", ^{
+            it(@"transitions to SERVICE_TYPE_STATE if the byte is valid", ^{
+                testProcessor.state = START_STATE;
+                Byte testByte = 0x11;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            });
+            it(@"transitions to ERROR_STATE if the byte is notvalid", ^{
+                testProcessor.state = START_STATE;
+                Byte testByte = 0x00;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(ERROR_STATE));  //TODO - this doesn't work right
+            });
         });
     });
-    context(@"When it recieves a valid byte while in the SERVICE_TYPE_STATE", ^{
-        it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
-            testProcessor.state = 0x01;
-            Byte testByte = 0x0b;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                //do nothing?
-            }];
-            expect(testProcessor.state).to(equal(0x02));
+    context(@"in SERVICE_TYPE_STATE", ^{
+        context(@"When it recieves a byte", ^{
+            it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
+                testProcessor.state = SERVICE_TYPE_STATE;
+                Byte testByte = 0x0b;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            });
         });
     });
-});
-
-
-describe(@"FAIL State Machine START_STATE", ^{
-    
-    __block SDLProtocolReceivedMessageProcessor *testReceiveProcessor;
-    __block SDLProtocolMessage *testMessage;
-    __block SDLProtocolHeader *testHeader;
-    __block NSMutableData *testPayloadBuffer;
-    __block NSMutableData *testHeaderBuffer;
-    
-    beforeEach(^{
-        testReceiveProcessor = [[SDLProtocolReceivedMessageProcessor alloc] init];
+    context(@"in CONTROL_FRAME_INFO_STATE", ^{
+        context(@"recieves a SDLServiceTypeControl byte", ^{
+            it(@"transitions to SESSION_ID_STATE", ^{
+                testProcessor.state = CONTROL_FRAME_INFO_STATE;
+                Byte testByte = SDLServiceTypeControl;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+            });
+        });
+        context(@"recieves a SDLServiceTypeRPC byte", ^{
+            it(@"transitions to SESSION_ID_STATE", ^{
+                testProcessor.state = CONTROL_FRAME_INFO_STATE;
+                Byte testByte = SDLServiceTypeRPC;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+            });
+        });
+        context(@"recieves a SDLServiceTypeAudio byte", ^{
+            it(@"transitions to SESSION_ID_STATE", ^{
+                testProcessor.state = CONTROL_FRAME_INFO_STATE;
+                Byte testByte = SDLServiceTypeAudio;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+            });
+        });
+        context(@"recieves a SDLServiceTypeVideo byte", ^{
+            it(@"transitions to SESSION_ID_STATE", ^{
+                testProcessor.state = CONTROL_FRAME_INFO_STATE;
+                Byte testByte = SDLServiceTypeVideo;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+            });
+        });
+        context(@"recieves a SDLServiceTypeBulkData byte", ^{
+            it(@"transitions to SESSION_ID_STATE", ^{
+                testProcessor.state = CONTROL_FRAME_INFO_STATE;
+                Byte testByte = SDLServiceTypeBulkData;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+            });
+        });
     });
-    
-    it(@"can pass a good message version 1, frame type ", ^{
-        // setup the test
-        UInt8 version = 1;
-        BOOL encrypted = 0;
-        UInt8 frameType = 0;
-        UInt32 datasize = 0;
-        Byte firstByte = ((version & 0x0f) << 4) + (encrypted << 3) + (frameType & 0x07);
-        const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (datasize >> 24) & 0xff, (datasize >> 16) & 0xff, (datasize >> 8) & 0xff, (datasize) & 0xff };
-        [testHeaderBuffer appendBytes:&testBytes length:8];
-        UInt32 messageID = 0;
-        Byte messageIDBytes[4] = {(messageID >> 24) & 0xff, (messageID >> 16) & 0xff, (messageID >> 8) & 0xff, (messageID) & 0xff};
-        [testHeaderBuffer appendBytes:&messageIDBytes length:4];
-        Byte testPayloadByte;
-        for(int i=0;i<datasize;i++){
-            testPayloadByte = 0xba;
-            [testPayloadBuffer appendBytes:&testPayloadByte length:1];
-        }
-        
-        if (testHeaderBuffer != nil){
-            testHeader = [SDLProtocolHeader headerForVersion:version];
-            [testHeader parse:testHeaderBuffer];
-            testMessage = [SDLProtocolMessage messageWithHeader:testHeader andPayload:testPayloadBuffer];
-        }
-
-        // run test
-        [testReceiveProcessor processReceiveBuffer:testMessage.data withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            expect(header).to(equal(testHeader));
-            expect(payload).to(equal(testPayloadBuffer));
-        }];
-        //TODO - how will tests end for cases where it doesn't call the block?
+    context(@"in SESSION_ID_STATE", ^{
+        context(@"recieves a byte", ^{
+            it(@"transitions to DATA_SIZE_1_STATE", ^{
+                testProcessor.state = SESSION_ID_STATE;
+                Byte testByte = 0x00;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(DATA_SIZE_1_STATE));
+            });
+        });
     });
+    context(@"in DATA_SIZE_1_STATE", ^{
+        context(@"recieves a byte", ^{
+            it(@"transitions to DATA_SIZE_2_STATE", ^{
+                testProcessor.state = DATA_SIZE_1_STATE;
+                Byte testByte = 0x00;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(DATA_SIZE_2_STATE));
+            });
+        });
+    });
+    context(@"in DATA_SIZE_2_STATE", ^{
+        context(@"recieves a byte", ^{
+            it(@"transitions to DATA_SIZE_3_STATE", ^{
+                testProcessor.state = DATA_SIZE_2_STATE;
+                Byte testByte = 0x00;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(DATA_SIZE_3_STATE));
+            });
+        });
+    });
+    context(@"in DATA_SIZE_3_STATE", ^{
+        context(@"recieves a byte", ^{
+            it(@"transitions to DATA_SIZE_4_STATE", ^{
+                testProcessor.state = DATA_SIZE_3_STATE;
+                Byte testByte = 0x00;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(DATA_SIZE_4_STATE));
+            });
+        });
+    });
+    context(@"in DATA_SIZE_4_STATE", ^{
+        context(@"if version is 1", ^{
+            context(@"datalength is 0", ^{
+                context(@"recieves a byte", ^{
+                    it(@"transitions to START_STATE", ^{
+                        testProcessor.state = DATA_SIZE_4_STATE;
+                        testProcessor.version = 1;
+                        testProcessor.dataLength = 0;
+                        Byte testByte = 0x00;
+                        [testBuffer appendBytes:&testByte length:1];
+                        
+                        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                            //do nothing?
+                        }];
+                        expect(@(testProcessor.state)).to(equal(START_STATE));
+                    });
+                });
+            });
+            context(@"datalength is greater than 0", ^{
+                context(@"recieves a byte", ^{
+                    it(@"transitions to DATA_PUMP_STATE", ^{
+                        testProcessor.state = DATA_SIZE_4_STATE;
+                        testProcessor.version = 1;
+                        testProcessor.dataLength = 1;
+                        Byte testByte = 0x00;
+                        [testBuffer appendBytes:&testByte length:1];
+                        
+                        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                            //do nothing?
+                        }];
+                        expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+                    });
+                });
+            });
+        });
+        context(@"if version greater than 1", ^{
+            context(@"recieves a byte", ^{
+                it(@"transitions to MESSAGE_1_STATE", ^{
+                    testProcessor.state = DATA_SIZE_4_STATE;
+                    testProcessor.version = 2;
+                    testProcessor.dataLength = 0;
+                    Byte testByte = 0x00;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(MESSAGE_1_STATE));
+                });
+            });
     
+        });
+    });
+    context(@"in MESSAGE_1_STATE", ^{
+        context(@"recieves a byte", ^{
+            it(@"transitions to MESSAGE_2_STATE", ^{
+                testProcessor.state = MESSAGE_1_STATE;
+                Byte testByte = 0x00;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(MESSAGE_2_STATE));
+            });
+        });
+    });
+    context(@"in MESSAGE_2_STATE", ^{
+        context(@"recieves a byte", ^{
+            it(@"transitions to MESSAGE_3_STATE", ^{
+                testProcessor.state = MESSAGE_2_STATE;
+                Byte testByte = 0x00;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(MESSAGE_3_STATE));
+            });
+        });
+    });
+    context(@"in MESSAGE_3_STATE", ^{
+        context(@"recieves a byte", ^{
+            it(@"transitions to MESSAGE_4_STATE", ^{
+                testProcessor.state = MESSAGE_3_STATE;
+                Byte testByte = 0x00;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(MESSAGE_4_STATE));
+            });
+        });
+    });
+    context(@"in MESSAGE_4_STATE", ^{
+        context(@"datalength is 0", ^{
+            context(@"recieves a byte", ^{
+                it(@"transitions to START_STATE", ^{
+                    testProcessor.state = MESSAGE_4_STATE;
+                    testProcessor.dataLength = 0;
+                    Byte testByte = 0x00;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(START_STATE));
+                });
+            });
+            context(@"datalength is greater than 0", ^{
+                context(@"recieves a byte", ^{
+                    it(@"transitions to DATA_PUMP_STATE", ^{
+                        testProcessor.state = MESSAGE_4_STATE;
+                        testProcessor.dataLength = 1;
+                        Byte testByte = 0x00;
+                        [testBuffer appendBytes:&testByte length:1];
+                        
+                        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                            //do nothing?
+                        }];
+                        expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+                    });
+                });
+            });
+        });
+    });
 });
+    
 
 QuickSpecEnd
-- 
cgit v1.2.1


From b33d4e9a5b94aea6077f24cd6206b7f985e31834 Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Fri, 12 Aug 2022 14:49:12 -0400
Subject: Most tests are in and work

---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 203 +++++++++++++++------
 1 file changed, 150 insertions(+), 53 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 006da6049..5a026f229 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -55,33 +55,96 @@ QuickSpecBegin(SDLProtocolReceivedMessageProcessorSpec)
 describe(@"The processor", ^{
     __block SDLProtocolReceivedMessageProcessor *testProcessor = nil;
     __block NSMutableData *testBuffer;
+    __block NSMutableData *testHeaderBuffer;
     
     beforeEach(^{
         testProcessor = [[SDLProtocolReceivedMessageProcessor alloc] init];
         testBuffer = [NSMutableData data];
+        testHeaderBuffer = [NSMutableData data];
     });
     context(@"in START_STATE", ^{
-        context(@"recieves a byte", ^{
-            it(@"transitions to SERVICE_TYPE_STATE if the byte is valid", ^{
-                testProcessor.state = START_STATE;
-                Byte testByte = 0x11;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
-                }];
-                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+        beforeEach(^{
+            testProcessor.state = START_STATE;
+        });
+        context(@"When it recieves a byte", ^{
+            context(@"with a good version 1", ^{
+                it(@"transitions to SERVICE_TYPE_STATE", ^{
+                    Byte testByte = 0x11;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                });
             });
-            it(@"transitions to ERROR_STATE if the byte is notvalid", ^{
-                testProcessor.state = START_STATE;
-                Byte testByte = 0x00;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
-                }];
-                expect(@(testProcessor.state)).to(equal(ERROR_STATE));  //TODO - this doesn't work right
+            context(@"with a good version 2", ^{
+                it(@"transitions to SERVICE_TYPE_STATE", ^{
+                    Byte testByte = 0x21;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                });
+            });
+            context(@"with a good version 3", ^{
+                it(@"transitions to SERVICE_TYPE_STATE", ^{
+                    Byte testByte = 0x31;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                });
+            });
+            context(@"with a good version 4", ^{
+                it(@"transitions to SERVICE_TYPE_STATE", ^{
+                    Byte testByte = 0x41;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                });
+            });
+            context(@"with a good version 5", ^{
+                it(@"transitions to SERVICE_TYPE_STATE", ^{
+                    Byte testByte = 0x51;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                });
             });
+            context(@"with a bad version 0", ^{
+                it(@"resets state to START_STATE if the byte is not valid", ^{
+                    Byte testByte = 0x01;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(START_STATE));  //TODO - this doesn't work right
+                });
+            });
+            context(@"with a bad version 6", ^{
+                it(@"resets state to START_STATE if the byte is not valid", ^{
+                    Byte testByte = 0x61;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(START_STATE));  //TODO - this doesn't work right
+                });
+            });
+            
         });
     });
     context(@"in SERVICE_TYPE_STATE", ^{
@@ -99,9 +162,11 @@ describe(@"The processor", ^{
         });
     });
     context(@"in CONTROL_FRAME_INFO_STATE", ^{
+        beforeEach(^{
+            testProcessor.state = CONTROL_FRAME_INFO_STATE;
+        });
         context(@"recieves a SDLServiceTypeControl byte", ^{
             it(@"transitions to SESSION_ID_STATE", ^{
-                testProcessor.state = CONTROL_FRAME_INFO_STATE;
                 Byte testByte = SDLServiceTypeControl;
                 [testBuffer appendBytes:&testByte length:1];
                 
@@ -113,7 +178,6 @@ describe(@"The processor", ^{
         });
         context(@"recieves a SDLServiceTypeRPC byte", ^{
             it(@"transitions to SESSION_ID_STATE", ^{
-                testProcessor.state = CONTROL_FRAME_INFO_STATE;
                 Byte testByte = SDLServiceTypeRPC;
                 [testBuffer appendBytes:&testByte length:1];
                 
@@ -125,7 +189,6 @@ describe(@"The processor", ^{
         });
         context(@"recieves a SDLServiceTypeAudio byte", ^{
             it(@"transitions to SESSION_ID_STATE", ^{
-                testProcessor.state = CONTROL_FRAME_INFO_STATE;
                 Byte testByte = SDLServiceTypeAudio;
                 [testBuffer appendBytes:&testByte length:1];
                 
@@ -137,7 +200,6 @@ describe(@"The processor", ^{
         });
         context(@"recieves a SDLServiceTypeVideo byte", ^{
             it(@"transitions to SESSION_ID_STATE", ^{
-                testProcessor.state = CONTROL_FRAME_INFO_STATE;
                 Byte testByte = SDLServiceTypeVideo;
                 [testBuffer appendBytes:&testByte length:1];
                 
@@ -149,7 +211,6 @@ describe(@"The processor", ^{
         });
         context(@"recieves a SDLServiceTypeBulkData byte", ^{
             it(@"transitions to SESSION_ID_STATE", ^{
-                testProcessor.state = CONTROL_FRAME_INFO_STATE;
                 Byte testByte = SDLServiceTypeBulkData;
                 [testBuffer appendBytes:&testByte length:1];
                 
@@ -217,15 +278,20 @@ describe(@"The processor", ^{
         });
     });
     context(@"in DATA_SIZE_4_STATE", ^{
+        beforeEach(^{
+            testProcessor.state = DATA_SIZE_4_STATE;
+            
+            Byte testByte = 0x00;
+            [testBuffer appendBytes:&testByte length:1];
+        });
         context(@"if version is 1", ^{
+            beforeEach(^{
+                testProcessor.version = 1;
+            });
             context(@"datalength is 0", ^{
                 context(@"recieves a byte", ^{
-                    it(@"transitions to START_STATE", ^{
-                        testProcessor.state = DATA_SIZE_4_STATE;
-                        testProcessor.version = 1;
+                    it(@"resets state to START_STATE", ^{
                         testProcessor.dataLength = 0;
-                        Byte testByte = 0x00;
-                        [testBuffer appendBytes:&testByte length:1];
                         
                         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                             //do nothing?
@@ -237,11 +303,7 @@ describe(@"The processor", ^{
             context(@"datalength is greater than 0", ^{
                 context(@"recieves a byte", ^{
                     it(@"transitions to DATA_PUMP_STATE", ^{
-                        testProcessor.state = DATA_SIZE_4_STATE;
-                        testProcessor.version = 1;
                         testProcessor.dataLength = 1;
-                        Byte testByte = 0x00;
-                        [testBuffer appendBytes:&testByte length:1];
                         
                         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                             //do nothing?
@@ -254,11 +316,8 @@ describe(@"The processor", ^{
         context(@"if version greater than 1", ^{
             context(@"recieves a byte", ^{
                 it(@"transitions to MESSAGE_1_STATE", ^{
-                    testProcessor.state = DATA_SIZE_4_STATE;
                     testProcessor.version = 2;
                     testProcessor.dataLength = 0;
-                    Byte testByte = 0x00;
-                    [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                         //do nothing?
@@ -312,13 +371,16 @@ describe(@"The processor", ^{
         });
     });
     context(@"in MESSAGE_4_STATE", ^{
+        beforeEach(^{
+            testProcessor.state = MESSAGE_4_STATE;
+            
+            Byte testByte = 0x00;
+            [testBuffer appendBytes:&testByte length:1];
+        });
         context(@"datalength is 0", ^{
             context(@"recieves a byte", ^{
-                it(@"transitions to START_STATE", ^{
-                    testProcessor.state = MESSAGE_4_STATE;
+                it(@"resets state to START_STATE", ^{
                     testProcessor.dataLength = 0;
-                    Byte testByte = 0x00;
-                    [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                         //do nothing?
@@ -326,23 +388,58 @@ describe(@"The processor", ^{
                     expect(@(testProcessor.state)).to(equal(START_STATE));
                 });
             });
-            context(@"datalength is greater than 0", ^{
-                context(@"recieves a byte", ^{
-                    it(@"transitions to DATA_PUMP_STATE", ^{
-                        testProcessor.state = MESSAGE_4_STATE;
-                        testProcessor.dataLength = 1;
-                        Byte testByte = 0x00;
-                        [testBuffer appendBytes:&testByte length:1];
-                        
-                        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                            //do nothing?
-                        }];
-                        expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
-                    });
+        });
+        context(@"datalength is greater than 0", ^{
+            context(@"recieves a byte", ^{
+                it(@"transitions to DATA_PUMP_STATE", ^{
+                    testProcessor.dataLength = 1;
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
                 });
             });
         });
     });
+    context(@"in DATA_PUMP_STATE", ^{
+        beforeEach(^{
+            testProcessor.state = DATA_PUMP_STATE;
+            testProcessor.version = 5;
+            //need a valid headerbuffer.  TODO - Lots of magic numbers here.
+            Byte firstByte = ((5 & 0x0f) << 4) + (0 << 3) + (1 & 0x07);
+            const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (3 >> 24) & 0xff, (3 >> 16) & 0xff, (3 >> 8) & 0xff, (3) & 0xff };
+            [testHeaderBuffer appendBytes:&testBytes length:8];
+            UInt32 messageID = 0;
+            Byte messageIDBytes[4] = {(messageID >> 24) & 0xff, (messageID >> 16) & 0xff, (messageID >> 8) & 0xff, (messageID) & 0xff};
+            [testHeaderBuffer appendBytes:&messageIDBytes length:4];
+            
+            testProcessor.headerBuffer = testHeaderBuffer;
+            
+            Byte testByte = 0xBA;
+            [testBuffer appendBytes:&testByte length:1];
+        });
+        context(@"dataBytesRemaining is greater than 1", ^{
+            it(@"Stays in DATA_PUMP_STATE", ^{
+                testProcessor.dataBytesRemaining = 2;
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+            });
+        });
+        context(@"dataBytesRemaining is 1", ^{
+            it(@"transitions to START_STATE", ^{
+                testProcessor.dataBytesRemaining = 1;
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(START_STATE));
+            });
+        });
+    });
 });
     
 
-- 
cgit v1.2.1


From bae5d017fb6a255df02515b8ad0fda001ea159ae Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Fri, 12 Aug 2022 15:26:25 -0400
Subject: fixed the controlFrameInfo tests

---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 145 +++++++++++++++++----
 1 file changed, 119 insertions(+), 26 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 5a026f229..33331d3ba 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -144,14 +144,70 @@ describe(@"The processor", ^{
                     expect(@(testProcessor.state)).to(equal(START_STATE));  //TODO - this doesn't work right
                 });
             });
-            
+            context(@"with a frameType of SDLFrameTypeControl", ^{
+                it(@"transitions to SERVICE_TYPE_STATE", ^{
+                    Byte testByte = 0x10;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));  //TODO - this doesn't work right
+                });
+            });
+            context(@"with a frameType of SDLFrameTypeSingle", ^{
+                it(@"transitions to SERVICE_TYPE_STATE", ^{
+                    Byte testByte = 0x11;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));  //TODO - this doesn't work right
+                });
+            });
+            context(@"with a frameType of SDLFrameTypeFirst", ^{
+                it(@"transitions to SERVICE_TYPE_STATE", ^{
+                    Byte testByte = 0x12;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));  //TODO - this doesn't work right
+                });
+            });
+            context(@"with a frameType of SDLFrameTypeConsecutive", ^{
+                it(@"transitions to SERVICE_TYPE_STATE", ^{
+                    Byte testByte = 0x13;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));  //TODO - this doesn't work right
+                });
+            });
+            context(@"with an invalid frameType of 6", ^{
+                it(@"resets state to START_STATE", ^{
+                    Byte testByte = 0x66;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
+                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                        //do nothing?
+                    }];
+                    expect(@(testProcessor.state)).to(equal(START_STATE));  //TODO - this doesn't work right
+                });
+            });
         });
     });
     context(@"in SERVICE_TYPE_STATE", ^{
-        context(@"When it recieves a byte", ^{
+        beforeEach(^{
+            testProcessor.state = SERVICE_TYPE_STATE;
+        });
+        context(@"When it recieves a SDLServiceTypeControl byte", ^{
             it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
-                testProcessor.state = SERVICE_TYPE_STATE;
-                Byte testByte = 0x0b;
+                Byte testByte = SDLServiceTypeControl;
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
@@ -160,58 +216,70 @@ describe(@"The processor", ^{
                 expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
             });
         });
-    });
-    context(@"in CONTROL_FRAME_INFO_STATE", ^{
-        beforeEach(^{
-            testProcessor.state = CONTROL_FRAME_INFO_STATE;
+        context(@"When it recieves a SDLServiceTypeRPC byte", ^{
+            it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
+                Byte testByte = SDLServiceTypeRPC;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            });
         });
-        context(@"recieves a SDLServiceTypeControl byte", ^{
-            it(@"transitions to SESSION_ID_STATE", ^{
-                Byte testByte = SDLServiceTypeControl;
+        context(@"When it recieves a SDLServiceTypeAudio byte", ^{
+            it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
+                Byte testByte = SDLServiceTypeAudio;
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                     //do nothing?
                 }];
-                expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
             });
         });
-        context(@"recieves a SDLServiceTypeRPC byte", ^{
-            it(@"transitions to SESSION_ID_STATE", ^{
-                Byte testByte = SDLServiceTypeRPC;
+        context(@"When it recieves a SDLServiceTypeVideo byte", ^{
+            it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
+                Byte testByte = SDLServiceTypeVideo;
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                     //do nothing?
                 }];
-                expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
             });
         });
-        context(@"recieves a SDLServiceTypeAudio byte", ^{
-            it(@"transitions to SESSION_ID_STATE", ^{
-                Byte testByte = SDLServiceTypeAudio;
+        context(@"When it recieves a SDLServiceTypeBulkData byte", ^{
+            it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
+                Byte testByte = SDLServiceTypeBulkData;
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                     //do nothing?
                 }];
-                expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
             });
         });
-        context(@"recieves a SDLServiceTypeVideo byte", ^{
-            it(@"transitions to SESSION_ID_STATE", ^{
-                Byte testByte = SDLServiceTypeVideo;
+        context(@"recieves an invalid byte", ^{
+            it(@"resets state to START_STATE", ^{
+                Byte testByte = 0xFF;
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                     //do nothing?
                 }];
-                expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+                expect(@(testProcessor.state)).to(equal(START_STATE));
             });
         });
-        context(@"recieves a SDLServiceTypeBulkData byte", ^{
+    });
+    context(@"in CONTROL_FRAME_INFO_STATE", ^{
+        beforeEach(^{
+            testProcessor.state = CONTROL_FRAME_INFO_STATE;
+        });
+        context(@"recieves a valid byte", ^{
             it(@"transitions to SESSION_ID_STATE", ^{
-                Byte testByte = SDLServiceTypeBulkData;
+                Byte testByte = 0x00;
+                testProcessor.frameType = SDLFrameTypeFirst;
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
@@ -220,6 +288,31 @@ describe(@"The processor", ^{
                 expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
             });
         });
+        context(@"controlFrameInfo is not 0 for a SDLFrameTypeFirst", ^{
+            it(@"resets to START_STATE", ^{
+                Byte testByte = 0x01;
+                testProcessor.frameType = SDLFrameTypeFirst;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(START_STATE));
+            });
+        });
+        context(@"controlFrameInfo is not 0 for a SDLFrameTypeSingle", ^{
+            it(@"resets to START_STATE", ^{
+                Byte testByte = 0x01;
+                testProcessor.frameType = SDLFrameTypeSingle;
+                [testBuffer appendBytes:&testByte length:1];
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    //do nothing?
+                }];
+                expect(@(testProcessor.state)).to(equal(START_STATE));
+            });
+        });
+        
     });
     context(@"in SESSION_ID_STATE", ^{
         context(@"recieves a byte", ^{
-- 
cgit v1.2.1


From 4731803a53c6c3d6bd5557bc52c782cfcfbcc617 Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Fri, 12 Aug 2022 15:50:46 -0400
Subject: comment

---
 .../ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 33331d3ba..2d1c56514 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -500,7 +500,7 @@ describe(@"The processor", ^{
             testProcessor.state = DATA_PUMP_STATE;
             testProcessor.version = 5;
             //need a valid headerbuffer.  TODO - Lots of magic numbers here.
-            Byte firstByte = ((5 & 0x0f) << 4) + (0 << 3) + (1 & 0x07);
+            Byte firstByte = ((5 & 0x0f) << 4) + (0 << 3) + (1 & 0x07); //version 5 with no encryption, frametype 1
             const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (3 >> 24) & 0xff, (3 >> 16) & 0xff, (3 >> 8) & 0xff, (3) & 0xff };
             [testHeaderBuffer appendBytes:&testBytes length:8];
             UInt32 messageID = 0;
-- 
cgit v1.2.1


From 7e5b6cffba506869bc9ab4b7d9a76c87cf928fd3 Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Mon, 15 Aug 2022 12:09:47 -0400
Subject: fixed maxMtuSize

---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 29 ++++++++++++++++------
 1 file changed, 22 insertions(+), 7 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 2d1c56514..1b2c69fbc 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -48,6 +48,7 @@ typedef NS_ENUM(NSInteger, ProcessorState) {
 @property (assign, nonatomic) SDLFrameType frameType;
 @property (assign, nonatomic) UInt32 dataLength;
 @property (assign, nonatomic) UInt32 dataBytesRemaining;
+@property (assign, nonatomic) SDLServiceType serviceType;
 @end
 
 QuickSpecBegin(SDLProtocolReceivedMessageProcessorSpec)
@@ -130,7 +131,7 @@ describe(@"The processor", ^{
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                         //do nothing?
                     }];
-                    expect(@(testProcessor.state)).to(equal(START_STATE));  //TODO - this doesn't work right
+                    expect(@(testProcessor.state)).to(equal(START_STATE));
                 });
             });
             context(@"with a bad version 6", ^{
@@ -141,7 +142,7 @@ describe(@"The processor", ^{
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                         //do nothing?
                     }];
-                    expect(@(testProcessor.state)).to(equal(START_STATE));  //TODO - this doesn't work right
+                    expect(@(testProcessor.state)).to(equal(START_STATE));
                 });
             });
             context(@"with a frameType of SDLFrameTypeControl", ^{
@@ -152,7 +153,7 @@ describe(@"The processor", ^{
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                         //do nothing?
                     }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));  //TODO - this doesn't work right
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                 });
             });
             context(@"with a frameType of SDLFrameTypeSingle", ^{
@@ -163,7 +164,7 @@ describe(@"The processor", ^{
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                         //do nothing?
                     }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));  //TODO - this doesn't work right
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                 });
             });
             context(@"with a frameType of SDLFrameTypeFirst", ^{
@@ -174,7 +175,7 @@ describe(@"The processor", ^{
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                         //do nothing?
                     }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));  //TODO - this doesn't work right
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                 });
             });
             context(@"with a frameType of SDLFrameTypeConsecutive", ^{
@@ -185,7 +186,7 @@ describe(@"The processor", ^{
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                         //do nothing?
                     }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));  //TODO - this doesn't work right
+                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                 });
             });
             context(@"with an invalid frameType of 6", ^{
@@ -196,7 +197,7 @@ describe(@"The processor", ^{
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                         //do nothing?
                     }];
-                    expect(@(testProcessor.state)).to(equal(START_STATE));  //TODO - this doesn't work right
+                    expect(@(testProcessor.state)).to(equal(START_STATE));
                 });
             });
         });
@@ -405,6 +406,20 @@ describe(@"The processor", ^{
                     });
                 });
             });
+            context(@"datalength is greater than maxMtuSize", ^{
+                context(@"recieves a byte", ^{
+                    it(@"transitions to DATA_PUMP_STATE", ^{
+                        testProcessor.serviceType = SDLServiceTypeControl;
+                        testProcessor.dataLength = 200000;
+                        
+                        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                            //do nothing?
+                        }];
+                        expect(@(testProcessor.state)).to(equal(START_STATE));
+                    });
+                });
+            });
+            
         });
         context(@"if version greater than 1", ^{
             context(@"recieves a byte", ^{
-- 
cgit v1.2.1


From 22136d3ddf985672aa7e9f173fa13c4671e299ec Mon Sep 17 00:00:00 2001
From: George Miller <Swift2568@yahoo.com>
Date: Tue, 16 Aug 2022 17:03:43 -0400
Subject: Update
 SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m

Co-authored-by: Joel Fischer <joeljfischer@gmail.com>
---
 .../ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 1b2c69fbc..bef15270a 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -33,7 +33,7 @@ typedef NS_ENUM(NSInteger, ProcessorState) {
     ERROR_STATE = -1,
 };
 
-@interface SDLProtocolReceivedMessageProcessor(){}
+@interface SDLProtocolReceivedMessageProcessor ()
 // State management
 @property (assign, nonatomic) ProcessorState state;
 
-- 
cgit v1.2.1


From b72133e32c4758eb01acc27e1f1e3100c05a1911 Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Tue, 16 Aug 2022 17:08:38 -0400
Subject: end of day commit

---
 .../SDLProtocolReceivedMessageProcessorSpec.m             | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 1b2c69fbc..20ef1781d 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -53,7 +53,7 @@ typedef NS_ENUM(NSInteger, ProcessorState) {
 
 QuickSpecBegin(SDLProtocolReceivedMessageProcessorSpec)
 
-describe(@"The processor", ^{
+describe(@"The received message processor", ^{
     __block SDLProtocolReceivedMessageProcessor *testProcessor = nil;
     __block NSMutableData *testBuffer;
     __block NSMutableData *testHeaderBuffer;
@@ -63,6 +63,7 @@ describe(@"The processor", ^{
         testBuffer = [NSMutableData data];
         testHeaderBuffer = [NSMutableData data];
     });
+    
     context(@"in START_STATE", ^{
         beforeEach(^{
             testProcessor.state = START_STATE;
@@ -202,6 +203,7 @@ describe(@"The processor", ^{
             });
         });
     });
+    
     context(@"in SERVICE_TYPE_STATE", ^{
         beforeEach(^{
             testProcessor.state = SERVICE_TYPE_STATE;
@@ -273,6 +275,7 @@ describe(@"The processor", ^{
             });
         });
     });
+    
     context(@"in CONTROL_FRAME_INFO_STATE", ^{
         beforeEach(^{
             testProcessor.state = CONTROL_FRAME_INFO_STATE;
@@ -315,6 +318,7 @@ describe(@"The processor", ^{
         });
         
     });
+    
     context(@"in SESSION_ID_STATE", ^{
         context(@"recieves a byte", ^{
             it(@"transitions to DATA_SIZE_1_STATE", ^{
@@ -329,6 +333,7 @@ describe(@"The processor", ^{
             });
         });
     });
+    
     context(@"in DATA_SIZE_1_STATE", ^{
         context(@"recieves a byte", ^{
             it(@"transitions to DATA_SIZE_2_STATE", ^{
@@ -343,6 +348,7 @@ describe(@"The processor", ^{
             });
         });
     });
+    
     context(@"in DATA_SIZE_2_STATE", ^{
         context(@"recieves a byte", ^{
             it(@"transitions to DATA_SIZE_3_STATE", ^{
@@ -357,6 +363,7 @@ describe(@"The processor", ^{
             });
         });
     });
+    
     context(@"in DATA_SIZE_3_STATE", ^{
         context(@"recieves a byte", ^{
             it(@"transitions to DATA_SIZE_4_STATE", ^{
@@ -371,6 +378,7 @@ describe(@"The processor", ^{
             });
         });
     });
+    
     context(@"in DATA_SIZE_4_STATE", ^{
         beforeEach(^{
             testProcessor.state = DATA_SIZE_4_STATE;
@@ -436,6 +444,7 @@ describe(@"The processor", ^{
     
         });
     });
+    
     context(@"in MESSAGE_1_STATE", ^{
         context(@"recieves a byte", ^{
             it(@"transitions to MESSAGE_2_STATE", ^{
@@ -450,6 +459,7 @@ describe(@"The processor", ^{
             });
         });
     });
+    
     context(@"in MESSAGE_2_STATE", ^{
         context(@"recieves a byte", ^{
             it(@"transitions to MESSAGE_3_STATE", ^{
@@ -464,6 +474,7 @@ describe(@"The processor", ^{
             });
         });
     });
+    
     context(@"in MESSAGE_3_STATE", ^{
         context(@"recieves a byte", ^{
             it(@"transitions to MESSAGE_4_STATE", ^{
@@ -478,6 +489,7 @@ describe(@"The processor", ^{
             });
         });
     });
+    
     context(@"in MESSAGE_4_STATE", ^{
         beforeEach(^{
             testProcessor.state = MESSAGE_4_STATE;
@@ -510,6 +522,7 @@ describe(@"The processor", ^{
             });
         });
     });
+    
     context(@"in DATA_PUMP_STATE", ^{
         beforeEach(^{
             testProcessor.state = DATA_PUMP_STATE;
-- 
cgit v1.2.1


From d812d3ff321ab1b49fa34e2536bea045b086e03e Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Wed, 17 Aug 2022 17:12:02 -0400
Subject: review edits

things are not working here
---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 229 +++++++++++++++++----
 1 file changed, 188 insertions(+), 41 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 095924e88..ab25b4a13 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -57,11 +57,17 @@ describe(@"The received message processor", ^{
     __block SDLProtocolReceivedMessageProcessor *testProcessor = nil;
     __block NSMutableData *testBuffer;
     __block NSMutableData *testHeaderBuffer;
+    __block SDLProtocolHeader *messageReadyHeader = nil;
+    __block SDLProtocolHeader *expectedMessageReadyHeader = nil;
+    __block NSData *messageReadyPayload = nil;
     
     beforeEach(^{
         testProcessor = [[SDLProtocolReceivedMessageProcessor alloc] init];
         testBuffer = [NSMutableData data];
         testHeaderBuffer = [NSMutableData data];
+        messageReadyHeader = nil;
+        expectedMessageReadyHeader = nil;
+        messageReadyPayload = nil;
     });
     
     context(@"in START_STATE", ^{
@@ -74,10 +80,15 @@ describe(@"The received message processor", ^{
                     Byte testByte = 0x11;
                     [testBuffer appendBytes:&testByte length:1];
                     
+                    expect(messageReadyPayload).toEventually(beNil());
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
+                        expect(messageReadyPayload).toEventually(beNil());
                     }];
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
             context(@"with a good version 2", ^{
@@ -86,9 +97,12 @@ describe(@"The received message processor", ^{
                     [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
             context(@"with a good version 3", ^{
@@ -97,9 +111,12 @@ describe(@"The received message processor", ^{
                     [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
             context(@"with a good version 4", ^{
@@ -108,9 +125,12 @@ describe(@"The received message processor", ^{
                     [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
             context(@"with a good version 5", ^{
@@ -119,9 +139,12 @@ describe(@"The received message processor", ^{
                     [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
             context(@"with a bad version 0", ^{
@@ -130,9 +153,12 @@ describe(@"The received message processor", ^{
                     [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(START_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
             context(@"with a bad version 6", ^{
@@ -141,9 +167,12 @@ describe(@"The received message processor", ^{
                     [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(START_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
             context(@"with a frameType of SDLFrameTypeControl", ^{
@@ -152,9 +181,12 @@ describe(@"The received message processor", ^{
                     [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
             context(@"with a frameType of SDLFrameTypeSingle", ^{
@@ -163,9 +195,12 @@ describe(@"The received message processor", ^{
                     [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
             context(@"with a frameType of SDLFrameTypeFirst", ^{
@@ -174,9 +209,12 @@ describe(@"The received message processor", ^{
                     [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
             context(@"with a frameType of SDLFrameTypeConsecutive", ^{
@@ -185,9 +223,12 @@ describe(@"The received message processor", ^{
                     [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
             context(@"with an invalid frameType of 6", ^{
@@ -196,9 +237,12 @@ describe(@"The received message processor", ^{
                     [testBuffer appendBytes:&testByte length:1];
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(START_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
         });
@@ -214,9 +258,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
         context(@"When it recieves a SDLServiceTypeRPC byte", ^{
@@ -225,9 +272,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
         context(@"When it recieves a SDLServiceTypeAudio byte", ^{
@@ -236,9 +286,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
         context(@"When it recieves a SDLServiceTypeVideo byte", ^{
@@ -247,9 +300,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
         context(@"When it recieves a SDLServiceTypeBulkData byte", ^{
@@ -258,9 +314,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
         context(@"recieves an invalid byte", ^{
@@ -269,9 +328,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
     });
@@ -287,9 +349,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
         context(@"controlFrameInfo is not 0 for a SDLFrameTypeFirst", ^{
@@ -299,9 +364,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
         context(@"controlFrameInfo is not 0 for a SDLFrameTypeSingle", ^{
@@ -311,9 +379,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
         
@@ -327,9 +398,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(DATA_SIZE_1_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
     });
@@ -342,9 +416,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(DATA_SIZE_2_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
     });
@@ -357,9 +434,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(DATA_SIZE_3_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
     });
@@ -372,9 +452,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(DATA_SIZE_4_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
     });
@@ -382,6 +465,9 @@ describe(@"The received message processor", ^{
     context(@"in DATA_SIZE_4_STATE", ^{
         beforeEach(^{
             testProcessor.state = DATA_SIZE_4_STATE;
+            testProcessor.version = 3;
+            messageReadyHeader = nil;
+            messageReadyPayload = nil;
             
             Byte testByte = 0x00;
             [testBuffer appendBytes:&testByte length:1];
@@ -389,16 +475,30 @@ describe(@"The received message processor", ^{
         context(@"if version is 1", ^{
             beforeEach(^{
                 testProcessor.version = 1;
+                //need a valid headerbuffer.
+                Byte firstByte = ((testProcessor.version & 0x0f) << 4) + (0 << 3) + (1 & 0x07); //version 2 with no encryption, frametype 1
+                UInt32 dataLength = 3;
+                const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (dataLength >> 24) & 0xff, (dataLength >> 16) & 0xff, (dataLength >> 8) & 0xff, (dataLength) & 0xff };
+                [testHeaderBuffer appendBytes:&testBytes length:8];
+                UInt32 messageID = 0;
+                Byte messageIDBytes[4] = {(messageID >> 24) & 0xff, (messageID >> 16) & 0xff, (messageID >> 8) & 0xff, (messageID) & 0xff};
+                [testHeaderBuffer appendBytes:&messageIDBytes length:4];
+                
+                testProcessor.headerBuffer = testHeaderBuffer;
             });
             context(@"datalength is 0", ^{
                 context(@"recieves a byte", ^{
                     it(@"resets state to START_STATE", ^{
                         testProcessor.dataLength = 0;
+                        messageReadyHeader = [SDLProtocolHeader headerForVersion:1];
                         
                         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                            //do nothing?
+                            messageReadyHeader = [header copy];
+                            messageReadyPayload = [payload copy];
                         }];
                         expect(@(testProcessor.state)).to(equal(START_STATE));
+                        //expect(messageReadyHeader).toEventually(beNil());  //TODO - these will have values here!!!
+                        //expect(messageReadyPayload).toEventually(beNil());
                     });
                 });
             });
@@ -408,9 +508,12 @@ describe(@"The received message processor", ^{
                         testProcessor.dataLength = 1;
                         
                         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                            //do nothing?
+                            messageReadyHeader = header;
+                            messageReadyPayload = payload;
                         }];
                         expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+                        expect(messageReadyHeader).toEventually(beNil());
+                        expect(messageReadyPayload).toEventually(beNil());
                     });
                 });
             });
@@ -421,9 +524,12 @@ describe(@"The received message processor", ^{
                         testProcessor.dataLength = 200000;
                         
                         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                            //do nothing?
+                            messageReadyHeader = header;
+                            messageReadyPayload = payload;
                         }];
                         expect(@(testProcessor.state)).to(equal(START_STATE));
+                        expect(messageReadyHeader).toEventually(beNil());
+                        expect(messageReadyPayload).toEventually(beNil());
                     });
                 });
             });
@@ -436,9 +542,12 @@ describe(@"The received message processor", ^{
                     testProcessor.dataLength = 0;
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(MESSAGE_1_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
     
@@ -453,9 +562,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(MESSAGE_2_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
     });
@@ -468,9 +580,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(MESSAGE_3_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
     });
@@ -483,9 +598,12 @@ describe(@"The received message processor", ^{
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(MESSAGE_4_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
     });
@@ -493,6 +611,20 @@ describe(@"The received message processor", ^{
     context(@"in MESSAGE_4_STATE", ^{
         beforeEach(^{
             testProcessor.state = MESSAGE_4_STATE;
+            //need a valid headerbuffer.
+            Byte firstByte = ((testProcessor.version & 0x0f) << 4) + (0 << 3) + (1 & 0x07); //version 2 with no encryption, frametype 1
+            UInt32 dataLength = 3;
+            const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (dataLength >> 24) & 0xff, (dataLength >> 16) & 0xff, (dataLength >> 8) & 0xff, (dataLength) & 0xff };
+            [testHeaderBuffer appendBytes:&testBytes length:8];
+            UInt32 messageID = 0;
+            Byte messageIDBytes[4] = {(messageID >> 24) & 0xff, (messageID >> 16) & 0xff, (messageID >> 8) & 0xff, (messageID) & 0xff};
+            [testHeaderBuffer appendBytes:&messageIDBytes length:4];
+            
+            testProcessor.headerBuffer = testHeaderBuffer;
+            [expectedMessageReadyHeader parse:testHeaderBuffer];
+            
+            messageReadyHeader = nil;
+            messageReadyPayload = nil;
             
             Byte testByte = 0x00;
             [testBuffer appendBytes:&testByte length:1];
@@ -501,11 +633,13 @@ describe(@"The received message processor", ^{
             context(@"recieves a byte", ^{
                 it(@"resets state to START_STATE", ^{
                     testProcessor.dataLength = 0;
-                    
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(START_STATE));
+                    expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
+                    //expect(messageReadyPayload).toEventually(equal(testBuffer));
                 });
             });
         });
@@ -515,9 +649,12 @@ describe(@"The received message processor", ^{
                     testProcessor.dataLength = 1;
                     
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        //do nothing?
+                        messageReadyHeader = header;
+                        messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+                    expect(messageReadyHeader).toEventually(beNil());
+                    expect(messageReadyPayload).toEventually(beNil());
                 });
             });
         });
@@ -526,16 +663,19 @@ describe(@"The received message processor", ^{
     context(@"in DATA_PUMP_STATE", ^{
         beforeEach(^{
             testProcessor.state = DATA_PUMP_STATE;
-            testProcessor.version = 5;
-            //need a valid headerbuffer.  TODO - Lots of magic numbers here.
-            Byte firstByte = ((5 & 0x0f) << 4) + (0 << 3) + (1 & 0x07); //version 5 with no encryption, frametype 1
-            const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (3 >> 24) & 0xff, (3 >> 16) & 0xff, (3 >> 8) & 0xff, (3) & 0xff };
+            testProcessor.version = 3;
+            //need a valid headerbuffer.
+            Byte firstByte = ((testProcessor.version & 0x0f) << 4) + (0 << 3) + (1 & 0x07); //version 2 with no encryption, frametype 1
+            UInt32 dataLength = 3;
+            const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (dataLength >> 24) & 0xff, (dataLength >> 16) & 0xff, (dataLength >> 8) & 0xff, (dataLength) & 0xff };
             [testHeaderBuffer appendBytes:&testBytes length:8];
             UInt32 messageID = 0;
             Byte messageIDBytes[4] = {(messageID >> 24) & 0xff, (messageID >> 16) & 0xff, (messageID >> 8) & 0xff, (messageID) & 0xff};
             [testHeaderBuffer appendBytes:&messageIDBytes length:4];
             
             testProcessor.headerBuffer = testHeaderBuffer;
+            expectedMessageReadyHeader= [SDLProtocolHeader headerForVersion:testProcessor.version];
+            [expectedMessageReadyHeader parse:testHeaderBuffer];
             
             Byte testByte = 0xBA;
             [testBuffer appendBytes:&testByte length:1];
@@ -545,9 +685,12 @@ describe(@"The received message processor", ^{
                 testProcessor.dataBytesRemaining = 2;
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                //expect(messageReadyPayload).toEventually(beNil());
             });
         });
         context(@"dataBytesRemaining is 1", ^{
@@ -555,9 +698,13 @@ describe(@"The received message processor", ^{
                 testProcessor.dataBytesRemaining = 1;
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    //do nothing?
+                    messageReadyHeader = header;
+                    //messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).to(equal(expectedMessageReadyHeader));
+                //expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
+                //expect(messageReadyPayload).toEventually(equal(testBuffer));
             });
         });
     });
-- 
cgit v1.2.1


From 21f50e3b1d7bc8da5dcdacbbd9908e11de195834 Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Thu, 18 Aug 2022 15:30:13 -0400
Subject: cleanup and review edits

---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 32 +++++++++++++++-------
 1 file changed, 22 insertions(+), 10 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index ab25b4a13..69a683573 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -53,6 +53,10 @@ typedef NS_ENUM(NSInteger, ProcessorState) {
 
 QuickSpecBegin(SDLProtocolReceivedMessageProcessorSpec)
 
+// set up all test constants
+
+
+
 describe(@"The received message processor", ^{
     __block SDLProtocolReceivedMessageProcessor *testProcessor = nil;
     __block NSMutableData *testBuffer;
@@ -60,6 +64,7 @@ describe(@"The received message processor", ^{
     __block SDLProtocolHeader *messageReadyHeader = nil;
     __block SDLProtocolHeader *expectedMessageReadyHeader = nil;
     __block NSData *messageReadyPayload = nil;
+    __block NSData *expectedPayloadBuffer = nil;
     
     beforeEach(^{
         testProcessor = [[SDLProtocolReceivedMessageProcessor alloc] init];
@@ -485,6 +490,11 @@ describe(@"The received message processor", ^{
                 [testHeaderBuffer appendBytes:&messageIDBytes length:4];
                 
                 testProcessor.headerBuffer = testHeaderBuffer;
+                expectedMessageReadyHeader= [SDLProtocolHeader headerForVersion:testProcessor.version];
+                [expectedMessageReadyHeader parse:testHeaderBuffer];
+                
+                expectedPayloadBuffer = [NSData data];
+                
             });
             context(@"datalength is 0", ^{
                 context(@"recieves a byte", ^{
@@ -493,12 +503,12 @@ describe(@"The received message processor", ^{
                         messageReadyHeader = [SDLProtocolHeader headerForVersion:1];
                         
                         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                            messageReadyHeader = [header copy];
-                            messageReadyPayload = [payload copy];
+                            messageReadyHeader = header;
+                            messageReadyPayload = payload;
                         }];
                         expect(@(testProcessor.state)).to(equal(START_STATE));
-                        //expect(messageReadyHeader).toEventually(beNil());  //TODO - these will have values here!!!
-                        //expect(messageReadyPayload).toEventually(beNil());
+                        expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
+                        expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
                     });
                 });
             });
@@ -621,8 +631,11 @@ describe(@"The received message processor", ^{
             [testHeaderBuffer appendBytes:&messageIDBytes length:4];
             
             testProcessor.headerBuffer = testHeaderBuffer;
+            expectedMessageReadyHeader= [SDLProtocolHeader headerForVersion:testProcessor.version];
             [expectedMessageReadyHeader parse:testHeaderBuffer];
             
+            expectedPayloadBuffer = [NSData data];
+            
             messageReadyHeader = nil;
             messageReadyPayload = nil;
             
@@ -639,7 +652,7 @@ describe(@"The received message processor", ^{
                     }];
                     expect(@(testProcessor.state)).to(equal(START_STATE));
                     expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
-                    //expect(messageReadyPayload).toEventually(equal(testBuffer));
+                    expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
                 });
             });
         });
@@ -690,7 +703,7 @@ describe(@"The received message processor", ^{
                 }];
                 expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
-                //expect(messageReadyPayload).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
             });
         });
         context(@"dataBytesRemaining is 1", ^{
@@ -699,12 +712,11 @@ describe(@"The received message processor", ^{
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                     messageReadyHeader = header;
-                    //messageReadyPayload = payload;
+                    messageReadyPayload = payload;
                 }];
                 expect(@(testProcessor.state)).to(equal(START_STATE));
-                expect(messageReadyHeader).to(equal(expectedMessageReadyHeader));
-                //expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
-                //expect(messageReadyPayload).toEventually(equal(testBuffer));
+                expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
+                expect(messageReadyPayload).toEventually(equal(testBuffer));
             });
         });
     });
-- 
cgit v1.2.1


From 57660956c7db94bd26a8c473274a20f647dc5edd Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Thu, 18 Aug 2022 15:49:25 -0400
Subject: update the reset function.

---
 .../ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m   | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 69a683573..39f1e67ee 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -94,6 +94,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(testProcessor.version).toEventually(equal(1));
                 });
             });
             context(@"with a good version 2", ^{
@@ -106,8 +107,10 @@ describe(@"The received message processor", ^{
                         messageReadyPayload = payload;
                     }];
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                    
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(testProcessor.version).toEventually(equal(2));
                 });
             });
             context(@"with a good version 3", ^{
@@ -122,6 +125,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(testProcessor.version).toEventually(equal(3));
                 });
             });
             context(@"with a good version 4", ^{
@@ -136,6 +140,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(testProcessor.version).toEventually(equal(4));
                 });
             });
             context(@"with a good version 5", ^{
@@ -150,6 +155,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(testProcessor.version).toEventually(equal(5));
                 });
             });
             context(@"with a bad version 0", ^{
@@ -164,6 +170,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(START_STATE));
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(testProcessor.version).toEventually(equal(0));
                 });
             });
             context(@"with a bad version 6", ^{
@@ -178,6 +185,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(START_STATE));
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(testProcessor.version).toEventually(equal(0));
                 });
             });
             context(@"with a frameType of SDLFrameTypeControl", ^{
@@ -558,6 +566,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(MESSAGE_1_STATE));
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(testProcessor.version).toEventually(equal(2));
                 });
             });
     
@@ -704,6 +713,7 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(testProcessor.dataBytesRemaining).toEventually(equal(1));
             });
         });
         context(@"dataBytesRemaining is 1", ^{
@@ -717,6 +727,7 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(START_STATE));
                 expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
                 expect(messageReadyPayload).toEventually(equal(testBuffer));
+                expect(testProcessor.dataBytesRemaining).toEventually(equal(0));
             });
         });
     });
-- 
cgit v1.2.1


From 86a5a68ecec70aca9f3649537165da6efd7f1ee0 Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Thu, 18 Aug 2022 16:43:59 -0400
Subject: review edits

---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 65 +++++++++++++++++-----
 1 file changed, 51 insertions(+), 14 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 39f1e67ee..682fe78a2 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -214,6 +214,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeSingle));
                 });
             });
             context(@"with a frameType of SDLFrameTypeFirst", ^{
@@ -228,6 +229,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
                 });
             });
             context(@"with a frameType of SDLFrameTypeConsecutive", ^{
@@ -242,6 +244,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeConsecutive));
                 });
             });
             context(@"with an invalid frameType of 6", ^{
@@ -256,6 +259,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(START_STATE));
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(@(testProcessor.frameType)).toEventually(equal(0));
                 });
             });
         });
@@ -277,6 +281,7 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeControl));
             });
         });
         context(@"When it recieves a SDLServiceTypeRPC byte", ^{
@@ -291,6 +296,7 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeRPC));
             });
         });
         context(@"When it recieves a SDLServiceTypeAudio byte", ^{
@@ -305,6 +311,7 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeAudio));
             });
         });
         context(@"When it recieves a SDLServiceTypeVideo byte", ^{
@@ -319,6 +326,7 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeVideo));
             });
         });
         context(@"When it recieves a SDLServiceTypeBulkData byte", ^{
@@ -333,6 +341,7 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeBulkData));
             });
         });
         context(@"recieves an invalid byte", ^{
@@ -347,16 +356,15 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(START_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.serviceType)).toEventually(equal(0));
             });
         });
     });
     
     context(@"in CONTROL_FRAME_INFO_STATE", ^{
-        beforeEach(^{
-            testProcessor.state = CONTROL_FRAME_INFO_STATE;
-        });
         context(@"recieves a valid byte", ^{
             it(@"transitions to SESSION_ID_STATE", ^{
+                testProcessor.state = CONTROL_FRAME_INFO_STATE;
                 Byte testByte = 0x00;
                 testProcessor.frameType = SDLFrameTypeFirst;
                 [testBuffer appendBytes:&testByte length:1];
@@ -368,10 +376,12 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
             });
         });
         context(@"controlFrameInfo is not 0 for a SDLFrameTypeFirst", ^{
             it(@"resets to START_STATE", ^{
+                testProcessor.state = CONTROL_FRAME_INFO_STATE;
                 Byte testByte = 0x01;
                 testProcessor.frameType = SDLFrameTypeFirst;
                 [testBuffer appendBytes:&testByte length:1];
@@ -383,10 +393,12 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(START_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.frameType)).toEventually(equal(0x00));
             });
         });
         context(@"controlFrameInfo is not 0 for a SDLFrameTypeSingle", ^{
             it(@"resets to START_STATE", ^{
+                testProcessor.state = CONTROL_FRAME_INFO_STATE;
                 Byte testByte = 0x01;
                 testProcessor.frameType = SDLFrameTypeSingle;
                 [testBuffer appendBytes:&testByte length:1];
@@ -398,6 +410,7 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(START_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.frameType)).toEventually(equal(0x00));
             });
         });
         
@@ -417,6 +430,8 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(DATA_SIZE_1_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.dataLength)).toEventually(equal(0));
+                
             });
         });
     });
@@ -425,7 +440,7 @@ describe(@"The received message processor", ^{
         context(@"recieves a byte", ^{
             it(@"transitions to DATA_SIZE_2_STATE", ^{
                 testProcessor.state = DATA_SIZE_1_STATE;
-                Byte testByte = 0x00;
+                Byte testByte = 0x02;
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
@@ -435,6 +450,7 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(DATA_SIZE_2_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 24));
             });
         });
     });
@@ -443,7 +459,7 @@ describe(@"The received message processor", ^{
         context(@"recieves a byte", ^{
             it(@"transitions to DATA_SIZE_3_STATE", ^{
                 testProcessor.state = DATA_SIZE_2_STATE;
-                Byte testByte = 0x00;
+                Byte testByte = 0x02;
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
@@ -453,6 +469,7 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(DATA_SIZE_3_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 16));
             });
         });
     });
@@ -461,7 +478,7 @@ describe(@"The received message processor", ^{
         context(@"recieves a byte", ^{
             it(@"transitions to DATA_SIZE_4_STATE", ^{
                 testProcessor.state = DATA_SIZE_3_STATE;
-                Byte testByte = 0x00;
+                Byte testByte = 0x02;
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
@@ -471,6 +488,7 @@ describe(@"The received message processor", ^{
                 expect(@(testProcessor.state)).to(equal(DATA_SIZE_4_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 8));
             });
         });
     });
@@ -478,12 +496,8 @@ describe(@"The received message processor", ^{
     context(@"in DATA_SIZE_4_STATE", ^{
         beforeEach(^{
             testProcessor.state = DATA_SIZE_4_STATE;
-            testProcessor.version = 3;
             messageReadyHeader = nil;
             messageReadyPayload = nil;
-            
-            Byte testByte = 0x00;
-            [testBuffer appendBytes:&testByte length:1];
         });
         context(@"if version is 1", ^{
             beforeEach(^{
@@ -507,7 +521,10 @@ describe(@"The received message processor", ^{
             context(@"datalength is 0", ^{
                 context(@"recieves a byte", ^{
                     it(@"resets state to START_STATE", ^{
-                        testProcessor.dataLength = 0;
+                        //testProcessor.dataLength = 0;  //can't jsut assign this, since this state changes this value
+
+                        Byte testByte = 0x00;
+                        [testBuffer appendBytes:&testByte length:1];
                         messageReadyHeader = [SDLProtocolHeader headerForVersion:1];
                         
                         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
@@ -517,13 +534,18 @@ describe(@"The received message processor", ^{
                         expect(@(testProcessor.state)).to(equal(START_STATE));
                         expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
                         expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
+                        expect(@(testProcessor.dataLength)).toEventually(equal(0));
+                        expect(@(testProcessor.version)).toEventually(equal(0));
                     });
                 });
             });
             context(@"datalength is greater than 0", ^{
                 context(@"recieves a byte", ^{
                     it(@"transitions to DATA_PUMP_STATE", ^{
-                        testProcessor.dataLength = 1;
+                        //testProcessor.dataLength = 0;  //can't jsut assign this, since this state changes this value
+
+                        Byte testByte = 0x01;
+                        [testBuffer appendBytes:&testByte length:1];
                         
                         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                             messageReadyHeader = header;
@@ -532,15 +554,20 @@ describe(@"The received message processor", ^{
                         expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
                         expect(messageReadyHeader).toEventually(beNil());
                         expect(messageReadyPayload).toEventually(beNil());
+                        expect(@(testProcessor.dataLength)).toEventually(equal(1));
+                        expect(@(testProcessor.version)).toEventually(equal(1));
                     });
                 });
             });
             context(@"datalength is greater than maxMtuSize", ^{
                 context(@"recieves a byte", ^{
-                    it(@"transitions to DATA_PUMP_STATE", ^{
+                    it(@"transitions to START_STATE", ^{
                         testProcessor.serviceType = SDLServiceTypeControl;
                         testProcessor.dataLength = 200000;
                         
+                        Byte testByte = 0x00;
+                        [testBuffer appendBytes:&testByte length:1];
+                        
                         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                             messageReadyHeader = header;
                             messageReadyPayload = payload;
@@ -548,6 +575,9 @@ describe(@"The received message processor", ^{
                         expect(@(testProcessor.state)).to(equal(START_STATE));
                         expect(messageReadyHeader).toEventually(beNil());
                         expect(messageReadyPayload).toEventually(beNil());
+                        expect(@(testProcessor.serviceType)).toEventually(equal(0));
+                        expect(@(testProcessor.dataLength)).toEventually(equal(0));
+                        expect(@(testProcessor.version)).toEventually(equal(0));
                     });
                 });
             });
@@ -559,6 +589,9 @@ describe(@"The received message processor", ^{
                     testProcessor.version = 2;
                     testProcessor.dataLength = 0;
                     
+                    Byte testByte = 0x00;
+                    [testBuffer appendBytes:&testByte length:1];
+                    
                     [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                         messageReadyHeader = header;
                         messageReadyPayload = payload;
@@ -569,7 +602,6 @@ describe(@"The received message processor", ^{
                     expect(testProcessor.version).toEventually(equal(2));
                 });
             });
-    
         });
     });
     
@@ -630,6 +662,7 @@ describe(@"The received message processor", ^{
     context(@"in MESSAGE_4_STATE", ^{
         beforeEach(^{
             testProcessor.state = MESSAGE_4_STATE;
+            testProcessor.version = 2;
             //need a valid headerbuffer.
             Byte firstByte = ((testProcessor.version & 0x0f) << 4) + (0 << 3) + (1 & 0x07); //version 2 with no encryption, frametype 1
             UInt32 dataLength = 3;
@@ -662,6 +695,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(START_STATE));
                     expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
                     expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
+                    expect(testProcessor.version).toEventually(equal(0));
                 });
             });
         });
@@ -677,6 +711,7 @@ describe(@"The received message processor", ^{
                     expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
                     expect(messageReadyHeader).toEventually(beNil());
                     expect(messageReadyPayload).toEventually(beNil());
+                    expect(testProcessor.version).toEventually(equal(2));
                 });
             });
         });
@@ -714,6 +749,7 @@ describe(@"The received message processor", ^{
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
                 expect(testProcessor.dataBytesRemaining).toEventually(equal(1));
+                expect(testProcessor.version).toEventually(equal(3));
             });
         });
         context(@"dataBytesRemaining is 1", ^{
@@ -728,6 +764,7 @@ describe(@"The received message processor", ^{
                 expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
                 expect(messageReadyPayload).toEventually(equal(testBuffer));
                 expect(testProcessor.dataBytesRemaining).toEventually(equal(0));
+                expect(testProcessor.version).toEventually(equal(0));
             });
         });
     });
-- 
cgit v1.2.1


From 54980c4f4ffe6fad39e6dd9fe6e3c42d3d6ca313 Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Fri, 19 Aug 2022 11:14:05 -0400
Subject: review edits

---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 1073 ++++++++++----------
 1 file changed, 530 insertions(+), 543 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 682fe78a2..ede53db5a 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -75,540 +75,523 @@ describe(@"The received message processor", ^{
         messageReadyPayload = nil;
     });
     
-    context(@"in START_STATE", ^{
-        beforeEach(^{
+    //context(@"in START_STATE", ^{
+    context(@"when in START_STATE, it receives a byte with a good version 1", ^{
+        it(@"transitions to SERVICE_TYPE_STATE", ^{
             testProcessor.state = START_STATE;
+            Byte testByte = 0x11;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            expect(messageReadyPayload).toEventually(beNil());
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+                expect(messageReadyPayload).toEventually(beNil());
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(1));
         });
-        context(@"When it recieves a byte", ^{
-            context(@"with a good version 1", ^{
-                it(@"transitions to SERVICE_TYPE_STATE", ^{
-                    Byte testByte = 0x11;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    expect(messageReadyPayload).toEventually(beNil());
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                        expect(messageReadyPayload).toEventually(beNil());
-                    }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(testProcessor.version).toEventually(equal(1));
-                });
-            });
-            context(@"with a good version 2", ^{
-                it(@"transitions to SERVICE_TYPE_STATE", ^{
-                    Byte testByte = 0x21;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-                    
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(testProcessor.version).toEventually(equal(2));
-                });
-            });
-            context(@"with a good version 3", ^{
-                it(@"transitions to SERVICE_TYPE_STATE", ^{
-                    Byte testByte = 0x31;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(testProcessor.version).toEventually(equal(3));
-                });
-            });
-            context(@"with a good version 4", ^{
-                it(@"transitions to SERVICE_TYPE_STATE", ^{
-                    Byte testByte = 0x41;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(testProcessor.version).toEventually(equal(4));
-                });
-            });
-            context(@"with a good version 5", ^{
-                it(@"transitions to SERVICE_TYPE_STATE", ^{
-                    Byte testByte = 0x51;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(testProcessor.version).toEventually(equal(5));
-                });
-            });
-            context(@"with a bad version 0", ^{
-                it(@"resets state to START_STATE if the byte is not valid", ^{
-                    Byte testByte = 0x01;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(START_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(testProcessor.version).toEventually(equal(0));
-                });
-            });
-            context(@"with a bad version 6", ^{
-                it(@"resets state to START_STATE if the byte is not valid", ^{
-                    Byte testByte = 0x61;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(START_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(testProcessor.version).toEventually(equal(0));
-                });
-            });
-            context(@"with a frameType of SDLFrameTypeControl", ^{
-                it(@"transitions to SERVICE_TYPE_STATE", ^{
-                    Byte testByte = 0x10;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                });
-            });
-            context(@"with a frameType of SDLFrameTypeSingle", ^{
-                it(@"transitions to SERVICE_TYPE_STATE", ^{
-                    Byte testByte = 0x11;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeSingle));
-                });
-            });
-            context(@"with a frameType of SDLFrameTypeFirst", ^{
-                it(@"transitions to SERVICE_TYPE_STATE", ^{
-                    Byte testByte = 0x12;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
-                });
-            });
-            context(@"with a frameType of SDLFrameTypeConsecutive", ^{
-                it(@"transitions to SERVICE_TYPE_STATE", ^{
-                    Byte testByte = 0x13;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeConsecutive));
-                });
-            });
-            context(@"with an invalid frameType of 6", ^{
-                it(@"resets state to START_STATE", ^{
-                    Byte testByte = 0x66;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(START_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(@(testProcessor.frameType)).toEventually(equal(0));
-                });
-            });
+    });
+    context(@"when in START_STATE, it receives a byte with a good version 2", ^{
+        it(@"transitions to SERVICE_TYPE_STATE", ^{
+            testProcessor.state = START_STATE;
+            Byte testByte = 0x21;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(2));
         });
     });
-    
-    context(@"in SERVICE_TYPE_STATE", ^{
-        beforeEach(^{
+    context(@"when in START_STATE, it receives a byte with a good version 3", ^{
+        it(@"transitions to SERVICE_TYPE_STATE", ^{
+            testProcessor.state = START_STATE;
+            Byte testByte = 0x31;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(3));
+        });
+    });
+    context(@"when in START_STATE, it receives a byte with a good version 4", ^{
+        it(@"transitions to SERVICE_TYPE_STATE", ^{
+            testProcessor.state = START_STATE;
+            Byte testByte = 0x41;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(4));
+        });
+    });
+    context(@"when in START_STATE, it receives a byte with a good version 5", ^{
+        it(@"transitions to SERVICE_TYPE_STATE", ^{
+            testProcessor.state = START_STATE;
+            Byte testByte = 0x51;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(5));
+        });
+    });
+    context(@"when in START_STATE, it receives a byte with a bad version 0", ^{
+        it(@"resets state to START_STATE if the byte is not valid", ^{
+            testProcessor.state = START_STATE;
+            Byte testByte = 0x01;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(0));
+        });
+    });
+    context(@"when in START_STATE, it receives a byte with a bad version 6", ^{
+        it(@"resets state to START_STATE if the byte is not valid", ^{
+            testProcessor.state = START_STATE;
+            Byte testByte = 0x61;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(0));
+        });
+    });
+    context(@"when in START_STATE, it receives a byte with a frameType of SDLFrameTypeControl", ^{
+        it(@"transitions to SERVICE_TYPE_STATE", ^{
+            testProcessor.state = START_STATE;
+            Byte testByte = 0x10;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+        });
+    });
+    context(@"when in START_STATE, it receives a byte with a frameType of SDLFrameTypeSingle", ^{
+        it(@"transitions to SERVICE_TYPE_STATE", ^{
+            testProcessor.state = START_STATE;
+            Byte testByte = 0x11;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeSingle));
+        });
+    });
+    context(@"when in START_STATE, it receives a byte with a frameType of SDLFrameTypeFirst", ^{
+        it(@"transitions to SERVICE_TYPE_STATE", ^{
+            testProcessor.state = START_STATE;
+            Byte testByte = 0x12;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
+        });
+    });
+    context(@"when in START_STATE, it receives a byte with a frameType of SDLFrameTypeConsecutive", ^{
+        it(@"transitions to SERVICE_TYPE_STATE", ^{
+            testProcessor.state = START_STATE;
+            Byte testByte = 0x13;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeConsecutive));
+        });
+    });
+    context(@"when in START_STATE, it receives a byte with an invalid frameType of 6", ^{
+        it(@"resets state to START_STATE", ^{
+            testProcessor.state = START_STATE;
+            Byte testByte = 0x46; //0100 0 110
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.frameType)).toEventually(equal(0));
+            expect(testProcessor.version).toEventually(equal(0));
+            
+        });
+    });
+    context(@"when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeControl byte", ^{
+        it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
             testProcessor.state = SERVICE_TYPE_STATE;
+            Byte testByte = SDLServiceTypeControl;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeControl));
         });
-        context(@"When it recieves a SDLServiceTypeControl byte", ^{
-            it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
-                Byte testByte = SDLServiceTypeControl;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeControl));
-            });
+    });
+    context(@"when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeRPC byte", ^{
+        it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
+            testProcessor.state = SERVICE_TYPE_STATE;
+            Byte testByte = SDLServiceTypeRPC;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeRPC));
         });
-        context(@"When it recieves a SDLServiceTypeRPC byte", ^{
-            it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
-                Byte testByte = SDLServiceTypeRPC;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeRPC));
-            });
+    });
+    context(@"when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeAudio byte", ^{
+        it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
+            testProcessor.state = SERVICE_TYPE_STATE;
+            Byte testByte = SDLServiceTypeAudio;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeAudio));
         });
-        context(@"When it recieves a SDLServiceTypeAudio byte", ^{
-            it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
-                Byte testByte = SDLServiceTypeAudio;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeAudio));
-            });
+    });
+    context(@"when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeVideo byte", ^{
+        it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
+            testProcessor.state = SERVICE_TYPE_STATE;
+            Byte testByte = SDLServiceTypeVideo;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeVideo));
         });
-        context(@"When it recieves a SDLServiceTypeVideo byte", ^{
-            it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
-                Byte testByte = SDLServiceTypeVideo;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeVideo));
-            });
+    });
+    context(@"when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeBulkData byte", ^{
+        it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
+            testProcessor.state = SERVICE_TYPE_STATE;
+            Byte testByte = SDLServiceTypeBulkData;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeBulkData));
         });
-        context(@"When it recieves a SDLServiceTypeBulkData byte", ^{
-            it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
-                Byte testByte = SDLServiceTypeBulkData;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeBulkData));
-            });
+    });
+    context(@"when in SERVICE_TYPE_STATE, it receives a invalid byte", ^{
+        it(@"resets state to START_STATE", ^{
+            testProcessor.state = SERVICE_TYPE_STATE;
+            Byte testByte = 0xFF;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.serviceType)).toEventually(equal(0));
         });
-        context(@"recieves an invalid byte", ^{
-            it(@"resets state to START_STATE", ^{
-                Byte testByte = 0xFF;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(START_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.serviceType)).toEventually(equal(0));
-            });
+    });
+    context(@"when in CONTROL_FRAME_INFO_STATE, it receives a valid byte", ^{
+        it(@"transitions to SESSION_ID_STATE", ^{
+            testProcessor.state = CONTROL_FRAME_INFO_STATE;
+            Byte testByte = 0x00;
+            testProcessor.frameType = SDLFrameTypeFirst;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
         });
     });
-    
-    context(@"in CONTROL_FRAME_INFO_STATE", ^{
-        context(@"recieves a valid byte", ^{
-            it(@"transitions to SESSION_ID_STATE", ^{
-                testProcessor.state = CONTROL_FRAME_INFO_STATE;
-                Byte testByte = 0x00;
-                testProcessor.frameType = SDLFrameTypeFirst;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
-            });
+    context(@"when in CONTROL_FRAME_INFO_STATE, it receives a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeFirst", ^{
+        it(@"resets to START_STATE", ^{
+            testProcessor.state = CONTROL_FRAME_INFO_STATE;
+            Byte testByte = 0x01;
+            testProcessor.frameType = SDLFrameTypeFirst;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.frameType)).toEventually(equal(0x00));
         });
-        context(@"controlFrameInfo is not 0 for a SDLFrameTypeFirst", ^{
-            it(@"resets to START_STATE", ^{
-                testProcessor.state = CONTROL_FRAME_INFO_STATE;
-                Byte testByte = 0x01;
-                testProcessor.frameType = SDLFrameTypeFirst;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(START_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.frameType)).toEventually(equal(0x00));
-            });
+    });
+    context(@"when in CONTROL_FRAME_INFO_STATE, it receives a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeSingle", ^{
+        it(@"resets to START_STATE", ^{
+            testProcessor.state = CONTROL_FRAME_INFO_STATE;
+            Byte testByte = 0x01;
+            testProcessor.frameType = SDLFrameTypeSingle;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.frameType)).toEventually(equal(0x00));
         });
-        context(@"controlFrameInfo is not 0 for a SDLFrameTypeSingle", ^{
-            it(@"resets to START_STATE", ^{
-                testProcessor.state = CONTROL_FRAME_INFO_STATE;
-                Byte testByte = 0x01;
-                testProcessor.frameType = SDLFrameTypeSingle;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(START_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.frameType)).toEventually(equal(0x00));
-            });
+    });
+    context(@"when in SESSION_ID_STATE, it receives a byte", ^{
+        it(@"transitions to DATA_SIZE_1_STATE", ^{
+            testProcessor.state = SESSION_ID_STATE;
+            Byte testByte = 0x00;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(DATA_SIZE_1_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.dataLength)).toEventually(equal(0));
+            
         });
-        
     });
-    
-    context(@"in SESSION_ID_STATE", ^{
-        context(@"recieves a byte", ^{
-            it(@"transitions to DATA_SIZE_1_STATE", ^{
-                testProcessor.state = SESSION_ID_STATE;
+    context(@"when in DATA_SIZE_1_STATE, it receives a byte", ^{
+        it(@"transitions to DATA_SIZE_2_STATE", ^{
+            testProcessor.state = DATA_SIZE_1_STATE;
+            Byte testByte = 0x02;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(DATA_SIZE_2_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 24));
+        });
+    });
+    context(@"when in DATA_SIZE_2_STATE, it receives a byte", ^{
+        it(@"transitions to DATA_SIZE_3_STATE", ^{
+            testProcessor.state = DATA_SIZE_2_STATE;
+            Byte testByte = 0x02;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(DATA_SIZE_3_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 16));
+        });
+    });
+    context(@"when in DATA_SIZE_3_STATE, it receives a byte", ^{
+        it(@"transitions to DATA_SIZE_4_STATE", ^{
+            testProcessor.state = DATA_SIZE_3_STATE;
+            Byte testByte = 0x02;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(DATA_SIZE_4_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 8));
+        });
+    });
+    describe(@"when in DATA_SIZE_4_STATE, the version is 1", ^{
+        beforeEach(^{
+            testProcessor.state = DATA_SIZE_4_STATE;
+            testProcessor.version = 1;
+            
+            messageReadyHeader = nil;
+            messageReadyPayload = nil;
+            
+            
+            //need a valid headerbuffer.
+            Byte firstByte = ((testProcessor.version & 0x0f) << 4) + (0 << 3) + (1 & 0x07); //version 2 with no encryption, frametype 1
+            UInt32 dataLength = 3;
+            const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (dataLength >> 24) & 0xff, (dataLength >> 16) & 0xff, (dataLength >> 8) & 0xff, (dataLength) & 0xff };
+            [testHeaderBuffer appendBytes:&testBytes length:8];
+            UInt32 messageID = 0;
+            Byte messageIDBytes[4] = {(messageID >> 24) & 0xff, (messageID >> 16) & 0xff, (messageID >> 8) & 0xff, (messageID) & 0xff};
+            [testHeaderBuffer appendBytes:&messageIDBytes length:4];
+            
+            testProcessor.headerBuffer = testHeaderBuffer;
+            expectedMessageReadyHeader= [SDLProtocolHeader headerForVersion:testProcessor.version];
+            [expectedMessageReadyHeader parse:testHeaderBuffer];
+            
+            expectedPayloadBuffer = [NSData data];
+        });
+        context(@"and it receives a byte and determines the data length is 0", ^{
+            it(@"resets state to START_STATE", ^{
+
                 Byte testByte = 0x00;
                 [testBuffer appendBytes:&testByte length:1];
+                messageReadyHeader = [SDLProtocolHeader headerForVersion:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                     messageReadyHeader = header;
                     messageReadyPayload = payload;
                 }];
-                expect(@(testProcessor.state)).to(equal(DATA_SIZE_1_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
+                expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
+                expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
                 expect(@(testProcessor.dataLength)).toEventually(equal(0));
-                
+                expect(@(testProcessor.version)).toEventually(equal(0));
             });
         });
-    });
-    
-    context(@"in DATA_SIZE_1_STATE", ^{
-        context(@"recieves a byte", ^{
-            it(@"transitions to DATA_SIZE_2_STATE", ^{
-                testProcessor.state = DATA_SIZE_1_STATE;
-                Byte testByte = 0x02;
+        context(@"and it receives a byte and determines the data length is greater than 0", ^{
+            it(@"transitions to DATA_PUMP_STATE", ^{
+
+                Byte testByte = 0x01;
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                     messageReadyHeader = header;
                     messageReadyPayload = payload;
                 }];
-                expect(@(testProcessor.state)).to(equal(DATA_SIZE_2_STATE));
+                expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 24));
+                expect(@(testProcessor.dataLength)).toEventually(equal(1));
+                expect(@(testProcessor.version)).toEventually(equal(1));
             });
         });
-    });
-    
-    context(@"in DATA_SIZE_2_STATE", ^{
-        context(@"recieves a byte", ^{
-            it(@"transitions to DATA_SIZE_3_STATE", ^{
-                testProcessor.state = DATA_SIZE_2_STATE;
-                Byte testByte = 0x02;
-                [testBuffer appendBytes:&testByte length:1];
+        context(@"and it receives a byte and determines the data length is ggreater than maxMtuSize", ^{
+            it(@"transitions to START_STATE", ^{
+                testProcessor.serviceType = SDLServiceTypeControl;
+                testProcessor.dataLength = 200000;
                 
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(DATA_SIZE_3_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 16));
-            });
-        });
-    });
-    
-    context(@"in DATA_SIZE_3_STATE", ^{
-        context(@"recieves a byte", ^{
-            it(@"transitions to DATA_SIZE_4_STATE", ^{
-                testProcessor.state = DATA_SIZE_3_STATE;
-                Byte testByte = 0x02;
+                Byte testByte = 0x00;
                 [testBuffer appendBytes:&testByte length:1];
                 
                 [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                     messageReadyHeader = header;
                     messageReadyPayload = payload;
                 }];
-                expect(@(testProcessor.state)).to(equal(DATA_SIZE_4_STATE));
+                expect(@(testProcessor.state)).to(equal(START_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 8));
+                expect(@(testProcessor.serviceType)).toEventually(equal(0));
+                expect(@(testProcessor.dataLength)).toEventually(equal(0));
+                expect(@(testProcessor.version)).toEventually(equal(0));
             });
         });
     });
-    
-    context(@"in DATA_SIZE_4_STATE", ^{
+    describe(@"when in DATA_SIZE_4_STATE, the version is greater than 1", ^{
         beforeEach(^{
             testProcessor.state = DATA_SIZE_4_STATE;
             messageReadyHeader = nil;
             messageReadyPayload = nil;
-        });
-        context(@"if version is 1", ^{
-            beforeEach(^{
-                testProcessor.version = 1;
-                //need a valid headerbuffer.
-                Byte firstByte = ((testProcessor.version & 0x0f) << 4) + (0 << 3) + (1 & 0x07); //version 2 with no encryption, frametype 1
-                UInt32 dataLength = 3;
-                const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (dataLength >> 24) & 0xff, (dataLength >> 16) & 0xff, (dataLength >> 8) & 0xff, (dataLength) & 0xff };
-                [testHeaderBuffer appendBytes:&testBytes length:8];
-                UInt32 messageID = 0;
-                Byte messageIDBytes[4] = {(messageID >> 24) & 0xff, (messageID >> 16) & 0xff, (messageID >> 8) & 0xff, (messageID) & 0xff};
-                [testHeaderBuffer appendBytes:&messageIDBytes length:4];
-                
-                testProcessor.headerBuffer = testHeaderBuffer;
-                expectedMessageReadyHeader= [SDLProtocolHeader headerForVersion:testProcessor.version];
-                [expectedMessageReadyHeader parse:testHeaderBuffer];
-                
-                expectedPayloadBuffer = [NSData data];
-                
-            });
-            context(@"datalength is 0", ^{
-                context(@"recieves a byte", ^{
-                    it(@"resets state to START_STATE", ^{
-                        //testProcessor.dataLength = 0;  //can't jsut assign this, since this state changes this value
-
-                        Byte testByte = 0x00;
-                        [testBuffer appendBytes:&testByte length:1];
-                        messageReadyHeader = [SDLProtocolHeader headerForVersion:1];
-                        
-                        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                            messageReadyHeader = header;
-                            messageReadyPayload = payload;
-                        }];
-                        expect(@(testProcessor.state)).to(equal(START_STATE));
-                        expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
-                        expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
-                        expect(@(testProcessor.dataLength)).toEventually(equal(0));
-                        expect(@(testProcessor.version)).toEventually(equal(0));
-                    });
-                });
-            });
-            context(@"datalength is greater than 0", ^{
-                context(@"recieves a byte", ^{
-                    it(@"transitions to DATA_PUMP_STATE", ^{
-                        //testProcessor.dataLength = 0;  //can't jsut assign this, since this state changes this value
-
-                        Byte testByte = 0x01;
-                        [testBuffer appendBytes:&testByte length:1];
-                        
-                        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                            messageReadyHeader = header;
-                            messageReadyPayload = payload;
-                        }];
-                        expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
-                        expect(messageReadyHeader).toEventually(beNil());
-                        expect(messageReadyPayload).toEventually(beNil());
-                        expect(@(testProcessor.dataLength)).toEventually(equal(1));
-                        expect(@(testProcessor.version)).toEventually(equal(1));
-                    });
-                });
-            });
-            context(@"datalength is greater than maxMtuSize", ^{
-                context(@"recieves a byte", ^{
-                    it(@"transitions to START_STATE", ^{
-                        testProcessor.serviceType = SDLServiceTypeControl;
-                        testProcessor.dataLength = 200000;
-                        
-                        Byte testByte = 0x00;
-                        [testBuffer appendBytes:&testByte length:1];
-                        
-                        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                            messageReadyHeader = header;
-                            messageReadyPayload = payload;
-                        }];
-                        expect(@(testProcessor.state)).to(equal(START_STATE));
-                        expect(messageReadyHeader).toEventually(beNil());
-                        expect(messageReadyPayload).toEventually(beNil());
-                        expect(@(testProcessor.serviceType)).toEventually(equal(0));
-                        expect(@(testProcessor.dataLength)).toEventually(equal(0));
-                        expect(@(testProcessor.version)).toEventually(equal(0));
-                    });
-                });
-            });
+            
+            testProcessor.version = 1;
+            //need a valid headerbuffer.
+            Byte firstByte = ((testProcessor.version & 0x0f) << 4) + (0 << 3) + (1 & 0x07); //version 2 with no encryption, frametype 1
+            UInt32 dataLength = 3;
+            const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (dataLength >> 24) & 0xff, (dataLength >> 16) & 0xff, (dataLength >> 8) & 0xff, (dataLength) & 0xff };
+            [testHeaderBuffer appendBytes:&testBytes length:8];
+            UInt32 messageID = 0;
+            Byte messageIDBytes[4] = {(messageID >> 24) & 0xff, (messageID >> 16) & 0xff, (messageID >> 8) & 0xff, (messageID) & 0xff};
+            [testHeaderBuffer appendBytes:&messageIDBytes length:4];
+            
+            testProcessor.headerBuffer = testHeaderBuffer;
+            expectedMessageReadyHeader= [SDLProtocolHeader headerForVersion:testProcessor.version];
+            [expectedMessageReadyHeader parse:testHeaderBuffer];
+            
+            expectedPayloadBuffer = [NSData data];
             
         });
-        context(@"if version greater than 1", ^{
-            context(@"recieves a byte", ^{
-                it(@"transitions to MESSAGE_1_STATE", ^{
-                    testProcessor.version = 2;
-                    testProcessor.dataLength = 0;
-                    
-                    Byte testByte = 0x00;
-                    [testBuffer appendBytes:&testByte length:1];
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(MESSAGE_1_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(testProcessor.version).toEventually(equal(2));
-                });
-            });
-        });
-    });
-    
-    context(@"in MESSAGE_1_STATE", ^{
-        context(@"recieves a byte", ^{
-            it(@"transitions to MESSAGE_2_STATE", ^{
-                testProcessor.state = MESSAGE_1_STATE;
+        context(@"and it receives a byte", ^{
+            it(@"transitions to MESSAGE_1_STATE", ^{
+                testProcessor.version = 2;
+                testProcessor.dataLength = 0;
+                
                 Byte testByte = 0x00;
                 [testBuffer appendBytes:&testByte length:1];
                 
@@ -616,50 +599,59 @@ describe(@"The received message processor", ^{
                     messageReadyHeader = header;
                     messageReadyPayload = payload;
                 }];
-                expect(@(testProcessor.state)).to(equal(MESSAGE_2_STATE));
+                expect(@(testProcessor.state)).to(equal(MESSAGE_1_STATE));
                 expect(messageReadyHeader).toEventually(beNil());
                 expect(messageReadyPayload).toEventually(beNil());
+                expect(testProcessor.version).toEventually(equal(2));
             });
         });
     });
-    
-    context(@"in MESSAGE_2_STATE", ^{
-        context(@"recieves a byte", ^{
-            it(@"transitions to MESSAGE_3_STATE", ^{
-                testProcessor.state = MESSAGE_2_STATE;
-                Byte testByte = 0x00;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(MESSAGE_3_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-            });
+    context(@"when in MESSAGE_1_STATE, it receives a byte", ^{
+        it(@"transitions to MESSAGE_2_STATE", ^{
+            testProcessor.state = MESSAGE_1_STATE;
+            Byte testByte = 0x00;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(MESSAGE_2_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
         });
     });
-    
-    context(@"in MESSAGE_3_STATE", ^{
-        context(@"recieves a byte", ^{
-            it(@"transitions to MESSAGE_4_STATE", ^{
-                testProcessor.state = MESSAGE_3_STATE;
-                Byte testByte = 0x00;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(MESSAGE_4_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-            });
+    context(@"when in MESSAGE_2_STATE, it receives a byte", ^{
+        it(@"transitions to MESSAGE_3_STATE", ^{
+            testProcessor.state = MESSAGE_2_STATE;
+            Byte testByte = 0x00;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(MESSAGE_3_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
         });
     });
-    
-    context(@"in MESSAGE_4_STATE", ^{
+    context(@"when in MESSAGE_3_STATE, it receives a byte", ^{
+        it(@"transitions to MESSAGE_4_STATE", ^{
+            testProcessor.state = MESSAGE_3_STATE;
+            Byte testByte = 0x00;
+            [testBuffer appendBytes:&testByte length:1];
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(MESSAGE_4_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+        });
+    });
+    describe(@"when in MESSAGE_4_STATE, the version is greater than 1", ^{
         beforeEach(^{
             testProcessor.state = MESSAGE_4_STATE;
             testProcessor.version = 2;
@@ -684,40 +676,35 @@ describe(@"The received message processor", ^{
             Byte testByte = 0x00;
             [testBuffer appendBytes:&testByte length:1];
         });
-        context(@"datalength is 0", ^{
-            context(@"recieves a byte", ^{
-                it(@"resets state to START_STATE", ^{
-                    testProcessor.dataLength = 0;
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(START_STATE));
-                    expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
-                    expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
-                    expect(testProcessor.version).toEventually(equal(0));
-                });
+        context(@"datalength is 0 and it recieves a byte", ^{
+            it(@"resets state to START_STATE", ^{
+                testProcessor.dataLength = 0;
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
+                }];
+                expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
+                expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
+                expect(testProcessor.version).toEventually(equal(0));
             });
         });
-        context(@"datalength is greater than 0", ^{
-            context(@"recieves a byte", ^{
-                it(@"transitions to DATA_PUMP_STATE", ^{
-                    testProcessor.dataLength = 1;
-                    
-                    [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                        messageReadyHeader = header;
-                        messageReadyPayload = payload;
-                    }];
-                    expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
-                    expect(messageReadyHeader).toEventually(beNil());
-                    expect(messageReadyPayload).toEventually(beNil());
-                    expect(testProcessor.version).toEventually(equal(2));
-                });
+        context(@"datalength is greater than 0 and it receives a byte", ^{
+            it(@"transitions to DATA_PUMP_STATE", ^{
+                testProcessor.dataLength = 1;
+                
+                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                    messageReadyHeader = header;
+                    messageReadyPayload = payload;
+                }];
+                expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+                expect(messageReadyHeader).toEventually(beNil());
+                expect(messageReadyPayload).toEventually(beNil());
+                expect(testProcessor.version).toEventually(equal(2));
             });
         });
     });
-    
-    context(@"in DATA_PUMP_STATE", ^{
+    describe(@"in DATA_PUMP_STATE", ^{
         beforeEach(^{
             testProcessor.state = DATA_PUMP_STATE;
             testProcessor.version = 3;
-- 
cgit v1.2.1


From 090ba773477913048c2fe1bb4364d9f7ecfec66e Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Fri, 19 Aug 2022 11:21:00 -0400
Subject: review edits

---
 .../ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m           | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index ede53db5a..ee23c4e66 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -724,7 +724,7 @@ describe(@"The received message processor", ^{
             Byte testByte = 0xBA;
             [testBuffer appendBytes:&testByte length:1];
         });
-        context(@"dataBytesRemaining is greater than 1", ^{
+        context(@"dataBytesRemaining is greater than 1 and it receives a byte", ^{
             it(@"Stays in DATA_PUMP_STATE", ^{
                 testProcessor.dataBytesRemaining = 2;
                 
@@ -739,7 +739,7 @@ describe(@"The received message processor", ^{
                 expect(testProcessor.version).toEventually(equal(3));
             });
         });
-        context(@"dataBytesRemaining is 1", ^{
+        context(@"dataBytesRemaining is 1 and it receives a byte", ^{
             it(@"transitions to START_STATE", ^{
                 testProcessor.dataBytesRemaining = 1;
                 
-- 
cgit v1.2.1


From d6b1ea4aac66dcaecc64a7683d5f4c278f556e37 Mon Sep 17 00:00:00 2001
From: George Miller <George@livio.io>
Date: Fri, 19 Aug 2022 14:00:30 -0400
Subject: flattening the structure

I am not happy with it yet.
---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 1039 +++++++++-----------
 1 file changed, 483 insertions(+), 556 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index ee23c4e66..00ab1a96c 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -76,352 +76,422 @@ describe(@"The received message processor", ^{
     });
     
     //context(@"in START_STATE", ^{
-    context(@"when in START_STATE, it receives a byte with a good version 1", ^{
-        it(@"transitions to SERVICE_TYPE_STATE", ^{
-            testProcessor.state = START_STATE;
-            Byte testByte = 0x11;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            expect(messageReadyPayload).toEventually(beNil());
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-                expect(messageReadyPayload).toEventually(beNil());
-            }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(1));
-        });
-    });
-    context(@"when in START_STATE, it receives a byte with a good version 2", ^{
-        it(@"transitions to SERVICE_TYPE_STATE", ^{
-            testProcessor.state = START_STATE;
-            Byte testByte = 0x21;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(2));
-        });
-    });
-    context(@"when in START_STATE, it receives a byte with a good version 3", ^{
-        it(@"transitions to SERVICE_TYPE_STATE", ^{
-            testProcessor.state = START_STATE;
-            Byte testByte = 0x31;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(3));
-        });
-    });
-    context(@"when in START_STATE, it receives a byte with a good version 4", ^{
-        it(@"transitions to SERVICE_TYPE_STATE", ^{
-            testProcessor.state = START_STATE;
-            Byte testByte = 0x41;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(4));
-        });
-    });
-    context(@"when in START_STATE, it receives a byte with a good version 5", ^{
-        it(@"transitions to SERVICE_TYPE_STATE", ^{
-            testProcessor.state = START_STATE;
-            Byte testByte = 0x51;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(5));
-        });
-    });
-    context(@"when in START_STATE, it receives a byte with a bad version 0", ^{
-        it(@"resets state to START_STATE if the byte is not valid", ^{
-            testProcessor.state = START_STATE;
-            Byte testByte = 0x01;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(START_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(0));
-        });
-    });
-    context(@"when in START_STATE, it receives a byte with a bad version 6", ^{
-        it(@"resets state to START_STATE if the byte is not valid", ^{
-            testProcessor.state = START_STATE;
-            Byte testByte = 0x61;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(START_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(0));
-        });
-    });
-    context(@"when in START_STATE, it receives a byte with a frameType of SDLFrameTypeControl", ^{
-        it(@"transitions to SERVICE_TYPE_STATE", ^{
-            testProcessor.state = START_STATE;
-            Byte testByte = 0x10;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-        });
-    });
-    context(@"when in START_STATE, it receives a byte with a frameType of SDLFrameTypeSingle", ^{
-        it(@"transitions to SERVICE_TYPE_STATE", ^{
-            testProcessor.state = START_STATE;
-            Byte testByte = 0x11;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
+    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a good version 1", ^{
+        testProcessor.state = START_STATE;
+        Byte testByte = 0x11;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        expect(messageReadyPayload).toEventually(beNil());
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
             expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeSingle));
-        });
-    });
-    context(@"when in START_STATE, it receives a byte with a frameType of SDLFrameTypeFirst", ^{
-        it(@"transitions to SERVICE_TYPE_STATE", ^{
-            testProcessor.state = START_STATE;
-            Byte testByte = 0x12;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
-        });
-    });
-    context(@"when in START_STATE, it receives a byte with a frameType of SDLFrameTypeConsecutive", ^{
-        it(@"transitions to SERVICE_TYPE_STATE", ^{
-            testProcessor.state = START_STATE;
-            Byte testByte = 0x13;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeConsecutive));
-        });
-    });
-    context(@"when in START_STATE, it receives a byte with an invalid frameType of 6", ^{
-        it(@"resets state to START_STATE", ^{
-            testProcessor.state = START_STATE;
-            Byte testByte = 0x46; //0100 0 110
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(START_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.frameType)).toEventually(equal(0));
-            expect(testProcessor.version).toEventually(equal(0));
-            
-        });
-    });
-    context(@"when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeControl byte", ^{
-        it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
-            testProcessor.state = SERVICE_TYPE_STATE;
-            Byte testByte = SDLServiceTypeControl;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeControl));
-        });
-    });
-    context(@"when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeRPC byte", ^{
-        it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
-            testProcessor.state = SERVICE_TYPE_STATE;
-            Byte testByte = SDLServiceTypeRPC;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeRPC));
-        });
-    });
-    context(@"when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeAudio byte", ^{
-        it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
-            testProcessor.state = SERVICE_TYPE_STATE;
-            Byte testByte = SDLServiceTypeAudio;
-            [testBuffer appendBytes:&testByte length:1];
+        }];
+        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(testProcessor.version).toEventually(equal(1));
+    });
+    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a good version 2", ^{
+        testProcessor.state = START_STATE;
+        Byte testByte = 0x21;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+        
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(testProcessor.version).toEventually(equal(2));
+    });
+    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a good version 3", ^{
+        testProcessor.state = START_STATE;
+        Byte testByte = 0x31;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(testProcessor.version).toEventually(equal(3));
+    });
+    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a good version 4", ^{
+        testProcessor.state = START_STATE;
+        Byte testByte = 0x41;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(testProcessor.version).toEventually(equal(4));
+    });
+    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a good version 5", ^{
+        testProcessor.state = START_STATE;
+        Byte testByte = 0x51;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(testProcessor.version).toEventually(equal(5));
+    });
+    it(@"resets state to START_STATE if the byte is not valid hen in START_STATE, it receives a byte with a bad version 0", ^{
+        testProcessor.state = START_STATE;
+        Byte testByte = 0x01;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(START_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(testProcessor.version).toEventually(equal(0));
+    });
+    it(@"resets state to START_STATE if the byte is not valid when in START_STATE, it receives a byte with a bad version 6", ^{
+        testProcessor.state = START_STATE;
+        Byte testByte = 0x61;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(START_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(testProcessor.version).toEventually(equal(0));
+    });
+    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a frameType of SDLFrameTypeControl", ^{
+        testProcessor.state = START_STATE;
+        Byte testByte = 0x10;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+    });
+    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a frameType of SDLFrameTypeSingle", ^{
+        testProcessor.state = START_STATE;
+        Byte testByte = 0x11;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeSingle));
+    });
+    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a frameType of SDLFrameTypeFirst", ^{
+        testProcessor.state = START_STATE;
+        Byte testByte = 0x12;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
+    });
+    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a frameType of SDLFrameTypeConsecutive", ^{
+        testProcessor.state = START_STATE;
+        Byte testByte = 0x13;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeConsecutive));
+    });
+    it(@"resets state to START_STATE when in START_STATE, it receives a byte with an invalid frameType of 6", ^{
+        testProcessor.state = START_STATE;
+        Byte testByte = 0x46; //0100 0 110
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(START_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.frameType)).toEventually(equal(0));
+        expect(testProcessor.version).toEventually(equal(0));
+        
+    });
+    it(@"transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeControl byte", ^{
+        testProcessor.state = SERVICE_TYPE_STATE;
+        Byte testByte = SDLServiceTypeControl;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeControl));
+    });
+    it(@"transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeRPC byte", ^{
+        testProcessor.state = SERVICE_TYPE_STATE;
+        Byte testByte = SDLServiceTypeRPC;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeRPC));
+    });
+    it(@"transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeAudio byte", ^{
+        testProcessor.state = SERVICE_TYPE_STATE;
+        Byte testByte = SDLServiceTypeAudio;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeAudio));
+    });
+    it(@"transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeVideo byte", ^{
+        testProcessor.state = SERVICE_TYPE_STATE;
+        Byte testByte = SDLServiceTypeVideo;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeVideo));
+    });
+    it(@"transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeBulkData byte", ^{
+        testProcessor.state = SERVICE_TYPE_STATE;
+        Byte testByte = SDLServiceTypeBulkData;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeBulkData));
+    });
+    it(@"resets state to START_STATE when in SERVICE_TYPE_STATE, it receives a invalid byte", ^{
+        testProcessor.state = SERVICE_TYPE_STATE;
+        Byte testByte = 0xFF;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(START_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.serviceType)).toEventually(equal(0));
+    });
+    it(@"transitions to SESSION_ID_STATE when in CONTROL_FRAME_INFO_STATE, it receives a valid byte", ^{
+        testProcessor.state = CONTROL_FRAME_INFO_STATE;
+        Byte testByte = 0x00;
+        testProcessor.frameType = SDLFrameTypeFirst;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
+    });
+    it(@"resets to START_STATE when in CONTROL_FRAME_INFO_STATE, it receives a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeFirst", ^{
+        testProcessor.state = CONTROL_FRAME_INFO_STATE;
+        Byte testByte = 0x01;
+        testProcessor.frameType = SDLFrameTypeFirst;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(START_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.frameType)).toEventually(equal(0x00));
+    });
+    it(@"resets to START_STATE when in CONTROL_FRAME_INFO_STATE, it receives a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeSingle", ^{
+        testProcessor.state = CONTROL_FRAME_INFO_STATE;
+        Byte testByte = 0x01;
+        testProcessor.frameType = SDLFrameTypeSingle;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(START_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.frameType)).toEventually(equal(0x00));
+    });
+    it(@"transitions to DATA_SIZE_1_STATE when in SESSION_ID_STATE, it receives a byte", ^{
+        testProcessor.state = SESSION_ID_STATE;
+        Byte testByte = 0x00;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(DATA_SIZE_1_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.dataLength)).toEventually(equal(0));
+        
+    });
+    it(@"transitions to DATA_SIZE_2_STATE when in DATA_SIZE_1_STATE, it receives a byte", ^{
+        testProcessor.state = DATA_SIZE_1_STATE;
+        Byte testByte = 0x02;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(DATA_SIZE_2_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 24));
+    });
+    it(@"transitions to DATA_SIZE_3_STATE when in DATA_SIZE_2_STATE, it receives a byte", ^{
+        testProcessor.state = DATA_SIZE_2_STATE;
+        Byte testByte = 0x02;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(DATA_SIZE_3_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 16));
+    });
+    it(@"transitions to DATA_SIZE_4_STATE when in DATA_SIZE_3_STATE, it receives a byte", ^{
+        testProcessor.state = DATA_SIZE_3_STATE;
+        Byte testByte = 0x02;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(DATA_SIZE_4_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+        expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 8));
+    });
+    describe(@"when in DATA_SIZE_4_STATE and the version is 1", ^{
+        beforeEach(^{
+            testProcessor.state = DATA_SIZE_4_STATE;
+            testProcessor.version = 1;
             
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeAudio));
-        });
-    });
-    context(@"when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeVideo byte", ^{
-        it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
-            testProcessor.state = SERVICE_TYPE_STATE;
-            Byte testByte = SDLServiceTypeVideo;
-            [testBuffer appendBytes:&testByte length:1];
+            messageReadyHeader = nil;
+            messageReadyPayload = nil;
             
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeVideo));
-        });
-    });
-    context(@"when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeBulkData byte", ^{
-        it(@"transitions to CONTROL_FRAME_INFO_STATE", ^{
-            testProcessor.state = SERVICE_TYPE_STATE;
-            Byte testByte = SDLServiceTypeBulkData;
-            [testBuffer appendBytes:&testByte length:1];
+            //need a valid headerbuffer.
+            Byte firstByte = ((testProcessor.version & 0x0f) << 4) + (0 << 3) + (1 & 0x07); //version 2 with no encryption, frametype 1
+            UInt32 dataLength = 3;
+            const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (dataLength >> 24) & 0xff, (dataLength >> 16) & 0xff, (dataLength >> 8) & 0xff, (dataLength) & 0xff };
+            [testHeaderBuffer appendBytes:&testBytes length:8];
+            UInt32 messageID = 0;
+            Byte messageIDBytes[4] = {(messageID >> 24) & 0xff, (messageID >> 16) & 0xff, (messageID >> 8) & 0xff, (messageID) & 0xff};
+            [testHeaderBuffer appendBytes:&messageIDBytes length:4];
             
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeBulkData));
-        });
-    });
-    context(@"when in SERVICE_TYPE_STATE, it receives a invalid byte", ^{
-        it(@"resets state to START_STATE", ^{
-            testProcessor.state = SERVICE_TYPE_STATE;
-            Byte testByte = 0xFF;
-            [testBuffer appendBytes:&testByte length:1];
+            testProcessor.headerBuffer = testHeaderBuffer;
+            expectedMessageReadyHeader= [SDLProtocolHeader headerForVersion:testProcessor.version];
+            [expectedMessageReadyHeader parse:testHeaderBuffer];
             
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(START_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.serviceType)).toEventually(equal(0));
+            expectedPayloadBuffer = [NSData data];
         });
-    });
-    context(@"when in CONTROL_FRAME_INFO_STATE, it receives a valid byte", ^{
-        it(@"transitions to SESSION_ID_STATE", ^{
-            testProcessor.state = CONTROL_FRAME_INFO_STATE;
+        it(@"resets state to START_STATE when it receives a byte and determines the data length is 0", ^{
+
             Byte testByte = 0x00;
-            testProcessor.frameType = SDLFrameTypeFirst;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
-        });
-    });
-    context(@"when in CONTROL_FRAME_INFO_STATE, it receives a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeFirst", ^{
-        it(@"resets to START_STATE", ^{
-            testProcessor.state = CONTROL_FRAME_INFO_STATE;
-            Byte testByte = 0x01;
-            testProcessor.frameType = SDLFrameTypeFirst;
             [testBuffer appendBytes:&testByte length:1];
+            messageReadyHeader = [SDLProtocolHeader headerForVersion:1];
             
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
             }];
             expect(@(testProcessor.state)).to(equal(START_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.frameType)).toEventually(equal(0x00));
+            expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
+            expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
+            expect(@(testProcessor.dataLength)).toEventually(equal(0));
+            expect(@(testProcessor.version)).toEventually(equal(0));
         });
-    });
-    context(@"when in CONTROL_FRAME_INFO_STATE, it receives a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeSingle", ^{
-        it(@"resets to START_STATE", ^{
-            testProcessor.state = CONTROL_FRAME_INFO_STATE;
+        it(@"transitions to DATA_PUMP_STATE it receives a byte and determines the data length is greater than 0", ^{
+
             Byte testByte = 0x01;
-            testProcessor.frameType = SDLFrameTypeSingle;
             [testBuffer appendBytes:&testByte length:1];
             
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
             }];
-            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
             expect(messageReadyHeader).toEventually(beNil());
             expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.frameType)).toEventually(equal(0x00));
+            expect(@(testProcessor.dataLength)).toEventually(equal(1));
+            expect(@(testProcessor.version)).toEventually(equal(1));
         });
-    });
-    context(@"when in SESSION_ID_STATE, it receives a byte", ^{
-        it(@"transitions to DATA_SIZE_1_STATE", ^{
-            testProcessor.state = SESSION_ID_STATE;
+        it(@"transitions to START_STATE when it receives a byte and determines the data length is ggreater than maxMtuSize", ^{
+            testProcessor.serviceType = SDLServiceTypeControl;
+            testProcessor.dataLength = 200000;
+            
             Byte testByte = 0x00;
             [testBuffer appendBytes:&testByte length:1];
             
@@ -429,142 +499,15 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
             }];
-            expect(@(testProcessor.state)).to(equal(DATA_SIZE_1_STATE));
+            expect(@(testProcessor.state)).to(equal(START_STATE));
             expect(messageReadyHeader).toEventually(beNil());
             expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.serviceType)).toEventually(equal(0));
             expect(@(testProcessor.dataLength)).toEventually(equal(0));
-            
-        });
-    });
-    context(@"when in DATA_SIZE_1_STATE, it receives a byte", ^{
-        it(@"transitions to DATA_SIZE_2_STATE", ^{
-            testProcessor.state = DATA_SIZE_1_STATE;
-            Byte testByte = 0x02;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(DATA_SIZE_2_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 24));
-        });
-    });
-    context(@"when in DATA_SIZE_2_STATE, it receives a byte", ^{
-        it(@"transitions to DATA_SIZE_3_STATE", ^{
-            testProcessor.state = DATA_SIZE_2_STATE;
-            Byte testByte = 0x02;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(DATA_SIZE_3_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 16));
-        });
-    });
-    context(@"when in DATA_SIZE_3_STATE, it receives a byte", ^{
-        it(@"transitions to DATA_SIZE_4_STATE", ^{
-            testProcessor.state = DATA_SIZE_3_STATE;
-            Byte testByte = 0x02;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(DATA_SIZE_4_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 8));
+            expect(@(testProcessor.version)).toEventually(equal(0));
         });
     });
-    describe(@"when in DATA_SIZE_4_STATE, the version is 1", ^{
-        beforeEach(^{
-            testProcessor.state = DATA_SIZE_4_STATE;
-            testProcessor.version = 1;
-            
-            messageReadyHeader = nil;
-            messageReadyPayload = nil;
-            
-            
-            //need a valid headerbuffer.
-            Byte firstByte = ((testProcessor.version & 0x0f) << 4) + (0 << 3) + (1 & 0x07); //version 2 with no encryption, frametype 1
-            UInt32 dataLength = 3;
-            const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (dataLength >> 24) & 0xff, (dataLength >> 16) & 0xff, (dataLength >> 8) & 0xff, (dataLength) & 0xff };
-            [testHeaderBuffer appendBytes:&testBytes length:8];
-            UInt32 messageID = 0;
-            Byte messageIDBytes[4] = {(messageID >> 24) & 0xff, (messageID >> 16) & 0xff, (messageID >> 8) & 0xff, (messageID) & 0xff};
-            [testHeaderBuffer appendBytes:&messageIDBytes length:4];
-            
-            testProcessor.headerBuffer = testHeaderBuffer;
-            expectedMessageReadyHeader= [SDLProtocolHeader headerForVersion:testProcessor.version];
-            [expectedMessageReadyHeader parse:testHeaderBuffer];
-            
-            expectedPayloadBuffer = [NSData data];
-        });
-        context(@"and it receives a byte and determines the data length is 0", ^{
-            it(@"resets state to START_STATE", ^{
-
-                Byte testByte = 0x00;
-                [testBuffer appendBytes:&testByte length:1];
-                messageReadyHeader = [SDLProtocolHeader headerForVersion:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(START_STATE));
-                expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
-                expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
-                expect(@(testProcessor.dataLength)).toEventually(equal(0));
-                expect(@(testProcessor.version)).toEventually(equal(0));
-            });
-        });
-        context(@"and it receives a byte and determines the data length is greater than 0", ^{
-            it(@"transitions to DATA_PUMP_STATE", ^{
-
-                Byte testByte = 0x01;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.dataLength)).toEventually(equal(1));
-                expect(@(testProcessor.version)).toEventually(equal(1));
-            });
-        });
-        context(@"and it receives a byte and determines the data length is ggreater than maxMtuSize", ^{
-            it(@"transitions to START_STATE", ^{
-                testProcessor.serviceType = SDLServiceTypeControl;
-                testProcessor.dataLength = 200000;
-                
-                Byte testByte = 0x00;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(START_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(@(testProcessor.serviceType)).toEventually(equal(0));
-                expect(@(testProcessor.dataLength)).toEventually(equal(0));
-                expect(@(testProcessor.version)).toEventually(equal(0));
-            });
-        });
-    });
-    describe(@"when in DATA_SIZE_4_STATE, the version is greater than 1", ^{
+    describe(@"when in DATA_SIZE_4_STATE and the version is greater than 1", ^{
         beforeEach(^{
             testProcessor.state = DATA_SIZE_4_STATE;
             messageReadyHeader = nil;
@@ -587,43 +530,10 @@ describe(@"The received message processor", ^{
             expectedPayloadBuffer = [NSData data];
             
         });
-        context(@"and it receives a byte", ^{
-            it(@"transitions to MESSAGE_1_STATE", ^{
-                testProcessor.version = 2;
-                testProcessor.dataLength = 0;
-                
-                Byte testByte = 0x00;
-                [testBuffer appendBytes:&testByte length:1];
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(MESSAGE_1_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(testProcessor.version).toEventually(equal(2));
-            });
-        });
-    });
-    context(@"when in MESSAGE_1_STATE, it receives a byte", ^{
-        it(@"transitions to MESSAGE_2_STATE", ^{
-            testProcessor.state = MESSAGE_1_STATE;
-            Byte testByte = 0x00;
-            [testBuffer appendBytes:&testByte length:1];
+        it(@"transitions to MESSAGE_1_STATE when it receives a byte", ^{
+            testProcessor.version = 2;
+            testProcessor.dataLength = 0;
             
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(MESSAGE_2_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-        });
-    });
-    context(@"when in MESSAGE_2_STATE, it receives a byte", ^{
-        it(@"transitions to MESSAGE_3_STATE", ^{
-            testProcessor.state = MESSAGE_2_STATE;
             Byte testByte = 0x00;
             [testBuffer appendBytes:&testByte length:1];
             
@@ -631,25 +541,50 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
             }];
-            expect(@(testProcessor.state)).to(equal(MESSAGE_3_STATE));
+            expect(@(testProcessor.state)).to(equal(MESSAGE_1_STATE));
             expect(messageReadyHeader).toEventually(beNil());
             expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(2));
         });
     });
-    context(@"when in MESSAGE_3_STATE, it receives a byte", ^{
-        it(@"transitions to MESSAGE_4_STATE", ^{
-            testProcessor.state = MESSAGE_3_STATE;
-            Byte testByte = 0x00;
-            [testBuffer appendBytes:&testByte length:1];
-            
-            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                messageReadyHeader = header;
-                messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(MESSAGE_4_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-        });
+    it(@"transitions to MESSAGE_2_STATE when in MESSAGE_1_STATE, it receives a byte", ^{
+        testProcessor.state = MESSAGE_1_STATE;
+        Byte testByte = 0x00;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(MESSAGE_2_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+    });
+    it(@"transitions to MESSAGE_3_STATE when in MESSAGE_2_STATE, it receives a byte", ^{
+        testProcessor.state = MESSAGE_2_STATE;
+        Byte testByte = 0x00;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(MESSAGE_3_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
+    });
+    it(@"transitions to MESSAGE_4_STATE when in MESSAGE_3_STATE, it receives a byte", ^{
+        testProcessor.state = MESSAGE_3_STATE;
+        Byte testByte = 0x00;
+        [testBuffer appendBytes:&testByte length:1];
+        
+        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+            messageReadyHeader = header;
+            messageReadyPayload = payload;
+        }];
+        expect(@(testProcessor.state)).to(equal(MESSAGE_4_STATE));
+        expect(messageReadyHeader).toEventually(beNil());
+        expect(messageReadyPayload).toEventually(beNil());
     });
     describe(@"when in MESSAGE_4_STATE, the version is greater than 1", ^{
         beforeEach(^{
@@ -676,32 +611,28 @@ describe(@"The received message processor", ^{
             Byte testByte = 0x00;
             [testBuffer appendBytes:&testByte length:1];
         });
-        context(@"datalength is 0 and it recieves a byte", ^{
-            it(@"resets state to START_STATE", ^{
-                testProcessor.dataLength = 0;
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(START_STATE));
-                expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
-                expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
-                expect(testProcessor.version).toEventually(equal(0));
-            });
+        it(@"resets state to START_STATE when datalength is 0 and it recieves a byte", ^{
+            testProcessor.dataLength = 0;
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
+            expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
+            expect(testProcessor.version).toEventually(equal(0));
         });
-        context(@"datalength is greater than 0 and it receives a byte", ^{
-            it(@"transitions to DATA_PUMP_STATE", ^{
-                testProcessor.dataLength = 1;
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(testProcessor.version).toEventually(equal(2));
-            });
+        it(@"transitions to DATA_PUMP_STATE when datalength is greater than 0 and it receives a byte", ^{
+            testProcessor.dataLength = 1;
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(2));
         });
     });
     describe(@"in DATA_PUMP_STATE", ^{
@@ -724,35 +655,31 @@ describe(@"The received message processor", ^{
             Byte testByte = 0xBA;
             [testBuffer appendBytes:&testByte length:1];
         });
-        context(@"dataBytesRemaining is greater than 1 and it receives a byte", ^{
-            it(@"Stays in DATA_PUMP_STATE", ^{
-                testProcessor.dataBytesRemaining = 2;
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
-                expect(messageReadyHeader).toEventually(beNil());
-                expect(messageReadyPayload).toEventually(beNil());
-                expect(testProcessor.dataBytesRemaining).toEventually(equal(1));
-                expect(testProcessor.version).toEventually(equal(3));
-            });
+        it(@"Stays in DATA_PUMP_STATE when dataBytesRemaining is greater than 1 and it receives a byte", ^{
+            testProcessor.dataBytesRemaining = 2;
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.dataBytesRemaining).toEventually(equal(1));
+            expect(testProcessor.version).toEventually(equal(3));
         });
-        context(@"dataBytesRemaining is 1 and it receives a byte", ^{
-            it(@"transitions to START_STATE", ^{
-                testProcessor.dataBytesRemaining = 1;
-                
-                [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-                    messageReadyHeader = header;
-                    messageReadyPayload = payload;
-                }];
-                expect(@(testProcessor.state)).to(equal(START_STATE));
-                expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
-                expect(messageReadyPayload).toEventually(equal(testBuffer));
-                expect(testProcessor.dataBytesRemaining).toEventually(equal(0));
-                expect(testProcessor.version).toEventually(equal(0));
-            });
+        it(@"transitions to START_STATE when dataBytesRemaining is 1 and it receives a byte", ^{
+            testProcessor.dataBytesRemaining = 1;
+            
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
+            expect(messageReadyPayload).toEventually(equal(testBuffer));
+            expect(testProcessor.dataBytesRemaining).toEventually(equal(0));
+            expect(testProcessor.version).toEventually(equal(0));
         });
     });
 });
-- 
cgit v1.2.1


From a0a217792de6540c9c92cae57d6344a9daf00508 Mon Sep 17 00:00:00 2001
From: Justin Beharry <justin.beharry@livio.io>
Date: Tue, 23 Aug 2022 15:12:46 -0400
Subject: organize unit tests and remove unnecessary header

---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 530 +++++++++++----------
 1 file changed, 285 insertions(+), 245 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 00ab1a96c..d34cfc809 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -74,250 +74,271 @@ describe(@"The received message processor", ^{
         expectedMessageReadyHeader = nil;
         messageReadyPayload = nil;
     });
-    
-    //context(@"in START_STATE", ^{
-    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a good version 1", ^{
-        testProcessor.state = START_STATE;
-        Byte testByte = 0x11;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        expect(messageReadyPayload).toEventually(beNil());
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-            expect(messageReadyPayload).toEventually(beNil());
-        }];
-        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(testProcessor.version).toEventually(equal(1));
-    });
-    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a good version 2", ^{
-        testProcessor.state = START_STATE;
-        Byte testByte = 0x21;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-        
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(testProcessor.version).toEventually(equal(2));
-    });
-    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a good version 3", ^{
-        testProcessor.state = START_STATE;
-        Byte testByte = 0x31;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(testProcessor.version).toEventually(equal(3));
-    });
-    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a good version 4", ^{
-        testProcessor.state = START_STATE;
-        Byte testByte = 0x41;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(testProcessor.version).toEventually(equal(4));
-    });
-    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a good version 5", ^{
-        testProcessor.state = START_STATE;
-        Byte testByte = 0x51;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(testProcessor.version).toEventually(equal(5));
-    });
-    it(@"resets state to START_STATE if the byte is not valid hen in START_STATE, it receives a byte with a bad version 0", ^{
-        testProcessor.state = START_STATE;
-        Byte testByte = 0x01;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(START_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(testProcessor.version).toEventually(equal(0));
-    });
-    it(@"resets state to START_STATE if the byte is not valid when in START_STATE, it receives a byte with a bad version 6", ^{
-        testProcessor.state = START_STATE;
-        Byte testByte = 0x61;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(START_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(testProcessor.version).toEventually(equal(0));
-    });
-    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a frameType of SDLFrameTypeControl", ^{
-        testProcessor.state = START_STATE;
-        Byte testByte = 0x10;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-    });
-    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a frameType of SDLFrameTypeSingle", ^{
-        testProcessor.state = START_STATE;
-        Byte testByte = 0x11;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeSingle));
-    });
-    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a frameType of SDLFrameTypeFirst", ^{
-        testProcessor.state = START_STATE;
-        Byte testByte = 0x12;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
-    });
-    it(@"transitions to SERVICE_TYPE_STATE when in START_STATE, it receives a byte with a frameType of SDLFrameTypeConsecutive", ^{
-        testProcessor.state = START_STATE;
-        Byte testByte = 0x13;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeConsecutive));
-    });
-    it(@"resets state to START_STATE when in START_STATE, it receives a byte with an invalid frameType of 6", ^{
-        testProcessor.state = START_STATE;
-        Byte testByte = 0x46; //0100 0 110
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
+
+    it(@"test processor should be initialized correctly", ^{
         expect(@(testProcessor.state)).to(equal(START_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.frameType)).toEventually(equal(0));
-        expect(testProcessor.version).toEventually(equal(0));
-        
-    });
-    it(@"transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeControl byte", ^{
-        testProcessor.state = SERVICE_TYPE_STATE;
-        Byte testByte = SDLServiceTypeControl;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeControl));
-    });
-    it(@"transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeRPC byte", ^{
-        testProcessor.state = SERVICE_TYPE_STATE;
-        Byte testByte = SDLServiceTypeRPC;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeRPC));
+        expect(@(testProcessor.version)).to(equal(0));
+        expect(@(testProcessor.encrypted)).to(equal(NO));
+        expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeControl));
+        expect(@(testProcessor.dataLength)).to(equal(0));
+        expect(@(testProcessor.dataBytesRemaining)).to(equal(0));
+        expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeControl));
     });
-    it(@"transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeAudio byte", ^{
-        testProcessor.state = SERVICE_TYPE_STATE;
-        Byte testByte = SDLServiceTypeAudio;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeAudio));
+    
+    describe(@"transitions to SERVICE_TYPE_STATE when in START_STATE", ^{
+
+        it(@"should receive a byte with a good version 1", ^{
+            Byte testByte = 0x11;
+            [testBuffer appendBytes:&testByte length:1];
+
+            expect(messageReadyPayload).toEventually(beNil());
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+                expect(messageReadyPayload).toEventually(beNil());
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(1));
+        });
+
+        it(@"should receive a byte with a good version 2", ^{
+            Byte testByte = 0x21;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(2));
+        });
+
+        it(@"should receive a byte with a good version 3", ^{
+            Byte testByte = 0x31;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(3));
+        });
+
+        it(@"should receive a byte with a good version 4", ^{
+            Byte testByte = 0x41;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(4));
+        });
+
+        it(@"should receive a byte with a good version 5", ^{
+            Byte testByte = 0x51;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(5));
+        });
+
+        it(@"should recieve a byte with a frameType of SDLFrameTypeControl", ^{
+            Byte testByte = 0x10;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+        });
+
+        it(@"should recieve a byte with a frameType of SDLFrameTypeSingle", ^{
+            Byte testByte = 0x11;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeSingle));
+        });
+
+        it(@"should recieve a byte with a frameType of SDLFrameTypeFirst", ^{
+            Byte testByte = 0x12;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
+        });
+
+        it(@"should recieve a byte with a frameType of SDLFrameTypeConsecutive", ^{
+            Byte testByte = 0x13;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeConsecutive));
+        });
     });
-    it(@"transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeVideo byte", ^{
-        testProcessor.state = SERVICE_TYPE_STATE;
-        Byte testByte = SDLServiceTypeVideo;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeVideo));
+
+    describe(@"resets state to START_STATE if the byte is not valid when in START_STATE", ^{
+
+        it(@"should recieve a byte with a bad version 0", ^{
+            Byte testByte = 0x01;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(0));
+        });
+
+        it(@"should recieve a byte with a bad version 6", ^{
+            Byte testByte = 0x61;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(testProcessor.version).toEventually(equal(0));
+        });
+
+        it(@"should recieve a byte with an invalid frameType of 6", ^{
+            Byte testByte = 0x46; //0100 0 110
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.frameType)).toEventually(equal(0));
+            expect(testProcessor.version).toEventually(equal(0));
+        });
     });
-    it(@"transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE, it receives a SDLServiceTypeBulkData byte", ^{
-        testProcessor.state = SERVICE_TYPE_STATE;
-        Byte testByte = SDLServiceTypeBulkData;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeBulkData));
+
+    describe(@"transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE", ^ {
+
+        beforeEach(^{
+            testProcessor.state = SERVICE_TYPE_STATE;
+        });
+
+        it(@"should recieve a SDLServiceTypeControl byte", ^{
+            Byte testByte = SDLServiceTypeControl;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeControl));
+        });
+
+        it(@"should recieve a SDLServiceTypeRPC byte", ^{
+            Byte testByte = SDLServiceTypeRPC;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeRPC));
+        });
+
+        it(@"should recieve a SDLServiceTypeAudio byte", ^{
+            Byte testByte = SDLServiceTypeAudio;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeAudio));
+        });
+
+        it(@"should receive a SDLServiceTypeVideo byte", ^{
+            Byte testByte = SDLServiceTypeVideo;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeVideo));
+        });
+
+        it(@"should receive a SDLServiceTypeBulkData byte", ^{
+            Byte testByte = SDLServiceTypeBulkData;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+            }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(messageReadyHeader).toEventually(beNil());
+            expect(messageReadyPayload).toEventually(beNil());
+            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeBulkData));
+        });
     });
+
     it(@"resets state to START_STATE when in SERVICE_TYPE_STATE, it receives a invalid byte", ^{
         testProcessor.state = SERVICE_TYPE_STATE;
         Byte testByte = 0xFF;
@@ -330,8 +351,9 @@ describe(@"The received message processor", ^{
         expect(@(testProcessor.state)).to(equal(START_STATE));
         expect(messageReadyHeader).toEventually(beNil());
         expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.serviceType)).toEventually(equal(0));
+        expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeControl));
     });
+
     it(@"transitions to SESSION_ID_STATE when in CONTROL_FRAME_INFO_STATE, it receives a valid byte", ^{
         testProcessor.state = CONTROL_FRAME_INFO_STATE;
         Byte testByte = 0x00;
@@ -347,6 +369,7 @@ describe(@"The received message processor", ^{
         expect(messageReadyPayload).toEventually(beNil());
         expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
     });
+
     it(@"resets to START_STATE when in CONTROL_FRAME_INFO_STATE, it receives a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeFirst", ^{
         testProcessor.state = CONTROL_FRAME_INFO_STATE;
         Byte testByte = 0x01;
@@ -360,8 +383,9 @@ describe(@"The received message processor", ^{
         expect(@(testProcessor.state)).to(equal(START_STATE));
         expect(messageReadyHeader).toEventually(beNil());
         expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.frameType)).toEventually(equal(0x00));
+        expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeControl));
     });
+
     it(@"resets to START_STATE when in CONTROL_FRAME_INFO_STATE, it receives a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeSingle", ^{
         testProcessor.state = CONTROL_FRAME_INFO_STATE;
         Byte testByte = 0x01;
@@ -375,8 +399,9 @@ describe(@"The received message processor", ^{
         expect(@(testProcessor.state)).to(equal(START_STATE));
         expect(messageReadyHeader).toEventually(beNil());
         expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.frameType)).toEventually(equal(0x00));
+        expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeControl));
     });
+
     it(@"transitions to DATA_SIZE_1_STATE when in SESSION_ID_STATE, it receives a byte", ^{
         testProcessor.state = SESSION_ID_STATE;
         Byte testByte = 0x00;
@@ -392,6 +417,7 @@ describe(@"The received message processor", ^{
         expect(@(testProcessor.dataLength)).toEventually(equal(0));
         
     });
+
     it(@"transitions to DATA_SIZE_2_STATE when in DATA_SIZE_1_STATE, it receives a byte", ^{
         testProcessor.state = DATA_SIZE_1_STATE;
         Byte testByte = 0x02;
@@ -406,6 +432,7 @@ describe(@"The received message processor", ^{
         expect(messageReadyPayload).toEventually(beNil());
         expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 24));
     });
+
     it(@"transitions to DATA_SIZE_3_STATE when in DATA_SIZE_2_STATE, it receives a byte", ^{
         testProcessor.state = DATA_SIZE_2_STATE;
         Byte testByte = 0x02;
@@ -420,6 +447,7 @@ describe(@"The received message processor", ^{
         expect(messageReadyPayload).toEventually(beNil());
         expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 16));
     });
+
     it(@"transitions to DATA_SIZE_4_STATE when in DATA_SIZE_3_STATE, it receives a byte", ^{
         testProcessor.state = DATA_SIZE_3_STATE;
         Byte testByte = 0x02;
@@ -434,6 +462,7 @@ describe(@"The received message processor", ^{
         expect(messageReadyPayload).toEventually(beNil());
         expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 8));
     });
+
     describe(@"when in DATA_SIZE_4_STATE and the version is 1", ^{
         beforeEach(^{
             testProcessor.state = DATA_SIZE_4_STATE;
@@ -457,8 +486,8 @@ describe(@"The received message processor", ^{
             
             expectedPayloadBuffer = [NSData data];
         });
-        it(@"resets state to START_STATE when it receives a byte and determines the data length is 0", ^{
 
+        it(@"resets state to START_STATE when it receives a byte and determines the data length is 0", ^{
             Byte testByte = 0x00;
             [testBuffer appendBytes:&testByte length:1];
             messageReadyHeader = [SDLProtocolHeader headerForVersion:1];
@@ -473,8 +502,8 @@ describe(@"The received message processor", ^{
             expect(@(testProcessor.dataLength)).toEventually(equal(0));
             expect(@(testProcessor.version)).toEventually(equal(0));
         });
-        it(@"transitions to DATA_PUMP_STATE it receives a byte and determines the data length is greater than 0", ^{
 
+        it(@"transitions to DATA_PUMP_STATE it receives a byte and determines the data length is greater than 0", ^{
             Byte testByte = 0x01;
             [testBuffer appendBytes:&testByte length:1];
             
@@ -488,6 +517,7 @@ describe(@"The received message processor", ^{
             expect(@(testProcessor.dataLength)).toEventually(equal(1));
             expect(@(testProcessor.version)).toEventually(equal(1));
         });
+
         it(@"transitions to START_STATE when it receives a byte and determines the data length is ggreater than maxMtuSize", ^{
             testProcessor.serviceType = SDLServiceTypeControl;
             testProcessor.dataLength = 200000;
@@ -507,6 +537,7 @@ describe(@"The received message processor", ^{
             expect(@(testProcessor.version)).toEventually(equal(0));
         });
     });
+
     describe(@"when in DATA_SIZE_4_STATE and the version is greater than 1", ^{
         beforeEach(^{
             testProcessor.state = DATA_SIZE_4_STATE;
@@ -528,8 +559,8 @@ describe(@"The received message processor", ^{
             [expectedMessageReadyHeader parse:testHeaderBuffer];
             
             expectedPayloadBuffer = [NSData data];
-            
         });
+
         it(@"transitions to MESSAGE_1_STATE when it receives a byte", ^{
             testProcessor.version = 2;
             testProcessor.dataLength = 0;
@@ -547,6 +578,7 @@ describe(@"The received message processor", ^{
             expect(testProcessor.version).toEventually(equal(2));
         });
     });
+
     it(@"transitions to MESSAGE_2_STATE when in MESSAGE_1_STATE, it receives a byte", ^{
         testProcessor.state = MESSAGE_1_STATE;
         Byte testByte = 0x00;
@@ -560,6 +592,7 @@ describe(@"The received message processor", ^{
         expect(messageReadyHeader).toEventually(beNil());
         expect(messageReadyPayload).toEventually(beNil());
     });
+
     it(@"transitions to MESSAGE_3_STATE when in MESSAGE_2_STATE, it receives a byte", ^{
         testProcessor.state = MESSAGE_2_STATE;
         Byte testByte = 0x00;
@@ -573,6 +606,7 @@ describe(@"The received message processor", ^{
         expect(messageReadyHeader).toEventually(beNil());
         expect(messageReadyPayload).toEventually(beNil());
     });
+
     it(@"transitions to MESSAGE_4_STATE when in MESSAGE_3_STATE, it receives a byte", ^{
         testProcessor.state = MESSAGE_3_STATE;
         Byte testByte = 0x00;
@@ -586,6 +620,7 @@ describe(@"The received message processor", ^{
         expect(messageReadyHeader).toEventually(beNil());
         expect(messageReadyPayload).toEventually(beNil());
     });
+
     describe(@"when in MESSAGE_4_STATE, the version is greater than 1", ^{
         beforeEach(^{
             testProcessor.state = MESSAGE_4_STATE;
@@ -611,6 +646,7 @@ describe(@"The received message processor", ^{
             Byte testByte = 0x00;
             [testBuffer appendBytes:&testByte length:1];
         });
+
         it(@"resets state to START_STATE when datalength is 0 and it recieves a byte", ^{
             testProcessor.dataLength = 0;
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
@@ -622,6 +658,7 @@ describe(@"The received message processor", ^{
             expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
             expect(testProcessor.version).toEventually(equal(0));
         });
+
         it(@"transitions to DATA_PUMP_STATE when datalength is greater than 0 and it receives a byte", ^{
             testProcessor.dataLength = 1;
             
@@ -635,6 +672,7 @@ describe(@"The received message processor", ^{
             expect(testProcessor.version).toEventually(equal(2));
         });
     });
+
     describe(@"in DATA_PUMP_STATE", ^{
         beforeEach(^{
             testProcessor.state = DATA_PUMP_STATE;
@@ -655,6 +693,7 @@ describe(@"The received message processor", ^{
             Byte testByte = 0xBA;
             [testBuffer appendBytes:&testByte length:1];
         });
+
         it(@"Stays in DATA_PUMP_STATE when dataBytesRemaining is greater than 1 and it receives a byte", ^{
             testProcessor.dataBytesRemaining = 2;
             
@@ -668,6 +707,7 @@ describe(@"The received message processor", ^{
             expect(testProcessor.dataBytesRemaining).toEventually(equal(1));
             expect(testProcessor.version).toEventually(equal(3));
         });
+
         it(@"transitions to START_STATE when dataBytesRemaining is 1 and it receives a byte", ^{
             testProcessor.dataBytesRemaining = 1;
             
-- 
cgit v1.2.1


From 1af049098301db73491086536e11419510c53216 Mon Sep 17 00:00:00 2001
From: Justin Beharry <justin.beharry@livio.io>
Date: Tue, 23 Aug 2022 16:50:09 -0400
Subject: Check header and payload buffers are reset

---
 .../SDLProtocolReceivedMessageProcessorSpec.m            | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index d34cfc809..315e088c7 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -53,10 +53,6 @@ typedef NS_ENUM(NSInteger, ProcessorState) {
 
 QuickSpecBegin(SDLProtocolReceivedMessageProcessorSpec)
 
-// set up all test constants
-
-
-
 describe(@"The received message processor", ^{
     __block SDLProtocolReceivedMessageProcessor *testProcessor = nil;
     __block NSMutableData *testBuffer;
@@ -230,6 +226,8 @@ describe(@"The received message processor", ^{
             expect(messageReadyHeader).toEventually(beNil());
             expect(messageReadyPayload).toEventually(beNil());
             expect(testProcessor.version).toEventually(equal(0));
+            expect(testProcessor.headerBuffer).toEventually(equal([NSMutableData data]));
+            expect(testProcessor.payloadBuffer).toEventually(equal([NSMutableData data]));
         });
 
         it(@"should recieve a byte with a bad version 6", ^{
@@ -352,6 +350,8 @@ describe(@"The received message processor", ^{
         expect(messageReadyHeader).toEventually(beNil());
         expect(messageReadyPayload).toEventually(beNil());
         expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeControl));
+        expect(testProcessor.headerBuffer).toEventually(equal([NSMutableData data]));
+        expect(testProcessor.payloadBuffer).toEventually(equal([NSMutableData data]));
     });
 
     it(@"transitions to SESSION_ID_STATE when in CONTROL_FRAME_INFO_STATE, it receives a valid byte", ^{
@@ -384,6 +384,8 @@ describe(@"The received message processor", ^{
         expect(messageReadyHeader).toEventually(beNil());
         expect(messageReadyPayload).toEventually(beNil());
         expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeControl));
+        expect(testProcessor.headerBuffer).toEventually(equal([NSMutableData data]));
+        expect(testProcessor.payloadBuffer).toEventually(equal([NSMutableData data]));
     });
 
     it(@"resets to START_STATE when in CONTROL_FRAME_INFO_STATE, it receives a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeSingle", ^{
@@ -400,6 +402,8 @@ describe(@"The received message processor", ^{
         expect(messageReadyHeader).toEventually(beNil());
         expect(messageReadyPayload).toEventually(beNil());
         expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeControl));
+        expect(testProcessor.headerBuffer).toEventually(equal([NSMutableData data]));
+        expect(testProcessor.payloadBuffer).toEventually(equal([NSMutableData data]));
     });
 
     it(@"transitions to DATA_SIZE_1_STATE when in SESSION_ID_STATE, it receives a byte", ^{
@@ -501,6 +505,8 @@ describe(@"The received message processor", ^{
             expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
             expect(@(testProcessor.dataLength)).toEventually(equal(0));
             expect(@(testProcessor.version)).toEventually(equal(0));
+            expect(testProcessor.headerBuffer).toEventually(equal([NSMutableData data]));
+            expect(testProcessor.payloadBuffer).toEventually(equal([NSMutableData data]));
         });
 
         it(@"transitions to DATA_PUMP_STATE it receives a byte and determines the data length is greater than 0", ^{
@@ -657,6 +663,8 @@ describe(@"The received message processor", ^{
             expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
             expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
             expect(testProcessor.version).toEventually(equal(0));
+            expect(testProcessor.headerBuffer).toEventually(equal([NSMutableData data]));
+            expect(testProcessor.payloadBuffer).toEventually(equal([NSMutableData data]));
         });
 
         it(@"transitions to DATA_PUMP_STATE when datalength is greater than 0 and it receives a byte", ^{
-- 
cgit v1.2.1


From fa9bc9981d2099e51655a99b32c63adf8233ac18 Mon Sep 17 00:00:00 2001
From: Justin Beharry <109764059+jshivabeharry@users.noreply.github.com>
Date: Wed, 24 Aug 2022 11:41:54 -0400
Subject: Apply suggestions from code review

Co-authored-by: Joel Fischer <joeljfischer@gmail.com>
---
 .../ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 315e088c7..96303d694 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -42,7 +42,6 @@ typedef NS_ENUM(NSInteger, ProcessorState) {
 @property (strong, nonatomic) NSMutableData *headerBuffer;
 @property (strong, nonatomic) NSMutableData *payloadBuffer;
 
-// Error checking
 @property (assign, nonatomic) UInt8 version;
 @property (assign, nonatomic) BOOL encrypted;
 @property (assign, nonatomic) SDLFrameType frameType;
@@ -81,9 +80,8 @@ describe(@"The received message processor", ^{
         expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeControl));
     });
     
-    describe(@"transitions to SERVICE_TYPE_STATE when in START_STATE", ^{
-
-        it(@"should receive a byte with a good version 1", ^{
+    describe(@"when in START_STATE", ^{
+        it(@"should transition to next state when receiving version 1", ^{
             Byte testByte = 0x11;
             [testBuffer appendBytes:&testByte length:1];
 
@@ -91,11 +89,10 @@ describe(@"The received message processor", ^{
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
-                expect(messageReadyPayload).toEventually(beNil());
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
             }];
             expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
             expect(testProcessor.version).toEventually(equal(1));
         });
 
@@ -156,7 +153,7 @@ describe(@"The received message processor", ^{
             expect(testProcessor.version).toEventually(equal(5));
         });
 
-        it(@"should recieve a byte with a frameType of SDLFrameTypeControl", ^{
+        it(@"should receive a byte with a frameType of SDLFrameTypeControl", ^{
             Byte testByte = 0x10;
             [testBuffer appendBytes:&testByte length:1];
 
-- 
cgit v1.2.1


From 6d52a1602d6d429a1dbe014c0ad0948a519790e3 Mon Sep 17 00:00:00 2001
From: Justin Beharry <justin.beharry@livio.io>
Date: Wed, 24 Aug 2022 15:10:22 -0400
Subject: update unit tests and add hash to proto headers

-Rename unit tests
-Add expects into into ready blocks
-Create a hash for proto headers for isEqual
---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 512 +++++++++++----------
 1 file changed, 275 insertions(+), 237 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 96303d694..974fd4930 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -85,325 +85,348 @@ describe(@"The received message processor", ^{
             Byte testByte = 0x11;
             [testBuffer appendBytes:&testByte length:1];
 
-            expect(messageReadyPayload).toEventually(beNil());
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
+                expect(testProcessor.version).to(equal(1));
+                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
             }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(testProcessor.version).toEventually(equal(1));
         });
 
-        it(@"should receive a byte with a good version 2", ^{
+        it(@"should transition to next state when receiving version 2", ^{
             Byte testByte = 0x21;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
-            }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
 
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(2));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(testProcessor.version).to(equal(2));
+                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            }];
         });
 
-        it(@"should receive a byte with a good version 3", ^{
+        it(@"should transition to next state when receiving version 3", ^{
             Byte testByte = 0x31;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(testProcessor.version).to(equal(3));
+                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+
             }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(3));
         });
 
-        it(@"should receive a byte with a good version 4", ^{
+        it(@"should transition to next state when receiving version 4", ^{
             Byte testByte = 0x41;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(testProcessor.version).to(equal(4));
+                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
             }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(4));
         });
 
-        it(@"should receive a byte with a good version 5", ^{
+        it(@"should transition to next state when receiving version 5", ^{
             Byte testByte = 0x51;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(testProcessor.version).to(equal(5));
+                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
             }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(5));
         });
 
-        it(@"should receive a byte with a frameType of SDLFrameTypeControl", ^{
+        it(@"should transition to next state when receiving a byte with a frameType of SDLFrameTypeControl", ^{
             Byte testByte = 0x10;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
             }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
         });
 
-        it(@"should recieve a byte with a frameType of SDLFrameTypeSingle", ^{
+        it(@"should transition to next state when receiving a byte with a frameType of SDLFrameTypeSingle", ^{
             Byte testByte = 0x11;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeSingle));
             }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeSingle));
         });
 
-        it(@"should recieve a byte with a frameType of SDLFrameTypeFirst", ^{
+        it(@"should transition to next state when receiving a byte with a frameType of SDLFrameTypeFirst", ^{
             Byte testByte = 0x12;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeFirst));
             }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
         });
 
-        it(@"should recieve a byte with a frameType of SDLFrameTypeConsecutive", ^{
+        it(@"should transition to next state when receiving a byte with a frameType of SDLFrameTypeConsecutive", ^{
             Byte testByte = 0x13;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeConsecutive));
             }];
-            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeConsecutive));
         });
-    });
-
-    describe(@"resets state to START_STATE if the byte is not valid when in START_STATE", ^{
 
-        it(@"should recieve a byte with a bad version 0", ^{
+        it(@"should reset state when receiving a byte with a bad version 0", ^{
             Byte testByte = 0x01;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(testProcessor.version).to(equal(0));
+                expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
+                expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
             }];
-            expect(@(testProcessor.state)).to(equal(START_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(0));
-            expect(testProcessor.headerBuffer).toEventually(equal([NSMutableData data]));
-            expect(testProcessor.payloadBuffer).toEventually(equal([NSMutableData data]));
         });
 
-        it(@"should recieve a byte with a bad version 6", ^{
+        it(@"should reset state when receiving a byte with a bad version 6", ^{
             Byte testByte = 0x61;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(testProcessor.version).to(equal(0));
+                expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
+                expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
             }];
-            expect(@(testProcessor.state)).to(equal(START_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(0));
         });
 
-        it(@"should recieve a byte with an invalid frameType of 6", ^{
+        it(@"should reset state when receiving a byte with an invalid frameType of 6", ^{
             Byte testByte = 0x46; //0100 0 110
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.frameType)).to(equal(0));
+                expect(testProcessor.version).to(equal(0));
             }];
-            expect(@(testProcessor.state)).to(equal(START_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.frameType)).toEventually(equal(0));
-            expect(testProcessor.version).toEventually(equal(0));
         });
     });
 
-    describe(@"transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE", ^ {
+    // transitions to CONTROL_FRAME_INFO_STATE when in SERVICE_TYPE_STATE
+    describe(@"when in SERVICE_TYPE_STATE", ^{
 
         beforeEach(^{
             testProcessor.state = SERVICE_TYPE_STATE;
         });
 
-        it(@"should recieve a SDLServiceTypeControl byte", ^{
+        it(@"should transition to next state when receiving a SDLServiceTypeControl byte", ^{
             Byte testByte = SDLServiceTypeControl;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeControl));
             }];
-            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeControl));
         });
 
-        it(@"should recieve a SDLServiceTypeRPC byte", ^{
+        it(@"should transition to next state when receiving a SDLServiceTypeRPC byte", ^{
             Byte testByte = SDLServiceTypeRPC;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeRPC));
             }];
-            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeRPC));
         });
 
-        it(@"should recieve a SDLServiceTypeAudio byte", ^{
+        it(@"should transition to next state when receiving a SDLServiceTypeAudio byte", ^{
             Byte testByte = SDLServiceTypeAudio;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeAudio));
             }];
-            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeAudio));
         });
 
-        it(@"should receive a SDLServiceTypeVideo byte", ^{
+        it(@"should transition to next state when receiving a SDLServiceTypeVideo byte", ^{
             Byte testByte = SDLServiceTypeVideo;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeVideo));
             }];
-            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeVideo));
         });
 
-        it(@"should receive a SDLServiceTypeBulkData byte", ^{
+        it(@"should transition to next state when receiving a SDLServiceTypeBulkData byte", ^{
             Byte testByte = SDLServiceTypeBulkData;
             [testBuffer appendBytes:&testByte length:1];
 
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeBulkData));
             }];
-            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeBulkData));
         });
-    });
 
-    it(@"resets state to START_STATE when in SERVICE_TYPE_STATE, it receives a invalid byte", ^{
-        testProcessor.state = SERVICE_TYPE_STATE;
-        Byte testByte = 0xFF;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(START_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.serviceType)).toEventually(equal(SDLServiceTypeControl));
-        expect(testProcessor.headerBuffer).toEventually(equal([NSMutableData data]));
-        expect(testProcessor.payloadBuffer).toEventually(equal([NSMutableData data]));
-    });
+        it(@"should reset state when receiving an invalid byte", ^{
+            Byte testByte = 0xFF;
+            [testBuffer appendBytes:&testByte length:1];
 
-    it(@"transitions to SESSION_ID_STATE when in CONTROL_FRAME_INFO_STATE, it receives a valid byte", ^{
-        testProcessor.state = CONTROL_FRAME_INFO_STATE;
-        Byte testByte = 0x00;
-        testProcessor.frameType = SDLFrameTypeFirst;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeFirst));
-    });
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
 
-    it(@"resets to START_STATE when in CONTROL_FRAME_INFO_STATE, it receives a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeFirst", ^{
-        testProcessor.state = CONTROL_FRAME_INFO_STATE;
-        Byte testByte = 0x01;
-        testProcessor.frameType = SDLFrameTypeFirst;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(START_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeControl));
-        expect(testProcessor.headerBuffer).toEventually(equal([NSMutableData data]));
-        expect(testProcessor.payloadBuffer).toEventually(equal([NSMutableData data]));
+                expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeControl));
+                expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
+                expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
+            }];
+        });
     });
 
-    it(@"resets to START_STATE when in CONTROL_FRAME_INFO_STATE, it receives a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeSingle", ^{
-        testProcessor.state = CONTROL_FRAME_INFO_STATE;
-        Byte testByte = 0x01;
-        testProcessor.frameType = SDLFrameTypeSingle;
-        [testBuffer appendBytes:&testByte length:1];
-        
-        [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
-            messageReadyHeader = header;
-            messageReadyPayload = payload;
-        }];
-        expect(@(testProcessor.state)).to(equal(START_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.frameType)).toEventually(equal(SDLFrameTypeControl));
-        expect(testProcessor.headerBuffer).toEventually(equal([NSMutableData data]));
-        expect(testProcessor.payloadBuffer).toEventually(equal([NSMutableData data]));
+    describe(@"when in CONTROL_FRAME_INFO_STATE", ^{
+
+        beforeEach(^{
+            testProcessor.state = CONTROL_FRAME_INFO_STATE;
+        });
+
+        it(@"should transition to next state when receiving a valid byte", ^{
+            Byte testByte = 0x00;
+            testProcessor.frameType = SDLFrameTypeFirst;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeFirst));
+            }];
+        });
+
+        it(@"should reset state when receiving a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeFirst", ^{
+            Byte testByte = 0x01;
+            testProcessor.frameType = SDLFrameTypeFirst;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeControl));
+                expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
+                expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
+            }];
+        });
+
+        it(@"should resets state when receiving a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeSingle", ^{
+            Byte testByte = 0x01;
+            testProcessor.frameType = SDLFrameTypeSingle;
+            [testBuffer appendBytes:&testByte length:1];
+
+            [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
+                messageReadyHeader = header;
+                messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeControl));
+                expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
+                expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
+            }];
+        });
     });
 
-    it(@"transitions to DATA_SIZE_1_STATE when in SESSION_ID_STATE, it receives a byte", ^{
+    it(@"should transition to DATA_SIZE_1_STATE when in SESSION_ID_STATE and receiving a byte", ^{
         testProcessor.state = SESSION_ID_STATE;
         Byte testByte = 0x00;
         [testBuffer appendBytes:&testByte length:1];
@@ -411,15 +434,15 @@ describe(@"The received message processor", ^{
         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
             messageReadyHeader = header;
             messageReadyPayload = payload;
+            
+            expect(@(testProcessor.state)).to(equal(DATA_SIZE_1_STATE));
+            expect(messageReadyHeader).to(beNil());
+            expect(messageReadyPayload).to(beNil());
+            expect(@(testProcessor.dataLength)).to(equal(0));
         }];
-        expect(@(testProcessor.state)).to(equal(DATA_SIZE_1_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.dataLength)).toEventually(equal(0));
-        
     });
 
-    it(@"transitions to DATA_SIZE_2_STATE when in DATA_SIZE_1_STATE, it receives a byte", ^{
+    it(@"should transition to DATA_SIZE_2_STATE when in DATA_SIZE_1_STATE and receiving a byte", ^{
         testProcessor.state = DATA_SIZE_1_STATE;
         Byte testByte = 0x02;
         [testBuffer appendBytes:&testByte length:1];
@@ -427,14 +450,15 @@ describe(@"The received message processor", ^{
         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
             messageReadyHeader = header;
             messageReadyPayload = payload;
+
+            expect(@(testProcessor.state)).to(equal(DATA_SIZE_2_STATE));
+            expect(messageReadyHeader).to(beNil());
+            expect(messageReadyPayload).to(beNil());
+            expect(@(testProcessor.dataLength)).to(equal((UInt32)(testByte & 0xFF) << 24));
         }];
-        expect(@(testProcessor.state)).to(equal(DATA_SIZE_2_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 24));
     });
 
-    it(@"transitions to DATA_SIZE_3_STATE when in DATA_SIZE_2_STATE, it receives a byte", ^{
+    it(@"should transitions to DATA_SIZE_3_STATE when in DATA_SIZE_2_STATE and receiving a byte", ^{
         testProcessor.state = DATA_SIZE_2_STATE;
         Byte testByte = 0x02;
         [testBuffer appendBytes:&testByte length:1];
@@ -442,14 +466,15 @@ describe(@"The received message processor", ^{
         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
             messageReadyHeader = header;
             messageReadyPayload = payload;
+
+            expect(@(testProcessor.state)).to(equal(DATA_SIZE_3_STATE));
+            expect(messageReadyHeader).to(beNil());
+            expect(messageReadyPayload).to(beNil());
+            expect(@(testProcessor.dataLength)).to(equal((UInt32)(testByte & 0xFF) << 16));
         }];
-        expect(@(testProcessor.state)).to(equal(DATA_SIZE_3_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 16));
     });
 
-    it(@"transitions to DATA_SIZE_4_STATE when in DATA_SIZE_3_STATE, it receives a byte", ^{
+    it(@"should transition to DATA_SIZE_4_STATE when in DATA_SIZE_3_STATE and receiving a byte", ^{
         testProcessor.state = DATA_SIZE_3_STATE;
         Byte testByte = 0x02;
         [testBuffer appendBytes:&testByte length:1];
@@ -457,11 +482,12 @@ describe(@"The received message processor", ^{
         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
             messageReadyHeader = header;
             messageReadyPayload = payload;
+
+            expect(@(testProcessor.state)).to(equal(DATA_SIZE_4_STATE));
+            expect(messageReadyHeader).to(beNil());
+            expect(messageReadyPayload).to(beNil());
+            expect(@(testProcessor.dataLength)).to(equal((UInt32)(testByte & 0xFF) << 8));
         }];
-        expect(@(testProcessor.state)).to(equal(DATA_SIZE_4_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
-        expect(@(testProcessor.dataLength)).toEventually(equal((UInt32)(testByte & 0xFF) << 8));
     });
 
     describe(@"when in DATA_SIZE_4_STATE and the version is 1", ^{
@@ -488,7 +514,7 @@ describe(@"The received message processor", ^{
             expectedPayloadBuffer = [NSData data];
         });
 
-        it(@"resets state to START_STATE when it receives a byte and determines the data length is 0", ^{
+        it(@"should reset state when receiving a byte and determines the data length is 0", ^{
             Byte testByte = 0x00;
             [testBuffer appendBytes:&testByte length:1];
             messageReadyHeader = [SDLProtocolHeader headerForVersion:1];
@@ -496,32 +522,35 @@ describe(@"The received message processor", ^{
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(messageReadyHeader).to(equal(expectedMessageReadyHeader));
+                expect(messageReadyPayload).to(equal(expectedPayloadBuffer));
+                expect(@(testProcessor.dataLength)).to(equal(0));
             }];
+
             expect(@(testProcessor.state)).to(equal(START_STATE));
-            expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
-            expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
-            expect(@(testProcessor.dataLength)).toEventually(equal(0));
-            expect(@(testProcessor.version)).toEventually(equal(0));
-            expect(testProcessor.headerBuffer).toEventually(equal([NSMutableData data]));
-            expect(testProcessor.payloadBuffer).toEventually(equal([NSMutableData data]));
+            expect(@(testProcessor.version)).to(equal(0));
+            expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
+            expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
         });
 
-        it(@"transitions to DATA_PUMP_STATE it receives a byte and determines the data length is greater than 0", ^{
+        it(@"should transition to DATA_PUMP_STATE when receiving a byte and determines the data length is greater than 0", ^{
             Byte testByte = 0x01;
             [testBuffer appendBytes:&testByte length:1];
             
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.dataLength)).to(equal(1));
+                expect(@(testProcessor.version)).to(equal(1));
             }];
-            expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.dataLength)).toEventually(equal(1));
-            expect(@(testProcessor.version)).toEventually(equal(1));
         });
 
-        it(@"transitions to START_STATE when it receives a byte and determines the data length is ggreater than maxMtuSize", ^{
+        it(@"should transition to START_STATE when receiving a byte and determines the data length is greater than maxMtuSize", ^{
             testProcessor.serviceType = SDLServiceTypeControl;
             testProcessor.dataLength = 200000;
             
@@ -531,13 +560,14 @@ describe(@"The received message processor", ^{
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(START_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(@(testProcessor.serviceType)).to(equal(0));
+                expect(@(testProcessor.dataLength)).to(equal(0));
+                expect(@(testProcessor.version)).to(equal(0));
             }];
-            expect(@(testProcessor.state)).to(equal(START_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(@(testProcessor.serviceType)).toEventually(equal(0));
-            expect(@(testProcessor.dataLength)).toEventually(equal(0));
-            expect(@(testProcessor.version)).toEventually(equal(0));
         });
     });
 
@@ -564,7 +594,7 @@ describe(@"The received message processor", ^{
             expectedPayloadBuffer = [NSData data];
         });
 
-        it(@"transitions to MESSAGE_1_STATE when it receives a byte", ^{
+        it(@"should transition to MESSAGE_1_STATE when it receives a byte", ^{
             testProcessor.version = 2;
             testProcessor.dataLength = 0;
             
@@ -574,15 +604,16 @@ describe(@"The received message processor", ^{
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(MESSAGE_1_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(testProcessor.version).to(equal(2));
             }];
-            expect(@(testProcessor.state)).to(equal(MESSAGE_1_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(2));
         });
     });
 
-    it(@"transitions to MESSAGE_2_STATE when in MESSAGE_1_STATE, it receives a byte", ^{
+    it(@"should transition to MESSAGE_2_STATE when in MESSAGE_1_STATE, it receives a byte", ^{
         testProcessor.state = MESSAGE_1_STATE;
         Byte testByte = 0x00;
         [testBuffer appendBytes:&testByte length:1];
@@ -590,13 +621,14 @@ describe(@"The received message processor", ^{
         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
             messageReadyHeader = header;
             messageReadyPayload = payload;
+
+            expect(@(testProcessor.state)).to(equal(MESSAGE_2_STATE));
+            expect(messageReadyHeader).to(beNil());
+            expect(messageReadyPayload).to(beNil());
         }];
-        expect(@(testProcessor.state)).to(equal(MESSAGE_2_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
     });
 
-    it(@"transitions to MESSAGE_3_STATE when in MESSAGE_2_STATE, it receives a byte", ^{
+    it(@"should transition to MESSAGE_3_STATE when in MESSAGE_2_STATE and  it receives a byte", ^{
         testProcessor.state = MESSAGE_2_STATE;
         Byte testByte = 0x00;
         [testBuffer appendBytes:&testByte length:1];
@@ -604,13 +636,14 @@ describe(@"The received message processor", ^{
         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
             messageReadyHeader = header;
             messageReadyPayload = payload;
+
+            expect(@(testProcessor.state)).to(equal(MESSAGE_3_STATE));
+            expect(messageReadyHeader).to(beNil());
+            expect(messageReadyPayload).to(beNil());
         }];
-        expect(@(testProcessor.state)).to(equal(MESSAGE_3_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
     });
 
-    it(@"transitions to MESSAGE_4_STATE when in MESSAGE_3_STATE, it receives a byte", ^{
+    it(@"should transition to MESSAGE_4_STATE when in MESSAGE_3_STATE and it receives a byte", ^{
         testProcessor.state = MESSAGE_3_STATE;
         Byte testByte = 0x00;
         [testBuffer appendBytes:&testByte length:1];
@@ -618,13 +651,14 @@ describe(@"The received message processor", ^{
         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
             messageReadyHeader = header;
             messageReadyPayload = payload;
+
+            expect(@(testProcessor.state)).to(equal(MESSAGE_4_STATE));
+            expect(messageReadyHeader).to(beNil());
+            expect(messageReadyPayload).to(beNil());
         }];
-        expect(@(testProcessor.state)).to(equal(MESSAGE_4_STATE));
-        expect(messageReadyHeader).toEventually(beNil());
-        expect(messageReadyPayload).toEventually(beNil());
     });
 
-    describe(@"when in MESSAGE_4_STATE, the version is greater than 1", ^{
+    describe(@"when in MESSAGE_4_STATE and version is greater than 1", ^{
         beforeEach(^{
             testProcessor.state = MESSAGE_4_STATE;
             testProcessor.version = 2;
@@ -650,31 +684,33 @@ describe(@"The received message processor", ^{
             [testBuffer appendBytes:&testByte length:1];
         });
 
-        it(@"resets state to START_STATE when datalength is 0 and it recieves a byte", ^{
+        it(@"should reset state when data length is 0 and receiving a byte", ^{
             testProcessor.dataLength = 0;
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(messageReadyHeader).to(equal(expectedMessageReadyHeader));
+                expect(messageReadyPayload).to(equal(expectedPayloadBuffer));
             }];
+            expect(testProcessor.version).to(equal(0));
+            expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
+            expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
             expect(@(testProcessor.state)).to(equal(START_STATE));
-            expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
-            expect(messageReadyPayload).toEventually(equal(expectedPayloadBuffer));
-            expect(testProcessor.version).toEventually(equal(0));
-            expect(testProcessor.headerBuffer).toEventually(equal([NSMutableData data]));
-            expect(testProcessor.payloadBuffer).toEventually(equal([NSMutableData data]));
         });
 
-        it(@"transitions to DATA_PUMP_STATE when datalength is greater than 0 and it receives a byte", ^{
+        it(@"should transition to DATA_PUMP_STATE when datalength is greater than 0 and receiving a byte", ^{
             testProcessor.dataLength = 1;
             
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(testProcessor.version).to(equal(2));
             }];
-            expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.version).toEventually(equal(2));
         });
     });
 
@@ -682,7 +718,7 @@ describe(@"The received message processor", ^{
         beforeEach(^{
             testProcessor.state = DATA_PUMP_STATE;
             testProcessor.version = 3;
-            //need a valid headerbuffer.
+            //need a valid header buffer.
             Byte firstByte = ((testProcessor.version & 0x0f) << 4) + (0 << 3) + (1 & 0x07); //version 2 with no encryption, frametype 1
             UInt32 dataLength = 3;
             const Byte testBytes[8] = {firstByte, 0x00, 0x00, 0x00, (dataLength >> 24) & 0xff, (dataLength >> 16) & 0xff, (dataLength >> 8) & 0xff, (dataLength) & 0xff };
@@ -699,35 +735,37 @@ describe(@"The received message processor", ^{
             [testBuffer appendBytes:&testByte length:1];
         });
 
-        it(@"Stays in DATA_PUMP_STATE when dataBytesRemaining is greater than 1 and it receives a byte", ^{
+        it(@"should stay in current state when dataBytesRemaining is greater than 1 and receiving a byte", ^{
             testProcessor.dataBytesRemaining = 2;
             
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+                expect(messageReadyHeader).to(beNil());
+                expect(messageReadyPayload).to(beNil());
+                expect(testProcessor.dataBytesRemaining).to(equal(1));
+                expect(testProcessor.version).to(equal(3));
             }];
-            expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
-            expect(messageReadyHeader).toEventually(beNil());
-            expect(messageReadyPayload).toEventually(beNil());
-            expect(testProcessor.dataBytesRemaining).toEventually(equal(1));
-            expect(testProcessor.version).toEventually(equal(3));
         });
 
-        it(@"transitions to START_STATE when dataBytesRemaining is 1 and it receives a byte", ^{
+        it(@"should transition to START_STATE when dataBytesRemaining is 1 and receiving a byte", ^{
             testProcessor.dataBytesRemaining = 1;
             
             [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
+
+                expect(messageReadyHeader).to(equal(expectedMessageReadyHeader));
+                expect(messageReadyPayload).to(equal(testBuffer));
+                expect(testProcessor.dataBytesRemaining).to(equal(0));
             }];
             expect(@(testProcessor.state)).to(equal(START_STATE));
-            expect(messageReadyHeader).toEventually(equal(expectedMessageReadyHeader));
-            expect(messageReadyPayload).toEventually(equal(testBuffer));
-            expect(testProcessor.dataBytesRemaining).toEventually(equal(0));
-            expect(testProcessor.version).toEventually(equal(0));
+            expect(testProcessor.version).to(equal(0));
         });
     });
 });
-    
+
 
 QuickSpecEnd
-- 
cgit v1.2.1


From 375c4130d5eca3dd8a7ec1f3dd17b19c732a989b Mon Sep 17 00:00:00 2001
From: Justin Beharry <justin.beharry@livio.io>
Date: Fri, 26 Aug 2022 11:49:43 -0400
Subject: Move test processor expects outside of completion block

---
 .../SDLProtocolReceivedMessageProcessorSpec.m      | 162 ++++++++++-----------
 1 file changed, 80 insertions(+), 82 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
index 974fd4930..7065e89a8 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/SDLProtocolReceivedMessageProcessorSpec.m
@@ -91,9 +91,9 @@ describe(@"The received message processor", ^{
 
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(testProcessor.version).to(equal(1));
-                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
             }];
+            expect(testProcessor.version).to(equal(1));
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
         });
 
         it(@"should transition to next state when receiving version 2", ^{
@@ -106,9 +106,9 @@ describe(@"The received message processor", ^{
 
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(testProcessor.version).to(equal(2));
-                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
             }];
+            expect(testProcessor.version).to(equal(2));
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
         });
 
         it(@"should transition to next state when receiving version 3", ^{
@@ -121,10 +121,9 @@ describe(@"The received message processor", ^{
 
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(testProcessor.version).to(equal(3));
-                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
-
             }];
+            expect(testProcessor.version).to(equal(3));
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
         });
 
         it(@"should transition to next state when receiving version 4", ^{
@@ -137,9 +136,9 @@ describe(@"The received message processor", ^{
 
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(testProcessor.version).to(equal(4));
-                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
             }];
+            expect(testProcessor.version).to(equal(4));
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
         });
 
         it(@"should transition to next state when receiving version 5", ^{
@@ -152,9 +151,9 @@ describe(@"The received message processor", ^{
 
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(testProcessor.version).to(equal(5));
-                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
             }];
+            expect(testProcessor.version).to(equal(5));
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
         });
 
         it(@"should transition to next state when receiving a byte with a frameType of SDLFrameTypeControl", ^{
@@ -165,10 +164,10 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
             }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
         });
 
         it(@"should transition to next state when receiving a byte with a frameType of SDLFrameTypeSingle", ^{
@@ -179,11 +178,11 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeSingle));
             }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeSingle));
         });
 
         it(@"should transition to next state when receiving a byte with a frameType of SDLFrameTypeFirst", ^{
@@ -194,11 +193,11 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeFirst));
             }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeFirst));
         });
 
         it(@"should transition to next state when receiving a byte with a frameType of SDLFrameTypeConsecutive", ^{
@@ -209,11 +208,11 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeConsecutive));
             }];
+            expect(@(testProcessor.state)).to(equal(SERVICE_TYPE_STATE));
+            expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeConsecutive));
         });
 
         it(@"should reset state when receiving a byte with a bad version 0", ^{
@@ -224,13 +223,13 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(START_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(testProcessor.version).to(equal(0));
-                expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
-                expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
             }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(testProcessor.version).to(equal(0));
+            expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
+            expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
         });
 
         it(@"should reset state when receiving a byte with a bad version 6", ^{
@@ -241,13 +240,13 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(START_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(testProcessor.version).to(equal(0));
-                expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
-                expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
             }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(testProcessor.version).to(equal(0));
+            expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
+            expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
         });
 
         it(@"should reset state when receiving a byte with an invalid frameType of 6", ^{
@@ -258,12 +257,12 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(START_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.frameType)).to(equal(0));
-                expect(testProcessor.version).to(equal(0));
             }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(@(testProcessor.frameType)).to(equal(0));
+            expect(testProcessor.version).to(equal(0));
         });
     });
 
@@ -282,11 +281,11 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeControl));
             }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeControl));
         });
 
         it(@"should transition to next state when receiving a SDLServiceTypeRPC byte", ^{
@@ -297,11 +296,11 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeRPC));
             }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeRPC));
         });
 
         it(@"should transition to next state when receiving a SDLServiceTypeAudio byte", ^{
@@ -312,11 +311,11 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeAudio));
             }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeAudio));
         });
 
         it(@"should transition to next state when receiving a SDLServiceTypeVideo byte", ^{
@@ -327,11 +326,11 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeVideo));
             }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeVideo));
         });
 
         it(@"should transition to next state when receiving a SDLServiceTypeBulkData byte", ^{
@@ -342,11 +341,11 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeBulkData));
             }];
+            expect(@(testProcessor.state)).to(equal(CONTROL_FRAME_INFO_STATE));
+            expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeBulkData));
         });
 
         it(@"should reset state when receiving an invalid byte", ^{
@@ -357,13 +356,13 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(START_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeControl));
-                expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
-                expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
             }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(@(testProcessor.serviceType)).to(equal(SDLServiceTypeControl));
+            expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
+            expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
         });
     });
 
@@ -382,11 +381,11 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeFirst));
             }];
+            expect(@(testProcessor.state)).to(equal(SESSION_ID_STATE));
+            expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeFirst));
         });
 
         it(@"should reset state when receiving a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeFirst", ^{
@@ -398,13 +397,13 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(START_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeControl));
-                expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
-                expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
             }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeControl));
+            expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
+            expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
         });
 
         it(@"should resets state when receiving a byte where controlFrameInfo is not 0 and frameType is SDLFrameTypeSingle", ^{
@@ -416,13 +415,13 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(START_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeControl));
-                expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
-                expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
             }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(@(testProcessor.frameType)).to(equal(SDLFrameTypeControl));
+            expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
+            expect(testProcessor.payloadBuffer).to(equal([NSMutableData data]));
         });
     });
 
@@ -434,12 +433,12 @@ describe(@"The received message processor", ^{
         [testProcessor processReceiveBuffer:testBuffer withMessageReadyBlock:^(SDLProtocolHeader *header, NSData *payload) {
             messageReadyHeader = header;
             messageReadyPayload = payload;
-            
-            expect(@(testProcessor.state)).to(equal(DATA_SIZE_1_STATE));
+
             expect(messageReadyHeader).to(beNil());
             expect(messageReadyPayload).to(beNil());
-            expect(@(testProcessor.dataLength)).to(equal(0));
         }];
+        expect(@(testProcessor.state)).to(equal(DATA_SIZE_1_STATE));
+        expect(@(testProcessor.dataLength)).to(equal(0));
     });
 
     it(@"should transition to DATA_SIZE_2_STATE when in DATA_SIZE_1_STATE and receiving a byte", ^{
@@ -451,11 +450,11 @@ describe(@"The received message processor", ^{
             messageReadyHeader = header;
             messageReadyPayload = payload;
 
-            expect(@(testProcessor.state)).to(equal(DATA_SIZE_2_STATE));
             expect(messageReadyHeader).to(beNil());
             expect(messageReadyPayload).to(beNil());
-            expect(@(testProcessor.dataLength)).to(equal((UInt32)(testByte & 0xFF) << 24));
         }];
+        expect(@(testProcessor.state)).to(equal(DATA_SIZE_2_STATE));
+        expect(@(testProcessor.dataLength)).to(equal((UInt32)(testByte & 0xFF) << 24));
     });
 
     it(@"should transitions to DATA_SIZE_3_STATE when in DATA_SIZE_2_STATE and receiving a byte", ^{
@@ -467,11 +466,11 @@ describe(@"The received message processor", ^{
             messageReadyHeader = header;
             messageReadyPayload = payload;
 
-            expect(@(testProcessor.state)).to(equal(DATA_SIZE_3_STATE));
             expect(messageReadyHeader).to(beNil());
             expect(messageReadyPayload).to(beNil());
-            expect(@(testProcessor.dataLength)).to(equal((UInt32)(testByte & 0xFF) << 16));
         }];
+        expect(@(testProcessor.state)).to(equal(DATA_SIZE_3_STATE));
+        expect(@(testProcessor.dataLength)).to(equal((UInt32)(testByte & 0xFF) << 16));
     });
 
     it(@"should transition to DATA_SIZE_4_STATE when in DATA_SIZE_3_STATE and receiving a byte", ^{
@@ -483,11 +482,11 @@ describe(@"The received message processor", ^{
             messageReadyHeader = header;
             messageReadyPayload = payload;
 
-            expect(@(testProcessor.state)).to(equal(DATA_SIZE_4_STATE));
             expect(messageReadyHeader).to(beNil());
             expect(messageReadyPayload).to(beNil());
-            expect(@(testProcessor.dataLength)).to(equal((UInt32)(testByte & 0xFF) << 8));
         }];
+        expect(@(testProcessor.state)).to(equal(DATA_SIZE_4_STATE));
+        expect(@(testProcessor.dataLength)).to(equal((UInt32)(testByte & 0xFF) << 8));
     });
 
     describe(@"when in DATA_SIZE_4_STATE and the version is 1", ^{
@@ -525,9 +524,8 @@ describe(@"The received message processor", ^{
 
                 expect(messageReadyHeader).to(equal(expectedMessageReadyHeader));
                 expect(messageReadyPayload).to(equal(expectedPayloadBuffer));
-                expect(@(testProcessor.dataLength)).to(equal(0));
             }];
-
+            expect(@(testProcessor.dataLength)).to(equal(0));
             expect(@(testProcessor.state)).to(equal(START_STATE));
             expect(@(testProcessor.version)).to(equal(0));
             expect(testProcessor.headerBuffer).to(equal([NSMutableData data]));
@@ -542,12 +540,12 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.dataLength)).to(equal(1));
-                expect(@(testProcessor.version)).to(equal(1));
             }];
+            expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+            expect(@(testProcessor.dataLength)).to(equal(1));
+            expect(@(testProcessor.version)).to(equal(1));
         });
 
         it(@"should transition to START_STATE when receiving a byte and determines the data length is greater than maxMtuSize", ^{
@@ -561,13 +559,13 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(START_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(@(testProcessor.serviceType)).to(equal(0));
-                expect(@(testProcessor.dataLength)).to(equal(0));
-                expect(@(testProcessor.version)).to(equal(0));
             }];
+            expect(@(testProcessor.state)).to(equal(START_STATE));
+            expect(@(testProcessor.serviceType)).to(equal(0));
+            expect(@(testProcessor.dataLength)).to(equal(0));
+            expect(@(testProcessor.version)).to(equal(0));
         });
     });
 
@@ -605,11 +603,11 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(MESSAGE_1_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(testProcessor.version).to(equal(2));
             }];
+            expect(@(testProcessor.state)).to(equal(MESSAGE_1_STATE));
+            expect(testProcessor.version).to(equal(2));
         });
     });
 
@@ -622,10 +620,10 @@ describe(@"The received message processor", ^{
             messageReadyHeader = header;
             messageReadyPayload = payload;
 
-            expect(@(testProcessor.state)).to(equal(MESSAGE_2_STATE));
             expect(messageReadyHeader).to(beNil());
             expect(messageReadyPayload).to(beNil());
         }];
+        expect(@(testProcessor.state)).to(equal(MESSAGE_2_STATE));
     });
 
     it(@"should transition to MESSAGE_3_STATE when in MESSAGE_2_STATE and  it receives a byte", ^{
@@ -637,10 +635,10 @@ describe(@"The received message processor", ^{
             messageReadyHeader = header;
             messageReadyPayload = payload;
 
-            expect(@(testProcessor.state)).to(equal(MESSAGE_3_STATE));
             expect(messageReadyHeader).to(beNil());
             expect(messageReadyPayload).to(beNil());
         }];
+        expect(@(testProcessor.state)).to(equal(MESSAGE_3_STATE));
     });
 
     it(@"should transition to MESSAGE_4_STATE when in MESSAGE_3_STATE and it receives a byte", ^{
@@ -652,10 +650,10 @@ describe(@"The received message processor", ^{
             messageReadyHeader = header;
             messageReadyPayload = payload;
 
-            expect(@(testProcessor.state)).to(equal(MESSAGE_4_STATE));
             expect(messageReadyHeader).to(beNil());
             expect(messageReadyPayload).to(beNil());
         }];
+        expect(@(testProcessor.state)).to(equal(MESSAGE_4_STATE));
     });
 
     describe(@"when in MESSAGE_4_STATE and version is greater than 1", ^{
@@ -706,11 +704,11 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(testProcessor.version).to(equal(2));
             }];
+            expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+            expect(testProcessor.version).to(equal(2));
         });
     });
 
@@ -742,12 +740,12 @@ describe(@"The received message processor", ^{
                 messageReadyHeader = header;
                 messageReadyPayload = payload;
 
-                expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
                 expect(messageReadyHeader).to(beNil());
                 expect(messageReadyPayload).to(beNil());
-                expect(testProcessor.dataBytesRemaining).to(equal(1));
-                expect(testProcessor.version).to(equal(3));
             }];
+            expect(@(testProcessor.state)).to(equal(DATA_PUMP_STATE));
+            expect(testProcessor.dataBytesRemaining).to(equal(1));
+            expect(testProcessor.version).to(equal(3));
         });
 
         it(@"should transition to START_STATE when dataBytesRemaining is 1 and receiving a byte", ^{
@@ -759,8 +757,8 @@ describe(@"The received message processor", ^{
 
                 expect(messageReadyHeader).to(equal(expectedMessageReadyHeader));
                 expect(messageReadyPayload).to(equal(testBuffer));
-                expect(testProcessor.dataBytesRemaining).to(equal(0));
             }];
+            expect(testProcessor.dataBytesRemaining).to(equal(0));
             expect(@(testProcessor.state)).to(equal(START_STATE));
             expect(testProcessor.version).to(equal(0));
         });
-- 
cgit v1.2.1


From 899bcbfca63e755c8806b781a31df87c6fd436b9 Mon Sep 17 00:00:00 2001
From: Justin Beharry <justin.beharry@livio.io>
Date: Thu, 1 Sep 2022 11:12:57 -0400
Subject: Add test for Headers and modify hash function

Removed data from hash function. Does not work on SDlProtocolHeader hash
---
 .../ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m   | 17 +++++++++++++++++
 .../ProtocolSpecs/HeaderSpecs/SDLV1ProtocolHeaderSpec.m | 17 +++++++++++++++++
 .../ProtocolSpecs/HeaderSpecs/SDLV2ProtocolHeaderSpec.m | 17 +++++++++++++++++
 3 files changed, 51 insertions(+)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m
index a578ec561..9fcff743c 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m
@@ -38,4 +38,21 @@ describe(@"DetermineVersion Tests", ^ {
     });
 });
 
+describe(@"Hash Tests", ^ {
+    it(@"Should return equivalent hash values", ^ {
+        SDLProtocolHeader *testHeader = [[SDLProtocolHeader alloc] init];
+        SDLProtocolHeader *equalHeader = [[SDLProtocolHeader alloc] init];
+
+        expect([testHeader hash]).to(equal([equalHeader hash]));
+    });
+
+    it(@"Should return unequivalent hash values", ^ {
+        SDLProtocolHeader *testHeader = [[SDLProtocolHeader alloc] init];
+        SDLProtocolHeader *unequalHeader = [[SDLProtocolHeader alloc] init];
+        unequalHeader.frameType = SDLFrameTypeFirst;
+
+        expect([testHeader hash]).toNot(equal([unequalHeader hash]));
+    });
+});
+
 QuickSpecEnd
diff --git a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV1ProtocolHeaderSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV1ProtocolHeaderSpec.m
index a7c6c1660..d5ddb4707 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV1ProtocolHeaderSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV1ProtocolHeaderSpec.m
@@ -86,4 +86,21 @@ describe(@"RPCPayloadWithData Test", ^ {
     });
 });
 
+describe(@"IsEqual Tests", ^ {
+    it (@"Should be equal to copy of header", ^ {
+        // Create exact copy of test header
+        SDLV1ProtocolHeader *equalHeader = [testHeader copy];
+
+        expect([testHeader isEqual:equalHeader]).to(equal(@YES));
+    });
+
+    it (@"Should not be equal to a different header", ^ {
+        // create a slighty different version of test header
+        SDLV1ProtocolHeader *unequalHeader = [testHeader copy];
+        unequalHeader.encrypted = NO;
+
+        expect(([testHeader isEqual:unequalHeader])).to(equal(@NO));
+    });
+});
+
 QuickSpecEnd
diff --git a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV2ProtocolHeaderSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV2ProtocolHeaderSpec.m
index 1ade6e426..8c1de8a56 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV2ProtocolHeaderSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV2ProtocolHeaderSpec.m
@@ -90,4 +90,21 @@ describe(@"RPCPayloadWithData Test", ^ {
     });
 });
 
+describe(@"IsEqual Tests", ^ {
+    it (@"Should be equal to copy of header", ^ {
+        // Create exact copy of test header
+        SDLV2ProtocolHeader *equalHeader = [testHeader copy];
+
+        expect([testHeader isEqual:equalHeader]).to(equal(@YES));
+    });
+
+    it (@"Should not be equal to a different header", ^ {
+        // Create a slighty different version of test header
+        SDLV2ProtocolHeader *unequalHeader = [testHeader copy];
+        unequalHeader.messageID = 0x6DAB424E;
+
+        expect(([testHeader isEqual:unequalHeader])).to(equal(@NO));
+    });
+});
+
 QuickSpecEnd
-- 
cgit v1.2.1


From 95da8e724d1d8599a30586539e5eca08b37f5be8 Mon Sep 17 00:00:00 2001
From: Justin Beharry <109764059+jshivabeharry@users.noreply.github.com>
Date: Thu, 1 Sep 2022 12:41:45 -0400
Subject: Apply suggestions from code review

Co-authored-by: Joel Fischer <joeljfischer@gmail.com>
---
 .../ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m          |  6 +++---
 .../ProtocolSpecs/HeaderSpecs/SDLV1ProtocolHeaderSpec.m        | 10 +++++-----
 .../ProtocolSpecs/HeaderSpecs/SDLV2ProtocolHeaderSpec.m        | 10 +++++-----
 3 files changed, 13 insertions(+), 13 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m
index 9fcff743c..0e042ba4b 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m
@@ -38,15 +38,15 @@ describe(@"DetermineVersion Tests", ^ {
     });
 });
 
-describe(@"Hash Tests", ^ {
-    it(@"Should return equivalent hash values", ^ {
+describe(@"hashing tests", ^ {
+    it(@"should return equivalent hash values", ^ {
         SDLProtocolHeader *testHeader = [[SDLProtocolHeader alloc] init];
         SDLProtocolHeader *equalHeader = [[SDLProtocolHeader alloc] init];
 
         expect([testHeader hash]).to(equal([equalHeader hash]));
     });
 
-    it(@"Should return unequivalent hash values", ^ {
+    it(@"should return unequivalent hash values", ^ {
         SDLProtocolHeader *testHeader = [[SDLProtocolHeader alloc] init];
         SDLProtocolHeader *unequalHeader = [[SDLProtocolHeader alloc] init];
         unequalHeader.frameType = SDLFrameTypeFirst;
diff --git a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV1ProtocolHeaderSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV1ProtocolHeaderSpec.m
index d5ddb4707..f2218f7db 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV1ProtocolHeaderSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV1ProtocolHeaderSpec.m
@@ -86,20 +86,20 @@ describe(@"RPCPayloadWithData Test", ^ {
     });
 });
 
-describe(@"IsEqual Tests", ^ {
-    it (@"Should be equal to copy of header", ^ {
+describe(@"equality tests", ^ {
+    it (@"should be equal to copy of header", ^ {
         // Create exact copy of test header
         SDLV1ProtocolHeader *equalHeader = [testHeader copy];
 
-        expect([testHeader isEqual:equalHeader]).to(equal(@YES));
+        expect([testHeader isEqual:equalHeader]).to(beTrue());
     });
 
-    it (@"Should not be equal to a different header", ^ {
+    it (@"should not be equal to a different header", ^ {
         // create a slighty different version of test header
         SDLV1ProtocolHeader *unequalHeader = [testHeader copy];
         unequalHeader.encrypted = NO;
 
-        expect(([testHeader isEqual:unequalHeader])).to(equal(@NO));
+        expect(([testHeader isEqual:unequalHeader])).to(beFalse());
     });
 });
 
diff --git a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV2ProtocolHeaderSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV2ProtocolHeaderSpec.m
index 8c1de8a56..ec06d2b4d 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV2ProtocolHeaderSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLV2ProtocolHeaderSpec.m
@@ -90,20 +90,20 @@ describe(@"RPCPayloadWithData Test", ^ {
     });
 });
 
-describe(@"IsEqual Tests", ^ {
-    it (@"Should be equal to copy of header", ^ {
+describe(@"equality tests", ^ {
+    it (@"should be equal to copy of header", ^ {
         // Create exact copy of test header
         SDLV2ProtocolHeader *equalHeader = [testHeader copy];
 
-        expect([testHeader isEqual:equalHeader]).to(equal(@YES));
+        expect([testHeader isEqual:equalHeader]).to(beTrue());
     });
 
-    it (@"Should not be equal to a different header", ^ {
+    it (@"should not be equal to a different header", ^ {
         // Create a slighty different version of test header
         SDLV2ProtocolHeader *unequalHeader = [testHeader copy];
         unequalHeader.messageID = 0x6DAB424E;
 
-        expect(([testHeader isEqual:unequalHeader])).to(equal(@NO));
+        expect(([testHeader isEqual:unequalHeader])).to(beFalse());
     });
 });
 
-- 
cgit v1.2.1


From 1d50cc2f21bcd1dbbe2b810e058c757a1f516c96 Mon Sep 17 00:00:00 2001
From: Justin Beharry <justin.beharry@livio.io>
Date: Thu, 1 Sep 2022 14:28:49 -0400
Subject: Add data to SDLProtocolHeader test

---
 .../HeaderSpecs/SDLProtocolHeaderSpec.m            | 25 ++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

(limited to 'SmartDeviceLinkTests')

diff --git a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m
index 0e042ba4b..9dac0203f 100644
--- a/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m
+++ b/SmartDeviceLinkTests/ProtocolSpecs/HeaderSpecs/SDLProtocolHeaderSpec.m
@@ -15,6 +15,18 @@
 
 QuickSpecBegin(SDLProtocolHeaderSpec)
 
+__block SDLProtocolHeader *testHeader;
+
+beforeSuite(^ {
+    testHeader = [[SDLProtocolHeader alloc] init];
+    testHeader.encrypted = YES;
+    testHeader.frameType = SDLFrameTypeControl;
+    testHeader.serviceType = SDLServiceTypeRPC;
+    testHeader.frameData = SDLFrameInfoStartService;
+    testHeader.sessionID = 0x53;
+    testHeader.bytesInPayload = 0x1234;
+});
+
 describe(@"HeaderForVersion Tests", ^ {
     it(@"Should return the correct header", ^ {
         expect([SDLProtocolHeader headerForVersion:1]).to(beAKindOf(SDLV1ProtocolHeader.class));
@@ -40,16 +52,25 @@ describe(@"DetermineVersion Tests", ^ {
 
 describe(@"hashing tests", ^ {
     it(@"should return equivalent hash values", ^ {
-        SDLProtocolHeader *testHeader = [[SDLProtocolHeader alloc] init];
         SDLProtocolHeader *equalHeader = [[SDLProtocolHeader alloc] init];
+        equalHeader.encrypted = YES;
+        equalHeader.frameType = SDLFrameTypeControl;
+        equalHeader.serviceType = SDLServiceTypeRPC;
+        equalHeader.frameData = SDLFrameInfoStartService;
+        equalHeader.sessionID = 0x53;
+        equalHeader.bytesInPayload = 0x1234;
 
         expect([testHeader hash]).to(equal([equalHeader hash]));
     });
 
     it(@"should return unequivalent hash values", ^ {
-        SDLProtocolHeader *testHeader = [[SDLProtocolHeader alloc] init];
         SDLProtocolHeader *unequalHeader = [[SDLProtocolHeader alloc] init];
+        unequalHeader.encrypted = NO;
         unequalHeader.frameType = SDLFrameTypeFirst;
+        unequalHeader.serviceType = SDLServiceTypeVideo;
+        unequalHeader.frameData = SDLFrameInfoStartService;
+        unequalHeader.sessionID = 0x54;
+        unequalHeader.bytesInPayload = 0x1234;
 
         expect([testHeader hash]).toNot(equal([unequalHeader hash]));
     });
-- 
cgit v1.2.1