cosmos 4.2.4 → 4.5.0

data/spec/packets/commands_spec.rb

@@ -140,6 +140,28 @@ module Cosmos
         expect(pkt.item4).to eql 4
       end
 
+      it "works in unique id mode or not" do
+        System.targets["TGT1"] = Target.new("TGT1")
+        target = System.targets["TGT1"]
+        target.cmd_unique_id_mode = false
+        buffer = "\x01\x02\x03\x04"
+        pkt = @cmd.identify(buffer,["TGT1"])
+        pkt.enable_method_missing
+        expect(pkt.item1).to eql 1
+        expect(pkt.item2).to eql 2
+        expect(pkt.item3).to eql 3
+        expect(pkt.item4).to eql 4
+        target.cmd_unique_id_mode = true
+        buffer = "\x01\x02\x01\x02"
+        pkt = @cmd.identify(buffer,["TGT1"])
+        pkt.enable_method_missing
+        expect(pkt.item1).to eql 1
+        expect(pkt.item2).to eql 2
+        expect(pkt.item3).to eql 1
+        expect(pkt.item4).to eql 2        
+        target.cmd_unique_id_mode = false
+      end
+
       it "returns nil with unknown targets given" do
         buffer = "\x01\x02\x03\x04"
         expect(@cmd.identify(buffer,["TGTX"])).to be_nil

data/spec/packets/packet_config_spec.rb

@@ -114,6 +114,30 @@ module Cosmos
             tf.unlink
           end
         end
+        
+        it "builds the id value hash" do
+          @tlm_keywords.each do |keyword|
+            next if %w(PROCESSOR META).include? keyword
+            tf = Tempfile.new('unittest')
+            tf.puts 'TELEMETRY tgt1 pkt1 BIG_ENDIAN "Packet"'
+            tf.puts 'ID_ITEM myitem 0 8 UINT 13 "Test Item id=1"'
+            tf.puts 'APPEND_ID_ITEM myitem 8 UINT 114 "Test Item id=1"'
+            tf.puts 'COMMAND tgt1 pkt1 BIG_ENDIAN "Packet"'
+            tf.puts 'ID_PARAMETER myitem 0 8 UINT 12 12 12 "Test Item id=1"'
+            tf.puts 'APPEND_ID_PARAMETER myitem 8 UINT 115 115 115 "Test Item id=1"'
+            tf.close
+            @pc.process_file(tf.path, "TGT1")
+            expected_tlm_hash = {}
+            expected_tlm_hash["TGT1"] = {}
+            expected_tlm_hash["TGT1"][[13, 114]] = @pc.telemetry["TGT1"]["PKT1"]
+            expected_cmd_hash = {}
+            expected_cmd_hash["TGT1"] = {}
+            expected_cmd_hash["TGT1"][[12, 115]] = @pc.commands["TGT1"]["PKT1"]            
+            expect(@pc.tlm_id_value_hash).to eql expected_tlm_hash
+            expect(@pc.cmd_id_value_hash).to eql expected_cmd_hash
+            tf.unlink
+          end          
+        end
 
         it "complains if there are too many parameters" do
           @top_keywords.each do |keyword|
@@ -324,11 +348,11 @@ module Cosmos
           tf.close
           @pc.process_file(tf.path, "TGT1")
           pkt = @pc.telemetry["TGT1"]["PKT1"]
-          expect(pkt.items.length).to eql 6 # 3 plus the RECEIVED_XXX items
+          expect(pkt.items.length).to eql 8 # 3 plus the RECEIVED_XXX and PACKET_TIMExxx items
           expect(pkt.items.keys).to include('BYTE1','BYTE2','BYTE3')
-          expect(pkt.sorted_items[3].name).to eql 'BYTE1'
-          expect(pkt.sorted_items[4].name).to eql 'BYTE2'
-          expect(pkt.sorted_items[5].name).to eql 'BYTE3'
+          expect(pkt.sorted_items[5].name).to eql 'BYTE1'
+          expect(pkt.sorted_items[6].name).to eql 'BYTE2'
+          expect(pkt.sorted_items[7].name).to eql 'BYTE3'
           tf.unlink
         end
       end
