cosmos 3.0.1 → 3.1.0

data/spec/streams/preidentified_stream_protocol_spec.rb

@@ -1,118 +1,118 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'spec_helper'
-require 'cosmos/streams/preidentified_stream_protocol'
-require 'cosmos/interfaces/interface'
-require 'cosmos/streams/stream'
-
-module Cosmos
-
-  class MyInterface < Interface; end
-
-  describe PreidentifiedStreamProtocol do
-    before(:each) do
-      @psp = PreidentifiedStreamProtocol.new
-    end
-
-    after(:all) do
-      clean_config()
-    end
-
-    it "should handle receiving a bad packet length" do
-      @psp = PreidentifiedStreamProtocol.new(nil, 5)
-      pkt = System.telemetry.packet("COSMOS","VERSION")
-      class MyStream < Stream
-        def connected?; true; end
-        def read; $buffer; end
-        def write(data); $buffer = data; end
-      end
-      stream = MyStream.new
-      @psp.connect(stream)
-      time = Time.new(2020,1,31,12,15,30.5)
-      pkt.received_time = time
-      @psp.write(pkt)
-      expect { packet = @psp.read }.to raise_error(RuntimeError)
-    end
-
-    describe "initialize" do
-      it "should initialize attributes" do
-        @psp.bytes_read.should eql 0
-        @psp.bytes_written.should eql 0
-        @psp.interface.should be_nil
-        @psp.stream.should be_nil
-        @psp.post_read_data_callback.should be_nil
-        @psp.post_read_packet_callback.should be_nil
-        @psp.pre_write_packet_callback.should be_nil
-      end
-    end
-
-    describe "write" do
-      it "should create a packet header" do
-        pkt = System.telemetry.packet("COSMOS","VERSION")
-        class MyStream < Stream
-          def connected?; true; end
-          def read; $buffer; end
-          def write(data); $buffer = data; end
-        end
-        stream = MyStream.new
-        @psp.connect(stream)
-        time = Time.new(2020,1,31,12,15,30.5)
-        pkt.received_time = time
-        @psp.write(pkt)
-        $buffer[0..3].unpack('N')[0].should eql time.to_f.to_i
-        $buffer[4..7].unpack('N')[0].should eql 500000
-        offset = 8
-        tgt_name_length = $buffer[offset].unpack('C')[0]
-        offset += 1 # for the length field
-        $buffer[offset...(offset+tgt_name_length)].should eql 'COSMOS'
-        offset += tgt_name_length
-        pkt_name_length = $buffer[offset].unpack('C')[0]
-        offset += 1 # for the length field
-        $buffer[offset...(offset+pkt_name_length)].should eql 'VERSION'
-        offset += pkt_name_length
-        $buffer[offset..(offset+3)].unpack('N')[0].should eql pkt.buffer.length
-        offset += 4
-        $buffer[offset..-1].should eql pkt.buffer
-      end
-    end
-
-    describe "read" do
-      it "should return a packet" do
-        pkt = System.telemetry.packet("COSMOS","VERSION")
-        pkt.write("PKT_ID", 1)
-        pkt.write("COSMOS", "TEST")
-        class MyStream < Stream
-          def connected?; true; end
-          def read; $buffer; end
-          def write(data); $buffer = data; end
-        end
-        stream = MyStream.new
-        @psp.connect(stream)
-        time = Time.new(2020,1,31,12,15,30.5)
-        pkt.received_time = time
-        @psp.write(pkt)
-        packet = @psp.read
-        packet.target_name.should eql 'COSMOS'
-        packet.packet_name.should eql 'VERSION'
-        packet.identified?.should be_truthy
-        packet.defined?.should be_falsey
-
-        pkt2 = System.telemetry.update!("COSMOS","VERSION",packet.buffer)
-        pkt2.read('PKT_ID').should eql 1
-        pkt2.read('COSMOS').should eql 'TEST'
-        pkt2.identified?.should be_truthy
-        pkt2.defined?.should be_truthy
-      end
-    end
-
-  end
-end
-
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'spec_helper'
+require 'cosmos/streams/preidentified_stream_protocol'
+require 'cosmos/interfaces/interface'
+require 'cosmos/streams/stream'
+
+module Cosmos
+
+  class MyInterface < Interface; end
+
+  describe PreidentifiedStreamProtocol do
+    before(:each) do
+      @psp = PreidentifiedStreamProtocol.new
+    end
+
+    after(:all) do
+      clean_config()
+    end
+
+    it "should handle receiving a bad packet length" do
+      @psp = PreidentifiedStreamProtocol.new(nil, 5)
+      pkt = System.telemetry.packet("COSMOS","VERSION")
+      class MyStream < Stream
+        def connected?; true; end
+        def read; $buffer; end
+        def write(data); $buffer = data; end
+      end
+      stream = MyStream.new
+      @psp.connect(stream)
+      time = Time.new(2020,1,31,12,15,30.5)
+      pkt.received_time = time
+      @psp.write(pkt)
+      expect { packet = @psp.read }.to raise_error(RuntimeError)
+    end
+
+    describe "initialize" do
+      it "should initialize attributes" do
+        @psp.bytes_read.should eql 0
+        @psp.bytes_written.should eql 0
+        @psp.interface.should be_nil
+        @psp.stream.should be_nil
+        @psp.post_read_data_callback.should be_nil
+        @psp.post_read_packet_callback.should be_nil
+        @psp.pre_write_packet_callback.should be_nil
+      end
+    end
+
+    describe "write" do
+      it "should create a packet header" do
+        pkt = System.telemetry.packet("COSMOS","VERSION")
+        class MyStream < Stream
+          def connected?; true; end
+          def read; $buffer; end
+          def write(data); $buffer = data; end
+        end
+        stream = MyStream.new
+        @psp.connect(stream)
+        time = Time.new(2020,1,31,12,15,30.5)
+        pkt.received_time = time
+        @psp.write(pkt)
+        $buffer[0..3].unpack('N')[0].should eql time.to_f.to_i
+        $buffer[4..7].unpack('N')[0].should eql 500000
+        offset = 8
+        tgt_name_length = $buffer[offset].unpack('C')[0]
+        offset += 1 # for the length field
+        $buffer[offset...(offset+tgt_name_length)].should eql 'COSMOS'
+        offset += tgt_name_length
+        pkt_name_length = $buffer[offset].unpack('C')[0]
+        offset += 1 # for the length field
+        $buffer[offset...(offset+pkt_name_length)].should eql 'VERSION'
+        offset += pkt_name_length
+        $buffer[offset..(offset+3)].unpack('N')[0].should eql pkt.buffer.length
+        offset += 4
+        $buffer[offset..-1].should eql pkt.buffer
+      end
+    end
+
+    describe "read" do
+      it "should return a packet" do
+        pkt = System.telemetry.packet("COSMOS","VERSION")
+        pkt.write("PKT_ID", 1)
+        pkt.write("COSMOS", "TEST")
+        class MyStream < Stream
+          def connected?; true; end
+          def read; $buffer; end
+          def write(data); $buffer = data; end
+        end
+        stream = MyStream.new
+        @psp.connect(stream)
+        time = Time.new(2020,1,31,12,15,30.5)
+        pkt.received_time = time
+        @psp.write(pkt)
+        packet = @psp.read
+        packet.target_name.should eql 'COSMOS'
+        packet.packet_name.should eql 'VERSION'
+        packet.identified?.should be_truthy
+        packet.defined?.should be_falsey
+
+        pkt2 = System.telemetry.update!("COSMOS","VERSION",packet.buffer)
+        pkt2.read('PKT_ID').should eql 1
+        pkt2.read('COSMOS').should eql 'TEST'
+        pkt2.identified?.should be_truthy
+        pkt2.defined?.should be_truthy
+      end
+    end
+
+  end
+end
+

