cosmos 3.2.1 → 3.3.0

data/spec/interfaces/tcpip_server_interface_spec.rb

@@ -21,29 +21,29 @@ module Cosmos
     end
 
     describe "initialize" do
-      it "should initialize the instance variables" do
+      it "initializes the instance variables" do
         i = TcpipServerInterface.new('8888','8889','5','5','burst')
       end
 
-      it "should not be writeable if no write port given" do
+      it "is not 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
+        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
       end
 
-      it "should not be readable if no read port given" do
+      it "is not 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
+        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
       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
+      it "calls 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)
@@ -56,62 +56,62 @@ 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')
-        i.connected?.should be_falsey
+        expect(i.connected?).to be_falsey
         i.connect
-        i.connected?.should be_truthy
+        expect(i.connected?).to be_truthy
         i.disconnect
-        i.connected?.should be_falsey
+        expect(i.connected?).to 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
+        expect(i.bytes_read).to eql 10
+        expect(i.bytes_written).to eql 20
+        expect(i.num_clients).to eql 30
+        expect(i.read_queue_size).to eql 40
+        expect(i.write_queue_size).to eql 50
       end
     end
 
     describe "read" do
-      it "should count the packets received" do
+      it "counts 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
+        expect(i.read_count).to eql 0
         i.read
-        i.read_count.should eql 1
+        expect(i.read_count).to eql 1
         i.read
-        i.read_count.should eql 2
+        expect(i.read_count).to eql 2
       end
 
-      it "should not count nil packets" do
+      it "does 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
+        expect(i.read_count).to eql 0
         i.read
-        i.read_count.should eql 0
+        expect(i.read_count).to eql 0
         i.read
-        i.read_count.should eql 0
+        expect(i.read_count).to eql 0
       end
     end
 
     describe "write" do
-      it "should complain if the server is not connected" do
+      it "complains 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
+      it "counts 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
+        expect(i.write_count).to eql 0
         i.write(Packet.new('',''))
-        i.write_count.should eql 1
+        expect(i.write_count).to eql 1
         i.write(Packet.new('',''))
-        i.write_count.should eql 2
+        expect(i.write_count).to eql 2
       end
 
-      it "should handle server exceptions and disconnect" do
+      it "handles 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)
@@ -121,24 +121,24 @@ module Cosmos
     end
 
     describe "write_raw" do
-      it "should complain if the server is not connected" do
+      it "complains 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
+      it "counts 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
+        expect(i.write_count).to eql 0
         i.write_raw('')
-        i.write_count.should eql 1
+        expect(i.write_count).to eql 1
         i.write_raw('')
-        i.write_count.should eql 2
+        expect(i.write_count).to eql 2
       end
 
-      it "should handle server exceptions and disconnect" do
+      it "handles 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)
@@ -148,7 +148,7 @@ module Cosmos
     end
 
     describe "set_option" do
-      it "should set the listen address for the tcpip_server" do
+      it "sets the listen address for the tcpip_server" do
         expect(@stream).to receive(:listen_address=).with('127.0.0.1')
         i = TcpipServerInterface.new('8888','8889','5','5','burst')
         i.set_option('LISTEN_ADDRESS', ['127.0.0.1'])

data/spec/interfaces/udp_interface_spec.rb

@@ -15,29 +15,29 @@ module Cosmos
 
   describe UdpInterface do
     describe "initialize" do
-      it "should initialize the instance variables" do
+      it "initializes 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
+      it "is not 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
+        expect(i.name).to eql "Cosmos::UdpInterface"
+        expect(i.write_allowed?).to be_falsey
+        expect(i.write_raw_allowed?).to be_falsey
+        expect(i.read_allowed?).to be_truthy
       end
 
-      it "should not be readable if no read port given" do
+      it "is not 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
+        expect(i.name).to eql "Cosmos::UdpInterface"
+        expect(i.write_allowed?).to be_truthy
+        expect(i.write_raw_allowed?).to be_truthy
+        expect(i.read_allowed?).to be_falsey
       end
     end
 
     describe "connect, connected?, disconnect" do
-      it "should create a UdpWriteSocket and UdpReadSocket if both given" 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)
@@ -47,44 +47,44 @@ module Cosmos
         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
+        expect(i.connected?).to be_falsey
         i.connect
-        i.connected?.should be_truthy
+        expect(i.connected?).to be_truthy
         i.disconnect
-        i.connected?.should be_falsey
+        expect(i.connected?).to be_falsey
       end
 
-      it "should create a UdpWriteSocket if write port given" do
+      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')
-        i.connected?.should be_falsey
+        expect(i.connected?).to be_falsey
         i.connect
-        i.connected?.should be_truthy
+        expect(i.connected?).to be_truthy
         i.disconnect
-        i.connected?.should be_falsey
+        expect(i.connected?).to be_falsey
       end
 
