cosmos 4.5.2 → 5.0.2.pre.beta2

data/spec/processors/processor_spec.rb

@@ -1,55 +0,0 @@
-# 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/processors/processor'
-
-module Cosmos
-
-  describe Processor do
-
-    describe "initialize" do
-      it "stores an optional value_type" do
-        a = Processor.new(:RAW)
-        expect(a.value_type).to eql :RAW
-        b = Processor.new
-        expect(b.value_type).to eql :CONVERTED
-      end
-    end
-
-    describe "call" do
-      it "raises an exception" do
-        expect { Processor.new.call(0, 0) }.to raise_error("call method must be defined by subclass")
-      end
-    end
-
-    describe "to_s" do
-      it "returns a String" do
-        expect(Processor.new.to_s).to eql "Processor"
-      end
-    end
-
-    describe "name" do
-      it "has an assignable name" do
-        a = Processor.new
-        a.name = "Test"
-        expect(a.name).to eql "TEST"
-      end
-    end
-
-    describe "reset" do
-      it "has a reset method" do
-        a = Processor.new
-        expect { a.reset }.not_to raise_error
-      end
-    end
-  end
-end
-

data/spec/processors/statistics_processor_spec.rb

@@ -1,95 +0,0 @@
-# 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'
-require 'cosmos/processors/statistics_processor'
-
-module Cosmos
-
-  describe StatisticsProcessor do
-
-    describe "initialize" do
-      it "takes an item_name, samples_to_average, and value_type" do
-        p = StatisticsProcessor.new('TEST', '5', 'RAW')
-        expect(p.value_type).to eql :RAW
-        expect(p.instance_variable_get("@item_name")).to eql 'TEST'
-        expect(p.instance_variable_get("@samples_to_average")).to eql 5
-      end
-    end
-
-    describe "call and reset" do
-      it "generates statistics" do
-        p = StatisticsProcessor.new('TEST', '5', 'RAW')
-        packet = Packet.new("tgt","pkt")
-        packet.append_item("TEST", 8, :UINT)
-        packet.buffer= "\x01"
-        p.call(packet, packet.buffer)
-        expect(p.results[:MAX]).to eql 1
-        expect(p.results[:MIN]).to eql 1
-        expect(p.results[:MEAN]).to be_within(0.001).of(1.0)
-        expect(p.results[:STDDEV]).to be_within(0.001).of(0.0)
-        packet.buffer= "\x02"
-        p.call(packet, packet.buffer)
-        expect(p.results[:MAX]).to eql 2
-        expect(p.results[:MIN]).to eql 1
-        expect(p.results[:MEAN]).to be_within(0.001).of(1.5)
-        expect(p.results[:STDDEV]).to be_within(0.001).of(0.7071)
-        packet.buffer= "\x00"
-        p.call(packet, packet.buffer)
-        expect(p.results[:MAX]).to eql 2
-        expect(p.results[:MIN]).to eql 0
-        expect(p.results[:MEAN]).to be_within(0.001).of(1.0)
-        expect(p.results[:STDDEV]).to be_within(0.001).of(1.0)
-        p.reset
-        expect(p.results[:MAX]).to eql nil
-        expect(p.results[:MIN]).to eql nil
-        expect(p.results[:MEAN]).to eql nil
-        expect(p.results[:STDDEV]).to eql nil
-      end
-
-      it "handles nil and infinity" do
-        p = StatisticsProcessor.new('TEST', '5')
-        packet = Packet.new("tgt","pkt")
-        packet.append_item("TEST", 32, :FLOAT)
-        packet.write("TEST", 1)
-        p.call(packet, packet.buffer)
-        expect(p.results[:MAX]).to eql 1.0
-        expect(p.results[:MIN]).to eql 1.0
-        expect(p.results[:MEAN]).to be_within(0.001).of(1.0)
-        expect(p.results[:STDDEV]).to be_within(0.001).of(0.0)
-        packet.write("TEST", Float::NAN)
-        p.call(packet, packet.buffer)
-        expect(p.results[:MAX]).to eql 1.0
-        expect(p.results[:MIN]).to eql 1.0
-        expect(p.results[:MEAN]).to be_within(0.001).of(1.0)
-        expect(p.results[:STDDEV]).to be_within(0.001).of(0.0)
-        packet.write("TEST", 2)
-        p.call(packet, packet.buffer)
-        expect(p.results[:MAX]).to eql 2.0
-        expect(p.results[:MIN]).to eql 1.0
-        expect(p.results[:MEAN]).to be_within(0.001).of(1.5)
-        expect(p.results[:STDDEV]).to be_within(0.001).of(0.7071)
-        packet.write("TEST", Float::INFINITY)
-        p.call(packet, packet.buffer)
-        expect(p.results[:MAX]).to eql 2.0
-        expect(p.results[:MIN]).to eql 1.0
-        expect(p.results[:MEAN]).to be_within(0.001).of(1.5)
-        expect(p.results[:STDDEV]).to be_within(0.001).of(0.7071)
-        p.reset
-        expect(p.results[:MAX]).to eql nil
-        expect(p.results[:MIN]).to eql nil
-        expect(p.results[:MEAN]).to eql nil
-        expect(p.results[:STDDEV]).to eql nil
-      end
-    end
-  end
-end
-

