cosmos 3.1.2 → 3.2.0

data/lib/cosmos/utilities/message_log.rb

@@ -32,6 +32,7 @@ module Cosmos
       @filename = ''
       @file = nil
       @start_time = nil
+      @mutex = Mutex.new
     end
 
     # Ensures the log file is opened and ready to write. It then writes the
@@ -39,34 +40,38 @@ module Cosmos
     #
     # @param message [String] Message to write to the log
     def write(message)
-      if @file.nil? or @file.closed? or (not File.exist?(@filename))
-        start()
-      end
+      @mutex.synchronize do
+        if @file.nil? or @file.closed? or (not File.exist?(@filename))
+          start(false)
+        end
 
-      @file.write(message)
-      # While it's nice to flush the IO this is an extreme slowdown
-      #@file.flush
+        @file.write(message)
+      end
     end
 
     # Closes the message log and marks it read only
-    def stop
+    def stop(take_mutex = true)
+      @mutex.lock if take_mutex
       if @file and not @file.closed?
         @file.close
         Cosmos.set_working_dir do
           File.chmod(0444, @filename)
         end
       end
+      @mutex.unlock if take_mutex
     end
 
     # Creates a new message log and sets the filename
-    def start
+    def start(take_mutex = true)
+      @mutex.lock if take_mutex
       # Prevent starting files too fast
       sleep(0.1) until !File.exist?(File.join(@log_dir, File.build_timestamped_filename([@tool_name, 'messages'])))
-      stop()
+      stop(false)
       Cosmos.set_working_dir do
         @filename = File.join(@log_dir, File.build_timestamped_filename([@tool_name, 'messages']))
         @file = File.open(@filename, 'a')
       end
+      @mutex.unlock if take_mutex
     end
 
   end # class MessageLog

data/lib/cosmos/version.rb

@@ -1,12 +1,12 @@
 # encoding: ascii-8bit
 
-COSMOS_VERSION = '3.1.2'
+COSMOS_VERSION = '3.2.0'
 module Cosmos
   module Version
     MAJOR = '3'
-    MINOR = '1'
-    PATCH = '2'
-    BUILD = '5864bf4376d74014c01d625e46b5aefc843908ba'
+    MINOR = '2'
+    PATCH = '0'
+    BUILD = '29c04013a08ebeab57b88412820e0cd79782c49f'
   end
-  VERSION = '3.1.2'
+  VERSION = '3.2.0'
 end

data/spec/interfaces/cmd_tlm_server_interface_spec.rb

@@ -44,31 +44,31 @@ module Cosmos
       sleep 0.1 # Give the server time to really stop all the Threads
     end
 
-    specify { @ctsi.methods.should include(:cmd) }
+    specify { expect(@ctsi.methods).to include(:cmd) }
 
     describe "connect, connected?, disconnect" do
-      it "should subscribe to the server" do
+      it "subscribes to the server" do
         expect { @ctsi.connect }.to_not raise_error
-        @ctsi.connected?.should be_truthy
+        expect(@ctsi.connected?).to be true
         expect { @ctsi.disconnect}.to_not raise_error
-        @ctsi.connected?.should be_falsey
+        expect(@ctsi.connected?).to be false
       end
     end
 
     describe "write_raw_allowed?" do
-      it "should be false" do
-        @ctsi.write_raw_allowed?.should be_falsey
+      it "returns false" do
+        expect(@ctsi.write_raw_allowed?).to be false
       end
     end
 
     describe "write_raw" do
-      it "should raise an error" do
+      it "raises an error" do
         expect { @ctsi.write_raw(nil) }.to raise_error(/write_raw not implemented/)
       end
     end
 
     describe "read" do
-      it "should first return the COSMOS VERSION packet and then COSMOS LIMITS_CHANGE" do
+      it "returns the COSMOS VERSION packet and then COSMOS LIMITS_CHANGE" do
         @ctsi.connect
 
         pkt = Packet.new("TGT","PKT")
@@ -78,25 +78,25 @@ module Cosmos
         @cts.limits_change_callback(pkt, pi, :RED, 100, true)
 
         result = @ctsi.read
-        result.read('CTDB').should eql "Demo Version"
+        expect(result.read('CTDB')).to eql "Demo Version"
 
         result = @ctsi.read
-        result.read('TARGET').should eql "TGT"
-        result.read('PACKET').should eql "PKT"
-        result.read('ITEM').should eql "ITEM"
-        result.read('OLD_STATE').should eql "RED"
-        result.read('NEW_STATE').should eql "GREEN"
+        expect(result.read('TARGET')).to eql "TGT"
+        expect(result.read('PACKET')).to eql "PKT"
+        expect(result.read('ITEM')).to eql "ITEM"
+        expect(result.read('OLD_STATE')).to eql "RED"
+        expect(result.read('NEW_STATE')).to eql "GREEN"
       end
     end
 
     describe "write" do
-      it "should raise an error if the packet is not identified" do
+      it "raises an error if the packet is not identified" do
         pkt = Packet.new("COSMOS","STARTLOGGING")
         pkt.buffer = "\x00\x00\x00\x00\x00\x00\x00\x00"
         expect { @ctsi.write(pkt) }.to raise_error(/Unknown command/)
       end
 
-      it "should raise an error if the command is not recognized" do
+      it "raises an error if the command is not recognized" do
         pkt = Packet.new("COSMOS","DOSOMETHING")
         pkt.buffer = "\x00\x00\x00\x00\x00\x00\x00\x00"
         expect { @ctsi.write(pkt) }.to raise_error(/Unknown command/)

data/spec/interfaces/linc_interface_spec.rb

@@ -22,6 +22,7 @@ module Cosmos
     describe "connect" do
       it "should pass a new TcpipClientStream to the stream protocol" do
         stream = double("stream")
+        allow(stream).to receive(:connect)
         expect(TcpipClientStream).to receive(:new) { stream }
         expect(stream).to receive(:connected?) { true }
         expect(stream).to receive(:raw_logger_pair=) { nil }
@@ -36,6 +37,7 @@ module Cosmos
     describe "write" do
       before(:each) do
         stream = double("stream")
+        allow(stream).to receive(:connect)
         expect(TcpipClientStream).to receive(:new) { stream }
         allow(stream).to receive(:connected?) { true }
         allow(stream).to receive(:write)
