cosmos 3.3.3 → 3.4.0

data/spec/interfaces/udp_interface_spec.rb

@@ -22,17 +22,17 @@ module Cosmos
       it "is not writeable if no write port given" do
         i = UdpInterface.new('localhost','nil','8889')
         expect(i.name).to eql "Cosmos::UdpInterface"
-        expect(i.write_allowed?).to be_falsey
-        expect(i.write_raw_allowed?).to be_falsey
-        expect(i.read_allowed?).to be_truthy
+        expect(i.write_allowed?).to be false
+        expect(i.write_raw_allowed?).to be false
+        expect(i.read_allowed?).to be true
       end
 
       it "is not readable if no read port given" do
         i = UdpInterface.new('localhost','8888','nil')
         expect(i.name).to eql "Cosmos::UdpInterface"
-        expect(i.write_allowed?).to be_truthy
-        expect(i.write_raw_allowed?).to be_truthy
-        expect(i.read_allowed?).to be_falsey
+        expect(i.write_allowed?).to be true
+        expect(i.write_raw_allowed?).to be true
+        expect(i.read_allowed?).to be false
       end
     end
 
@@ -47,11 +47,11 @@ module Cosmos
         expect(UdpWriteSocket).to receive(:new).and_return(write)
         expect(UdpReadSocket).to receive(:new).and_return(read)
         i = UdpInterface.new('localhost','8888','8889')
-        expect(i.connected?).to be_falsey
+        expect(i.connected?).to be false
         i.connect
-        expect(i.connected?).to be_truthy
+        expect(i.connected?).to be true
         i.disconnect
-        expect(i.connected?).to be_falsey
+        expect(i.connected?).to be false
       end
 
       it "creates a UdpWriteSocket if write port given" do
@@ -61,11 +61,11 @@ module Cosmos
         expect(UdpWriteSocket).to receive(:new).and_return(write)
         expect(UdpReadSocket).to_not receive(:new)
         i = UdpInterface.new('localhost','8888','nil')
-        expect(i.connected?).to be_falsey
+        expect(i.connected?).to be false
         i.connect
-        expect(i.connected?).to be_truthy
+        expect(i.connected?).to be true
         i.disconnect
-        expect(i.connected?).to be_falsey
+        expect(i.connected?).to be false
       end
 
       it "creates a UdpReadSocket if read port given" do
@@ -75,11 +75,11 @@ module Cosmos
         expect(UdpWriteSocket).to_not receive(:new)
         expect(UdpReadSocket).to receive(:new).and_return(read)
         i = UdpInterface.new('localhost','nil','8889')
-        expect(i.connected?).to be_falsey
+        expect(i.connected?).to be false
         i.connect
-        expect(i.connected?).to be_truthy
+        expect(i.connected?).to be true
         i.disconnect
-        expect(i.connected?).to be_falsey
+        expect(i.connected?).to be false
       end
     end
 
@@ -94,11 +94,11 @@ module Cosmos
         expect(UdpWriteSocket).to receive(:new).and_return(write)
         expect(UdpReadSocket).to receive(:new).and_return(read)
         i = UdpInterface.new('localhost','8888','8889')
-        expect(i.connected?).to be_falsey
+        expect(i.connected?).to be false
         i.connect
-        expect(i.connected?).to be_truthy
+        expect(i.connected?).to be true
         i.disconnect
-        expect(i.connected?).to be_falsey
+        expect(i.connected?).to be false
       end
     end
 
@@ -107,7 +107,7 @@ module Cosmos
         i = UdpInterface.new('localhost','8888','nil')
         thread = Thread.new { i.read }
         sleep 0.1
-        expect(thread.stop?).to be_truthy
+        expect(thread.stop?).to be true
         Cosmos.kill_thread(nil, thread)
       end
 
@@ -119,7 +119,7 @@ module Cosmos
         i.connect
         thread = Thread.new { i.read }
         sleep 0.1
-        expect(thread.stop?).to be_truthy
+        expect(thread.stop?).to be true
         Cosmos.kill_thread(nil, thread)
       end
 

