cosmos 3.2.1 → 3.3.0

data/spec/io/udp_sockets_spec.rb

@@ -16,30 +16,30 @@ module Cosmos
   describe UdpWriteSocket do
 
     describe "initialize" do
-      it "should create a socket" do
+      it "creates a socket" do
         udp = UdpWriteSocket.new('127.0.0.1', 8888)
-        udp.peeraddr[2].should eql '127.0.0.1'
-        udp.peeraddr[1].should eql 8888
+        expect(udp.peeraddr[2]).to eql '127.0.0.1'
+        expect(udp.peeraddr[1]).to eql 8888
         udp.close
         udp = UdpWriteSocket.new('224.0.1.1', 8888, 7777, '127.0.0.1', 3)
-        udp.local_address.ip_port.should eql 7777
-        udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL).int.should eql 3
-        IPAddr.new_ntoh(udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF).data).to_s.should eql "127.0.0.1"
+        expect(udp.local_address.ip_port).to eql 7777
+        expect(udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL).int).to eql 3
+        expect(IPAddr.new_ntoh(udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF).data).to_s).to eql "127.0.0.1"
         udp.close
       end
     end
 
     describe "write" do
-      it "should write data" do
+      it "writes data" do
         udp_read  = UdpReadSocket.new(8888)
         udp_write = UdpWriteSocket.new('127.0.0.1', 8888)
         udp_write.write("\x01\x02",2.0)
-        udp_read.read.should eql "\x01\x02"
+        expect(udp_read.read).to eql "\x01\x02"
         udp_read.close
         udp_write.close
       end
 
-      it "should handle timeouts" do
+      it "handles timeouts" do
         allow_any_instance_of(UDPSocket).to receive(:write_nonblock) { raise Errno::EWOULDBLOCK }
         expect(IO).to receive(:select).at_least(:once).and_return([], nil)
         udp_write = UdpWriteSocket.new('127.0.0.1', 8888)
@@ -49,9 +49,9 @@ module Cosmos
     end
 
     describe "multicast" do
-      it "should determine if a host is multicast" do
-        UdpWriteSocket.multicast?('127.0.0.1').should be_falsey
-        UdpWriteSocket.multicast?('224.0.1.1').should be_truthy
+      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
       end
     end
 
@@ -60,28 +60,28 @@ module Cosmos
   describe UdpReadSocket do
 
     describe "initialize" do
-      it "should create a socket" do
+      it "creates a socket" do
         udp = UdpReadSocket.new(8888)
-        udp.local_address.ip_address.should eql '0.0.0.0'
-        udp.local_address.ip_port.should eql 8888
+        expect(udp.local_address.ip_address).to eql '0.0.0.0'
+        expect(udp.local_address.ip_port).to eql 8888
         udp.close
         udp = UdpReadSocket.new(8888, '224.0.1.1')
-        IPAddr.new_ntoh(udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF).data).to_s.should eql "0.0.0.0"
+        expect(IPAddr.new_ntoh(udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF).data).to_s).to eql "0.0.0.0"
         udp.close
       end
     end
 
     describe "read" do
-      it "should read data" do
+      it "reads data" do
         udp_read  = UdpReadSocket.new(8888)
         udp_write = UdpWriteSocket.new('127.0.0.1', 8888)
         udp_write.write("\x01\x02",2.0)
-        udp_read.read.should eql "\x01\x02"
+        expect(udp_read.read).to eql "\x01\x02"
         udp_read.close
         udp_write.close
       end
 
-      it "should handle timeouts" do
+      it "handles timeouts" do
         allow_any_instance_of(UDPSocket).to receive(:recvfrom_nonblock) { raise Errno::EWOULDBLOCK }
         expect(IO).to receive(:select).at_least(:once).and_return([], nil)
         udp_read = UdpReadSocket.new(8889)

data/spec/io/win32_serial_driver_spec.rb

@@ -24,18 +24,18 @@ module Cosmos
     end
 
     describe "instance" do
-      it "should enforce the baud rate to a known value" do
+      it "enforces the baud rate to a known value" do
         expect { Win32SerialDriver.new('COM1',10,:NONE) }.to raise_error(ArgumentError, "Invalid baud rate: 10")
       end
 
-      it "should support even, odd, or no parity" do
+      it "supports even, odd, or no parity" do
         expect { Win32SerialDriver.new('COM1',9600,:EVEN) }.to_not raise_error
         expect { Win32SerialDriver.new('COM1',9600,:ODD) }.to_not raise_error
         expect { Win32SerialDriver.new('COM1',9600,:NONE) }.to_not raise_error
         expect { Win32SerialDriver.new('COM1',9600,:BLAH) }.to raise_error(ArgumentError, "Invalid parity: BLAH")
       end
 
