cosmos 4.0.3-java

data/spec/io/raw_logger_pair_spec.rb

@@ -0,0 +1,76 @@
+# 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/io/raw_logger_pair'
+
+module Cosmos
+
+  describe RawLoggerPair do
+
+    describe "initialize" do
+      it "sets the write logger and read logger" do
+        pair = RawLoggerPair.new('MYINT')
+        expect(pair.read_logger).not_to be_nil
+        expect(pair.write_logger).not_to be_nil
+        expect(pair.read_logger.logging_enabled).to be false
+        expect(pair.write_logger.logging_enabled).to be false
+
+        pair = RawLoggerPair.new('MYINT2', ['raw_logger.rb', true, 100000, './'])
+        expect(pair.read_logger).not_to be_nil
+        expect(pair.write_logger).not_to be_nil
+        expect(pair.read_logger.logging_enabled).to be true
+        expect(pair.write_logger.logging_enabled).to be true
+      end
+    end
+
+    describe "start" do
+      it "starts logging" do
+        pair = RawLoggerPair.new('MYINT')
+        pair.start
+        expect(pair.write_logger.logging_enabled).to be true
+        expect(pair.read_logger.logging_enabled).to be true
+      end
+    end
+
+    describe "stop" do
+      it "stops logging" do
+        pair = RawLoggerPair.new('MYINT')
+        pair.start
+        expect(pair.write_logger.logging_enabled).to be true
+        expect(pair.read_logger.logging_enabled).to be true
+        pair.stop
+        expect(pair.write_logger.logging_enabled).to be false
+        expect(pair.read_logger.logging_enabled).to be false
+      end
+    end
+
+    describe "clone" do
+      it "clones itself including logging state" do
+        pair = RawLoggerPair.new('MYINT')
+        expect(pair.write_logger.logging_enabled).to be false
+        expect(pair.read_logger.logging_enabled).to be false
+        pair_clone1 = pair.clone
+        pair.start
+        expect(pair.write_logger.logging_enabled).to be true
+        expect(pair.read_logger.logging_enabled).to be true
+        expect(pair_clone1.write_logger.logging_enabled).to be false
+        expect(pair_clone1.read_logger.logging_enabled).to be false
+        pair_clone2 = pair.clone
+        expect(pair_clone1.write_logger.logging_enabled).to be false
+        expect(pair_clone1.read_logger.logging_enabled).to be false
+        expect(pair_clone2.write_logger.logging_enabled).to be true
+        expect(pair_clone2.read_logger.logging_enabled).to be true
+      end
+    end
+
+  end
+end
+

data/spec/io/raw_logger_spec.rb