data/spec/io/json_drb_spec.rb

@@ -86,7 +86,7 @@ module Cosmos
       it "creates a single listen thread" do
         expect(@json.thread).to be_nil
         @json.start_service('127.0.0.1', 7777, self)
-        expect(@json.thread.alive?).to be_truthy
+        expect(@json.thread.alive?).to be true
         expect { @json.start_service('127.0.0.1', 7777, self) }.to raise_error(/Error binding to port/)
         @json.stop_service
         sleep(0.1)
@@ -114,7 +114,7 @@ module Cosmos
         @json.start_service('127.0.0.1', 7777, self)
         socket = TCPSocket.open('127.0.0.1',7777)
         sleep 0.1
-        expect(socket.eof?).to be_truthy
+        expect(socket.eof?).to be true
         socket.close
         @json.stop_service
         sleep(0.1)
@@ -300,9 +300,9 @@ module Cosmos
     describe "debug, debug?" do
       it "sets the debug level" do
         JsonDRb.debug = true
-        expect(JsonDRb.debug?).to be_truthy
+        expect(JsonDRb.debug?).to be true
         JsonDRb.debug = false
-        expect(JsonDRb.debug?).to be_falsey
+        expect(JsonDRb.debug?).to be false
       end
     end
 

data/spec/io/raw_logger_pair_spec.rb

@@ -20,14 +20,14 @@ module Cosmos
         pair = RawLoggerPair.new('MYINT')
         expect(pair.read_logger).not_to be_nil
         expect(pair.write_logger).not_to be_nil
-        expect(pair.read_logger.logging_enabled).to be_falsey
-        expect(pair.write_logger.logging_enabled).to be_falsey
+        expect(pair.read_logger.logging_enabled).to be false
+        expect(pair.write_logger.logging_enabled).to be false
 
         pair = RawLoggerPair.new('MYINT2', ['raw_logger.rb', true, 100000, './'])
         expect(pair.read_logger).not_to be_nil
         expect(pair.write_logger).not_to be_nil
-        expect(pair.read_logger.logging_enabled).to be_truthy
-        expect(pair.write_logger.logging_enabled).to be_truthy
+        expect(pair.read_logger.logging_enabled).to be true
+        expect(pair.write_logger.logging_enabled).to be true
       end
     end
 
@@ -35,8 +35,8 @@ module Cosmos
       it "starts logging" do
         pair = RawLoggerPair.new('MYINT')
         pair.start
-        expect(pair.write_logger.logging_enabled).to be_truthy
-        expect(pair.read_logger.logging_enabled).to be_truthy
+        expect(pair.write_logger.logging_enabled).to be true
+        expect(pair.read_logger.logging_enabled).to be true
       end
     end
 
@@ -44,30 +44,30 @@ module Cosmos
       it "stops logging" do
         pair = RawLoggerPair.new('MYINT')
         pair.start
-        expect(pair.write_logger.logging_enabled).to be_truthy
-        expect(pair.read_logger.logging_enabled).to be_truthy
+        expect(pair.write_logger.logging_enabled).to be true
+        expect(pair.read_logger.logging_enabled).to be true
         pair.stop
-        expect(pair.write_logger.logging_enabled).to be_falsey
-        expect(pair.read_logger.logging_enabled).to be_falsey
+        expect(pair.write_logger.logging_enabled).to be false
+        expect(pair.read_logger.logging_enabled).to be false
       end
     end
 
     describe "clone" do
       it "clones itself including logging state" do
         pair = RawLoggerPair.new('MYINT')
-        expect(pair.write_logger.logging_enabled).to be_falsey
-        expect(pair.read_logger.logging_enabled).to be_falsey
+        expect(pair.write_logger.logging_enabled).to be false
+        expect(pair.read_logger.logging_enabled).to be false
         pair_clone1 = pair.clone
         pair.start
