cosmos 3.2.1 → 3.3.0

data/spec/packets/packet_item_limits_spec.rb

@@ -20,39 +20,39 @@ module Cosmos
     end
 
     describe "values=" do
-      it "should set the values Hash" do
+      it "sets the values Hash" do
         @l.values = {:DEFAULT => [0,1,2,3,4,5]}
-        @l.values[:DEFAULT].should eql [0,1,2,3,4,5]
+        expect(@l.values[:DEFAULT]).to eql [0,1,2,3,4,5]
       end
 
-      it "should allow nil values" do
+      it "allows nil values" do
         @l.values = nil
-        @l.values.should be_nil
+        expect(@l.values).to be_nil
       end
 
-      it "should complain about non Hash values" do
+      it "complains about non Hash values" do
         expect { @l.values = [] }.to raise_error(ArgumentError, "values must be a Hash but is a Array")
       end
 
-      it "should complain about Hash values without a :DEFAULT key" do
+      it "complains about Hash values without a :DEFAULT key" do
         expect { @l.values = {} }.to raise_error(ArgumentError, "values must be a Hash with a :DEFAULT key")
       end
     end
 
     describe "state=" do
-      it "should set the state to a Symbol" do
+      it "sets the state to a Symbol" do
         PacketItemLimits::LIMITS_STATES.each do |state|
           @l.state = state
-          @l.state.should eql state
+          expect(@l.state).to eql state
         end
       end
 
-      it "should set the state to nil" do
+      it "sets the state to nil" do
         @l.state = nil
-        @l.state.should be_nil
+        expect(@l.state).to be_nil
       end
 
-      it "should complain about bad Symbol states" do
+      it "complains about bad Symbol states" do
         expect { @l.state = :ORANGE }.to raise_error(ArgumentError, "state must be one of #{PacketItemLimits::LIMITS_STATES} but is ORANGE")
         expect { @l.state = "RED" }.to raise_error(ArgumentError, "state must be one of #{PacketItemLimits::LIMITS_STATES} but is RED")
         expect { @l.state = 5 }.to raise_error(ArgumentError, "state must be one of #{PacketItemLimits::LIMITS_STATES} but is 5")
@@ -60,67 +60,67 @@ module Cosmos
     end
 
     describe "response=" do
-      it "should accept LimitsResponse instances" do
+      it "accepts LimitsResponse instances" do
         r = LimitsResponse.new()
         @l.response = r
-        (LimitsResponse === @l.response).should be_truthy
+        expect(LimitsResponse === @l.response).to be_truthy
       end
 
-      it "should set the response to nil" do
+      it "sets the response to nil" do
         @l.response = nil
-        @l.response.should be_nil
+        expect(@l.response).to be_nil
       end
 
-      it "should complain about non LimitsResponse responses" do
+      it "complains about non LimitsResponse responses" do
         expect { @l.response = "HI" }.to raise_error(ArgumentError, "response must be a Cosmos::LimitsResponse but is a String")
       end
     end
 
     describe "persistence_setting=" do
-      it "should accept persistence_setting as a Fixnum" do
+      it "accepts persistence_setting as a Fixnum" do
         persistence_setting = 1
         @l.persistence_setting = persistence_setting
-        @l.persistence_setting.should eql persistence_setting
+        expect(@l.persistence_setting).to eql persistence_setting
       end
 
-      it "should complain about persistence_setting = nil" do
+      it "complains about persistence_setting = nil" do
         expect { @l.persistence_setting = nil}.to raise_error(ArgumentError, "persistence_setting must be a Fixnum but is a NilClass")
       end
 
-      it "should complain about persistence_setting that aren't Fixnum" do
+      it "complains about persistence_setting that aren't Fixnum" do
         expect { @l.persistence_setting = 5.5}.to raise_error(ArgumentError, "persistence_setting must be a Fixnum but is a Float")
       end
     end
 
     describe "persistence_count=" do
-      it "should accept persistence_count as a String" do
+      it "accepts persistence_count as a String" do
         persistence_count = 1
         @l.persistence_count = persistence_count
-        @l.persistence_count.should eql persistence_count
+        expect(@l.persistence_count).to eql persistence_count
       end
 
