cosmos 4.2.4-java → 4.3.0-java

data/spec/io/serial_driver_spec.rb

@@ -41,20 +41,22 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
         end
 
         it "defers to the posix serial driver on nix" do
-          class PosixSerialDriver
+          if RUBY_ENGINE == 'ruby'
+            class PosixSerialDriver
+            end
+            allow(Kernel).to receive(:is_windows?).and_return(false)
+            driver = double("PosixSerialDriver")
+            expect(driver).to receive(:close)
+            expect(driver).to receive(:closed?)
+            expect(driver).to receive(:write)
+            expect(driver).to receive(:read)
+            allow(PosixSerialDriver).to receive(:new).and_return(driver)
+            driver = SerialDriver.new('COM1',9600)
+            driver.close
+            driver.closed?
+            driver.write("hi")
+            driver.read
           end
-          allow(Kernel).to receive(:is_windows?).and_return(false)
-          driver = double("PosixSerialDriver")
-          expect(driver).to receive(:close)
-          expect(driver).to receive(:closed?)
-          expect(driver).to receive(:write)
-          expect(driver).to receive(:read)
-          allow(PosixSerialDriver).to receive(:new).and_return(driver)
-          driver = SerialDriver.new('COM1',9600)
-          driver.close
-          driver.closed?
-          driver.write("hi")
-          driver.read
         end
       end
     end

data/spec/packet_logs/packet_log_reader_spec.rb

@@ -133,6 +133,34 @@ module Cosmos
         expect(pkt3.packet_name).to eql 'PKT3'
         @plr.close
       end
+
+      it "opens COSMOS2 log files" do
+        pkt = System.telemetry.packet("SYSTEM","LIMITS_CHANGE").clone
+        filename = File.join(@log_path,'test.bin')
+        File.open(filename,'wb') do |file|
+          file.write ("COSMOS2_CMD                             TEST " + (" " * 83))
+          file.write [1000,100,4,"TGT1",4,"PKT1"].pack('NNCA4CA4')
+          file.write [pkt.buffer.length].pack('N')
+          file.write pkt.buffer
+          file.write [1000,100,4,"TGT2",4,"PKT2"].pack('NNCA4CA4')
+          file.write [pkt.buffer.length].pack('N')
+          file.write pkt.buffer
+          file.write [1000,100,4,"TGT3",4,"PKT3"].pack('NNCA4CA4')
+          file.write [pkt.buffer.length].pack('N')
+          file.write pkt.buffer
+        end
+        expect(@plr.open(filename)).to eql [false, nil]
+        pkt1 = @plr.read
+        expect(pkt1.target_name).to eql 'TGT1'
+        expect(pkt1.packet_name).to eql 'PKT1'
+        pkt2 = @plr.read
+        expect(pkt2.target_name).to eql 'TGT2'
+        expect(pkt2.packet_name).to eql 'PKT2'
+        pkt3 = @plr.read
+        expect(pkt3.target_name).to eql 'TGT3'
+        expect(pkt3.packet_name).to eql 'PKT3'
+        @plr.close
+      end
     end
 
     it "handles saved configuration with errors" do
@@ -205,10 +233,10 @@ module Cosmos
         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
-        meta_header_length = 8 + 1 + 6 + 1 + 4 + 4
+        header_length = 1 + 8 + 1 + 6 + 1 + 12 + 4
+        meta_header_length = 1 + 8 + 1 + 6 + 1 + 4 + 4
         meta_length = System.telemetry.packet('SYSTEM', 'META').length
-        expect(packet_offsets).to eql [PacketLogReader::COSMOS2_HEADER_LENGTH, PacketLogReader::COSMOS2_HEADER_LENGTH + meta_header_length + meta_length, PacketLogReader::COSMOS2_HEADER_LENGTH + meta_header_length + meta_length + header_length + @cmd_packet_length, PacketLogReader::COSMOS2_HEADER_LENGTH + meta_header_length + meta_length + (header_length + @cmd_packet_length) * 2]
+        expect(packet_offsets).to eql [PacketLogReader::COSMOS4_HEADER_LENGTH, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length + header_length + @cmd_packet_length, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length + (header_length + @cmd_packet_length) * 2]
 
         expect(@plr.open(Dir[File.join(@log_path,"*cmd.bin")][0])).to eql [true, nil]
         pkt = @plr.read_at_offset(packet_offsets[2])
