cosmos 4.0.3-java

data/spec/interfaces/protocols/override_protocol_spec.rb

@@ -0,0 +1,158 @@
+# 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/interface'
+require 'cosmos/interfaces/protocols/override_protocol'
+
+module Cosmos
+  describe OverrideProtocol do
+    let(:interface) do
+      interface = Interface.new
+      class << interface
+        def read_interface; ""; end
+      end
+      interface.add_protocol(OverrideProtocol, [], :READ)
+      interface
+    end
+
+    it "overrides INT values" do
+      pkt = Packet.new("TGT","PKT")
+      rc = GenericConversion.new("value * 2")
+      wc = GenericConversion.new("value * 4")
+      pkt.append_item("ITEM", 8, :INT, nil, :BIG_ENDIAN, :ERROR, nil, rc, wc)
+      expect(pkt.read("ITEM")).to eql(0)
+
+      interface._override_tlm_raw("TGT","PKT","ITEM",-10)
+      pkt.write("ITEM", 0, :RAW)
+      pkt = interface.read_protocols[0].read_packet(pkt)
+      expect(pkt.read("ITEM")).to eql(-20)
+
+      interface._override_tlm("TGT","PKT","ITEM",-10) # Write conversion writes -40
+      pkt.write("ITEM", 0, :RAW)
+      pkt = interface.read_protocols[0].read_packet(pkt)
+      expect(pkt.read("ITEM")).to eql(-80) # Read conversion reads -80
+    end
+
+    it "overrides UINT values" do
+      pkt = Packet.new("TGT","PKT")
+      rc = GenericConversion.new("value * 2")
+      wc = GenericConversion.new("value * 4")
+      pkt.append_item("ITEM", 8, :UINT, nil, :BIG_ENDIAN, :ERROR, nil, rc, wc)
+      expect(pkt.read("ITEM")).to eql(0)
+
+      interface._override_tlm_raw("TGT","PKT","ITEM",10)
+      pkt.write("ITEM", 0, :RAW)
+      pkt = interface.read_protocols[0].read_packet(pkt)
+      expect(pkt.read("ITEM")).to eql(20)
+
+      interface._override_tlm("TGT","PKT","ITEM",10) # Write conversion writes 40
+      pkt.write("ITEM", 0, :RAW)
+      pkt = interface.read_protocols[0].read_packet(pkt)
+      expect(pkt.read("ITEM")).to eql(80) # Read conversion reads 80
+    end
+
+    it "overrides FLOAT values" do
+      pkt = Packet.new("TGT","PKT")
+      rc = GenericConversion.new("value * 2")
+      wc = GenericConversion.new("value * 4")
+      pkt.append_item("ITEM", 32, :FLOAT, nil, :BIG_ENDIAN, :ERROR, nil, rc, wc)
+      expect(pkt.read("ITEM")).to eql(0.0)
+
+      interface._override_tlm_raw("TGT","PKT","ITEM",10.5)
+      pkt.write("ITEM", 0, :RAW)
+      pkt = interface.read_protocols[0].read_packet(pkt)
+      expect(pkt.read("ITEM")).to eql(21.0)
+
+      interface._override_tlm("TGT","PKT","ITEM",10.5) # Write conversion writes 42
+      pkt.write("ITEM", 0, :RAW)
+      pkt = interface.read_protocols[0].read_packet(pkt)
+      expect(pkt.read("ITEM")).to eql(84.0) # Read conversion reads 84
+    end
+
+    it "overrides DOUBLE values" do
+      pkt = Packet.new("TGT","PKT")
+      rc = GenericConversion.new("value * 2")
+      wc = GenericConversion.new("value * 4")
+      pkt.append_item("ITEM", 32, :FLOAT, nil, :BIG_ENDIAN, :ERROR, nil, rc, wc)
+      expect(pkt.read("ITEM")).to eql(0.0)
+
+      interface._override_tlm_raw("TGT","PKT","ITEM",Float::INFINITY)
+      pkt.write("ITEM", 0, :RAW)
+      pkt = interface.read_protocols[0].read_packet(pkt)
+      expect(pkt.read("ITEM")).to eql(Float::INFINITY)
+
+      interface._override_tlm("TGT","PKT","ITEM",10.5) # Write conversion writes 42
+      pkt.write("ITEM", 0, :RAW)
+      pkt = interface.read_protocols[0].read_packet(pkt)
+      expect(pkt.read("ITEM")).to eql(84.0) # Read conversion reads 84
+    end
+
+    it "overrides STRING values" do
+      pkt = Packet.new("TGT","PKT")
+      rc = GenericConversion.new("value * 2")
+      wc = GenericConversion.new("value * 4")
+      pkt.append_item("ITEM", 1024, :STRING, nil, :BIG_ENDIAN, :ERROR, nil, rc, wc)
+      expect(pkt.read("ITEM")).to eql("")
+
+      interface._override_tlm_raw("TGT","PKT","ITEM","HI")
+      pkt.write("ITEM", 0, :RAW)
+      pkt = interface.read_protocols[0].read_packet(pkt)
+      expect(pkt.read("ITEM")).to eql("HIHI")
+
+      interface._override_tlm("TGT","PKT","ITEM","X") # Write conversion writes XXXX
+      pkt.write("ITEM", 0, :RAW)
+      pkt = interface.read_protocols[0].read_packet(pkt)
+      expect(pkt.read("ITEM")).to eql("XXXXXXXX")
+    end
+
+    it "clears overriden values" do
+      pkt = Packet.new("TGT","PKT")
+      rc = GenericConversion.new("value * 2")
+      wc = GenericConversion.new("value * 4")
+      pkt.append_item("ITEM", 8, :INT, nil, :BIG_ENDIAN, :ERROR, nil, rc, wc)
+      expect(pkt.read("ITEM")).to eql(0)
+
+      interface._override_tlm_raw("TGT","PKT","ITEM",-10)
+      pkt.write("ITEM", 0, :RAW)
+      pkt = interface.read_protocols[0].read_packet(pkt)
+      expect(pkt.read("ITEM")).to eql(-20)
+
+      interface._normalize_tlm("TGT","PKT","ITEM")
+      pkt.write("ITEM", 0, :RAW)
+      pkt = interface.read_protocols[0].read_packet(pkt)
+      expect(pkt.read("ITEM")).to eql(0)
+    end
+
+    it "warns the user if the protocol is not required" do
+      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 INST_INT interface.rb'
+        file.puts 'TARGET INST'
+        # We don't include: PROTOCOL override_protocol.rb
+      end
+      System.class_eval('@@instance = nil')
+      require 'cosmos/script'
+      @server = CmdTlmServer.new
+      shutdown_cmd_tlm()
+      initialize_script_module()
+      sleep 0.1
+
+      expect { override_tlm_raw("INST HEALTH_STATUS TEMP3 = 0") }.to raise_error(/INST_INT does not have override ability/)
+
+      @server.stop
+      shutdown_cmd_tlm()
+      sleep(0.1)
+      clean_config()
+      FileUtils.rm_rf File.join(Cosmos::USERPATH,'config','tools')
+    end
+  end
+end