@@ -691,17 +715,6 @@ module Cosmos
           expect(@pc.telemetry["TGT1"]["PKT1"].read("ITEM1",:WITH_UNITS)).to eql "0 V"
           tf.unlink
         end
-
-        it "complains if STATE defined" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  ITEM item1 0 8 UINT'
-          tf.puts '    STATE ONE 1'
-          tf.puts '    UNITS Volts V'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /Items with STATE can't define UNITS/)
-          tf.unlink
-        end
       end
 
       context "with META" do
@@ -842,7 +855,7 @@ module Cosmos
           expect(@pc.telemetry["TGT1"]["PKT1"].items["ITEM1"].data_type).to be :DERIVED
           tf.unlink
         end
-      end      
+      end
 
     end # describe "process_file"
   end

data/spec/packets/packet_item_spec.rb

@@ -400,7 +400,7 @@ module Cosmos
         @pi.read_conversion = GenericConversion.new("value / 2")
         @pi.write_conversion = GenericConversion.new("value * 2")
         @pi.description = "description"
-        @pi.units_full = "Celcius"
+        @pi.units_full = "Celsius"
         @pi.units = "C"
         @pi.default = 0
         @pi.range = (0..100)
@@ -428,7 +428,7 @@ module Cosmos
         expect(hash["id_value"]).to eql 10
         expect(hash["states"]).to include("TRUE"=>1,"FALSE"=>0)
         expect(hash["description"]).to eql "description"
-        expect(hash["units_full"]).to eql "Celcius"
+        expect(hash["units_full"]).to eql "Celsius"
         expect(hash["units"]).to eql "C"
         expect(hash["default"]).to eql 0
         expect(hash["range"]).to eql (0..100)

data/spec/packets/packet_spec.rb

@@ -707,7 +707,7 @@ module Cosmos
     end
 
     describe "formatted" do
-      it "prints out all the items and CONVERTED values" do
+      it "prints out all the items" do
         p = Packet.new("tgt","pkt")
         p.append_item("test1", 8, :UINT, 16)
         p.write("test1", [1,2])
@@ -727,6 +727,25 @@ module Cosmos
         expect(p.formatted).to include("TEST2: TRUE")
         expect(p.formatted).to include("TEST3: #{0x02030405}")
         expect(p.formatted).to include("TEST4: Test")
+        # Test the data_type parameter
+        expect(p.formatted(:RAW)).to include("TEST1: [1, 2]")
+        expect(p.formatted(:RAW)).to include("TEST2: #{0x0304}")
+        expect(p.formatted(:RAW)).to include("TEST3: #{0x0406080A}")
+        expect(p.formatted(:RAW)).to include("00000000: 54 65 73 74") # Raw TEST4 block
+        # Test the indent parameter
+        expect(p.formatted(:CONVERTED, 4)).to include("    TEST1: [1, 2]")
+        # Test the buffer parameter
+        buffer = "\x02\x03\x04\x05\x00\x00\x00\x02\x44\x45\x41\x44"
+        expect(p.formatted(:CONVERTED, 0, buffer)).to include("TEST1: [2, 3]")
+        expect(p.formatted(:CONVERTED, 0, buffer)).to include("TEST2: #{0x0405}")
+        expect(p.formatted(:CONVERTED, 0, buffer)).to include("TEST3: 1")
+        expect(p.formatted(:CONVERTED, 0, buffer)).to include("TEST4: DEAD")
+        # Test the ignored parameter
+        string = p.formatted(:CONVERTED, 0, p.buffer, %w(TEST1 TEST4))
+        expect(string).not_to include("TEST1")
+        expect(string).to include("TEST2: TRUE")
+        expect(string).to include("TEST3: #{0x02030405}")
+        expect(string).not_to include("TEST4")
       end
     end
 
@@ -828,12 +847,26 @@ module Cosmos
       it "returns an array of the identifying items" do
         p = Packet.new("tgt","pkt")
         p.define_item("item1",0,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,nil)
-        p.define_item("item2",0,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,5)
-        p.define_item("item3",0,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,nil)
-        p.define_item("item4",0,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,6)
+        p.define_item("item2",64,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,5)
+        p.define_item("item3",96,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,nil)
+        p.define_item("item4",32,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,6)        
         expect(p.id_items).to be_a Array