-      it "should complain about persistence_count = nil" do
+      it "complains about persistence_count = nil" do
         expect { @l.persistence_count = nil}.to raise_error(ArgumentError, "persistence_count must be a Fixnum but is a NilClass")
       end
 
-      it "should complain about persistence_count that aren't Fixnum" do
+      it "complains about persistence_count that aren't Fixnum" do
         expect { @l.persistence_count = 5.5}.to raise_error(ArgumentError, "persistence_count must be a Fixnum but is a Float")
       end
     end
 
     describe "clone" do
-      it "should duplicate the entire Limits" do
+      it "duplicates the entire Limits" do
         l2 = @l.clone
-        @l.values.should eql l2.values
-        @l.response.should eql l2.response
-        @l.state.should eql l2.state
-        @l.persistence_count.should eql l2.persistence_count
-        @l.persistence_setting.should eql l2.persistence_setting
+        expect(@l.values).to eql l2.values
+        expect(@l.response).to eql l2.response
+        expect(@l.state).to eql l2.state
+        expect(@l.persistence_count).to eql l2.persistence_count
+        expect(@l.persistence_setting).to eql l2.persistence_setting
       end
     end
 
     describe "to_hash" do
-      it "should create a Hash" do
+      it "creates a Hash" do
         @l.enabled = true
         @l.values = {:DEFAULT => [0,1,2,3,4,5]}
         @l.state = :RED_LOW
@@ -130,17 +130,17 @@ module Cosmos
         @l.persistence_count = 2
 
         hash = @l.to_hash
-        hash.keys.length.should eql 6
-        hash.keys.should include('values','enabled','state','response','persistence_setting','persistence_count')
-        hash["enabled"].should be_truthy
-        hash["values"].should include(:DEFAULT => [0,1,2,3,4,5])
-        hash["state"].should eql :RED_LOW
-        hash["response"].should match "LimitsResponse"
-        hash["persistence_setting"].should eql 1
-        hash["persistence_count"].should eql 2
+        expect(hash.keys.length).to eql 6
+        expect(hash.keys).to include('values','enabled','state','response','persistence_setting','persistence_count')
+        expect(hash["enabled"]).to be_truthy
+        expect(hash["values"]).to include(:DEFAULT => [0,1,2,3,4,5])
+        expect(hash["state"]).to eql :RED_LOW
+        expect(hash["response"]).to match "LimitsResponse"
+        expect(hash["persistence_setting"]).to eql 1
+        expect(hash["persistence_count"]).to eql 2
       end
 
-      it "should create a Hash without a response" do
+      it "creates a Hash without a response" do
         @l.enabled = true
         @l.values = {:DEFAULT => [0,1,2,3,4,5]}
         @l.state = :RED_LOW
@@ -148,12 +148,12 @@ module Cosmos
         @l.persistence_count = 2
 
         hash = @l.to_hash
-        hash["enabled"].should be_truthy
-        hash["values"].should include(:DEFAULT => [0,1,2,3,4,5])
-        hash["state"].should eql :RED_LOW
-        hash["response"].should be_nil
-        hash["persistence_setting"].should eql 1
-        hash["persistence_count"].should eql 2
+        expect(hash["enabled"]).to be_truthy
+        expect(hash["values"]).to include(:DEFAULT => [0,1,2,3,4,5])
+        expect(hash["state"]).to eql :RED_LOW
+        expect(hash["response"]).to be_nil
+        expect(hash["persistence_setting"]).to eql 1
+        expect(hash["persistence_count"]).to eql 2
       end
     end
 

data/spec/packets/packet_item_spec.rb

@@ -21,21 +21,21 @@ module Cosmos
     end
 
     describe "format_string=" do
-      it "should set the format_string" do
+      it "sets the format_string" do
         @pi.format_string = "%5.1f"
-        @pi.format_string.should eql "%5.1f"
+        expect(@pi.format_string).to eql "%5.1f"
       end
 
-      it "should set the format_string to nil" do
+      it "sets the format_string to nil" do
         @pi.format_string = nil
