cosmos 4.0.3 → 4.1.0

data/spec/packet_logs/packet_log_reader_spec.rb

@@ -180,7 +180,10 @@ module Cosmos
 
         # Corrupt the second config
         second_config_path = System.instance.send(:find_configuration, second_config_name)
-        FileUtils.mv File.join(second_config_path, 'system.txt'), File.join(second_config_path, 'system2.txt')
+        md5 = File.basename(second_config_path, '.*')
+        Zip::File.open(second_config_path) do |zip|
+          zip.file.rename(File.join(md5, 'system.txt'), File.join(md5, 'system2.txt'))
+        end
 
         # Return to original config
         System.load_configuration
@@ -195,7 +198,7 @@ module Cosmos
         FileUtils.mv File.join(Cosmos::USERPATH, 'system.txt'),
           File.join(Cosmos::USERPATH,'config','system')
 
-        File.delete(File.join(@config_targets,'SYSTEM','cmd_tlm','test1_tlm.txt'))
+        FileUtils.rm_f(File.join(@config_targets,'SYSTEM','cmd_tlm','test1_tlm.txt'))
       end
     end
 

data/spec/packets/binary_accessor_spec.rb

@@ -975,7 +975,7 @@ module Cosmos
       it "complains about writing a frozen buffer" do
         buffer = "BLANK WORLD".freeze
         string = "HELLO"
-        expect {BinaryAccessor.write(string, 0, string.length*8, :STRING, buffer, :BIG_ENDIAN, :ERROR) }.to raise_error(RuntimeError, "can't modify frozen String")
+        expect {BinaryAccessor.write(string, 0, string.length*8, :STRING, buffer, :BIG_ENDIAN, :ERROR) }.to raise_error(RuntimeError, /can't modify frozen String/)
       end
 
       it "writes aligned 8-bit unsigned integers" do

data/spec/packets/packet_item_spec.rb

@@ -324,7 +324,7 @@ module Cosmos
     describe "clone" do
       it "duplicates the entire PacketItem" do
         pi2 = @pi.clone
-        expect(@pi == pi2).to be true
+        expect(@pi < pi2).to be true
       end
     end
 

data/spec/packets/structure_item_spec.rb

@@ -149,8 +149,8 @@ module Cosmos
         expect(si1 > si2).to be false
 
         si2 = StructureItem.new("si2", 0, 8, :UINT, :BIG_ENDIAN, nil)
-        expect(si1 < si2).to be false
-        expect(si1 == si2).to be true
+        expect(si1 < si2).to be true
+        expect(si1 == si2).to be false
         expect(si1 > si2).to be false
       end
 
@@ -170,9 +170,8 @@ module Cosmos
         expect(si1 > si2).to be true
 
         si2 = StructureItem.new("si2", -8, 8, :UINT, :BIG_ENDIAN, nil)
-        expect(si1 < si2).to be false
-        # si1 == si2 even though they have different names and sizes
-        expect(si1 == si2).to be true
+        expect(si1 < si2).to be true
+        expect(si1 == si2).to be false
         expect(si1 > si2).to be false
       end
 
@@ -189,7 +188,7 @@ module Cosmos
       it "duplicates the entire structure item " do
         si1 = StructureItem.new("si1", -8, 1, :UINT, :LITTLE_ENDIAN, nil)
         si2 = si1.clone
-        expect(si1 == si2).to be true
+        expect(si1 < si2).to be true
       end
     end
 

data/spec/script/cmd_tlm_server_spec.rb

@@ -70,7 +70,7 @@ module Cosmos
       end
     end
 
-    describe "get_interface_info" do 
+    describe "get_interface_info" do
       it "returns interface info" do
         state, clients, tx_q_size, rx_q_size, bytes_tx, bytes_rx, cmd_cnt, tlm_cnt = get_interface_info("INST_INT")
         connect_interface("INST_INT")
@@ -86,7 +86,7 @@ module Cosmos
       end
     end
 
-    describe "get_router_info" do 
+    describe "get_router_info" do
       it "returns router info" do
         connect_router("PREIDENTIFIED_ROUTER")
         state, clients, tx_q_size, rx_q_size, bytes_tx, bytes_rx, pkts_rcvd, pkts_sent = get_router_info("PREIDENTIFIED_ROUTER")
@@ -110,6 +110,20 @@ module Cosmos
       end
     end
 
+    describe "get_target_ignored_parameters" do
+      it "returns ignored parameters" do
+        params = get_target_ignored_parameters("INST")
+        expect(params.length).to be >= 0
+      end
+    end
+
+    describe "get_target_ignored_items" do
+      it "returns ignored items" do
+        items = get_target_ignored_items("INST")
+        expect(items.length).to be >= 0
+      end
+    end
+
     describe "get_cmd_cnt" do
       it "returns cmd count" do
         expect(get_cmd_cnt("INST", "COLLECT")).to be >= 0
@@ -122,9 +136,16 @@ module Cosmos
       end
     end
 
+    describe "get_packet_loggers" do
+      it "returns all the packet logger names" do
+        loggers = get_packet_loggers()
+        expect(loggers).to include("DEFAULT")
+      end
+    end
+
     describe "get_packet_logger_info" do
       it "returns packet logger info" do
-        interfaces, cmd_logging, cmd_q_size, cmd_filename, cmd_file_size, 
+        interfaces, cmd_logging, cmd_q_size, cmd_filename, cmd_file_size,
                     tlm_logging, tlm_q_size, tlm_filename, tlm_file_size, = get_packet_logger_info("DEFAULT")
         expect(interfaces).to include("INST_INT")
         expect(cmd_logging).to eql true
@@ -171,6 +192,20 @@ module Cosmos
       end
     end
 
+    describe "subscribe_server_messages, get_server_message, unsubscribe_server_messages" do
+      it "raises an error if non_block and the queue is empty" do
+        id = subscribe_server_messages
+        expect { get_server_message(id, true) }.to raise_error(ThreadError, "queue empty")
+        unsubscribe_server_messages(id)
+      end
+
+      it "subscribes and gets server messages" do
+        id = subscribe_server_messages
+        CmdTlmServer.instance.post_server_message("This is a test")
+        result = get_server_message(id, true)
+        expect(result).to eql "This is a test"
+        unsubscribe_server_messages(id)
+      end
+    end
   end
 end
-

data/spec/script/commands_disconnect_spec.rb

@@ -254,7 +254,7 @@ module Cosmos
     describe "get_cmd_param_list" do
       it "returns all the parameters for a command" do
         list = get_cmd_param_list("INST", "COLLECT")
-        expect(list).to include(["TYPE", 0, {"NORMAL"=>0, "SPECIAL"=>1}, "Collect type", nil, nil, true])
+        expect(list).to include(["TYPE", 0, {"NORMAL"=>0, "SPECIAL"=>1}, "Collect type", nil, nil, true, "UINT"])
       end
     end
 

data/spec/script/commands_spec.rb

@@ -272,7 +272,8 @@ module Cosmos
     describe "get_cmd_param_list" do
       it "returns all the parameters for a command" do
         list = get_cmd_param_list("INST", "COLLECT")
-        expect(list).to include(["TYPE", 0, {"NORMAL"=>0, "SPECIAL"=>1}, "Collect type", nil, nil, true])
+        #puts list
+        expect(list).to include(["TYPE", 0, {"NORMAL"=>0, "SPECIAL"=>1}, "Collect type", nil, nil, true, "UINT"])
       end
     end
 

data/spec/script/scripting_spec.rb

@@ -79,21 +79,37 @@ module Cosmos
       it "gets file listings" do
         capture_io do |stdout|
           expect(self).to receive(:gets) { 'file' }
-          expect(save_file_dialog(Dir.pwd, "Save Something!!!")).to eql 'file'
+          expect(save_file_dialog()).to eql 'file'
+          expect(stdout.string).to include "Save File"
+          stdout.rewind
+          expect(self).to receive(:gets) { 'file' }
+          expect(save_file_dialog(Dir.pwd, "Save Something!!!", "*.txt")).to eql 'file'
           expect(stdout.string).to include "Save Something!!!"
           stdout.rewind
           expect(self).to receive(:gets) { 'file' }
-          expect(open_file_dialog("C:/")).to eql 'file'
+          expect(open_file_dialog()).to eql 'file'
           expect(stdout.string).to include "Open File"
           stdout.rewind
           expect(self).to receive(:gets) { 'file' }
+          expect(open_file_dialog(Dir.pwd, "Test Open", "*.txt")).to eql 'file'
+          expect(stdout.string).to include "Test Open"
+          stdout.rewind
+          expect(self).to receive(:gets) { 'file' }
           expect(open_files_dialog()).to eql 'file'
           expect(stdout.string).to include "Open File(s)"
           stdout.rewind
+          expect(self).to receive(:gets) { 'file' }
+          expect(open_files_dialog(Dir.pwd, "Test Open Files")).to eql 'file'
+          expect(stdout.string).to include "Test Open Files"
+          stdout.rewind
           expect(self).to receive(:gets) { 'dir' }
           expect(open_directory_dialog()).to eql 'dir'
           expect(stdout.string).to include "Open Directory"
           stdout.rewind
+          expect(self).to receive(:gets) { 'dir' }
+          expect(open_directory_dialog(Dir.pwd, "Test Dir")).to eql 'dir'
+          expect(stdout.string).to include "Test Dir"
+          stdout.rewind
         end
       end
     end
@@ -742,4 +758,3 @@ module Cosmos
 
   end
 end
-

data/spec/script/telemetry_spec.rb

@@ -168,6 +168,11 @@ module Cosmos
         expect(packet.target_name).to eql "SYSTEM"
         expect(packet.packet_name).to eql "META"
         expect(packet.received_time).to be_within(1).of Time.now
+        expect(packet.received_count).to eql 0
+        packet = get_packet(id)
+        expect(packet.target_name).to eql "SYSTEM"
+        expect(packet.packet_name).to eql "META"
+        expect(packet.received_time).to be_within(1).of Time.now
         expect(packet.received_count).to eql 1
         unsubscribe_packet_data(id)
       end

data/spec/spec_helper.rb

@@ -20,13 +20,12 @@ def load(file, wrap = false)
 end
 
 # NOTE: You MUST require simplecov before anything else!
-if RUBY_ENGINE == 'ruby' and !ENV['COSMOS_NO_SIMPLECOV']
+if !ENV['COSMOS_NO_SIMPLECOV']
   require 'simplecov'
-  require 'coveralls'
-  Coveralls.wear!
+  require 'codecov'
   SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
     SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
+    SimpleCov::Formatter::Codecov,
   ])
   SimpleCov.start do
     merge_timeout 12 * 60 * 60 # merge the last 12 hours of results
