cosmos 3.3.3 → 3.4.0

data/spec/gui/qt_spec.rb

@@ -0,0 +1,102 @@
+# 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/gui/qt'
+
+module Cosmos
+
+  describe Qt do
+    describe "Cosmos.getColor" do
+      it "returns a Qt::Color when given a Qt::Color" do
+        expect(Cosmos.getColor(Qt::Color.new('red'))).to be_instance_of(Qt::Color)
+      end
+
+      it "returns a Qt::Pen when given a Qt::Pen" do
+        expect(Cosmos.getColor(Qt::Pen.new)).to be_instance_of(Qt::Pen)
+      end
+
+      it "returns a Qt::LinearGradient when given a Qt::LinearGradient" do
+        expect(Cosmos.getColor(Qt::LinearGradient.new)).to be_instance_of(Qt::LinearGradient)
+      end
+
+      context "when given a string" do
+        it "processes 'white'" do
+          expect(Cosmos.getColor('white')).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor('white').rgb()).to eql 0xFFFFFFFF
+        end
+        it "processes 'black'" do
+          expect(Cosmos.getColor('black')).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor('black').rgb()).to eql 0xFF000000
+        end
+        it "processes 'red'" do
+          expect(Cosmos.getColor('red')).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor('red').rgb()).to eql 0xFFFF0000
+        end
+        it "processes 'lime'" do
+          expect(Cosmos.getColor('lime')).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor('lime').rgb()).to eql 0xFF00FF00
+        end
+        it "processes 'blue'" do
+          expect(Cosmos.getColor('blue')).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor('blue').rgb()).to eql 0xFF0000FF
+        end
+      end
+
+      context "when given a Qt::Enum" do
+        it "processes Qt::white" do
+          expect(Cosmos.getColor(Qt::white)).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor(Qt::white).rgb()).to eql 0xFFFFFFFF
+        end
+        it "processes Qt::black" do
+          expect(Cosmos.getColor(Qt::black)).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor(Qt::black).rgb()).to eql 0xFF000000
+        end
+        it "processes Qt::red" do
+          expect(Cosmos.getColor(Qt::red)).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor(Qt::red).rgb()).to eql 0xFFFF0000
+        end
+        it "processes Qt::green" do
+          expect(Cosmos.getColor(Qt::green)).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor(Qt::green).rgb()).to eql 0xFF00FF00
+        end
+        it "processes Qt::blue" do
+          expect(Cosmos.getColor(Qt::blue)).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor(Qt::blue).rgb()).to eql 0xFF0000FF
+        end
+      end
+
+      context "when given rgb values" do
+        it "processes FF,FF,FF" do
+          expect(Cosmos.getColor(0xFF,0xFF,0xFF)).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor(0xFF,0xFF,0xFF).rgb()).to eql 0xFFFFFFFF
+        end
+        it "processes 00,00,00 " do
+          expect(Cosmos.getColor(0,0,0)).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor(0,0,0).rgb()).to eql 0xFF000000
+        end
+        it "processes FF,00,00" do
+          expect(Cosmos.getColor(0xFF,0,0)).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor(0xFF,0,0).rgb()).to eql 0xFFFF0000
+        end
+        it "processes 00,FF,00" do
+          expect(Cosmos.getColor(0,0xFF,0)).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor(0,0xFF,0).rgb()).to eql 0xFF00FF00
+        end
+        it "processes 00,00,FF" do
+          expect(Cosmos.getColor(0,0,0xFF)).to be_instance_of(Qt::Color)
+          expect(Cosmos.getColor(0,0,0xFF).rgb()).to eql 0xFF0000FF
+        end
+      end
+
+    end
+  end
+
+end # module Cosmos

data/spec/interfaces/interface_spec.rb

@@ -27,10 +27,10 @@ module Cosmos
         expect(i.name).to eql "Cosmos::Interface"
         expect(i.target_names).to eql []
         expect(i.thread).to be_nil
-        expect(i.connect_on_startup).to be_truthy
-        expect(i.auto_reconnect).to be_truthy
+        expect(i.connect_on_startup).to be true
+        expect(i.auto_reconnect).to be true
         expect(i.reconnect_delay).to eql 5.0
-        expect(i.disable_disconnect).to be_falsey
+        expect(i.disable_disconnect).to be false
         expect(i.packet_log_writer_pairs).to eql []
         expect(i.routers).to eql []
         expect(i.read_count).to eql 0
@@ -58,19 +58,19 @@ module Cosmos
 
     describe "read_allowed?" do
       it "is true" do
-        expect(Interface.new.read_allowed?).to be_truthy
+        expect(Interface.new.read_allowed?).to be true
       end
     end
 
     describe "write_allowed?" do
       it "is true" do
