biryani 0.0.7 → 0.0.9

data/spec/connection/read_http2_magic_spec.rb

@@ -1,26 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Connection do
-  context 'read_http2_magic' do
-    let(:io1) do
-      StringIO.new("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n")
-    end
-    it 'should read' do
-      expect(Connection.read_http2_magic(io1)).to eq nil
-    end
-
-    let(:io2) do
-      StringIO.new("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n\x00xff")
-    end
-    it 'should read' do
-      expect(Connection.read_http2_magic(io2)).to eq nil
-    end
-
-    let(:io3) do
-      StringIO.new("\x00xffPRI * HTTP/2.0\r\n\r\nSM\r\n\r\n")
-    end
-    it 'should not read' do
-      expect(Connection.read_http2_magic(io3)).to be_kind_of ConnectionError
-    end
-  end
-end

data/spec/connection/send_spec.rb

@@ -1,104 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Connection do
-  context 'send' do
-    let(:io) do
-      StringIO.new
-    end
-    let(:data_buffer) do
-      DataBuffer.new
-    end
-
-    let(:headers1) do
-      Frame::Headers.new(true, true, 2, nil, nil, 'this is dummy'.b, nil)
-    end
-    let(:send_window1) do
-      Window.new(65_535)
-    end
-    let(:streams_ctx1) do
-      streams_ctx = StreamsContext.new(do_nothing_proc)
-      streams_ctx.new_context(1, 65_535, 65_535)
-      streams_ctx.new_context(2, 65_535, 65_535)
-      streams_ctx
-    end
-    it 'should send' do
-      streams_ctx1[2].state_transition!(headers1, :recv)
-      Connection.send_headers(io, 2, "\x88".b, false, 16_384, streams_ctx1)
-      Connection.send_data(io, 2, 'Hello, world!'.b, send_window1, 16_384, streams_ctx1, data_buffer)
-      expect(io.string.force_encoding(Encoding::ASCII_8BIT)).to eq "\x00\x00\x01\x01\x04\x00\x00\x00\x02\x88\x00\x00\x0d\x00\x01\x00\x00\x00\x02Hello, world!".b
-      expect(send_window1.length).to eq 65_535 - 13
-      expect(streams_ctx1[1].send_window.length).to eq 65_535
-      expect(streams_ctx1[2].send_window.length).to eq 65_535 - 13
-      expect(data_buffer.length).to eq 0
-    end
-
-    let(:headers2) do
-      Frame::Headers.new(true, true, 1, nil, nil, 'this is dummy', nil)
-    end
-    let(:send_window2) do
-      Window.new(65_535)
-    end
-    let(:streams_ctx2) do
-      streams_ctx = StreamsContext.new(do_nothing_proc)
-      streams_ctx.new_context(1, 65_535, 65_535)
-      streams_ctx.new_context(2, 65_535, 65_535)
-      streams_ctx
-    end
-    it 'should send' do
-      streams_ctx2[1].state_transition!(headers2, :recv)
-      Connection.send_headers(io, 1, "\x88".b, true, 16_384, streams_ctx2)
-      expect(io.string.force_encoding(Encoding::ASCII_8BIT)).to eq "\x00\x00\x01\x01\x05\x00\x00\x00\x01\x88".b
-      expect(send_window2.length).to eq 65_535
-      expect(streams_ctx2[1].send_window.length).to eq 65_535
-      expect(streams_ctx2[2].send_window.length).to eq 65_535
-      expect(data_buffer.length).to eq 0
-    end
-
-    let(:headers3) do
-      Frame::Headers.new(true, true, 2, nil, nil, 'this is dummy', nil)
-    end
-    let(:send_window3) do
-      Window.new(65_535)
-    end
-    let(:streams_ctx3) do
-      streams_ctx = StreamsContext.new(do_nothing_proc)
-      streams_ctx.new_context(1, 65_535, 65_535)
-      streams_ctx.new_context(2, 65_535, 65_535)
-      streams_ctx[2].send_window.consume!(65_535)
-      streams_ctx
-    end
-    it 'should send' do
-      streams_ctx3[2].state_transition!(headers3, :recv)
-      Connection.send_data(io, 2, 'Hello, world!'.b, send_window3, 16_384, streams_ctx3, data_buffer)
-      expect(io.string.force_encoding(Encoding::ASCII_8BIT)).to eq ''.b
-      expect(send_window3.length).to eq 65_535
-      expect(streams_ctx3[1].send_window.length).to eq 65_535
-      expect(streams_ctx3[2].send_window.length).to eq 0
-      expect(data_buffer.length).to eq 1
-    end
-
-    let(:headers4) do
-      Frame::Headers.new(true, true, 2, nil, nil, 'this is dummy', nil)
-    end
-    let(:send_window4) do
-      send_window = Window.new(65_535)
-      send_window.consume!(65_535)
-      send_window
-    end
-    let(:streams_ctx4) do
-      streams_ctx = StreamsContext.new(do_nothing_proc)
-      streams_ctx.new_context(1, 65_535, 65_535)
-      streams_ctx.new_context(2, 65_535, 65_535)
-      streams_ctx
-    end
-    it 'should send' do
-      streams_ctx4[2].state_transition!(headers4, :recv)
-      Connection.send_data(io, 2, 'Hello, world!'.b, send_window4, 16_384, streams_ctx4, data_buffer)
-      expect(io.string.force_encoding(Encoding::ASCII_8BIT)).to eq ''.b
-      expect(send_window4.length).to eq 0
-      expect(streams_ctx4[1].send_window.length).to eq 65_535
-      expect(streams_ctx4[2].send_window.length).to eq 65_535
-      expect(data_buffer.length).to eq 1
-    end
-  end
-end