@@ -223,10 +251,10 @@ module Cosmos
         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 + 13 + 4
-        meta_header_length = 8 + 1 + 6 + 1 + 4 + 4
+        header_length = 1 + 8 + 1 + 6 + 1 + 13 + 4
+        meta_header_length = 1 + 8 + 1 + 6 + 1 + 4 + 4
         meta_length = System.telemetry.packet('SYSTEM', 'META').length
-        expect(packet_offsets).to eql [PacketLogReader::COSMOS2_HEADER_LENGTH, PacketLogReader::COSMOS2_HEADER_LENGTH + meta_header_length + meta_length, PacketLogReader::COSMOS2_HEADER_LENGTH + meta_header_length + meta_length + header_length + @tlm_packet_length, PacketLogReader::COSMOS2_HEADER_LENGTH + meta_header_length + meta_length + (header_length + @tlm_packet_length) * 2]
+        expect(packet_offsets).to eql [PacketLogReader::COSMOS4_HEADER_LENGTH, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length + header_length + @tlm_packet_length, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length + (header_length + @tlm_packet_length) * 2]
 
         expect(@plr.open(Dir[File.join(@log_path,"*tlm.bin")][0])).to eql [true, nil]
         pkt = @plr.read_at_offset(packet_offsets[2])
@@ -240,10 +268,10 @@ module Cosmos
     describe "each" do
       it "returns packets" do
         index = 0
-        meta_header_length = 8 + 1 + 6 + 1 + 4 + 4
+        meta_header_length = 1 + 8 + 1 + 6 + 1 + 4 + 4
         meta_length = System.telemetry.packet('SYSTEM', 'META').length
         packet_length = System.commands.packet('SYSTEM', 'STARTLOGGING').length
-        packet_header_length = 8 + 1 + 'SYSTEM'.length + 1 + 'STARTLOGGING'.length + 4
+        packet_header_length = 1 + 8 + 1 + 'SYSTEM'.length + 1 + 'STARTLOGGING'.length + 4
         bytes_read = 128 + packet_header_length + packet_length + meta_header_length + meta_length
         @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0]) do |packet|
           next if packet.packet_name == 'META'
@@ -257,7 +285,7 @@ module Cosmos
         end
         index = 0
         packet_length = System.telemetry.packet('SYSTEM', 'LIMITS_CHANGE').length
-        packet_header_length = 8 + 1 + 'SYSTEM'.length + 1 + 'LIMITS_CHANGE'.length + 4
+        packet_header_length = 1 + 8 + 1 + 'SYSTEM'.length + 1 + 'LIMITS_CHANGE'.length + 4
         bytes_read = 128 + packet_header_length + packet_length + meta_header_length + meta_length
         @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0]) do |packet|
           next if packet.packet_name == 'META'
@@ -294,12 +322,20 @@ module Cosmos
 
       it "increments the command received count" do
         plw = PacketLogWriter.new(:CMD,'cnt',true,nil,10000000,nil,false)
-        plw.write(System.commands.packet("INST","COLLECT").clone)
-        plw.write(System.commands.packet("INST","ABORT").clone)
-        plw.write(System.commands.packet("INST","ABORT").clone)
-        plw.write(System.commands.packet("INST","COLLECT").clone)
-        plw.write(System.commands.packet("SYSTEM","STOPLOGGING").clone)
-        plw.write(System.commands.packet("INST","ABORT").clone)
+        collect_packet = System.commands.packet("INST","COLLECT").clone
+        collect_packet.stored = false
+        collect_packet.extra = {"vcid" => 2}
+        abort_packet = System.commands.packet("INST","ABORT").clone
+        abort_packet.stored = true
+        abort_packet.extra = {"test" => 1}
+        stop_packet = System.commands.packet("SYSTEM","STOPLOGGING").clone
+        stop_packet.stored = true
+        plw.write(collect_packet)
+        plw.write(abort_packet)
+        plw.write(abort_packet)
+        plw.write(collect_packet)
+        plw.write(stop_packet)
+        plw.write(abort_packet)
         plw.stop
 
         cnt = {}
@@ -308,6 +344,15 @@ module Cosmos
           cnt["#{packet.target_name}_#{packet.packet_name}"] ||= 0
           cnt["#{packet.target_name}_#{packet.packet_name}"] += 1
           expect(packet.received_count).to eql cnt["#{packet.target_name}_#{packet.packet_name}"]