@@ -159,6 +161,7 @@ module Cosmos
     describe "read" do
       before(:each) do
         stream = double("stream")
+        allow(stream).to receive(:connect)
         expect(TcpipClientStream).to receive(:new) { stream }
         allow(stream).to receive(:connected?) { true }
         allow(stream).to receive(:write)

data/spec/interfaces/tcpip_client_interface_spec.rb

@@ -40,6 +40,7 @@ module Cosmos
     describe "connect" do
       it "should pass a new TcpipClientStream to the stream protocol" do
         stream = double("stream")
+        allow(stream).to receive(:connect)
         expect(TcpipClientStream).to receive(:new) { stream }
         expect(stream).to receive(:connected?) { true }
         expect(stream).to receive(:raw_logger_pair=) { nil }

data/spec/interfaces/tcpip_server_interface_spec.rb

@@ -146,6 +146,15 @@ module Cosmos
         expect { i.write_raw('') }.to raise_error("TEST")
       end
     end
+
+    describe "set_option" do
+      it "should set the listen address for the tcpip_server" do
+        expect(@stream).to receive(:listen_address=).with('127.0.0.1')
+        i = TcpipServerInterface.new('8888','8889','5','5','burst')
+        i.set_option('LISTEN_ADDRESS', ['127.0.0.1'])
+      end
+    end
+
   end
 end
 

data/spec/io/json_drb_object_spec.rb

@@ -40,7 +40,7 @@ module Cosmos
       it "should raise an exception if the remote connection can't be made" do
         json = JsonDRb.new
         json.start_service('127.0.0.1', 7777, self)
-        allow(TCPSocket).to receive(:new) { raise "Error" }
+        allow_any_instance_of(Socket).to receive(:connect_nonblock) { raise "Error" }
         obj = JsonDRbObject.new("localhost", 7777)
         expect { obj.my_method(10) }.to raise_error(DRb::DRbConnError)
         obj.disconnect

data/spec/io/serial_driver_spec.rb

@@ -40,7 +40,6 @@ module Cosmos
 
       it "should defer to the posix serial driver on nix" do
         class PosixSerialDriver
-          def initialize(port,baud); end
         end
         allow(Kernel).to receive(:is_windows?).and_return(false)
         driver = double("PosixSerialDriver")

data/spec/packet_logs/packet_log_writer_spec.rb

@@ -130,9 +130,11 @@ module Cosmos
         Dir[File.join(@log_path,"*.bin")].length.should eql 2
         # Check that the log files have timestamps which are 3 (or 4) seconds apart
         files = Dir[File.join(@log_path,"*tlm.bin")].sort
-        log1_seconds = files[0].split('_')[-3].to_i * 60 + files[0].split('_')[-2].to_i
-        log2_seconds = files[1].split('_')[-3].to_i * 60 + files[1].split('_')[-2].to_i
-        (log2_seconds - log1_seconds).should be_within(2).of(3)
+        split1 = files[0].split('_')
+        split2 = files[1].split('_')
+        log1_time = Time.new(split1[-7].to_i, split1[-6].to_i, split1[-5].to_i, split1[-4].to_i, split1[-3].to_i, split1[-2].to_i)
+        log2_time = Time.new(split2[-7].to_i, split2[-6].to_i, split2[-5].to_i, split2[-4].to_i, split2[-3].to_i, split2[-2].to_i)
+        (log2_time - log1_time).should be_within(2).of(3)
         plw.shutdown
         # Monkey patch the constant back to the default
         PacketLogWriter.__send__(:remove_const,:CYCLE_TIME_INTERVAL)

data/spec/packets/packet_config_spec.rb

@@ -30,115 +30,12 @@ module Cosmos
         tf.unlink
       end
 
-      it "should complain about overlapping items" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-        tf.puts '  ITEM item1 0 8 UINT'
-        tf.puts '  ITEM item2 0 8 UINT'
-        tf.close
-        @pc.process_file(tf.path, "TGT1")
-        @pc.warnings[0].should eql "Bit definition overlap at bit offset 0 for Telemetry packet TGT1 PKT1 items ITEM2 and ITEM1"
-        tf.unlink
-      end
-
-      it "should not complain with non-overlapping negative offsets" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'TELEMETRY tgt1 pkt2 LITTLE_ENDIAN "Description"'
-        tf.puts '  ITEM item1 0 8 UINT'
-        tf.puts '  ITEM item2 8 -16 BLOCK'
-        tf.puts '  ITEM item3 -16 16 UINT'
-        tf.close
-        @pc.process_file(tf.path, "TGT1")
-        @pc.warnings[0].should be_nil
-        tf.unlink
-      end
-
-      it "should complain with overlapping negative offsets" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'TELEMETRY tgt1 pkt2 LITTLE_ENDIAN "Description"'
-        tf.puts '  ITEM item1 0 8 UINT'
-        tf.puts '  ITEM item2 8 -16 BLOCK'
-        tf.puts '  ITEM item3 -17 16 UINT'
-        tf.close
-        @pc.process_file(tf.path, "TGT1")
-        @pc.warnings[0].should eql "Bit definition overlap at bit offset -17 for Telemetry packet TGT1 PKT2 items ITEM3 and ITEM2"
-        tf.unlink
-      end
-
-      it "should complain about intersecting items" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-        tf.puts '  ITEM item1 0 32 UINT'
-        tf.puts '  ITEM item2 16 32 UINT'
-        tf.close
-        @pc.process_file(tf.path, "TGT1")
-        @pc.warnings[0].should eql "Bit definition overlap at bit offset 16 for Telemetry packet TGT1 PKT1 items ITEM2 and ITEM1"
-        tf.unlink
-      end
-
-      it "should complain about array overlapping items" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-        tf.puts '  ARRAY_ITEM item1 0 8 UINT 32'
-        tf.puts '  ARRAY_ITEM item2 0 8 UINT 32'
-        tf.close
-        @pc.process_file(tf.path, "TGT1")
-        @pc.warnings[0].should eql "Bit definition overlap at bit offset 0 for Telemetry packet TGT1 PKT1 items ITEM2 and ITEM1"
-        tf.unlink
-      end
-
-      it "should not complain with array non-overlapping negative offsets" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'TELEMETRY tgt1 pkt2 LITTLE_ENDIAN "Description"'
-        tf.puts '  ITEM item1 0 8 UINT'
-        tf.puts '  ARRAY_ITEM item2 8 8 INT -16'
-        tf.puts '  ITEM item3 -16 16 UINT'
-        tf.close
-        @pc.process_file(tf.path, "TGT1")
-        @pc.warnings[0].should be_nil
-        tf.unlink
-      end
-
-      it "should complain with array overlapping negative offsets" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'TELEMETRY tgt1 pkt2 LITTLE_ENDIAN "Description"'
-        tf.puts '  ITEM item1 0 8 UINT'
-        tf.puts '  ARRAY_ITEM item2 8 8 INT -16'
-        tf.puts '  ITEM item3 -17 16 UINT'
-        tf.close
-        @pc.process_file(tf.path, "TGT1")
-        @pc.warnings[0].should eql "Bit definition overlap at bit offset -17 for Telemetry packet TGT1 PKT2 items ITEM3 and ITEM2"
-        tf.unlink
-      end
-
-      it "should complain about array intersecting items" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-        tf.puts '  ARRAY_ITEM item1 0 8 UINT 32'
-        tf.puts '  ARRAY_ITEM item2 16 8 UINT 32'
-        tf.close
-        @pc.process_file(tf.path, "TGT1")
-        @pc.warnings[0].should eql "Bit definition overlap at bit offset 16 for Telemetry packet TGT1 PKT1 items ITEM2 and ITEM1"
-        tf.unlink
-      end
-
-      it "should not complain about nonoverlapping little endian bitfields" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-        tf.puts '  ITEM item1 12 12 UINT'
-        tf.puts '  ITEM item2 16 16 UINT'
-        tf.close
-        @pc.process_file(tf.path, "TGT1")
-        @pc.warnings[0].should be_nil
-        tf.unlink
-      end
-
       context "with all telemetry keywords" do
         before(:all) do
           # top level keywords
