cosmos 3.9.2 → 4.0.0

data/spec/interfaces/udp_interface_spec.rb

@@ -10,6 +10,7 @@
 
 require 'spec_helper'
 require 'cosmos/interfaces/udp_interface'
+require 'cosmos/io/udp_sockets'
 
 module Cosmos
 
@@ -21,7 +22,7 @@ module Cosmos
 
       it "is not writeable if no write port given" do
         i = UdpInterface.new('localhost','nil','8889')
-        expect(i.name).to eql "Cosmos::UdpInterface"
+        expect(i.name).to eql "UdpInterface"
         expect(i.write_allowed?).to be false
         expect(i.write_raw_allowed?).to be false
         expect(i.read_allowed?).to be true
@@ -29,7 +30,7 @@ module Cosmos
 
       it "is not readable if no read port given" do
         i = UdpInterface.new('localhost','8888','nil')
-        expect(i.name).to eql "Cosmos::UdpInterface"
+        expect(i.name).to eql "UdpInterface"
         expect(i.write_allowed?).to be true
         expect(i.write_raw_allowed?).to be true
         expect(i.read_allowed?).to be false
@@ -38,73 +39,49 @@ module Cosmos
 
     describe "connect, connected?, disconnect" do
       it "creates a UdpWriteSocket and UdpReadSocket if both given" do
-        write = double("write")
-        expect(write).to receive(:closed?).and_return(false)
-        expect(write).to receive(:close)
-        read = double("read")
-        expect(read).to receive(:closed?).and_return(false)
-        expect(read).to receive(:close)
-        expect(UdpWriteSocket).to receive(:new).and_return(write)
-        expect(UdpReadSocket).to receive(:new).and_return(read)
         i = UdpInterface.new('localhost','8888','8889')
         expect(i.connected?).to be false
         i.connect
         expect(i.connected?).to be true
+        expect(i.instance_variable_get(:@write_socket)).to_not be_nil
+        expect(i.instance_variable_get(:@read_socket)).to_not be_nil
         i.disconnect
         expect(i.connected?).to be false
+        expect(i.instance_variable_get(:@write_socket)).to be_nil
+        expect(i.instance_variable_get(:@read_socket)).to be_nil
       end
 
       it "creates a UdpWriteSocket if write port given" do
-        write = double("write")
-        expect(write).to receive(:closed?).and_return(false)
-        expect(write).to receive(:close)
-        expect(UdpWriteSocket).to receive(:new).and_return(write)
-        expect(UdpReadSocket).to_not receive(:new)
         i = UdpInterface.new('localhost','8888','nil')
         expect(i.connected?).to be false
         i.connect
         expect(i.connected?).to be true
+        expect(i.instance_variable_get(:@write_socket)).to_not be_nil
+        expect(i.instance_variable_get(:@read_socket)).to be_nil
         i.disconnect
         expect(i.connected?).to be false
+        expect(i.instance_variable_get(:@write_socket)).to be_nil
+        expect(i.instance_variable_get(:@read_socket)).to be_nil
       end
 
       it "creates a UdpReadSocket if read port given" do
-        read = double("read")
-        expect(read).to receive(:closed?).and_return(false)
-        expect(read).to receive(:close)
-        expect(UdpWriteSocket).to_not receive(:new)
-        expect(UdpReadSocket).to receive(:new).and_return(read)
         i = UdpInterface.new('localhost','nil','8889')
         expect(i.connected?).to be false
         i.connect
         expect(i.connected?).to be true
+        expect(i.instance_variable_get(:@write_socket)).to be_nil
+        expect(i.instance_variable_get(:@read_socket)).to_not be_nil
         i.disconnect
         expect(i.connected?).to be false
-      end
-    end
-
-    describe "disconnect" do
-      it "rescues IOError from close" do
-        write = double("write")
-        expect(write).to receive(:closed?).and_return(false)
-        expect(write).to receive(:close).and_raise(IOError)
-        read = double("read")
-        expect(read).to receive(:closed?).and_return(false)
-        expect(read).to receive(:close).and_raise(IOError)
-        expect(UdpWriteSocket).to receive(:new).and_return(write)
-        expect(UdpReadSocket).to receive(:new).and_return(read)
-        i = UdpInterface.new('localhost','8888','8889')
-        expect(i.connected?).to be false
-        i.connect
-        expect(i.connected?).to be true
-        i.disconnect
-        expect(i.connected?).to be false
+        expect(i.instance_variable_get(:@write_socket)).to be_nil
+        expect(i.instance_variable_get(:@read_socket)).to be_nil
       end
     end
 
     describe "read" do
       it "stops the read thread if no read port given" do
         i = UdpInterface.new('localhost','8888','nil')