-        expect(p.id_items[0].name).to eq "ITEM2"
-        expect(p.id_items[1].name).to eq "ITEM4"
+        expect(p.id_items[0].name).to eq "ITEM4"
+        expect(p.id_items[1].name).to eq "ITEM2"
+      end
+    end
+
+    describe "read_id_values" do
+      it "to read the right values" do
+        buffer = "\x00\x00\x00\x04\x00\x00\x00\x03\x00\x00\x00\x02\x00\x00\x00\x01"
+        p = Packet.new("tgt","pkt")
+        p.define_item("item1",0,32,:UINT,nil,:BIG_ENDIAN,:ERROR,nil,nil,nil,nil)
+        p.define_item("item2",64,32,:UINT,nil,:BIG_ENDIAN,:ERROR,nil,nil,nil,5)
+        p.define_item("item3",96,32,:UINT,nil,:BIG_ENDIAN,:ERROR,nil,nil,nil,nil)
+        p.define_item("item4",32,32,:UINT,nil,:BIG_ENDIAN,:ERROR,nil,nil,nil,6)
+        values = p.read_id_values(buffer)
+        expect(values[0]).to eq 3
+        expect(values[1]).to eq 2
       end
     end
 

data/spec/packets/parsers/format_string_parser_spec.rb

@@ -53,17 +53,6 @@ module Cosmos
         tf.unlink
       end
 
-      it "complains if STATE is defined" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-        tf.puts 'ITEM myitem 0 8 UINT "Test Item"'
-        tf.puts 'STATE ONE 1'
-        tf.puts "FORMAT_STRING '0x%x'"
-        tf.close
-        expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /Items with STATE can't define FORMAT_STRING/)
-        tf.unlink
-      end
-
       it "complains about invalid format strings" do
         tf = Tempfile.new('unittest')
         tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'

data/spec/packets/parsers/macro_parser_spec.rb

@@ -69,12 +69,12 @@ module Cosmos
         tf.close
         @pc.process_file(tf.path, "TGT1")
         pkt = @pc.telemetry["TGT1"]["PKT1"]
-        expect(pkt.items.length).to eql 7 # 4 plus the RECEIVED_XXX items
+        expect(pkt.items.length).to eql 9 # 4 plus the RECEIVED_XXX and PACKET_TIMExxx items
         expect(pkt.items.keys).to include('BIT1','BIT2','BIT3','BIT4')
-        expect(pkt.sorted_items[3].name).to eql 'BIT4'
-        expect(pkt.sorted_items[4].name).to eql 'BIT3'
-        expect(pkt.sorted_items[5].name).to eql 'BIT2'
-        expect(pkt.sorted_items[6].name).to eql 'BIT1'
+        expect(pkt.sorted_items[5].name).to eql 'BIT4'
+        expect(pkt.sorted_items[6].name).to eql 'BIT3'
+        expect(pkt.sorted_items[7].name).to eql 'BIT2'
+        expect(pkt.sorted_items[8].name).to eql 'BIT1'
         limits_items = []
         pkt.items.each do |name, item|
           limits_items << item if name.include?('BIT')
@@ -117,24 +117,24 @@ module Cosmos
         tf.close
         @pc.process_file(tf.path, "TGT1")
         pkt = @pc.telemetry["TGT1"]["PKT1"]
-        expect(pkt.items.length).to eql 11 # 8 plus the RECEIVED_XXX items
+        expect(pkt.items.length).to eql 13 # 8 plus the RECEIVED_XXX and PACKET_TIMExxx items
         expect(pkt.items.keys).to include('WORD1','WORD2','WORD3','WORD4','DWORD1','DWORD2','DWORD3','DWORD4')
