cosmos 4.2.4-java → 4.5.0-java

data/spec/core_ext/socket_spec.rb

@@ -27,7 +27,7 @@ describe Socket do
     it "returns the hostname for the ip address" do
       if !ENV['APPVEYOR']
         ipaddr = Resolv.getaddress "localhost"
-        expect(Socket.lookup_hostname_from_ip(ipaddr)).to match("localhost")
+        expect(Socket.lookup_hostname_from_ip(ipaddr)).to_not be_nil
       end
     end
   end

data/spec/core_ext/time_spec.rb

@@ -183,6 +183,10 @@ describe Time do
       expect(parts[1]).to eql ccsds_ms
       expect(parts[2]).to be_within(50).of(ccsds_us)
     end
+
+    it "maintains precision" do
+      expect(Time.ccsds2sec(22766, 65115943, 552).round(6)).to eql(1967047515.943552)
+    end
   end
 
   describe "Time.yds2mdy" do

data/spec/gui/utilities/script_module_gui_spec.rb

@@ -12,89 +12,70 @@ if RUBY_ENGINE == 'ruby'
   require 'spec_helper'
   require 'cosmos/gui/qt'
   require 'cosmos/script'
-  require 'cosmos/gui/utilities/script_module_gui'
+  require 'cosmos/script/scripting'
 
   module Cosmos
     describe Script do
-      after(:all) do
-        # Load the original scripting file over the script_module_gui
-        load 'cosmos/script/scripting.rb'
-      end
-
-      def stub_null_object(constant)
-        class_double(constant).tap do |double|
-          stub_const(constant, double)
-          allow(double).to receive(:new).and_return(double(constant).as_null_object)
-          yield double if block_given?
-        end
-      end
-
-      let!(:qt_module) do
-        class_double('Qt').as_stubbed_const(:transfer_nested_constants => true).tap do |double|
-          stub_const('Qt', double)
-          stub_const('Qt::WindowTitleHint', double)
-          stub_const('Qt::WindowSystemMenuHint', double)
-          allow(double).to receive(:execute_in_main_thread).and_yield
-          allow(double).to receive(:debug_level)
-        end
-        stub_null_object('Qt::Widget')
-        stub_null_object('Qt::Dialog') do |double|
-          instance = double("Qt::Dialog").as_null_object
-          allow(instance).to receive(:exec).and_return 1 # break the loop by returning 1
-          allow(double).to receive(:new).and_return(instance)
-        end
-        # Stub Accepted to be 1 to match the instance exec returning 1
-        stub_const('Qt::Dialog::Accepted', 1)
-        stub_null_object('Qt::VBoxLayout')
-        stub_null_object('Qt::HBoxLayout')
-        stub_null_object('Qt::Label')
-        stub_null_object('Qt::PushButton')
-      end
-
       describe "combo_box" do
-        it "should not modify the inputs" do
-          class_double('Cosmos::ComboboxChooser').as_stubbed_const.tap do |double|
-            chooser = double("ComboboxChooser").as_null_object
-            allow(chooser).to receive(:sel_command_callback=) do |args|
-              # Simulate the user clicking the TEST option in the combobox
-              args.call("TEST")
-            end
-            allow(double).to receive(:new).and_return(chooser)
+        it "should not modify the button inputs" do
+          expect(self).to receive(:gets) { ' ' }
+          capture_io do |stdout|
+            buttons = %w(THIS IS A TEST)
+            combo_box("Combo box test", *buttons)
+            expect(buttons).to eq %w(THIS IS A TEST)
+            expect(stdout.string).to match(/Combo box test/)
           end
+        end
 
-          buttons = %w(THIS IS A TEST)
-          combo_box("HI", *buttons)
-          expect(buttons).to eq %w(THIS IS A TEST)
+        it "should display details" do
+          expect(self).to receive(:gets) { ' ' }
+          capture_io do |stdout|
+            buttons = %w(THIS IS A TEST)
+            combo_box("HI", *buttons, details: 'These are the details')
+            expect(stdout.string).to match(/These are the details/)
+          end
         end
       end
 
       describe "message_box" do
         it "should not modify the inputs" do