@@ -87,32 +86,16 @@ RSpec.configure do |config|
     Cosmos.disable_warnings do
       Object.const_set(:STDOUT, $saved_stdout_const)
     end
-    if RUBY_ENGINE == 'ruby'
-      # Kill any leftover threads
-      if Thread.list.length > 1
-        Thread.list.each do |t|
-          t.kill if t != Thread.current
-        end
-        sleep(0.2)
-      end
-    else
-      # Kill any leftover threads
-      if Thread.list.length > 2
-        Thread.list[2..-1].each do |t|
-          t.kill if t != Thread.current
-        end
-        sleep(0.2)
-      end
-    end
+    kill_leftover_threads()
   end
 
   config.after(:each) do
     # Make sure we didn't leave any lingering threads
-    if RUBY_ENGINE == 'ruby'
-      expect(Thread.list.length).to eql(1), "At end of test expect 1 remaining thread but found #{Thread.list.length}.\nEnsure you kill all spawned threads before the test finishes."
-    else
-      expect(Thread.list.length).to be <= 2, "At end of test expect 2 remaining thread but found #{Thread.list.length}.\nEnsure you kill all spawned threads before the test finishes."
-    end
+    threads = running_threads()
+    thread_count = threads.size()
+    running_threads_str = threads.join("\n")
+
+    expect(thread_count).to eql(1), "At end of test expect 1 remaining thread but found #{thread_count}.\nEnsure you kill all spawned threads before the test finishes.\nThreads:\n#{running_threads_str}"
   end
 end
 
@@ -152,6 +135,40 @@ def capture_io
   $stdout = STDOUT
 end
 
+# Get a list of running threads, ignoring jruby system threads if necessary.
+def running_threads
+  threads = []
+  Thread.list.each do |t|
+    if RUBY_ENGINE == 'jruby'
+      thread_name = JRuby.reference(t).native_thread.get_name
+      threads << t.inspect unless thread_name == "Finalizer" or thread_name.include?("JRubyWorker")
+    else
+      threads << t.inspect
+    end
+  end
+  return threads
+end
+
+# Kill threads that are not "main", ignoring jruby system threads if necessary.
+def kill_leftover_threads
+  if RUBY_ENGINE == 'jruby'
+    if Thread.list.length > 2
+      Thread.list.each do |t|
+        thread_name = JRuby.reference(t).native_thread.get_name
+        t.kill if t != Thread.current and thread_name != "Finalizer" and !thread_name.include?("JRubyWorker")
+      end
+      sleep(0.2)
+    end
+  else
+    if Thread.list.length > 1
+      Thread.list.each do |t|
+        t.kill if t != Thread.current
+      end
+      sleep(0.2)
+    end
+  end
+end
+
 RSpec.configure do |c|
   if ENV.key?("PROFILE")
     c.before(:suite) do