@@ -0,0 +1,137 @@
+# 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/io/raw_logger'
+
+module Cosmos
+
+  describe RawLogger do
+    before(:each) do
+      @log_path = System.paths['LOGS']
+    end
+
+    after(:each) do
+      clean_config()
+    end
+
+    describe "initialize" do
+      it "complains with not enough arguments" do
+        expect { RawLogger.new('MYINT') }.to raise_error(ArgumentError)
+      end
+
+      it "complains with an unknown log type" do
+        expect { RawLogger.new('MYINT', :BOTH) }.to raise_error(/log_type must be :READ or :WRITE/)
+      end
+
+      it "creates a raw write log" do
+        raw_logger = RawLogger.new('MYINT', :WRITE, true, 100000, nil)
+        raw_logger.write("\x00\x01\x02\0x3")
+        raw_logger.stop
+        expect(Dir[File.join(@log_path,"*.bin")][-1]).to match("myint_raw_write")
+      end
+
+      it "creates a raw read log" do
+        raw_logger = RawLogger.new('MYINT', :READ, true, 100000, nil)
+        raw_logger.write("\x00\x01\x02\0x3")
+        raw_logger.stop
+        expect(Dir[File.join(@log_path,"*.bin")][-1]).to match("myint_raw_read")
+      end
+
+      it "uses the log directory" do
+        raw_logger = RawLogger.new('raw_logger_spec_', :READ, true, 100000, Cosmos::USERPATH)
+        raw_logger.write("\x00\x01\x02\0x3")
+        raw_logger.stop
+        expect(Dir[File.join(Cosmos::USERPATH,"*raw_logger_spec_*")][-1]).to match("raw_logger_spec_")
+        Dir[File.join(Cosmos::USERPATH,"*raw_logger_spec_*")].each do |file|
+          File.delete file
+        end
+      end
+    end
+
+    describe "write" do
+      it "writes synchronously to a log" do
+        raw_logger = RawLogger.new('MYINT', :WRITE, true, 100000, nil)
+        raw_logger.write("\x00\x01\x02\x03")
+        raw_logger.stop
+        data = nil
+        File.open(Dir[File.join(@log_path,"*.bin")][-1],'rb') do |file|
+          data = file.read
+        end
+        expect(data).to eql "\x00\x01\x02\x03"
+      end
+
+      it "does not write data if logging is disabled" do
+        raw_logger = RawLogger.new('MYINT', :WRITE, false, 100000, nil)
+        raw_logger.write("\x00\x01\x02\x03")
+        expect(Dir[File.join(@log_path,"*.bin")]).to be_empty
+      end
+
+      it "cycles the log when it a size" do
+        raw_logger = RawLogger.new('MYINT', :WRITE, true, 200000, nil)
+        raw_logger.write("\x00\x01\x02\x03" * 25000) # size 100000
+        raw_logger.write("\x00\x01\x02\x03" * 25000) # size 200000
+        expect(Dir[File.join(@log_path,"*.bin")].length).to eql 1
+        sleep(2)
+        raw_logger.write("\x00") # size 200001
+        raw_logger.stop
+        files = Dir[File.join(@log_path,"*.bin")]
+        expect(files.length).to eql 2
+      end
+
+      it "handles errors creating the log file" do
+        capture_io do |stdout|
+          allow(File).to receive(:new) { raise "Error" }
+          raw_logger = RawLogger.new('MYINT', :WRITE, true, 200, nil)
+          raw_logger.write("\x00\x01\x02\x03")
+          raw_logger.stop
+          expect(stdout.string).to match "Error opening"
+        end
+      end
+
+      it "handles errors closing the log file" do
+        capture_io do |stdout|
+          allow(File).to receive(:chmod) { raise "Error" }
+          raw_logger = RawLogger.new('MYINT', :WRITE, true, 200, nil)
+          raw_logger.write("\x00\x01\x02\x03")
+          raw_logger.stop
+          expect(stdout.string).to match "Error closing"
+        end
+      end
+
+      it "handles errors writing the log file" do
+        capture_io do |stdout|
+          raw_logger = RawLogger.new('MYINT', :WRITE, true, 200, nil)
+          raw_logger.write("\x00\x01\x02\x03")
+          allow(raw_logger.instance_variable_get(:@file)).to receive(:write) { raise "Error" }
+          raw_logger.write("\x00\x01\x02\x03")
+          raw_logger.stop
+          expect(stdout.string).to match "Error writing"
+        end
+      end
+    end
+
+    describe "start and stop" do
+      it "enables and disable logging" do
+        raw_logger = RawLogger.new('MYINT', :WRITE, false, 200, nil)
+        expect(raw_logger.logging_enabled).to be false
+        raw_logger.start
+        expect(raw_logger.logging_enabled).to be true
+        raw_logger.write("\x00\x01\x02\x03")
+        raw_logger.stop
+        expect(raw_logger.logging_enabled).to be false
+        file = Dir[File.join(@log_path,"*.bin")][-1]
+        expect(File.size(file)).not_to eql 0
+      end
+    end
+
+  end
+end
+

data/spec/io/serial_driver_spec.rb

@@ -0,0 +1,62 @@
+# 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
+
+if RUBY_ENGINE == 'ruby' or Gem.win_platform?
+
+  require 'spec_helper'
+  require 'cosmos/io/serial_driver'
+  require 'cosmos/io/win32_serial_driver'
+
+  module Cosmos
+
+    describe SerialDriver do
+
+      describe "instance" do
+        it "enforces the parity to a known value" do
+          expect { SerialDriver.new('COM1',9600,:BLAH) }.to raise_error(ArgumentError, "Invalid parity: BLAH")
+        end
+      end
+
+      describe "close, closed?, write, read" do
+        it "defers to the windows serial driver on windows" do
+          allow(Kernel).to receive(:is_windows?).and_return(true)
+          driver = double("Win32SerialDriver")
+          expect(driver).to receive(:close)
+          expect(driver).to receive(:closed?)
+          expect(driver).to receive(:write)
+          expect(driver).to receive(:read)
+          allow(Win32SerialDriver).to receive(:new).and_return(driver)
+          driver = SerialDriver.new('COM1',9600)
+          driver.close
+          driver.closed?
+          driver.write("hi")
+          driver.read
+        end
+
+        it "defers to the posix serial driver on nix" do
+          class PosixSerialDriver
+          end
+          allow(Kernel).to receive(:is_windows?).and_return(false)
+          driver = double("PosixSerialDriver")
+          expect(driver).to receive(:close)
+          expect(driver).to receive(:closed?)
+          expect(driver).to receive(:write)
+          expect(driver).to receive(:read)
+          allow(PosixSerialDriver).to receive(:new).and_return(driver)
+          driver = SerialDriver.new('COM1',9600)
+          driver.close
+          driver.closed?
+          driver.write("hi")
+          driver.read
+        end
+      end
+    end
+  end
+end