+          if packet.packet_name == 'ABORT'
+            expect(packet.stored).to eql true
+            expect(packet.extra).to eql({"test" => 1})
+          elsif packet.packet_name == 'COLLECT'
+            expect(packet.stored).to eql false
+            expect(packet.extra).to eql({"vcid" => 2})
+          elsif packet.packet_name == 'STOPLOGGING'
+            expect(packet.stored).to eql true
+          end
         end
 
         # Resetting a packet should reset only that packet's received_count
@@ -328,10 +373,13 @@ module Cosmos
 
       it "increments the telemetry received count" do
         plw = PacketLogWriter.new(:TLM,'cnt',true,nil,10000000,nil,false)
-        plw.write(System.telemetry.packet("INST","HEALTH_STATUS").clone)
+        hs_packet = System.telemetry.packet("INST","HEALTH_STATUS").clone
+        hs_packet.stored = true
+        hs_packet.extra = {"vcid" => 2}
+        plw.write(hs_packet)
         plw.write(System.telemetry.packet("INST","ADCS").clone)
         plw.write(System.telemetry.packet("INST","ADCS").clone)
-        plw.write(System.telemetry.packet("INST","HEALTH_STATUS").clone)
+        plw.write(hs_packet)
         plw.write(System.telemetry.packet("INST","ADCS").clone)
         plw.stop
 
@@ -341,6 +389,13 @@ module Cosmos
           cnt["#{packet.target_name}_#{packet.packet_name}"] ||= 0
           cnt["#{packet.target_name}_#{packet.packet_name}"] += 1
           expect(packet.received_count).to eql cnt["#{packet.target_name}_#{packet.packet_name}"]
+          if packet.packet_name == 'HEALTH_STATUS'
+            expect(packet.stored).to eql true
+            expect(packet.extra).to eql({"vcid" => 2})
+          elsif packet.packet_name == 'ADCS'
+            expect(packet.stored).to eql false
+            expect(packet.extra).to eql nil
+          end
         end
 
         # Resetting a packet should reset only that packet's received_count

data/spec/packets/packet_config_spec.rb

@@ -324,11 +324,11 @@ module Cosmos
           tf.close
           @pc.process_file(tf.path, "TGT1")
           pkt = @pc.telemetry["TGT1"]["PKT1"]
-          expect(pkt.items.length).to eql 6 # 3 plus the RECEIVED_XXX items
+          expect(pkt.items.length).to eql 8 # 3 plus the RECEIVED_XXX and PACKET_TIMExxx items
           expect(pkt.items.keys).to include('BYTE1','BYTE2','BYTE3')
-          expect(pkt.sorted_items[3].name).to eql 'BYTE1'
-          expect(pkt.sorted_items[4].name).to eql 'BYTE2'
-          expect(pkt.sorted_items[5].name).to eql 'BYTE3'
+          expect(pkt.sorted_items[5].name).to eql 'BYTE1'
+          expect(pkt.sorted_items[6].name).to eql 'BYTE2'
+          expect(pkt.sorted_items[7].name).to eql 'BYTE3'
           tf.unlink
         end
       end
@@ -691,17 +691,6 @@ module Cosmos
           expect(@pc.telemetry["TGT1"]["PKT1"].read("ITEM1",:WITH_UNITS)).to eql "0 V"
           tf.unlink
         end
-
-        it "complains if STATE defined" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  ITEM item1 0 8 UINT'
-          tf.puts '    STATE ONE 1'
-          tf.puts '    UNITS Volts V'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /Items with STATE can't define UNITS/)
-          tf.unlink
-        end
       end
 
       context "with META" do
@@ -842,7 +831,7 @@ module Cosmos
           expect(@pc.telemetry["TGT1"]["PKT1"].items["ITEM1"].data_type).to be :DERIVED
           tf.unlink
         end
-      end      
+      end
 
     end # describe "process_file"
   end

data/spec/packets/parsers/format_string_parser_spec.rb

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

data/spec/packets/parsers/macro_parser_spec.rb

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

data/spec/packets/parsers/state_parser_spec.rb

@@ -119,6 +119,42 @@ module Cosmos
       end
 
       context "with telemetry" do