-          class_double('Qt::MessageBox').as_stubbed_const.tap do |double|
-            msg_box = double("MessageBox").as_null_object
-            allow(msg_box).to receive_message_chain(:clickedButton, :text).and_return("TEST")
-            allow(double).to receive(:new).and_return(msg_box)
-            stub_const('Qt::MessageBox::AcceptRole', 1)
-            stub_const('Qt::MessageBox::RejectRole', 0)
+          expect(self).to receive(:gets) { ' ' }
+          capture_io do |stdout|
+            buttons = %w(THIS IS A TEST)
+            message_box("Message box test", *buttons)
+            expect(buttons).to eq %w(THIS IS A TEST)
+            expect(stdout.string).to match(/Message box test/)
           end
+        end
 
-          buttons = %w(THIS IS A TEST)
-          message_box("HI", *buttons)
-          expect(buttons).to eq %w(THIS IS A TEST)
+        it "should display details" do
+          expect(self).to receive(:gets) { ' ' }
+          capture_io do |stdout|
+            buttons = %w(THIS IS A TEST)
+            message_box("HI", *buttons, details: 'These are the details')
+            expect(stdout.string).to match(/These are the details/)
+          end
         end
       end
 
       describe "vertical_message_box" do
         it "should not modify the inputs" do
-          stub_null_object('Qt::PushButton') do |double|
-            instance = double("Qt::PushButton").as_null_object
-            allow(instance).to receive(:connect).and_yield
-            allow(double).to receive(:new).and_return(instance)
+          expect(self).to receive(:gets) { ' ' }
+          capture_io do |stdout|
+            buttons = %w(THIS IS A TEST)
+            vertical_message_box("Vertical message box test", *buttons)
+            expect(buttons).to eq %w(THIS IS A TEST)
+            expect(stdout.string).to match(/Vertical message box test/)
           end
+        end
 
-          buttons = %w(THIS IS A TEST)
-          vertical_message_box("HI", *buttons)
-          expect(buttons).to eq %w(THIS IS A TEST)
+        it "should display details" do
+          expect(self).to receive(:gets) { ' ' }
+          capture_io do |stdout|
+            buttons = %w(THIS IS A TEST)
+            vertical_message_box("HI", *buttons, details: 'These are the details')
+            expect(stdout.string).to match(/These are the details/)
+          end
         end
       end
     end

data/spec/install/config/targets/INST/cmd_tlm/inst_cmds.txt

@@ -15,7 +15,7 @@ COMMAND INST COLLECT BIG_ENDIAN "Starts a collect on the instrument"
   PARAMETER    OPCODE        112   8  UINT 0x0 0xFF 0xAB "Collect opcode"
     FORMAT_STRING "0x%0X"
   PARAMETER    TEMP          120  32  FLOAT 0.0 25.0 0.0 "Collect temperature"
-    UNITS Celcius C
+    UNITS Celsius C
 
 COMMAND INST ABORT BIG_ENDIAN "Aborts a collect on the instrument"
   PARAMETER    CCSDSVER        0   3  UINT  0     0   0 "CCSDS primary header version number"

data/spec/install/config/targets/INST/cmd_tlm/inst_tlm.txt

@@ -21,28 +21,28 @@ TELEMETRY INST HEALTH_STATUS BIG_ENDIAN "Health and status from the instrument"
   ITEM TEMP1            144 16 UINT     "Temperature #1"
     POLY_READ_CONVERSION  -100.0 0.00305
     POLY_WRITE_CONVERSION 32768.885246 327.86885