-      it "should support 1 or 2 stop bits" do
+      it "supports 1 or 2 stop bits" do
         expect { Win32SerialDriver.new('COM1',9600,:NONE,1) }.to_not raise_error
         expect { Win32SerialDriver.new('COM1',9600,:NONE,2) }.to_not raise_error
         expect { Win32SerialDriver.new('COM1',9600,:NONE,3) }.to raise_error(ArgumentError, "Invalid stop bits: 3")
@@ -43,23 +43,23 @@ module Cosmos
     end
 
     describe "close, closed?" do
-      it "should close the handle" do
+      it "closes the handle" do
         expect(Win32).to receive(:close_handle)
         driver = Win32SerialDriver.new('COM1',9600)
-        driver.closed?.should be_falsey
+        expect(driver.closed?).to be_falsey
         driver.close
-        driver.closed?.should be_truthy
+        expect(driver.closed?).to be_truthy
       end
     end
 
     describe "write" do
-      it "should handle write errors" do
+      it "handles write errors" do
         expect(Win32).to receive(:write_file).and_return 0
         driver = Win32SerialDriver.new('COM1',9600)
         expect { driver.write('\x00') }.to raise_error("Error writing to comm port")
       end
 
-      it "should use the write timeout" do
+      it "uses the write timeout" do
         expect(Win32).to receive(:write_file) do
           sleep 2
           1
@@ -73,10 +73,10 @@ module Cosmos
       it "return the data read" do
         expect(Win32).to receive(:read_file) { '\x00' }
         driver = Win32SerialDriver.new('COM1',9600,:NONE,1,1,nil,0.01,1)
-        driver.read.should eql '\x00'
+        expect(driver.read).to eql '\x00'
       end
 
-      it "should use the read timeout" do
+      it "uses the read timeout" do
         allow(Win32).to receive(:read_file) { '' }
         driver = Win32SerialDriver.new('COM1',9600,:NONE,1,1,1.0,0.5,10)
         expect { driver.read }.to raise_error(Timeout::Error)

data/spec/packet_logs/meta_packet_log_writer_spec.rb

@@ -26,7 +26,7 @@ module Cosmos
       clean_config()
     end
 
-    it "should create a command log writer" do
+    it "creates a command log writer" do
       meta_packet = System.commands.packet('META', 'DATA')
       meta_packet.write('VERSION', 'Great Version')
       meta_packet.write('NUMBER', 5)
@@ -44,19 +44,19 @@ module Cosmos
       count = 0
       reader.each(filename) do |packet|
         if count == 0
-          packet.target_name.should eql('META')
-          packet.packet_name.should eql('DATA')
-          packet.read('VERSION').should eql('Great Version')
-          packet.read('NUMBER').should eql(5)
+          expect(packet.target_name).to eql('META')
+          expect(packet.packet_name).to eql('DATA')
+          expect(packet.read('VERSION')).to eql('Great Version')
+          expect(packet.read('NUMBER')).to eql(5)
         else
-          packet.target_name.should eql('INST')
-          packet.packet_name.should eql('ABORT')
+          expect(packet.target_name).to eql('INST')
+          expect(packet.packet_name).to eql('ABORT')
         end
         count += 1
       end
     end
 
-    it "should create a telemetry log writer" do
+    it "creates a telemetry log writer" do
       meta_packet = System.telemetry.packet('META', 'DATA')
       meta_packet.write('VERSION', 'Good Version')
       meta_packet.write('NUMBER', 3)
@@ -76,20 +76,20 @@ module Cosmos
       count = 0
       reader.each(filename) do |packet|
         if count == 0 or count == 2
-          packet.target_name.should eql('META')
-          packet.packet_name.should eql('DATA')
-          packet.read('VERSION').should eql('Good Version')
-          packet.read('NUMBER').should eql(3)
+          expect(packet.target_name).to eql('META')
+          expect(packet.packet_name).to eql('DATA')
+          expect(packet.read('VERSION')).to eql('Good Version')
+          expect(packet.read('NUMBER')).to eql(3)
         else
-          packet.target_name.should eql('INST')
-          packet.packet_name.should eql('ADCS')
+          expect(packet.target_name).to eql('INST')
+          expect(packet.packet_name).to eql('ADCS')
         end
         count += 1
       end