-      it "should create a UdpReadSocket if read port given" do
+      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')
-        i.connected?.should be_falsey
+        expect(i.connected?).to be_falsey
         i.connect
-        i.connected?.should be_truthy
+        expect(i.connected?).to be_truthy
         i.disconnect
-        i.connected?.should be_falsey
+        expect(i.connected?).to be_falsey
       end
     end
 
     describe "disconnect" do
-      it "should rescue IOError from close" 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)
@@ -94,24 +94,24 @@ module Cosmos
         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
+        expect(i.connected?).to be_falsey
         i.connect
-        i.connected?.should be_truthy
+        expect(i.connected?).to be_truthy
         i.disconnect
-        i.connected?.should be_falsey
+        expect(i.connected?).to be_falsey
       end
     end
 
     describe "read" do
-      it "should stop the read thread if no read port given" do
+      it "stops 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
+        expect(thread.stop?).to be_truthy
         Cosmos.kill_thread(nil, thread)
       end
 
-      it "should stop the read thread if there is an IOError" do
+      it "stops 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)
@@ -119,55 +119,55 @@ module Cosmos
         i.connect
         thread = Thread.new { i.read }
         sleep 0.1
-        thread.stop?.should be_truthy
+        expect(thread.stop?).to be_truthy
         Cosmos.kill_thread(nil, thread)
       end
 
-      it "should count the packets received" do
+      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)
         i = UdpInterface.new('localhost','nil','8889')
         i.connect
-        i.read_count.should eql 0
-        i.bytes_read.should eql 0
+        expect(i.read_count).to eql 0
+        expect(i.bytes_read).to eql 0
         i.read
-        i.read_count.should eql 1
-        i.bytes_read.should eql 4
+        expect(i.read_count).to eql 1
+        expect(i.bytes_read).to eql 4
         i.read
-        i.read_count.should eql 2
-        i.bytes_read.should eql 8
+        expect(i.read_count).to eql 2
+        expect(i.bytes_read).to eql 8
       end
     end
 
     describe "write, write_raw" do
-      it "should complain if write_dest not given" 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/)
       end
 
-      it "should complain if the server is not connected" do
+      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 "should count the packets written" do
+      it "counts 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
+        expect(i.write_count).to 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
+        expect(i.write_count).to eql 1
+        expect(i.bytes_written).to eql 4
         i.write_raw(pkt.buffer)
-        i.write_count.should eql 2
-        i.bytes_written.should eql 8
+        expect(i.write_count).to eql 2
+        expect(i.bytes_written).to eql 8
       end
     end
   end

data/spec/io/buffered_file_spec.rb

@@ -28,82 +28,82 @@ module Cosmos
     end
 
     describe "read" do
-      it "should read less than the buffer size" do
+      it "reads less than the buffer size" do
         file = BufferedFile.open(@filename, "rb") do |file|
-          file.read(8).should eql DATA[0..7]
-          file.pos.should eql 8
-          file.read(4).should eql DATA[8..11]
-          file.pos.should eql 12
-          file.read(1).should eql DATA[12..12]
-          file.pos.should eql 13
-          file.read(3).should eql DATA[13..15]
-          file.pos.should eql 16
-          file.read(16).should eql DATA
-          file.pos.should eql 32
+          expect(file.read(8)).to eql DATA[0..7]
+          expect(file.pos).to eql 8
+          expect(file.read(4)).to eql DATA[8..11]
+          expect(file.pos).to eql 12
+          expect(file.read(1)).to eql DATA[12..12]
+          expect(file.pos).to eql 13
+          expect(file.read(3)).to eql DATA[13..15]
+          expect(file.pos).to eql 16
+          expect(file.read(16)).to eql DATA
+          expect(file.pos).to eql 32
           expected_pos = 32
           while (expected_pos < (2 * BufferedFile::BUFFER_SIZE))
-            file.read(16).should eql DATA
+            expect(file.read(16)).to eql DATA
             expected_pos += 16
-            file.pos.should eql expected_pos
+            expect(file.pos).to eql expected_pos
           end
-          file.read(1).should be_nil
+          expect(file.read(1)).to be_nil
         end
       end
 
-      it "should read equal to the buffer size" do
+      it "reads equal to the buffer size" do
         file = BufferedFile.open(@filename, "rb") do |file|
-          file.read(BufferedFile::BUFFER_SIZE).should eql(DATA * (BufferedFile::BUFFER_SIZE / DATA.length))
-          file.pos.should eql BufferedFile::BUFFER_SIZE
-          file.read(BufferedFile::BUFFER_SIZE).should eql(DATA * (BufferedFile::BUFFER_SIZE / DATA.length))
-          file.pos.should eql BufferedFile::BUFFER_SIZE * 2
-          file.read(BufferedFile::BUFFER_SIZE).should be_nil
+          expect(file.read(BufferedFile::BUFFER_SIZE)).to eql(DATA * (BufferedFile::BUFFER_SIZE / DATA.length))
+          expect(file.pos).to eql BufferedFile::BUFFER_SIZE
+          expect(file.read(BufferedFile::BUFFER_SIZE)).to eql(DATA * (BufferedFile::BUFFER_SIZE / DATA.length))
+          expect(file.pos).to eql BufferedFile::BUFFER_SIZE * 2
+          expect(file.read(BufferedFile::BUFFER_SIZE)).to be_nil
         end
       end
 
