amq-protocol 2.4.0 → 2.5.1

data/spec/amq/bit_set_spec.rb

@@ -1,249 +0,0 @@
-require "amq/bit_set"
-
-# extracted from amqp gem. MK.
-RSpec.describe AMQ::BitSet do
-
-  #
-  # Environment
-  #
-
-  let(:nbits) { (1 << 16) - 1 }
-
-
-  #
-  # Examples
-  #
-
-  describe "#new" do
-    it "has no bits set at the start" do
-      bs = AMQ::BitSet.new(128)
-      0.upto(127) do |i|
-        expect(bs[i]).to be_falsey
-      end
-    end # it
-  end # describe
-
-  describe "#word_index" do
-    subject do
-      described_class.new(nbits)
-    end
-    it "returns 0 when the word is between 0 and 63" do
-      expect(subject.word_index(0)).to eq(0)
-      expect(subject.word_index(63)).to eq(0)
-    end # it
-    it "returns 1 when the word is between 64 and 127" do
-      expect(subject.word_index(64)).to be(1)
-      expect(subject.word_index(127)).to be(1)
-    end # it
-    it "returns 2 when the word is between 128 and another number" do
-      expect(subject.word_index(128)).to be(2)
-    end # it
-  end # describe
-
-  describe "#get, #[]" do
-    describe "when bit at given position is set" do
-      subject do
-        o = described_class.new(nbits)
-        o.set(3)
-        o
-      end
-
-      it "returns true" do
-        expect(subject.get(3)).to be_truthy
-      end # it
-    end # describe
-
-    describe "when bit at given position is off" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "returns false" do
-        expect(subject.get(5)).to be_falsey
-      end # it
-    end # describe
-
-    describe "when index out of range" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "should raise IndexError for negative index" do
-        expect { subject.get(-1) }.to raise_error(IndexError)
-      end # it
-      it "should raise IndexError for index >= number of bits" do
-        expect { subject.get(nbits) }.to raise_error(IndexError)
-      end # it
-    end # describe
-  end # describe
-
-
-  describe "#set" do
-    describe "when bit at given position is set" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "has no effect" do
-        subject.set(3)
-        expect(subject.get(3)).to be_truthy
-        subject.set(3)
-        expect(subject[3]).to be_truthy
-      end # it
-    end # describe
-
-    describe "when bit at given position is off" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "sets that bit" do
-        subject.set(3)
-        expect(subject.get(3)).to be_truthy
-
-        subject.set(33)
-        expect(subject.get(33)).to be_truthy
-
-        subject.set(3387)
-        expect(subject.get(3387)).to be_truthy
-      end # it
-    end # describe
-
-    describe "when index out of range" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "should raise IndexError for negative index" do
-        expect { subject.set(-1) }.to raise_error(IndexError)
-      end # it
-      it "should raise IndexError for index >= number of bits" do
-        expect { subject.set(nbits) }.to raise_error(IndexError)
-      end # it
-    end # describe
-  end # describe
-
-
-  describe "#unset" do
-    describe "when bit at a given position is set" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "unsets that bit" do
-        subject.set(3)
-        expect(subject.get(3)).to be_truthy
-        subject.unset(3)
-        expect(subject.get(3)).to be_falsey
-      end # it
-    end # describe
-
-
-    describe "when bit at a given position is off" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "has no effect" do
-        expect(subject.get(3)).to be_falsey
-        subject.unset(3)
-        expect(subject.get(3)).to be_falsey
-      end # it
-    end # describe
-
-    describe "when index out of range" do
-      subject do
-        described_class.new(nbits)
-      end
-
-      it "should raise IndexError for negative index" do
-        expect { subject.unset(-1) }.to raise_error(IndexError)
-      end # it
-      it "should raise IndexError for index >= number of bits" do
-        expect { subject.unset(nbits) }.to raise_error(IndexError)
-      end # it
-    end # describe
-  end # describe
-
-
-
-  describe "#clear" do
-    subject do
-      described_class.new(nbits)
-    end
-
-    it "clears all bits" do
-      subject.set(3)
-      expect(subject.get(3)).to be_truthy
-
-      subject.set(7668)
-      expect(subject.get(7668)).to be_truthy
-
-      subject.clear
-
-      expect(subject.get(3)).to be_falsey
-      expect(subject.get(7668)).to be_falsey
-    end # it
-  end # describe
-
-  describe "#number_of_trailing_ones" do
-    it "calculates them" do
-      expect(described_class.number_of_trailing_ones(0)).to eq(0)
-      expect(described_class.number_of_trailing_ones(1)).to eq(1)
-      expect(described_class.number_of_trailing_ones(2)).to eq(0)
-      expect(described_class.number_of_trailing_ones(3)).to eq(2)
-      expect(described_class.number_of_trailing_ones(4)).to eq(0)
-    end # it
-  end # describe
-
-  describe '#next_clear_bit' do
-    subject do
-      described_class.new(255)
-    end
-    it "returns sequential values when none have been returned" do
-      expect(subject.next_clear_bit).to eq(0)
-      subject.set(0)
-      expect(subject.next_clear_bit).to eq(1)
-      subject.set(1)
-      expect(subject.next_clear_bit).to eq(2)
-      subject.unset(1)
-      expect(subject.next_clear_bit).to eq(1)
-    end # it
-
-    it "returns the same number as long as nothing is set" do
-      expect(subject.next_clear_bit).to eq(0)
-      expect(subject.next_clear_bit).to eq(0)
-    end # it
-
-    it "handles more than 128 bits" do
-      0.upto(254) do |i|
-        subject.set(i)
-        expect(subject.next_clear_bit).to eq(i + 1)
-      end
-      subject.unset(254)
-      expect(subject.get(254)).to be_falsey
-    end # it
-
-    it "returns -1 when all bits are set" do
-      bs = described_class.new(64)
-      0.upto(63) { |i| bs.set(i) }
-      expect(bs.next_clear_bit).to eq(-1)
-    end
-  end # describe
-
-  describe "#to_s" do
-    it "returns a string representation of the bit set" do
-      bs = described_class.new(64)
-      result = bs.to_s
-      expect(result).to be_a(String)
-      expect(result).to include(":")
-    end
-
-    it "shows set bits" do
-      bs = described_class.new(64)
-      bs.set(0)
-      result = bs.to_s
-      expect(result).to end_with("1:")
-    end
-  end # describe
-end