+        i.connect
         thread = Thread.new { i.read }
         sleep 0.1
         expect(thread.stop?).to be true
@@ -124,50 +101,138 @@ module Cosmos
       end
 
       it "counts the packets received" do
-        read = double("read")
-        allow(read).to receive(:read) { "\x00\x01\x02\x03" }
-        expect(UdpReadSocket).to receive(:new).and_return(read)
+        write = UdpWriteSocket.new('localhost', 8889)
         i = UdpInterface.new('localhost','nil','8889')
         i.connect
         expect(i.read_count).to eql 0
         expect(i.bytes_read).to eql 0
-        i.read
+        packet = nil
+        t = Thread.new { packet = i.read }
+        write.write("\x00\x01\x02\x03")
+        t.join
         expect(i.read_count).to eql 1
         expect(i.bytes_read).to eql 4
-        i.read
+        expect(packet.buffer).to eql "\x00\x01\x02\x03"
+        t = Thread.new { packet = i.read }
+        write.write("\x04\x05\x06\x07")
+        t.join
         expect(i.read_count).to eql 2
         expect(i.bytes_read).to eql 8
+        expect(packet.buffer).to eql "\x04\x05\x06\x07"
+        i.disconnect
+        Cosmos.close_socket(write)
+      end
+
+      it "logs the raw data" do
+        write = UdpWriteSocket.new('localhost', 8889)
+        i = UdpInterface.new('localhost','nil','8889')
+        i.connect
+        expect(i.raw_logger_pair.read_logger.logging_enabled).to be false
+        i.start_raw_logging
+        expect(i.raw_logger_pair.read_logger.logging_enabled).to be true
+        packet = nil
+        t = Thread.new { packet = i.read }
+        write.write("\x00\x01\x02\x03")
+        t.join
+        filename = i.raw_logger_pair.read_logger.filename
+        i.stop_raw_logging
+        expect(i.raw_logger_pair.read_logger.logging_enabled).to be false
+        expect(File.read(filename)).to eq "\x00\x01\x02\x03"
+        i.disconnect
+        Cosmos.close_socket(write)
       end
     end
 
-    describe "write, write_raw" do
+    describe "write" do
       it "complains if write_dest not given" do
         i = UdpInterface.new('localhost','nil','8889')
-        expect { i.write(Packet.new('','')) }.to raise_error(/read only/)
-        expect { i.write_raw('') }.to raise_error(/read only/)
+        expect { i.write(Packet.new('','')) }.to raise_error(/not connected for write/)
       end
 
       it "complains if the server is not connected" do
         i = UdpInterface.new('localhost','8888','nil')
         expect { i.write(Packet.new('','')) }.to raise_error(/Interface not connected/)
-        expect { i.write_raw('') }.to raise_error(/Interface not connected/)
       end
 
-      it "counts the packets written" do
-        write = double("write")
-        expect(UdpWriteSocket).to receive(:new).and_return(write)
-        allow(write).to receive(:write)
+      it "counts the packets and bytes written" do
+        read = UdpReadSocket.new(8888, 'localhost')
         i = UdpInterface.new('localhost','8888','nil')
         i.connect
         expect(i.write_count).to eql 0
         pkt = Packet.new('tgt','pkt')
         pkt.buffer = "\x00\x01\x02\x03"
+        packet = nil
         i.write(pkt)
+        data = read.read
         expect(i.write_count).to eql 1
         expect(i.bytes_written).to eql 4