data/spec/connection/transition_stream_state_send_spec.rb

@@ -1,39 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Connection do
-  context 'transition_stream_state_send' do
-    let(:streams_ctx) do
-      streams_ctx = StreamsContext.new(do_nothing_proc)
-      streams_ctx.new_context(1, 65_535, 65_535)
-      streams_ctx.new_context(2, 65_535, 65_535)
-      streams_ctx
-    end
-
-    let(:headers) do
-      Frame::Headers.new(true, true, 2, nil, nil, 'this is dummy', nil)
-    end
-    it 'should transition' do
-      streams_ctx[2].state_transition!(headers, :recv)
-      Connection.transition_stream_state_send(headers, streams_ctx)
-      expect(streams_ctx.length).to eq 2
-    end
-
-    it 'should transition' do
-      streams_ctx[1].state_transition!(headers, :recv)
-      streams_ctx[2].state_transition!(headers, :recv)
-      streams_ctx.close_all
-      expect { streams_ctx[1].tx << nil }.to raise_error Ractor::ClosedError
-      expect { streams_ctx[2].tx << nil }.to raise_error Ractor::ClosedError
-    end
-
-    let(:rst_stream) do
-      Frame::RstStream.new(2, 0)
-    end
-    it 'should transition' do
-      streams_ctx[2].state_transition!(headers, :recv)
-      Connection.transition_stream_state_send(rst_stream, streams_ctx)
-      expect { streams_ctx[1].tx << nil }.to_not raise_error
-      expect { streams_ctx[2].tx << nil }.to_not raise_error
-    end
-  end
-end

data/spec/data_buffer_spec.rb

