cosmos 3.1.2 → 3.2.0

data/spec/packets/parsers/state_parser_spec.rb

@@ -0,0 +1,156 @@
+# 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'
+require 'cosmos/packets/packet_config'
+require 'cosmos/packets/parsers/state_parser'
+require 'tempfile'
+
+module Cosmos
+
+  describe StateParser do
+
+    describe "process_file" do
+      before(:each) do
+        @pc = PacketConfig.new
+      end
+
+      it "should complain if a current item is not defined" do
+        # Check for missing ITEM definitions
+        tf = Tempfile.new('unittest')
+        tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
+        tf.puts 'STATE'
+        tf.close
+        expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "No current item for STATE")
+        tf.unlink
+      end
+
+      it "should complain if there are not enough parameters" 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'
+        tf.close
+        expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /Not enough parameters for STATE/)
+        tf.unlink
+      end
+
+      it "should complain if there are too many parameters" 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 mystate 0 RED extra'
+        tf.close
+        expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /Too many parameters for STATE/)
+        tf.unlink
+      end
+
+      it "should support STRING items" do
+        tf = Tempfile.new('unittest')
+        tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
+        tf.puts '  APPEND_ITEM item1 128 STRING "state item"'
+        tf.puts '    STATE FALSE "FALSE STRING"'
+        tf.puts '    STATE TRUE "TRUE STRING"'
+        tf.close
+        @pc.process_file(tf.path, "TGT1")
+        @pc.telemetry["TGT1"]["PKT1"].write("ITEM1", "TRUE STRING")
+        @pc.telemetry["TGT1"]["PKT1"].read("ITEM1").should eql "TRUE"
+        @pc.telemetry["TGT1"]["PKT1"].write("ITEM1", "FALSE STRING")
+        @pc.telemetry["TGT1"]["PKT1"].read("ITEM1").should eql "FALSE"
+        tf.unlink
+      end
+
+      it "should warn about duplicate states and replace the duplicate" do
+        tf = Tempfile.new('unittest')
+        tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
+        tf.puts '  APPEND_PARAMETER item1 8 UINT 0 2 0 "state item"'
+        tf.puts '    STATE FALSE 0'
+        tf.puts '    STATE TRUE 1'
+        tf.puts '    STATE FALSE 2'
+        tf.close
+        @pc.process_file(tf.path, "TGT1")
+        @pc.warnings.should include("Duplicate state defined on line 5: STATE FALSE 2")
+        @pc.commands["TGT1"]["PKT1"].buffer = "\x00"
+        @pc.commands["TGT1"]["PKT1"].read("ITEM1").should eql 0
+        @pc.commands["TGT1"]["PKT1"].buffer = "\x02"
+        @pc.commands["TGT1"]["PKT1"].read("ITEM1").should eql "FALSE"
+        tf.unlink
+      end
+
+      context "with telemetry" do
+        it "should only allow GREEN YELLOW or RED" 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 WORST 1 ORANGE'
+          tf.close
+          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /Invalid state color ORANGE/)
+          tf.unlink
+        end
+
+        it "should record the state values and colors" 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 STATE1 1 RED'
+          tf.puts '    STATE STATE2 2 YELLOW'
+          tf.puts '    STATE STATE3 3 GREEN'
+          tf.puts '    STATE STATE4 4'
+          tf.close
+          @pc.process_file(tf.path, "TGT1")
+          index = 1
+          colors = [:RED, :YELLOW, :GREEN]
+          @pc.telemetry["TGT1"]["PKT1"].items["ITEM1"].states.each do |name,val|
+            name.should eql "STATE#{index}"
+            val.should eql index
+            @pc.telemetry["TGT1"]["PKT1"].items["ITEM1"].state_colors[name].should eql colors[index - 1]
+
+            index += 1
+          end
+          @pc.telemetry["TGT1"]["PKT1"].limits_items.should eql [@pc.telemetry["TGT1"]["PKT1"].items["ITEM1"]]
+          tf.unlink
+        end
+      end
+
+      context "with command" do
+        it "should only allow HAZARDOUS as the third param" do
+          tf = Tempfile.new('unittest')
+          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
+          tf.puts '  APPEND_PARAMETER item1 8 UINT 0 0 0'
+          tf.puts '    STATE WORST 0 RED'
+          tf.close
+          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /HAZARDOUS expected as third parameter/)
+          tf.unlink
+        end
+
+        it "should take HAZARDOUS and an optional description" do
+          tf = Tempfile.new('unittest')
+          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
+          tf.puts '  APPEND_PARAMETER item1 8 UINT 1 3 1'
+          tf.puts '    STATE GOOD 1'
+          tf.puts '    STATE BAD 2 HAZARDOUS'
+          tf.puts '    STATE WORST 3 HAZARDOUS "Hazardous description"'
+          tf.close
+          @pc.process_file(tf.path, "TGT1")
+          @pc.commands["TGT1"]["PKT1"].buffer = "\x01"
+          @pc.commands["TGT1"]["PKT1"].check_limits
+          @pc.commands["TGT1"]["PKT1"].items["ITEM1"].hazardous["GOOD"].should be_nil
+          @pc.commands["TGT1"]["PKT1"].items["ITEM1"].hazardous["BAD"].should_not be_nil
+          @pc.commands["TGT1"]["PKT1"].items["ITEM1"].hazardous["WORST"].should_not be_nil
+          @pc.commands["TGT1"]["PKT1"].items["ITEM1"].hazardous["WORST"].should eql "Hazardous description"
+          @pc.commands["TGT1"]["PKT1"].limits_items.should be_empty
+          tf.unlink
+        end
+      end
+
+    end
+  end
+end

