cosmos 3.0.1 → 3.1.0

data/spec/interfaces/tcpip_client_interface_spec.rb

@@ -1,54 +1,54 @@
-# 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/tcpip_client_interface'
-
-module Cosmos
-
-  describe TcpipClientInterface do
-
-    describe "initialize" do
-      it "should initialize the instance variables" do
-        i = TcpipClientInterface.new('localhost','8888','8889','5','5','burst')
-      end
-
-      it "should not be writeable if no write port given" do
-        i = TcpipClientInterface.new('localhost','nil','8889','nil','5','burst')
-        i.name.should eql "Cosmos::TcpipClientInterface"
-        i.write_allowed?.should be_falsey
-        i.write_raw_allowed?.should be_falsey
-        i.read_allowed?.should be_truthy
-      end
-
-      it "should not be readable if no read port given" do
-        i = TcpipClientInterface.new('localhost','8888','nil','5','nil','burst')
-        i.name.should eql "Cosmos::TcpipClientInterface"
-        i.write_allowed?.should be_truthy
-        i.write_raw_allowed?.should be_truthy
-        i.read_allowed?.should be_falsey
-      end
-    end
-
-    describe "connect" do
-      it "should pass a new TcpipClientStream to the stream protocol" do
-        stream = double("stream")
-        expect(TcpipClientStream).to receive(:new) { stream }
-        expect(stream).to receive(:connected?) { true }
-        expect(stream).to receive(:raw_logger_pair=) { nil }
-        i = TcpipClientInterface.new('localhost','8888','8889','5','5','burst')
-        i.connected?.should be_falsey
-        i.connect
-        i.connected?.should be_truthy
-      end
-    end
-  end
-end
-
+# 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/tcpip_client_interface'
+
+module Cosmos
+
+  describe TcpipClientInterface do
+
+    describe "initialize" do
+      it "should initialize the instance variables" do
+        i = TcpipClientInterface.new('localhost','8888','8889','5','5','burst')
+      end
+
+      it "should not be writeable if no write port given" do
+        i = TcpipClientInterface.new('localhost','nil','8889','nil','5','burst')
+        i.name.should eql "Cosmos::TcpipClientInterface"
+        i.write_allowed?.should be_falsey
+        i.write_raw_allowed?.should be_falsey
+        i.read_allowed?.should be_truthy
+      end
+
+      it "should not be readable if no read port given" do
+        i = TcpipClientInterface.new('localhost','8888','nil','5','nil','burst')
+        i.name.should eql "Cosmos::TcpipClientInterface"
+        i.write_allowed?.should be_truthy
+        i.write_raw_allowed?.should be_truthy
+        i.read_allowed?.should be_falsey
+      end
+    end
+
+    describe "connect" do
+      it "should pass a new TcpipClientStream to the stream protocol" do
+        stream = double("stream")
+        expect(TcpipClientStream).to receive(:new) { stream }
+        expect(stream).to receive(:connected?) { true }
+        expect(stream).to receive(:raw_logger_pair=) { nil }
+        i = TcpipClientInterface.new('localhost','8888','8889','5','5','burst')
+        i.connected?.should be_falsey
+        i.connect
+        i.connected?.should be_truthy
+      end
+    end
+  end
+end
+

data/spec/interfaces/tcpip_server_interface_spec.rb