@@ -1,135 +0,0 @@
-require_relative 'spec_helper'
-
-RSpec.describe DataBuffer do
-  context 'take!' do
-    let(:data_buffer1) do
-      DataBuffer.new
-    end
-    let(:send_window1) do
-      Window.new(65_535)
-    end
-    let(:streams_ctx1) do
-      streams_ctx = StreamsContext.new(do_nothing_proc)
-      streams_ctx.new_context(1, 65_535, 65_535)
-      streams_ctx.new_context(2, 65_535, 65_535)
-      streams_ctx
-    end
-    it 'should take' do
-      expect(data_buffer1.take!(send_window1, streams_ctx1, 16_384).length).to eq 0
-      expect(send_window1.length).to eq 65_535
-      expect(streams_ctx1[1].send_window.length).to eq 65_535
-      expect(streams_ctx1[2].send_window.length).to eq 65_535
-    end
-
-    let(:data_buffer2) do
-      data_buffer = DataBuffer.new
-      data_buffer.store(1, 'one')
-      data_buffer.store(2, 'two')
-      data_buffer
-    end
-    let(:send_window2) do
-      Window.new(65_535)
-    end
-    let(:streams_ctx2) do
-      streams_ctx = StreamsContext.new(do_nothing_proc)
-      streams_ctx.new_context(1, 65_535, 65_535)
-      streams_ctx.new_context(2, 65_535, 65_535)
-      streams_ctx
-    end
-    it 'should take' do
-      datas = data_buffer2.take!(send_window2, streams_ctx2, 16_384)
-      expect(datas.length).to eq 2
-      expect(datas.map(&:stream_id)).to eq [1, 2]
-      expect(datas.map(&:data)).to eq %w[one two]
-      expect(send_window2.length).to eq 65_535 - 6
-      expect(streams_ctx2[1].send_window.length).to eq 65_535 - 3
-      expect(streams_ctx2[2].send_window.length).to eq 65_535 - 3
-    end
-
-    let(:data_buffer3) do
-      data_buffer = DataBuffer.new
-      data_buffer.store(2, 'two')
-      data_buffer
-    end
-    let(:send_window3) do
-      Window.new(65_535)
-    end
-    let(:streams_ctx3) do
-      streams_ctx = StreamsContext.new(do_nothing_proc)
-      streams_ctx.new_context(1, 65_535, 65_535)
-      streams_ctx.new_context(2, 65_535, 65_535)
-      streams_ctx
-    end
-    it 'should take' do
-      datas = data_buffer3.take!(send_window3, streams_ctx3, 16_384)
-      expect(datas.length).to eq 1
-      expect(datas.first.stream_id).to eq 2
-      expect(datas.first.data).to eq 'two'
-      expect(send_window3.length).to eq 65_535 - 3
-      expect(streams_ctx3[1].send_window.length).to eq 65_535
-      expect(streams_ctx3[2].send_window.length).to eq 65_535 - 3
-    end
-
-    let(:data_buffer4) do
-      data_buffer = DataBuffer.new
-      data_buffer.store(1, 'one')
-      data_buffer.store(2, 'two')
-      data_buffer
-    end
-    let(:send_window4) do
-      Window.new(65_535)
-    end
-    let(:streams_ctx4) do
-      streams_ctx = StreamsContext.new(do_nothing_proc)
-      streams_ctx.new_context(1, 65_535, 65_535)
-      streams_ctx[1].send_window.consume!(65_535)
-      streams_ctx.new_context(2, 65_535, 65_535)
-      streams_ctx
-    end
-    it 'should take' do
-      datas = data_buffer4.take!(send_window4, streams_ctx4, 16_384)
-      expect(datas.length).to eq 1
-      expect(datas.first.stream_id).to eq 2
-      expect(datas.first.data).to eq 'two'
-      expect(send_window4.length).to eq 65_535 - 3
-      expect(streams_ctx4[1].send_window.length).to eq 0
-      expect(streams_ctx4[2].send_window.length).to eq 65_535 - 3
-    end
-
-    let(:data_buffer5) do
-      data_buffer = DataBuffer.new
-      data_buffer.store(1, 'one')
-      data_buffer.store(2, 'two')
-      data_buffer
-    end
-    let(:send_window5) do
-      send_window = Window.new(65_535)
-      send_window.consume!(65_535)
-      send_window
-    end
-    let(:streams_ctx5) do
-      streams_ctx = StreamsContext.new(do_nothing_proc)
-      streams_ctx.new_context(1, 65_535, 65_535)
-      streams_ctx.new_context(2, 65_535, 65_535)
-      streams_ctx
-    end
-    it 'should take' do
-      expect(data_buffer5.take!(send_window5, streams_ctx5, 16_384).length).to eq 0
-      expect(send_window5.length).to eq 0
-      expect(streams_ctx5[1].send_window.length).to eq 65_535
-      expect(streams_ctx5[2].send_window.length).to eq 65_535
-    end
-  end
-
-  context 'has?' do
-    let(:data_buffer6) do
-      data_buffer = DataBuffer.new
-      data_buffer.store(1, 'one')
-      data_buffer
-    end
-    it 'should take' do
-      expect(data_buffer6.has?(1)).to eq true
-      expect(data_buffer6.has?(2)).to eq false
-    end
-  end
-end