data/spec/processors/watermark_processor_spec.rb

@@ -1,51 +0,0 @@
-# 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'
-require 'cosmos/processors/watermark_processor'
-
-module Cosmos
-
-  describe WatermarkProcessor do
-
-    describe "initialize" do
-      it "takes an item_name and value_type" do
-        p = WatermarkProcessor.new('TEST', 'RAW')
-        expect(p.value_type).to eql :RAW
-        expect(p.instance_variable_get("@item_name")).to eql 'TEST'
-      end
-    end
-
-    describe "call and reset" do
-      it "generates a high and low water mark" do
-        p = WatermarkProcessor.new('TEST', 'RAW')
-        packet = Packet.new("tgt","pkt")
-        packet.append_item("TEST", 8, :UINT)
-        packet.buffer= "\x01"
-        p.call(packet, packet.buffer)
-        expect(p.results[:HIGH_WATER]).to eql 1
-        expect(p.results[:LOW_WATER]).to eql 1
-        packet.buffer= "\x02"
-        p.call(packet, packet.buffer)
-        expect(p.results[:HIGH_WATER]).to eql 2
-        expect(p.results[:LOW_WATER]).to eql 1
-        packet.buffer= "\x00"
-        p.call(packet, packet.buffer)
-        expect(p.results[:HIGH_WATER]).to eql 2
-        expect(p.results[:LOW_WATER]).to eql 0
-        p.reset
-        expect(p.results[:HIGH_WATER]).to eql nil
-        expect(p.results[:LOW_WATER]).to eql nil
-      end
-    end
-  end
-end
-

data/spec/script/cmd_tlm_server_spec.rb