-        expect(pkt.sorted_items[3].name).to eql 'WORD1'
-        expect(pkt.sorted_items[3].bit_offset).to eql 0
-        expect(pkt.sorted_items[4].name).to eql 'DWORD1'
-        expect(pkt.sorted_items[4].bit_offset).to eql 16
-        expect(pkt.sorted_items[5].name).to eql 'WORD2'
-        expect(pkt.sorted_items[5].bit_offset).to eql 48
-        expect(pkt.sorted_items[6].name).to eql 'DWORD2'
-        expect(pkt.sorted_items[6].bit_offset).to eql 64
-        expect(pkt.sorted_items[7].name).to eql 'WORD3'
-        expect(pkt.sorted_items[7].bit_offset).to eql 96
-        expect(pkt.sorted_items[8].name).to eql 'DWORD3'
-        expect(pkt.sorted_items[8].bit_offset).to eql 112
-        expect(pkt.sorted_items[9].name).to eql 'WORD4'
-        expect(pkt.sorted_items[9].bit_offset).to eql 144
-        expect(pkt.sorted_items[10].name).to eql 'DWORD4'
-        expect(pkt.sorted_items[10].bit_offset).to eql 160
+        expect(pkt.sorted_items[5].name).to eql 'WORD1'
+        expect(pkt.sorted_items[5].bit_offset).to eql 0
+        expect(pkt.sorted_items[6].name).to eql 'DWORD1'
+        expect(pkt.sorted_items[6].bit_offset).to eql 16
+        expect(pkt.sorted_items[7].name).to eql 'WORD2'
+        expect(pkt.sorted_items[7].bit_offset).to eql 48
+        expect(pkt.sorted_items[8].name).to eql 'DWORD2'
+        expect(pkt.sorted_items[8].bit_offset).to eql 64
+        expect(pkt.sorted_items[9].name).to eql 'WORD3'
+        expect(pkt.sorted_items[9].bit_offset).to eql 96
+        expect(pkt.sorted_items[10].name).to eql 'DWORD3'
+        expect(pkt.sorted_items[10].bit_offset).to eql 112
+        expect(pkt.sorted_items[11].name).to eql 'WORD4'
+        expect(pkt.sorted_items[11].bit_offset).to eql 144
+        expect(pkt.sorted_items[12].name).to eql 'DWORD4'
+        expect(pkt.sorted_items[12].bit_offset).to eql 160
         tf.unlink
       end
 
@@ -149,18 +149,18 @@ module Cosmos
         tf.close
         @pc.process_file(tf.path, "TGT1")
         pkt = @pc.telemetry["TGT1"]["PKT1"]
-        expect(pkt.items.length).to eql 8 # 5 plus the RECEIVED_XXX items
+        expect(pkt.items.length).to eql 10 # 5 plus the RECEIVED_XXX and PACKET_TIMExxx items
         expect(pkt.items.keys).to include('BIT1','BIT2','BIT3','BIT4','BIT5')
-        expect(pkt.sorted_items[3].name).to eql 'BIT1'
-        expect(pkt.sorted_items[3].bit_offset).to eql 0
-        expect(pkt.sorted_items[4].name).to eql 'BIT2'
-        expect(pkt.sorted_items[4].bit_offset).to eql 16
-        expect(pkt.sorted_items[5].name).to eql 'BIT3'
-        expect(pkt.sorted_items[5].bit_offset).to eql 32
-        expect(pkt.sorted_items[6].name).to eql 'BIT4'
-        expect(pkt.sorted_items[6].bit_offset).to eql 48
-        expect(pkt.sorted_items[7].name).to eql 'BIT5'
-        expect(pkt.sorted_items[7].bit_offset).to eql 64
+        expect(pkt.sorted_items[5].name).to eql 'BIT1'
+        expect(pkt.sorted_items[5].bit_offset).to eql 0
+        expect(pkt.sorted_items[6].name).to eql 'BIT2'
+        expect(pkt.sorted_items[6].bit_offset).to eql 16
+        expect(pkt.sorted_items[7].name).to eql 'BIT3'
+        expect(pkt.sorted_items[7].bit_offset).to eql 32
+        expect(pkt.sorted_items[8].name).to eql 'BIT4'
+        expect(pkt.sorted_items[8].bit_offset).to eql 48
+        expect(pkt.sorted_items[9].name).to eql 'BIT5'
+        expect(pkt.sorted_items[9].bit_offset).to eql 64
         limits_items = []
         pkt.items.each do |name, item|
           limits_items << item if name.include?('BIT')