-        @pi.format_string.should be_nil
+        expect(@pi.format_string).to be_nil
       end
 
-      it "should complain about non String format_strings" do
+      it "complains about non String format_strings" do
         expect { @pi.format_string = 5 }.to raise_error(ArgumentError, "#{@pi.name}: format_string must be a String but is a Fixnum")
       end
 
-      it "should complain about badly formatted format_strings" do
+      it "complains about badly formatted format_strings" do
         expect { @pi.format_string = "%" }.to raise_error(ArgumentError, "#{@pi.name}: format_string invalid '%'")
         expect { @pi.format_string = "5" }.to raise_error(ArgumentError, "#{@pi.name}: format_string invalid '5'")
         expect { @pi.format_string = "%Q" }.to raise_error(ArgumentError, "#{@pi.name}: format_string invalid '%Q'")
@@ -43,57 +43,57 @@ module Cosmos
     end
 
     describe "read_conversion=" do
-      it "should accept Conversion instances" do
+      it "accepts Conversion instances" do
         c = GenericConversion.new("value / 2")
         @pi.read_conversion = c
-        (@pi.read_conversion.to_s == c.to_s).should be_truthy
+        expect(@pi.read_conversion.to_s == c.to_s).to be_truthy
       end
 
-      it "should set the read_conversion to nil" do
+      it "sets the read_conversion to nil" do
         @pi.read_conversion = nil
-        @pi.read_conversion.should be_nil
+        expect(@pi.read_conversion).to be_nil
       end
 
-      it "should complain about non Conversion read_conversions" do
+      it "complains about non Conversion read_conversions" do
         expect { @pi.read_conversion = "HI" }.to raise_error(ArgumentError, "#{@pi.name}: read_conversion must be a Cosmos::Conversion but is a String")
       end
     end
 
     describe "write_conversion=" do
-      it "should accept Conversion instances" do
+      it "accepts Conversion instances" do
         c = GenericConversion.new("value / 2")
         @pi.write_conversion = c
-        (@pi.write_conversion.to_s == c.to_s).should be_truthy
+        expect(@pi.write_conversion.to_s == c.to_s).to be_truthy
       end
 
-      it "should set the write_conversion to nil" do
+      it "sets the write_conversion to nil" do
         @pi.write_conversion = nil
-        @pi.write_conversion.should be_nil
+        expect(@pi.write_conversion).to be_nil
       end
 
-      it "should complain about non Conversion write_conversions" do
+      it "complains about non Conversion write_conversions" do
         expect { @pi.write_conversion = "HI" }.to raise_error(ArgumentError, "#{@pi.name}: write_conversion must be a Cosmos::Conversion but is a String")
       end
     end
 
     describe "id_value=" do
-      it "should accept id values according to data_type" do
+      it "accepts id values according to data_type" do
         @pi.id_value = 10
-        @pi.id_value.should eql 10
+        expect(@pi.id_value).to eql 10
         @pi.data_type = :FLOAT
         @pi.id_value = 10.0
-        @pi.id_value.should eql 10.0
+        expect(@pi.id_value).to eql 10.0
         @pi.data_type = :STRING
         @pi.id_value = "HI"
-        @pi.id_value.should eql "HI"
+        expect(@pi.id_value).to eql "HI"
       end
 
-      it "should set the id_value to nil" do
+      it "sets the id_value to nil" do
         @pi.id_value = nil
-        @pi.id_value.should be_nil
+        expect(@pi.id_value).to be_nil
       end
 
-      it "should complain about id_values that don't match the data_type" do
+      it "complains about id_values that don't match the data_type" do
         expect { @pi.id_value = "HI" }.to raise_error(ArgumentError, "#{@pi.name}: Invalid value: HI for data type: UINT")
         @pi.data_type = :FLOAT
         expect { @pi.id_value = "HI" }.to raise_error(ArgumentError, "#{@pi.name}: Invalid value: HI for data type: FLOAT")
@@ -101,97 +101,97 @@ module Cosmos
     end
 
     describe "states=" do
-      it "should accept states as a Hash" do
+      it "accepts states as a Hash" do
         states = {"TRUE"=>1, "FALSE"=>0}
         @pi.states = states