data/spec/frame/continuation_spec.rb

@@ -1,39 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Frame::Continuation do
-  context do
-    let(:continuation1) do
-      Frame::Continuation.new(false, 50, '')
-    end
-    it 'should encode' do
-      expect(continuation1.to_binary_s).to eq "\x00\x00\x00\x09\x00\x00\x00\x00\x32".b
-    end
-
-    let(:continuation2) do
-      Frame::Continuation.new(false, 50, 'this is dummy')
-    end
-    it 'should encode' do
-      expect(continuation2.to_binary_s).to eq "\x00\x00\x0d\x09\x00\x00\x00\x00\x32\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79".b
-    end
-
-    let(:continuation3) do
-      Frame::Continuation.read(''.b, 0, 50)
-    end
-    it 'should decode' do
-      expect(continuation3.f_type).to eq FrameType::CONTINUATION
-      expect(continuation3.end_headers?).to eq false
-      expect(continuation3.stream_id).to eq 50
-      expect(continuation3.fragment).to eq ''
-    end
-
-    let(:continuation4) do
-      Frame::Continuation.read("\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79".b, 9, 50)
-    end
-    it 'should decode' do
-      expect(continuation4.f_type).to eq FrameType::CONTINUATION
-      expect(continuation4.end_headers?).to eq false
-      expect(continuation4.stream_id).to eq 50
-      expect(continuation4.fragment).to eq 'this is dummy'
-    end
-  end
-end

data/spec/frame/data_spec.rb

@@ -1,25 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Frame::Data do
-  context do
-    let(:data1) do
-      Frame::Data.new(false, 2, 'Hello, world!', 'Howdy!')
-    end
-    it 'should encode' do
-      expect(data1.to_binary_s).to eq "\x00\x00\x14\x00\x08\x00\x00\x00\x02\x06\x48\x65\x6c\x6c\x6f\x2c\x20\x77\x6f\x72\x6c\x64\x21\x48\x6f\x77\x64\x79\x21".b
-    end
-
-    let(:data2) do
-      Frame::Data.read("\x06\x48\x65\x6c\x6c\x6f\x2c\x20\x77\x6f\x72\x6c\x64\x21\x48\x6f\x77\x64\x79\x21".b, 8, 2)
-    end
-    it 'should decode' do
-      expect(data2.f_type).to eq FrameType::DATA
-      expect(data2.end_stream?).to eq false
-      expect(data2.stream_id).to eq 2
-      expect(data2.data).to eq 'Hello, world!'
-      expect(data2.padding).to eq 'Howdy!'
-      expect(data2.padded?).to eq true
-      expect(data2.length).to eq 20
-    end
-  end
-end

data/spec/frame/goaway_spec.rb

@@ -1,23 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Frame::Goaway do
-  context do
-    let(:goaway1) do
-      Frame::Goaway.new(0, 30, 9, 'hpack is broken')
-    end
-    it 'should encode' do
-      expect(goaway1.to_binary_s).to eq "\x00\x00\x17\x07\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x09\x68\x70\x61\x63\x6b\x20\x69\x73\x20\x62\x72\x6f\x6b\x65\x6e".b
-    end
-
-    let(:goaway2) do
-      Frame::Goaway.read("\x00\x00\x00\x1e\x00\x00\x00\x09\x68\x70\x61\x63\x6b\x20\x69\x73\x20\x62\x72\x6f\x6b\x65\x6e".b, 7, 0)
-    end
-    it 'should decode' do
-      expect(goaway2.f_type).to eq FrameType::GOAWAY
-      expect(goaway2.stream_id).to eq 0
-      expect(goaway2.last_stream_id).to eq 30
-      expect(goaway2.error_code).to eq 9
-      expect(goaway2.debug).to eq 'hpack is broken'
-    end
-  end
-end

data/spec/frame/headers_spec.rb