data/spec/streams/tcpip_socket_stream_spec.rb

@@ -164,7 +164,7 @@ module Cosmos
             4
           end
         end
-        expect(IO).to receive(:select).at_least(:once).and_return([])
+        expect(IO).to receive(:fast_select).at_least(:once).and_return([])
         $index = 1
         ss = TcpipSocketStream.new(write,nil,nil,nil)
         ss.connect
@@ -174,7 +174,7 @@ module Cosmos
       it "handles socket timeouts" do
         write = double("write_socket")
         allow(write).to receive(:write_nonblock).and_raise(Errno::EWOULDBLOCK)
-        expect(IO).to receive(:select).at_least(:once).and_return(nil)
+        expect(IO).to receive(:fast_select).at_least(:once).and_return(nil)
         ss = TcpipSocketStream.new(write,nil,nil,nil)
         ss.connect
         expect { ss.write('test') }.to raise_error(Timeout::Error)

data/spec/system/system_spec.rb

@@ -44,7 +44,7 @@ module Cosmos
     describe "instance" do
       it "creates default ports" do
         # Don't check the actual port numbers but just that they exist
-        expect(System.ports.keys).to eql %w(CTS_API TLMVIEWER_API CTS_PREIDENTIFIED CTS_CMD_ROUTER)
+        expect(System.ports.keys).to eql %w(CTS_API TLMVIEWER_API CTS_PREIDENTIFIED CTS_CMD_ROUTER REPLAY_API REPLAY_PREIDENTIFIED REPLAY_CMD_ROUTER)
       end
 
       it "creates default paths" do
@@ -201,7 +201,7 @@ module Cosmos
        # Force a reload of the configuration
        System.class_eval('@@instance = nil')
        capture_io do |stdout|
-         allow(FileUtils).to receive(:cp_r) { raise "Error" }
+         allow(Zip::File).to receive(:open) { raise "Error" }
          System.commands
          expect(stdout.string).to match "Problem saving configuration"
        end
@@ -290,8 +290,10 @@ module Cosmos
 
       describe "load_configuration" do
         after(:all) do
-          File.delete(File.join(@config_targets,'SYSTEM','cmd_tlm','test1_tlm.txt'))
-          File.delete(File.join(@config_targets,'SYSTEM','cmd_tlm','test2_tlm.txt'))
+          test1 = File.join(@config_targets,'SYSTEM','cmd_tlm','test1_tlm.txt')
+          FileUtils.rm_f(test1) if File.exist?(test1)
+          test2 = File.join(@config_targets,'SYSTEM','cmd_tlm','test2_tlm.txt')
+          FileUtils.rm_f(test2) if File.exist?(test2)
         end
 
         it "loads the initial configuration" do
@@ -352,11 +354,11 @@ module Cosmos
           expect(System.telemetry.packets('SYSTEM').keys).not_to include "TEST2"
 
           # Now remove system.txt from the third configuration and try to load it again to cause an error
-          third_config_path = System.instance.send(:find_configuration, third_config_name)
-          FileUtils.mv File.join(third_config_path, 'system.txt'), File.join(third_config_path, 'system2.txt')
-          result, err = System.load_configuration(third_config_name)
-          expect(result).to eql original_config_name
-          expect(err).to_not be_nil
+          #third_config_path = System.instance.send(:find_configuration, third_config_name)
+          #FileUtils.mv File.join(third_config_path, 'system.txt'), File.join(third_config_path, 'system2.txt')
+          #result, err = System.load_configuration(third_config_name)
+          #expect(result).to eql original_config_name
+          #expect(err).to_not be_nil
         end
       end
     end

data/spec/system/target_spec.rb

@@ -164,6 +164,9 @@ module Cosmos
           tf = Tempfile.new('unittest')
           tf.puts("REQUIRE system_file.rb")
           tf.close
+
+          # Initial require in target lib shouldn't be reported as error
+          expect(Logger).to_not receive(:error)
           Target.new("INST").process_file(tf.path)
           expect { SystemFile.new }.to_not raise_error
           File.delete filename

data/spec/tools/cmd_tlm_server/api_spec.rb

@@ -21,14 +21,58 @@ module Cosmos
       cts = File.join(Cosmos::USERPATH,'config','tools','cmd_tlm_server','cmd_tlm_server.txt')
       FileUtils.mkdir_p(File.dirname(cts))
       File.open(cts,'w') do |file|
-        file.puts 'INTERFACE INT interface.rb'
+        file.puts 'INTERFACE INST_INT interface.rb'
+        file.puts '  TARGET INST'
+        file.puts '  PROTOCOL READ_WRITE OverrideProtocol'
         file.puts 'ROUTER ROUTE interface.rb'
+        file.puts 'BACKGROUND_TASK example_background_task1.rb'
+        file.puts 'BACKGROUND_TASK example_background_task2.rb'
+      end
+      @background1 = File.join(Cosmos::USERPATH,'lib','example_background_task1.rb')
+      File.open(@background1,'w') do |file|
+        file.write <<-DOC
+require 'cosmos/tools/cmd_tlm_server/background_task'
+module Cosmos
+  class ExampleBackgroundTask1 < BackgroundTask
+    def initialize
+      super()
+      @name = 'Example Background Task1'
+      @status = "This is example one"
+    end
+    def call
+      sleep 0.3
+    end
+  end
+end
+DOC
+      end
+      @background2 = File.join(Cosmos::USERPATH,'lib','example_background_task2.rb')
+      File.open(@background2,'w') do |file|
+        file.write <<-DOC
+require 'cosmos/tools/cmd_tlm_server/background_task'
+module Cosmos
+  class ExampleBackgroundTask2 < BackgroundTask
+    def initialize
+      super()
+      @name = 'Example Background Task2'
+      @status = "This is example two"
+    end
+    def call
+      loop do
+        sleep 1
+      end
+    end
+  end
+end
+DOC
       end
     end
 
     after(:all) do
       clean_config()
       FileUtils.rm_rf File.join(Cosmos::USERPATH,'config','tools')
+      FileUtils.rm_rf @background1
+      FileUtils.rm_rf @background2
     end
 
     before(:each) do