data/spec/io/stderr_spec.rb

@@ -0,0 +1,32 @@
+# 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/io/stderr'
+
+module Cosmos
+
+  describe Stderr do
+
+    describe "instance" do
+      it "returns a single instance" do
+        expect(Stderr.instance).to eq(Stderr.instance)
+      end
+    end
+
+    describe "puts" do
+      it "writes to STDERR" do
+        expect($stderr).to receive(:puts).with("TEST")
+        Stderr.instance.puts("TEST")
+      end
+    end
+  end
+end
+

data/spec/io/stdout_spec.rb

@@ -0,0 +1,32 @@
+# 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/io/stdout'
+
+module Cosmos
+
+  describe Stdout do
+
+    describe "instance" do
+      it "returns a single instance" do
+        expect(Stdout.instance).to eq(Stdout.instance)
+      end
+    end
+
+    describe "puts" do
+      it "writes to STDOUT" do
+        expect($stdout).to receive(:puts).with("TEST")
+        Stdout.instance.puts("TEST")
+      end
+    end
+  end
+end
+

data/spec/io/udp_sockets_spec.rb

@@ -0,0 +1,99 @@
+# 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/io/udp_sockets'
+
+module Cosmos
+
+  describe UdpWriteSocket do
+
+    describe "initialize" do
+      it "creates a socket" do
+        udp = UdpWriteSocket.new('127.0.0.1', 8888)
+        expect(udp.peeraddr[2]).to eql '127.0.0.1'
+        expect(udp.peeraddr[1]).to eql 8888
+        udp.close
+        if RUBY_ENGINE == 'ruby' # UDP multicast does not work in Jruby
+          udp = UdpWriteSocket.new('224.0.1.1', 8888, 7777, '127.0.0.1', 3)
+          expect(udp.local_address.ip_port).to eql 7777
+          # Reading this back doesn't appear to work in JRUBY, not sure if it is actually taking
+          expect(udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL).int).to eql 3
+          expect(IPAddr.new_ntoh(udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF).data).to_s).to eql "127.0.0.1"
+          udp.close
+        end
+      end
+    end
+
+    describe "write" do
+      it "writes data" do
+        udp_read  = UdpReadSocket.new(8888)
+        udp_write = UdpWriteSocket.new('127.0.0.1', 8888)
+        udp_write.write("\x01\x02",2.0)
+        expect(udp_read.read).to eql "\x01\x02"
+        udp_read.close
+        udp_write.close
+      end
+
+      it "handles timeouts" do
+        allow_any_instance_of(UDPSocket).to receive(:write_nonblock) { raise Errno::EWOULDBLOCK }
+        expect(IO).to receive(:select).at_least(:once).and_return([], nil)
+        udp_write = UdpWriteSocket.new('127.0.0.1', 8888)
+        expect { udp_write.write("\x01\x02",2.0) }.to raise_error(Timeout::Error)
+        udp_write.close
+      end
+    end
+
+    describe "multicast" do
+      it "determines if a host is multicast" do
+        expect(UdpWriteSocket.multicast?('127.0.0.1')).to be false
+        expect(UdpWriteSocket.multicast?('224.0.1.1')).to be true
+      end
+    end
+
+  end
+
+  describe UdpReadSocket do
+
+    describe "initialize" do
+      it "creates a socket" do
+        udp = UdpReadSocket.new(8888)
+        expect(udp.local_address.ip_address).to eql '0.0.0.0'
+        expect(udp.local_address.ip_port).to eql 8888
+        udp.close
+        if RUBY_ENGINE == 'ruby' # UDP multicast does not work in Jruby
+          udp = UdpReadSocket.new(8888, '224.0.1.1')
+          expect(IPAddr.new_ntoh(udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF).data).to_s).to eql "0.0.0.0"
+          udp.close
+        end
+      end
+    end
+
+    describe "read" do
+      it "reads data" do
+        udp_read  = UdpReadSocket.new(8888)
+        udp_write = UdpWriteSocket.new('127.0.0.1', 8888)
+        udp_write.write("\x01\x02",2.0)
+        expect(udp_read.read).to eql "\x01\x02"
+        udp_read.close
+        udp_write.close
+      end
+
+      it "handles timeouts" do
+        allow_any_instance_of(UDPSocket).to receive(:recvfrom_nonblock) { raise Errno::EWOULDBLOCK }
+        expect(IO).to receive(:select).at_least(:once).and_return([], nil)
+        udp_read = UdpReadSocket.new(8889)
+        expect { udp_read.read(2.0) }.to raise_error(Timeout::Error)
+      end
+    end
+
+  end
+end
+