@@ -1,52 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Frame::Headers do
-  context do
-    let(:headers1) do
-      Frame::Headers.new(true, false, 1, nil, nil, 'this is dummy', nil)
-    end
-    it 'should encode' do
-      expect(headers1.to_binary_s).to eq "\x00\x00\x0d\x01\x04\x00\x00\x00\x01\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79".b
-    end
-
-    let(:headers2) do
-      Frame::Headers.new(true, false, 3, 20, 10, 'this is dummy', 'This is padding.')
-    end
-    it 'should encode' do
-      expect(headers2.to_binary_s)
-        .to eq "\x00\x00\x23\x01\x2c\x00\x00\x00\x03\x10\x00\x00\x00\x14\x0a\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79\x54\x68\x69\x73\x20\x69\x73\x20\x70\x61\x64\x64\x69\x6e\x67\x2e".b
-    end
-
-    let(:headers3) do
-      Frame::Headers.read("\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79".b, 4, 1)
-    end
-    it 'should decode' do
-      expect(headers3.f_type).to eq FrameType::HEADERS
-      expect(headers3.end_headers?).to eq true
-      expect(headers3.end_stream?).to eq false
-      expect(headers3.stream_id).to eq 1
-      expect(headers3.stream_dependency).to eq nil
-      expect(headers3.weight).to eq nil
-      expect(headers3.fragment).to eq 'this is dummy'
-      expect(headers3.padding).to eq nil
-      expect(headers3.priority?).to eq false
-      expect(headers3.padded?).to eq false
-    end
-
-    let(:headers4) do
-      Frame::Headers.read("\x10\x00\x00\x00\x14\x0a\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79\x54\x68\x69\x73\x20\x69\x73\x20\x70\x61\x64\x64\x69\x6e\x67\x2e".b, 44, 3)
-    end
-    it 'should decode' do
-      expect(headers4.f_type).to eq FrameType::HEADERS
-      expect(headers4.end_headers?).to eq true
-      expect(headers4.end_stream?).to eq false
-      expect(headers4.stream_id).to eq 3
-      expect(headers4.stream_dependency).to eq 20
-      expect(headers4.weight).to eq 10
-      expect(headers4.fragment).to eq 'this is dummy'
-      expect(headers4.padding).to eq 'This is padding.'
-      expect(headers4.priority?).to eq true
-      expect(headers4.padded?).to eq true
-    end
-  end
-end

data/spec/frame/ping_spec.rb

@@ -1,22 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Frame::Ping do
-  context do
-    let(:ping1) do
-      Frame::Ping.new(false, 0, 'deadbeef')
-    end
-    it 'should encode' do
-      expect(ping1.to_binary_s).to eq "\x00\x00\x08\x06\x00\x00\x00\x00\x00\x64\x65\x61\x64\x62\x65\x65\x66".b
-    end
-
-    let(:ping2) do
-      Frame::Ping.read("\x64\x65\x61\x64\x62\x65\x65\x66".b, 0, 0)
-    end
-    it 'should decode' do
-      expect(ping2.f_type).to eq FrameType::PING
-      expect(ping2.ack?).to eq false
-      expect(ping2.stream_id).to eq 0
-      expect(ping2.opaque).to eq 'deadbeef'
-    end
-  end
-end

data/spec/frame/priority_spec.rb

@@ -1,22 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Frame::Priority do
-  context do
-    let(:priority1) do
-      Frame::Priority.new(9, 11, 8)
-    end
-    it 'should encode' do
-      expect(priority1.to_binary_s).to eq "\x00\x00\x05\x02\x00\x00\x00\x00\x09\x00\x00\x00\x0b\x08".b
-    end
-
-    let(:priority2) do
-      Frame::Priority.read("\x00\x00\x00\x0b\x08".b, 0, 9)
-    end
-    it 'should decode' do
-      expect(priority2.f_type).to eq FrameType::PRIORITY
-      expect(priority2.stream_id).to eq 9
-      expect(priority2.stream_dependency).to eq 11
-      expect(priority2.weight).to eq 8
-    end
-  end
-end

data/spec/frame/push_promise_spec.rb