@@ -37,8 +81,8 @@ module Cosmos
       allow_any_instance_of(Interface).to receive(:disconnect)
       allow_any_instance_of(Interface).to receive(:write_raw)
       allow_any_instance_of(Interface).to receive(:read)
+      allow_any_instance_of(Interface).to receive(:write)
       @api = CmdTlmServer.new
-      allow(@api.commanding).to receive(:send_command_to_target)
     end
 
     after(:each) do
@@ -395,6 +439,15 @@ module Cosmos
       end
     end
 
+    describe "get_cmd_buffer" do
+      it "returns a command packet buffer" do
+        @api.cmd("INST ABORT")
+        expect(@api.get_cmd_buffer("INST", "ABORT")[6..7].unpack("n")[0]).to eq 2
+        @api.cmd("INST COLLECT with TYPE NORMAL, DURATION 5")
+        expect(@api.get_cmd_buffer("INST", "COLLECT")[6..7].unpack("n")[0]).to eq 1
+      end
+    end
+
     describe "get_cmd_list" do
       it "returns command names sorted" do
         result = @api.get_cmd_list("INST")
@@ -431,15 +484,17 @@ module Cosmos
         result = @api.get_cmd_param_list("INST","COLLECT")
         # Each element in the results array contains:
         #   name, default, states, description, full units, units, required
-        expect(result).to include ['TYPE',0,{"NORMAL"=>0,"SPECIAL"=>1},'Collect type',nil,nil,true]
-        expect(result).to include ['TEMP',0.0,nil,'Collect temperature','Celcius','C',false]
+        expect(result).to include ['TYPE',0,{"NORMAL"=>0,"SPECIAL"=>1},'Collect type',nil,nil,true,"UINT"]
+        expect(result).to include ['TEMP',0.0,nil,'Collect temperature','Celcius','C',false,"FLOAT"]
       end
 
       it "returns array parameters for the command" do
         result = @api.get_cmd_param_list("INST","ARYCMD")
         # Each element in the results array contains:
         #   name, default, states, description, full units, units, required
-        expect(result).to include ['ARRAY',[],nil,'Array parameter',nil,nil,false]
+        expect(result).to include ['ARRAY',[],nil,'Array parameter',nil,nil,false,"FLOAT"]
+        # Since ARRAY2 has a format string the default is in quotes
+        expect(result).to include ['ARRAY2',"[]",nil,'Array parameter',nil,nil,false,"UINT"]
       end
     end
 
@@ -466,22 +521,42 @@ module Cosmos
         expect(@api.get_cmd_value("INST", "COLLECT", "RECEIVED_TIMESECONDS")).to eql time.to_f
         expect(@api.get_cmd_value("INST", "COLLECT", "RECEIVED_COUNT")).to eql 5
       end
+
+      it "returns special values for time if time isn't set" do
+        time = Time.now
+        packet = System.commands.packet("INST", "COLLECT")
+        packet.received_time = nil
+        packet.restore_defaults
+        packet.received_count = 5
+        expect(@api.get_cmd_value("INST", "COLLECT", "TYPE")).to eql 'NORMAL'
+        expect(@api.get_cmd_value("INST", "COLLECT", "RECEIVED_TIMEFORMATTED")).to eql "No Packet Received Time"
+        expect(@api.get_cmd_value("INST", "COLLECT", "RECEIVED_TIMESECONDS")).to eql 0.0
+        expect(@api.get_cmd_value("INST", "COLLECT", "RECEIVED_COUNT")).to eql 5
+      end
     end
 
     describe "get_cmd_time" do
       it "returns command times" do
         time = Time.now
         time2 = Time.now + 2
-        packet = System.commands.packet("INST", "COLLECT")
-        packet.received_time = time
+        collect_cmd = System.commands.packet("INST", "COLLECT")
+        collect_cmd.received_time = time
+        abort_cmd = System.commands.packet("INST", "ABORT")
+        abort_cmd.received_time = time + 1
         packet2 = System.commands.packet("SYSTEM", "STARTLOGGING")
         packet2.received_time = time2
         expect(@api.get_cmd_time()).to eql ['SYSTEM', 'STARTLOGGING', time2.tv_sec, time2.tv_usec]
-        expect(@api.get_cmd_time('INST')).to eql ['INST', 'COLLECT', time.tv_sec, time.tv_usec]
+        expect(@api.get_cmd_time('INST')).to eql ['INST', 'ABORT', time.tv_sec + 1, time.tv_usec]
         expect(@api.get_cmd_time('SYSTEM')).to eql ['SYSTEM', 'STARTLOGGING', time2.tv_sec, time2.tv_usec]
         expect(@api.get_cmd_time('INST', 'COLLECT')).to eql ['INST', 'COLLECT', time.tv_sec, time.tv_usec]
         expect(@api.get_cmd_time('SYSTEM', 'STARTLOGGING')).to eql ['SYSTEM', 'STARTLOGGING', time2.tv_sec, time2.tv_usec]
       end
+
+      it "returns nil if no times are set" do
+        System.commands.packets("INST").each { |name, pkt| pkt.received_time = nil }
+        expect(@api.get_cmd_time("INST")).to eql [nil, nil, nil, nil]
+        expect(@api.get_cmd_time("INST", "ABORT")).to eql ["INST", "ABORT", nil, nil]
+      end
     end
 
     def test_tlm_unknown(method)
@@ -499,12 +574,11 @@ module Cosmos
       end
 
       it "processes a string" do
-        value = @api.tlm("INST HEALTH_STATUS TEMP1")
-        expect(value).to eql -100.0
+        expect(@api.tlm("INST HEALTH_STATUS TEMP1")).to eql -100.0
       end
 
       it "processes parameters" do
-        value = @api.tlm("INST","HEALTH_STATUS","TEMP1")
+        expect(@api.tlm("INST","HEALTH_STATUS","TEMP1")).to eql -100.0
       end
 
       it "complains if too many parameters" do
@@ -603,7 +677,7 @@ module Cosmos
     end
 
     describe "set_tlm" do
-      it "complains about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, packets, and parameters" do
         expect { @api.set_tlm("BLAH HEALTH_STATUS COLLECTS = 1") }.to raise_error(/does not exist/)
         expect { @api.set_tlm("INST UNKNOWN COLLECTS = 1") }.to raise_error(/does not exist/)
         expect { @api.set_tlm("INST HEALTH_STATUS BLAH = 1") }.to raise_error(/does not exist/)
@@ -612,6 +686,19 @@ module Cosmos
         expect { @api.set_tlm("INST","HEALTH_STATUS","BLAH",1) }.to raise_error(/does not exist/)
       end
 