data/spec/interfaces/protocols/preidentified_protocol_spec.rb

@@ -0,0 +1,149 @@
+# 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/preidentified_protocol'
+require 'cosmos/interfaces/interface'
+require 'cosmos/streams/stream'
+
+module Cosmos
+  describe PreidentifiedProtocol do
+    before(:each) do
+      $buffer = ''
+      @interface = StreamInterface.new
+      allow(@interface).to receive(:connected?) { true }
+    end
+
+    after(:all) do
+      clean_config()
+    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
+
+    it "handles receiving a bad packet length" do
+      @interface.instance_variable_set(:@stream, PreStream.new)
+      @interface.add_protocol(PreidentifiedProtocol, [nil, 5], :READ_WRITE)
+      pkt = System.telemetry.packet("SYSTEM","META")
+      time = Time.new(2020,1,31,12,15,30.5)
+      pkt.received_time = time
+      @interface.write(pkt)
+      expect { packet = @interface.read }.to raise_error(RuntimeError)
+    end
+
+    describe "initialize" do
+      it "initializes attributes" do
+        @interface.add_protocol(PreidentifiedProtocol, ['0xDEADBEEF', 100], :READ_WRITE)
+        expect(@interface.read_protocols[0].instance_variable_get(:@data)).to eq ''
+        expect(@interface.read_protocols[0].instance_variable_get(:@sync_pattern)).to eq "\xDE\xAD\xBE\xEF"
+        expect(@interface.read_protocols[0].instance_variable_get(:@max_length)).to eq 100
+      end
+    end
+
+    describe "write" do
+      it "creates a packet header" do
+        @interface.instance_variable_set(:@stream, PreStream.new)
+        @interface.add_protocol(PreidentifiedProtocol, [nil, 5], :READ_WRITE)
+        pkt = System.telemetry.packet("SYSTEM","META")
+        time = Time.new(2020,1,31,12,15,30.5)
+        pkt.received_time = time
+        @interface.write(pkt)
+        expect($buffer[0..3].unpack('N')[0]).to eql time.to_f.to_i
+        expect($buffer[4..7].unpack('N')[0]).to eql 500000
+        offset = 8
+        tgt_name_length = $buffer[offset].unpack('C')[0]
+        offset += 1 # for the length field
+        expect($buffer[offset...(offset+tgt_name_length)]).to eql 'SYSTEM'
+        offset += tgt_name_length
+        pkt_name_length = $buffer[offset].unpack('C')[0]
+        offset += 1 # for the length field
+        expect($buffer[offset...(offset+pkt_name_length)]).to eql 'META'
+        offset += pkt_name_length
+        expect($buffer[offset..(offset+3)].unpack('N')[0]).to eql pkt.buffer.length
+        offset += 4
+        expect($buffer[offset..-1]).to eql pkt.buffer
+      end
+
+      it "handles a sync pattern" do
+        @interface.instance_variable_set(:@stream, PreStream.new)
+        @interface.add_protocol(PreidentifiedProtocol, ["DEAD"], :READ_WRITE)
+        pkt = System.telemetry.packet("SYSTEM","META")
+        time = Time.new(2020,1,31,12,15,30.5)
+        pkt.received_time = time
+        @interface.write(pkt)
+        expect($buffer[0..1]).to eql("\xDE\xAD")
+        expect($buffer[2..5].unpack('N')[0]).to eql time.to_f.to_i
+        expect($buffer[6..9].unpack('N')[0]).to eql 500000
+        offset = 10
+        tgt_name_length = $buffer[offset].unpack('C')[0]
+        offset += 1 # for the length field
+        expect($buffer[offset...(offset+tgt_name_length)]).to eql 'SYSTEM'
+        offset += tgt_name_length
+        pkt_name_length = $buffer[offset].unpack('C')[0]
+        offset += 1 # for the length field
+        expect($buffer[offset...(offset+pkt_name_length)]).to eql 'META'
+        offset += pkt_name_length
+        expect($buffer[offset..(offset+3)].unpack('N')[0]).to eql pkt.buffer.length
+        offset += 4
+        expect($buffer[offset..-1]).to eql pkt.buffer
+      end
+    end
+
+    describe "read" do
+      it "handles a sync pattern" do
+        @interface.instance_variable_set(:@stream, PreStream.new)
+        @interface.add_protocol(PreidentifiedProtocol, ["0x1234"], :READ_WRITE)
+        pkt = System.telemetry.packet("SYSTEM","META")
+        pkt.write("COSMOS_VERSION", "TEST")
+        time = Time.new(2020,1,31,12,15,30.5)
+        pkt.received_time = time
+        @interface.write(pkt)
+        expect($buffer[0]).to eql "\x12"
+        expect($buffer[1]).to eql "\x34"
+        packet = @interface.read
+        expect(packet.target_name).to eql 'SYSTEM'
+        expect(packet.packet_name).to eql 'META'
+        expect(packet.identified?).to be true
+        expect(packet.defined?).to be false
+
+        pkt2 = System.telemetry.update!("SYSTEM","META",packet.buffer)
+        expect(pkt2.read('COSMOS_VERSION')).to eql 'TEST'
+        expect(pkt2.identified?).to be true
+        expect(pkt2.defined?).to be true
+      end
+
+      it "returns a packet" do
+        @interface.instance_variable_set(:@stream, PreStream.new)
+        @interface.add_protocol(PreidentifiedProtocol, [], :READ_WRITE)
+        pkt = System.telemetry.packet("SYSTEM","META")
+        pkt.write("COSMOS_VERSION", "TEST")
+        time = Time.new(2020,1,31,12,15,30.5)
+        pkt.received_time = time
+        @interface.write(pkt)
+        packet = @interface.read
+        expect(packet.target_name).to eql 'SYSTEM'
+        expect(packet.packet_name).to eql 'META'
+        expect(packet.identified?).to be true
+        expect(packet.defined?).to be false
+
+        pkt2 = System.telemetry.update!("SYSTEM","META",packet.buffer)
+        expect(pkt2.read('COSMOS_VERSION')).to eql 'TEST'
+        expect(pkt2.identified?).to be true
+        expect(pkt2.defined?).to be true
+      end
+    end
+
+  end
+end