-      count.should eql 3
+      expect(count).to eql 3
     end
 
-    it "should not log metadata packets if configured not to" do
+    it "does not log metadata packets if configured not to" do
       meta_packet = System.telemetry.packet('META', 'DATA')
       meta_packet.write('VERSION', 'Good Version')
       meta_packet.write('NUMBER', 1)
@@ -110,20 +110,20 @@ module Cosmos
       count = 0
       reader.each(filename) do |packet|
         if count == 0
-          packet.target_name.should eql('META')
-          packet.packet_name.should eql('DATA')
-          packet.read('VERSION').should eql('Good Version')
-          packet.read('NUMBER').should eql(1)
+          expect(packet.target_name).to eql('META')
+          expect(packet.packet_name).to eql('DATA')
+          expect(packet.read('VERSION')).to eql('Good Version')
+          expect(packet.read('NUMBER')).to eql(1)
         else
-          packet.target_name.should eql('INST')
-          packet.packet_name.should eql('ADCS')
+          expect(packet.target_name).to eql('INST')
+          expect(packet.packet_name).to eql('ADCS')
         end
         count += 1
       end
-      count.should eql(2)
+      expect(count).to eql(2)
     end
 
-    it "should initialize the meta packet if configured to" do
+    it "initializes the meta packet if configured to" do
       tf = Tempfile.new('unittest')
       tf.puts("VERSION 'Ok Version'")
       tf.puts("NUMBER 11")
@@ -148,21 +148,21 @@ module Cosmos
       count = 0
       reader.each(filename) do |packet|
         if count == 0
-          packet.target_name.should eql('META')
-          packet.packet_name.should eql('DATA')
-          packet.read('VERSION').should eql('Ok Version')
-          packet.read('NUMBER').should eql(11)
+          expect(packet.target_name).to eql('META')
+          expect(packet.packet_name).to eql('DATA')
+          expect(packet.read('VERSION')).to eql('Ok Version')
+          expect(packet.read('NUMBER')).to eql(11)
         else
-          packet.target_name.should eql('INST')
-          packet.packet_name.should eql('ADCS')
+          expect(packet.target_name).to eql('INST')
+          expect(packet.packet_name).to eql('ADCS')
         end
         count += 1
       end
-      count.should eql(2)
+      expect(count).to eql(2)
       tf.unlink
     end
 
-    it "should complain if the packet does not exist" do
+    it "complains if the packet does not exist" do
       expect {plw = MetaPacketLogWriter.new(:CMD,'INST','ADCS',nil,true,true)}.to raise_error(RuntimeError)
       expect {plw = MetaPacketLogWriter.new(:CMD,'INST','ABORT',nil,true,true)}.to raise_error(RuntimeError)
     end

data/spec/packet_logs/packet_log_reader_spec.rb

@@ -70,15 +70,15 @@ module Cosmos
     end
 
     describe "initialize" do
-      it "should create a command log writer" do
-        @plr.log_type.should eql :TLM
-        @plr.configuration_name.should be_nil
-        @plr.hostname.should be_nil
+      it "creates a command log writer" do
+        expect(@plr.log_type).to eql :TLM
+        expect(@plr.configuration_name).to be_nil
+        expect(@plr.hostname).to be_nil
       end
     end
 
     describe "open" do
-      it "should complain if the log file is too small" do
+      it "complains if the log file is too small" do
         tf = Tempfile.new('log_file')
         tf.puts "BLAH"
         tf.close
@@ -86,7 +86,7 @@ module Cosmos
         tf.unlink
       end
 
-      it "should complain if the log does not have a COSMOS header" do
+      it "complains if the log does not have a COSMOS header" do
         pkt = System.telemetry.packet("COSMOS","VERSION").clone
         filename = File.join(@log_path,'test.bin')
         File.open(filename,'wb') do |file|
@@ -98,7 +98,7 @@ module Cosmos
         expect { @plr.open(filename) }.to raise_error(/file header not found/)
       end
 
-      it "should complain if the log is not CMD or TLM" do
+      it "complains if the log is not CMD or TLM" do
         pkt = System.telemetry.packet("COSMOS","VERSION").clone
         filename = File.join(@log_path,'test.bin')
         File.open(filename,'wb') do |file|
@@ -110,7 +110,7 @@ module Cosmos
         expect { @plr.open(filename) }.to raise_error("Unknown log type BOT")
       end
 