@@ -1,194 +0,0 @@
-# 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'
-require 'cosmos/script'
-require 'tempfile'
-
-module Cosmos
-  describe Script do
-    before(:each) do
-      allow_any_instance_of(Interface).to receive(:connected?).and_return(true)
-      allow_any_instance_of(Interface).to receive(:disconnect)
-
-      @server = CmdTlmServer.new
-      shutdown_cmd_tlm()
-      initialize_script_module()
-      sleep 0.1
-    end
-
-    after(:each) do
-      @server.stop
-      shutdown_cmd_tlm()
-      sleep(0.1)
-    end
-
-    describe "get_interface_names" do
-      it "returns all interfaces" do
-        expect(get_interface_names).to include("INST_INT")
-      end
-    end
-
-    describe "connect_interface, disconnect_interface, interface_state" do
-      it "connects, disconnect and return the state of the interface CTS-3" do
-        connect_interface("INST_INT")
-        expect(interface_state("INST_INT")).to eql "CONNECTED"
-        disconnect_interface("INST_INT")
-      end
-    end
-
-    describe "map_target_to_interface" do
-      it "maps a target name to an interface" do
-        map_target_to_interface("INST","INST_INT")
-      end
-    end
-
-    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")
-        expect(state).to eql "CONNECTED"
-        disconnect_interface("INST_INT")
-        expect(clients).to be >= 0
-        expect(tx_q_size).to be >= 0
-        expect(rx_q_size).to be >= 0
-        expect(bytes_tx).to be >= 0
-        expect(bytes_rx).to be >= 0
-        expect(cmd_cnt).to be >= 0
-        expect(tlm_cnt).to be >= 0
-      end
-    end
-
-    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")
-        disconnect_router("PREIDENTIFIED_ROUTER")
-        expect(state).to eql "CONNECTED"
-        expect(clients).to be >= 0
-        expect(tx_q_size).to be >= 0
-        expect(rx_q_size).to be >= 0
-        expect(bytes_tx).to be >= 0
-        expect(bytes_rx).to be >= 0
-        expect(pkts_rcvd).to be >= 0
-        expect(pkts_sent).to be >= 0
-      end
-    end
-
-    describe "get_target_info" do
-      it "returns target info" do
-        cmd_cnt, tlm_cnt = get_target_info("INST")
-        expect(cmd_cnt).to be >= 0
-        expect(tlm_cnt).to be >= 0
-      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
-      end
-    end
-
-    describe "get_tlm_cnt" do
-      it "returns tlm count" do
-        expect(get_tlm_cnt("INST", "HEALTH_STATUS")).to be >= 0
-      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,
-                    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
-        expect(cmd_q_size).to be >= 0
-        expect(cmd_filename).to be nil # No commands yet so nil
-        expect(cmd_file_size).to be >= 0
-        expect(tlm_logging).to eql true
-        expect(tlm_q_size).to be >= 0
-        expect(tlm_filename).to be nil # No telemetry yet so nil
-        expect(tlm_file_size).to be >= 0
-      end
-    end
-
-    describe "connect_router, disconnect_router, get_router_names, router_state" do
-      it "returns connect, disconnect, and list the routers CTS-11" do
-        expect(get_router_names).to include("PREIDENTIFIED_ROUTER")
-        connect_router("PREIDENTIFIED_ROUTER")
-        expect(router_state("PREIDENTIFIED_ROUTER")).to eql "CONNECTED"
-        disconnect_router("PREIDENTIFIED_ROUTER")
-      end
-    end
-
-    describe "logging methods" do
-      it "starts and stop logging and get filenames CTS-14" do
-        start_logging
-        stop_logging
-        get_cmd_log_filename
-        get_tlm_log_filename
-        start_cmd_log
-        start_tlm_log
-        get_cmd_log_filename
-        get_tlm_log_filename
-        stop_cmd_log
-        stop_tlm_log
-        get_cmd_log_filename
-        get_tlm_log_filename
-        start_raw_logging_interface
-        start_raw_logging_router
-        stop_raw_logging_interface
-        stop_raw_logging_router
-
-        start_new_server_message_log
-        sleep 0.1
-        filename = get_server_message_log_filename
-        expect(filename).to match(/server_messages.txt/)
-      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