-        expect(Interface.new.write_allowed?).to be_truthy
+        expect(Interface.new.write_allowed?).to be true
       end
     end
 
     describe "write_raw_allowed?" do
       it "is true" do
-        expect(Interface.new.write_raw_allowed?).to be_truthy
+        expect(Interface.new.write_raw_allowed?).to be true
       end
     end
 
@@ -100,10 +100,10 @@ module Cosmos
         expect(i2.name).to eql 'TEST'
         expect(i2.target_names).to eql ['TGT1','TGT2']
         expect(i2.thread).to be_nil # Thread does not get copied
-        expect(i2.connect_on_startup).to be_falsey
-        expect(i2.auto_reconnect).to be_falsey
+        expect(i2.connect_on_startup).to be false
+        expect(i2.auto_reconnect).to be false
         expect(i2.reconnect_delay).to eql 1.0
-        expect(i2.disable_disconnect).to be_truthy
+        expect(i2.disable_disconnect).to be true
         expect(i2.packet_log_writer_pairs).to eql [1,2]
         expect(i2.routers).to eql [3,4]
         expect(i2.read_count).to eql 1

data/spec/interfaces/linc_interface_spec.rb

@@ -28,25 +28,25 @@ module Cosmos
         expect(stream).to receive(:raw_logger_pair=) { nil }
         i = LincInterface.new('localhost','8888')
         i.target_names << "INST"
-        expect(i.connected?).to be_falsey
+        expect(i.connected?).to be false
         i.connect
-        expect(i.connected?).to be_truthy
+        expect(i.connected?).to be true
       end
     end
 
     describe "write" do
       before(:each) do
-        stream = double("stream")
-        allow(stream).to receive(:connect)
-        expect(TcpipClientStream).to receive(:new) { stream }
-        allow(stream).to receive(:connected?) { true }
-        allow(stream).to receive(:write)
-        expect(stream).to receive(:raw_logger_pair=) { nil }
+        @stream = double("stream")
+        allow(@stream).to receive(:connect)
+        expect(TcpipClientStream).to receive(:new) { @stream }
+        allow(@stream).to receive(:connected?) { true }
+        allow(@stream).to receive(:write)
+        expect(@stream).to receive(:raw_logger_pair=) { nil }
         @i = LincInterface.new('localhost','8888','true','2','nil','5','0','16','4','GSE_HDR_GUID','BIG_ENDIAN','GSE_HDR_LEN')
         @i.target_names << "INST"
-        expect(@i.connected?).to be_falsey
+        expect(@i.connected?).to be false
         @i.connect
-        expect(@i.connected?).to be_truthy
+        expect(@i.connected?).to be true
       end
 
       it "returns an exception if its not connected" do
@@ -79,11 +79,11 @@ module Cosmos
         disable.restore_defaults
 
         @i.write(enable)
-        expect(@i.instance_variable_get(:@handshake_enabled)).to be_truthy
+        expect(@i.instance_variable_get(:@handshake_enabled)).to be true
         @i.write(disable)
-        expect(@i.instance_variable_get(:@handshake_enabled)).to be_falsey
+        expect(@i.instance_variable_get(:@handshake_enabled)).to be false
         @i.write(enable)
-        expect(@i.instance_variable_get(:@handshake_enabled)).to be_truthy
+        expect(@i.instance_variable_get(:@handshake_enabled)).to be true
       end
 
       it "timeouts waiting for handshake" do
@@ -107,6 +107,7 @@ module Cosmos
           @cmd = System.commands.packet("INST","LINC_COMMAND")
           @cmd.restore_defaults
           @cmd.write("GSE_HDR_GUID",0xDEADBEEF)
+          @cmd.write("DATA",1)
           @handshake = System.telemetry.packet("INST","HANDSHAKE")
           @handshake.write("GSE_HDR_ID", 1001)
           @handshake.write("STATUS","OK")
@@ -134,6 +135,62 @@ module Cosmos
           t.join
         end
 