+      it "doesn't allow SYSTEM META PKTID or CONFIG" do
+        expect { @api.set_tlm("SYSTEM META PKTID = 1") }.to raise_error(/set_tlm not allowed/)
+        expect { @api.set_tlm("SYSTEM META CONFIG = 1") }.to raise_error(/set_tlm not allowed/)
+      end
+
+      it "sets SYSTEM META command as well as tlm" do
+        cmd = System.commands.packet("SYSTEM", "META")
+        tlm = System.telemetry.packet("SYSTEM", "META")
+        @api.set_tlm("SYSTEM META RUBY_VERSION = 1.8.0")
+        expect(cmd.read("RUBY_VERSION")).to eq("1.8.0")
+        expect(tlm.read("RUBY_VERSION")).to eq("1.8.0")
+      end
+
       it "processes a string" do
         @api.set_tlm("INST HEALTH_STATUS TEMP1 = 0.0")
         expect(@api.tlm("INST HEALTH_STATUS TEMP1")).to be_within(0.00001).of(-0.05759)
@@ -628,7 +715,7 @@ module Cosmos
     end
 
     describe "set_tlm_raw" do
-      it "complains about unknown targets, commands, and parameters" do
+      it "complains about unknown targets, packets, and parameters" do
         expect { @api.set_tlm_raw("BLAH HEALTH_STATUS COLLECTS = 1") }.to raise_error(/does not exist/)
         expect { @api.set_tlm_raw("INST UNKNOWN COLLECTS = 1") }.to raise_error(/does not exist/)
         expect { @api.set_tlm_raw("INST HEALTH_STATUS BLAH = 1") }.to raise_error(/does not exist/)
@@ -648,6 +735,148 @@ module Cosmos
       end
     end
 
+    describe "inject_tlm" do
+      it "complains about non-existant targets" do
+        expect { @api.inject_tlm("BLAH","HEALTH_STATUS") }.to raise_error(RuntimeError, "Unknown target: BLAH")
+      end
+
+      it "complains about non-existant packets" do
+        expect { @api.inject_tlm("INST","BLAH") }.to raise_error(RuntimeError, "Telemetry packet 'INST BLAH' does not exist")
+      end
+
+      it "complains about non-existant items" do
+        expect { @api.inject_tlm("INST","HEALTH_STATUS",{BLAH: 0}) }.to raise_error(RuntimeError, "Packet item 'INST HEALTH_STATUS BLAH' does not exist")
+      end
+
+      it "logs errors writing routers" do
+        @api.inject_tlm("INST","HEALTH_STATUS",{TEMP1: 50, TEMP2: 50, TEMP3: 50, TEMP4: 50}, :CONVERTED)
+        allow_any_instance_of(Interface).to receive(:write_allowed?).and_raise("PROBLEM!")
+        expect(Logger).to receive(:error) do |msg|
+          expect(msg).to match /Problem writing to router/
+        end
+        @api.inject_tlm("INST","HEALTH_STATUS")
+      end
+
+      it "injects a packet into the system" do
+        @api.inject_tlm("INST","HEALTH_STATUS",{TEMP1: 10, TEMP2: 20}, :CONVERTED, true, true, false)
+        expect(@api.tlm("INST HEALTH_STATUS TEMP1")).to be_within(0.1).of(10.0)
+        expect(@api.tlm("INST HEALTH_STATUS TEMP2")).to be_within(0.1).of(20.0)
+        @api.inject_tlm("INST","HEALTH_STATUS",{TEMP1: 0, TEMP2: 0}, :RAW, true, true, false)
+        expect(@api.tlm("INST HEALTH_STATUS TEMP1")).to eql -100.0
+        expect(@api.tlm("INST HEALTH_STATUS TEMP2")).to eql -100.0
+      end
+
+      it "writes to routers and logs even if the packet has no interface" do
+        sys = System.targets["SYSTEM"]
+        interface = sys.interface
+        sys.interface = nil
+
+        allow_any_instance_of(Interface).to receive(:write_allowed?).and_raise("PROBLEM!")
+        expect(Logger).to receive(:error) do |msg|
+          expect(msg).to match /Problem writing to router/
+        end
+
+        @api.inject_tlm("SYSTEM","LIMITS_CHANGE")
+        sys.interface = interface
+      end
+    end
+
+    describe "override_tlm" do
+      it "complains about unknown targets, packets, and parameters" do
+        expect { @api.override_tlm("BLAH HEALTH_STATUS COLLECTS = 1") }.to raise_error(/does not exist/)
+        expect { @api.override_tlm("INST UNKNOWN COLLECTS = 1") }.to raise_error(/does not exist/)
+        expect { @api.override_tlm("INST HEALTH_STATUS BLAH = 1") }.to raise_error(/does not exist/)
+        expect { @api.override_tlm("BLAH","HEALTH_STATUS","COLLECTS",1) }.to raise_error(/does not exist/)
+        expect { @api.override_tlm("INST","UNKNOWN","COLLECTS",1) }.to raise_error(/does not exist/)
+        expect { @api.override_tlm("INST","HEALTH_STATUS","BLAH",1) }.to raise_error(/does not exist/)
+      end
+
+      it "complains if the target has no interface" do
+        expect { @api.override_tlm("SYSTEM META PKTID = 1") }.to raise_error(/Target 'SYSTEM' has no interface/)
+      end
+
+      it "complains if the target doesn't have OVERRIDE protocol" do
+        interface = OpenStruct.new
+        interface.name = "SYSTEM_INT"
+        System.targets["SYSTEM"].interface = interface # Set a dummy interface
+        expect { @api.override_tlm("SYSTEM META PKTID = 1") }.to raise_error(/Interface SYSTEM_INT does not have override/)
+        System.targets["SYSTEM"].interface = nil
+      end
+
+      it "complains with too many parameters" do
+        expect { @api.override_tlm("INST","HEALTH_STATUS","TEMP1","TEMP2",0.0) }.to raise_error(/Invalid number of arguments/)
+      end
+
+      it "calls _override_tlm in the interface" do
+        int = System.targets["INST"].interface
+        expect(int).to receive("_override_tlm").with("INST","HEALTH_STATUS","TEMP1",100.0)
+        @api.override_tlm("INST HEALTH_STATUS TEMP1 = 100.0")
+        expect(int).to receive("_override_tlm").with("INST","HEALTH_STATUS","TEMP2",50.0)
+        @api.override_tlm("INST","HEALTH_STATUS","TEMP2", 50.0)
+      end
+    end
+
+    describe "override_tlm_raw" do
+      it "complains about unknown targets, commands, and parameters" do
+        expect { @api.override_tlm_raw("BLAH HEALTH_STATUS COLLECTS = 1") }.to raise_error(/does not exist/)
+        expect { @api.override_tlm_raw("INST UNKNOWN COLLECTS = 1") }.to raise_error(/does not exist/)
+        expect { @api.override_tlm_raw("INST HEALTH_STATUS BLAH = 1") }.to raise_error(/does not exist/)
+        expect { @api.override_tlm_raw("BLAH","HEALTH_STATUS","COLLECTS",1) }.to raise_error(/does not exist/)
+        expect { @api.override_tlm_raw("INST","UNKNOWN","COLLECTS",1) }.to raise_error(/does not exist/)
+        expect { @api.override_tlm_raw("INST","HEALTH_STATUS","BLAH",1) }.to raise_error(/does not exist/)
+      end
+
+      it "complains if the target has no interface" do
+        expect { @api.override_tlm_raw("SYSTEM META PKTID = 1") }.to raise_error(/Target 'SYSTEM' has no interface/)
+      end
+
+      it "complains with too many parameters" do
+        expect { @api.override_tlm_raw("INST","HEALTH_STATUS","TEMP1","TEMP2",0.0) }.to raise_error(/Invalid number of arguments/)
+      end
+
+      it "calls _override_tlm_raw in the interface" do
+        int = System.targets["INST"].interface
+        expect(int).to receive("_override_tlm_raw").with("INST","HEALTH_STATUS","TEMP1",100.0)
+        @api.override_tlm_raw("INST HEALTH_STATUS TEMP1 = 100.0")
+        expect(int).to receive("_override_tlm_raw").with("INST","HEALTH_STATUS","TEMP2",50.0)
+        @api.override_tlm_raw("INST","HEALTH_STATUS","TEMP2", 50.0)
+      end
+    end
+
+    describe "normalize_tlm" do
+      it "complains about unknown targets, commands, and parameters" do
+        expect { @api.normalize_tlm("BLAH HEALTH_STATUS COLLECTS") }.to raise_error(/does not exist/)
+        expect { @api.normalize_tlm("INST UNKNOWN COLLECTS") }.to raise_error(/does not exist/)
+        expect { @api.normalize_tlm("INST HEALTH_STATUS BLAH") }.to raise_error(/does not exist/)
+        expect { @api.normalize_tlm("BLAH","HEALTH_STATUS","COLLECTS") }.to raise_error(/does not exist/)
+        expect { @api.normalize_tlm("INST","UNKNOWN","COLLECTS") }.to raise_error(/does not exist/)
+        expect { @api.normalize_tlm("INST","HEALTH_STATUS","BLAH") }.to raise_error(/does not exist/)
+      end
+
+      it "complains if the target has no interface" do
+        expect { @api.normalize_tlm("SYSTEM META PKTID") }.to raise_error(/Target 'SYSTEM' has no interface/)
+      end
+
+      it "complains with too many parameters" do
+        expect { @api.normalize_tlm("INST","HEALTH_STATUS","TEMP1",0.0) }.to raise_error(/Invalid number of arguments/)
+      end
+
+      it "calls _normalize_tlm in the interface" do
+        int = System.targets["INST"].interface
+        expect(int).to receive("_normalize_tlm").with("INST","HEALTH_STATUS","TEMP1")
+        @api.normalize_tlm("INST HEALTH_STATUS TEMP1")
+        expect(int).to receive("_normalize_tlm").with("INST","HEALTH_STATUS","TEMP2")
+        @api.normalize_tlm("INST","HEALTH_STATUS","TEMP2")
+      end
+    end
+
+    describe "get_tlm_buffer" do
+      it "returns a telemetry packet buffer" do
+        @api.inject_tlm("INST","HEALTH_STATUS",{TIMESEC: 0xDEADBEEF})
+        expect(@api.get_tlm_buffer("INST", "HEALTH_STATUS")[6..10].unpack("N")[0]).to eq 0xDEADBEEF
+      end
+    end
+
     describe "get_tlm_packet" do
       it "complains about non-existant targets" do
         expect { @api.get_tlm_packet("BLAH","HEALTH_STATUS") }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