-          @top_keywords = %w(TELEMETRY SELECT_TELEMETRY LIMITS_GROUP LIMITS_GROUP_ITEM)
+          @top_keywords = %w(SELECT_COMMAND SELECT_TELEMETRY LIMITS_GROUP LIMITS_GROUP_ITEM)
           # Keywords that require a current packet from TELEMETRY keyword
-          @tlm_keywords = %w(SELECT_ITEM ITEM ID_ITEM ARRAY_ITEM APPEND_ITEM APPEND_ID_ITEM APPEND_ARRAY_ITEM MACRO_APPEND_START MACRO_APPEND_END PROCESSOR META)
+          @tlm_keywords = %w(SELECT_ITEM ITEM ID_ITEM ARRAY_ITEM APPEND_ITEM APPEND_ID_ITEM APPEND_ARRAY_ITEM PROCESSOR META)
           # Keywords that require both a current packet and current item
           @item_keywords = %w(STATE READ_CONVERSION WRITE_CONVERSION POLY_READ_CONVERSION POLY_WRITE_CONVERSION SEG_POLY_READ_CONVERSION SEG_POLY_WRITE_CONVERSION GENERIC_READ_CONVERSION_START GENERIC_WRITE_CONVERSION_START LIMITS LIMITS_RESPONSE UNITS FORMAT_STRING DESCRIPTION META)
         end
@@ -177,7 +74,6 @@ module Cosmos
           end
 
           @tlm_keywords.each do |keyword|
-            next if %w(MACRO_APPEND_END).include? keyword
             tf = Tempfile.new('unittest')
             tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
             tf.puts keyword
@@ -202,8 +98,8 @@ module Cosmos
           @top_keywords.each do |keyword|
             tf = Tempfile.new('unittest')
             case keyword
-            when "TELEMETRY"
-              tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet" extra'
+            when "SELECT_COMMAND"
+              tf.puts 'SELECT_COMMAND tgt1 pkt1 extra'
             when "SELECT_TELEMETRY"
               tf.puts 'SELECT_TELEMETRY tgt1 pkt1 extra'
             when 'LIMITS_GROUP'
@@ -217,7 +113,7 @@ module Cosmos
           end
 
           @tlm_keywords.each do |keyword|
-            next if %w(MACRO_APPEND_END PROCESSOR META).include? keyword
+            next if %w(PROCESSOR META).include? keyword
             tf = Tempfile.new('unittest')
             tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
             case keyword
@@ -236,10 +132,6 @@ module Cosmos
             when "SELECT_ITEM"
               tf.puts 'ITEM myitem 0 8 UINT'
               tf.puts 'SELECT_ITEM myitem extra'
-            when "MACRO_APPEND_START"
-              tf.puts 'MACRO_APPEND_START 0 1 "%s_%d" extra'
-            when "ACRO_APPEND_END"
-              tf.puts 'MACRO_APPEND_END extra'
             end
             tf.close
             expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /Too many parameters for #{keyword}/)
@@ -271,47 +163,6 @@ module Cosmos
         end
       end
 
-      context "with COMMAND or TELEMETRY" do
-        it "should complain about invalid endianness" do
-          %w(COMMAND TELEMETRY).each do |keyword|
-            tf = Tempfile.new('unittest')
-            tf.puts keyword + ' tgt1 pkt1 MIDDLE_ENDIAN "Packet"'
-            tf.close
-            expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "Invalid endianness MIDDLE_ENDIAN. Must be BIG_ENDIAN or LITTLE_ENDIAN.")
-            tf.unlink
-          end
-        end
-
-        it "should process target, packet, endianness, description" do
-          %w(COMMAND TELEMETRY).each do |keyword|
-            tf = Tempfile.new('unittest')
-            tf.puts keyword + ' tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-            tf.close
-            @pc.process_file(tf.path, "TGT1")
-            pkt = @pc.commands["TGT1"]["PKT1"] if keyword == 'COMMAND'
-            pkt = @pc.telemetry["TGT1"]["PKT1"] if keyword == 'TELEMETRY'
-            pkt.target_name.should eql "TGT1"
-            pkt.packet_name.should eql "PKT1"
-            pkt.default_endianness.should eql :LITTLE_ENDIAN
-            pkt.description.should eql "Packet"
-            tf.unlink
-          end
-        end
-
-        it "should substitute the target name" do
-          %w(COMMAND TELEMETRY).each do |keyword|
-            tf = Tempfile.new('unittest')
-            tf.puts keyword + ' tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-            tf.close
-            @pc.process_file(tf.path, "NEW")
-            pkt = @pc.commands["NEW"]["PKT1"] if keyword == 'COMMAND'
-            pkt = @pc.telemetry["NEW"]["PKT1"] if keyword == 'TELEMETRY'
-            pkt.target_name.should eql "NEW"
-            tf.unlink
-          end
-        end
-      end
-
       context "with SELECT_COMMAND or SELECT_TELEMETRY" do
         it "should complain if the packet is not found" do
           %w(SELECT_COMMAND SELECT_TELEMETRY).each do |keyword|