@@ -1,151 +1,151 @@
-# 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/tcpip_server_interface'
-
-module Cosmos
-
-  describe TcpipServerInterface do
-    before(:each) do
-      @stream = double("stream")
-      expect(@stream).to receive(:interface=)
-      expect(TcpipServer).to receive(:new) { @stream }
-    end
-
-    describe "initialize" do
-      it "should initialize the instance variables" do
-        i = TcpipServerInterface.new('8888','8889','5','5','burst')
-      end
-
-      it "should not be writeable if no write port given" do
-        i = TcpipServerInterface.new('nil','8889','nil','5','burst')
-        i.name.should eql "Cosmos::TcpipServerInterface"
-        i.write_allowed?.should be_falsey
-        i.write_raw_allowed?.should be_falsey
-        i.read_allowed?.should be_truthy
-      end
-
-      it "should not be readable if no read port given" do
-        i = TcpipServerInterface.new('8888','nil','5','nil','burst')
-        i.name.should eql "Cosmos::TcpipServerInterface"
-        i.write_allowed?.should be_truthy
-        i.write_raw_allowed?.should be_truthy
-        i.read_allowed?.should be_falsey
-      end
-    end
-
-    describe "connect, connected?, disconnect, bytes_read, bytes_written, num_clients, read_queue_size, write_queue_size" do
-      it "should call forward to the TcpipServer" do
-        expect(@stream).to receive(:connected?).and_return(false, true, false)
-        expect(@stream).to receive(:connect)
-        expect(@stream).to receive(:disconnect)
-        expect(@stream).to receive(:bytes_read=)
-        expect(@stream).to receive(:bytes_written=)
-        expect(@stream).to receive(:bytes_read).and_return(10)
-        expect(@stream).to receive(:bytes_written).and_return(20)
-        expect(@stream).to receive(:num_clients).and_return(30)
-        expect(@stream).to receive(:read_queue_size).and_return(40)
-        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')
-        i.connected?.should be_falsey
-        i.connect
-        i.connected?.should be_truthy
-        i.disconnect
-        i.connected?.should be_falsey
-        i.bytes_read = 1000
-        i.bytes_written = 2000
-        i.bytes_read.should eql 10
-        i.bytes_written.should eql 20
-        i.num_clients.should eql 30
-        i.read_queue_size.should eql 40
-        i.write_queue_size.should eql 50
-      end
-    end
-
-    describe "read" do
-      it "should count the packets received" do
-        allow(@stream).to receive(:read) { Packet.new('','') }
-        i = TcpipServerInterface.new('8888','8889','5','5','burst')
-        i.read_count.should eql 0
-        i.read
-        i.read_count.should eql 1
-        i.read
-        i.read_count.should eql 2
-      end
-
-      it "should not count nil packets" do
-        allow(@stream).to receive(:read) { nil }
-        i = TcpipServerInterface.new('8888','8889','5','5','burst')
-        i.read_count.should eql 0
-        i.read
-        i.read_count.should eql 0
-        i.read
-        i.read_count.should eql 0
-      end
-    end
-
-    describe "write" do
-      it "should complain if the server is not connected" do
-        expect(@stream).to receive(:connected?).and_return(false)
-        i = TcpipServerInterface.new('8888','8889','5','5','burst')
-        expect { i.write(Packet.new('','')) }.to raise_error(/Interface not connected/)
-      end
-
-      it "should count the packets written" do
-        allow(@stream).to receive(:connected?).and_return(true)
-        allow(@stream).to receive(:write).with(kind_of(Packet))
-        i = TcpipServerInterface.new('8888','8889','5','5','burst')
-        i.write_count.should eql 0
-        i.write(Packet.new('',''))
-        i.write_count.should eql 1
-        i.write(Packet.new('',''))
-        i.write_count.should eql 2
-      end
-
-      it "should handle server exceptions and disconnect" do
-        allow(@stream).to receive(:connected?).and_return(true)
-        allow(@stream).to receive(:write).with(kind_of(Packet)).and_raise(RuntimeError.new("TEST"))
-        expect(@stream).to receive(:disconnect)
-        i = TcpipServerInterface.new('8888','8889','5','5','burst')
-        expect { i.write(Packet.new('','')) }.to raise_error("TEST")
-      end
-    end
-
-    describe "write_raw" do
-      it "should complain if the server is not connected" do
-        expect(@stream).to receive(:connected?).and_return(false)
-        i = TcpipServerInterface.new('8888','8889','5','5','burst')
-        expect { i.write_raw(Packet.new('','')) }.to raise_error(/Interface not connected/)
-      end
-
-      it "should count the packets written" do
-        allow(@stream).to receive(:connected?).and_return(true)
-        allow(@stream).to receive(:write_raw).with(kind_of(String))
-        i = TcpipServerInterface.new('8888','8889','5','5','burst')
-        i.write_count.should eql 0
-        i.write_raw('')
-        i.write_count.should eql 1
-        i.write_raw('')
-        i.write_count.should eql 2
-      end
-
-      it "should handle server exceptions and disconnect" do
-        allow(@stream).to receive(:connected?).and_return(true)
-        allow(@stream).to receive(:write_raw).with(kind_of(String)).and_raise(RuntimeError.new("TEST"))
-        expect(@stream).to receive(:disconnect)
-        i = TcpipServerInterface.new('8888','8889','5','5','burst')
-        expect { i.write_raw('') }.to raise_error("TEST")
-      end
-    end
-  end
-end
-
+# 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/tcpip_server_interface'
+
+module Cosmos
+
+  describe TcpipServerInterface do
+    before(:each) do
+      @stream = double("stream")
+      expect(@stream).to receive(:interface=)
+      expect(TcpipServer).to receive(:new) { @stream }
+    end
+
+    describe "initialize" do
+      it "should initialize the instance variables" do
+        i = TcpipServerInterface.new('8888','8889','5','5','burst')
+      end
+
+      it "should not be writeable if no write port given" do
+        i = TcpipServerInterface.new('nil','8889','nil','5','burst')
+        i.name.should eql "Cosmos::TcpipServerInterface"
+        i.write_allowed?.should be_falsey
+        i.write_raw_allowed?.should be_falsey
+        i.read_allowed?.should be_truthy
+      end
+
+      it "should not be readable if no read port given" do
+        i = TcpipServerInterface.new('8888','nil','5','nil','burst')
+        i.name.should eql "Cosmos::TcpipServerInterface"
+        i.write_allowed?.should be_truthy
+        i.write_raw_allowed?.should be_truthy
+        i.read_allowed?.should be_falsey
+      end
+    end
+
+    describe "connect, connected?, disconnect, bytes_read, bytes_written, num_clients, read_queue_size, write_queue_size" do
+      it "should call forward to the TcpipServer" do
+        expect(@stream).to receive(:connected?).and_return(false, true, false)
+        expect(@stream).to receive(:connect)
+        expect(@stream).to receive(:disconnect)
+        expect(@stream).to receive(:bytes_read=)
+        expect(@stream).to receive(:bytes_written=)
+        expect(@stream).to receive(:bytes_read).and_return(10)
+        expect(@stream).to receive(:bytes_written).and_return(20)
+        expect(@stream).to receive(:num_clients).and_return(30)
+        expect(@stream).to receive(:read_queue_size).and_return(40)
+        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')
+        i.connected?.should be_falsey
+        i.connect
+        i.connected?.should be_truthy
+        i.disconnect
+        i.connected?.should be_falsey
+        i.bytes_read = 1000
+        i.bytes_written = 2000
+        i.bytes_read.should eql 10
+        i.bytes_written.should eql 20
+        i.num_clients.should eql 30
+        i.read_queue_size.should eql 40
+        i.write_queue_size.should eql 50
+      end
+    end
+
+    describe "read" do
+      it "should count the packets received" do
+        allow(@stream).to receive(:read) { Packet.new('','') }
+        i = TcpipServerInterface.new('8888','8889','5','5','burst')
+        i.read_count.should eql 0
+        i.read
+        i.read_count.should eql 1
+        i.read
+        i.read_count.should eql 2
+      end
+
+      it "should not count nil packets" do
+        allow(@stream).to receive(:read) { nil }
+        i = TcpipServerInterface.new('8888','8889','5','5','burst')
+        i.read_count.should eql 0
+        i.read
+        i.read_count.should eql 0
+        i.read
+        i.read_count.should eql 0
+      end
+    end
+
+    describe "write" do
+      it "should complain if the server is not connected" do
+        expect(@stream).to receive(:connected?).and_return(false)
+        i = TcpipServerInterface.new('8888','8889','5','5','burst')
+        expect { i.write(Packet.new('','')) }.to raise_error(/Interface not connected/)
+      end
+
+      it "should count the packets written" do
+        allow(@stream).to receive(:connected?).and_return(true)
+        allow(@stream).to receive(:write).with(kind_of(Packet))
+        i = TcpipServerInterface.new('8888','8889','5','5','burst')
+        i.write_count.should eql 0
+        i.write(Packet.new('',''))
+        i.write_count.should eql 1
+        i.write(Packet.new('',''))
+        i.write_count.should eql 2
+      end
+
+      it "should handle server exceptions and disconnect" do
+        allow(@stream).to receive(:connected?).and_return(true)
+        allow(@stream).to receive(:write).with(kind_of(Packet)).and_raise(RuntimeError.new("TEST"))
+        expect(@stream).to receive(:disconnect)
+        i = TcpipServerInterface.new('8888','8889','5','5','burst')
+        expect { i.write(Packet.new('','')) }.to raise_error("TEST")
+      end
+    end
+
+    describe "write_raw" do
+      it "should complain if the server is not connected" do
+        expect(@stream).to receive(:connected?).and_return(false)
+        i = TcpipServerInterface.new('8888','8889','5','5','burst')
+        expect { i.write_raw(Packet.new('','')) }.to raise_error(/Interface not connected/)
+      end
+
+      it "should count the packets written" do
+        allow(@stream).to receive(:connected?).and_return(true)
+        allow(@stream).to receive(:write_raw).with(kind_of(String))
+        i = TcpipServerInterface.new('8888','8889','5','5','burst')
+        i.write_count.should eql 0
+        i.write_raw('')
+        i.write_count.should eql 1
+        i.write_raw('')
+        i.write_count.should eql 2
+      end
+
+      it "should handle server exceptions and disconnect" do
+        allow(@stream).to receive(:connected?).and_return(true)
+        allow(@stream).to receive(:write_raw).with(kind_of(String)).and_raise(RuntimeError.new("TEST"))
+        expect(@stream).to receive(:disconnect)
+        i = TcpipServerInterface.new('8888','8889','5','5','burst')
+        expect { i.write_raw('') }.to raise_error("TEST")
+      end
+    end
+  end
+end
+