-        expect(pair.write_logger.logging_enabled).to be_truthy
-        expect(pair.read_logger.logging_enabled).to be_truthy
-        expect(pair_clone1.write_logger.logging_enabled).to be_falsey
-        expect(pair_clone1.read_logger.logging_enabled).to be_falsey
+        expect(pair.write_logger.logging_enabled).to be true
+        expect(pair.read_logger.logging_enabled).to be true
+        expect(pair_clone1.write_logger.logging_enabled).to be false
+        expect(pair_clone1.read_logger.logging_enabled).to be false
         pair_clone2 = pair.clone
-        expect(pair_clone1.write_logger.logging_enabled).to be_falsey
-        expect(pair_clone1.read_logger.logging_enabled).to be_falsey
-        expect(pair_clone2.write_logger.logging_enabled).to be_truthy
-        expect(pair_clone2.read_logger.logging_enabled).to be_truthy
+        expect(pair_clone1.write_logger.logging_enabled).to be false
+        expect(pair_clone1.read_logger.logging_enabled).to be false
+        expect(pair_clone2.write_logger.logging_enabled).to be true
+        expect(pair_clone2.read_logger.logging_enabled).to be true
       end
     end
 

data/spec/io/raw_logger_spec.rb

@@ -117,12 +117,12 @@ module Cosmos
     describe "start and stop" do
       it "enables and disable logging" do
         raw_logger = RawLogger.new('MYINT', :WRITE, false, 200, nil)
-        expect(raw_logger.logging_enabled).to be_falsey
+        expect(raw_logger.logging_enabled).to be false
         raw_logger.start
-        expect(raw_logger.logging_enabled).to be_truthy
+        expect(raw_logger.logging_enabled).to be true
         raw_logger.write("\x00\x01\x02\x03")
         raw_logger.stop
-        expect(raw_logger.logging_enabled).to be_falsey
+        expect(raw_logger.logging_enabled).to be false
         file = Dir[File.join(@log_path,"*.bin")][-1]
         expect(File.size(file)).not_to eql 0
       end

data/spec/io/tcpip_server_spec.rb

@@ -35,12 +35,12 @@ module Cosmos
         server = TcpipServer.new(nil,8889,nil,nil,'Burst')
         server.connect
         sleep 0.2
-        expect(server.connected?).to be_truthy
+        expect(server.connected?).to be true
         # 2 because the RSpec main thread plus the listener
         expect(Thread.list.length).to eql 2
         server.disconnect
         sleep 0.2
-        expect(server.connected?).to be_falsey
+        expect(server.connected?).to be false
         expect(Thread.list.length).to eql 1
       end
 
@@ -48,13 +48,13 @@ module Cosmos
         server = TcpipServer.new(8888,nil,nil,nil,'Burst')
         server.connect
         sleep 0.2
-        expect(server.connected?).to be_truthy
+        expect(server.connected?).to be true
         # 3 because the RSpec main thread plus the listener
         # plus one for the write thread
         expect(Thread.list.length).to eql 3
         server.disconnect
         sleep 0.2
-        expect(server.connected?).to be_falsey
+        expect(server.connected?).to be false
         expect(Thread.list.length).to eql 1
       end
 
@@ -62,13 +62,13 @@ module Cosmos
         server = TcpipServer.new(8888,8888,nil,nil,'Burst')
         server.connect
         sleep 0.2
-        expect(server.connected?).to be_truthy
+        expect(server.connected?).to be true
         # 3 because the RSpec main thread plus the listener
         # plus one for the write thread
         expect(Thread.list.length).to eql 3
         server.disconnect
         sleep 0.2
-        expect(server.connected?).to be_falsey
+        expect(server.connected?).to be false
         expect(Thread.list.length).to eql 1
       end
 
@@ -76,13 +76,13 @@ module Cosmos
         server = TcpipServer.new(8888,8889,nil,nil,'Burst')
         server.connect
         sleep 0.2
-        expect(server.connected?).to be_truthy
+        expect(server.connected?).to be true
         # 4 because the RSpec main thread plus the two listeners
         # plus one for the write thread
         expect(Thread.list.length).to eql 4
         server.disconnect
         sleep 0.2