data/spec/amq/endianness_spec.rb

@@ -1,23 +0,0 @@
-# encoding: binary
-
-require "amq/endianness"
-
-RSpec.describe AMQ::Endianness do
-  describe ".big_endian?" do
-    it "returns a boolean" do
-      expect([true, false]).to include(described_class.big_endian?)
-    end
-  end
-
-  describe ".little_endian?" do
-    it "returns the opposite of big_endian?" do
-      expect(described_class.little_endian?).to eq(!described_class.big_endian?)
-    end
-  end
-
-  describe "BIG_ENDIAN constant" do
-    it "is a boolean" do
-      expect([true, false]).to include(AMQ::Endianness::BIG_ENDIAN)
-    end
-  end
-end

data/spec/amq/int_allocator_spec.rb

@@ -1,136 +0,0 @@
-require "amq/int_allocator"
-
-RSpec.describe AMQ::IntAllocator do
-
-  #
-  # Environment
-  #
-
-  subject do
-    described_class.new(1, 5)
-  end
-
-
-  #
-  # Examples
-  #
-
-  describe "#initialize" do
-    it "raises ArgumentError when hi <= lo" do
-      expect { described_class.new(5, 5) }.to raise_error(ArgumentError)
-      expect { described_class.new(10, 5) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#number_of_bits" do
-    it "returns number of bits available for allocation" do
-      expect(subject.number_of_bits).to eq(4)
-    end
-  end
-
-
-  describe "#hi" do
-    it "returns upper bound of the allocation range" do
-      expect(subject.hi).to eq(5)
-    end
-  end
-
-  describe "#lo" do
-    it "returns lower bound of the allocation range" do
-      expect(subject.lo).to eq(1)
-    end
-  end
-
-
-  describe "#allocate" do
-    context "when integer in the range is available" do
-      it "returns allocated integer" do
-        expect(subject.allocate).to eq(1)
-        expect(subject.allocate).to eq(2)
-        expect(subject.allocate).to eq(3)
-        expect(subject.allocate).to eq(4)
-
-        expect(subject.allocate).to eq(-1)
-      end
-    end
-
-    context "when integer in the range IS NOT available" do
-      it "returns -1" do
-        4.times { subject.allocate }
-
-        expect(subject.allocate).to eq(-1)
-        expect(subject.allocate).to eq(-1)
-        expect(subject.allocate).to eq(-1)
-        expect(subject.allocate).to eq(-1)
-      end
-    end
-  end
-
-
-  describe "#free" do
-    context "when the integer WAS allocated" do
-      it "returns frees that integer" do
-        4.times { subject.allocate }
-        expect(subject.allocate).to eq(-1)
-
-        subject.free(1)
-        expect(subject.allocate).to eq(1)
-        expect(subject.allocate).to eq(-1)
-        subject.free(2)
-        expect(subject.allocate).to eq(2)
-        expect(subject.allocate).to eq(-1)
-        subject.free(3)
-        expect(subject.allocate).to eq(3)
-        expect(subject.allocate).to eq(-1)
-      end
-    end
-
-    context "when the integer WAS NOT allocated" do
-      it "has no effect" do
-        32.times { subject.free(1) }
-        expect(subject.allocate).to eq(1)
-      end
-    end
-  end
-
-
-  describe "#allocated?" do
-    context "when given position WAS allocated" do
-      it "returns true" do
-        3.times { subject.allocate }
-
-        expect(subject.allocated?(1)).to be_truthy
-        expect(subject.allocated?(2)).to be_truthy
-        expect(subject.allocated?(3)).to be_truthy
-      end
-    end
-
-    context "when given position WAS NOT allocated" do
-      it "returns false" do
-        2.times { subject.allocate }
-
-        expect(subject.allocated?(3)).to be_falsey
-        expect(subject.allocated?(4)).to be_falsey
-      end
-    end
-  end
-
-  describe "#release" do
-    it "is an alias for #free" do
-      subject.allocate
-      expect(subject.allocated?(1)).to be_truthy
-      subject.release(1)
-      expect(subject.allocated?(1)).to be_falsey
-    end
-  end
-
-  describe "#reset" do
-    it "releases all allocations" do
-      4.times { subject.allocate }
-      expect(subject.allocate).to eq(-1)
-
-      subject.reset
-      expect(subject.allocate).to eq(1)
-    end
-  end
-end

data/spec/amq/pack_spec.rb

@@ -1,58 +0,0 @@
-# encoding: binary
-
-RSpec.describe AMQ::Pack do
-  context "16-bit big-endian packing / unpacking" do
-    let(:examples_16bit) {
-      {
-        0x068D => "\x06\x8D",  # 1677
-        0x0000 => "\x00\x00",  # 0
-        0x7FFF => "\x7F\xFF"   # 32767 (max positive signed 16-bit)
-      }
-    }
-
-    it "packs signed integers into a big-endian string" do
-      examples_16bit.each do |key, value|
-        expect(described_class.pack_int16_big_endian(key)).to eq(value)
-      end
-    end
-
-    it "unpacks signed integers from a string to a number" do
-      examples_16bit.each do |key, value|
-        expect(described_class.unpack_int16_big_endian(value)[0]).to eq(key)
-      end
-    end
-  end
-
-  context "64-bit big-endian packing / unpacking" do
-    let(:examples) {
-      {
-        0x0000000000000000 => "\x00\x00\x00\x00\x00\x00\x00\x00",
-        0x000000000000000A => "\x00\x00\x00\x00\x00\x00\x00\x0A",
-        0x00000000000000A0 => "\x00\x00\x00\x00\x00\x00\x00\xA0",
-        0x000000000000B0A0 => "\x00\x00\x00\x00\x00\x00\xB0\xA0",
-        0x00000000000CB0AD => "\x00\x00\x00\x00\x00\x0C\xB0\xAD",
-        0x8BADF00DDEFEC8ED => "\x8B\xAD\xF0\x0D\xDE\xFE\xC8\xED",
-        0x0D15EA5EFEE1DEAD => "\x0D\x15\xEA\x5E\xFE\xE1\xDE\xAD",
-        0xDEADBEEFDEADBABE => "\xDE\xAD\xBE\xEF\xDE\xAD\xBA\xBE"
-      }
-    }
-
-    it "packs integers into big-endian string" do
-      examples.each do |key, value|
-        expect(described_class.pack_uint64_big_endian(key)).to eq(value)
-      end
-    end
-
-    it "unpacks string representation into integer" do
-      examples.each do |key, value|
-        expect(described_class.unpack_uint64_big_endian(value)[0]).to eq(key)
-      end
-    end
-  end
-
-  describe "AMQ::Hacks alias" do
-    it "is an alias for AMQ::Pack (backwards compatibility)" do
-      expect(AMQ::Hacks).to eq(AMQ::Pack)
-    end
-  end
-end