data/spec/interfaces/udp_interface_spec.rb

@@ -1,177 +1,175 @@
-# 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/udp_interface'
-
-module Cosmos
-
-  describe UdpInterface do
-    describe "initialize" do
-      it "should initialize the instance variables" do
-        i = UdpInterface.new('localhost','8888','8889','8890','127.0.0.1','64','5','5')
-      end
-
-      it "should not be writeable if no write port given" do
-        i = UdpInterface.new('localhost','nil','8889')
-        i.name.should eql "Cosmos::UdpInterface"
-        i.write_allowed?.should be_falsey
-        i.write_raw_allowed?.should be_falsey
-        i.read_allowed?.should be_truthy
-      end
-
-      it "should not be readable if no read port given" do
-        i = UdpInterface.new('localhost','8888','nil')
-        i.name.should eql "Cosmos::UdpInterface"
-        i.write_allowed?.should be_truthy
-        i.write_raw_allowed?.should be_truthy
-        i.read_allowed?.should be_falsey
-      end
-    end
-
-    describe "connect, connected?, disconnect" do
-      it "should create 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')
-        i.connected?.should be_falsey
-        i.connect
-        i.connected?.should be_truthy
-        i.disconnect
-        i.connected?.should be_falsey
-      end
-
-      it "should create 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')
-        i.connected?.should be_falsey
-        i.connect
-        i.connected?.should be_truthy
-        i.disconnect
-        i.connected?.should be_falsey
-      end
-
-      it "should create 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')
-        i.connected?.should be_falsey
-        i.connect
-        i.connected?.should be_truthy
-        i.disconnect
-        i.connected?.should be_falsey
-      end
-    end
-
-    describe "disconnect" do
-      it "should rescue 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')
-        i.connected?.should be_falsey
-        i.connect
-        i.connected?.should be_truthy
-        i.disconnect
-        i.connected?.should be_falsey
-      end
-    end
-
-    describe "read" do
-      it "should stop the read thread if no read port given" do
-        i = UdpInterface.new('localhost','8888','nil')
-        thread = Thread.new { i.read }
-        sleep 0.1
-        thread.stop?.should be_truthy
-        thread.kill
-        thread.join
-      end
-
-      it "should stop the read thread if there is an IOError" do
-        read = double("read")
-        allow(read).to receive(:read).and_raise(IOError)
-        expect(UdpReadSocket).to receive(:new).and_return(read)
-        i = UdpInterface.new('localhost','nil','8889')
-        i.connect
-        thread = Thread.new { i.read }
-        sleep 0.1
-        thread.stop?.should be_truthy
-        thread.kill
-        thread.join
-      end
-
-      it "should count the packets received" do
-        read = double("read")
-        allow(read).to receive(:read) { "\x00\x01\x02\x03" }
-        expect(UdpReadSocket).to receive(:new).and_return(read)
-        i = UdpInterface.new('localhost','nil','8889')
-        i.connect
-        i.read_count.should eql 0
-        i.bytes_read.should eql 0
-        i.read
-        i.read_count.should eql 1
-        i.bytes_read.should eql 4
-        i.read
-        i.read_count.should eql 2
-        i.bytes_read.should eql 8
-      end
-    end
-
-    describe "write, write_raw" do
-      it "should complain 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/)
-      end
-
-      it "should complain 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 "should count the packets written" do
-        write = double("write")
-        expect(UdpWriteSocket).to receive(:new).and_return(write)
-        allow(write).to receive(:write)
-        i = UdpInterface.new('localhost','8888','nil')
-        i.connect
-        i.write_count.should eql 0
-        pkt = Packet.new('tgt','pkt')
-        pkt.buffer = "\x00\x01\x02\x03"
-        i.write(pkt)
-        i.write_count.should eql 1
-        i.bytes_written.should eql 4
-        i.write_raw(pkt.buffer)
-        i.write_count.should eql 2
-        i.bytes_written.should eql 8
-      end
-    end
-  end
-end
-
+# 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/udp_interface'
+
+module Cosmos
+
+  describe UdpInterface do
+    describe "initialize" do
+      it "should initialize the instance variables" do
+        i = UdpInterface.new('localhost','8888','8889','8890','127.0.0.1','64','5','5')
+      end
+
+      it "should not be writeable if no write port given" do
+        i = UdpInterface.new('localhost','nil','8889')
+        i.name.should eql "Cosmos::UdpInterface"
+        i.write_allowed?.should be_falsey
+        i.write_raw_allowed?.should be_falsey
+        i.read_allowed?.should be_truthy
+      end
+
+      it "should not be readable if no read port given" do
+        i = UdpInterface.new('localhost','8888','nil')
+        i.name.should eql "Cosmos::UdpInterface"
+        i.write_allowed?.should be_truthy
+        i.write_raw_allowed?.should be_truthy
+        i.read_allowed?.should be_falsey
+      end
+    end
+
+    describe "connect, connected?, disconnect" do
+      it "should create 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')
+        i.connected?.should be_falsey
+        i.connect
+        i.connected?.should be_truthy
+        i.disconnect
+        i.connected?.should be_falsey
+      end
+
+      it "should create 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')
+        i.connected?.should be_falsey
+        i.connect
+        i.connected?.should be_truthy
+        i.disconnect
+        i.connected?.should be_falsey
+      end
+
+      it "should create 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')
+        i.connected?.should be_falsey
+        i.connect
+        i.connected?.should be_truthy
+        i.disconnect
+        i.connected?.should be_falsey
+      end
+    end
+
+    describe "disconnect" do
+      it "should rescue 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')
+        i.connected?.should be_falsey
+        i.connect
+        i.connected?.should be_truthy
+        i.disconnect
+        i.connected?.should be_falsey
+      end
+    end
+
+    describe "read" do
+      it "should stop the read thread if no read port given" do
+        i = UdpInterface.new('localhost','8888','nil')
+        thread = Thread.new { i.read }
+        sleep 0.1
+        thread.stop?.should be_truthy
+        Cosmos.kill_thread(nil, thread)
+      end
+
+      it "should stop the read thread if there is an IOError" do
+        read = double("read")
+        allow(read).to receive(:read).and_raise(IOError)
+        expect(UdpReadSocket).to receive(:new).and_return(read)
+        i = UdpInterface.new('localhost','nil','8889')
+        i.connect
+        thread = Thread.new { i.read }
+        sleep 0.1
+        thread.stop?.should be_truthy
+        Cosmos.kill_thread(nil, thread)
+      end
+
+      it "should count the packets received" do
+        read = double("read")
+        allow(read).to receive(:read) { "\x00\x01\x02\x03" }
+        expect(UdpReadSocket).to receive(:new).and_return(read)
+        i = UdpInterface.new('localhost','nil','8889')
+        i.connect
+        i.read_count.should eql 0
+        i.bytes_read.should eql 0
+        i.read
+        i.read_count.should eql 1
+        i.bytes_read.should eql 4
+        i.read
+        i.read_count.should eql 2
+        i.bytes_read.should eql 8
+      end
+    end
+
+    describe "write, write_raw" do
+      it "should complain 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/)
+      end
+
+      it "should complain 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 "should count the packets written" do
+        write = double("write")
+        expect(UdpWriteSocket).to receive(:new).and_return(write)
+        allow(write).to receive(:write)
+        i = UdpInterface.new('localhost','8888','nil')
+        i.connect
+        i.write_count.should eql 0
+        pkt = Packet.new('tgt','pkt')
+        pkt.buffer = "\x00\x01\x02\x03"
+        i.write(pkt)
+        i.write_count.should eql 1
+        i.bytes_written.should eql 4
+        i.write_raw(pkt.buffer)
+        i.write_count.should eql 2
+        i.bytes_written.should eql 8
+      end
+    end
+  end
+end
+