+        it "defines states on ARRAY items" do
+          tf = Tempfile.new('unittest')
+          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
+          tf.puts '  APPEND_ARRAY_ITEM item1 8 UINT 40 "state item"'
+          tf.puts '    STATE FALSE 0'
+          tf.puts '    STATE TRUE 1'
+          tf.puts '    STATE ERROR ANY'
+          tf.close
+          @pc.process_file(tf.path, "TGT1")
+          tlm = Telemetry.new(@pc)
+          pkt = tlm.packet("TGT1", "PKT1")
+          pkt.write("ITEM1", [0,1,2,1,0])
+          expect(pkt.read("ITEM1")).to eql ["FALSE","TRUE","ERROR","TRUE","FALSE"]
+          tf.unlink
+        end
+
+        it "allows an 'ANY' state" do
+          tf = Tempfile.new('unittest')
+          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
+          tf.puts '  APPEND_ITEM item1 8 UINT "state item"'
+          tf.puts '    STATE FALSE 0'
+          tf.puts '    STATE TRUE 1'
+          tf.puts '    STATE ERROR ANY'
+          tf.close
+          @pc.process_file(tf.path, "TGT1")
+          tlm = Telemetry.new(@pc)
+          pkt = tlm.packet("TGT1", "PKT1")
+          pkt.write("ITEM1", 0)
+          expect(pkt.read("ITEM1")).to eql "FALSE"
+          pkt.write("ITEM1", 1)
+          expect(pkt.read("ITEM1")).to eql "TRUE"
+          pkt.write("ITEM1", 2)
+          expect(pkt.read("ITEM1")).to eql "ERROR"
+          tf.unlink
+        end
+
         it "only allows GREEN YELLOW or RED" do
           tf = Tempfile.new('unittest')
           tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'

data/spec/packets/telemetry_spec.rb

@@ -114,21 +114,23 @@ module Cosmos
 
       it "returns all items from packet TGT1/PKT1" do
         items = @tlm.items("TGT1","PKT1")
-        expect(items.length).to eql 7
-        expect(items[0].name).to eql "RECEIVED_TIMESECONDS"
-        expect(items[1].name).to eql "RECEIVED_TIMEFORMATTED"
-        expect(items[2].name).to eql "RECEIVED_COUNT"
-        expect(items[3].name).to eql "ITEM1"
-        expect(items[4].name).to eql "ITEM2"
-        expect(items[5].name).to eql "ITEM3"
-        expect(items[6].name).to eql "ITEM4"
+        expect(items.length).to eql 9
+        expect(items[0].name).to eql "PACKET_TIMESECONDS"
+        expect(items[1].name).to eql "PACKET_TIMEFORMATTED"
+        expect(items[2].name).to eql "RECEIVED_TIMESECONDS"
+        expect(items[3].name).to eql "RECEIVED_TIMEFORMATTED"
+        expect(items[4].name).to eql "RECEIVED_COUNT"
+        expect(items[5].name).to eql "ITEM1"
+        expect(items[6].name).to eql "ITEM2"
+        expect(items[7].name).to eql "ITEM3"
+        expect(items[8].name).to eql "ITEM4"
       end
     end
 
     describe "item_names" do
       it "returns all the items for a given target and packet" do
         items = @tlm.item_names("TGT1","PKT1")
-        expect(items).to contain_exactly('RECEIVED_TIMEFORMATTED','RECEIVED_TIMESECONDS','RECEIVED_COUNT','ITEM1','ITEM2','ITEM3','ITEM4')
+        expect(items).to contain_exactly('PACKET_TIMEFORMATTED', 'PACKET_TIMESECONDS', 'RECEIVED_TIMEFORMATTED','RECEIVED_TIMESECONDS','RECEIVED_COUNT','ITEM1','ITEM2','ITEM3','ITEM4')
 
         items = @tlm.item_names("TGT1","LATEST")
         expect(items).to contain_exactly('ITEM1','ITEM2','ITEM3','ITEM4')

data/spec/script/script_spec.rb

@@ -67,9 +67,8 @@ module Cosmos
         expect { get_limits_groups() }.to raise_error(DRb::DRbConnError)
         expect { set_limits_set("DEFAULT") }.to raise_error(DRb::DRbConnError)
         ignore = []
-        ignore << %w(INST HEALTH_STATUS TEMP1)
-        ignore << %w(INST HEALTH_STATUS TEMP2)
-        ignore << %w(INST HEALTH_STATUS GROUND2STATUS)
+        ignore << %w(SYSTEM META COMPUTER)
+        ignore << %w(SYSTEM META VERSION)
         expect { get_overall_limits_state(ignore) }.to raise_error(DRb::DRbConnError)
 
         clear_disconnected_targets()