-      it "should open COSMOS1 log files" do
+      it "opens COSMOS1 log files" do
         pkt = System.telemetry.packet("COSMOS","VERSION").clone
         filename = File.join(@log_path,'test.bin')
         File.open(filename,'wb') do |file|
@@ -127,278 +127,278 @@ module Cosmos
         end
         @plr.open(filename)
         pkt1 = @plr.read
-        pkt1.target_name.should eql 'TGT1'
-        pkt1.packet_name.should eql 'PKT1'
+        expect(pkt1.target_name).to eql 'TGT1'
+        expect(pkt1.packet_name).to eql 'PKT1'
         pkt2 = @plr.read
-        pkt2.target_name.should eql 'TGT2'
-        pkt2.packet_name.should eql 'PKT2'
+        expect(pkt2.target_name).to eql 'TGT2'
+        expect(pkt2.packet_name).to eql 'PKT2'
         pkt3 = @plr.read
-        pkt3.target_name.should eql 'TGT3'
-        pkt3.packet_name.should eql 'PKT3'
+        expect(pkt3.target_name).to eql 'TGT3'
+        expect(pkt3.packet_name).to eql 'PKT3'
         @plr.close
       end
     end
 
     describe "packet_offsets and read_at_offset" do
-      it "should return packet offsets CTS-20, CTS-22" do
+      it "returns packet offsets CTS-20, CTS-22" do
         packet_offsets = @plr.packet_offsets(Dir[File.join(@log_path,"*cmd.bin")][0])
-        @plr.log_type.should eql :CMD
-        @plr.configuration_name.should_not be_nil
-        @plr.hostname.should eql Socket.gethostname
+        expect(@plr.log_type).to eql :CMD
+        expect(@plr.configuration_name).not_to be_nil
+        expect(@plr.hostname).to eql Socket.gethostname
         header_length = 8 + 1 + 6 + 1 + 12 + 4
-        packet_offsets.should eql [PacketLogReader::COSMOS2_HEADER_LENGTH, PacketLogReader::COSMOS2_HEADER_LENGTH + header_length + @cmd_packet_length, PacketLogReader::COSMOS2_HEADER_LENGTH + (header_length + @cmd_packet_length) * 2]
+        expect(packet_offsets).to eql [PacketLogReader::COSMOS2_HEADER_LENGTH, PacketLogReader::COSMOS2_HEADER_LENGTH + header_length + @cmd_packet_length, PacketLogReader::COSMOS2_HEADER_LENGTH + (header_length + @cmd_packet_length) * 2]
 
         @plr.open(Dir[File.join(@log_path,"*cmd.bin")][0])
         pkt = @plr.read_at_offset(packet_offsets[1])
-        pkt.target_name.should eql "COSMOS"
-        pkt.packet_name.should eql "STARTLOGGING"
-        pkt.received_time.should eql Time.new(2020,1,31,12,30,16)
+        expect(pkt.target_name).to eql "COSMOS"
+        expect(pkt.packet_name).to eql "STARTLOGGING"
+        expect(pkt.received_time).to eql Time.new(2020,1,31,12,30,16)
         @plr.close
       end
 
-      it "should return telemetry packet information" do
+      it "returns telemetry packet information" do
         packet_offsets = @plr.packet_offsets(Dir[File.join(@log_path,"*tlm.bin")][0])
-        @plr.log_type.should eql :TLM
-        @plr.configuration_name.should_not be_nil
-        @plr.hostname.should eql Socket.gethostname
+        expect(@plr.log_type).to eql :TLM
+        expect(@plr.configuration_name).not_to be_nil
+        expect(@plr.hostname).to eql Socket.gethostname
         header_length = 8 + 1 + 6 + 1 + 7 + 4
-        packet_offsets.should eql [PacketLogReader::COSMOS2_HEADER_LENGTH, PacketLogReader::COSMOS2_HEADER_LENGTH + header_length + @tlm_packet_length, PacketLogReader::COSMOS2_HEADER_LENGTH + (header_length + @tlm_packet_length) * 2]
+        expect(packet_offsets).to eql [PacketLogReader::COSMOS2_HEADER_LENGTH, PacketLogReader::COSMOS2_HEADER_LENGTH + header_length + @tlm_packet_length, PacketLogReader::COSMOS2_HEADER_LENGTH + (header_length + @tlm_packet_length) * 2]
 
         @plr.open(Dir[File.join(@log_path,"*tlm.bin")][0])
         pkt = @plr.read_at_offset(packet_offsets[1])