@@ -1,24 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Frame::PushPromise do
-  context do
-    let(:push_promise1) do
-      Frame::PushPromise.new(true, 10, 12, 'this is dummy', 'Howdy!')
-    end
-    it 'should encode' do
-      expect(push_promise1.to_binary_s).to eq "\x00\x00\x18\x05\x0c\x00\x00\x00\x0a\x06\x00\x00\x00\x0c\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79\x48\x6f\x77\x64\x79\x21".b
-    end
-
-    let(:push_promise2) do
-      Frame::PushPromise.read("\x06\x00\x00\x00\x0c\x74\x68\x69\x73\x20\x69\x73\x20\x64\x75\x6d\x6d\x79\x48\x6f\x77\x64\x79\x21".b, 12, 10)
-    end
-    it 'should decode' do
-      expect(push_promise2.f_type).to eq FrameType::PUSH_PROMISE
-      expect(push_promise2.padded?).to eq true
-      expect(push_promise2.stream_id).to eq 10
-      expect(push_promise2.promised_stream_id).to eq 12
-      expect(push_promise2.fragment).to eq 'this is dummy'
-      expect(push_promise2.padding).to eq 'Howdy!'
-    end
-  end
-end

data/spec/frame/read_spec.rb

@@ -1,30 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Frame do
-  context do
-    let(:empty) do
-      StringIO.new(''.b)
-    end
-    it 'should not read' do
-      expect(Frame.read(empty)).to eq nil
-    end
-
-    let(:invalid_header) do
-      StringIO.new("\x12\x34\x56\x00\x00".b)
-    end
-    it 'should not read' do
-      expect(Frame.read(invalid_header)).to be_kind_of ConnectionError
-    end
-
-    let(:unknown) do
-      StringIO.new("\x00\x00\x01\x0a\x01\x00\x00\x00\x01\xff".b)
-    end
-    it 'should read' do
-      frame = Frame.read(unknown)
-      expect(frame.f_type).to eq 0x0a
-      expect(frame.flags).to eq 0x01
-      expect(frame.stream_id).to eq 0x01
-      expect(frame.payload).to eq "\xff".b
-    end
-  end
-end

data/spec/frame/rst_stream_spec.rb

@@ -1,21 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Frame::RstStream do
-  context do
-    let(:rst_stream1) do
-      Frame::RstStream.new(5, 8)
-    end
-    it 'should encode' do
-      expect(rst_stream1.to_binary_s).to eq "\x00\x00\x04\x03\x00\x00\x00\x00\x05\x00\x00\x00\x08".b
-    end
-
-    let(:rst_stream2) do
-      Frame::RstStream.read("\x00\x00\x00\x08".b, 0, 5)
-    end
-    it 'should decode' do
-      expect(rst_stream2.f_type).to eq FrameType::RST_STREAM
-      expect(rst_stream2.stream_id).to eq 5
-      expect(rst_stream2.error_code).to eq 8
-    end
-  end
-end

data/spec/frame/settings_spec.rb

@@ -1,23 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Frame::Settings do
-  context do
-    let(:settings1) do
-      Frame::Settings.new(false, 0, { 1 => 8192, 3 => 5000 })
-    end
-    it 'should encode' do
-      expect(settings1.to_binary_s).to eq "\x00\x00\x0c\x04\x00\x00\x00\x00\x00\x00\x01\x00\x00\x20\x00\x00\x03\x00\x00\x13\x88".b
-    end
-
-    let(:settings2) do
-      Frame::Settings.read("\x00\x01\x00\x00\x20\x00\x00\x03\x00\x00\x13\x88".b, 0, 0)
-    end
-    it 'should decode' do
-      expect(settings2.f_type).to eq FrameType::SETTINGS
-      expect(settings2.ack?).to eq false
-      expect(settings2.stream_id).to eq 0
-      expect(settings2.setting[1]).to eq 8192
-      expect(settings2.setting[3]).to eq 5000
-    end
-  end
-end

data/spec/frame/window_update_spec.rb

@@ -1,21 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Frame::WindowUpdate do
-  context do
-    let(:window_update1) do
-      Frame::WindowUpdate.new(50, 1000)
-    end
-    it 'should encode' do
-      expect(window_update1.to_binary_s).to eq "\x00\x00\x04\x08\x00\x00\x00\x00\x32\x00\x00\x03\xe8".b
-    end
-
-    let(:window_update2) do
-      Frame::WindowUpdate.read("\x00\x00\x03\xe8".b, 0, 50)
-    end
-    it 'should decode' do
-      expect(window_update2.f_type).to eq FrameType::WINDOW_UPDATE
-      expect(window_update2.stream_id).to eq 50
-      expect(window_update2.window_size_increment).to eq 1000
-    end
-  end
-end