-        @pi.states.should eql states
+        expect(@pi.states).to eql states
       end
 
-      it "should set the states to nil" do
+      it "sets the states to nil" do
         @pi.states = nil
-        @pi.states.should be_nil
+        expect(@pi.states).to be_nil
       end
 
-      it "should complain about states that aren't Hashes" do
+      it "complains about states that aren't Hashes" do
         expect { @pi.states = "state" }.to raise_error(ArgumentError, "#{@pi.name}: states must be a Hash but is a String")
       end
     end
 
     describe "description=" do
-      it "should accept description as a String" do
+      it "accepts description as a String" do
         description = "this is it"
         @pi.description = description
-        @pi.description.should eql description
+        expect(@pi.description).to eql description
       end
 
-      it "should set the description to nil" do
+      it "sets the description to nil" do
         @pi.description = nil
-        @pi.description.should be_nil
+        expect(@pi.description).to be_nil
       end
 
-      it "should complain about description that aren't Strings" do
+      it "complains about description that aren't Strings" do
         expect { @pi.description = 5}.to raise_error(ArgumentError, "#{@pi.name}: description must be a String but is a Fixnum")
       end
     end
 
     describe "units_full=" do
-      it "should accept units_full as a String" do
+      it "accepts units_full as a String" do
         units_full = "Volts"
         @pi.units_full = units_full
-        @pi.units_full.should eql units_full
+        expect(@pi.units_full).to eql units_full
       end
 
-      it "should set the units_full to nil" do
+      it "sets the units_full to nil" do
         @pi.units_full = nil
-        @pi.units_full.should be_nil
+        expect(@pi.units_full).to be_nil
       end
 
-      it "should complain about units_full that aren't Strings" do
+      it "complains about units_full that aren't Strings" do
         expect { @pi.units_full = 5}.to raise_error(ArgumentError, "#{@pi.name}: units_full must be a String but is a Fixnum")
       end
     end
 
     describe "units=" do
-      it "should accept units as a String" do
+      it "accepts units as a String" do
         units = "V"
         @pi.units = units
-        @pi.units.should eql units
+        expect(@pi.units).to eql units
       end
 
-      it "should set the units to nil" do
+      it "sets the units to nil" do
         @pi.units = nil
-        @pi.units.should be_nil
+        expect(@pi.units).to be_nil
       end
 
-      it "should complain about units that aren't Strings" do
+      it "complains about units that aren't Strings" do
         expect { @pi.units = 5}.to raise_error(ArgumentError, "#{@pi.name}: units must be a String but is a Fixnum")
       end
     end
 
     describe "default=" do
-      it "should accept default according to the data_type" do
+      it "accepts default according to the data_type" do
         pi = PacketItem.new("test", 0, 8, :INT, :BIG_ENDIAN, 16)
         pi.default = [1, -1]
-        pi.default.should eql [1, -1]
+        expect(pi.default).to eql [1, -1]
         pi = PacketItem.new("test", 0, 32, :UINT, :BIG_ENDIAN, nil)
         pi.default = 0x01020304
-        pi.default.should eql 0x01020304
+        expect(pi.default).to eql 0x01020304
         pi = PacketItem.new("test", 0, 32, :FLOAT, :BIG_ENDIAN, nil)
         pi.default = 5.5
-        pi.default.should eql 5.5
+        expect(pi.default).to eql 5.5
         pi = PacketItem.new("test", 0, 32, :STRING, :BIG_ENDIAN, nil)
         pi.default = "HI"
-        pi.default.should eql "HI"
+        expect(pi.default).to eql "HI"
       end
 
-      it "should set the default to nil" do
+      it "sets the default to nil" do
         @pi.default = nil
-        @pi.default.should be_nil
+        expect(@pi.default).to be_nil
       end
     end
 
     describe "check_default_and_range_data_types" do
-      it "should complain about default not matching data_type" do
+      it "complains about default not matching data_type" do
         pi = PacketItem.new("test", 0, 8, :UINT, :BIG_ENDIAN, 16)
         pi.default = 1
         expect { pi.check_default_and_range_data_types }.to raise_error(ArgumentError, "TEST: default must be an Array but is a Fixnum")