-        pkt.target_name.should eql "COSMOS"
-        pkt.packet_name.should eql "VERSION"
-        pkt.received_time.should eql Time.new(2020,2,1,12,30,16)
+        expect(pkt.target_name).to eql "COSMOS"
+        expect(pkt.packet_name).to eql "VERSION"
+        expect(pkt.received_time).to eql Time.new(2020,2,1,12,30,16)
         @plr.close
       end
     end
 
     describe "each" do
-      it "should return packets" do
+      it "returns packets" do
         index = 0
         bytes_read = 208
         @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0]) do |packet|
-          packet.target_name.should eql @cmd_packets[index].target_name
-          packet.packet_name.should eql @cmd_packets[index].packet_name
-          packet.received_time.should eql @cmd_packets[index].received_time
-          packet.read('LABEL').should eql @cmd_packets[index].read('LABEL')
-          @plr.bytes_read.should eql bytes_read
+          expect(packet.target_name).to eql @cmd_packets[index].target_name
+          expect(packet.packet_name).to eql @cmd_packets[index].packet_name
+          expect(packet.received_time).to eql @cmd_packets[index].received_time
+          expect(packet.read('LABEL')).to eql @cmd_packets[index].read('LABEL')
+          expect(@plr.bytes_read).to eql bytes_read
           bytes_read += 80
           index += 1
         end
         index = 0
         bytes_read = 276
         @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0]) do |packet|
-          packet.target_name.should eql @tlm_packets[index].target_name
-          packet.packet_name.should eql @tlm_packets[index].packet_name
-          packet.received_time.should eql @tlm_packets[index].received_time
-          packet.read('COSMOS').should eql @tlm_packets[index].read('COSMOS')
-          @plr.bytes_read.should eql bytes_read
+          expect(packet.target_name).to eql @tlm_packets[index].target_name
+          expect(packet.packet_name).to eql @tlm_packets[index].packet_name
+          expect(packet.received_time).to eql @tlm_packets[index].received_time
+          expect(packet.read('COSMOS')).to eql @tlm_packets[index].read('COSMOS')
+          expect(@plr.bytes_read).to eql bytes_read
           bytes_read += 148
           index += 1
         end
       end
 
-      it "should optionally not identify and define packets" do
+      it "optionallies not identify and define packets" do
         index = 0
         @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], false) do |packet|
-          packet.target_name.should eql @cmd_packets[index].target_name
-          packet.packet_name.should eql @cmd_packets[index].packet_name
-          packet.received_time.should eql @cmd_packets[index].received_time
+          expect(packet.target_name).to eql @cmd_packets[index].target_name
+          expect(packet.packet_name).to eql @cmd_packets[index].packet_name
+          expect(packet.received_time).to eql @cmd_packets[index].received_time
           expect { packet.read('LABEL') }.to raise_error(/does not exist/)
           index += 1
         end
         index = 0
         @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], false) do |packet|
-          packet.target_name.should eql @tlm_packets[index].target_name
-          packet.packet_name.should eql @tlm_packets[index].packet_name
-          packet.received_time.should eql @tlm_packets[index].received_time
+          expect(packet.target_name).to eql @tlm_packets[index].target_name
+          expect(packet.packet_name).to eql @tlm_packets[index].packet_name
+          expect(packet.received_time).to eql @tlm_packets[index].received_time
           expect { packet.read('COSMOS') }.to raise_error(/does not exist/)
           index += 1
         end
       end
 
-      it "should return all packets if the start time is before all" do
+      it "returns all packets if the start time is before all" do
         time = Time.new(2000,1,31,12,30,16)
         index = 0
         @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, time) do |packet|
-          packet.target_name.should eql @cmd_packets[index].target_name
-          packet.packet_name.should eql @cmd_packets[index].packet_name
-          packet.received_time.should eql @cmd_packets[index].received_time
-          packet.read('LABEL').should eql @cmd_packets[index].read('LABEL')
+          expect(packet.target_name).to eql @cmd_packets[index].target_name
+          expect(packet.packet_name).to eql @cmd_packets[index].packet_name
+          expect(packet.received_time).to eql @cmd_packets[index].received_time
+          expect(packet.read('LABEL')).to eql @cmd_packets[index].read('LABEL')
           index += 1
         end
-        index.should eql 3
+        expect(index).to eql 3
       end
 
-      it "should return no packets if the start time is after all" do
+      it "returns no packets if the start time is after all" do
         time = Time.new(2030,2,1,12,30,16)
         index = 0
         @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, time) do |packet|
           index += 1
         end
-        index.should eql 0
+        expect(index).to eql 0
       end
 