@@ -442,176 +293,21 @@ module Cosmos
         end
       end
 
-      context "with keywords including ITEM" do
-        it "should only allow DERIVED items with offset 0 and size 0" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  ITEM ITEM1 8 0 DERIVED'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /DERIVED items must have bit_offset of zero/)
-          tf.unlink
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  ITEM ITEM1 0 8 DERIVED'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /DERIVED items must have bit_size of zero/)
-          tf.unlink
-
+      context "with MACRO_APPEND" do
+        it "creates a range of items" do
           tf = Tempfile.new('unittest')
           tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  ITEM ITEM1 0 0 DERIVED'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          @pc.telemetry["TGT1"]["PKT1"].items.keys.should include('ITEM1')
-          tf.unlink
-        end
-
-        it "should accept types INT UINT FLOAT STRING BLOCK" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  ID_ITEM ITEM1 0 32 INT 0'
-          tf.puts '  ITEM ITEM2 0 32 UINT'
-          tf.puts '  ARRAY_ITEM ITEM3 0 32 FLOAT 64'
-          tf.puts '  APPEND_ID_ITEM ITEM4 32 STRING "ABCD"'
-          tf.puts '  APPEND_ITEM ITEM5 32 BLOCK'
-          tf.puts '  APPEND_ARRAY_ITEM ITEM6 32 BLOCK 64'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          @pc.telemetry["TGT1"]["PKT1"].items.keys.should include('ITEM1','ITEM2','ITEM3','ITEM4','ITEM5','ITEM6')
-          id_items = []
-          id_items << @pc.telemetry["TGT1"]["PKT1"].items["ITEM1"]
-          id_items << @pc.telemetry["TGT1"]["PKT1"].items["ITEM4"]
-          @pc.telemetry["TGT1"]["PKT1"].id_items.should eql id_items
-          tf.unlink
-        end
-
-        it "should support arbitrary endianness per item" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  ID_ITEM ITEM1 0 32 UINT 0 "" LITTLE_ENDIAN'
-          tf.puts '  ITEM ITEM2 0 32 UINT "" LITTLE_ENDIAN'
-          tf.puts '  ARRAY_ITEM ITEM3 0 32 UINT 64 "" LITTLE_ENDIAN'
-          tf.puts '  APPEND_ID_ITEM ITEM4 32 UINT 1 "" LITTLE_ENDIAN'
-          tf.puts '  APPEND_ITEM ITEM5 32 UINT "" LITTLE_ENDIAN'
-          tf.puts '  APPEND_ARRAY_ITEM ITEM6 32 UINT 64 "" LITTLE_ENDIAN'
-          tf.puts '  ID_ITEM ITEM10 224 32 UINT 0 "" BIG_ENDIAN'
-          tf.puts '  ITEM ITEM20 256 32 UINT "" BIG_ENDIAN'
-          tf.puts '  ARRAY_ITEM ITEM30 0 32 UINT 64 "" BIG_ENDIAN'
-          tf.puts '  APPEND_ID_ITEM ITEM40 32 UINT 1 "" BIG_ENDIAN'
-          tf.puts '  APPEND_ITEM ITEM50 32 UINT "" BIG_ENDIAN'
-          tf.puts '  APPEND_ARRAY_ITEM ITEM60 32 UINT 64 "" BIG_ENDIAN'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          packet = @pc.telemetry["TGT1"]["PKT1"]
-          packet.buffer = "\x00\x00\x00\x01" * 16
-          packet.read("ITEM1").should eql 0x01000000
-          packet.read("ITEM2").should eql 0x01000000
-          packet.read("ITEM3").should eql [0x01000000, 0x01000000]
-          packet.read("ITEM4").should eql 0x01000000
-          packet.read("ITEM5").should eql 0x01000000
-          packet.read("ITEM6").should eql [0x01000000, 0x01000000]
-          packet.read("ITEM10").should eql 0x00000001
-          packet.read("ITEM20").should eql 0x00000001
-          packet.read("ITEM30").should eql [0x00000001, 0x00000001]
-          packet.read("ITEM40").should eql 0x00000001
-          packet.read("ITEM50").should eql 0x00000001
-          packet.read("ITEM60").should eql [0x00000001, 0x00000001]
-          tf.unlink
-        end
-      end
-
-      context "with keywords including PARAMETER" do
-        it "should only allow DERIVED items with offset 0 and size 0" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  PARAMETER ITEM1 8 0 DERIVED 0 0 0'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /DERIVED items must have bit_offset of zero/)
-          tf.unlink
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  PARAMETER ITEM1 0 8 DERIVED 0 0 0'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /DERIVED items must have bit_size of zero/)
-          tf.unlink
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  PARAMETER ITEM1 0 0 DERIVED 0 0 0'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          @pc.commands["TGT1"]["PKT1"].items.keys.should include('ITEM1')
-          tf.unlink
-        end
-
-        it "should not allow ID_PARAMETER with DERIVED type" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  ID_PARAMETER ITEM1 0 0 DERIVED 0 0 0'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /DERIVED data type not allowed/)
-          tf.unlink
-        end
-
-        it "should not allow APPEND_ID_PARAMETER with DERIVED type" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  APPEND_ID_PARAMETER ITEM1 0 DERIVED 0 0 0'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /DERIVED data type not allowed/)
-          tf.unlink
-        end
-
-        it "should accept types INT UINT FLOAT STRING BLOCK" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  ID_PARAMETER ITEM1 0 32 INT 0 0 0'
-          tf.puts '  ID_PARAMETER ITEM2 32 32 STRING "ABCD"'
-          tf.puts '  PARAMETER ITEM3 64 32 UINT 0 0 0'
-          tf.puts '  ARRAY_PARAMETER ITEM4 96 32 FLOAT 64'
-          tf.puts '  APPEND_ID_PARAMETER ITEM5 32 UINT 0 0 0'
-          tf.puts '  APPEND_ID_PARAMETER ITEM6 32 STRING "ABCD"'
-          tf.puts '  APPEND_PARAMETER ITEM7 32 BLOCK "1234"'
-          tf.puts '  APPEND_ARRAY_PARAMETER ITEM8 32 BLOCK 64'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          @pc.commands["TGT1"]["PKT1"].items.keys.should include('ITEM1','ITEM2','ITEM3','ITEM4','ITEM5','ITEM6','ITEM7','ITEM8')
-          tf.unlink
-        end
-
-        it "should support arbitrary endianness per item" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  ID_PARAMETER ITEM1 0 32 UINT 0 0 0 "" LITTLE_ENDIAN'
-          tf.puts '  PARAMETER ITEM2 0 32 UINT 0 0 0 "" LITTLE_ENDIAN'
-          tf.puts '  ARRAY_PARAMETER ITEM3 0 32 UINT 64 "" LITTLE_ENDIAN'
-          tf.puts '  APPEND_ID_PARAMETER ITEM4 32 UINT 0 0 0 "" LITTLE_ENDIAN'
-          tf.puts '  APPEND_PARAMETER ITEM5 32 UINT 0 0 0 "" LITTLE_ENDIAN'
-          tf.puts '  APPEND_ARRAY_PARAMETER ITEM6 32 UINT 64 "" LITTLE_ENDIAN'
-          tf.puts '  ID_PARAMETER ITEM10 224 32 UINT 0 0 0 "" BIG_ENDIAN'
-          tf.puts '  PARAMETER ITEM20 256 32 UINT 0 0 0 "" BIG_ENDIAN'
-          tf.puts '  ARRAY_PARAMETER ITEM30 0 32 UINT 64 "" BIG_ENDIAN'
-          tf.puts '  APPEND_ID_PARAMETER ITEM40 32 UINT 0 0 0 "" BIG_ENDIAN'
-          tf.puts '  APPEND_PARAMETER ITEM50 32 UINT 0 0 0 "" BIG_ENDIAN'
-          tf.puts '  APPEND_ARRAY_PARAMETER ITEM60 32 UINT 64 "" BIG_ENDIAN'
+          tf.puts 'MACRO_APPEND_START 1 3'
+          tf.puts '  APPEND_ITEM BYTE 8 UINT "Setting #x"'
+          tf.puts 'MACRO_APPEND_END'
           tf.close
           @pc.process_file(tf.path, "TGT1")