@@ -227,7 +227,7 @@ module Cosmos
         expect { pi.check_default_and_range_data_types }.to_not raise_error
       end
 
-      it "should complain about range not matching data_type" do
+      it "complains about range not matching data_type" do
         pi = PacketItem.new("test", 0, 32, :UINT, :BIG_ENDIAN, nil)
         pi.default = 5
         pi.range = (5.5..10)
@@ -246,90 +246,90 @@ module Cosmos
     end
 
     describe "range=" do
-      it "should accept range as a String" do
+      it "accepts range as a String" do
         range = (0..1)
         @pi.range = range
-        @pi.range.should eql range
+        expect(@pi.range).to eql range
       end
 
-      it "should set the range to nil" do
+      it "sets the range to nil" do
         @pi.range = nil
-        @pi.range.should be_nil
+        expect(@pi.range).to be_nil
       end
 
-      it "should complain about ranges that aren't Ranges" do
+      it "complains about ranges that aren't Ranges" do
         expect { @pi.range = 5}.to raise_error(ArgumentError, "#{@pi.name}: range must be a Range but is a Fixnum")
       end
     end
 
     describe "hazardous=" do
-      it "should accept hazardous as a Hash" do
+      it "accepts hazardous as a Hash" do
         hazardous = {"TRUE"=>nil,"FALSE"=>"NO FALSE ALLOWED"}
         @pi.hazardous = hazardous
-        @pi.hazardous.should eql hazardous
-        @pi.hazardous["TRUE"].should eql hazardous["TRUE"]
-        @pi.hazardous["FALSE"].should eql hazardous["FALSE"]
+        expect(@pi.hazardous).to eql hazardous
+        expect(@pi.hazardous["TRUE"]).to eql hazardous["TRUE"]
+        expect(@pi.hazardous["FALSE"]).to eql hazardous["FALSE"]
       end
 
-      it "should set hazardous to nil" do
+      it "sets hazardous to nil" do
         @pi.hazardous = nil
-        @pi.hazardous.should be_nil
+        expect(@pi.hazardous).to be_nil
       end
 
-      it "should complain about hazardous that aren't Hashes" do
+      it "complains about hazardous that aren't Hashes" do
         expect { @pi.hazardous = ""}.to raise_error(ArgumentError, "#{@pi.name}: hazardous must be a Hash but is a String")
       end
     end
 
     describe "state_colors=" do
-      it "should accept state_colors as a Hash" do
+      it "accepts state_colors as a Hash" do
         state_colors = {"TRUE"=>:GREEN, "FALSE"=>:RED}
         @pi.state_colors = state_colors
-        @pi.state_colors.should eql state_colors
+        expect(@pi.state_colors).to eql state_colors
       end
 
-      it "should set the state_colors to nil" do
+      it "sets the state_colors to nil" do
         @pi.state_colors = nil
-        @pi.state_colors.should be_nil
+        expect(@pi.state_colors).to be_nil
       end
 
-      it "should complain about state_colors that aren't Hashes" do
+      it "complains about state_colors that aren't Hashes" do
         expect { @pi.state_colors = ""}.to raise_error(ArgumentError, "#{@pi.name}: state_colors must be a Hash but is a String")
       end
     end
 
     describe "limits=" do
-      it "should accept limits as a PacketItemLimits" do
+      it "accepts limits as a PacketItemLimits" do
         limits = PacketItemLimits.new
         @pi.limits = limits
       end
 
-      it "should set the limits to nil" do
+      it "sets the limits to nil" do
         @pi.limits = nil
-        @pi.limits.should be_nil
+        expect(@pi.limits).to be_nil
       end
 
-      it "should complain about limits that aren't PacketItemLimits" do
+      it "complains about limits that aren't PacketItemLimits" do
         expect { @pi.limits = ""}.to raise_error(ArgumentError, "#{@pi.name}: limits must be a PacketItemLimits but is a String")
       end
     end
 
     describe "meta" do
-      it "should allow adding items to the meta hash" do
+      it "allows adding items to the meta hash" do
         @pi.meta['TYPE'] = 'float32'