-      it "should return all packets after a start time" do
+      it "returns all packets after a start time" do
         time = Time.new(2020,1,31,12,30,16)
         index = 0
         @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, time) do |packet|
-          packet.target_name.should eql @cmd_packets[index+1].target_name
-          packet.packet_name.should eql @cmd_packets[index+1].packet_name
-          packet.received_time.should eql @cmd_packets[index+1].received_time
-          packet.read('LABEL').should eql @cmd_packets[index+1].read('LABEL')
+          expect(packet.target_name).to eql @cmd_packets[index+1].target_name
+          expect(packet.packet_name).to eql @cmd_packets[index+1].packet_name
+          expect(packet.received_time).to eql @cmd_packets[index+1].received_time
+          expect(packet.read('LABEL')).to eql @cmd_packets[index+1].read('LABEL')
           index += 1
         end
-        index.should eql 2
+        expect(index).to eql 2
 
         time = Time.new(2020,2,1,12,30,16)
         index = 0
         @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, time) do |packet|
-          packet.target_name.should eql @tlm_packets[index+1].target_name
-          packet.packet_name.should eql @tlm_packets[index+1].packet_name
-          packet.received_time.should eql @tlm_packets[index+1].received_time
-          packet.read('COSMOS').should eql @tlm_packets[index+1].read('COSMOS')
+          expect(packet.target_name).to eql @tlm_packets[index+1].target_name
+          expect(packet.packet_name).to eql @tlm_packets[index+1].packet_name
+          expect(packet.received_time).to eql @tlm_packets[index+1].received_time
+          expect(packet.read('COSMOS')).to eql @tlm_packets[index+1].read('COSMOS')
           index += 1
         end
-        index.should eql 2
+        expect(index).to eql 2
       end
 
-      it "should return no packets if the end time is before all" do
+      it "returns no packets if the end time is before all" do
         time = Time.new(2000,1,31,12,30,16)
         index = 0
         @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, nil, time) do |packet|
           index += 1
         end
-        index.should eql 0
+        expect(index).to eql 0
       end
 
-      it "should return all packets if the end time is after all" do
+      it "returns all packets if the end time is after all" do
         time = Time.new(2030,2,1,12,30,16)
         index = 0
         @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, nil, time) do |packet|
-          packet.target_name.should eql @cmd_packets[index].target_name
-          packet.packet_name.should eql @cmd_packets[index].packet_name
-          packet.received_time.should eql @cmd_packets[index].received_time
-          packet.read('LABEL').should eql @cmd_packets[index].read('LABEL')
+          expect(packet.target_name).to eql @cmd_packets[index].target_name
+          expect(packet.packet_name).to eql @cmd_packets[index].packet_name
+          expect(packet.received_time).to eql @cmd_packets[index].received_time
+          expect(packet.read('LABEL')).to eql @cmd_packets[index].read('LABEL')
           index += 1
         end
-        index.should eql 3
+        expect(index).to eql 3
       end
 
-      it "should return all packets before an end time" do
+      it "returns all packets before an end time" do
         time = Time.new(2020,1,31,12,30,16)
         index = 0
         @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, nil, time) do |packet|
-          packet.target_name.should eql @cmd_packets[index].target_name
-          packet.packet_name.should eql @cmd_packets[index].packet_name
-          packet.received_time.should eql @cmd_packets[index].received_time
-          packet.read('LABEL').should eql @cmd_packets[index].read('LABEL')
+          expect(packet.target_name).to eql @cmd_packets[index].target_name
+          expect(packet.packet_name).to eql @cmd_packets[index].packet_name
+          expect(packet.received_time).to eql @cmd_packets[index].received_time
+          expect(packet.read('LABEL')).to eql @cmd_packets[index].read('LABEL')
           index += 1
         end
-        index.should eql 2
+        expect(index).to eql 2
 
         time = Time.new(2020,2,1,12,30,16)
         index = 0
         @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, nil, time) do |packet|
-          packet.target_name.should eql @tlm_packets[index].target_name
-          packet.packet_name.should eql @tlm_packets[index].packet_name
-          packet.received_time.should eql @tlm_packets[index].received_time
-          packet.read('COSMOS').should eql @tlm_packets[index].read('COSMOS')
+          expect(packet.target_name).to eql @tlm_packets[index].target_name
+          expect(packet.packet_name).to eql @tlm_packets[index].packet_name
+          expect(packet.received_time).to eql @tlm_packets[index].received_time
+          expect(packet.read('COSMOS')).to eql @tlm_packets[index].read('COSMOS')
           index += 1
         end