data/spec/streams/serial_stream_spec.rb

@@ -1,105 +1,105 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'spec_helper'
-require 'cosmos/streams/serial_stream'
-
-module Cosmos
-
-  describe SerialStream do
-    describe "initialize" do
-      it "should complain if neither a read or write port given" do
-        expect { SerialStream.new(nil,nil,9600,:EVEN,1,nil,nil) }.to raise_error("Either a write port or read port must be given")
-      end
-    end
-
-    describe "connected?" do
-      it "should be connected when initialized" do
-        driver = double("driver")
-        expect(SerialDriver).to receive(:new).and_return(driver)
-        ss = SerialStream.new('COM1',nil,9600,:EVEN,1,nil,nil)
-        ss.connected?.should be_truthy
-      end
-    end
-
-    describe "read" do
-      it "should raise an error if no read port given" do
-        driver = double("driver")
-        expect(SerialDriver).to receive(:new).and_return(driver)
-        ss = SerialStream.new('COM1',nil,9600,:EVEN,1,nil,nil)
-        expect { ss.read }.to raise_error("Attempt to read from write only stream")
-      end
-
-      it "should call read from the driver" do
-        driver = double("driver")
-        expect(driver).to receive(:read).and_return 'test'
-        expect(SerialDriver).to receive(:new).and_return(driver)
-        ss = SerialStream.new('COM1','COM1',9600,:EVEN,1,nil,nil)
-        ss.read.should eql 'test'
-      end
-    end
-
-    describe "write" do
-      it "should raise an error if no write port given" do
-        driver = double("driver")
-        expect(SerialDriver).to receive(:new).and_return(driver)
-        ss = SerialStream.new(nil,'COM1',9600,:EVEN,1,nil,nil)
-        expect { ss.write('') }.to raise_error("Attempt to write to read only stream")
-      end
-
-      it "should call write from the driver" do
-        driver = double("driver")
-        expect(driver).to receive(:write).with('test')
-        expect(SerialDriver).to receive(:new).and_return(driver)
-        ss = SerialStream.new('COM1','COM1',9600,:EVEN,1,nil,nil)
-        ss.write('test')
-      end
-    end
-
-    describe "disconnect" do
-      it "should close the write driver" do
-        driver = double("driver")
-        expect(driver).to receive(:closed?).and_return(false)
-        expect(driver).to receive(:close)
-        expect(SerialDriver).to receive(:new).and_return(driver)
-        ss = SerialStream.new('COM1',nil,9600,:EVEN,1,nil,nil)
-        ss.connected?.should be_truthy
-        ss.disconnect
-        ss.connected?.should be_falsey
-      end
-
-      it "should close the read driver" do
-        driver = double("driver")
-        expect(driver).to receive(:closed?).and_return(false)
-        expect(driver).to receive(:close)
-        expect(SerialDriver).to receive(:new).and_return(driver)
-        ss = SerialStream.new(nil,'COM1',9600,:EVEN,1,nil,nil)
-        ss.connected?.should be_truthy
-        ss.disconnect
-        ss.connected?.should be_falsey
-      end
-
-      it "shouldn't close the driver twice" do
-        driver = double("driver")
-        expect(driver).to receive(:closed?).and_return(false, true)
-        expect(driver).to receive(:close).once
-        expect(SerialDriver).to receive(:new).and_return(driver)
-        ss = SerialStream.new('COM1','COM1',9600,:EVEN,1,nil,nil)
-        ss.connected?.should be_truthy
-        ss.disconnect
-        ss.connected?.should be_falsey
-        ss.disconnect
-        ss.connected?.should be_falsey
-      end
-    end
-
-  end
-end
-
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'spec_helper'
+require 'cosmos/streams/serial_stream'
+
+module Cosmos
+
+  describe SerialStream do
+    describe "initialize" do
+      it "should complain if neither a read or write port given" do
+        expect { SerialStream.new(nil,nil,9600,:EVEN,1,nil,nil) }.to raise_error("Either a write port or read port must be given")
+      end
+    end
+
+    describe "connected?" do
+      it "should be connected when initialized" do
+        driver = double("driver")
+        expect(SerialDriver).to receive(:new).and_return(driver)
+        ss = SerialStream.new('COM1',nil,9600,:EVEN,1,nil,nil)
+        ss.connected?.should be_truthy
+      end
+    end
+
+    describe "read" do
+      it "should raise an error if no read port given" do
+        driver = double("driver")
+        expect(SerialDriver).to receive(:new).and_return(driver)
+        ss = SerialStream.new('COM1',nil,9600,:EVEN,1,nil,nil)
+        expect { ss.read }.to raise_error("Attempt to read from write only stream")
+      end
+
+      it "should call read from the driver" do
+        driver = double("driver")
+        expect(driver).to receive(:read).and_return 'test'
+        expect(SerialDriver).to receive(:new).and_return(driver)
+        ss = SerialStream.new('COM1','COM1',9600,:EVEN,1,nil,nil)
+        ss.read.should eql 'test'
+      end
+    end
+
+    describe "write" do
+      it "should raise an error if no write port given" do
+        driver = double("driver")
+        expect(SerialDriver).to receive(:new).and_return(driver)
+        ss = SerialStream.new(nil,'COM1',9600,:EVEN,1,nil,nil)
+        expect { ss.write('') }.to raise_error("Attempt to write to read only stream")
+      end
+
+      it "should call write from the driver" do
+        driver = double("driver")
+        expect(driver).to receive(:write).with('test')
+        expect(SerialDriver).to receive(:new).and_return(driver)
+        ss = SerialStream.new('COM1','COM1',9600,:EVEN,1,nil,nil)
+        ss.write('test')
+      end
+    end
+
+    describe "disconnect" do
+      it "should close the write driver" do
+        driver = double("driver")
+        expect(driver).to receive(:closed?).and_return(false)
+        expect(driver).to receive(:close)
+        expect(SerialDriver).to receive(:new).and_return(driver)
+        ss = SerialStream.new('COM1',nil,9600,:EVEN,1,nil,nil)
+        ss.connected?.should be_truthy
+        ss.disconnect
+        ss.connected?.should be_falsey
+      end
+
+      it "should close the read driver" do
+        driver = double("driver")
+        expect(driver).to receive(:closed?).and_return(false)
+        expect(driver).to receive(:close)
+        expect(SerialDriver).to receive(:new).and_return(driver)
+        ss = SerialStream.new(nil,'COM1',9600,:EVEN,1,nil,nil)
+        ss.connected?.should be_truthy
+        ss.disconnect
+        ss.connected?.should be_falsey
+      end
+
+      it "shouldn't close the driver twice" do
+        driver = double("driver")
+        expect(driver).to receive(:closed?).and_return(false, true)
+        expect(driver).to receive(:close).once
+        expect(SerialDriver).to receive(:new).and_return(driver)
+        ss = SerialStream.new('COM1','COM1',9600,:EVEN,1,nil,nil)
+        ss.connected?.should be_truthy
+        ss.disconnect
+        ss.connected?.should be_falsey
+        ss.disconnect
+        ss.connected?.should be_falsey
+      end
+    end
+
+  end
+end
+