@@ -1,258 +0,0 @@
-# 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'
-require 'cosmos/script'
-require 'tempfile'
-
-module Cosmos
-  describe Script do
-    before(:all) do
-      System.class_eval('@@instance = nil')
-      require 'cosmos/script'
-      set_disconnected_targets(['INST'])
-    end
-
-    after(:all) do
-      clear_disconnected_targets()
-      clean_config()
-    end
-
-    describe "require cosmos/script.rb" do
-      it "should raise when inside CmdTlmServer" do
-        save = $0
-        $0 = "CmdTlmServer"
-        expect { load 'cosmos/script.rb' }.to raise_error(/must not be required/)
-        $0 = save
-      end
-
-      it "should raise when inside Replay" do
-        save = $0
-        $0 = "Replay"
-        expect { load 'cosmos/script.rb' }.to raise_error(/must not be required/)
-        $0 = save
-      end
-    end
-
-    describe "cmd" do
-      it "sends a command" do
-        capture_io do |stdout|
-          cmd("INST ABORT")
-          expect(stdout.string).to match(/cmd\(\"INST ABORT\"\)/) #"
-          stdout.rewind
-          cmd("INST", "ABORT")
-          expect(stdout.string).to match(/cmd\(\"INST ABORT\"\)/) #"
-        end
-      end
-
-      it "checks parameter ranges" do
-        expect { cmd("INST COLLECT with TYPE NORMAL, DURATION 20") }.to raise_error(/Command parameter 'INST COLLECT DURATION' = 20 not in valid range/)
-      end
-
-      it "prompts for a hazardous command" do
-        capture_io do |stdout|
-          expect(self).to receive(:gets) { 'y' } # Send hazardous command
-          cmd("INST COLLECT with TYPE SPECIAL")
-
-          expect(stdout.string).to match(/cmd\(\"INST COLLECT/) # "
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring hazardous warnings")
-          stdout.rewind
-
-          expect(self).to receive(:gets) { 'n' } # Don't send hazardous
-          expect(self).to receive(:gets) { 'y' } # Stop running script
-          cmd("INST COLLECT with TYPE SPECIAL")
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-        end
-      end
-    end
-
-    describe "cmd_no_range_check" do
-      it "sends an out of range command" do
-        expect { cmd_no_range_check("INST COLLECT with TYPE NORMAL, DURATION 20") }.to_not raise_error
-      end
-
-      it "prompts for a hazardous command" do
-        capture_io do |stdout|
-          expect(self).to receive(:gets) { 'y' } # Send hazardous command
-          cmd_no_range_check("INST COLLECT with TYPE SPECIAL")
-
-          expect(stdout.string).to match(/cmd\(\"INST COLLECT/) # "
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring hazardous warnings")
-          stdout.rewind
-
-          expect(self).to receive(:gets) { 'n' } # Don't send hazardous
-          expect(self).to receive(:gets) { 'y' } # Stop running script
-          cmd_no_range_check("INST COLLECT with TYPE SPECIAL")
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-        end
-      end
-    end
-
-    describe "cmd_no_hazardous_check" do
-      it "checks parameter ranges" do
-        expect { cmd_no_hazardous_check("INST COLLECT with TYPE SPECIAL, DURATION 20") }.to raise_error(/Command parameter 'INST COLLECT DURATION' = 20 not in valid range/)
-      end
-
-      it "sends a hazardous command without prompting" do
-        capture_io do |stdout|
-          cmd_no_hazardous_check("INST COLLECT with TYPE SPECIAL")
-
-          expect(stdout.string).to match(/cmd\(\"INST COLLECT/) # "
-          expect(stdout.string).to_not match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring hazardous warnings")
-        end
-      end
-    end
-
-    describe "cmd_no_checks" do
-      it "sends an out of range hazardous command without prompting" do
-        capture_io do |stdout|
-          cmd_no_checks("INST COLLECT with TYPE SPECIAL, DURATION 20")
-
-          expect(stdout.string).to match(/cmd\(\"INST COLLECT/) # "
-          expect(stdout.string).to_not match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring hazardous warnings")
-        end
-      end
-    end
-
-    describe "cmd_raw" do
-      it "sends a command" do
-        capture_io do |stdout|
-          cmd_raw("INST ABORT")
-          expect(stdout.string).to match(/cmd_raw\(\"INST ABORT\"\)/) # "
-        end
-      end
-
-      it "checks parameter ranges" do
-        expect { cmd_raw("INST COLLECT with TYPE 0, DURATION 20") }.to raise_error(/Command parameter 'INST COLLECT DURATION' = 20 not in valid range/) # '
-      end
-
-      it "prompts for a hazardous command" do
-        capture_io do |stdout|
-          expect(self).to receive(:gets) { 'y' } # Send hazardous command
-          cmd_raw("INST COLLECT with TYPE 1")
-
-          expect(stdout.string).to match(/cmd_raw\(\"INST COLLECT/) # "
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring hazardous warnings")
-          stdout.rewind
-
-          expect(self).to receive(:gets) { 'n' } # Don't send hazardous
-          expect(self).to receive(:gets) { 'y' } # Stop running script
-          cmd_raw("INST COLLECT with TYPE 1")
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-        end
-      end
-    end
-
-    describe "cmd_raw_no_range_check" do
-      it "sends an out of range command" do
-        expect { cmd_raw_no_range_check("INST COLLECT with TYPE 0, DURATION 20") }.to_not raise_error
-      end
-
-      it "prompts for a hazardous command" do
-        capture_io do |stdout|
-          expect(self).to receive(:gets) { 'y' } # Send hazardous command
-          cmd_raw_no_range_check("INST COLLECT with TYPE 1")
-
-          expect(stdout.string).to match(/cmd_raw\(\"INST COLLECT/) # "
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring hazardous warnings")
-          stdout.rewind
-
-          expect(self).to receive(:gets) { 'n' } # Don't send hazardous
-          expect(self).to receive(:gets) { 'y' } # Stop running script
-          cmd_raw_no_range_check("INST COLLECT with TYPE 1")
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-        end
-      end
-    end
-
-    describe "cmd_raw_no_hazardous_check" do
-      it "checks parameter ranges" do
-        expect { cmd_raw_no_hazardous_check("INST COLLECT with TYPE 1, DURATION 20") }.to raise_error(/Command parameter 'INST COLLECT DURATION' = 20 not in valid range/)
-      end
-
-      it "sends a hazardous command without prompting" do
-        capture_io do |stdout|
-          cmd_raw_no_hazardous_check("INST COLLECT with TYPE 1")
-          expect(stdout.string).to match(/cmd_raw\(\"INST COLLECT/) #"
-          expect(stdout.string).to_not match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring hazardous warnings")
-        end
-      end
-    end
-
-    describe "cmd_raw_no_checks" do
-      it "sends an out of range hazardous command without prompting" do
-        capture_io do |stdout|
-          cmd_raw_no_checks("INST COLLECT with TYPE 1, DURATION 20")
-          expect(stdout.string).to match(/cmd_raw\(\"INST COLLECT/) #"
-          expect(stdout.string).to_not match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring hazardous warnings")
-        end
-      end
-    end
-
-    describe "send_raw" do
-      it "uses the JsonDRbObject and is not disconnected" do
-        expect { send_raw('INST_INT', '\x00') }.to raise_error(DRb::DRbConnError)
-      end
-    end
-
-    describe "send_raw_file" do
-      it "uses the JsonDRbObject and is not disconnected" do
-        file = File.open('raw_test_file.bin','wb')
-        file.write '\x00\x01\x02\x03'
-        file.close
-
-        expect { send_raw_file('INST_INT', 'raw_test_file.bin') }.to raise_error(DRb::DRbConnError)
-
-        File.delete('raw_test_file.bin')
-      end
-    end
-
-    describe "get_cmd_list" do
-      it "returns all the target commands" do
-        list = get_cmd_list("INST")
-        # Only check for the collect command to make this test list dependent
-        # on the demo INST command definition file
-        expect(list).to include(["COLLECT", "Starts a collect on the instrument"])
-      end
-    end
-
-    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, "UINT"])
-      end
-    end
-
-    describe "get_cmd_hazardous" do
-      it "returns whether a command is hazardous" do
-        expect(get_cmd_hazardous("INST", "COLLECT", {"TYPE"=>"NORMAL"})).to be false
-        expect(get_cmd_hazardous("INST", "COLLECT", {"TYPE"=>"SPECIAL"})).to be true
-      end
-    end
-
-  end
-end