-        index.should eql 2
+        expect(index).to eql 2
       end
    end
 
     describe "first" do
-      it "should return the first command packet and retain the file position" do
+      it "returns the first command packet and retain the file position" do
         @plr.open(Dir[File.join(@log_path,"*cmd.bin")][0])
         pkt1 = @plr.read
-        pkt1.target_name.should eql @cmd_packets[0].target_name
-        pkt1.packet_name.should eql @cmd_packets[0].packet_name
-        pkt1.received_time.should eql @cmd_packets[0].received_time
-        pkt1.read('LABEL').should eql @cmd_packets[0].read('LABEL')
+        expect(pkt1.target_name).to eql @cmd_packets[0].target_name
+        expect(pkt1.packet_name).to eql @cmd_packets[0].packet_name
+        expect(pkt1.received_time).to eql @cmd_packets[0].received_time
+        expect(pkt1.read('LABEL')).to eql @cmd_packets[0].read('LABEL')
 
         first = @plr.first
-        first.target_name.should eql @cmd_packets[0].target_name
-        first.packet_name.should eql @cmd_packets[0].packet_name
-        first.received_time.should eql @cmd_packets[0].received_time
-        first.read('LABEL').should eql @cmd_packets[0].read('LABEL')
+        expect(first.target_name).to eql @cmd_packets[0].target_name
+        expect(first.packet_name).to eql @cmd_packets[0].packet_name
+        expect(first.received_time).to eql @cmd_packets[0].received_time
+        expect(first.read('LABEL')).to eql @cmd_packets[0].read('LABEL')
 
         pkt2 = @plr.read
-        pkt2.target_name.should eql @cmd_packets[1].target_name
-        pkt2.packet_name.should eql @cmd_packets[1].packet_name
-        pkt2.received_time.should eql @cmd_packets[1].received_time
-        pkt2.read('LABEL').should eql @cmd_packets[1].read('LABEL')
+        expect(pkt2.target_name).to eql @cmd_packets[1].target_name
+        expect(pkt2.packet_name).to eql @cmd_packets[1].packet_name
+        expect(pkt2.received_time).to eql @cmd_packets[1].received_time
+        expect(pkt2.read('LABEL')).to eql @cmd_packets[1].read('LABEL')
         @plr.close
       end
 
-      it "should return the first telemetry packet and retain the file position" do
+      it "returns the first telemetry packet and retain the file position" do
         @plr.open(Dir[File.join(@log_path,"*tlm.bin")][0])
         pkt1 = @plr.read
-        pkt1.target_name.should eql @tlm_packets[0].target_name
-        pkt1.packet_name.should eql @tlm_packets[0].packet_name
-        pkt1.received_time.should eql @tlm_packets[0].received_time
-        pkt1.read('COSMOS').should eql @tlm_packets[0].read('COSMOS')
+        expect(pkt1.target_name).to eql @tlm_packets[0].target_name
+        expect(pkt1.packet_name).to eql @tlm_packets[0].packet_name
+        expect(pkt1.received_time).to eql @tlm_packets[0].received_time
+        expect(pkt1.read('COSMOS')).to eql @tlm_packets[0].read('COSMOS')
 
         first = @plr.first
-        first.target_name.should eql @tlm_packets[0].target_name
-        first.packet_name.should eql @tlm_packets[0].packet_name
-        first.received_time.should eql @tlm_packets[0].received_time
-        first.read('COSMOS').should eql @tlm_packets[0].read('COSMOS')
+        expect(first.target_name).to eql @tlm_packets[0].target_name
+        expect(first.packet_name).to eql @tlm_packets[0].packet_name
+        expect(first.received_time).to eql @tlm_packets[0].received_time
+        expect(first.read('COSMOS')).to eql @tlm_packets[0].read('COSMOS')
 
         pkt2 = @plr.read
-        pkt2.target_name.should eql @tlm_packets[1].target_name
-        pkt2.packet_name.should eql @tlm_packets[1].packet_name
-        pkt2.received_time.should eql @tlm_packets[1].received_time
-        pkt2.read('COSMOS').should eql @tlm_packets[1].read('COSMOS')
+        expect(pkt2.target_name).to eql @tlm_packets[1].target_name
+        expect(pkt2.packet_name).to eql @tlm_packets[1].packet_name
+        expect(pkt2.received_time).to eql @tlm_packets[1].received_time
+        expect(pkt2.read('COSMOS')).to eql @tlm_packets[1].read('COSMOS')
         @plr.close
       end
     end
 
     describe "last" do