data/spec/packets/structure_item_spec.rb

@@ -18,7 +18,7 @@ module Cosmos
 
     describe "name=" do
       it "should create new structure items" do
-        StructureItem.new("test", 0, 8, :UINT, :BIG_ENDIAN, nil).name.should eql "test"
+        StructureItem.new("test", 0, 8, :UINT, :BIG_ENDIAN, nil).name.should eql "TEST"
       end
 
       it "should complain about non String names" do
@@ -38,7 +38,7 @@ module Cosmos
       end
 
       it "should complain about bad endianness" do
-        expect { StructureItem.new("test", 0, 8, :UINT, :BLAH, nil) }.to raise_error(ArgumentError, "test: unknown endianness: BLAH - Must be :BIG_ENDIAN or :LITTLE_ENDIAN")
+        expect { StructureItem.new("test", 0, 8, :UINT, :BLAH, nil) }.to raise_error(ArgumentError, "TEST: unknown endianness: BLAH - Must be :BIG_ENDIAN or :LITTLE_ENDIAN")
       end
     end
 
@@ -51,7 +51,7 @@ module Cosmos
       end
 
       it "should complain about bad data types" do
-        expect { StructureItem.new("test", 0, 0, :UNKNOWN, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "test: unknown data_type: UNKNOWN - Must be :INT, :UINT, :FLOAT, :STRING, :BLOCK, or :DERIVED")
+        expect { StructureItem.new("test", 0, 0, :UNKNOWN, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "TEST: unknown data_type: UNKNOWN - Must be :INT, :UINT, :FLOAT, :STRING, :BLOCK, or :DERIVED")
       end
     end
 
@@ -63,39 +63,39 @@ module Cosmos
       end
 
       it "should complain about bad overflow types" do
-        expect { StructureItem.new("test", 0, 32, :INT, :BIG_ENDIAN, nil, :UNKNOWN) }.to raise_error(ArgumentError, "test: unknown overflow type: UNKNOWN - Must be :ERROR, :ERROR_ALLOW_HEX, :TRUNCATE, or :SATURATE")
+        expect { StructureItem.new("test", 0, 32, :INT, :BIG_ENDIAN, nil, :UNKNOWN) }.to raise_error(ArgumentError, "TEST: unknown overflow type: UNKNOWN - Must be :ERROR, :ERROR_ALLOW_HEX, :TRUNCATE, or :SATURATE")
       end
     end
 
     describe "bit_offset=" do
       it "should compain about bad bit offsets types" do
-        expect { StructureItem.new("test", nil, 8, :UINT, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "test: bit_offset must be a Fixnum")
+        expect { StructureItem.new("test", nil, 8, :UINT, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "TEST: bit_offset must be a Fixnum")
       end
 
       it "should complain about unaligned bit offsets" do
         %w(FLOAT STRING BLOCK).each do |type|
-          expect { StructureItem.new("test", 1, 32, type.to_sym, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "test: bit_offset for :FLOAT, :STRING, and :BLOCK items must be byte aligned")
+          expect { StructureItem.new("test", 1, 32, type.to_sym, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "TEST: bit_offset for :FLOAT, :STRING, and :BLOCK items must be byte aligned")
         end
       end
 
       it "should complain about non zero DERIVED bit offsets" do
-        expect { StructureItem.new("test", 8, 0, :DERIVED, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "test: DERIVED items must have bit_offset of zero")
+        expect { StructureItem.new("test", 8, 0, :DERIVED, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "TEST: DERIVED items must have bit_offset of zero")
       end
     end
 
     describe "bit_size=" do
       it "should complain about bad bit sizes types" do
-        expect { StructureItem.new("test", 0, nil, :UINT, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "test: bit_size must be a Fixnum")
+        expect { StructureItem.new("test", 0, nil, :UINT, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "TEST: bit_size must be a Fixnum")
       end
 
       it "should complain about 0 size INT, UINT, and FLOAT" do
         %w(INT UINT FLOAT).each do |type|
-          expect { StructureItem.new("test", 0, 0, type.to_sym, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "test: bit_size cannot be negative or zero for :INT, :UINT, and :FLOAT items: 0")
+          expect { StructureItem.new("test", 0, 0, type.to_sym, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "TEST: bit_size cannot be negative or zero for :INT, :UINT, and :FLOAT items: 0")
         end
       end
 
       it "should complain about bad float bit sizes" do
-        expect { StructureItem.new("test", 0, 8, :FLOAT, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "test: bit_size for FLOAT items must be 32 or 64. Given: 8")
+        expect { StructureItem.new("test", 0, 8, :FLOAT, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "TEST: bit_size for FLOAT items must be 32 or 64. Given: 8")
       end
 
       it "should create 32 and 64 bit floats" do
@@ -104,17 +104,17 @@ module Cosmos
       end
 
       it "should complain about non zero DERIVED bit sizes" do
-        expect { StructureItem.new("test", 0, 8, :DERIVED, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "test: DERIVED items must have bit_size of zero")
+        expect { StructureItem.new("test", 0, 8, :DERIVED, :BIG_ENDIAN, nil) }.to raise_error(ArgumentError, "TEST: DERIVED items must have bit_size of zero")
       end
     end
 
     describe "array_size=" do
       it "should complain about bad array size types" do
-        expect { StructureItem.new("test", 0, 8, :UINT, :BIG_ENDIAN, "") }.to raise_error(ArgumentError, "test: array_size must be a Fixnum")
+        expect { StructureItem.new("test", 0, 8, :UINT, :BIG_ENDIAN, "") }.to raise_error(ArgumentError, "TEST: array_size must be a Fixnum")
       end
 
       it "should complain about array size != multiple of bit size" do
-        expect { StructureItem.new("test", 0, 8, :UINT, :BIG_ENDIAN, 10) }.to raise_error(ArgumentError, "test: array_size must be a multiple of bit_size")
+        expect { StructureItem.new("test", 0, 8, :UINT, :BIG_ENDIAN, 10) }.to raise_error(ArgumentError, "TEST: array_size must be a multiple of bit_size")
       end
 
       it "should not complain about array size != multiple of bit size with negative array size" do
@@ -181,7 +181,7 @@ module Cosmos
         hash = item.to_hash
         hash.keys.length.should eql 7
         hash.keys.should include('name','bit_offset','bit_size','data_type','endianness','array_size', 'overflow')
-        hash["name"].should eql "test"
+        hash["name"].should eql "TEST"
         hash["bit_offset"].should eql 0
         hash["bit_size"].should eql 8
         hash["data_type"].should eql :UINT

data/spec/packets/structure_spec.rb

@@ -34,6 +34,31 @@ module Cosmos
       end
     end # describe "initialize"
 
+    describe "defined?" do
+      it "returns true if any items have been defined" do
+        s = Structure.new
+        expect(s.defined?).to be false
+        s.define_item("test1",0,8,:UINT)
+        expect(s.defined?).to be true
+      end
+    end
+
+    describe "rename_item" do
+      it "renames a previously defined item" do
+        s = Structure.new
+        s.items["test1"].should be_nil
+        s.sorted_items[0].should be_nil
+        s.define_item("test1", 0, 8, :UINT)
+        s.items["TEST1"].should_not be_nil
+        s.sorted_items[0].should_not be_nil
+        s.sorted_items[0].name.should eql "TEST1"
+        s.rename_item("TEST1", "TEST2")
+        s.items["TEST1"].should be_nil
+        s.items["TEST2"].should_not be_nil
+        s.sorted_items[0].name.should eql "TEST2"
+      end
+    end
+
     describe "define_item" do
       before(:each) do
         @s = Structure.new
@@ -47,21 +72,21 @@ module Cosmos
         @s.sorted_items[0].should_not be_nil
         @s.sorted_items[0].name.should eql "TEST1"
         @s.defined_length.should eql 1
-        @s.fixed_size.should be_truthy
+        @s.fixed_size.should be true
       end
 
-      it "should add items with negative offsets" do
+      it "adds items with negative bit offsets" do
         @s.define_item("test1", -8, 8, :UINT)
         @s.defined_length.should eql 1
         @s.define_item("test2", 0, 4, :UINT)
         @s.defined_length.should eql 2
         @s.define_item("test3", 4, 4, :UINT)
         @s.defined_length.should eql 2
-        @s.define_item("test4", 8, 0, :BLOCK)
-        @s.defined_length.should eql 2
-        @s.define_item("test5", -16, 8, :UINT)
+        @s.define_item("test4", 16, 0, :BLOCK)
         @s.defined_length.should eql 3
-        @s.fixed_size.should be_falsey
+        @s.define_item("test5", -16, 8, :UINT)
+        @s.defined_length.should eql 4
+        @s.fixed_size.should be false
       end
 
       it "should add item with negative offset" do
@@ -81,7 +106,7 @@ module Cosmos
         @s.defined_length.should eql 3
         @s.define_item("test4", 8, 0, :BLOCK)
         @s.defined_length.should eql 3
-        @s.fixed_size.should be_falsey
+        @s.fixed_size.should be false
       end
 
       it "should recalulate sorted_items when adding multiple items" do
@@ -94,7 +119,7 @@ module Cosmos
         @s.define_item("test3", 16, 8, :UINT)
         @s.sorted_items[-1].name.should eql "TEST3"
         @s.defined_length.should eql 5
-        @s.fixed_size.should be_truthy
+        @s.fixed_size.should be true
       end
 
       it "should overwrite existing items" do
@@ -108,21 +133,73 @@ module Cosmos
         @s.items["TEST1"].bit_size.should eql 16
         @s.items["TEST1"].data_type.should eql :INT
         @s.defined_length.should eql 2
-        @s.fixed_size.should be_truthy
+        @s.fixed_size.should be true
       end
     end # describe "define_item"
 
-    describe "append_item" do
+    describe "define" do
       before(:each) do
         @s = Structure.new
       end
 
-      it "should append an item to items" do
-        @s.define_item("test1", 0, 8, :UINT)
+      it "adds the item to items and sorted_items" do
+        @s.items["test1"].should be_nil
+        @s.sorted_items[0].should be_nil
+        si = StructureItem.new("test1",0,8,:UINT,:BIG_ENDIAN)
+        @s.define(si)
+        @s.items["TEST1"].should_not be_nil
+        @s.sorted_items[0].should_not be_nil
+        @s.sorted_items[0].name.should eql "TEST1"
+        @s.defined_length.should eql 1
+        @s.fixed_size.should be true
+      end
+
+      it "allows items to be defined on top of each other" do
+        @s.items["test1"].should be_nil
+        @s.sorted_items[0].should be_nil
+        si = StructureItem.new("test1",0,8,:UINT,:BIG_ENDIAN)
+        @s.define(si)
+        @s.sorted_items[0].name.should eql "TEST1"
+        @s.items["TEST1"].bit_offset.should eql 0
         @s.items["TEST1"].bit_size.should eql 8
+        @s.items["TEST1"].data_type.should eql :UINT
+        @s.defined_length.should eql 1
+        si = StructureItem.new("test2",0,16,:INT,:BIG_ENDIAN)
+        @s.define(si)
+        @s.sorted_items[1].name.should eql "TEST2"
+        @s.items["TEST2"].bit_offset.should eql 0
+        @s.items["TEST2"].bit_size.should eql 16
+        @s.items["TEST2"].data_type.should eql :INT
+        @s.defined_length.should eql 2
+        buffer = "\x01\x02"
+        @s.read_item(@s.get_item("test1"), :RAW, buffer).should eql 1
+        @s.read_item(@s.get_item("test2"), :RAW, buffer).should eql 258
+      end
+
+      it "should overwrite existing items" do
+        si = StructureItem.new("test1",0,8,:UINT,:BIG_ENDIAN)
+        @s.define(si)
         @s.sorted_items[0].name.should eql "TEST1"
-        @s.sorted_items[1].should be_nil
+        @s.items["TEST1"].bit_size.should eql 8
+        @s.items["TEST1"].data_type.should eql :UINT
         @s.defined_length.should eql 1
+        si = StructureItem.new("test1",0,16,:INT,:BIG_ENDIAN)
+        @s.define(si)
+        @s.sorted_items[0].name.should eql "TEST1"
+        @s.items["TEST1"].bit_size.should eql 16
+        @s.items["TEST1"].data_type.should eql :INT
+        @s.defined_length.should eql 2
+        @s.fixed_size.should be true
+      end
+    end
+
+    describe "append_item" do
+      before(:each) do
+        @s = Structure.new
+      end
+
+      it "should append an item to items" do
+        @s.define_item("test1", 0, 8, :UINT)
         @s.append_item("test2", 16, :UINT)
         @s.items["TEST2"].bit_size.should eql 16
         @s.sorted_items[0].name.should eql "TEST1"
@@ -152,7 +229,29 @@ module Cosmos
         @s.define_item("test1", 0, 8, :UINT, -8)
         expect { @s.append_item("test2", 8, :UINT) }.to raise_error(ArgumentError, "Can't append an item after a variably sized item")
       end
-    end # describe "define_item"
+    end
+
+    describe "append" do
+      before(:each) do
+        @s = Structure.new
+      end
+
+      it "appends an item to the structure" do
+        @s.define_item("test1", 0, 8, :UINT)
+        item = StructureItem.new("test2", 0, 16, :UINT, :BIG_ENDIAN)
+        @s.append(item)
+        # Bit offset should change because we appended the item
+        @s.items["TEST2"].bit_offset.should eql 8
+        @s.sorted_items[0].name.should eql "TEST1"
+        @s.sorted_items[1].name.should eql "TEST2"
+        @s.defined_length.should eql 3
+      end
+
+      it "should complain if appending after a variably sized item" do
+        @s.define_item("test1", 0, 0, :BLOCK)
+        expect { @s.append(@item) }.to raise_error(ArgumentError, "Can't append an item after a variably sized item")
+      end
+    end
 
     describe "get_item" do
       before(:each) do
@@ -281,7 +380,7 @@ module Cosmos
     end
 
     describe "read_all" do
-      it "should read all defined items" do
+      it "reads all defined items" do
         s = Structure.new(:BIG_ENDIAN)
         s.append_item("test1", 8, :UINT, 16)
         s.append_item("test2", 16, :UINT)
@@ -296,6 +395,22 @@ module Cosmos
         vals[1][1].should eql 0x0304
         vals[2][1].should eql 0x05060708
       end
+
+      it "reads all defined items synchronized" do
+        s = Structure.new(:BIG_ENDIAN)
+        s.append_item("test1", 8, :UINT, 16)
+        s.append_item("test2", 16, :UINT)
+        s.append_item("test3", 32, :UINT)
+
+        buffer = "\x01\x02\x03\x04\x05\x06\x07\x08"
+        vals = s.read_all(:RAW, buffer, false)
+        vals[0][0].should eql "TEST1"
+        vals[1][0].should eql "TEST2"
+        vals[2][0].should eql "TEST3"
+        vals[0][1].should eql [1,2]
+        vals[1][1].should eql 0x0304
+        vals[2][1].should eql 0x05060708
+      end
     end
 
     describe "formatted" do
@@ -312,10 +427,24 @@ module Cosmos
         s.formatted.should include("TEST3")
         s.formatted.should include("00000000: 07 08 09 0A")
       end
+
+      it "should alter the indentation of the item" 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")
+        s.formatted(:CONVERTED, 4).should include("    TEST1: [1, 2]")
+        s.formatted(:CONVERTED, 4).should include("    TEST2: 3456")
+        s.formatted(:CONVERTED, 4).should include("    TEST3")
+        s.formatted(:CONVERTED, 4).should include("    00000000: 07 08 09 0A")
+      end
     end
 
     describe "buffer" do
-      it "should return the buffer" do
+      it "returns the buffer" do
         s = Structure.new(:BIG_ENDIAN)
         s.append_item("test1", 8, :UINT, 16)
         s.write("test1", [1,2])
@@ -324,6 +453,8 @@ module Cosmos
         s.append_item("test3", 32, :UINT)
         s.write("test3", 0x05060708)
         s.buffer.should eql "\x01\x02\x03\x04\x05\x06\x07\x08"
+        expect(s.buffer).to_not be s.buffer
+        expect(s.buffer(false)).to be s.buffer(false)
       end
     end
 
@@ -376,8 +507,16 @@ module Cosmos
         s.write("test2", 0x0304)
         s.append_item("test3", 32, :UINT)
         s.write("test3", 0x05060708)
+        # Get a reference to the original buffer
+        old_buffer = s.buffer(false)
 
         s2 = s.clone
+        # Ensure we didn't modify the original buffer object
+        expect(s.buffer(false)).to be old_buffer
+        # Check that they are equal in value
+        expect(s2.buffer(false)).to eql s.buffer(false)
+        # But not the same object
+        expect(s2.buffer(false)).to_not be s.buffer(false)
         s2.read("test1").should eql [1,2]
         s2.read("test2").should eql 0x0304
         s2.read("test3").should eql 0x05060708
@@ -407,6 +546,13 @@ module Cosmos
         s.test1.should eql [3,4]
       end
 
+      it "raises an exception if there is no buffer" do
+        s = Structure.new(:BIG_ENDIAN, nil)
+        s.append_item("test1", 8, :UINT, 16)
+        s.enable_method_missing
+        expect { s.test1 }.to raise_error(/No buffer/)
+      end
+
       it "should complain if it can't find an item" do
         s = Structure.new(:BIG_ENDIAN)
         s.enable_method_missing