+        it "handles two simultaneous writes" do
+          cmd2 = @cmd.clone
+          cmd2.write("GSE_HDR_GUID",0xBA5EBA11)
+          cmd2.write("DATA",2)
+          handshake2 = @handshake.clone
+          handshake2.write("GSE_HDR_ID", 1001)
+          buffer = ''
+          buffer << ["INST".length].pack("C")
+          buffer << "INST"
+          buffer << ["LINC_COMMAND".length].pack("C")
+          buffer << "LINC_COMMAND"
+          buffer << [cmd2.buffer.length].pack("N")
+          buffer << cmd2.buffer
+          buffer << [3].pack("N")
+          buffer << "BAD"
+          handshake2.write("DATA", buffer)
+
+          read_cnt = 0
+          write_cnt = 0
+          allow_any_instance_of(LengthStreamProtocol).to receive(:read) do
+            read_cnt += 1
+            result = nil
+            result = handshake2 if read_cnt == 1
+            result = @handshake if read_cnt == 2
+            result
+          end
+
+          # Create new thread for each write
+          t1 = Thread.new do
+            expect(@stream).to receive(:write) do
+              write_cnt += 1
+            end
+            @i.write(cmd2)
+          end
+          # Create new thread for each write
+          t2 = Thread.new do
+            expect(@stream).to receive(:write) do
+              write_cnt += 1
+            end
+            @i.write(@cmd)
+          end
+
+          sleep 0.5
+          # Expect both write threads have written
+          expect(write_cnt).to eql 2
+          # But no handshakes have been received
+          expect(read_cnt).to eql 0
+
+          # Now read the handshakes and allow the reads to complete
+          @i.read
+          @i.read
+          t1.join
+          t2.join
+          expect(read_cnt).to eql 2
+        end
+
         it "warns if an error code is set" do
           expect(Logger).to receive(:warn) do |msg|
             expect(msg).to eql "Warning sending command (12345): BAD"
@@ -168,9 +225,9 @@ module Cosmos
         expect(stream).to receive(:raw_logger_pair=) { nil }
         @i = LincInterface.new('localhost','8888','true','2','nil','5','0','16','4','GSE_HDR_GUID','BIG_ENDIAN','GSE_HDR_LEN')
         @i.target_names << "INST"
-        expect(@i.connected?).to be_falsey
+        expect(@i.connected?).to be false
         @i.connect
-        expect(@i.connected?).to be_truthy
+        expect(@i.connected?).to be true
       end
 
       it "handles local commands" do

data/spec/interfaces/serial_interface_spec.rb

@@ -24,17 +24,17 @@ module Cosmos
       it "is not writeable if no write port given" do
         i = SerialInterface.new('nil','COM1','9600','NONE','1','0','0','burst')
         expect(i.name).to eql "Cosmos::SerialInterface"
-        expect(i.write_allowed?).to be_falsey
-        expect(i.write_raw_allowed?).to be_falsey
-        expect(i.read_allowed?).to be_truthy
+        expect(i.write_allowed?).to be false
+        expect(i.write_raw_allowed?).to be false
+        expect(i.read_allowed?).to be true
       end
 
       it "is not readable if no read port given" do
         i = SerialInterface.new('COM1','nil','9600','NONE','1','0','0','burst')
         expect(i.name).to eql "Cosmos::SerialInterface"
-        expect(i.write_allowed?).to be_truthy
-        expect(i.write_raw_allowed?).to be_truthy
-        expect(i.read_allowed?).to be_falsey
+        expect(i.write_allowed?).to be true
+        expect(i.write_raw_allowed?).to be true
+        expect(i.read_allowed?).to be false
       end
     end
 
@@ -43,11 +43,11 @@ module Cosmos
         # Ensure the 'NONE' parity is coverted to a symbol
         if Kernel.is_windows?
           i = SerialInterface.new('COM1','COM1','9600','NONE','1','0','0','burst')
-          expect(i.connected?).to be_falsey
+          expect(i.connected?).to be false
           i.connect
-          expect(i.connected?).to be_truthy
+          expect(i.connected?).to be true
           i.disconnect
-          expect(i.connected?).to be_falsey
+          expect(i.connected?).to be false
         end
       end
     end

data/spec/interfaces/simulated_target_interface_spec.rb

@@ -66,9 +66,9 @@ end
       it "initiallies be false" do
         sti = SimulatedTargetInterface.new("test_inst.rb")
         sti.target_names = ['COSMOS']
-        expect(sti.connected?).to be_falsey
+        expect(sti.connected?).to be false
         sti.connect
-        expect(sti.connected?).to be_truthy
+        expect(sti.connected?).to be true
       end
     end
 
@@ -80,7 +80,7 @@ end
       it "returns a simulated packet" do
         sti = SimulatedTargetInterface.new("test_inst.rb")
         sti.target_names = ['COSMOS']
-        expect(sti.connected?).to be_falsey
+        expect(sti.connected?).to be false
         sti.connect
         pkt = sti.read
         expect(pkt.target_name).to eql "COSMOS"
@@ -99,7 +99,7 @@ end
       it "writes commands to the simulator" do
         sti = SimulatedTargetInterface.new("test_inst.rb")
         sti.target_names = ['COSMOS']
-        expect(sti.connected?).to be_falsey
+        expect(sti.connected?).to be false
         sti.connect
         sti.write(Packet.new("COSMOS","SETLOGLABEL"))
       end
