nio4r 2.5.8 → 2.7.4

data/spec/nio/acceptables_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "NIO acceptables" do
-  shared_context "an NIO acceptable" do
-    let(:selector) { NIO::Selector.new }
-
-    it "selects for read readiness" do
-      waiting_monitor = selector.register(unacceptable_subject, :r)
-      ready_monitor   = selector.register(acceptable_subject, :r)
-
-      ready_monitors = selector.select
-      expect(ready_monitors).to include ready_monitor
-      expect(ready_monitors).not_to include waiting_monitor
-    end
-  end
-
-  describe TCPServer do
-    let :acceptable_subject do
-      server = TCPServer.new("127.0.0.1", 0)
-      TCPSocket.open("127.0.0.1", server.local_address.ip_port)
-      server
-    end
-
-    let :unacceptable_subject do
-      TCPServer.new("127.0.0.1", 0)
-    end
-
-    it_behaves_like "an NIO acceptable"
-  end
-end

data/spec/nio/bytebuffer_spec.rb

@@ -1,354 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe NIO::ByteBuffer do
-  let(:capacity)       { 256 }
-  let(:example_string) { "Testing 1 2 3..." }
-  subject(:bytebuffer) { described_class.new(capacity) }
-
-  describe "#initialize" do
-    it "raises TypeError if given a bogus argument" do
-      expect { described_class.new(:symbols_are_bogus) }.to raise_error(TypeError)
-    end
-  end
-
-  describe "#clear" do
-    it "clears the buffer" do
-      bytebuffer << example_string
-      bytebuffer.clear
-
-      expect(bytebuffer.remaining).to eq capacity
-    end
-  end
-
-  describe "#position" do
-    it "defaults to zero" do
-      expect(bytebuffer.position).to be_zero
-    end
-  end
-
-  describe "#position=" do
-    let(:example_position) { 42 }
-
-    it "sets the buffer's position to a valid value" do
-      expect(bytebuffer.position).to be_zero
-      bytebuffer.position = example_position
-      expect(bytebuffer.position).to eq example_position
-    end
-
-    it "raises ArgumentError if the specified position is less than zero" do
-      expect { bytebuffer.position = -1 }.to raise_error(ArgumentError)
-    end
-
-    it "raises ArgumentError if the specified position exceeds the limit" do
-      expect { bytebuffer.position = capacity + 1 }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#limit" do
-    it "defaults to the buffer's capacity" do
-      expect(bytebuffer.limit).to eq capacity
-    end
-  end
-
-  describe "#limit=" do
-    it "sets the buffer's limit to a valid value" do
-      bytebuffer.flip
-      expect(bytebuffer.limit).to be_zero
-
-      new_limit = capacity / 2
-      bytebuffer.limit = new_limit
-      expect(bytebuffer.limit).to eq new_limit
-    end
-
-    it "preserves position and mark if they're less than the new limit" do
-      bytebuffer << "four"
-      bytebuffer.mark
-      bytebuffer << "more"
-
-      bytebuffer.limit = capacity / 2
-      expect(bytebuffer.position).to eq 8
-      bytebuffer.reset
-      expect(bytebuffer.position).to eq 4
-    end
-
-    it "sets position to the new limit if the previous position is beyond the limit" do
-      bytebuffer << "four"
-      bytebuffer.limit = 2
-      expect(bytebuffer.position).to eq 2
-    end
-
-    it "clears the mark if the new limit is before the current mark" do
-      bytebuffer << "four"
-      bytebuffer.mark
-      bytebuffer.limit = 2
-      expect { bytebuffer.reset }.to raise_error(NIO::ByteBuffer::MarkUnsetError)
-    end
-
-    it "raises ArgumentError if specified limit is less than zero" do
-      expect { bytebuffer.limit = -1 }.to raise_error(ArgumentError)
-    end
-
-    it "raises ArgumentError if specified limit exceeds capacity" do
-      expect { bytebuffer.limit = capacity }.not_to raise_error
-      expect { bytebuffer.limit = capacity + 1 }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#capacity" do
-    it "has the requested capacity" do
-      expect(bytebuffer.capacity).to eq capacity
-    end
-  end
-
-  describe "#remaining" do
-    it "calculates the number of bytes remaining" do
-      expect(bytebuffer.remaining).to eq capacity
-      bytebuffer << example_string
-      expect(bytebuffer.remaining).to eq(capacity - example_string.length)
-    end
-  end
-
-  describe "#full?" do
-    it "returns false when there is space remaining in the buffer" do
-      expect(bytebuffer).not_to be_full
-    end
-
-    it "returns true when the buffer is full" do
-      bytebuffer << "X" * capacity
-      expect(bytebuffer).to be_full
-    end
-  end
-
-  describe "#get" do
-    it "reads all remaining data if no length is given" do
-      bytebuffer << example_string
-      bytebuffer.flip
-
-      expect(bytebuffer.get).to eq example_string
-    end
-
-    it "reads zeroes from a newly initialized buffer" do
-      expect(bytebuffer.get(capacity)).to eq("\0" * capacity)
-    end
-
-    it "advances position as data is read" do
-      bytebuffer << "First"
-      bytebuffer << "Second"
-      bytebuffer << "Third"
-      bytebuffer.flip
-
-      expect(bytebuffer.position).to be_zero
-      expect(bytebuffer.get(10)).to eq "FirstSecon"
-      expect(bytebuffer.position).to eq 10
-    end
-
-    it "raises NIO::ByteBuffer::UnderflowError if there is not enough data in the buffer" do
-      bytebuffer << example_string
-      bytebuffer.flip
-
-      expect { bytebuffer.get(example_string.length + 1) }.to raise_error(NIO::ByteBuffer::UnderflowError)
-      expect(bytebuffer.get(example_string.length)).to eq example_string
-    end
-  end
-
-  describe "#[]" do
-    it "obtains bytes at a given index without altering position" do
-      bytebuffer << example_string
-      expect(bytebuffer[7]).to eq example_string.bytes[7]
-      expect(bytebuffer.position).to eq example_string.length
-    end
-
-    it "raises ArgumentError if the index is less than zero" do
-      expect { bytebuffer[-1] }.to raise_error(ArgumentError)
-    end
-
-    it "raises ArgumentError if the index exceeds the limit" do
-      bytebuffer << example_string
-      bytebuffer.flip
-      expect(bytebuffer[bytebuffer.limit - 1]).to eq example_string.bytes.last
-      expect { bytebuffer[bytebuffer.limit] }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#<<" do
-    it "adds strings to the buffer" do
-      bytebuffer << example_string
-      expect(bytebuffer.position).to eq example_string.length
-      expect(bytebuffer.limit).to eq capacity
-    end
-
-    it "raises TypeError if given a non-String type" do
-      expect { bytebuffer << 42 }.to raise_error(TypeError)
-      expect { bytebuffer << nil }.to raise_error(TypeError)
-    end
-
-    it "raises NIO::ByteBuffer::OverflowError if the buffer is full" do
-      bytebuffer << "X" * (capacity - 1)
-      expect { bytebuffer << "X" }.not_to raise_error
-      expect { bytebuffer << "X" }.to raise_error(NIO::ByteBuffer::OverflowError)
-    end
-  end
-
-  describe "#flip" do
-    it "flips the bytebuffer" do
-      bytebuffer << example_string
-      expect(bytebuffer.position).to eql example_string.length
-
-      expect(bytebuffer.flip).to eq bytebuffer
-
-      expect(bytebuffer.position).to be_zero
-      expect(bytebuffer.limit).to eq example_string.length
-      expect(bytebuffer.get).to eq example_string
-    end
-
-    it "sets remaining to the previous position" do
-      bytebuffer << example_string
-      previous_position = bytebuffer.position
-      expect(bytebuffer.remaining).to eq(capacity - previous_position)
-      expect(bytebuffer.flip.remaining).to eq previous_position
-    end
-
-    it "sets limit to the previous position" do
-      bytebuffer << example_string
-      expect(bytebuffer.limit).to eql(capacity)
-
-      previous_position = bytebuffer.position
-      expect(bytebuffer.flip.limit).to eql previous_position
-    end
-  end
-
-  describe "#rewind" do
-    it "rewinds the buffer leaving the limit intact" do
-      bytebuffer << example_string
-      expect(bytebuffer.rewind).to eq bytebuffer
-
-      expect(bytebuffer.position).to be_zero
-      expect(bytebuffer.limit).to eq capacity
-    end
-  end
-
-  describe "#mark" do
-    it "returns self" do
-      expect(bytebuffer.mark).to eql bytebuffer
-    end
-  end
-
-  describe "#reset" do
-    it "returns to a previously marked position" do
-      bytebuffer << "First"
-      expected_position = bytebuffer.position
-
-      expect(bytebuffer.mark).to eq bytebuffer
-      bytebuffer << "Second"
-      expect(bytebuffer.position).not_to eq expected_position
-      expect(bytebuffer.reset.position).to eq expected_position
-    end
-
-    it "raises NIO::ByteBuffer::MarkUnsetError unless mark has been set" do
-      expect { bytebuffer.reset }.to raise_error(NIO::ByteBuffer::MarkUnsetError)
-    end
-  end
-
-  describe "#compact" do
-    let(:first_string)  { "CompactMe" }
-    let(:second_string) { "Leftover" }
-
-    it "copies data from the current position to the beginning of the buffer" do
-      bytebuffer << first_string << second_string
-      bytebuffer.position = first_string.length
-      bytebuffer.limit = first_string.length + second_string.length
-      bytebuffer.compact
-
-      expect(bytebuffer.position).to eq second_string.length
-      expect(bytebuffer.limit).to eq capacity
-      expect(bytebuffer.flip.get).to eq second_string
-    end
-  end
-
-  describe "#each" do
-    it "iterates over data in the buffer" do
-      bytebuffer << example_string
-      bytebuffer.flip
-
-      bytes = []
-      bytebuffer.each { |byte| bytes << byte }
-      expect(bytes).to eq example_string.bytes
-    end
-  end
-
-  describe "#inspect" do
-    it "inspects the buffer offsets" do
-      regex = /\A#<NIO::ByteBuffer:.*? @position=0 @limit=#{capacity} @capacity=#{capacity}>\z/
-      expect(bytebuffer.inspect).to match(regex)
-    end
-  end
-
-  context "I/O" do
-    let(:addr)   { "127.0.0.1" }
-    let(:server) { TCPServer.new(addr, 0) }
-    let(:port)   { server.local_address.ip_port }
-    let(:client) { TCPSocket.new(addr, port) }
-    let(:peer)   { server_thread.value }
-
-    let(:server_thread) do
-      server
-
-      thread = Thread.new { server.accept }
-      Thread.pass while thread.status && thread.status != "sleep"
-
-      thread
-    end
-
-    before do
-      server_thread
-      client
-    end
-
-    after do
-      server_thread.kill if server_thread.alive?
-
-      server.close rescue nil
-      client.close rescue nil
-      peer.close rescue nil
-    end
-
-    describe "#read_from" do
-      it "reads data into the buffer" do
-        client.write(example_string)
-        expect(bytebuffer.read_from(peer)).to eq example_string.length
-        bytebuffer.flip
-
-        expect(bytebuffer.get).to eq example_string
-      end
-
-      it "raises NIO::ByteBuffer::OverflowError if the buffer is already full" do
-        client.write(example_string)
-        bytebuffer << "X" * capacity
-        expect { bytebuffer.read_from(peer) }.to raise_error(NIO::ByteBuffer::OverflowError)
-      end
-
-      it "returns 0 if no data is available" do
-        expect(bytebuffer.read_from(peer)).to eq 0
-      end
-    end
-
-    describe "#write_to" do
-      it "writes data from the buffer" do
-        bytebuffer << example_string
-        bytebuffer.flip
-
-        expect(bytebuffer.write_to(client)).to eq example_string.length
-        client.close
-
-        expect(peer.read(example_string.length)).to eq example_string
-      end
-
-      it "raises NIO::ByteBuffer::UnderflowError if the buffer is out of data" do
-        bytebuffer.flip
-        expect { bytebuffer.write_to(peer) }.to raise_error(NIO::ByteBuffer::UnderflowError)
-      end
-    end
-  end
-end

