cosmos 3.9.2 → 4.0.0

data/spec/streams/burst_stream_protocol_spec.rb

@@ -1,32 +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/streams/burst_stream_protocol'
-
-module Cosmos
-
-  describe BurstStreamProtocol do
-
-    describe "initialize" do
-      it "initializes attributes" do
-        bsp = BurstStreamProtocol.new
-        expect(bsp.bytes_read).to eql 0
-        expect(bsp.bytes_written).to eql 0
-        expect(bsp.interface).to be_nil
-        expect(bsp.stream).to be_nil
-        expect(bsp.post_read_data_callback).to be_nil
-        expect(bsp.post_read_packet_callback).to be_nil
-        expect(bsp.pre_write_packet_callback).to be_nil
-      end
-    end
-  end
-end
-

data/spec/streams/fixed_stream_protocol_spec.rb

@@ -1,113 +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/streams/fixed_stream_protocol'
-require 'cosmos/interfaces/interface'
-require 'cosmos/streams/stream'
-
-module Cosmos
-
-  class MyInterface < Interface; end
-
-  describe FixedStreamProtocol do
-    before(:each) do
-      @fsp = FixedStreamProtocol.new(1)
-    end
-
-    after(:each) do
-      clean_config()
-    end
-
-    describe "initialize" do
-      it "initializes attributes" do
-        expect(@fsp.bytes_read).to eql 0
-        expect(@fsp.bytes_written).to eql 0
-        expect(@fsp.interface).to be_nil
-        expect(@fsp.stream).to be_nil
-        expect(@fsp.post_read_data_callback).to be_nil
-        expect(@fsp.post_read_packet_callback).to be_nil
-        expect(@fsp.pre_write_packet_callback).to be_nil
-      end
-    end
-
-    describe "read" do
-      it "complains if no interface set" do
-        class MyStream < Stream
-          def connect; end
-          def connected?; true; end
-          def read; "\x01\x02\x03\x04"; end
-        end
-        stream = MyStream.new
-        @fsp.connect(stream)
-        expect { @fsp.read }.to raise_error(/Interface required/)
-      end
-
-      it "reads telemetry data from the stream" do
-        class MyStream < Stream
-          def connect; end
-          def connected?; true; end
-          def read; "\x01\x02"; end
-        end
-        stream = MyStream.new
-        @fsp.connect(stream)
-        interface = MyInterface.new
-        interface.target_names = %w(TEST COSMOS)
-        @fsp.interface = interface
-        packet = @fsp.read
-        expect(packet.received_time.to_f).to be_within(0.1).of(Time.now.to_f)
-        expect(packet.target_name).to eql 'COSMOS'
-        expect(packet.packet_name).to eql 'VERSION'
-        packet = @fsp.read
-        expect(packet.received_time.to_f).to be_within(0.1).of(Time.now.to_f)
-        expect(packet.target_name).to eql 'COSMOS'
-        expect(packet.packet_name).to eql 'LIMITS_CHANGE'
-        packet = @fsp.read
-        expect(packet.received_time.to_f).to be_within(0.1).of(Time.now.to_f)
-        expect(packet.target_name).to eql 'COSMOS'
-        expect(packet.packet_name).to eql 'VERSION'
-        packet = @fsp.read
-        expect(packet.received_time.to_f).to be_within(0.1).of(Time.now.to_f)
-        expect(packet.target_name).to eql 'COSMOS'
-        expect(packet.packet_name).to eql 'LIMITS_CHANGE'
-      end
-
-      it "reads command data from the stream" do
-        @fsp = FixedStreamProtocol.new(8, 0, '0x1ACFFC1D', false)
-
-        $index = 0
-        class MyStream < Stream
-          def connect; end
-          def connected?; true; end
-          def read
-            case $index
-            when 0
-              $index += 1
-              "\x1A\xCF\xFC\x1D\x00\x00\x00\x02"
-            else
-              "\x00\x00\x00\x00\x00\x00\x00\x00"
-            end
-          end
-        end
-        stream = MyStream.new
-        @fsp.connect(stream)
-        interface = MyInterface.new
-        interface.target_names = %w(TEST COSMOS)
-        @fsp.interface = interface
-        packet = @fsp.read
-        expect(packet.received_time.to_f).to be_within(0.01).of(Time.now.to_f)
-        expect(packet.target_name).to eql 'COSMOS'
-        expect(packet.packet_name).to eql 'STARTLOGGING'
-      end
-    end
-
-  end
-end
-

data/spec/streams/length_stream_protocol_spec.rb