data/spec/interfaces/protocols/template_protocol_spec.rb

@@ -0,0 +1,322 @@
+# 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/template_protocol'
+require 'cosmos/interfaces/interface'
+require 'cosmos/streams/stream'
+require 'cosmos/utilities/logger'
+
+module Cosmos
+  describe TemplateProtocol do
+    class TemplateStream < Stream
+      def connect; end
+      def connected?; true; end
+      def disconnect; end
+      def read_nonblock; []; end
+      def write(buffer) $write_buffer = buffer; end
+      def read; $read_buffer; end
+    end
+
+    before(:each) do
+      @interface = StreamInterface.new
+      allow(@interface).to receive(:connected?) { true }
+      $read_buffer = ''
+      $read_cnt = 0
+    end
+
+    describe "initialize" do
+      it "initializes attributes" do
+        @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD), :READ_WRITE)
+        expect(@interface.read_protocols[0].instance_variable_get(:@data)).to eq ''
+      end
+    end
+
+    describe "connect" do
+      it "supports an initial read delay" do
+        @interface.instance_variable_set(:@stream, TemplateStream.new)
+        @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD 0 2), :READ_WRITE)
+        time = Time.now
+        @interface.connect
+        expect(@interface.read_protocols[0].instance_variable_get(:@connect_complete_time)).to be >= time + 2.0
+      end
+    end
+
+    describe "disconnect" do
+      it "unblocks writes waiting for responses" do
+        @interface.instance_variable_set(:@stream, TemplateStream.new)
+        @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD), :READ_WRITE)
+        packet = Packet.new('TGT', 'CMD')
+        packet.append_item("CMD_TEMPLATE", 1024, :STRING)
+        packet.get_item("CMD_TEMPLATE").default = "SOUR:VOLT"
+        packet.append_item("RSP_TEMPLATE", 1024, :STRING)
+        packet.get_item("RSP_TEMPLATE").default = "<VOLTAGE>"
+        packet.append_item("RSP_PACKET", 1024, :STRING)
+        packet.get_item("RSP_PACKET").default = "READ_VOLTAGE"
+        packet.restore_defaults
+        # write blocks waiting for the response so spawn a thread
+        thread = Thread.new { @interface.write(packet) }
+        sleep 0.1
+        @interface.disconnect
+        sleep 0.1
+        expect(thread.alive?).to be false
+      end
+    end
+
+    describe "read_data" do
+      it "ignores all data during the connect period" do
+        @interface.instance_variable_set(:@stream, TemplateStream.new)
+        @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD 0 1.5), :READ_WRITE)
+        start = Time.now
+        @interface.connect
+        $read_buffer = "\x31\x30\xAB\xCD"
+        data = @interface.read
+        expect(Time.now - start).to be_within(0.1).of(1.5)
+        expect(data.buffer).to eql("\x31\x30")
+      end
+    end
+
+    describe "write" do
+      it "waits before writing during the initial delay period" do
+        @interface.instance_variable_set(:@stream, TemplateStream.new)
+        @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD 0 1.5), :READ_WRITE)
+        packet = Packet.new('TGT', 'CMD')
+        packet.append_item("VOLTAGE", 16, :UINT)
+        packet.get_item("VOLTAGE").default = 1
+        packet.append_item("CHANNEL", 16, :UINT)
+        packet.get_item("CHANNEL").default = 2
+        packet.append_item("CMD_TEMPLATE", 1024, :STRING)
+        packet.get_item("CMD_TEMPLATE").default = "SOUR:VOLT <VOLTAGE>, (@<CHANNEL>)"
+        packet.restore_defaults
+        @interface.connect
+        write = Time.now
+        @interface.write(packet)
+        expect(Time.now - write).to be_within(0.1).of(1.5)
+      end
+
+      it "works without a response" do
+        @interface.instance_variable_set(:@stream, TemplateStream.new)
+        @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD), :READ_WRITE)
+        packet = Packet.new('TGT', 'CMD')
+        packet.append_item("VOLTAGE", 16, :UINT)
+        packet.get_item("VOLTAGE").default = 1
+        packet.append_item("CHANNEL", 16, :UINT)
+        packet.get_item("CHANNEL").default = 2
+        packet.append_item("CMD_TEMPLATE", 1024, :STRING)
+        packet.get_item("CMD_TEMPLATE").default = "SOUR:VOLT <VOLTAGE>, (@<CHANNEL>)"
+        packet.restore_defaults
+        @interface.write(packet)
+        expect($write_buffer).to eql("SOUR:VOLT 1, (@2)\xAB\xCD")
+      end
+
+      it "logs an error if it doesn't receive a response" do
+        @interface.instance_variable_set(:@stream, TemplateStream.new)
+        @interface.add_protocol(TemplateProtocol, %w(0xA 0xA 0 nil 1 true 0 nil false 1.5), :READ_WRITE)
+        @interface.target_names = ['TGT']
+        packet = Packet.new('TGT', 'CMD')
+        packet.append_item("CMD_TEMPLATE", 1024, :STRING)
+        packet.get_item("CMD_TEMPLATE").default = "GO"
+        packet.append_item("RSP_TEMPLATE", 1024, :STRING)
+        packet.get_item("RSP_TEMPLATE").default = "<VOLTAGE>"
+        packet.append_item("RSP_PACKET", 1024, :STRING)
+        packet.get_item("RSP_PACKET").default = "DATA"
+        packet.restore_defaults
+        @interface.connect
+        start = Time.now
+        logger = class_double("Cosmos::Logger").as_stubbed_const(:transfer_nested_constants => true)
+        expect(logger).to receive(:error).with("StreamInterface: Timeout waiting for response")
+        @interface.write(packet)
+        expect(Time.now - start).to be_within(0.1).of(1.5)
+      end
+
+      it "disconnects if it doesn't receive a response" do
+        @interface.instance_variable_set(:@stream, TemplateStream.new)
+        @interface.add_protocol(TemplateProtocol, %w(0xA 0xA 0 nil 1 true 0 nil false 1.5 0.02 true), :READ_WRITE)
+        @interface.target_names = ['TGT']
+        packet = Packet.new('TGT', 'CMD')
+        packet.append_item("CMD_TEMPLATE", 1024, :STRING)
+        packet.get_item("CMD_TEMPLATE").default = "GO"
+        packet.append_item("RSP_TEMPLATE", 1024, :STRING)
+        packet.get_item("RSP_TEMPLATE").default = "<VOLTAGE>"
+        packet.append_item("RSP_PACKET", 1024, :STRING)
+        packet.get_item("RSP_PACKET").default = "DATA"
+        packet.restore_defaults
+        @interface.connect
+        start = Time.now
+        expect { @interface.write(packet) }.to raise_error(/Timeout waiting for response/)
+        expect(Time.now - start).to be_within(0.1).of(1.5)
+      end
+
+      it "doesn't expect responses for empty response fields" do
+        @interface.instance_variable_set(:@stream, TemplateStream.new)
+        @interface.add_protocol(TemplateProtocol, %w(0xA 0xA 0 nil 1 true 0 nil false nil), :READ_WRITE)
+        @interface.target_names = ['TGT']
+        packet = Packet.new('TGT', 'CMD')
+        packet.append_item("CMD_TEMPLATE", 1024, :STRING)
+        packet.get_item("CMD_TEMPLATE").default = "GO"
+        packet.append_item("RSP_TEMPLATE", 1024, :STRING)
+        packet.get_item("RSP_TEMPLATE").default = ""
+        packet.append_item("RSP_PACKET", 1024, :STRING)
+        packet.get_item("RSP_PACKET").default = ""
+        packet.restore_defaults
+        @interface.connect
+        start = Time.now
+        logger = class_double("Cosmos::Logger").as_stubbed_const(:transfer_nested_constants => true)
+        expect(logger).to_not receive(:error)
+        @interface.write(packet)
+      end
+
+      it "processes responses" do
+        rsp_pkt = Packet.new('TGT', 'READ_VOLTAGE')
+        rsp_pkt.append_item("VOLTAGE", 16, :UINT)
+        allow(System).to receive_message_chain(:telemetry, :packet).and_return(rsp_pkt)
+        @interface.instance_variable_set(:@stream, TemplateStream.new)
+        @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD 0 nil 1 true 0 nil false nil nil), :READ_WRITE)
+        @interface.target_names = ['TGT']
+        packet = Packet.new('TGT', 'CMD')
+        packet.append_item("VOLTAGE", 16, :UINT)
+        packet.get_item("VOLTAGE").default = 11
+        packet.append_item("CHANNEL", 16, :UINT)
+        packet.get_item("CHANNEL").default = 1
+        packet.append_item("CMD_TEMPLATE", 1024, :STRING)
+        packet.get_item("CMD_TEMPLATE").default = "SOUR:VOLT <VOLTAGE>, (@<CHANNEL>)"
+        packet.append_item("RSP_TEMPLATE", 1024, :STRING)
+        packet.get_item("RSP_TEMPLATE").default = "<VOLTAGE>"
+        packet.append_item("RSP_PACKET", 1024, :STRING)
+        packet.get_item("RSP_PACKET").default = "READ_VOLTAGE"
+        packet.restore_defaults
+        @interface.connect
+        read_result = nil
+        $read_buffer = "\x31\x30\xAB\xCD" # ASCII 31, 30 is '10'
+        Thread.new { sleep(0.5); read_result = @interface.read }
+        @interface.write(packet)
+        sleep 0.55
+        expect($write_buffer).to eql("SOUR:VOLT 11, (@1)\xAB\xCD")
+        expect(read_result.read("VOLTAGE")).to eq 10
+      end
+
+      it "handles templates with more values than the response" do
+        rsp_pkt = Packet.new('TGT', 'READ_VOLTAGE')
+        rsp_pkt.append_item("VOLTAGE", 16, :UINT)
+        allow(System).to receive_message_chain(:telemetry, :packet).and_return(rsp_pkt)
+        @interface.instance_variable_set(:@stream, TemplateStream.new)
+        @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD 0 nil 1 true 0 nil false nil), :READ_WRITE)
+        @interface.target_names = ['TGT']
+        packet = Packet.new('TGT', 'CMD')
+        packet.append_item("VOLTAGE", 16, :UINT)
+        packet.get_item("VOLTAGE").default = 12
+        packet.append_item("CHANNEL", 16, :UINT)
+        packet.get_item("CHANNEL").default = 2
+        packet.append_item("CMD_TEMPLATE", 1024, :STRING)
+        packet.get_item("CMD_TEMPLATE").default = "SOUR:VOLT <VOLTAGE>, (@<CHANNEL>)"
+        packet.append_item("RSP_TEMPLATE", 1024, :STRING)
+        packet.get_item("RSP_TEMPLATE").default = "<VOLTAGE>;<CURRENT>"
+        packet.append_item("RSP_PACKET", 1024, :STRING)
+        packet.get_item("RSP_PACKET").default = "READ_VOLTAGE"
+        packet.restore_defaults
+        @interface.connect
+        read_result = nil
+        $read_buffer = "\x31\x30\xAB\xCD" # ASCII 31, 30 is '10'
+        Thread.new { sleep(0.5); read_result = @interface.read }
+        logger = class_double("Cosmos::Logger").as_stubbed_const(:transfer_nested_constants => true)
+        expect(logger).to receive(:error) do |arg|
+          expect(arg).to match(/Unexpected response: 10/)
+        end
+        @interface.write(packet)
+        sleep 0.55
+        expect($write_buffer).to eql("SOUR:VOLT 12, (@2)\xAB\xCD")
+      end
+
+      it "handles responses with more values than the template" do
+        rsp_pkt = Packet.new('TGT', 'READ_VOLTAGE')
+        rsp_pkt.append_item("VOLTAGE", 16, :UINT)
+        allow(System).to receive_message_chain(:telemetry, :packet).and_return(rsp_pkt)
+        @interface.instance_variable_set(:@stream, TemplateStream.new)
+        @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD 0 nil 1 true 0 nil false nil), :READ_WRITE)
+        @interface.target_names = ['TGT']
+        packet = Packet.new('TGT', 'CMD')
+        packet.append_item("VOLTAGE", 16, :UINT)
+        packet.get_item("VOLTAGE").default = 12
+        packet.append_item("CHANNEL", 16, :UINT)
+        packet.get_item("CHANNEL").default = 2
+        packet.append_item("CMD_TEMPLATE", 1024, :STRING)
+        packet.get_item("CMD_TEMPLATE").default = "SOUR:VOLT <VOLTAGE>, (@<CHANNEL>)"
+        packet.append_item("RSP_TEMPLATE", 1024, :STRING)
+        packet.get_item("RSP_TEMPLATE").default = "<VOLTAGE>"
+        packet.append_item("RSP_PACKET", 1024, :STRING)
+        packet.get_item("RSP_PACKET").default = "READ_VOLTAGE"
+        packet.restore_defaults
+        @interface.connect
+        read_result = nil
+        $read_buffer = "\x31\x30\x3B\x31\x31\xAB\xCD" # ASCII is '10;11'
+        Thread.new { sleep(0.5); read_result = @interface.read }
+        logger = class_double("Cosmos::Logger").as_stubbed_const(:transfer_nested_constants => true)
+        expect(logger).to receive(:error) do |arg|
+          expect(arg).to match(/Could not write value 10;11/)
+        end
+        @interface.write(packet)
+        sleep 0.55
+        expect($write_buffer).to eql("SOUR:VOLT 12, (@2)\xAB\xCD")
+      end
+
+      it "ignores response lines" do
+        rsp_pkt = Packet.new('TGT', 'READ_VOLTAGE')
+        rsp_pkt.append_item("VOLTAGE", 16, :UINT)
+        allow(System).to receive_message_chain(:telemetry, :packet).and_return(rsp_pkt)
+        @interface.instance_variable_set(:@stream, TemplateStream.new)
+        @interface.add_protocol(TemplateProtocol, %w(0xAD 0xA 1), :READ_WRITE)
+        @interface.target_names = ['TGT']
+        packet = Packet.new('TGT', 'CMD')
+        packet.append_item("VOLTAGE", 16, :UINT)
+        packet.get_item("VOLTAGE").default = 11
+        packet.append_item("CHANNEL", 16, :UINT)
+        packet.get_item("CHANNEL").default = 20
+        packet.append_item("CMD_TEMPLATE", 1024, :STRING)
+        packet.get_item("CMD_TEMPLATE").default = "SOUR:VOLT <VOLTAGE>, (@<CHANNEL>)"
+        packet.append_item("RSP_TEMPLATE", 1024, :STRING)
+        packet.get_item("RSP_TEMPLATE").default = "<VOLTAGE>"
+        packet.append_item("RSP_PACKET", 1024, :STRING)
+        packet.get_item("RSP_PACKET").default = "READ_VOLTAGE"
+        packet.restore_defaults
+        @interface.connect
+        read_result = nil
+        $read_buffer = "\x31\x30\x0A\x31\x32\x0A" # ASCII: 30:'0', 31:'1', etc
+        Thread.new { sleep(0.5); read_result = @interface.read }
+        @interface.write(packet)
+        expect($write_buffer).to eql("SOUR:VOLT 11, (@20)\xAD")
+        expect(read_result.read("VOLTAGE")).to eq 12
+      end
+    end
+
+    it "allows multiple response lines" do
+      rsp_pkt = Packet.new('TGT', 'DATA')
+      rsp_pkt.append_item("STRING", 512, :STRING)
+      allow(System).to receive_message_chain(:telemetry, :packet).and_return(rsp_pkt)
+      @interface.instance_variable_set(:@stream, TemplateStream.new)
+      @interface.add_protocol(TemplateProtocol, %w(0xAD 0xA 0 nil 2), :READ_WRITE)
+      @interface.target_names = ['TGT']
+      packet = Packet.new('TGT', 'CMD')
+      packet.append_item("CMD_TEMPLATE", 1024, :STRING)
+      packet.get_item("CMD_TEMPLATE").default = "GO"
+      packet.append_item("RSP_TEMPLATE", 1024, :STRING)
+      packet.get_item("RSP_TEMPLATE").default = "<STRING>"
+      packet.append_item("RSP_PACKET", 1024, :STRING)
+      packet.get_item("RSP_PACKET").default = "DATA"
+      packet.restore_defaults
+      @interface.connect
+      read_result = nil
+      $read_buffer = "\x43\x4F\x53\x0A\x4D\x4F\x53\x0A" # ASCII
+      Thread.new { sleep(0.5); read_result = @interface.read }
+      @interface.write(packet)
+      expect($write_buffer).to eql("GO\xAD")
+      expect(read_result.read("STRING")).to eq 'COSMOS'
+    end
+  end
+end