data/spec/nio/monitor_spec.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "socket"
-
-RSpec.describe NIO::Monitor do
-  let(:addr) { "127.0.0.1" }
-
-  let(:reader) { TCPServer.new(addr, 0) }
-  let(:port) { reader.local_address.ip_port }
-  let(:writer) { TCPSocket.new(addr, port) }
-
-  let(:selector) { NIO::Selector.new }
-
-  subject(:monitor) { selector.register(writer, :rw) }
-  subject(:peer)    { selector.register(reader, :r) }
-
-  before { reader }
-  before { writer }
-  after  { reader.close }
-  after  { writer.close }
-  after  { selector.close }
-
-  describe "#interests" do
-    it "knows its interests" do
-      expect(peer.interests).to eq(:r)
-      expect(monitor.interests).to eq(:rw)
-    end
-  end
-
-  describe "#interests=" do
-    it "can set interests to nil" do
-      expect(monitor.interests).not_to eq(nil)
-      monitor.interests = nil
-      expect(monitor.interests).to eq(nil)
-    end
-
-    it "changes the interest set" do
-      expect(monitor.interests).not_to eq(:w)
-      monitor.interests = :w
-      expect(monitor.interests).to eq(:w)
-    end
-
-    it "raises EOFError if interests are changed after the monitor is closed" do
-      monitor.close
-      expect { monitor.interests = :rw }.to raise_error(EOFError)
-    end
-  end
-
-  describe "#add_interest" do
-    it "sets a new interest if it isn't currently registered" do
-      monitor.interests = :r
-      expect(monitor.interests).to eq(:r)
-
-      expect(monitor.add_interest(:w)).to eq(:rw)
-      expect(monitor.interests).to eq(:rw)
-    end
-
-    it "acts idempotently" do
-      monitor.interests = :r
-      expect(monitor.interests).to eq(:r)
-
-      expect(monitor.add_interest(:r)).to eq(:r)
-      expect(monitor.interests).to eq(:r)
-    end
-
-    it "raises ArgumentError if given a bogus option" do
-      expect { monitor.add_interest(:derp) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#remove_interest" do
-    it "removes an interest from the set" do
-      expect(monitor.interests).to eq(:rw)
-
-      expect(monitor.remove_interest(:r)).to eq(:w)
-      expect(monitor.interests).to eq(:w)
-    end
-
-    it "can clear the last interest" do
-      monitor.interests = :w
-      expect(monitor.interests).to eq(:w)
-
-      expect(monitor.remove_interest(:w)).to be_nil
-      expect(monitor.interests).to be_nil
-    end
-
-    it "acts idempotently" do
-      monitor.interests = :w
-      expect(monitor.interests).to eq(:w)
-
-      expect(monitor.remove_interest(:r)).to eq(:w)
-      expect(monitor.interests).to eq(:w)
-    end
-
-    it "raises ArgumentError if given a bogus option" do
-      expect { monitor.add_interest(:derp) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#io" do
-    it "knows its IO object" do
-      expect(monitor.io).to eq(writer)
-    end
-  end
-
-  describe "#selector" do
-    it "knows its selector" do
-      expect(monitor.selector).to eq(selector)
-    end
-  end
-
-  describe "#value=" do
-    it "stores arbitrary values" do
-      monitor.value = 42
-      expect(monitor.value).to eq(42)
-    end
-  end
-
-  describe "#readiness" do
-    it "knows what operations IO objects are ready for" do
-      # For whatever odd reason this breaks unless we eagerly evaluate monitor
-      reader_peer = peer
-      writer_peer = monitor
-
-      selected = selector.select(0)
-      expect(selected).to include(writer_peer)
-
-      expect(writer_peer.readiness).to eq(:w)
-      expect(writer_peer).not_to be_readable
-      expect(writer_peer).to be_writable
-
-      writer << "testing 1 2 3"
-
-      selected = selector.select(0)
-      expect(selected).to include(reader_peer)
-
-      expect(reader_peer.readiness).to eq(:r)
-      expect(reader_peer).to be_readable
-      expect(reader_peer).not_to be_writable
-    end
-  end
-
-  describe "#close" do
-    it "closes" do
-      expect(monitor).not_to be_closed
-      expect(selector.registered?(writer)).to be_truthy
-
-      monitor.close
-      expect(monitor).to be_closed
-      expect(selector.registered?(writer)).to be_falsey
-    end
-
-    it "closes even if the selector has been shutdown" do
-      expect(monitor).not_to be_closed
-      selector.close # forces shutdown
-      expect(monitor).not_to be_closed
-      monitor.close
-      expect(monitor).to be_closed
-    end
-  end
-end

data/spec/nio/selectables/pipe_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "IO.pipe" do
-  let(:pair) { IO.pipe }
-
-  let :unreadable_subject do
-    pair.first
-  end
-
-  let :readable_subject do
-    pipe, peer = pair
-    peer << "data"
-    pipe
-  end
-
-  let :writable_subject do
-    pair.last
-  end
-
-  let :unwritable_subject do
-    _reader, pipe = pair
-
-    # HACK: On OS X 10.8, this str must be larger than PIPE_BUF. Otherwise,
-    #      the write is atomic and select() will return writable but write()
-    #      will throw EAGAIN if there is too little space to write the string
-    # TODO: Use FFI to lookup the platform-specific size of PIPE_BUF
-    str = "JUNK IN THE TUBES" * 10_000
-    cntr = 0
-    begin
-      pipe.write_nonblock str
-      cntr += 1
-      t = select [], [pipe], [], 0
-    rescue Errno::EPIPE
-      break
-    rescue IO::EWOULDBLOCKWaitWritable
-      skip "windows - can't test due to 'select' not showing correct status"
-      break
-    end while t && t[1].include?(pipe) && cntr < 20
-
-    pipe
-  end
-
-  it_behaves_like "an NIO selectable"
-  it_behaves_like "an NIO selectable stream"
-end