-    UNITS CELCIUS C
+    UNITS CELSIUS C
     FORMAT_STRING "%0.3f"
     LIMITS DEFAULT 1 ENABLED -80.0 -70.0 60.0 80.0 -20.0 20.0
     LIMITS TVAC 1     ENABLED -80.0 -30.0 30.0 80.0
   ITEM TEMP2            160 16 UINT     "Temperature #2"
     POLY_READ_CONVERSION -100.0 0.00305
     POLY_WRITE_CONVERSION 32768.885246 327.86885
-    UNITS CELCIUS C
+    UNITS CELSIUS C
     FORMAT_STRING "%0.3f"
     LIMITS DEFAULT 1 ENABLED -60.0 -55.0 30.0 35.0
     LIMITS TVAC 1 ENABLED -60.0 20.0 30.0 35.0
   ITEM TEMP3            176 16 UINT     "Temperature #3"
     POLY_READ_CONVERSION -100.0 0.00305
     POLY_WRITE_CONVERSION 32768.885246 327.86885
-    UNITS CELCIUS C
+    UNITS CELSIUS C
     FORMAT_STRING "%0.3f"
     LIMITS DEFAULT 1 ENABLED -25.0 -10.0 50.0 55.0
     LIMITS TVAC 1 ENABLED -15.0 -10.0 20.0 30.0
   ITEM TEMP4            192 16 UINT     "Temperature #4"
     POLY_READ_CONVERSION -100.0 0.00305
     POLY_WRITE_CONVERSION 32768.885246 327.86885
-    UNITS CELCIUS C
+    UNITS CELSIUS C
     FORMAT_STRING "%0.3f"
     LIMITS DEFAULT 1 ENABLED -80.0 -70.0 60.0 80.0
   ARRAY_ITEM ARY              208 8 UINT 80 "Array data"
@@ -52,7 +52,7 @@ TELEMETRY INST HEALTH_STATUS BIG_ENDIAN "Health and status from the instrument"
     STATE NORMAL  0
     STATE SPECIAL 1
   APPEND_ARRAY_ITEM ARY2      64 FLOAT 640 "Double array"
-    UNITS CELCIUS C
+    UNITS CELSIUS C
   APPEND_ITEM ASCIICMD 2048 STRING "Most recent ASCIICMD string"
     STATE "NOOP" "NOOP"
     STATE "FIRE LASER" "FIRE LASER"

data/spec/install/yaml_docs_spec.rb