-          packet = @pc.commands["TGT1"]["PKT1"]
-          packet.buffer = "\x00\x00\x00\x01" * 16
-          packet.read("ITEM1").should eql 0x01000000
-          packet.read("ITEM2").should eql 0x01000000
-          packet.read("ITEM3").should eql [0x01000000, 0x01000000]
-          packet.read("ITEM4").should eql 0x01000000
-          packet.read("ITEM5").should eql 0x01000000
-          packet.read("ITEM6").should eql [0x01000000, 0x01000000]
-          packet.read("ITEM10").should eql 0x00000001
-          packet.read("ITEM20").should eql 0x00000001
-          packet.read("ITEM30").should eql [0x00000001, 0x00000001]
-          packet.read("ITEM40").should eql 0x00000001
-          packet.read("ITEM50").should eql 0x00000001
-          packet.read("ITEM60").should eql [0x00000001, 0x00000001]
+          pkt = @pc.telemetry["TGT1"]["PKT1"]
+          expect(pkt.items.length).to eql 6 # 3 plus the RECEIVED_XXX 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'
           tf.unlink
         end
       end
@@ -651,56 +347,6 @@ module Cosmos
         end
       end
 
-      context "with MACRO_APPEND_START" do
-        it "should add items to the packet" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts 'MACRO_APPEND_START 1 5'
-          tf.puts 'APPEND_ITEM BIT 16 UINT "Setting #x"'
-          tf.puts '  STATE BAD 0 RED'
-          tf.puts '  STATE GOOD 1 GREEN'
-          tf.puts 'MACRO_APPEND_END'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          pkt = @pc.telemetry["TGT1"]["PKT1"]
-          pkt.items.keys.should include('BIT1','BIT2','BIT3','BIT4','BIT5')
-          limits_items = []
-          pkt.items.each do |name, item|
-            limits_items << item if name =~ /BIT/
-          end
-          pkt.limits_items.should eql limits_items
-          tf.unlink
-        end
-
-        it "should array items to the packet" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts 'MACRO_APPEND_START 1 5'
-          tf.puts 'APPEND_ARRAY_ITEM BIT 16 INT 64 "Int Array Parameter"'
-          tf.puts 'MACRO_APPEND_END'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          pkt = @pc.telemetry["TGT1"]["PKT1"]
-          pkt.items.keys.should include('BIT1','BIT2','BIT3','BIT4','BIT5')
-          pkt.limits_items.should be_empty
-          tf.unlink
-        end
-
-        it "should work with printf format strings" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts 'MACRO_APPEND_START 1 5 "%d%s"'
-          tf.puts 'APPEND_ID_ITEM BIT 16 UINT 0 "Setting #x"'
-          tf.puts 'MACRO_APPEND_END'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          pkt = @pc.telemetry["TGT1"]["PKT1"]
-          pkt.items.keys.should include('1BIT','2BIT','3BIT','4BIT','5BIT')
-          pkt.limits_items.should be_empty
-          tf.unlink
-        end
-      end
-
       context "with ALLOW_SHORT" do
         it "should mark the packet as allowing short buffers" do
           tf = Tempfile.new('unittest')
@@ -806,106 +452,6 @@ module Cosmos
         end
       end
 