@@ -179,7 +179,7 @@ module Cosmos
         tf.close
         @pc.process_file(tf.path, "TGT1")
         pkt = @pc.telemetry["TGT1"]["PKT1"]
-        expect(pkt.items.length).to eql 8 # 5 plus the RECEIVED_XXX items
+        expect(pkt.items.length).to eql 10 # 5 plus the RECEIVED_XXX and PACKET_TIMExxx items
         expect(pkt.items.keys).to include('BIT1','BIT2','BIT3','BIT4','BIT5')
         expect(pkt.limits_items.collect{|item| item.name}).to include('BIT1','BIT2','BIT3','BIT4','BIT5')
         tf.unlink
@@ -194,7 +194,7 @@ module Cosmos
         tf.close
         @pc.process_file(tf.path, "TGT1")
         pkt = @pc.telemetry["TGT1"]["PKT1"]
-        expect(pkt.items.length).to eql 8 # 5 plus the RECEIVED_XXX items
+        expect(pkt.items.length).to eql 10 # 5 plus the RECEIVED_XXX and PACKET_TIMExxx items
         expect(pkt.items.keys).to include('BIT1','BIT2','BIT3','BIT4','BIT5')
         expect(pkt.limits_items).to be_empty
         tf.unlink
@@ -209,7 +209,7 @@ module Cosmos
         tf.close
         @pc.process_file(tf.path, "TGT1")
         pkt = @pc.telemetry["TGT1"]["PKT1"]
-        expect(pkt.items.length).to eql 8 # 5 plus the RECEIVED_XXX items
+        expect(pkt.items.length).to eql 10 # 5 plus the RECEIVED_XXX and PACKET_TIMExxx items
         expect(pkt.items.keys).to include('08_BIT','09_BIT','10_BIT','11_BIT','12_BIT')
         expect(pkt.limits_items).to be_empty
         tf.unlink

data/spec/packets/parsers/state_parser_spec.rb

@@ -54,17 +54,6 @@ module Cosmos
         tf.unlink
       end
 
-      it "complains if FORMAT_STRING defined" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-        tf.puts '  ITEM myitem 0 8 UINT "Test Item"'
-        tf.puts '    FORMAT_STRING "0x%x"'
-        tf.puts '    STATE ONE 1'
-        tf.close
-        expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /Items with FORMAT_STRING can't define STATE/)
-        tf.unlink
-      end
-
       it "complains if UNITS defined" do
         tf = Tempfile.new('unittest')
         tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
@@ -119,6 +108,75 @@ module Cosmos
       end
 
       context "with telemetry" do