@@ -1,300 +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/streams/length_stream_protocol'
-require 'cosmos/interfaces/interface'
-require 'cosmos/streams/stream'
-
-module Cosmos
-
-  describe LengthStreamProtocol do
-    describe "initialize" do
-      it "initializes attributes" do
-        lsp = LengthStreamProtocol.new(1)
-        expect(lsp.bytes_read).to eql 0
-        expect(lsp.bytes_written).to eql 0
-        expect(lsp.interface).to be_nil
-        expect(lsp.stream).to be_nil
-        expect(lsp.post_read_data_callback).to be_nil
-        expect(lsp.post_read_packet_callback).to be_nil
-        expect(lsp.pre_write_packet_callback).to be_nil
-      end
-    end
-
-    describe "read" do
-      it "reads BIG_ENDIAN length fields from the stream" do
-        class MyStream < Stream
-          def connect; end
-          def connected?; true; end
-          def read
-            case $index
-            when 0
-              $index += 1
-              $buffer1
-            when 1
-              $buffer2
-            end
-          end
-        end
-        stream = MyStream.new
-
-        lsp = LengthStreamProtocol.new(16, # bit offset
-                                        16, # bit size
-                                        1,  # length offset
-                                        1,  # bytes per count
-                                        'BIG_ENDIAN')
-        lsp.connect(stream)
-        $index = 0
-        $buffer1 = "\x00\x01\x00\x05"
-        $buffer2 = "\x03\x04"
-        packet = lsp.read
-        expect(packet.buffer.length).to eql 6
-
-        lsp = LengthStreamProtocol.new(16, # bit offset
-                                        16, # bit size
-                                        1,  # length offset
-                                        2,  # bytes per count
-                                        'BIG_ENDIAN')
-        lsp.connect(stream)
-        $index = 0
-        $buffer1 = "\x00\x01\x00\x05"
-        $buffer2 = "\x03\x04\x05\x06\x07\x08\x09"
-        packet = lsp.read
-        expect(packet.buffer.length).to eql 11
-
-        lsp = LengthStreamProtocol.new(19, # bit offset
-                                        5,  # bit size
-                                        0,  # length offset
-                                        1,  # bytes per count
-                                        'BIG_ENDIAN')
-        lsp.connect(stream)
-        $index = 0
-        $buffer1 = "\x00\x01\x05"
-        $buffer2 = "\x03\x04"
-        packet = lsp.read
-        expect(packet.buffer.length).to eql 5
-
-        lsp = LengthStreamProtocol.new(16, # bit offset
-                                        16, # bit size
-                                        1,  # length offset
-                                        1,  # bytes per count
-                                        'BIG_ENDIAN',
-                                        0,
-                                        nil,
-                                        50)
-        lsp.connect(stream)
-        $index = 0
-        $buffer1 = "\x00\x01\xFF\xFF"
-        $buffer2 = "\x03\x04"
-        expect { packet = lsp.read }.to raise_error(RuntimeError, "Length value received larger than max_length: 65535 > 50")
-      end
-
-      it "reads LITTLE_ENDIAN length fields from the stream" do
-        class MyStream < Stream
-          def connect; end
-          def connected?; true; end
-          def read
-            case $index
-            when 0
-              $index += 1
-              $buffer1
-            when 1
-              $buffer2
-            end
-          end
-        end
-        stream = MyStream.new
-
-        lsp = LengthStreamProtocol.new(16, # bit offset
-                                        16, # bit size
-                                        1,  # length offset
-                                        1,  # bytes per count
-                                        'LITTLE_ENDIAN')
-        lsp.connect(stream)
-        $index = 0
-        $buffer1 = "\x00\x01\x05\x00"
-        $buffer2 = "\x03\x04"
-        packet = lsp.read
-        expect(packet.buffer.length).to eql 6
-
-        lsp = LengthStreamProtocol.new(16, # bit offset
-                                        16, # bit size
-                                        1,  # length offset
-                                        2,  # bytes per count
-                                        'LITTLE_ENDIAN')
-        lsp.connect(stream)
-        $index = 0
-        $buffer1 = "\x00\x01\x05\x00"
-        $buffer2 = "\x03\x04\x05\x06\x07\x08\x09"
-        packet = lsp.read
-        expect(packet.buffer.length).to eql 11
-
-        lsp = LengthStreamProtocol.new(19, # bit offset
-                                        5,  # bit size
-                                        0,  # length offset
-                                        1,  # bytes per count
-                                        'LITTLE_ENDIAN')
-        lsp.connect(stream)
-        $index = 0
-        $buffer1 = "\x00\x01\x05"
-        $buffer2 = "\x03\x04"
-        packet = lsp.read
-        expect(packet.buffer.length).to eql 5
-
-        lsp = LengthStreamProtocol.new(16, # bit offset
-                                        16, # bit size
-                                        1,  # length offset
-                                        1,  # bytes per count
-                                        'LITTLE_ENDIAN',
-                                        0,
-                                        nil,
-                                        239)
-        lsp.connect(stream)
-        $index = 0
-        $buffer1 = "\x00\x01\xF0\x00"
-        $buffer2 = "\x03\x04"
-        expect { packet = lsp.read }.to raise_error(RuntimeError, "Length value received larger than max_length: 240 > 239")
-      end
-    end
-
-    describe "write" do
-      it "fills the length field and sync pattern if told to" do
-        class MyStream < Stream
-          def connect; end
-          @@written_data = nil
-          def self.written_data
-            @@written_data
-          end
-          def connected?; true; end
-          def write(data)
-            @@written_data = data
-          end
-        end
-        stream = MyStream.new
-
-        lsp = LengthStreamProtocol.new(32, # bit offset
-                                        16, # bit size
-                                        6,  # length offset
-                                        2,  # bytes per count
-                                        'BIG_ENDIAN',
-                                        0,  # discard no leading bytes
-                                        "BA5EBA11",
-                                        nil,
-                                        true)
-
-        lsp.connect(stream)
-        packet = Packet.new(nil, nil)
-        packet.buffer = "\x01\x02\x03\x04"
-        # 4 bytes are not enough since we expect the length field at offset 32
-        expect { lsp.write(packet) }.to raise_error(ArgumentError, /buffer insufficient/)
-
-        lsp = LengthStreamProtocol.new(32, # bit offset
-                                        16, # bit size
-                                        6,  # length offset
-                                        2,  # bytes per count
-                                        'BIG_ENDIAN',
-                                        2,  # discard 2 leading bytes
-                                        "BA5EBA11",
-                                        nil,
-                                        true)
-
-        lsp.connect(stream)
-        packet = Packet.new(nil, nil)
-        # The packet buffer contains data
-        packet.buffer = "\x01\x02\x03\x04"
-        lsp.write(packet)
-        # Since we discarded 2 leading bytes, they are put back in the final stream data
-        # with the sync word and then then length is set to 0
-        expect(MyStream.written_data).to eql("\xBA\x5E\xBA\x11\x00\x00")
-        expect(packet.buffer).to eql("\x01\x02\x00\x00")
-
-        lsp = LengthStreamProtocol.new(32, # bit offset
-                                        16, # bit size
-                                        6,  # length offset
-                                        2,  # bytes per count
-                                        'BIG_ENDIAN',
-                                        4,  # discard 4 leading bytes
-                                        "BA5EBA11",
-                                        nil,
-                                        true)
-
-        lsp.connect(stream)
-        packet = Packet.new(nil, nil)
-        # The packet buffer contains data
-        packet.buffer = "\x01\x02\x03\x04"
-        lsp.write(packet)
-        # Since we discarded 4 leading bytes, they are put back in the final stream data
-        # with the sync word and then then length is set to 1 followed by the
-        # last two bytes in the buffer. The \x01\x02 get written over by the length.
-        expect(MyStream.written_data).to eql("\xBA\x5E\xBA\x11\x00\x01\x03\x04")
-        expect(packet.buffer).to eql("\x00\x01\x03\x04")
-
-        lsp = LengthStreamProtocol.new(32, # bit offset
-                                        16, # bit size
-                                        6,  # length offset
-                                        2,  # bytes per count
-                                        'BIG_ENDIAN',
-                                        6,  # discard 6 leading bytes (sync and length)
-                                        "BA5EBA11",
-                                        nil,
-                                        true)
-
-        lsp.connect(stream)
-        packet = Packet.new(nil, nil)
-        # The packet buffer contains only the data
-        packet.buffer = "\x01\x02\x03\x04"
-        lsp.write(packet)
-        # Since we discarded 6 leading bytes, they are put back in the final stream data
-        # with the sync word and then then length is set to 2 followed by the buffer data.
-        expect(MyStream.written_data).to eql("\xBA\x5E\xBA\x11\x00\x02\x01\x02\x03\x04")
-        expect(packet.buffer).to eql("\x01\x02\x03\x04")
-
-        lsp = LengthStreamProtocol.new(64, # bit offset
-                                        32, # bit size
-                                        12, # length offset
-                                        1,  # bytes per count
-                                        'BIG_ENDIAN',
-                                        8,  # discard 8 leading bytes (sync)
-                                        "BA5EBA11CAFEBABE",
-                                        nil,
-                                        true)
-        lsp.connect(stream)
-        packet = Packet.new(nil, nil)
-        # The packet buffer contains the length field which is overwritten by the write call
-        packet.buffer = "\x00\x00\x00\x00\x01\x02\x03\x04"
-        lsp.write(packet)
-        # Since we discarded 8 leading bytes, they are put back in the final stream data
-        expect(MyStream.written_data).to eql("\xBA\x5E\xBA\x11\xCA\xFE\xBA\xBE\x00\x00\x00\x04\x01\x02\x03\x04")
-        expect(packet.buffer).to eql("\x00\x00\x00\x04\x01\x02\x03\x04")
-
-        lsp = LengthStreamProtocol.new(64, # bit offset
-                                        32, # bit size
-                                        12, # length offset
-                                        1,  # bytes per count
-                                        'BIG_ENDIAN',
-                                        0,  # discard no leading bytes
-                                        "BA5EBA11CAFEBABE",
-                                        nil,
-                                        true)
-        lsp.connect(stream)
-        packet = Packet.new(nil, nil)
-        # The packet buffer contains the sync and length fields which are overwritten by the write call
-        packet.buffer = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04"
-        lsp.write(packet)
-        # Since we discarded 0 leading bytes, they are simply written over by the write call
-        expect(MyStream.written_data).to eql("\xBA\x5E\xBA\x11\xCA\xFE\xBA\xBE\x00\x00\x00\x04\x01\x02\x03\x04")
-        expect(packet.buffer).to eql("\xBA\x5E\xBA\x11\xCA\xFE\xBA\xBE\x00\x00\x00\x04\x01\x02\x03\x04")
-      end
-    end
-
-  end
-end
-