-      context "with STATE" do
-        it "should support STRING items" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  APPEND_ITEM item1 128 STRING "state item"'
-          tf.puts '    STATE FALSE "FALSE STRING"'
-          tf.puts '    STATE TRUE "TRUE STRING"'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          @pc.telemetry["TGT1"]["PKT1"].write("ITEM1", "TRUE STRING")
-          @pc.telemetry["TGT1"]["PKT1"].read("ITEM1").should eql "TRUE"
-          @pc.telemetry["TGT1"]["PKT1"].write("ITEM1", "FALSE STRING")
-          @pc.telemetry["TGT1"]["PKT1"].read("ITEM1").should eql "FALSE"
-          tf.unlink
-        end
-
-        it "should warn about duplicate states and replace the duplicate" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
-          tf.puts '  APPEND_PARAMETER item1 8 UINT 0 2 0 "state item"'
-          tf.puts '    STATE FALSE 0'
-          tf.puts '    STATE TRUE 1'
-          tf.puts '    STATE FALSE 2'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          @pc.warnings.should include("Duplicate state defined on line 5: STATE FALSE 2")
-          @pc.commands["TGT1"]["PKT1"].buffer = "\x00"
-          @pc.commands["TGT1"]["PKT1"].read("ITEM1").should eql 0
-          @pc.commands["TGT1"]["PKT1"].buffer = "\x02"
-          @pc.commands["TGT1"]["PKT1"].read("ITEM1").should eql "FALSE"
-          tf.unlink
-        end
-
-        context "with telemetry" do
-          it "should only allow GREEN YELLOW or RED" do
-            tf = Tempfile.new('unittest')
-            tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-            tf.puts '  APPEND_ITEM item1 8 UINT "state item"'
-            tf.puts '    STATE WORST 1 ORANGE'
-            tf.close
-            expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /Invalid state color ORANGE/)
-            tf.unlink
-          end
-
-          it "should record the state values and colors" do
-            tf = Tempfile.new('unittest')
-            tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'
-            tf.puts '  APPEND_ITEM item1 8 UINT "state item"'
-            tf.puts '    STATE STATE1 1 RED'
-            tf.puts '    STATE STATE2 2 YELLOW'
-            tf.puts '    STATE STATE3 3 GREEN'
-            tf.puts '    STATE STATE4 4'
-            tf.close
-            @pc.process_file(tf.path, "TGT1")
-            index = 1
-            colors = [:RED, :YELLOW, :GREEN]
-            @pc.telemetry["TGT1"]["PKT1"].items["ITEM1"].states.each do |name,val|
-              name.should eql "STATE#{index}"
-              val.should eql index
-              @pc.telemetry["TGT1"]["PKT1"].items["ITEM1"].state_colors[name].should eql colors[index - 1]
-
-              index += 1
-            end
-            @pc.telemetry["TGT1"]["PKT1"].limits_items.should eql [@pc.telemetry["TGT1"]["PKT1"].items["ITEM1"]]
-            tf.unlink
-          end
-        end
-
-        context "with command" do
-          it "should only allow HAZARDOUS as the third param" do
-            tf = Tempfile.new('unittest')
-            tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
-            tf.puts '  APPEND_PARAMETER item1 8 UINT 0 0 0'
-            tf.puts '    STATE WORST 0 RED'
-            tf.close
-            expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /HAZARDOUS expected as third parameter/)
-            tf.unlink
-          end
-
-          it "should take HAZARDOUS and an optional description" do
-            tf = Tempfile.new('unittest')
-            tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Description"'
-            tf.puts '  APPEND_PARAMETER item1 8 UINT 1 3 1'
-            tf.puts '    STATE GOOD 1'
-            tf.puts '    STATE BAD 2 HAZARDOUS'
-            tf.puts '    STATE WORST 3 HAZARDOUS "Hazardous description"'
-            tf.close
-            @pc.process_file(tf.path, "TGT1")
-            @pc.commands["TGT1"]["PKT1"].buffer = "\x01"
-            @pc.commands["TGT1"]["PKT1"].check_limits
-            @pc.commands["TGT1"]["PKT1"].items["ITEM1"].hazardous["GOOD"].should be_nil
-            @pc.commands["TGT1"]["PKT1"].items["ITEM1"].hazardous["BAD"].should_not be_nil
-            @pc.commands["TGT1"]["PKT1"].items["ITEM1"].hazardous["WORST"].should_not be_nil
-            @pc.commands["TGT1"]["PKT1"].items["ITEM1"].hazardous["WORST"].should eql "Hazardous description"
-            @pc.commands["TGT1"]["PKT1"].limits_items.should be_empty
-            tf.unlink
-          end
-        end
-      end
-
       context "with READ_CONVERSION and WRITE_CONVERSION" do
         it "should complain about missing conversion file" do
           filename = File.join(File.dirname(__FILE__), "../test_only.rb")
@@ -993,76 +539,6 @@ module Cosmos
         end
       end
 
-      context "with PROCESSOR" do
-        it "should complain about missing processor file" do
-          filename = File.join(File.dirname(__FILE__), "../test_only.rb")
-          File.delete(filename) if File.exist?(filename)
-          @pc = PacketConfig.new
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  PROCESSOR TEST test_only.rb'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /TestOnly class not found/)
-          tf.unlink
-        end
-
-        it "should complain about a non Cosmos::Processor class" do
-          filename = File.join(File.dirname(__FILE__), "../processor1.rb")
-          File.open(filename, 'w') do |file|
-            file.puts "class Processor1"
-            file.puts "  def call(packet,buffer)"
-            file.puts "  end"
-            file.puts "end"
-          end
-          load 'processor1.rb'
-          File.delete(filename) if File.exist?(filename)
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  PROCESSOR P1 processor1.rb'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /processor must be a Cosmos::Processor but is a Processor1/)
-          tf.unlink
-        end
-
-        it "should parse the processor" do
-          filename = File.join(File.dirname(__FILE__), "../processor2.rb")
-          File.open(filename, 'w') do |file|
-            file.puts "require 'cosmos/processors/processor'"
-            file.puts "class Processor2 < Cosmos::Processor"
-            file.puts "  def call(packet,buffer)"
-            file.puts "    @results[:TEST] = 5"
-            file.puts "  end"
-            file.puts "end"
-          end
-          load 'processor2.rb'
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  ITEM item1 0 16 INT "Integer Item"'
-          tf.puts '    READ_CONVERSION processor_conversion.rb P2 TEST'
-          tf.puts '  PROCESSOR P2 processor2.rb'
-          tf.puts '  PROCESSOR P3 processor2.rb RAW'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          @pc.telemetry["TGT1"]["PKT1"].buffer = "\x01\x01"
-          @pc.telemetry["TGT1"]["PKT1"].read("ITEM1").should eql 5
-          tf.unlink
-
-          File.delete(filename) if File.exist?(filename)
-        end
-
-        it "should complain if applied to a command packet" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  PROCESSOR P1 processor1.rb'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "PROCESSOR only applies to telemetry packets")
-          tf.unlink
-        end
-      end
-
       context "with POLY_READ_CONVERSION and POLY_WRITE_CONVERSION" do
         it "should perform a polynomial conversion" do
           tf = Tempfile.new('unittest')