+        it "defines states on ARRAY items" do
+          tf = Tempfile.new('unittest')
+          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
+          tf.puts '  APPEND_ARRAY_ITEM item1 8 UINT 40 "state item"'
+          tf.puts '    STATE FALSE 0'
+          tf.puts '    STATE TRUE 1'
+          tf.puts '    STATE ERROR ANY'
+          tf.close
+          @pc.process_file(tf.path, "TGT1")
+          tlm = Telemetry.new(@pc)
+          pkt = tlm.packet("TGT1", "PKT1")
+          pkt.write("ITEM1", [0,1,2,1,0])
+          expect(pkt.read("ITEM1")).to eql ["FALSE","TRUE","ERROR","TRUE","FALSE"]
+          tf.unlink
+        end
+
+        it "uses state or FORMAT_STRING if no state" do
+          tf = Tempfile.new('unittest')
+          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
+          tf.puts '  APPEND_ITEM item1 8 UINT "Test Item"'
+          tf.puts '    FORMAT_STRING "0x%x"'
+          tf.puts '    STATE ONE 1'
+          tf.close
+          @pc.process_file(tf.path, "TGT1")
+          tlm = Telemetry.new(@pc)
+          pkt = tlm.packet("TGT1", "PKT1")
+          pkt.write("ITEM1", 1)
+          expect(pkt.read("ITEM1", :FORMATTED)).to eql "ONE"
+          pkt.write("ITEM1", 2)
+          expect(pkt.read("ITEM1", :FORMATTED)).to eql "0x2"
+          tf.unlink
+
+          # Ensure the order of STATE vs FORMAT_STRING doesn't matter
+          tf = Tempfile.new('unittest')
+          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
+          tf.puts '  APPEND_ITEM item1 8 UINT "Test Item"'
+          tf.puts '    STATE ONE 1'
+          tf.puts '    FORMAT_STRING "0x%x"'
+          tf.close
+          @pc.process_file(tf.path, "TGT1")
+          tlm = Telemetry.new(@pc)
+          pkt = tlm.packet("TGT1", "PKT1")
+          pkt.write("ITEM1", 1)
+          expect(pkt.read("ITEM1", :FORMATTED)).to eql "ONE"
+          pkt.write("ITEM1", 2)
+          expect(pkt.read("ITEM1", :FORMATTED)).to eql "0x2"
+          tf.unlink
+        end
+
+        it "allows an 'ANY' state" do
+          tf = Tempfile.new('unittest')
+          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
+          tf.puts '  APPEND_ITEM item1 8 UINT "state item"'
+          tf.puts '    STATE FALSE 0'
+          tf.puts '    STATE TRUE 1'
+          tf.puts '    STATE ERROR ANY'
+          tf.close
+          @pc.process_file(tf.path, "TGT1")
+          tlm = Telemetry.new(@pc)
+          pkt = tlm.packet("TGT1", "PKT1")
+          pkt.write("ITEM1", 0)
+          expect(pkt.read("ITEM1")).to eql "FALSE"
+          pkt.write("ITEM1", 1)
+          expect(pkt.read("ITEM1")).to eql "TRUE"
+          pkt.write("ITEM1", 2)
+          expect(pkt.read("ITEM1")).to eql "ERROR"
+          tf.unlink
+        end
+
         it "only allows GREEN YELLOW or RED" do
           tf = Tempfile.new('unittest')
           tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'

data/spec/packets/structure_spec.rb

@@ -185,6 +185,8 @@ module Cosmos
         expect(@s.defined_length).to eql 1
         si = StructureItem.new("test1",0,16,:INT,:BIG_ENDIAN)
         @s.define(si)
+        expect(@s.items.length).to eql 1
+        expect(@s.sorted_items.length).to eql 1
         expect(@s.sorted_items[0].name).to eql "TEST1"
         expect(@s.items["TEST1"].bit_size).to eql 16
         expect(@s.items["TEST1"].data_type).to eql :INT
@@ -290,6 +292,56 @@ module Cosmos
       end
     end
 
+    describe "delete_item" do
+      before(:each) do
+        @s = Structure.new(:BIG_ENDIAN)
+        @s.define_item("test1", 0, 8, :UINT)
+      end
+
+      it "removes the item and leaves a hole" do
+        @s.append_item("test2", 16, :UINT)
+        expect(@s.defined_length).to eql 3
+        @s.delete_item("test1")
+        expect { @s.get_item("test1") }.to raise_error(ArgumentError, "Unknown item: test1")
+        expect(@s.defined_length).to eql 3
+        expect(@s.items["TEST1"]).to be_nil
+        expect(@s.items["TEST2"]).not_to be_nil
+        expect(@s.sorted_items.length).to eql 1
+        expect(@s.sorted_items[0]).to eql(@s.get_item("test2"))
+        buffer = "\x01\x02\x03"
+        expect(@s.read("test2", :RAW, buffer)).to eql 0x0203
+      end
+
+      it "allows new items to be defined in place" do
+        @s.append_item("test2", 16, :UINT)
+        @s.append_item("test3", 8, :UINT)
+        expect(@s.defined_length).to eql 4
+        # Delete the first 2 items, note a 3 byte hole now exists
+        @s.delete_item("test1")
+        @s.delete_item("test2")
+        expect(@s.defined_length).to eql 4
+        expect(@s.items.length).to eql 1
+        expect(@s.sorted_items.length).to eql 1
+        # Fill the hole and overlap the last byte
+        @s.define_item("test4", 0, 16, :UINT)
+        @s.define_item("test5", 16, 16, :UINT)
+        @s.define_item("test6", 32, 32, :UINT)
+        buffer = "\x01\x02\x03\x04\x05\x06\x07\x08"
+        expect(@s.read("test4", :RAW, buffer)).to eql 0x0102
+        expect(@s.read("test5", :RAW, buffer)).to eql 0x0304
+        expect(@s.read("test6", :RAW, buffer)).to eql 0x05060708
+        # test3 is still defined
+        expect(@s.read("test3", :RAW, buffer)).to eql 0x04
+        expect(@s.items.length).to eql 4
+        expect(@s.sorted_items.length).to eql 4
+        # Check that everything is sorted correctly
+        expect(@s.sorted_items[0].name).to eql "TEST4"
+        expect(@s.sorted_items[1].name).to eql "TEST5"
+        expect(@s.sorted_items[2].name).to eql "TEST3"
+        expect(@s.sorted_items[3].name).to eql "TEST6"
+      end
+    end
+
     describe "read_item" do
       it "complains if no buffer given" do
         s = Structure.new