-        expect(server.connected?).to be_falsey
+        expect(server.connected?).to be false
         expect(Thread.list.length).to eql 1
       end
 
@@ -152,7 +152,7 @@ module Cosmos
           socket = TCPSocket.open("127.0.0.1",8889)
           sleep 0.2
           expect(server.num_clients).to eql 0
-          expect(socket.eof?).to be_truthy
+          expect(socket.eof?).to be true
           server.disconnect
           sleep 0.2
           socket.close

data/spec/io/udp_sockets_spec.rb

@@ -50,8 +50,8 @@ module Cosmos
 
     describe "multicast" do
       it "determines if a host is multicast" do
-        expect(UdpWriteSocket.multicast?('127.0.0.1')).to be_falsey
-        expect(UdpWriteSocket.multicast?('224.0.1.1')).to be_truthy
+        expect(UdpWriteSocket.multicast?('127.0.0.1')).to be false
+        expect(UdpWriteSocket.multicast?('224.0.1.1')).to be true
       end
     end
 

data/spec/io/win32_serial_driver_spec.rb

@@ -46,9 +46,9 @@ module Cosmos
       it "closes the handle" do
         expect(Win32).to receive(:close_handle)
         driver = Win32SerialDriver.new('COM1',9600)
-        expect(driver.closed?).to be_falsey
+        expect(driver.closed?).to be false
         driver.close
-        expect(driver.closed?).to be_truthy
+        expect(driver.closed?).to be true
       end
     end
 

data/spec/packets/binary_accessor_spec.rb

@@ -16,7 +16,7 @@ module Cosmos
 
   describe BinaryAccessor do
 
-    describe "read" do
+    describe "read only" do
 
       before(:each) do
         @data = "\x80\x81\x82\x83\x84\x85\x86\x87\x00\x09\x0A\x0B\x0C\x0D\x0E\x0F"
@@ -240,6 +240,21 @@ module Cosmos
           expect(BinaryAccessor.read(65, bit_size, :INT, @data, :BIG_ENDIAN)).to eql(expected[1])
         end
 
+        it "reads 67-bit unsigned integers" do
+          expected = [0x808182838485868700 >> 5, 0x8700090A0B0C0D0E0F >> 5]
+          bit_size = 67
+          expect(BinaryAccessor.read(0,  bit_size, :UINT, @data, :BIG_ENDIAN)).to eql(expected[0])
+          expect(BinaryAccessor.read(56, bit_size, :UINT, @data, :BIG_ENDIAN)).to eql(expected[1])
+        end
+
+        it "reads 67-bit signed integers" do
+          expected = [0x808182838485868700 >> 5, 0x8700090A0B0C0D0E0F >> 5]
+          bit_size = 67
+          expected.each_with_index { |value, index| expected[index] = value - 2**bit_size if value >= 2**(bit_size - 1) }
+          expect(BinaryAccessor.read(0,  bit_size, :INT, @data, :BIG_ENDIAN)).to eql(expected[0])
+          expect(BinaryAccessor.read(56, bit_size, :INT, @data, :BIG_ENDIAN)).to eql(expected[1])
+        end
+
         it "reads aligned 64-bit unsigned integers" do
           expected_array = [0x8081828384858687, 0x00090A0B0C0D0E0F]
           index = 0
@@ -404,6 +419,19 @@ module Cosmos
           expect(BinaryAccessor.read(57,   bit_size, :INT, @data, :LITTLE_ENDIAN)).to eql(expected[1])
         end
 
+        it "reads 67-bit unsigned integers" do
+          expected = [0x0F0E0D0C0B0A090087 >> 5]
+          bit_size = 67
+          expect(BinaryAccessor.read(120,  bit_size, :UINT, @data, :LITTLE_ENDIAN)).to eql(expected[0])
+        end
+
+        it "reads 67-bit signed integers" do
+          expected = [0x0F0E0D0C0B0A090087 >> 5]
+          bit_size = 67
+          expected.each_with_index { |value, index| expected[index] = value - 2**bit_size if value >= 2**(bit_size - 1) }
+          expect(BinaryAccessor.read(120,  bit_size, :INT, @data, :LITTLE_ENDIAN)).to eql(expected[0])
+        end
+
         it "reads aligned 64-bit unsigned integers" do
           expected_array = [0x8786858483828180, 0x0F0E0D0C0B0A0900]
           index = 0