-      it "should read greater than the buffer size" do
+      it "reads greater than the buffer size" do
         file = BufferedFile.open(@filename, "rb") do |file|
-          file.read(BufferedFile::BUFFER_SIZE + 1).should eql(DATA * (BufferedFile::BUFFER_SIZE / DATA.length) << DATA[0..0])
-          file.pos.should eql BufferedFile::BUFFER_SIZE + 1
-          file.read(BufferedFile::BUFFER_SIZE + 1).should eql((DATA * (BufferedFile::BUFFER_SIZE / DATA.length))[1..-1])
-          file.pos.should eql BufferedFile::BUFFER_SIZE * 2
-          file.read(BufferedFile::BUFFER_SIZE + 1).should be_nil
+          expect(file.read(BufferedFile::BUFFER_SIZE + 1)).to eql(DATA * (BufferedFile::BUFFER_SIZE / DATA.length) << DATA[0..0])
+          expect(file.pos).to eql BufferedFile::BUFFER_SIZE + 1
+          expect(file.read(BufferedFile::BUFFER_SIZE + 1)).to eql((DATA * (BufferedFile::BUFFER_SIZE / DATA.length))[1..-1])
+          expect(file.pos).to eql BufferedFile::BUFFER_SIZE * 2
+          expect(file.read(BufferedFile::BUFFER_SIZE + 1)).to be_nil
         end
       end
     end
 
     describe "seek" do
-      it "should have reads still work afterwards" do
+      it "has reads still work afterwards" do
         file = BufferedFile.open(@filename, "rb") do |file|
-          file.read(8).should eql DATA[0..7]
-          file.pos.should eql 8
+          expect(file.read(8)).to eql DATA[0..7]
+          expect(file.pos).to eql 8
           file.seek(4, IO::SEEK_CUR)
-          file.pos.should eql 12
-          file.read(1).should eql DATA[12..12]
-          file.pos.should eql 13
-          file.read(3).should eql DATA[13..15]
-          file.pos.should eql 16
+          expect(file.pos).to eql 12
+          expect(file.read(1)).to eql DATA[12..12]
+          expect(file.pos).to eql 13
+          expect(file.read(3)).to eql DATA[13..15]
+          expect(file.pos).to eql 16
           file.seek(0, IO::SEEK_SET)
-          file.pos.should eql 0
-          file.read(8).should eql DATA[0..7]
-          file.pos.should eql 8
+          expect(file.pos).to eql 0
+          expect(file.read(8)).to eql DATA[0..7]
+          expect(file.pos).to eql 8
           file.seek(0, IO::SEEK_END)
-          file.pos.should eql (2 * BufferedFile::BUFFER_SIZE)
+          expect(file.pos).to eql (2 * BufferedFile::BUFFER_SIZE)
           file.seek(-16, IO::SEEK_END)
-          file.pos.should eql ((2 * BufferedFile::BUFFER_SIZE) - 16)
-          file.read(4).should eql DATA[0..3]
-          file.pos.should eql ((2 * BufferedFile::BUFFER_SIZE) - 12)
+          expect(file.pos).to eql ((2 * BufferedFile::BUFFER_SIZE) - 16)
+          expect(file.read(4)).to eql DATA[0..3]
+          expect(file.pos).to eql ((2 * BufferedFile::BUFFER_SIZE) - 12)
           file.seek(4, IO::SEEK_CUR)
-          file.pos.should eql ((2 * BufferedFile::BUFFER_SIZE) - 8)
+          expect(file.pos).to eql ((2 * BufferedFile::BUFFER_SIZE) - 8)
           file.seek(0, IO::SEEK_SET)
-          file.pos.should eql 0
-          file.read(8).should eql DATA[0..7]
-          file.pos.should eql 8
+          expect(file.pos).to eql 0
+          expect(file.read(8)).to eql DATA[0..7]
+          expect(file.pos).to eql 8
           file.seek(4, IO::SEEK_CUR)
-          file.pos.should eql 12
-          file.read(1).should eql DATA[12..12]
-          file.pos.should eql 13
-          file.read(3).should eql DATA[13..15]
-          file.pos.should eql 16
+          expect(file.pos).to eql 12
+          expect(file.read(1)).to eql DATA[12..12]
+          expect(file.pos).to eql 13
+          expect(file.read(3)).to eql DATA[13..15]
+          expect(file.pos).to eql 16
         end
       end
     end