-      it "should return the last command packet and retain the file position" do
+      it "returns the last command packet and retain the file position" do
         @plr.open(Dir[File.join(@log_path,"*cmd.bin")][0])
         pkt1 = @plr.read
-        pkt1.target_name.should eql @cmd_packets[0].target_name
-        pkt1.packet_name.should eql @cmd_packets[0].packet_name
-        pkt1.received_time.should eql @cmd_packets[0].received_time
-        pkt1.read('LABEL').should eql @cmd_packets[0].read('LABEL')
+        expect(pkt1.target_name).to eql @cmd_packets[0].target_name
+        expect(pkt1.packet_name).to eql @cmd_packets[0].packet_name
+        expect(pkt1.received_time).to eql @cmd_packets[0].received_time
+        expect(pkt1.read('LABEL')).to eql @cmd_packets[0].read('LABEL')
 
         last = @plr.last
-        last.target_name.should eql @cmd_packets[2].target_name
-        last.packet_name.should eql @cmd_packets[2].packet_name
-        last.received_time.should eql @cmd_packets[2].received_time
-        last.read('LABEL').should eql @cmd_packets[2].read('LABEL')
+        expect(last.target_name).to eql @cmd_packets[2].target_name
+        expect(last.packet_name).to eql @cmd_packets[2].packet_name
+        expect(last.received_time).to eql @cmd_packets[2].received_time
+        expect(last.read('LABEL')).to eql @cmd_packets[2].read('LABEL')
 
         pkt2 = @plr.read
-        pkt2.target_name.should eql @cmd_packets[1].target_name
-        pkt2.packet_name.should eql @cmd_packets[1].packet_name
-        pkt2.received_time.should eql @cmd_packets[1].received_time
-        pkt2.read('LABEL').should eql @cmd_packets[1].read('LABEL')
+        expect(pkt2.target_name).to eql @cmd_packets[1].target_name
+        expect(pkt2.packet_name).to eql @cmd_packets[1].packet_name
+        expect(pkt2.received_time).to eql @cmd_packets[1].received_time
+        expect(pkt2.read('LABEL')).to eql @cmd_packets[1].read('LABEL')
         @plr.close
       end
 
-      it "should return the last telemetry packet and retain the file position" do
+      it "returns the last telemetry packet and retain the file position" do
         @plr.open(Dir[File.join(@log_path,"*tlm.bin")][0])
         pkt1 = @plr.read
-        pkt1.target_name.should eql @tlm_packets[0].target_name
-        pkt1.packet_name.should eql @tlm_packets[0].packet_name
-        pkt1.received_time.should eql @tlm_packets[0].received_time
-        pkt1.read('COSMOS').should eql @tlm_packets[0].read('COSMOS')
+        expect(pkt1.target_name).to eql @tlm_packets[0].target_name
+        expect(pkt1.packet_name).to eql @tlm_packets[0].packet_name
+        expect(pkt1.received_time).to eql @tlm_packets[0].received_time
+        expect(pkt1.read('COSMOS')).to eql @tlm_packets[0].read('COSMOS')
 
         last = @plr.last
-        last.target_name.should eql @tlm_packets[2].target_name
-        last.packet_name.should eql @tlm_packets[2].packet_name
-        last.received_time.should eql @tlm_packets[2].received_time
-        last.read('COSMOS').should eql @tlm_packets[2].read('COSMOS')
+        expect(last.target_name).to eql @tlm_packets[2].target_name
+        expect(last.packet_name).to eql @tlm_packets[2].packet_name
+        expect(last.received_time).to eql @tlm_packets[2].received_time
+        expect(last.read('COSMOS')).to eql @tlm_packets[2].read('COSMOS')
 
         pkt2 = @plr.read
-        pkt2.target_name.should eql @tlm_packets[1].target_name
-        pkt2.packet_name.should eql @tlm_packets[1].packet_name
-        pkt2.received_time.should eql @tlm_packets[1].received_time
-        pkt2.read('COSMOS').should eql @tlm_packets[1].read('COSMOS')
+        expect(pkt2.target_name).to eql @tlm_packets[1].target_name
+        expect(pkt2.packet_name).to eql @tlm_packets[1].packet_name
+        expect(pkt2.received_time).to eql @tlm_packets[1].received_time
+        expect(pkt2.read('COSMOS')).to eql @tlm_packets[1].read('COSMOS')
         @plr.close
       end
     end