@@ -0,0 +1,132 @@
+
+require 'spec_helper'
+require 'find'
+require 'cosmos/system'
+require 'cosmos/config/meta_config_parser'
+
+module Cosmos
+  describe Cosmos do
+    # These are not expected to be documented as they are deprecated
+    DEPRECATED = %w(MACRO_APPEND_START MACRO_APPEND_END ROUTER_LOG_RAW IGNORE REQUIRE_UTILITY)
+    # These source keywords are ignored in the YAML
+    EXCEPTIONS = %w(LAUNCH LAUNCH_TERMINAL LAUNCH_GEM CONVERTED RAW FORMATTED WITH_UNITS NONE)
+    EXCEPTIONS.concat(%w(MINUTE HOUR DAY AVG MIN MAX STDDEV AGING CRC OVERRIDE))
+    # These are not documented because OpenGL is not officially a tool
+    OPENGL = %w(STL_FILE TEXTURE_MAPPED_SPHERE TIP_TEXT POSITION ROTATION_X ROTATION_Y ROTATION_Z)
+    OPENGL.concat(%w(ZOOM ORIENTATION CENTER BOUNDS))
+
+    def process_line(line)
+      line.split(',').each do |item|
+        item.strip!
+        if (item[0] == "'" || item[0] == '"') && (item[-1] == "'" || item[-1] == '"')
+          @src_keywords << item[1..-2]
+        end
+      end
+    end
+
+    def process_continuation(line)
+      if line[-1] == "\\"
+        continuation = true
+        line = line[0..-2] # remove the continuation character
+      else
+        continuation = false
+      end
+      return continuation
+    end
+
+    def get_src_keywords
+      @src_keywords = []
+      path = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/**/*.rb"))
+      Dir[path].each do |filename|
+        data = File.read(filename)
+        part = nil
+        if data.include?('parser.parse_file')
+          part = data.split('parser.parse_file')[1..-1].join
+        elsif data.include?('handle_keyword(parser, keyword, parameters)')
+          part = data.split('handle_keyword(parser, keyword, parameters)')[1..-1].join
+        end
+        if part
+          continuation = false
+          part.split("\n").each do |line|
+            if continuation
+              continuation = process_continuation(line)
+              process_line(line)
+            end
+            if match = line.match(/when (.*)/)
+              line = match.captures[0]
+              continuation = process_continuation(line)
+              process_line(line)
+            end
+          end
+        end
+      end
+
+      # All the widgets are referenced in screen definitions
+      path = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/cosmos/tools/tlm_viewer/widgets/*_widget.rb"))
+      Dir[path].each do |filename|
+        @src_keywords << filename.split('/')[-1].split('_widget.rb')[0].upcase
+      end
+      # Remove the base classes
+      @src_keywords -= %w(CANVASVALUE LAYOUT MULTI)
+      # Add specific keyword(s) that we want to document
+      @src_keywords.concat(%w(NAMED_WIDGET))
+
+      # All the protocols are referenced as keywords in INTERFACES
+      path = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/cosmos/interfaces/protocols/*_protocol.rb"))
+      Dir[path].each do |filename|
+        @src_keywords << filename.split('/')[-1].split('_protocol.rb')[0].upcase
+      end
+
+      # Remove things we don't document
+      @src_keywords.uniq!
+      @src_keywords -= (DEPRECATED + EXCEPTIONS + OPENGL)
+
+      #puts "Total source keywords: #{@src_keywords.length}"
+      expect(@src_keywords.length > 100) # Sanity check
+    end
+
+    def process_meta(yaml_keywords, meta)
+      meta.each do |keyword, data|
+        next unless keyword.is_a?(String) && keyword.upcase == keyword
+        next if keyword == 'UNKNOWN' # Ignore the UNKNOWN placeholder
+
+        if data['modifiers']
+          process_meta(yaml_keywords, data['modifiers'])
+        end
+        yaml_keywords << keyword
+      end
+    end
+
+    def get_yaml_keywords
+      @yaml_keywords = []
+      path = File.expand_path(File.join(File.dirname(__FILE__), "../../data/config/*.yaml"))
+      Dir[path].each do |filename|
+        meta = Cosmos::MetaConfigParser.load(filename)
+        process_meta(@yaml_keywords, meta)
+      end
+      #puts "Total yaml keywords: #{@yaml_keywords.length}"
+      expect(@yaml_keywords.length > 100) # Sanity check
+    end
+
+    before(:all) do
+      get_src_keywords()
+      get_yaml_keywords()
+    end
+
+    it "should document all source keywords" do
+      undocumented = []
+      @src_keywords.each do |keyword|
+        undocumented << keyword unless @yaml_keywords.include?(keyword)
+      end
+      expect(undocumented).to be_empty, "Following source keywords not in YAML: #{undocumented}"
+    end
+
+    it "should not have extra keywords" do
+      extra = []
+      @yaml_keywords.each do |keyword|
+        extra << keyword unless @src_keywords.include?(keyword)
+      end
+      expect(extra).to be_empty, "Following YAML keywords not in source: #{extra}"
+    end
+  end
+end

data/spec/interfaces/linc_interface_spec.rb

@@ -179,7 +179,7 @@ module Cosmos
         it "warns if an error code is set" do
           allow_any_instance_of(TcpipClientStream).to receive(:read).and_return @handshake.buffer(false)
           expect(Logger).to receive(:warn) do |msg|
-            expect(msg).to eql "Warning sending command (12345): BAD"
+            expect(msg).to eql "LincInterface: Warning sending command (12345): BAD"
           end
           t = Thread.new do
             sleep 0.1

data/spec/interfaces/protocols/fixed_protocol_spec.rb

@@ -90,6 +90,7 @@ module Cosmos
       end
 
       it "reads telemetry data from the stream" do
+        target = System.targets['SYSTEM']
         @interface.add_protocol(FixedProtocol, [1], :READ_WRITE)
         @interface.instance_variable_set(:@stream, FixedStream.new)
         @interface.target_names = ['SYSTEM']
@@ -103,6 +104,7 @@ module Cosmos
         expect(packet.received_time.to_f).to be_within(0.1).of(Time.now.to_f)
         expect(packet.target_name).to eql 'SYSTEM'
         expect(packet.packet_name).to eql 'LIMITS_CHANGE'
+        target.tlm_unique_id_mode = true
         $index = 1
         packet = @interface.read
         expect(packet.received_time.to_f).to be_within(0.1).of(Time.now.to_f)
@@ -113,30 +115,39 @@ module Cosmos
         expect(packet.received_time.to_f).to be_within(0.1).of(Time.now.to_f)
         expect(packet.target_name).to eql 'SYSTEM'
         expect(packet.packet_name).to eql 'LIMITS_CHANGE'
+        target.tlm_unique_id_mode = false
       end
 
       it "reads command data from the stream" do
-        $index = 0
+        target = System.targets['SYSTEM']
+        packet = System.commands.packet("SYSTEM", "STARTLOGGING")
+        packet.restore_defaults
+        $buffer = packet.buffer.clone
         class FixedStream2 < Stream
           def connect; end
           def connected?; true; end
           def read
-            case $index
-            when 0
-              $index += 1
-              "\x1A\xCF\xFC\x1D\x00\x00\x00\x02"
-            else
-              "\x00\x00\x00\x00\x00\x00\x00\x00"
-            end
+            # Prepend a matching sync pattern to test the discard
+            "\x1A\xCF\xFC\x1D\x55\x55" << $buffer
           end
         end
-        @interface.add_protocol(FixedProtocol, [8, 0, '0x1ACFFC1D', false], :READ_WRITE)
+        # Require 8 bytes, discard 6 leading bytes, use 0x1ACFFC1D sync, telemetry = false (command)
+        @interface.add_protocol(FixedProtocol, [8, 6, '0x1ACFFC1D', false], :READ_WRITE)
         @interface.instance_variable_set(:@stream, FixedStream2.new)
         @interface.target_names = ['SYSTEM']
+        target.cmd_unique_id_mode = false
         packet = @interface.read
         expect(packet.received_time.to_f).to be_within(0.01).of(Time.now.to_f)
         expect(packet.target_name).to eql 'SYSTEM'
         expect(packet.packet_name).to eql 'STARTLOGGING'
+        expect(packet.buffer).to eql $buffer
+        target.cmd_unique_id_mode = true
+        packet = @interface.read
+        expect(packet.received_time.to_f).to be_within(0.01).of(Time.now.to_f)
+        expect(packet.target_name).to eql 'SYSTEM'
+        expect(packet.packet_name).to eql 'STARTLOGGING'        
+        expect(packet.buffer).to eql $buffer
+        target.cmd_unique_id_mode = false
       end
     end
   end

data/spec/interfaces/protocols/ignore_packet_protocol_spec.rb

@@ -0,0 +1,243 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'spec_helper'
+require 'cosmos/interfaces/protocols/ignore_packet_protocol'
+require 'cosmos/interfaces/interface'
+require 'cosmos/streams/stream'
+
+module Cosmos
+  describe IgnorePacketProtocol do
+    before(:each) do
+      $buffer = nil
+      @interface = StreamInterface.new
+      @interface.target_names = ['SYSTEM', 'INST']
+      allow(@interface).to receive(:connected?) { true }
+    end
+
+    class PreStream < Stream
+      def connect; end
+      def connected?; true; end
+      def disconnect; end
+      def read; $buffer; end
+      def write(data); $buffer = data; end
+    end
+
+    describe "initialize" do
+      it "complains if target is not given" do
+        expect { @interface.add_protocol(IgnorePacketProtocol, [], :READ_WRITE) }.to raise_error(ArgumentError)
+      end
+
+      it "complains if packet is not given" do
+        expect { @interface.add_protocol(IgnorePacketProtocol, ['SYSTEM'], :READ_WRITE) }.to raise_error(ArgumentError)
+      end
+
+      it "complains if the target is not found" do
+        expect { @interface.add_protocol(IgnorePacketProtocol, ['BLAH', 'META'], :READ_WRITE) }.to raise_error(/target 'BLAH' does not exist/)
+      end
+
+      it "complains if the target is not found" do
+        expect { @interface.add_protocol(IgnorePacketProtocol, ['SYSTEM', 'BLAH'], :READ_WRITE) }.to raise_error(/packet 'SYSTEM BLAH' does not exist/)
+      end
+    end
+
+    describe "read" do
+      it "ignores the packet specified" do
+        @interface.instance_variable_set(:@stream, PreStream.new)
+        pkt = System.telemetry.packet("SYSTEM","META")
+        # Ensure the ID items are set so this packet can be identified
+        pkt.id_items.each do |item|
+          pkt.write_item(item, item.id_value)
+        end
+        pkt.received_time = Time.now
+        $buffer = nil
+        @interface.write(pkt)
+        # Verify the write went out
+        expect(pkt.buffer).to eql $buffer
+        # Verify we read the packet back
+        packet = @interface.read
+        expect(packet.buffer).to eql $buffer
+
+        # Now add the protocol to ignore the packet
+        @interface.add_protocol(IgnorePacketProtocol, ['SYSTEM', 'META'], :READ)
+        $buffer = nil
+        @interface.write(pkt)
+        packet = nil
+        # Try to read the interface
+        # We put this in a thread because it calls it continuously
+        thread = Thread.new do
+          packet = @interface.read
+        end
+        sleep 0.1
+        thread.kill
+        sleep 0.2 # Allow thread to die
+        expect(packet).to be_nil
+      end
+
+      it "can be added multiple times to ignore different packets" do
+        @interface.instance_variable_set(:@stream, PreStream.new)
+
+        pkt = System.telemetry.packet("INST","HEALTH_STATUS")
+        # Ensure the ID items are set so this packet can be identified
+        pkt.id_items.each do |item|
+          pkt.write_item(item, item.id_value)
+        end
+        pkt.received_time = Time.now
+        $buffer = nil
+        @interface.write(pkt)
+        expect($buffer).to eql pkt.buffer
+
+        # Verify we read the packet back
+        packet = @interface.read
+        expect(packet.buffer).to eql $buffer
+
+        # Now add the protocol to ignore the packet
+        @interface.add_protocol(IgnorePacketProtocol, ['INST', 'HEALTH_STATUS'], :READ)
+        $buffer = nil
+        @interface.write(pkt)
+        expect($buffer).to eql pkt.buffer
+        packet = nil
+        # Try to read the interface
+        # We put this in a thread because it calls it continuously
+        thread = Thread.new do
+          packet = @interface.read
+        end
+        sleep 0.1
+        thread.kill
+        sleep 0.2 # Allow thread to die
+        expect(packet).to be_nil
+
+        # Add another protocol to ignore another packet
+        @interface.add_protocol(IgnorePacketProtocol, ['INST', 'ADCS'], :READ)
+
+        pkt = System.telemetry.packet("INST","ADCS")
+        # Ensure the ID items are set so this packet can be identified
+        pkt.id_items.each do |item|
+          pkt.write_item(item, item.id_value)
+        end
+        pkt.received_time = Time.now
+        $buffer = nil
+        @interface.write(pkt)
+        expect($buffer).to eql pkt.buffer
+
+        packet = nil
+        # Try to read the interface
+        # We put this in a thread because it calls it continuously
+        thread = Thread.new do
+          packet = @interface.read
+        end
+        sleep 0.1
+        thread.kill
+        sleep 0.2 # Allow thread to die
+        expect(packet).to be_nil
+
+        pkt = System.telemetry.packet("INST","PARAMS")
+        # Ensure the ID items are set so this packet can be identified
+        pkt.id_items.each do |item|
+          pkt.write_item(item, item.id_value)
+        end
+        pkt.received_time = Time.now
+        $buffer = nil
+        @interface.write(pkt)
+        # Verify the write went out
+        expect($buffer).to eql pkt.buffer
+
+        packet = @interface.read
+        expect(packet.buffer).to eql pkt.buffer
+      end
+    end
+
+    describe "write" do
+      it "ignores the packet specified" do
+        @interface.instance_variable_set(:@stream, PreStream.new)
+        @interface.add_protocol(IgnorePacketProtocol, ['SYSTEM', 'META'], :WRITE)
+        pkt = System.telemetry.packet("SYSTEM","META")
+        pkt.write("COSMOS_VERSION", "TEST")
+        pkt.received_time = Time.now
+        $buffer = nil
+        @interface.write(pkt)
+        # Verify the write was ignored
+        expect($buffer).to be_nil
+
+        # Verify reading the interface works
+        $buffer = pkt.buffer
+        packet = @interface.read
+        expect(packet.buffer).to eql $buffer
+      end
+
+      it "can be added multiple times to ignore different packets" do
+        @interface.instance_variable_set(:@stream, PreStream.new)
+        @interface.add_protocol(IgnorePacketProtocol, ['INST', 'HEALTH_STATUS'], :WRITE)
+        @interface.add_protocol(IgnorePacketProtocol, ['INST', 'ADCS'], :WRITE)
+
+        pkt = System.telemetry.packet("INST","HEALTH_STATUS")
+        pkt.received_time = Time.now
+        $buffer = nil
+        @interface.write(pkt)
+        # Verify the write was ignored
+        expect($buffer).to be_nil
+
+        pkt = System.telemetry.packet("INST","ADCS")
+        pkt.received_time = Time.now
+        $buffer = nil
+        @interface.write(pkt)
+        # Verify the write was ignored
+        expect($buffer).to be_nil
+
+        pkt = System.telemetry.packet("INST","PARAMS")
+        pkt.received_time = Time.now
+        $buffer = nil
+        @interface.write(pkt)
+        # Verify the write went out
+        expect($buffer).to eql pkt.buffer
+      end
+    end
+
+    describe "read/write" do
+      it "ignores the packet specified" do
+        @interface.instance_variable_set(:@stream, PreStream.new)
+        @interface.add_protocol(IgnorePacketProtocol, ['SYSTEM', 'META'], :READ_WRITE)
+        pkt = System.telemetry.packet("SYSTEM","META")
+        pkt.write("COSMOS_VERSION", "TEST")
+        pkt.received_time = Time.now
+        $buffer = nil
+        @interface.write(pkt)
+        # Verify the write was ignored
+        expect($buffer).to be_nil
+
+        packet = nil
+        # Try to read the interface
+        thread = Thread.new do
+          packet = @interface.read
+        end
+        sleep 0.1
+        thread.kill
+        sleep 0.2 # Allow thread to die
+        expect(packet).to be_nil
+      end
+
+      it "reads and writes unknown packets" do
+        @interface.instance_variable_set(:@stream, PreStream.new)
+        @interface.add_protocol(IgnorePacketProtocol, ['SYSTEM', 'META'], :READ_WRITE)
+        $buffer = nil
+        pkt = Packet.new("TGT","PTK")
+        pkt.append_item("ITEM", 8, :INT)
+        pkt.write("ITEM", 33, :RAW)
+        @interface.write(pkt)
+        # Verify the write went out
+        expect(pkt.buffer).to eql $buffer
+
+        # Verify the read works
+        packet = @interface.read
+        expect(packet.buffer).to eq $buffer
+      end
+    end
+  end
+end