@@ -666,15 +895,18 @@ module Cosmos
       end
 
       it "reads all telemetry items with their limits states" do
+        # Call inject_tlm to ensure the limits are set
+        @api.inject_tlm("INST","HEALTH_STATUS",{TEMP1: 0, TEMP2: 0, TEMP3: 0, TEMP4: 0}, :RAW)
+
         vals = @api.get_tlm_packet("INST","HEALTH_STATUS")
         expect(vals[0][0]).to eql "RECEIVED_TIMESECONDS"
-        expect(vals[0][1]).to eql 0.0
+        expect(vals[0][1]).to be > 0
         expect(vals[0][2]).to be_nil
         expect(vals[1][0]).to eql "RECEIVED_TIMEFORMATTED"
-        expect(vals[1][1]).to eql "No Packet Received Time"
+        expect(vals[1][1].split(' ')[0]).to eql Time.now.formatted.split(' ')[0]
         expect(vals[1][2]).to be_nil
         expect(vals[2][0]).to eql "RECEIVED_COUNT"
-        expect(vals[2][1]).to eql 0
+        expect(vals[2][1]).to be > 0
         expect(vals[2][2]).to be_nil
         # Spot check a few more
         expect(vals[22][0]).to eql "TEMP1"
@@ -872,6 +1104,7 @@ module Cosmos
 
     describe "get_out_of_limits" do
       it "returns all out of limits items" do
+        @api.inject_tlm("INST","HEALTH_STATUS",{TEMP1: 0, TEMP2: 0, TEMP3: 0, TEMP4: 0}, :RAW)
         items = @api.get_out_of_limits
         (0..3).each do |i|
           expect(items[i][0]).to eql "INST"
@@ -882,6 +1115,13 @@ module Cosmos
       end
     end
 
+    describe "get_overall_limits_state" do
+      it "returns the overall system limits state" do
+        @api.inject_tlm("INST","HEALTH_STATUS",{TEMP1: 0, TEMP2: 0, TEMP3: 0, TEMP4: 0}, :RAW)
+        expect(@api.get_overall_limits_state).to eq :RED
+      end
+    end
+
     describe "limits_enabled?" do
       it "complains about non-existant targets" do
         expect { @api.limits_enabled?("BLAH","HEALTH_STATUS","TEMP1") }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
@@ -943,6 +1183,28 @@ module Cosmos
       end
     end
 