data/spec/streams/preidentified_stream_protocol_spec.rb

@@ -1,121 +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/streams/preidentified_stream_protocol'
-require 'cosmos/interfaces/interface'
-require 'cosmos/streams/stream'
-
-module Cosmos
-
-  class MyInterface < Interface; end
-
-  describe PreidentifiedStreamProtocol do
-    before(:each) do
-      @psp = PreidentifiedStreamProtocol.new
-    end
-
-    after(:all) do
-      clean_config()
-    end
-
-    it "handles receiving a bad packet length" do
-      @psp = PreidentifiedStreamProtocol.new(nil, 5)
-      pkt = System.telemetry.packet("COSMOS","VERSION")
-      class MyStream < Stream
-        def connect; end
-        def connected?; true; end
-        def read; $buffer; end
-        def write(data); $buffer = data; end
-      end
-      stream = MyStream.new
-      @psp.connect(stream)
-      time = Time.new(2020,1,31,12,15,30.5)
-      pkt.received_time = time
-      @psp.write(pkt)
-      expect { packet = @psp.read }.to raise_error(RuntimeError)
-    end
-
-    describe "initialize" do
-      it "initializes attributes" do
-        expect(@psp.bytes_read).to eql 0
-        expect(@psp.bytes_written).to eql 0
-        expect(@psp.interface).to be_nil
-        expect(@psp.stream).to be_nil
-        expect(@psp.post_read_data_callback).to be_nil
-        expect(@psp.post_read_packet_callback).to be_nil
-        expect(@psp.pre_write_packet_callback).to be_nil
-      end
-    end
-
-    describe "write" do
-      it "creates a packet header" do
-        pkt = System.telemetry.packet("COSMOS","VERSION")
-        class MyStream < Stream
-          def connect; end
-          def connected?; true; end
-          def read; $buffer; end
-          def write(data); $buffer = data; end
-        end
-        stream = MyStream.new
-        @psp.connect(stream)
-        time = Time.new(2020,1,31,12,15,30.5)
-        pkt.received_time = time
-        @psp.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 'COSMOS'
-        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 'VERSION'
-        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 "returns a packet" do
-        pkt = System.telemetry.packet("COSMOS","VERSION")
-        pkt.write("PKT_ID", 1)
-        pkt.write("COSMOS", "TEST")
-        class MyStream < Stream
-          def connect; end
-          def connected?; true; end
-          def read; $buffer; end
-          def write(data); $buffer = data; end
-        end
-        stream = MyStream.new
-        @psp.connect(stream)
-        time = Time.new(2020,1,31,12,15,30.5)
-        pkt.received_time = time
-        @psp.write(pkt)
-        packet = @psp.read
-        expect(packet.target_name).to eql 'COSMOS'
-        expect(packet.packet_name).to eql 'VERSION'
-        expect(packet.identified?).to be true
-        expect(packet.defined?).to be false
-
-        pkt2 = System.telemetry.update!("COSMOS","VERSION",packet.buffer)
-        expect(pkt2.read('PKT_ID')).to eql 1
-        expect(pkt2.read('COSMOS')).to eql 'TEST'
-        expect(pkt2.identified?).to be true
-        expect(pkt2.defined?).to be true
-      end
-    end
-
-  end
-end
-