@@ -348,6 +400,20 @@ module Cosmos
         expect(s.read("test1", :RAW, buffer)).to eql 1
       end
 
+      it "reads until null byte for STRING items" do
+        s = Structure.new
+        s.define_item("test1", 0, 80, :STRING)
+        buffer = "\x4E\x4F\x4F\x50\x00\x4E\x4F\x4F\x50\x0A" # NOOP<NULL>NOOP\n
+        expect(s.read("test1", :CONVERTED, buffer)).to eql "NOOP"
+      end
+
+      it "reads the entire buffer for BLOCK items" do
+        s = Structure.new
+        s.define_item("test1", 0, 80, :BLOCK)
+        buffer = "\x4E\x4F\x4F\x50\x00\x4E\x4F\x4F\x50\x0A" # NOOP<NULL>NOOP\n
+        expect(s.read("test1", :CONVERTED, buffer)).to eql "NOOP\x00NOOP\n"
+      end
+
       it "reads array data from the buffer" do
         s = Structure.new
         s.define_item("test1", 0, 8, :UINT, 16)
@@ -442,6 +508,33 @@ module Cosmos
         expect(s.formatted(:CONVERTED, 4)).to include("    TEST3")
         expect(s.formatted(:CONVERTED, 4)).to include("    00000000: 07 08 09 0A")
       end
+
+      it "processes uses a different buffer" do
+        s = Structure.new(:BIG_ENDIAN)
+        s.append_item("test1", 8, :UINT, 16)
+        s.write("test1", [1,2])
+        s.append_item("test2", 16, :UINT)
+        s.write("test2", 3456)
+        s.append_item("test3", 32, :BLOCK)
+        s.write("test3", "\x07\x08\x09\x0A")
+        buffer = "\x0A\x0B\x0C\x0D\xDE\xAD\xBE\xEF"
+        expect(s.formatted(:CONVERTED, 0, buffer)).to include("TEST1: [10, 11]")
+        expect(s.formatted(:CONVERTED, 0, buffer)).to include("TEST2: #{0x0C0D}")
+        expect(s.formatted(:CONVERTED, 0, buffer)).to include("TEST3")
+        expect(s.formatted(:CONVERTED, 0, buffer)).to include("00000000: DE AD BE EF")
+      end
+
+      it "ignores items" do
+        s = Structure.new(:BIG_ENDIAN)
+        s.append_item("test1", 8, :UINT, 16)
+        s.write("test1", [1,2])
+        s.append_item("test2", 16, :UINT)
+        s.write("test2", 3456)
+        s.append_item("test3", 32, :BLOCK)
+        s.write("test3", "\x07\x08\x09\x0A")
+        expect(s.formatted(:CONVERTED, 0, s.buffer, %w(TEST1 TEST3))).to eq("TEST2: 3456\n")
+        expect(s.formatted(:CONVERTED, 0, s.buffer, %w(TEST1 TEST2 TEST3))).to eq("")
+      end
     end
 
     describe "buffer" do
@@ -560,7 +653,5 @@ module Cosmos
         expect { s.test1 }.to raise_error(ArgumentError, "Unknown item: test1")
       end
     end
-
   end # describe Structure
-
 end