+    describe "get_stale" do
+      it "complains about non-existant targets" do
+        expect { @api.get_stale(false,"BLAH") }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
+      end
+
+      it "gets stale packets for the specified target" do
+        # By calling check_limits we make HEALTH_STATUS not stale
+        System.telemetry.packet("INST","HEALTH_STATUS").check_limits
+        stale = @api.get_stale(false,"INST").sort
+        inst_pkts = []
+        System.telemetry.packets("INST").each do |name, pkt|
+          next if name == "HEALTH_STATUS" # not stale
+          inst_pkts << ["INST", name]
+        end
+        expect(stale).to eq inst_pkts.sort
+
+        # Passing true only gets packets with limits items
+        stale = @api.get_stale(true,"INST").sort
+        expect(stale).to eq [["INST","PARAMS"]]
+      end
+    end
+
     describe "get_limits" do
       it "complains about non-existant targets" do
         expect { @api.get_limits("BLAH","HEALTH_STATUS","TEMP1") }.to raise_error(RuntimeError, "Telemetry target 'BLAH' does not exist")
@@ -1084,27 +1346,276 @@ module Cosmos
       end
     end
 
+    describe "get_packet" do
+      it "creates a packet out of the get_packet_data" do
+        time = Time.now
+        expect(CmdTlmServer).to receive(:get_packet_data).and_return(["\xAB","INST","HEALTH_STATUS",time.to_f,0,10])
+        pkt = @api.get_packet(10)
+        expect(pkt.buffer[0]).to eq "\xAB"
+        expect(pkt.target_name).to eq "INST"
+        expect(pkt.packet_name).to eq "HEALTH_STATUS"
+        expect(pkt.received_time.formatted).to eq time.formatted
+        expect(pkt.received_count).to eq 10
+      end
+    end
+
+    describe "subscribe_server_messages" do
+      it "calls CmdTlmServer" do
+        stub_const("Cosmos::CmdTlmServer::DEFAULT_SERVER_MESSAGES_QUEUE_SIZE", 100)
+        expect(CmdTlmServer).to receive(:subscribe_server_messages)
+        @api.subscribe_server_messages
+      end
+    end
+
+    describe "unsubscribe_server_messages" do
+      it "calls CmdTlmServer" do
+        expect(CmdTlmServer).to receive(:unsubscribe_server_messages)
+        @api.unsubscribe_server_messages(0)
+      end
+    end
+
+    describe "get_server_message" do
+      it "gets a server message" do
+        expect(CmdTlmServer).to receive(:get_server_message)
+        @api.get_server_message(0)
+      end
+    end
+
+    describe "get_interface_targets" do
+      it "returns the targets associated with an interface" do
+        expect(@api.get_interface_targets("INST_INT")).to eql ["INST"]
+      end
+    end
+
+    describe "get_background_tasks" do
+      it "gets background task details" do
+        sleep 0.1
+        tasks = @api.get_background_tasks
+        expect(tasks[0][0]).to eql("Example Background Task1")
+        expect(tasks[0][1]).to eql("sleep")
+        expect(tasks[0][2]).to eql("This is example one")
+        expect(tasks[1][0]).to eql("Example Background Task2")
+        expect(tasks[1][1]).to eql("sleep")
+        expect(tasks[1][2]).to eql("This is example two")
+        sleep 0.5
+        tasks = @api.get_background_tasks
+        expect(tasks[0][0]).to eql("Example Background Task1")
+        expect(tasks[0][1]).to eql("complete") # Thread completes
+        expect(tasks[0][2]).to eql("This is example one")
+        expect(tasks[1][0]).to eql("Example Background Task2")
+        expect(tasks[1][1]).to eql("sleep")
+        expect(tasks[1][2]).to eql("This is example two")
+      end
+    end
+
+    describe "get_server_status" do
+      it "gets server details" do
+        status = @api.get_server_status
+        expect(status[0]).to eql 'DEFAULT'
+        expect(status[1]).to eql 7777
+        expect(status[2]).to eql 0
+        expect(status[3]).to eql 0
+        expect(status[4]).to eql 0.0
+        expect(status[5]).to be > 10
+      end
+    end
+
+    describe "get_target_info" do
+      it "complains about non-existant targets" do
+        expect { @api.get_target_info("BLAH") }.to raise_error(RuntimeError, "Unknown target: BLAH")
+      end
+
+      it "gets target cmd tlm count" do
+        cmd1, tlm1 = @api.get_target_info("INST")
+        @api.cmd("INST ABORT")
+        @api.inject_tlm("INST","HEALTH_STATUS")
+        cmd2, tlm2 = @api.get_target_info("INST")
+        expect(cmd2 - cmd1).to eq 1
+        expect(tlm2 - tlm1).to eq 1
+      end
+    end
+
+    describe "get_all_target_info" do
+      it "gets target name, interface name, cmd & tlm count" do
+        @api.cmd("INST ABORT")
+        @api.inject_tlm("INST","HEALTH_STATUS")
+        info = @api.get_all_target_info().sort
+        expect(info[0][0]).to eq "INST"
+        expect(info[0][1]).to eq "INST_INT"
+        expect(info[0][2]).to be > 0
+        expect(info[0][3]).to be > 0
+        expect(info[1][0]).to eq "SYSTEM"
+        expect(info[1][1]).to eq "" # No interface
+      end
+    end
+
+    describe "get_interface_info" do
+      it "complains about non-existant interfaces" do
+        expect { @api.get_interface_info("BLAH") }.to raise_error(RuntimeError, "Unknown interface: BLAH")
+      end
+
+      it "gets interface info" do
+        info = @api.get_interface_info("INST_INT")
+        expect(info[0]).to eq "ATTEMPTING"
+        expect(info[1..-1]).to eq [0,0,0,0,0,0,0]
+      end
+    end
+
+    describe "get_all_interface_info" do
+      it "gets interface name and all info" do
+        info = @api.get_all_interface_info.sort
+        expect(info[0][0]).to eq "INST_INT"
+      end
+    end
+
+    describe "get_router_names" do
+      it "returns all router names" do
+        expect(@api.get_router_names.sort).to eq %w(PREIDENTIFIED_CMD_ROUTER PREIDENTIFIED_ROUTER ROUTE)
+      end
+    end
+
+    describe "get_router_info" do
+      it "complains about non-existant routers" do
+        expect { @api.get_router_info("BLAH") }.to raise_error(RuntimeError, "Unknown router: BLAH")
+      end
+
+      it "gets router info" do
+        info = @api.get_router_info("ROUTE")
+        expect(info[0]).to eq "ATTEMPTING"
+        expect(info[1..-1]).to eq [0,0,0,0,0,0,0]
+      end
+    end
+
+    describe "get_all_router_info" do
+      it "gets router name and all info" do
+        info = @api.get_all_router_info.sort
+        expect(info[0][0]).to eq "PREIDENTIFIED_CMD_ROUTER"
+        expect(info[1][0]).to eq "PREIDENTIFIED_ROUTER"
+        expect(info[2][0]).to eq "ROUTE"
+      end
+    end
+
+    describe "get_cmd_cnt" do
+      it "complains about non-existant targets" do
+        expect { @api.get_cmd_cnt("BLAH", "ABORT") }.to raise_error(RuntimeError, /does not exist/)
+      end
+
+      it "complains about non-existant packets" do
+        expect { @api.get_cmd_cnt("INST", "BLAH") }.to raise_error(RuntimeError, /does not exist/)
+      end
+
+      it "gets the command packet count" do
+        cnt1 = @api.get_cmd_cnt("INST", "ABORT")
+        @api.cmd("INST", "ABORT")
+        cnt2 = @api.get_cmd_cnt("INST", "ABORT")
+        expect(cnt2 - cnt1).to eq 1
+      end
+    end
+
+    describe "get_tlm_cnt" do
+      it "complains about non-existant targets" do
+        expect { @api.get_tlm_cnt("BLAH", "ABORT") }.to raise_error(RuntimeError, /does not exist/)
+      end
+
+      it "complains about non-existant packets" do
+        expect { @api.get_tlm_cnt("INST", "BLAH") }.to raise_error(RuntimeError, /does not exist/)
+      end
+
+      it "gets the telemetry packet count" do
+        cnt1 = @api.get_tlm_cnt("INST", "ADCS")
+        @api.inject_tlm("INST","ADCS")
+        cnt2 = @api.get_tlm_cnt("INST", "ADCS")
+        expect(cnt2 - cnt1).to eq 1
+      end
+    end
+
+    describe "get_all_cmd_info" do
+      it "gets tgt, pkt, rx cnt for all commands" do
+        total = 1 # Unknown is 1
+        System.commands.target_names.each do |tgt|
+          total += System.commands.packets(tgt).keys.length
+        end
+        info = @api.get_all_cmd_info.sort
+        expect(info.length).to eq total
+        expect(info[0][0]).to eq "INST"
+        expect(info[0][1]).to eq "ABORT"
+        expect(info[0][2]).to be >= 0
+        expect(info[-1][0]).to eq "UNKNOWN"
+        expect(info[-1][1]).to eq "UNKNOWN"
+        expect(info[-1][2]).to eq 0
+      end
+    end
+
+    describe "get_all_tlm_info" do
+      it "gets tgt, pkt, rx cnt for all telemetry" do
+        total = 1 # Unknown is 1
+        System.telemetry.target_names.each do |tgt|
+          total += System.telemetry.packets(tgt).keys.length
+        end
+        info = @api.get_all_tlm_info.sort
+        expect(info.length).to eq total
+        expect(info[0][0]).to eq "INST"
+        expect(info[0][1]).to eq "ADCS"
+        expect(info[0][2]).to be >= 0
+        expect(info[-1][0]).to eq "UNKNOWN"
+        expect(info[-1][1]).to eq "UNKNOWN"
+        expect(info[-1][2]).to eq 0
+      end
+    end
+
+    describe "get_packet_logger_info" do
+      it "complains about non-existant loggers" do
+        expect { @api.get_packet_logger_info("BLAH") }.to raise_error(RuntimeError, "Unknown packet log writer: BLAH")
+      end
+
+      it "gets packet logger info" do
+        info = @api.get_packet_logger_info("DEFAULT")
+        expect(info[0]).to eq ["INST_INT"]
+      end
+    end
+
+    describe "get_all_packet_logger_info" do
+      it "gets all packet loggers info" do
+        info = @api.get_all_packet_logger_info.sort
+        expect(info[0][0]).to eq "DEFAULT"
+        expect(info[0][1]).to eq ["INST_INT"]
+      end
+    end
+
+    describe "background_task apis" do
+      it "starts, gets into, and stops background tasks" do
+        @api.start_background_task("Example Background Task2")
+        sleep 0.1
+        info = @api.get_background_tasks.sort
+        expect(info[1][0]).to eq "Example Background Task2"
+        expect(info[1][1]).to eq "sleep"
+        expect(info[1][2]).to eq "This is example two"
+        @api.stop_background_task("Example Background Task2")
+        sleep 0.1
+        info = @api.get_background_tasks.sort
+        expect(info[1][0]).to eq "Example Background Task2"
+        expect(info[1][1]).to eq "complete"
+        expect(info[1][2]).to eq "This is example two"
+      end
+    end
+
     # All these methods simply pass through directly to CmdTlmServer without
     # adding any functionality. Thus we just test that they are are received
     # by the CmdTlmServer.
     describe "CmdTlmServer pass-throughs" do
       it "calls through to the CmdTlmServer" do
         @api.get_interface_names