-        @pi.meta['TYPE'].should eql 'float32'
+        expect(@pi.meta['TYPE']).to eql 'float32'
       end
     end
 
     describe "clone" do
-      it "should duplicate the entire PacketItem" do
+      it "duplicates the entire PacketItem" do
         pi2 = @pi.clone
-        (@pi == pi2).should be_truthy
+        expect(@pi == pi2).to be_truthy
       end
     end
 
     describe "to_hash" do
-      it "should convert to a Hash" do
+      it "converts to a Hash" do
         @pi.format_string = "%5.1f"
         @pi.id_value = 10
         @pi.states = {"TRUE"=>1, "FALSE"=>0}
@@ -346,39 +346,39 @@ module Cosmos
         @pi.limits = PacketItemLimits.new
 
         hash = @pi.to_hash
-        hash.keys.length.should eql 22
+        expect(hash.keys.length).to eql 22
         # Check the values from StructureItem
-        hash.keys.should include('name','bit_offset','bit_size','data_type','endianness','array_size','overflow')
-        hash["name"].should eql "TEST"
-        hash["bit_offset"].should eql 0
-        hash["bit_size"].should eql 32
-        hash["data_type"].should eql :UINT
-        hash["endianness"].should eql :BIG_ENDIAN
-        hash["array_size"].should be_nil
-        hash["overflow"].should eql :ERROR
+        expect(hash.keys).to include('name','bit_offset','bit_size','data_type','endianness','array_size','overflow')
+        expect(hash["name"]).to eql "TEST"
+        expect(hash["bit_offset"]).to eql 0
+        expect(hash["bit_size"]).to eql 32
+        expect(hash["data_type"]).to eql :UINT
+        expect(hash["endianness"]).to eql :BIG_ENDIAN
+        expect(hash["array_size"]).to be_nil
+        expect(hash["overflow"]).to eql :ERROR
         # Check the unique PacketItem values
-        hash.keys.should include('format_string','read_conversion','write_conversion','id_value','states','description','units_full','units','default','range','required','hazardous','state_colors','limits')
-        hash["format_string"].should eql "%5.1f"
-        hash["read_conversion"].should match "value / 2"
-        hash["write_conversion"].should match /value \* 2/
-        hash["id_value"].should eql 10
-        hash["states"].should include("TRUE"=>1,"FALSE"=>0)
-        hash["description"].should eql "description"
-        hash["units_full"].should eql "Celcius"
-        hash["units"].should eql "C"
-        hash["default"].should eql 0
-        hash["range"].should eql (0..100)
-        hash["required"].should be_truthy
-        hash["hazardous"].should include("TRUE"=>nil,"FALSE"=>"NO!")
-        hash["state_colors"].should include("TRUE"=>:GREEN,"FALSE"=>:RED)
-        hash["limits"].should eql PacketItemLimits.new.to_hash
-        hash["meta"].should be_nil
-      end
-
-      it "should convert to a Hash with no conversions" do
+        expect(hash.keys).to include('format_string','read_conversion','write_conversion','id_value','states','description','units_full','units','default','range','required','hazardous','state_colors','limits')
+        expect(hash["format_string"]).to eql "%5.1f"
+        expect(hash["read_conversion"]).to match "value / 2"
+        expect(hash["write_conversion"]).to match /value \* 2/
+        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"]).to eql "C"
+        expect(hash["default"]).to eql 0
+        expect(hash["range"]).to eql (0..100)
+        expect(hash["required"]).to be_truthy
+        expect(hash["hazardous"]).to include("TRUE"=>nil,"FALSE"=>"NO!")
+        expect(hash["state_colors"]).to include("TRUE"=>:GREEN,"FALSE"=>:RED)
+        expect(hash["limits"]).to eql PacketItemLimits.new.to_hash
+        expect(hash["meta"]).to be_nil
+      end
+
+      it "converts to a Hash with no conversions" do
         hash = @pi.to_hash
-        hash["read_conversion"].should be_nil
-        hash["write_conversion"].should be_nil
+        expect(hash["read_conversion"]).to be_nil
+        expect(hash["write_conversion"]).to be_nil
       end
     end