@@ -1163,313 +639,22 @@ module Cosmos
       end
 
       context "with LIMITS" do
-        it "should complain if applied to a command PARAMETER" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_PARAMETER item1 16 UINT 0 0 0 "Item"'
-          tf.puts '    LIMITS DEFAULT 3 ENABLED 1 2 6 7 3 5'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "LIMITS only applies to telemetry items")
-          tf.unlink
-        end
-
-        it "should complain if the second parameter isn't a number" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
-          tf.puts '    LIMITS DEFAULT TRUE ENABLED 1 2 6 7 3 5'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /Ensure persistence is an integer/)
-          tf.unlink
-        end
-
-        it "should complain if the third parameter isn't ENABLED or DISABLED" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
-          tf.puts '    LIMITS DEFAULT 3 TRUE 1 2 6 7 3 5'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /Initial state must be ENABLED or DISABLED/)
-          tf.unlink
-        end
-
-        it "should complain if the 4 limits are out of order" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
-          tf.puts '    LIMITS DEFAULT 3 ENABLED 2 1 3 4'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "Invalid limits specified. Ensure yellow limits are within red limits.")
-          tf.unlink
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
-          tf.puts '    LIMITS DEFAULT 3 ENABLED 1 5 3 7'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "Invalid limits specified. Ensure yellow limits are within red limits.")
-          tf.unlink
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
-          tf.puts '    LIMITS DEFAULT 3 ENABLED 1 2 5 4'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "Invalid limits specified. Ensure yellow limits are within red limits.")
-          tf.unlink
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
-          tf.puts '    LIMITS DEFAULT 3 ENABLED 1 2 3 0'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "Invalid limits specified. Ensure yellow limits are within red limits.")
-          tf.unlink
-        end
-
-        it "should complain if the 6 limits are out of order" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
-          tf.puts '    LIMITS DEFAULT 3 ENABLED 1 2 6 7 0 5'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "Invalid limits specified. Ensure green limits are within yellow limits.")
-          tf.unlink
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
-          tf.puts '    LIMITS DEFAULT 3 ENABLED 1 3 6 7 2 5'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "Invalid limits specified. Ensure green limits are within yellow limits.")
-          tf.unlink
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
-          tf.puts '    LIMITS DEFAULT 3 ENABLED 1 2 6 8 3 7'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "Invalid limits specified. Ensure green limits are within yellow limits.")
-          tf.unlink
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
-          tf.puts '    LIMITS DEFAULT 3 ENABLED 1 2 6 8 3 9'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "Invalid limits specified. Ensure green limits are within yellow limits.")
-          tf.unlink
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
-          tf.puts '    LIMITS DEFAULT 3 ENABLED 1 2 6 8 4 3'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "Invalid limits specified. Ensure green limits are within yellow limits.")
-          tf.unlink
-        end
-
-        it "should take 4 limits values" do
+        it "ensures limits sets have unique names" do
           tf = Tempfile.new('unittest')
           tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
           tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
           tf.puts '    LIMITS DEFAULT 1 ENABLED 1 2 6 7'
+          tf.puts '    LIMITS TVAC 1 ENABLED 1 2 6 7'
+          tf.puts '    LIMITS DEFAULT 1 ENABLED 8 9 12 13'
           tf.close
           @pc.process_file(tf.path, "TGT1")
           item = @pc.telemetry["TGT1"]["PKT1"].items["ITEM1"]
-          item.limits.values[:DEFAULT].should_not be_nil
-          @pc.telemetry["TGT1"]["PKT1"].buffer = "\x04"
-          @pc.telemetry["TGT1"]["PKT1"].enable_limits("ITEM1")
-          @pc.telemetry["TGT1"]["PKT1"].check_limits
-          item.limits.state.should eql :GREEN
-          @pc.telemetry["TGT1"]["PKT1"].limits_items.should eql [item]
-          tf.unlink
-        end
-
-        it "should take 6 limits values" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_ITEM item1 16 UINT "Item"'
-          tf.puts '    LIMITS DEFAULT 1 ENABLED 1 2 6 7 3 5'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          item = @pc.telemetry["TGT1"]["PKT1"].items["ITEM1"]
-          item.limits.values[:DEFAULT].should_not be_nil
+          expect(item.limits.values.length).to eql 2
+          # Verify the last defined DEFAULT limits wins
           @pc.telemetry["TGT1"]["PKT1"].buffer = "\x04"
           @pc.telemetry["TGT1"]["PKT1"].enable_limits("ITEM1")
           @pc.telemetry["TGT1"]["PKT1"].check_limits