@@ -677,7 +705,7 @@ module Cosmos
       end # given big endian data
     end # describe "read_array"
 
-    describe "write" do
+    describe "write only" do
 
       before(:each) do
         @data = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
@@ -804,6 +832,36 @@ module Cosmos
         expect { BinaryAccessor.write(@baseline_data, 8, 800, :STRING, @data, :BIG_ENDIAN, :ERROR) }.to raise_error(ArgumentError, "16 byte buffer insufficient to write STRING at bit_offset 8 with bit_size 800")
       end
 
+      it "truncates the buffer for 0 bitsize" do
+        expect(@data.length).to eql 16
+        BinaryAccessor.write("\x01\x02\x03", 8, 0, :BLOCK, @data, :BIG_ENDIAN, :ERROR)
+        expect(@data).to eql("\x00\x01\x02\x03")
+        expect(@data.length).to eql 4
+      end
+
+      it "expands the buffer for 0 bitsize" do
+        expect(@data.length).to eql 16
+        BinaryAccessor.write("\x01\x02\x03", (14 * 8), 0, :BLOCK, @data, :BIG_ENDIAN, :ERROR)
+        expect(@data).to eql("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03")
+        expect(@data.length).to eql 17
+      end
+
+      it "writes a frozen string" do
+        buffer = "BLANKxxxWORLD"
+        string = "HELLO".freeze
+        # Specify 3 more bytes than given to exercise the padding logic
+        string = BinaryAccessor.write(string, 0, (string.length + 3)*8, :STRING, buffer, :BIG_ENDIAN, :ERROR)
+        expect(buffer).to eql("HELLO\x00\x00\x00WORLD")
+        expect(string).to eql("HELLO")
+        expect(string.frozen?).to be true
+      end
+
+      it "complains about writing a frozen buffer" do
+        buffer = "BLANK WORLD".freeze
+        string = "HELLO"
+        expect {BinaryAccessor.write(string, 0, string.length*8, :STRING, buffer, :BIG_ENDIAN, :ERROR) }.to raise_error(RuntimeError, "can't modify frozen String")
+      end
+
       it "writes aligned 8-bit unsigned integers" do
         0.step((@data.length - 1) * 8, 8) do |bit_offset|
           @data = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
@@ -824,6 +882,27 @@ module Cosmos
         end
       end
 