data/spec/io/win32_serial_driver_spec.rb

@@ -0,0 +1,91 @@
+# 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
+
+if RUBY_ENGINE == 'ruby' or Gem.win_platform?
+
+  require 'spec_helper'
+  require 'cosmos/io/win32_serial_driver'
+
+  module Cosmos
+
+    describe Win32SerialDriver do
+      before(:each) do
+        allow(Win32).to receive(:create_file).and_return(Object.new)
+        state = double("comm_state")
+        allow(state).to receive(:write)
+        allow(Win32).to receive(:get_comm_state).and_return(state)
+        allow(Win32).to receive(:set_comm_state)
+        allow(Win32).to receive(:set_comm_timeouts)
+      end
+
+      describe "instance" do
+        it "enforces the baud rate to a known value" do
+          expect { Win32SerialDriver.new('COM1',10,:NONE) }.to raise_error(ArgumentError, "Invalid baud rate: 10")
+        end
+
+        it "supports even, odd, or no parity" do
+          expect { Win32SerialDriver.new('COM1',9600,:EVEN) }.to_not raise_error
+          expect { Win32SerialDriver.new('COM1',9600,:ODD) }.to_not raise_error
+          expect { Win32SerialDriver.new('COM1',9600,:NONE) }.to_not raise_error
+          expect { Win32SerialDriver.new('COM1',9600,:BLAH) }.to raise_error(ArgumentError, "Invalid parity: BLAH")
+        end
+
+        it "supports 1 or 2 stop bits" do
+          expect { Win32SerialDriver.new('COM1',9600,:NONE,1) }.to_not raise_error
+          expect { Win32SerialDriver.new('COM1',9600,:NONE,2) }.to_not raise_error
+          expect { Win32SerialDriver.new('COM1',9600,:NONE,3) }.to raise_error(ArgumentError, "Invalid stop bits: 3")
+        end
+      end
+
+      describe "close, closed?" do
+        it "closes the handle" do
+          expect(Win32).to receive(:close_handle)
+          driver = Win32SerialDriver.new('COM1',9600)
+          expect(driver.closed?).to be false
+          driver.close
+          expect(driver.closed?).to be true
+        end
+      end
+
+      describe "write" do
+        it "handles write errors" do
+          expect(Win32).to receive(:write_file).and_return 0
+          driver = Win32SerialDriver.new('COM1',9600)
+          expect { driver.write('\x00') }.to raise_error("Error writing to comm port")
+        end
+
+        it "uses the write timeout" do
+          expect(Win32).to receive(:write_file) do
+            sleep 2
+            1
+          end
+          driver = Win32SerialDriver.new('COM1',9600,:NONE,1,1)
+          expect { driver.write('\x00\x01') }.to raise_error(Timeout::Error)
+        end
+      end
+
+      describe "read" do
+        it "return the data read" do
+          expect(Win32).to receive(:read_file) { '\x00' }
+          driver = Win32SerialDriver.new('COM1',9600,:NONE,1,1,nil,0.01,1)
+          expect(driver.read).to eql '\x00'
+        end
+
+        it "uses the read timeout" do
+          allow(Win32).to receive(:read_file) { '' }
+          driver = Win32SerialDriver.new('COM1',9600,:NONE,1,1,1.0,0.5,10)
+          expect { driver.read }.to raise_error(Timeout::Error)
+        end
+      end
+
+    end
+  end
+
+end