data/spec/streams/stream_protocol_spec.rb

@@ -1,332 +1,332 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 Ball Aerospace & Technologies Corp.
-# All Rights Reserved.
-#
-# This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'spec_helper'
-require 'cosmos/streams/stream_protocol'
-require 'cosmos/interfaces/interface'
-require 'cosmos/streams/stream'
-
-module Cosmos
-
-  describe StreamProtocol do
-    before(:each) do
-      @sp = StreamProtocol.new
-    end
-
-    describe "initialize" do
-      it "should initialize attributes" do
-        @sp.bytes_read.should eql 0
-        @sp.bytes_written.should eql 0
-        @sp.interface.should be_nil
-        @sp.stream.should be_nil
-        @sp.post_read_data_callback.should be_nil
-        @sp.post_read_packet_callback.should be_nil
-        @sp.pre_write_packet_callback.should be_nil
-      end
-    end
-
-    describe "interface=" do
-      it "should set the interface" do
-        class MyInterface1 < Interface; end
-        interface = MyInterface1.new
-        @sp.interface = interface
-        @sp.interface.should eql interface
-      end
-
-      it "should set the post_read_data callback" do
-        class MyInterface2 < Interface
-          def post_read_data(buffer); 1; end
-        end
-        interface = MyInterface2.new
-        @sp.interface = interface
-        @sp.post_read_data_callback.call(nil).should eql 1
-      end
-
-      it "should set the post_read_packet callback" do
-        class MyInterface3 < Interface
-          def post_read_packet(packet); 2; end
-        end
-        interface = MyInterface3.new
-        @sp.interface = interface
-        @sp.post_read_packet_callback.call(nil).should eql 2
-      end
-
-      it "should set the pre_write_packet callback" do
-        class MyInterface4 < Interface
-          def pre_write_packet(packet); 3; end
-        end
-        interface = MyInterface4.new
-        @sp.interface = interface
-        @sp.pre_write_packet_callback.call(nil).should eql 3
-      end
-    end
-
-    describe "connect" do
-      it "should set the stream" do
-        class MyStream1 < Stream; end
-        stream = MyStream1.new
-        @sp.connect(stream)
-        @sp.stream.should eql stream
-      end
-    end
-
-    describe "connected" do
-      it "should return false if the stream hasn't been set" do
-        @sp.connected?.should be_falsey
-      end
-
-      it "should return the status of the stream connection" do
-        class MyStream2 < Stream
-          def connected?; true; end
-        end
-        stream = MyStream2.new
-        @sp.connect(stream)
-        @sp.connected?.should be_truthy
-      end
-    end
-
-    describe "disconnect" do
-      it "should call disconnect on the stream" do
-        $test = false
-        class MyStream3 < Stream
-          def disconnect; $test = true; end
-        end
-        stream = MyStream3.new
-        @sp.connect(stream)
-        $test.should be_falsey
-        @sp.disconnect
-        $test.should be_truthy
-      end
-    end
-
-    describe "read" do
-      it "should read data from the stream" do
-        class MyStream33 < Stream
-          def connected?; true; end
-          def read; "\x01\x02\x03\x04"; end
-        end
-        stream = MyStream33.new
-        @sp.connect(stream)
-        packet = @sp.read
-        packet.length.should eql 4
-      end
-
-      it "should handle timeouts from the stream" do
-        class MyStream4 < Stream
-          def connected?; true; end
-          def read; raise Timeout::Error; end
-        end
-        stream = MyStream4.new
-        @sp.connect(stream)
-        @sp.read.should be_nil
-      end
-
-      it "should handle a sync pattern" do
-        $read_cnt = 0
-        class MyStream5 < Stream
-          def connected?; true; end
-          def read
-            $read_cnt += 1
-            case $read_cnt
-            when 1
-              "\x00\x00\x00\x00\x00\x00"
-            when 2
-              "\x00\x12\x34\x10\x20"
-            when 3
-              ""
-            end
-          end
-        end
-        @sp = StreamProtocol.new(0, '0x1234')
-        stream = MyStream5.new
-        @sp.connect(stream)
-        packet = @sp.read
-        packet.length.should eql 4 # sync plus two bytes
-      end
-
-      it "should handle a sync pattern split across reads" do
-        $read_cnt = 0
-        class MyStream6 < Stream
-          def connected?; true; end
-          def read
-            $read_cnt += 1
-            case $read_cnt
-            when 1
-              "\x00\x00\x00\x00\x00\x00\x00\x12"
-            when 2
-              "\x34\x20"
-            when 3
-              ""
-            end
-          end
-        end
-        @sp = StreamProtocol.new(0, '0x1234')
-        stream = MyStream6.new
-        @sp.connect(stream)
-        packet = @sp.read
-        packet.length.should eql 3 # sync plus one byte
-      end
-
-      it "should handle a false positive sync pattern" do
-        $read_cnt = 0
-        class MyStream7 < Stream
-          def connected?; true; end
-          def read
-            $read_cnt += 1
-            case $read_cnt
-            when 1
-              "\x00\x00\x12\x00\x00\x12"
-            when 2
-              "\x34\x20"
-            when 3
-              ""
-            end
-          end
-        end
-        @sp = StreamProtocol.new(0, '0x1234')
-        stream = MyStream7.new
-        @sp.connect(stream)
-        packet = @sp.read
-        packet.length.should eql 3 # sync plus one byte
-      end
-
-      it "should discard leading bytes from the stream" do
-        class MyStream8 < Stream
-          def connected?; true; end
-          def read
-            "\x01\x02\x03\x04"
-          end
-        end
-        @sp = StreamProtocol.new(2, nil)
-        stream = MyStream8.new
-        @sp.connect(stream)
-        packet = @sp.read
-        packet.length.should eql 2
-        packet.buffer.formatted.should match(/03 04/)
-      end
-
-      it "should call the post_read_data method on the inteface" do
-        class MyStream9 < Stream
-          def connected?; true; end
-          def read
-            "\x01\x02\x03\x04"
-          end
-        end
-        class MyInterface5 < Interface
-          def post_read_data(buffer); "\x00\x01\x02\x03"; end
-        end
-        interface = MyInterface5.new
-        @sp.interface = interface
-        stream = MyStream9.new
-        @sp.connect(stream)
-        packet = @sp.read
-        packet.length.should eql 4
-        packet.buffer.formatted.should match(/00 01 02 03/)
-
-        # Simulate the interface returning an empty string which means to skip
-        # this packet and go back to reading data.
-        $read_cnt = 0
-        class MyInterface5 < Interface
-          def post_read_data(buffer)
-            $read_cnt += 1
-            case $read_cnt
-            when 1
-              ""
-            when 2
-              "\x01\x02"
-            end
-          end
-        end
-        interface = MyInterface5.new
-        @sp.interface = interface
-        packet = @sp.read
-        packet.length.should eql 2
-
-        # Simulate the interface returning nil which means the connection is
-        # lost.
-        $read_cnt = 0
-        class MyInterface5 < Interface
-          def post_read_data(buffer); nil; end
-        end
-        interface = MyInterface5.new
-        @sp.interface = interface
-        packet = @sp.read
-        packet.should be_nil
-      end
-
-      it "should call the post_read_packet method on the inteface" do
-        class MyStream10 < Stream
-          def connected?; true; end
-          def read
-            "\x01\x02\x03\x04"
-          end
-        end
-        class MyInterface6 < Interface
-          def post_read_packet(packet)
-            packet.buffer = "\x00\x01\x02\x03"
-            packet
-          end
-        end
-        interface = MyInterface6.new
-        @sp.interface = interface
-        stream = MyStream10.new
-        @sp.connect(stream)
-        packet = @sp.read
-        packet.length.should eql 4
-        packet.buffer.formatted.should match(/00 01 02 03/)
-      end
-    end
-
-    describe "write" do
-      it "should call pre_write_packet on the interface" do
-        $buffer = ''
-        class MyStream11 < Stream
-          def connected?; true; end
-          def write(buffer) $buffer = buffer; end
-        end
-        class MyInterface7 < Interface
-          def pre_write_packet(packet); "\x01\x02\x03\x04"; end
-        end
-        packet = Packet.new(nil, nil, :BIG_ENDIAN, nil, "\x00\x01\x02\x03")
-        @sp.interface = MyInterface7.new
-        @sp.connect(MyStream11.new)
-        @sp.write(packet)
-        $buffer.should eql "\x01\02\03\04"
-      end
-
-      it "should write the packet buffer to the stream" do
-        $buffer = ''
-        class MyStream11 < Stream
-          def connected?; true; end
-          def write(buffer) $buffer = buffer; end
-        end
-        packet = Packet.new(nil, nil, :BIG_ENDIAN, nil, "\x01\x02\x03\x04")
-        @sp.connect(MyStream11.new)
-        @sp.write(packet)
-        $buffer.should eql "\x01\02\03\04"
-      end
-    end
-
-    describe "write_raw" do
-      it "should write the raw buffer to the stream" do
-        $buffer = ''
-        class MyStream11 < Stream
-          def connected?; true; end
-          def write(buffer) $buffer = buffer; end
-        end
-        @sp.connect(MyStream11.new)
-        @sp.write_raw("\x01\x02\x03\x04")
-        $buffer.should eql "\x01\02\03\04"
-      end
-    end
-
-  end
-end
-
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'spec_helper'
+require 'cosmos/streams/stream_protocol'
+require 'cosmos/interfaces/interface'
+require 'cosmos/streams/stream'
+
+module Cosmos
+
+  describe StreamProtocol do
+    before(:each) do
+      @sp = StreamProtocol.new
+    end
+
+    describe "initialize" do
+      it "should initialize attributes" do
+        @sp.bytes_read.should eql 0
+        @sp.bytes_written.should eql 0
+        @sp.interface.should be_nil
+        @sp.stream.should be_nil
+        @sp.post_read_data_callback.should be_nil
+        @sp.post_read_packet_callback.should be_nil
+        @sp.pre_write_packet_callback.should be_nil
+      end
+    end
+
+    describe "interface=" do
+      it "should set the interface" do
+        class MyInterface1 < Interface; end
+        interface = MyInterface1.new
+        @sp.interface = interface
+        @sp.interface.should eql interface
+      end
+
+      it "should set the post_read_data callback" do
+        class MyInterface2 < Interface
+          def post_read_data(buffer); 1; end
+        end
+        interface = MyInterface2.new
+        @sp.interface = interface
+        @sp.post_read_data_callback.call(nil).should eql 1
+      end
+
+      it "should set the post_read_packet callback" do
+        class MyInterface3 < Interface
+          def post_read_packet(packet); 2; end
+        end
+        interface = MyInterface3.new
+        @sp.interface = interface
+        @sp.post_read_packet_callback.call(nil).should eql 2
+      end
+
+      it "should set the pre_write_packet callback" do
+        class MyInterface4 < Interface
+          def pre_write_packet(packet); 3; end
+        end
+        interface = MyInterface4.new
+        @sp.interface = interface
+        @sp.pre_write_packet_callback.call(nil).should eql 3
+      end
+    end
+
+    describe "connect" do
+      it "should set the stream" do
+        class MyStream1 < Stream; end
+        stream = MyStream1.new
+        @sp.connect(stream)
+        @sp.stream.should eql stream
+      end
+    end
+
+    describe "connected" do
+      it "should return false if the stream hasn't been set" do
+        @sp.connected?.should be_falsey
+      end
+
+      it "should return the status of the stream connection" do
+        class MyStream2 < Stream
+          def connected?; true; end
+        end
+        stream = MyStream2.new
+        @sp.connect(stream)
+        @sp.connected?.should be_truthy
+      end
+    end
+
+    describe "disconnect" do
+      it "should call disconnect on the stream" do
+        $test = false
+        class MyStream3 < Stream
+          def disconnect; $test = true; end
+        end
+        stream = MyStream3.new
+        @sp.connect(stream)
+        $test.should be_falsey
+        @sp.disconnect
+        $test.should be_truthy
+      end
+    end
+
+    describe "read" do
+      it "should read data from the stream" do
+        class MyStream33 < Stream
+          def connected?; true; end
+          def read; "\x01\x02\x03\x04"; end
+        end
+        stream = MyStream33.new
+        @sp.connect(stream)
+        packet = @sp.read
+        packet.length.should eql 4
+      end
+
+      it "should handle timeouts from the stream" do
+        class MyStream4 < Stream
+          def connected?; true; end
+          def read; raise Timeout::Error; end
+        end
+        stream = MyStream4.new
+        @sp.connect(stream)
+        @sp.read.should be_nil
+      end
+
+      it "should handle a sync pattern" do
+        $read_cnt = 0
+        class MyStream5 < Stream
+          def connected?; true; end
+          def read
+            $read_cnt += 1
+            case $read_cnt
+            when 1
+              "\x00\x00\x00\x00\x00\x00"
+            when 2
+              "\x00\x12\x34\x10\x20"
+            when 3
+              ""
+            end
+          end
+        end
+        @sp = StreamProtocol.new(0, '0x1234')
+        stream = MyStream5.new
+        @sp.connect(stream)
+        packet = @sp.read
+        packet.length.should eql 4 # sync plus two bytes
+      end
+
+      it "should handle a sync pattern split across reads" do
+        $read_cnt = 0
+        class MyStream6 < Stream
+          def connected?; true; end
+          def read
+            $read_cnt += 1
+            case $read_cnt
+            when 1
+              "\x00\x00\x00\x00\x00\x00\x00\x12"
+            when 2
+              "\x34\x20"
+            when 3
+              ""
+            end
+          end
+        end
+        @sp = StreamProtocol.new(0, '0x1234')
+        stream = MyStream6.new
+        @sp.connect(stream)
+        packet = @sp.read
+        packet.length.should eql 3 # sync plus one byte
+      end
+
+      it "should handle a false positive sync pattern" do
+        $read_cnt = 0
+        class MyStream7 < Stream
+          def connected?; true; end
+          def read
+            $read_cnt += 1
+            case $read_cnt
+            when 1
+              "\x00\x00\x12\x00\x00\x12"
+            when 2
+              "\x34\x20"
+            when 3
+              ""
+            end
+          end
+        end
+        @sp = StreamProtocol.new(0, '0x1234')
+        stream = MyStream7.new
+        @sp.connect(stream)
+        packet = @sp.read
+        packet.length.should eql 3 # sync plus one byte
+      end
+
+      it "should discard leading bytes from the stream" do
+        class MyStream8 < Stream
+          def connected?; true; end
+          def read
+            "\x01\x02\x03\x04"
+          end
+        end
+        @sp = StreamProtocol.new(2, nil)
+        stream = MyStream8.new
+        @sp.connect(stream)
+        packet = @sp.read
+        packet.length.should eql 2
+        packet.buffer.formatted.should match(/03 04/)
+      end
+
+      it "should call the post_read_data method on the inteface" do
+        class MyStream9 < Stream
+          def connected?; true; end
+          def read
+            "\x01\x02\x03\x04"
+          end
+        end
+        class MyInterface5 < Interface
+          def post_read_data(buffer); "\x00\x01\x02\x03"; end
+        end
+        interface = MyInterface5.new
+        @sp.interface = interface
+        stream = MyStream9.new
+        @sp.connect(stream)
+        packet = @sp.read
+        packet.length.should eql 4
+        packet.buffer.formatted.should match(/00 01 02 03/)
+
+        # Simulate the interface returning an empty string which means to skip
+        # this packet and go back to reading data.
+        $read_cnt = 0
+        class MyInterface5 < Interface
+          def post_read_data(buffer)
+            $read_cnt += 1
+            case $read_cnt
+            when 1
+              ""
+            when 2
+              "\x01\x02"
+            end
+          end
+        end
+        interface = MyInterface5.new
+        @sp.interface = interface
+        packet = @sp.read
+        packet.length.should eql 2
+
+        # Simulate the interface returning nil which means the connection is
+        # lost.
+        $read_cnt = 0
+        class MyInterface5 < Interface
+          def post_read_data(buffer); nil; end
+        end
+        interface = MyInterface5.new
+        @sp.interface = interface
+        packet = @sp.read
+        packet.should be_nil
+      end
+
+      it "should call the post_read_packet method on the inteface" do
+        class MyStream10 < Stream
+          def connected?; true; end
+          def read
+            "\x01\x02\x03\x04"
+          end
+        end
+        class MyInterface6 < Interface
+          def post_read_packet(packet)
+            packet.buffer = "\x00\x01\x02\x03"
+            packet
+          end
+        end
+        interface = MyInterface6.new
+        @sp.interface = interface
+        stream = MyStream10.new
+        @sp.connect(stream)
+        packet = @sp.read
+        packet.length.should eql 4
+        packet.buffer.formatted.should match(/00 01 02 03/)
+      end
+    end
+
+    describe "write" do
+      it "should call pre_write_packet on the interface" do
+        $buffer = ''
+        class MyStream11 < Stream
+          def connected?; true; end
+          def write(buffer) $buffer = buffer; end
+        end
+        class MyInterface7 < Interface
+          def pre_write_packet(packet); "\x01\x02\x03\x04"; end
+        end
+        packet = Packet.new(nil, nil, :BIG_ENDIAN, nil, "\x00\x01\x02\x03")
+        @sp.interface = MyInterface7.new
+        @sp.connect(MyStream11.new)
+        @sp.write(packet)
+        $buffer.should eql "\x01\02\03\04"
+      end
+
+      it "should write the packet buffer to the stream" do
+        $buffer = ''
+        class MyStream11 < Stream
+          def connected?; true; end
+          def write(buffer) $buffer = buffer; end
+        end
+        packet = Packet.new(nil, nil, :BIG_ENDIAN, nil, "\x01\x02\x03\x04")
+        @sp.connect(MyStream11.new)
+        @sp.write(packet)
+        $buffer.should eql "\x01\02\03\04"
+      end
+    end
+
+    describe "write_raw" do
+      it "should write the raw buffer to the stream" do
+        $buffer = ''
+        class MyStream11 < Stream
+          def connected?; true; end
+          def write(buffer) $buffer = buffer; end
+        end
+        @sp.connect(MyStream11.new)
+        @sp.write_raw("\x01\x02\x03\x04")
+        $buffer.should eql "\x01\02\03\04"
+      end
+    end
+
+  end
+end
+