+      it "converts floats when writing integers" do
+        @data = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+        BinaryAccessor.write(1.0, 0, 8, :UINT, @data, :BIG_ENDIAN, :ERROR)
+        BinaryAccessor.write(2.5, 8, 8, :INT, @data, :BIG_ENDIAN, :ERROR)
+        BinaryAccessor.write(4.99, 16, 8, :UINT, @data, :BIG_ENDIAN, :ERROR)
+        expect(@data).to eql("\x01\x02\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+      end
+
+      it "converts integer strings when writing integers" do
+        @data = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+        BinaryAccessor.write("1", 0, 8, :UINT, @data, :BIG_ENDIAN, :ERROR)
+        BinaryAccessor.write("2", 8, 8, :INT, @data, :BIG_ENDIAN, :ERROR)
+        BinaryAccessor.write("4", 16, 8, :UINT, @data, :BIG_ENDIAN, :ERROR)
+        expect(@data).to eql("\x01\x02\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+      end
+
+      it "complains about non-integer strings when writing integers" do
+        expect { BinaryAccessor.write("1.0", 0, 8, :UINT, @data, :BIG_ENDIAN, :ERROR) }.to raise_error(ArgumentError)
+        expect { BinaryAccessor.write("abc123", 0, 8, :UINT, @data, :BIG_ENDIAN, :ERROR) }.to raise_error(ArgumentError)
+      end
+
       describe "given big endian data" do
 
         it "writes 1-bit unsigned integers" do
@@ -834,10 +913,12 @@ module Cosmos
         end
 
         it "writes 1-bit signed integers" do
+          @data[1] = "\x55"
           BinaryAccessor.write(0x1, 8, 1, :INT, @data, :BIG_ENDIAN, :ERROR)
           BinaryAccessor.write(0x0, 9, 1, :INT, @data, :BIG_ENDIAN, :ERROR)
           BinaryAccessor.write(0x1, 10, 1, :INT, @data, :BIG_ENDIAN, :ERROR)
-          expect(@data).to eql("\x00\xA0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+          BinaryAccessor.write(0x0, 11, 1, :INT, @data, :BIG_ENDIAN, :ERROR)
+          expect(@data).to eql("\x00\xA5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
         end
 
         it "writes 7-bit unsigned integers" do
@@ -916,6 +997,11 @@ module Cosmos
           expect(@data).to eql(@baseline_data)
         end
 
+        it "writes aligned 32-bit negative integers" do
+          BinaryAccessor.write(-2147483648, 0, 32, :INT, @data, :BIG_ENDIAN, :ERROR_ALLOW_HEX)
+          expect(@data).to eql("\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+        end
+
         it "writes aligned 32-bit floats" do
           expected_array = [-1.189360e-038, -3.139169e-036, 8.301067e-040, 1.086646e-031]
           BinaryAccessor.write(expected_array[0], 0,  32, :FLOAT, @data, :BIG_ENDIAN, :ERROR)
@@ -941,9 +1027,12 @@ module Cosmos
         end
 
         it "writes 63-bit unsigned integers" do
+          @data[-1] = "\xFF"
           BinaryAccessor.write(0x8081828384858687 >> 1, 0,  63, :UINT, @data, :BIG_ENDIAN, :ERROR)
-          BinaryAccessor.write(0x00090A0B0C0D0E0F, 65, 63, :UINT, @data, :BIG_ENDIAN, :ERROR)
-          expect(@data).to eql("\x80\x81\x82\x83\x84\x85\x86\x86\x00\x09\x0A\x0B\x0C\x0D\x0E\x0F")
+          expect(@data).to eql("\x80\x81\x82\x83\x84\x85\x86\x86\x00\x00\x00\x00\x00\x00\x00\xFF")
+          @data[0] = "\xFF"
+          BinaryAccessor.write(0x08090A0B0C0D0E0F, 65, 63, :UINT, @data, :BIG_ENDIAN, :ERROR)
+          expect(@data).to eql("\xFF\x81\x82\x83\x84\x85\x86\x86\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F")
         end
 
         it "writes 63-bit signed integers" do
@@ -952,6 +1041,16 @@ module Cosmos
           expect(@data).to eql("\x80\x81\x82\x83\x84\x85\x86\x86\x00\x09\x0A\x0B\x0C\x0D\x0E\x0F")
         end
 
+        it "writes 67-bit unsigned integers" do
+          BinaryAccessor.write(0x8081828384858687FF >> 5, 0,  67, :UINT, @data, :BIG_ENDIAN, :ERROR)
+          expect(@data).to eql("\x80\x81\x82\x83\x84\x85\x86\x87\xE0\x00\x00\x00\x00\x00\x00\x00")
+        end
+
+        it "writes 67-bit signed integers" do
+          BinaryAccessor.write((0x8081828384858687FF >> 5) - 2**67, 0,  67, :INT, @data, :BIG_ENDIAN, :ERROR)
+          expect(@data).to eql("\x80\x81\x82\x83\x84\x85\x86\x87\xE0\x00\x00\x00\x00\x00\x00\x00")
+        end
+
         it "writes aligned 64-bit unsigned integers" do
           expected_array = [0x8081828384858687, 0x00090A0B0C0D0E0F]
           index = 0
@@ -982,6 +1081,32 @@ module Cosmos
           expect(BinaryAccessor.read(64, 64, :FLOAT, @data, :BIG_ENDIAN)).to be_within(1.0e-308).of(expected_array[1])
         end
 
+        it "converts integers to floats" do
+          BinaryAccessor.write(1, 0, 32, :FLOAT, @data, :BIG_ENDIAN, :ERROR)
+          value = BinaryAccessor.read(0, 32, :FLOAT, @data, :BIG_ENDIAN)
+          expect(value).to eql(1.0)
+          expect(value).to be_a(Float)
+          BinaryAccessor.write(4, 32, 64, :FLOAT, @data, :BIG_ENDIAN, :ERROR)
+          value = BinaryAccessor.read(32, 64, :FLOAT, @data, :BIG_ENDIAN)
+          expect(value).to eql(4.0)
+          expect(value).to be_a(Float)
+        end
+
+        it "converts strings when writing floats" do
+          BinaryAccessor.write("1", 0, 32, :FLOAT, @data, :BIG_ENDIAN, :ERROR)
+          value = BinaryAccessor.read(0, 32, :FLOAT, @data, :BIG_ENDIAN)
+          expect(value).to eql(1.0)
+          expect(value).to be_a(Float)
+          BinaryAccessor.write("4.5", 32, 64, :FLOAT, @data, :BIG_ENDIAN, :ERROR)
+          value = BinaryAccessor.read(32, 64, :FLOAT, @data, :BIG_ENDIAN)
+          expect(value).to eql(4.5)
+          expect(value).to be_a(Float)
+        end
+
+        it "complains about non-float strings when writing floats" do
+          expect { BinaryAccessor.write("abc123", 0, 32, :FLOAT, @data, :BIG_ENDIAN, :ERROR) }.to raise_error(ArgumentError)
+        end
+
         it "complains about unaligned floats" do
           expect { BinaryAccessor.write(0.0, 17, 32, :FLOAT, @data, :BIG_ENDIAN, :ERROR) }.to raise_error(ArgumentError, "bit_offset 17 is not byte aligned for data_type FLOAT")
         end
@@ -999,10 +1124,12 @@ module Cosmos
         end
 
         it "writes 1-bit unsigned integers" do
+          @data[1] = "\x55"
           BinaryAccessor.write(0x1, 8, 1, :UINT, @data, :LITTLE_ENDIAN, :ERROR)
           BinaryAccessor.write(0x0, 9, 1, :UINT, @data, :LITTLE_ENDIAN, :ERROR)
           BinaryAccessor.write(0x1, 10, 1, :UINT, @data, :LITTLE_ENDIAN, :ERROR)
-          expect(@data).to eql("\x00\xA0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+          BinaryAccessor.write(0x0, 11, 1, :INT, @data, :BIG_ENDIAN, :ERROR)
+          expect(@data).to eql("\x00\xA5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
         end
 
         it "writes 1-bit signed integers" do
@@ -1124,6 +1251,16 @@ module Cosmos
           expect(@data).to eql("\x80\x81\x82\x83\x84\x85\x86\x47\x00\x09\x0A\x0B\x0C\x0D\x0E\x0F")
         end
 
+        it "writes 67-bit unsigned integers" do
+          BinaryAccessor.write(0x0F0E0D0C0B0A0900FF >> 5, 120, 67, :UINT, @data, :LITTLE_ENDIAN, :ERROR)
+          expect(@data).to eql("\x00\x00\x00\x00\x00\x00\x00\xE0\x00\x09\x0A\x0B\x0C\x0D\x0E\x0F")
+        end
+
+        it "writes 67-bit signed integers" do
+          BinaryAccessor.write(0x0F0E0D0C0B0A0900FF >> 5, 120, 67, :INT, @data, :LITTLE_ENDIAN, :ERROR)
+          expect(@data).to eql("\x00\x00\x00\x00\x00\x00\x00\xE0\x00\x09\x0A\x0B\x0C\x0D\x0E\x0F")
+        end
+
         it "writes aligned 64-bit unsigned integers" do
           expected_array = [0x8786858483828180, 0x0F0E0D0C0B0A0900]
           index = 0