-        i.write_raw(pkt.buffer)
-        expect(i.write_count).to eql 2
-        expect(i.bytes_written).to eql 8
+        expect(data).to eq "\x00\x01\x02\x03"
+        i.disconnect
+        Cosmos.close_socket(read)
+      end
+
+      it "logs the raw data" do
+        read = UdpReadSocket.new(8888, 'localhost')
+        i = UdpInterface.new('localhost','8888','nil')
+        i.connect
+        expect(i.raw_logger_pair.write_logger.logging_enabled).to be false
+        i.start_raw_logging
+        expect(i.raw_logger_pair.write_logger.logging_enabled).to be true
+        pkt = Packet.new('tgt','pkt')
+        pkt.buffer = "\x00\x01\x02\x03"
+        packet = nil
+        i.write(pkt)
+        data = read.read
+        filename = i.raw_logger_pair.write_logger.filename
+        i.stop_raw_logging
+        expect(i.raw_logger_pair.write_logger.logging_enabled).to be false
+        expect(File.read(filename)).to eq "\x00\x01\x02\x03"
+        i.disconnect
+        Cosmos.close_socket(read)
+      end
+    end
+
+    describe "write_raw" do
+      it "complains if write_dest not given" do
+        i = UdpInterface.new('localhost','nil','8889')
+        expect { i.write_raw('') }.to raise_error(/not connected for write/)
+      end
+
+      it "complains if the server is not connected" do
+        i = UdpInterface.new('localhost','8888','nil')
+        expect { i.write_raw('') }.to raise_error(/Interface not connected/)
+      end
+
+      it "counts the bytes written" do
+        read = UdpReadSocket.new(8888, 'localhost')
+        i = UdpInterface.new('localhost','8888','nil')
+        i.connect
+        expect(i.write_count).to eql 0
+        expect(i.bytes_written).to eql 0
+        i.write_raw("\x04\x05\x06\x07")
+        data = read.read
+        expect(i.write_count).to eql 0
+        expect(i.bytes_written).to eql 4
+        expect(data).to eq "\x04\x05\x06\x07"
+        i.disconnect
+        Cosmos.close_socket(read)
+      end
+
+      it "logs the raw data" do
+        read = UdpReadSocket.new(8888, 'localhost')
+        i = UdpInterface.new('localhost','8888','nil')
+        i.connect
+        expect(i.raw_logger_pair.write_logger.logging_enabled).to be false
+        i.start_raw_logging
+        expect(i.raw_logger_pair.write_logger.logging_enabled).to be true
+        i.write_raw("\x00\x01\x02\x03")
+        data = read.read
+        filename = i.raw_logger_pair.write_logger.filename
+        i.stop_raw_logging
+        expect(i.raw_logger_pair.write_logger.logging_enabled).to be false
+        expect(File.read(filename)).to eq "\x00\x01\x02\x03"
+        i.disconnect
+        Cosmos.close_socket(read)
       end
     end
   end

data/spec/io/serial_driver_spec.rb

@@ -8,53 +8,55 @@
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
 
-require 'spec_helper'
-require 'cosmos/io/serial_driver'
-require 'cosmos/io/win32_serial_driver'
+if RUBY_ENGINE == 'ruby' or Gem.win_platform?
 
-module Cosmos
+  require 'spec_helper'
+  require 'cosmos/io/serial_driver'
+  require 'cosmos/io/win32_serial_driver'
 
-  describe SerialDriver do
+  module Cosmos
 
-    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 SerialDriver do
 
-    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
+      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
 
-      it "defers to the posix serial driver on nix" do
-        class PosixSerialDriver
+      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
-        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
-

data/spec/io/udp_sockets_spec.rb

@@ -21,11 +21,14 @@ module Cosmos
         expect(udp.peeraddr[2]).to eql '127.0.0.1'
         expect(udp.peeraddr[1]).to eql 8888
         udp.close
-        udp = UdpWriteSocket.new('224.0.1.1', 8888, 7777, '127.0.0.1', 3)
-        expect(udp.local_address.ip_port).to eql 7777
-        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
+        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
 
@@ -65,9 +68,11 @@ module Cosmos
         expect(udp.local_address.ip_address).to eql '0.0.0.0'
         expect(udp.local_address.ip_port).to eql 8888
         udp.close
-        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
+        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
 

data/spec/io/win32_serial_driver_spec.rb

@@ -8,81 +8,84 @@
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
 
-require 'spec_helper'
-require 'cosmos/io/win32_serial_driver'
+if RUBY_ENGINE == 'ruby' or Gem.win_platform?
 
-module Cosmos
+  require 'spec_helper'
+  require 'cosmos/io/win32_serial_driver'
 
-  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
+  module Cosmos
 
-    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")
+    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
 
-      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
+      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 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
+        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
 
-    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
+        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
-    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")
+      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
 
-      it "uses the write timeout" do
-        expect(Win32).to receive(:write_file) do
-          sleep 2
-          1
+      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
-        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'
+        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
 
-      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)
+      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
-end
 
+end