-        @api.connect_interface("INT")
-        @api.disconnect_interface("INT")
-        @api.interface_state("INT")
-        @api.map_target_to_interface("INST", "INT")
-        @api.get_interface_info("INT")
-        @api.get_target_info("INST")
-        @api.get_cmd_cnt("INST", "COLLECT")
-        @api.get_tlm_cnt("INST", "HEALTH_STATUS")
-        @api.get_router_info("ROUTE")
-        @api.get_packet_logger_info('DEFAULT')
-        @api.get_router_names
+        @api.connect_interface("INST_INT")
+        @api.disconnect_interface("INST_INT")
+        @api.interface_state("INST_INT")
+        @api.map_target_to_interface("INST", "INST_INT")
+        @api.get_target_ignored_parameters("INST")
+        @api.get_target_ignored_items("INST")
+        @api.get_packet_loggers
         @api.connect_router("ROUTE")
         @api.disconnect_router("ROUTE")
         @api.router_state("ROUTE")
-        @api.send_raw("INT","\x00\x01")
+        @api.send_raw("INST_INT","\x00\x01")
         @api.get_cmd_log_filename('DEFAULT')
         @api.get_tlm_log_filename('DEFAULT')
         @api.start_logging('ALL')
@@ -1115,9 +1626,12 @@ module Cosmos
         @api.stop_tlm_log('ALL')
         @api.get_server_message_log_filename
         @api.start_new_server_message_log
+        @api.start_raw_logging_interface
+        @api.stop_raw_logging_interface
+        @api.start_raw_logging_router
+        @api.stop_raw_logging_router
       end
     end
 
   end
 end
-