@@ -115,11 +115,11 @@ end
       it "disconnects from the simulator" do
         sti = SimulatedTargetInterface.new("test_inst.rb")
         sti.target_names = ['COSMOS']
-        expect(sti.connected?).to be_falsey
+        expect(sti.connected?).to be false
         sti.connect
-        expect(sti.connected?).to be_truthy
+        expect(sti.connected?).to be true
         sti.disconnect
-        expect(sti.connected?).to be_falsey
+        expect(sti.connected?).to be false
       end
     end
 

data/spec/interfaces/stream_interface_spec.rb

@@ -112,24 +112,24 @@ module Cosmos
         # Ensure we reload since TestStreamProtocol is used throughout
         load @file
 
-        expect($disconnect).to be_falsey
+        expect($disconnect).to be false
         si = StreamInterface.new("test")
         begin
           si.write(nil)
         rescue
         end
         expect(si.write_count).to eql 0
-        expect($disconnect).to be_truthy
+        expect($disconnect).to be true
 
         $disconnect = false
-        expect($disconnect).to be_falsey
+        expect($disconnect).to be false
         si = StreamInterface.new("test")
         begin
           si.write_raw(nil)
         rescue
         end
         expect(si.write_count).to eql 0
-        expect($disconnect).to be_truthy
+        expect($disconnect).to be true
       end
 
       it "writes to the stream interface and count the packet" do

data/spec/interfaces/tcpip_client_interface_spec.rb

@@ -23,17 +23,17 @@ module Cosmos
       it "is not writeable if no write port given" do
         i = TcpipClientInterface.new('localhost','nil','8889','nil','5','burst')
         expect(i.name).to eql "Cosmos::TcpipClientInterface"
-        expect(i.write_allowed?).to be_falsey
-        expect(i.write_raw_allowed?).to be_falsey
-        expect(i.read_allowed?).to be_truthy
+        expect(i.write_allowed?).to be false
+        expect(i.write_raw_allowed?).to be false
+        expect(i.read_allowed?).to be true
       end
 
       it "is not readable if no read port given" do
         i = TcpipClientInterface.new('localhost','8888','nil','5','nil','burst')
         expect(i.name).to eql "Cosmos::TcpipClientInterface"
-        expect(i.write_allowed?).to be_truthy
-        expect(i.write_raw_allowed?).to be_truthy
-        expect(i.read_allowed?).to be_falsey
+        expect(i.write_allowed?).to be true
+        expect(i.write_raw_allowed?).to be true
+        expect(i.read_allowed?).to be false
       end
     end
 
@@ -45,9 +45,9 @@ module Cosmos
         expect(stream).to receive(:connected?) { true }
         expect(stream).to receive(:raw_logger_pair=) { nil }
         i = TcpipClientInterface.new('localhost','8888','8889','5','5','burst')
-        expect(i.connected?).to be_falsey
+        expect(i.connected?).to be false
         i.connect
-        expect(i.connected?).to be_truthy
+        expect(i.connected?).to be true
       end
     end
   end

data/spec/interfaces/tcpip_server_interface_spec.rb

@@ -28,17 +28,17 @@ module Cosmos
       it "is not writeable if no write port given" do
         i = TcpipServerInterface.new('nil','8889','nil','5','burst')
         expect(i.name).to eql "Cosmos::TcpipServerInterface"
-        expect(i.write_allowed?).to be_falsey
-        expect(i.write_raw_allowed?).to be_falsey
-        expect(i.read_allowed?).to be_truthy
+        expect(i.write_allowed?).to be false
+        expect(i.write_raw_allowed?).to be false
+        expect(i.read_allowed?).to be true
       end
 
       it "is not readable if no read port given" do
         i = TcpipServerInterface.new('8888','nil','5','nil','burst')
         expect(i.name).to eql "Cosmos::TcpipServerInterface"
-        expect(i.write_allowed?).to be_truthy
-        expect(i.write_raw_allowed?).to be_truthy
-        expect(i.read_allowed?).to be_falsey
+        expect(i.write_allowed?).to be true
+        expect(i.write_raw_allowed?).to be true
+        expect(i.read_allowed?).to be false
       end
     end
 
@@ -56,11 +56,11 @@ module Cosmos
         expect(@stream).to receive(:write_queue_size).and_return(50)
         expect(@stream).to receive(:raw_logger_pair=) { nil }
         i = TcpipServerInterface.new('8888','8889','5','5','burst')
-        expect(i.connected?).to be_falsey
+        expect(i.connected?).to be false
         i.connect
-        expect(i.connected?).to be_truthy
+        expect(i.connected?).to be true
         i.disconnect
-        expect(i.connected?).to be_falsey
+        expect(i.connected?).to be false
         i.bytes_read = 1000
         i.bytes_written = 2000
         expect(i.bytes_read).to eql 10