-          item.limits.state.should eql :BLUE
-          @pc.telemetry["TGT1"]["PKT1"].limits_items.should eql [item]
-          tf.unlink
-        end
-      end
-
-      context "with LIMITS_RESPONSE" do
-        it "should complain if applied to a command PARAMETER" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'COMMAND tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  APPEND_PARAMETER item1 16 UINT 0 0 0 "Item"'
-          tf.puts '    LIMITS_RESPONSE test.rb'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "LIMITS_RESPONSE only applies to telemetry items")
-          tf.unlink
-        end
-
-        it "should complain about missing response file" do
-          filename = File.join(File.dirname(__FILE__), "../test_only.rb")
-          File.delete(filename) if File.exist?(filename)
-          @pc = PacketConfig.new
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  ITEM item1 0 16 INT "Integer Item"'
-          tf.puts '    LIMITS DEFAULT 3 ENABLED 1 2 6 7 3 5'
-          tf.puts '    LIMITS_RESPONSE test_only.rb'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /TestOnly class not found/)
-          tf.unlink
-        end
-
-        it "should complain about a non Cosmos::LimitsResponse class" do
-          filename = File.join(File.dirname(__FILE__), "../limits_response1.rb")
-          File.open(filename, 'w') do |file|
-            file.puts "class LimitsResponse1"
-            file.puts "  def call(target_name, packet_name, item, old_limits_state, new_limits_state)"
-            file.puts "  end"
-            file.puts "end"
-          end
-          load 'limits_response1.rb'
-          File.delete(filename) if File.exist?(filename)
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  ITEM item1 0 16 INT "Integer Item"'
-          tf.puts '    LIMITS DEFAULT 3 ENABLED 1 2 6 7 3 5'
-          tf.puts '    LIMITS_RESPONSE limits_response1.rb'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /response must be a Cosmos::LimitsResponse but is a LimitsResponse1/)
-          tf.unlink
-        end
-
-        it "should set the response" do
-          filename = File.join(File.dirname(__FILE__), "../limits_response2.rb")
-          File.open(filename, 'w') do |file|
-            file.puts "require 'cosmos/packets/limits_response'"
-            file.puts "class LimitsResponse2 < Cosmos::LimitsResponse"
-            file.puts "  def call(target_name, packet_name, item, old_limits_state, new_limits_state)"
-            file.puts "    puts \"\#{target_name} \#{packet_name} \#{item.name} \#{old_limits_state} \#{new_limits_state}\""
-            file.puts "  end"
-            file.puts "end"
-          end
-          load 'limits_response2.rb'
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  ITEM item1 0 16 INT "Integer Item"'
-          tf.puts '    LIMITS DEFAULT 1 ENABLED 1 2 6 7 3 5'
-          tf.puts '    LIMITS_RESPONSE limits_response2.rb'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          pkt = @pc.telemetry["TGT1"]["PKT1"]
-          pkt.get_item("ITEM1").limits.response.class.should eql LimitsResponse2
-
-          File.delete(filename) if File.exist?(filename)
-          tf.unlink
-        end
-
-        it "should call the response with parameters" do
-          filename = File.join(File.dirname(__FILE__), "../limits_response2.rb")
-          File.open(filename, 'w') do |file|
-            file.puts "require 'cosmos/packets/limits_response'"
-            file.puts "class LimitsResponse2 < Cosmos::LimitsResponse"
-            file.puts "  def initialize(val)"
-            file.puts "    puts \"initialize: \#{val}\""
-            file.puts "  end"
-            file.puts "  def call(target_name, packet_name, item, old_limits_state, new_limits_state)"
-            file.puts "    puts \"\#{target_name} \#{packet_name} \#{item.name} \#{old_limits_state} \#{new_limits_state}\""
-            file.puts "  end"
-            file.puts "end"
-          end
-          load 'limits_response2.rb'
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  ITEM item1 0 16 INT "Integer Item"'
-          tf.puts '    LIMITS DEFAULT 1 ENABLED 1 2 6 7 3 5'
-          tf.puts '    LIMITS_RESPONSE limits_response2.rb 2'
-          tf.close
-          capture_io do |stdout|
-            @pc.process_file(tf.path, "TGT1")
-            stdout.string.should eql "initialize: 2\n"
-          end
-
-          File.delete(filename) if File.exist?(filename)
-          tf.unlink
-        end
-      end
-
-      context "with FORMAT_STRING" do
-        it "should complain about invalid format strings" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  ITEM item1 0 8 INT'
-          tf.puts '    FORMAT_STRING "%*s"'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "Invalid FORMAT_STRING specified for type INT: %*s")
-          tf.unlink
-
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  ITEM item1 0 8 STRING'
-          tf.puts '    FORMAT_STRING "%d"'
-          tf.close
-          expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, "Invalid FORMAT_STRING specified for type STRING: %d")
-          tf.unlink
-        end
-
-        it "should format integers" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  ITEM item1 0 8 INT'
-          tf.puts '    FORMAT_STRING "d%d"'
-          tf.puts '  ITEM item2 0 8 UINT'
-          tf.puts '    FORMAT_STRING "u%u"'
-          tf.puts '  ITEM item3 0 8 UINT'
-          tf.puts '    FORMAT_STRING "0x%x"'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          @pc.telemetry["TGT1"]["PKT1"].buffer = "\x0a\x0b\x0c"
-          @pc.telemetry["TGT1"]["PKT1"].read("ITEM1",:FORMATTED).should eql "d10"
-          @pc.telemetry["TGT1"]["PKT1"].read("ITEM2",:FORMATTED).should eql "u10"
-          @pc.telemetry["TGT1"]["PKT1"].read("ITEM3",:FORMATTED).should eql "0xa"
-          tf.unlink
-        end
-
-        it "should format floats" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  ITEM item1 0 32 FLOAT'
-          tf.puts '    FORMAT_STRING "%3.3f"'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          @pc.telemetry["TGT1"]["PKT1"].write("ITEM1",12345.12345)
-          @pc.telemetry["TGT1"]["PKT1"].read("ITEM1",:FORMATTED).should eql "12345.123"
-          tf.unlink
-        end
-
-        it "should format strings and blocks" do
-          tf = Tempfile.new('unittest')
-          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-          tf.puts '  ITEM item1 0 32 STRING'
-          tf.puts '    FORMAT_STRING "String: %s"'
-          tf.puts '  ITEM item2 0 32 BLOCK'
-          tf.puts '    FORMAT_STRING "Block: %s"'
-          tf.close
-          @pc.process_file(tf.path, "TGT1")
-          @pc.telemetry["TGT1"]["PKT1"].write("ITEM1","HI")
-          @pc.telemetry["TGT1"]["PKT1"].read("ITEM1",:FORMATTED).should eql "String: HI"
-          @pc.telemetry["TGT1"]["PKT1"].write("ITEM2","\x00\x01\x02\x03")
-          @pc.telemetry["TGT1"]["PKT1"].read("ITEM2",:FORMATTED).should eql "Block: \x00\x01\x02\x03"
+          item.limits.state.should eql :RED_LOW
           tf.unlink
         end
       end