diff --git a/core/io/buffer/empty_spec.rb b/core/io/buffer/empty_spec.rb
new file mode 100644
index 000000000..e1fd4ab6a
--- /dev/null
+++ b/core/io/buffer/empty_spec.rb
@@ -0,0 +1,29 @@
+require_relative '../../../spec_helper'
+require_relative 'shared/null_and_empty'
+
+describe "IO::Buffer#empty?" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  it_behaves_like :io_buffer_null_and_empty, :empty?
+
+  it "is true for a 0-length String-backed buffer created with .for" do
+    @buffer = IO::Buffer.for("")
+    @buffer.empty?.should be_true
+  end
+
+  ruby_version_is "3.3" do
+    it "is true for a 0-length String-backed buffer created with .string" do
+      IO::Buffer.string(0) do |buffer|
+        buffer.empty?.should be_true
+      end
+    end
+  end
+
+  it "is true for a 0-length slice of a buffer with size > 0" do
+    @buffer = IO::Buffer.new(4)
+    @buffer.slice(3, 0).empty?.should be_true
+  end
+end
diff --git a/core/io/buffer/external_spec.rb b/core/io/buffer/external_spec.rb
new file mode 100644
index 000000000..4377a3835
--- /dev/null
+++ b/core/io/buffer/external_spec.rb
@@ -0,0 +1,108 @@
+require_relative '../../../spec_helper'
+
+describe "IO::Buffer#external?" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  context "with a buffer created with .new" do
+    it "is false for an internal buffer" do
+      @buffer = IO::Buffer.new(4)
+      @buffer.external?.should be_false
+    end
+
+    it "is false for a mapped buffer" do
+      @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+      @buffer.external?.should be_false
+    end
+  end
+
+  context "with a file-backed buffer created with .map" do
+    it "is true for a regular mapping" do
+      File.open(__FILE__, "r") do |file|
+        @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+        @buffer.external?.should be_true
+      end
+    end
+
+    ruby_version_is "3.3" do
+      it "is false for a private mapping" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY | IO::Buffer::PRIVATE)
+          @buffer.external?.should be_false
+        end
+      end
+    end
+  end
+
+  context "with a String-backed buffer created with .for" do
+    it "is true for a buffer created without a block" do
+      @buffer = IO::Buffer.for("test")
+      @buffer.external?.should be_true
+    end
+
+    it "is true for a buffer created with a block" do
+      IO::Buffer.for(+"test") do |buffer|
+        buffer.external?.should be_true
+      end
+    end
+  end
+
+  ruby_version_is "3.3" do
+    context "with a String-backed buffer created with .string" do
+      it "is true" do
+        IO::Buffer.string(4) do |buffer|
+          buffer.external?.should be_true
+        end
+      end
+    end
+  end
+
+  # Always false for slices
+  context "with a slice of a buffer" do
+    context "created with .new" do
+      it "is false when slicing an internal buffer" do
+        @buffer = IO::Buffer.new(4)
+        @buffer.slice.external?.should be_false
+      end
+
+      it "is false when slicing a mapped buffer" do
+        @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+        @buffer.slice.external?.should be_false
+      end
+    end
+
+    context "created with .map" do
+      it "is false" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+          @buffer.slice.external?.should be_false
+        end
+      end
+    end
+
+    context "created with .for" do
+      it "is false when slicing a buffer created without a block" do
+        @buffer = IO::Buffer.for("test")
+        @buffer.slice.external?.should be_false
+      end
+
+      it "is false when slicing a buffer created with a block" do
+        IO::Buffer.for(+"test") do |buffer|
+          buffer.slice.external?.should be_false
+        end
+      end
+    end
+
+    ruby_version_is "3.3" do
+      context "created with .string" do
+        it "is false" do
+          IO::Buffer.string(4) do |buffer|
+            buffer.slice.external?.should be_false
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/core/io/buffer/free_spec.rb b/core/io/buffer/free_spec.rb
new file mode 100644
index 000000000..f3a491897
--- /dev/null
+++ b/core/io/buffer/free_spec.rb
@@ -0,0 +1,104 @@
+require_relative '../../../spec_helper'
+
+describe "IO::Buffer#free" do
+  context "with a buffer created with .new" do
+    it "frees internal memory and nullifies the buffer" do
+      buffer = IO::Buffer.new(4)
+      buffer.free
+      buffer.null?.should be_true
+    end
+
+    it "frees mapped memory and nullifies the buffer" do
+      buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+      buffer.free
+      buffer.null?.should be_true
+    end
+  end
+
+  context "with a file-backed buffer created with .map" do
+    it "frees mapped memory and nullifies the buffer" do
+      File.open(__FILE__, "r") do |file|
+        buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+        buffer.free
+        buffer.null?.should be_true
+      end
+    end
+  end
+
+  context "with a String-backed buffer created with .for" do
+    context "without a block" do
+      it "disassociates the buffer from the string and nullifies the buffer" do
+        string = +"test"
+        buffer = IO::Buffer.for(string)
+        # Read-only buffer, can't modify the string.
+        buffer.free
+        buffer.null?.should be_true
+      end
+    end
+
+    context "with a block" do
+      it "disassociates the buffer from the string and nullifies the buffer" do
+        string = +"test"
+        IO::Buffer.for(string) do |buffer|
+          buffer.set_string("meat")
+          buffer.free
+          buffer.null?.should be_true
+        end
+        string.should == "meat"
+      end
+    end
+  end
+
+  ruby_version_is "3.3" do
+    context "with a String-backed buffer created with .string" do
+      it "disassociates the buffer from the string and nullifies the buffer" do
+        string =
+          IO::Buffer.string(4) do |buffer|
+            buffer.set_string("meat")
+            buffer.free
+            buffer.null?.should be_true
+          end
+        string.should == "meat"
+      end
+    end
+  end
+
+  it "can be called repeatedly without an error" do
+    buffer = IO::Buffer.new(4)
+    buffer.free
+    buffer.null?.should be_true
+    buffer.free
+    buffer.null?.should be_true
+  end
+
+  it "is disallowed while locked, raising IO::Buffer::LockedError" do
+    buffer = IO::Buffer.new(4)
+    buffer.locked do
+      -> { buffer.free }.should raise_error(IO::Buffer::LockedError, "Buffer is locked!")
+    end
+    buffer.free
+    buffer.null?.should be_true
+  end
+
+  context "with a slice of a buffer" do
+    it "nullifies the slice, not touching the buffer" do
+      buffer = IO::Buffer.new(4)
+      slice = buffer.slice(0, 2)
+
+      slice.free
+      slice.null?.should be_true
+      buffer.null?.should be_false
+
+      buffer.free
+    end
+
+    it "nullifies buffer, invalidating the slice" do
+      buffer = IO::Buffer.new(4)
+      slice = buffer.slice(0, 2)
+
+      buffer.free
+      slice.null?.should be_false
+      slice.valid?.should be_false
+    end
+  end
+end
diff --git a/core/io/buffer/initialize_spec.rb b/core/io/buffer/initialize_spec.rb
new file mode 100644
index 000000000..c86d1e7f1
--- /dev/null
+++ b/core/io/buffer/initialize_spec.rb
@@ -0,0 +1,103 @@
+require_relative '../../../spec_helper'
+
+describe "IO::Buffer#initialize" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  it "creates a new zero-filled buffer with default size" do
+    @buffer = IO::Buffer.new
+    @buffer.size.should == IO::Buffer::DEFAULT_SIZE
+    @buffer.each(:U8).should.all? { |_offset, value| value.eql?(0) }
+  end
+
+  it "creates a buffer with default state" do
+    @buffer = IO::Buffer.new
+    @buffer.should_not.shared?
+    @buffer.should_not.readonly?
+
+    @buffer.should_not.empty?
+    @buffer.should_not.null?
+
+    # This is run-time state, set by #locked.
+    @buffer.should_not.locked?
+  end
+
+  context "with size argument" do
+    it "creates a new internal buffer if size is less than IO::Buffer::PAGE_SIZE" do
+      size = IO::Buffer::PAGE_SIZE - 1
+      @buffer = IO::Buffer.new(size)
+      @buffer.size.should == size
+      @buffer.should.internal?
+      @buffer.should_not.mapped?
+      @buffer.should_not.empty?
+    end
+
+    it "creates a new mapped buffer if size is greater than or equal to IO::Buffer::PAGE_SIZE" do
+      size = IO::Buffer::PAGE_SIZE
+      @buffer = IO::Buffer.new(size)
+      @buffer.size.should == size
+      @buffer.should_not.internal?
+      @buffer.should.mapped?
+      @buffer.should_not.empty?
+    end
+
+    it "creates a null buffer if size is 0" do
+      @buffer = IO::Buffer.new(0)
+      @buffer.size.should.zero?
+      @buffer.should_not.internal?
+      @buffer.should_not.mapped?
+      @buffer.should.null?
+      @buffer.should.empty?
+    end
+
+    it "raises TypeError if size is not an Integer" do
+      -> { IO::Buffer.new(nil) }.should raise_error(TypeError, "not an Integer")
+      -> { IO::Buffer.new(10.0) }.should raise_error(TypeError, "not an Integer")
+    end
+
+    it "raises ArgumentError if size is negative" do
+      -> { IO::Buffer.new(-1) }.should raise_error(ArgumentError, "Size can't be negative!")
+    end
+  end
+
+  context "with size and flags arguments" do
+    it "forces mapped buffer with IO::Buffer::MAPPED flag" do
+      @buffer = IO::Buffer.new(IO::Buffer::PAGE_SIZE - 1, IO::Buffer::MAPPED)
+      @buffer.should.mapped?
+      @buffer.should_not.internal?
+      @buffer.should_not.empty?
+    end
+
+    it "forces internal buffer with IO::Buffer::INTERNAL flag" do
+      @buffer = IO::Buffer.new(IO::Buffer::PAGE_SIZE, IO::Buffer::INTERNAL)
+      @buffer.should.internal?
+      @buffer.should_not.mapped?
+      @buffer.should_not.empty?
+    end
+
+    it "raises IO::Buffer::AllocationError if neither IO::Buffer::MAPPED nor IO::Buffer::INTERNAL is given" do
+      -> { IO::Buffer.new(10, IO::Buffer::READONLY) }.should raise_error(IO::Buffer::AllocationError, "Could not allocate buffer!")
+      -> { IO::Buffer.new(10, 0) }.should raise_error(IO::Buffer::AllocationError, "Could not allocate buffer!")
+    end
+
+    ruby_version_is "3.3" do
+      it "raises ArgumentError if flags is negative" do
+        -> { IO::Buffer.new(10, -1) }.should raise_error(ArgumentError, "Flags can't be negative!")
+      end
+    end
+
+    ruby_version_is ""..."3.3" do
+      it "raises IO::Buffer::AllocationError with non-Integer flags" do
+        -> { IO::Buffer.new(10, 0.0) }.should raise_error(IO::Buffer::AllocationError, "Could not allocate buffer!")
+      end
+    end
+
+    ruby_version_is "3.3" do
+      it "raises TypeError with non-Integer flags" do
+        -> { IO::Buffer.new(10, 0.0) }.should raise_error(TypeError, "not an Integer")
+      end
+    end
+  end
+end
diff --git a/core/io/buffer/internal_spec.rb b/core/io/buffer/internal_spec.rb
new file mode 100644
index 000000000..409699cc3
--- /dev/null
+++ b/core/io/buffer/internal_spec.rb
@@ -0,0 +1,108 @@
+require_relative '../../../spec_helper'
+
+describe "IO::Buffer#internal?" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  context "with a buffer created with .new" do
+    it "is true for an internal buffer" do
+      @buffer = IO::Buffer.new(4)
+      @buffer.internal?.should be_true
+    end
+
+    it "is false for a mapped buffer" do
+      @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+      @buffer.internal?.should be_false
+    end
+  end
+
+  context "with a file-backed buffer created with .map" do
+    it "is false for a regular mapping" do
+      File.open(__FILE__, "r") do |file|
+        @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+        @buffer.internal?.should be_false
+      end
+    end
+
+    ruby_version_is "3.3" do
+      it "is false for a private mapping" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY | IO::Buffer::PRIVATE)
+          @buffer.internal?.should be_false
+        end
+      end
+    end
+  end
+
+  context "with a String-backed buffer created with .for" do
+    it "is false for a buffer created without a block" do
+      @buffer = IO::Buffer.for("test")
+      @buffer.internal?.should be_false
+    end
+
+    it "is false for a buffer created with a block" do
+      IO::Buffer.for(+"test") do |buffer|
+        buffer.internal?.should be_false
+      end
+    end
+  end
+
+  ruby_version_is "3.3" do
+    context "with a String-backed buffer created with .string" do
+      it "is false" do
+        IO::Buffer.string(4) do |buffer|
+          buffer.internal?.should be_false
+        end
+      end
+    end
+  end
+
+  # Always false for slices
+  context "with a slice of a buffer" do
+    context "created with .new" do
+      it "is false when slicing an internal buffer" do
+        @buffer = IO::Buffer.new(4)
+        @buffer.slice.internal?.should be_false
+      end
+
+      it "is false when slicing a mapped buffer" do
+        @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+        @buffer.slice.internal?.should be_false
+      end
+    end
+
+    context "created with .map" do
+      it "is false" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+          @buffer.slice.internal?.should be_false
+        end
+      end
+    end
+
+    context "created with .for" do
+      it "is false when slicing a buffer created without a block" do
+        @buffer = IO::Buffer.for("test")
+        @buffer.slice.internal?.should be_false
+      end
+
+      it "is false when slicing a buffer created with a block" do
+        IO::Buffer.for(+"test") do |buffer|
+          buffer.slice.internal?.should be_false
+        end
+      end
+    end
+
+    ruby_version_is "3.3" do
+      context "created with .string" do
+        it "is false" do
+          IO::Buffer.string(4) do |buffer|
+            buffer.slice.internal?.should be_false
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/core/io/buffer/locked_spec.rb b/core/io/buffer/locked_spec.rb
new file mode 100644
index 000000000..4ffa569fd
--- /dev/null
+++ b/core/io/buffer/locked_spec.rb
@@ -0,0 +1,75 @@
+require_relative '../../../spec_helper'
+
+describe "IO::Buffer#locked" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  context "when buffer is locked" do
+    it "allows reading and writing operations on the buffer" do
+      @buffer = IO::Buffer.new(4)
+      @buffer.set_string("test")
+      @buffer.locked do
+        @buffer.get_string.should == "test"
+        @buffer.set_string("meat")
+      end
+      @buffer.get_string.should == "meat"
+    end
+
+    it "disallows operations changing buffer itself, raising IO::Buffer::LockedError" do
+      @buffer = IO::Buffer.new(4)
+      @buffer.locked do
+        # Just an example, each method is responsible for checking the lock state.
+        -> { @buffer.resize(8) }.should raise_error(IO::Buffer::LockedError)
+      end
+    end
+  end
+
+  it "disallows reentrant locking, raising IO::Buffer::LockedError" do
+    @buffer = IO::Buffer.new(4)
+    @buffer.locked do
+      -> { @buffer.locked {} }.should raise_error(IO::Buffer::LockedError, "Buffer already locked!")
+    end
+  end
+
+  it "does not propagate to buffer's slices" do
+    @buffer = IO::Buffer.new(4)
+    slice = @buffer.slice(0, 2)
+    @buffer.locked do
+      @buffer.locked?.should be_true
+      slice.locked?.should be_false
+      slice.locked { slice.locked?.should be_true }
+    end
+  end
+
+  it "does not propagate backwards from buffer's slices" do
+    @buffer = IO::Buffer.new(4)
+    slice = @buffer.slice(0, 2)
+    slice.locked do
+      slice.locked?.should be_true
+      @buffer.locked?.should be_false
+      @buffer.locked { @buffer.locked?.should be_true }
+    end
+  end
+end
+
+describe "IO::Buffer#locked?" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  it "is false by default" do
+    @buffer = IO::Buffer.new(4)
+    @buffer.locked?.should be_false
+  end
+
+  it "is true only inside of #locked block" do
+    @buffer = IO::Buffer.new(4)
+    @buffer.locked do
+      @buffer.locked?.should be_true
+    end
+    @buffer.locked?.should be_false
+  end
+end
diff --git a/core/io/buffer/mapped_spec.rb b/core/io/buffer/mapped_spec.rb
new file mode 100644
index 000000000..b3610207f
--- /dev/null
+++ b/core/io/buffer/mapped_spec.rb
@@ -0,0 +1,108 @@
+require_relative '../../../spec_helper'
+
+describe "IO::Buffer#mapped?" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  context "with a buffer created with .new" do
+    it "is false for an internal buffer" do
+      @buffer = IO::Buffer.new(4)
+      @buffer.mapped?.should be_false
+    end
+
+    it "is true for a mapped buffer" do
+      @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+      @buffer.mapped?.should be_true
+    end
+  end
+
+  context "with a file-backed buffer created with .map" do
+    it "is true for a regular mapping" do
+      File.open(__FILE__, "r") do |file|
+        @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+        @buffer.mapped?.should be_true
+      end
+    end
+
+    ruby_version_is "3.3" do
+      it "is true for a private mapping" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY | IO::Buffer::PRIVATE)
+          @buffer.mapped?.should be_true
+        end
+      end
+    end
+  end
+
+  context "with a String-backed buffer created with .for" do
+    it "is false for a buffer created without a block" do
+      @buffer = IO::Buffer.for("test")
+      @buffer.mapped?.should be_false
+    end
+
+    it "is false for a buffer created with a block" do
+      IO::Buffer.for(+"test") do |buffer|
+        buffer.mapped?.should be_false
+      end
+    end
+  end
+
+  ruby_version_is "3.3" do
+    context "with a String-backed buffer created with .string" do
+      it "is false" do
+        IO::Buffer.string(4) do |buffer|
+          buffer.mapped?.should be_false
+        end
+      end
+    end
+  end
+
+  # Always false for slices
+  context "with a slice of a buffer" do
+    context "created with .new" do
+      it "is false when slicing an internal buffer" do
+        @buffer = IO::Buffer.new(4)
+        @buffer.slice.mapped?.should be_false
+      end
+
+      it "is false when slicing a mapped buffer" do
+        @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+        @buffer.slice.mapped?.should be_false
+      end
+    end
+
+    context "created with .map" do
+      it "is false" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+          @buffer.slice.mapped?.should be_false
+        end
+      end
+    end
+
+    context "created with .for" do
+      it "is false when slicing a buffer created without a block" do
+        @buffer = IO::Buffer.for("test")
+        @buffer.slice.mapped?.should be_false
+      end
+
+      it "is false when slicing a buffer created with a block" do
+        IO::Buffer.for(+"test") do |buffer|
+          buffer.slice.mapped?.should be_false
+        end
+      end
+    end
+
+    ruby_version_is "3.3" do
+      context "created with .string" do
+        it "is false" do
+          IO::Buffer.string(4) do |buffer|
+            buffer.slice.mapped?.should be_false
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/core/io/buffer/null_spec.rb b/core/io/buffer/null_spec.rb
new file mode 100644
index 000000000..3fb1144d0
--- /dev/null
+++ b/core/io/buffer/null_spec.rb
@@ -0,0 +1,29 @@
+require_relative '../../../spec_helper'
+require_relative 'shared/null_and_empty'
+
+describe "IO::Buffer#null?" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  it_behaves_like :io_buffer_null_and_empty, :null?
+
+  it "is false for a 0-length String-backed buffer created with .for" do
+    @buffer = IO::Buffer.for("")
+    @buffer.null?.should be_false
+  end
+
+  ruby_version_is "3.3" do
+    it "is false for a 0-length String-backed buffer created with .string" do
+      IO::Buffer.string(0) do |buffer|
+        buffer.null?.should be_false
+      end
+    end
+  end
+
+  it "is false for a 0-length slice of a buffer with size > 0" do
+    @buffer = IO::Buffer.new(4)
+    @buffer.slice(3, 0).null?.should be_false
+  end
+end
diff --git a/core/io/buffer/private_spec.rb b/core/io/buffer/private_spec.rb
new file mode 100644
index 000000000..7aa308997
--- /dev/null
+++ b/core/io/buffer/private_spec.rb
@@ -0,0 +1,111 @@
+require_relative '../../../spec_helper'
+
+ruby_version_is "3.3" do
+  describe "IO::Buffer#private?" do
+    after :each do
+      @buffer&.free
+      @buffer = nil
+    end
+
+    context "with a buffer created with .new" do
+      it "is false for an internal buffer" do
+        @buffer = IO::Buffer.new(4, IO::Buffer::INTERNAL)
+        @buffer.private?.should be_false
+      end
+
+      it "is false for a mapped buffer" do
+        @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+        @buffer.private?.should be_false
+      end
+    end
+
+    context "with a file-backed buffer created with .map" do
+      it "is false for a regular mapping" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+          @buffer.private?.should be_false
+        end
+      end
+
+      it "is true for a private mapping" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY | IO::Buffer::PRIVATE)
+          @buffer.private?.should be_true
+        end
+      end
+    end
+
+    context "with a String-backed buffer created with .for" do
+      it "is false for a buffer created without a block" do
+        @buffer = IO::Buffer.for("test")
+        @buffer.private?.should be_false
+      end
+
+      it "is false for a buffer created with a block" do
+        IO::Buffer.for(+"test") do |buffer|
+          buffer.private?.should be_false
+        end
+      end
+    end
+
+    context "with a String-backed buffer created with .string" do
+      it "is false" do
+        IO::Buffer.string(4) do |buffer|
+          buffer.private?.should be_false
+        end
+      end
+    end
+
+    # Always false for slices
+    context "with a slice of a buffer" do
+      context "created with .new" do
+        it "is false when slicing an internal buffer" do
+          @buffer = IO::Buffer.new(4)
+          @buffer.slice.private?.should be_false
+        end
+
+        it "is false when slicing a mapped buffer" do
+          @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+          @buffer.slice.private?.should be_false
+        end
+      end
+
+      context "created with .map" do
+        it "is false when slicing a regular file-backed buffer" do
+          File.open(__FILE__, "r") do |file|
+            @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+            @buffer.slice.private?.should be_false
+          end
+        end
+
+        it "is false when slicing a private file-backed buffer" do
+          File.open(__FILE__, "r") do |file|
+            @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY | IO::Buffer::PRIVATE)
+            @buffer.slice.private?.should be_false
+          end
+        end
+      end
+
+      context "created with .for" do
+        it "is false when slicing a buffer created without a block" do
+          @buffer = IO::Buffer.for("test")
+          @buffer.slice.private?.should be_false
+        end
+
+        it "is false when slicing a buffer created with a block" do
+          IO::Buffer.for(+"test") do |buffer|
+            buffer.slice.private?.should be_false
+          end
+        end
+      end
+
+      context "created with .string" do
+        it "is false" do
+          IO::Buffer.string(4) do |buffer|
+            buffer.slice.private?.should be_false
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/core/io/buffer/readonly_spec.rb b/core/io/buffer/readonly_spec.rb
new file mode 100644
index 000000000..0014a876e
--- /dev/null
+++ b/core/io/buffer/readonly_spec.rb
@@ -0,0 +1,143 @@
+require_relative '../../../spec_helper'
+
+describe "IO::Buffer#readonly?" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  context "with a buffer created with .new" do
+    it "is false for an internal buffer" do
+      @buffer = IO::Buffer.new(4, IO::Buffer::INTERNAL)
+      @buffer.readonly?.should be_false
+    end
+
+    it "is false for a mapped buffer" do
+      @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+      @buffer.readonly?.should be_false
+    end
+  end
+
+  context "with a file-backed buffer created with .map" do
+    it "is false for a writable mapping" do
+      File.open(__FILE__, "r+") do |file|
+        @buffer = IO::Buffer.map(file)
+        @buffer.readonly?.should be_false
+      end
+    end
+
+    it "is true for a readonly mapping" do
+      File.open(__FILE__, "r") do |file|
+        @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+        @buffer.readonly?.should be_true
+      end
+    end
+
+    ruby_version_is "3.3" do
+      it "is false for a private mapping" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::PRIVATE)
+          @buffer.readonly?.should be_false
+        end
+      end
+    end
+  end
+
+  context "with a String-backed buffer created with .for" do
+    it "is true for a buffer created without a block" do
+      @buffer = IO::Buffer.for(+"test")
+      @buffer.readonly?.should be_true
+    end
+
+    it "is false for a buffer created with a block" do
+      IO::Buffer.for(+"test") do |buffer|
+        buffer.readonly?.should be_false
+      end
+    end
+
+    it "is true for a buffer created with a block from a frozen string" do
+      IO::Buffer.for(-"test") do |buffer|
+        buffer.readonly?.should be_true
+      end
+    end
+  end
+
+  ruby_version_is "3.3" do
+    context "with a String-backed buffer created with .string" do
+      it "is false" do
+        IO::Buffer.string(4) do |buffer|
+          buffer.readonly?.should be_false
+        end
+      end
+    end
+  end
+
+  # This seems to be the only flag propagated from the source buffer to the slice.
+  context "with a slice of a buffer" do
+    context "created with .new" do
+      it "is false when slicing an internal buffer" do
+        @buffer = IO::Buffer.new(4)
+        @buffer.slice.readonly?.should be_false
+      end
+
+      it "is false when slicing a mapped buffer" do
+        @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+        @buffer.slice.readonly?.should be_false
+      end
+    end
+
+    context "created with .map" do
+      it "is false when slicing a read-write file-backed buffer" do
+        File.open(__FILE__, "r+") do |file|
+          @buffer = IO::Buffer.map(file)
+          @buffer.slice.readonly?.should be_false
+        end
+      end
+
+      it "is true when slicing a readonly file-backed buffer" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+          @buffer.slice.readonly?.should be_true
+        end
+      end
+
+      ruby_version_is "3.3" do
+        it "is false when slicing a private file-backed buffer" do
+          File.open(__FILE__, "r") do |file|
+            @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::PRIVATE)
+            @buffer.slice.readonly?.should be_false
+          end
+        end
+      end
+    end
+
+    context "created with .for" do
+      it "is true when slicing a buffer created without a block" do
+        @buffer = IO::Buffer.for(+"test")
+        @buffer.slice.readonly?.should be_true
+      end
+
+      it "is false when slicing a buffer created with a block" do
+        IO::Buffer.for(+"test") do |buffer|
+          buffer.slice.readonly?.should be_false
+        end
+      end
+
+      it "is true when slicing a buffer created with a block from a frozen string" do
+        IO::Buffer.for(-"test") do |buffer|
+          buffer.slice.readonly?.should be_true
+        end
+      end
+    end
+
+    ruby_version_is "3.3" do
+      context "created with .string" do
+        it "is false" do
+          IO::Buffer.string(4) do |buffer|
+            buffer.slice.readonly?.should be_false
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/core/io/buffer/resize_spec.rb b/core/io/buffer/resize_spec.rb
new file mode 100644
index 000000000..0da3a2335
--- /dev/null
+++ b/core/io/buffer/resize_spec.rb
@@ -0,0 +1,155 @@
+require_relative '../../../spec_helper'
+
+describe "IO::Buffer#resize" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  context "with a buffer created with .new" do
+    it "resizes internal buffer, preserving type" do
+      @buffer = IO::Buffer.new(4)
+      @buffer.resize(IO::Buffer::PAGE_SIZE)
+      @buffer.size.should == IO::Buffer::PAGE_SIZE
+      @buffer.internal?.should be_true
+      @buffer.mapped?.should be_false
+    end
+
+    platform_is :linux do
+      it "resizes mapped buffer, preserving type" do
+        @buffer = IO::Buffer.new(IO::Buffer::PAGE_SIZE, IO::Buffer::MAPPED)
+        @buffer.resize(4)
+        @buffer.size.should == 4
+        @buffer.internal?.should be_false
+        @buffer.mapped?.should be_true
+      end
+    end
+
+    platform_is_not :linux do
+      it "resizes mapped buffer, changing type to internal" do
+        @buffer = IO::Buffer.new(IO::Buffer::PAGE_SIZE, IO::Buffer::MAPPED)
+        @buffer.resize(4)
+        @buffer.size.should == 4
+        @buffer.internal?.should be_true
+        @buffer.mapped?.should be_false
+      end
+    end
+  end
+
+  context "with a file-backed buffer created with .map" do
+    it "disallows resizing shared buffer, raising IO::Buffer::AccessError" do
+      File.open(__FILE__, "r+") do |file|
+        @buffer = IO::Buffer.map(file)
+        -> { @buffer.resize(10) }.should raise_error(IO::Buffer::AccessError, "Cannot resize external buffer!")
+      end
+    end
+
+    ruby_version_is "3.3" do
+      it "resizes private buffer, discarding excess contents" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::PRIVATE)
+          @buffer.resize(10)
+          @buffer.size.should == 10
+          @buffer.get_string.should == "require_re"
+          @buffer.resize(12)
+          @buffer.size.should == 12
+          @buffer.get_string.should == "require_re\0\0"
+        end
+      end
+    end
+  end
+
+  context "with a String-backed buffer created with .for" do
+    context "without a block" do
+      it "disallows resizing, raising IO::Buffer::AccessError" do
+        @buffer = IO::Buffer.for(+"test")
+        -> { @buffer.resize(10) }.should raise_error(IO::Buffer::AccessError, "Cannot resize external buffer!")
+      end
+    end
+
+    context "with a block" do
+      it "disallows resizing, raising IO::Buffer::AccessError" do
+        IO::Buffer.for(+'test') do |buffer|
+          -> { buffer.resize(10) }.should raise_error(IO::Buffer::AccessError, "Cannot resize external buffer!")
+        end
+      end
+    end
+  end
+
+  ruby_version_is "3.3" do
+    context "with a String-backed buffer created with .string" do
+      it "disallows resizing, raising IO::Buffer::AccessError" do
+        IO::Buffer.string(4) do |buffer|
+          -> { buffer.resize(10) }.should raise_error(IO::Buffer::AccessError, "Cannot resize external buffer!")
+        end
+      end
+    end
+  end
+
+  context "with a null buffer" do
+    it "allows resizing a 0-sized buffer, creating a regular buffer according to new size" do
+      @buffer = IO::Buffer.new(0)
+      @buffer.resize(IO::Buffer::PAGE_SIZE)
+      @buffer.size.should == IO::Buffer::PAGE_SIZE
+      @buffer.internal?.should be_false
+      @buffer.mapped?.should be_true
+    end
+
+    it "allows resizing after a free, creating a regular buffer according to new size" do
+      @buffer = IO::Buffer.for("test")
+      @buffer.free
+      @buffer.resize(10)
+      @buffer.size.should == 10
+      @buffer.internal?.should be_true
+      @buffer.mapped?.should be_false
+    end
+  end
+
+  it "allows resizing to 0, freeing memory" do
+    @buffer = IO::Buffer.new(4)
+    @buffer.resize(0)
+    @buffer.null?.should be_true
+  end
+
+  it "can be called repeatedly" do
+    @buffer = IO::Buffer.new(4)
+    @buffer.resize(10)
+    @buffer.resize(27)
+    @buffer.resize(1)
+    @buffer.size.should == 1
+  end
+
+  it "always clears extra memory" do
+    @buffer = IO::Buffer.new(4)
+    @buffer.set_string("test")
+    # This should not cause a re-allocation, just a technical resizing,
+    # even with very aggressive memory allocation.
+    @buffer.resize(2)
+    @buffer.resize(4)
+    @buffer.get_string.should == "te\0\0"
+  end
+
+  it "is disallowed while locked, raising IO::Buffer::LockedError" do
+    @buffer = IO::Buffer.new(4)
+    @buffer.locked do
+      -> { @buffer.resize(10) }.should raise_error(IO::Buffer::LockedError, "Cannot resize locked buffer!")
+    end
+  end
+
+  it "raises ArgumentError if size is negative" do
+    @buffer = IO::Buffer.new(4)
+    -> { @buffer.resize(-1) }.should raise_error(ArgumentError, "Size can't be negative!")
+  end
+
+  it "raises TypeError if size is not an Integer" do
+    @buffer = IO::Buffer.new(4)
+    -> { @buffer.resize(nil) }.should raise_error(TypeError, "not an Integer")
+    -> { @buffer.resize(10.0) }.should raise_error(TypeError, "not an Integer")
+  end
+
+  context "with a slice of a buffer" do
+    # Current behavior of slice resizing seems unintended (it's undocumented, too).
+    # It either creates a completely new buffer, or breaks the slice on size 0.
+    it "needs to be reviewed for spec completeness"
+  end
+end
diff --git a/core/io/buffer/shared/null_and_empty.rb b/core/io/buffer/shared/null_and_empty.rb
new file mode 100644
index 000000000..c8fe9e5e4
--- /dev/null
+++ b/core/io/buffer/shared/null_and_empty.rb
@@ -0,0 +1,59 @@
+describe :io_buffer_null_and_empty, shared: true do
+  it "is false for a buffer with size > 0" do
+    @buffer = IO::Buffer.new(1)
+    @buffer.send(@method).should be_false
+  end
+
+  it "is false for a slice with length > 0" do
+    @buffer = IO::Buffer.new(4)
+    @buffer.slice(1, 2).send(@method).should be_false
+  end
+
+  it "is false for a file-mapped buffer" do
+    File.open(__FILE__, "rb") do |file|
+      @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+      @buffer.send(@method).should be_false
+    end
+  end
+
+  it "is false for a non-empty String-backed buffer created with .for" do
+    @buffer = IO::Buffer.for("test")
+    @buffer.send(@method).should be_false
+  end
+
+  ruby_version_is "3.3" do
+    it "is false for a non-empty String-backed buffer created with .string" do
+      IO::Buffer.string(4) do |buffer|
+        buffer.send(@method).should be_false
+      end
+    end
+  end
+
+  it "is true for a 0-sized buffer" do
+    @buffer = IO::Buffer.new(0)
+    @buffer.send(@method).should be_true
+  end
+
+  it "is true for a slice of a 0-sized buffer" do
+    @buffer = IO::Buffer.new(0)
+    @buffer.slice(0, 0).send(@method).should be_true
+  end
+
+  it "is true for a freed buffer" do
+    @buffer = IO::Buffer.new(1)
+    @buffer.free
+    @buffer.send(@method).should be_true
+  end
+
+  it "is true for a buffer resized to 0" do
+    @buffer = IO::Buffer.new(1)
+    @buffer.resize(0)
+    @buffer.send(@method).should be_true
+  end
+
+  it "is true for a buffer whose memory was transferred" do
+    buffer = IO::Buffer.new(1)
+    @buffer = buffer.transfer
+    buffer.send(@method).should be_true
+  end
+end
diff --git a/core/io/buffer/shared_spec.rb b/core/io/buffer/shared_spec.rb
new file mode 100644
index 000000000..f2a638cf3
--- /dev/null
+++ b/core/io/buffer/shared_spec.rb
@@ -0,0 +1,117 @@
+require_relative '../../../spec_helper'
+
+describe "IO::Buffer#shared?" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  context "with a buffer created with .new" do
+    it "is false for an internal buffer" do
+      @buffer = IO::Buffer.new(4, IO::Buffer::INTERNAL)
+      @buffer.shared?.should be_false
+    end
+
+    it "is false for a mapped buffer" do
+      @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+      @buffer.shared?.should be_false
+    end
+  end
+
+  context "with a file-backed buffer created with .map" do
+    it "is true for a regular mapping" do
+      File.open(__FILE__, "r") do |file|
+        @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+        @buffer.shared?.should be_true
+      end
+    end
+
+    ruby_version_is "3.3" do
+      it "is false for a private mapping" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY | IO::Buffer::PRIVATE)
+          @buffer.shared?.should be_false
+        end
+      end
+    end
+  end
+
+  context "with a String-backed buffer created with .for" do
+    it "is false for a buffer created without a block" do
+      @buffer = IO::Buffer.for("test")
+      @buffer.shared?.should be_false
+    end
+
+    it "is false for a buffer created with a block" do
+      IO::Buffer.for(+"test") do |buffer|
+        buffer.shared?.should be_false
+      end
+    end
+  end
+
+  ruby_version_is "3.3" do
+    context "with a String-backed buffer created with .string" do
+      it "is false" do
+        IO::Buffer.string(4) do |buffer|
+          buffer.shared?.should be_false
+        end
+      end
+    end
+  end
+
+  # Always false for slices
+  context "with a slice of a buffer" do
+    context "created with .new" do
+      it "is false when slicing an internal buffer" do
+        @buffer = IO::Buffer.new(4)
+        @buffer.slice.shared?.should be_false
+      end
+
+      it "is false when slicing a mapped buffer" do
+        @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+        @buffer.slice.shared?.should be_false
+      end
+    end
+
+    context "created with .map" do
+      it "is false when slicing a regular file-backed buffer" do
+        File.open(__FILE__, "r") do |file|
+          @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+          @buffer.slice.shared?.should be_false
+        end
+      end
+
+      ruby_version_is "3.3" do
+        it "is false when slicing a private file-backed buffer" do
+          File.open(__FILE__, "r") do |file|
+            @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY | IO::Buffer::PRIVATE)
+            @buffer.slice.shared?.should be_false
+          end
+        end
+      end
+    end
+
+    context "created with .for" do
+      it "is false when slicing a buffer created without a block" do
+        @buffer = IO::Buffer.for("test")
+        @buffer.slice.shared?.should be_false
+      end
+
+      it "is false when slicing a buffer created with a block" do
+        IO::Buffer.for(+"test") do |buffer|
+          buffer.slice.shared?.should be_false
+        end
+      end
+    end
+
+    ruby_version_is "3.3" do
+      context "created with .string" do
+        it "is false" do
+          IO::Buffer.string(4) do |buffer|
+            buffer.slice.shared?.should be_false
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/core/io/buffer/transfer_spec.rb b/core/io/buffer/transfer_spec.rb
new file mode 100644
index 000000000..cb8c843ff
--- /dev/null
+++ b/core/io/buffer/transfer_spec.rb
@@ -0,0 +1,118 @@
+require_relative '../../../spec_helper'
+
+describe "IO::Buffer#transfer" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  context "with a buffer created with .new" do
+    it "transfers internal memory to a new buffer, nullifying the original" do
+      buffer = IO::Buffer.new(4)
+      info = buffer.to_s
+      @buffer = buffer.transfer
+      @buffer.to_s.should == info
+      buffer.null?.should be_true
+    end
+
+    it "transfers mapped memory to a new buffer, nullifying the original" do
+      buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+      info = buffer.to_s
+      @buffer = buffer.transfer
+      @buffer.to_s.should == info
+      buffer.null?.should be_true
+    end
+  end
+
+  context "with a file-backed buffer created with .map" do
+    it "transfers mapped memory to a new buffer, nullifying the original" do
+      File.open(__FILE__, "r") do |file|
+        buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+        info = buffer.to_s
+        @buffer = buffer.transfer
+        @buffer.to_s.should == info
+        buffer.null?.should be_true
+      end
+    end
+  end
+
+  context "with a String-backed buffer created with .for" do
+    context "without a block" do
+      it "transfers memory to a new buffer, nullifying the original" do
+        buffer = IO::Buffer.for("test")
+        info = buffer.to_s
+        @buffer = buffer.transfer
+        @buffer.to_s.should == info
+        buffer.null?.should be_true
+      end
+    end
+
+    context "with a block" do
+      it "transfers memory to a new buffer, breaking the transaction by nullifying the original" do
+        IO::Buffer.for(+"test") do |buffer|
+          info = buffer.to_s
+          @buffer = buffer.transfer
+          @buffer.to_s.should == info
+          buffer.null?.should be_true
+        end
+        @buffer.null?.should be_false
+      end
+    end
+  end
+
+  ruby_version_is "3.3" do
+    context "with a String-backed buffer created with .string" do
+      it "transfers memory to a new buffer, breaking the transaction by nullifying the original" do
+        IO::Buffer.string(4) do |buffer|
+          info = buffer.to_s
+          @buffer = buffer.transfer
+          @buffer.to_s.should == info
+          buffer.null?.should be_true
+        end
+        @buffer.null?.should be_false
+      end
+    end
+  end
+
+  it "allows multiple transfers" do
+    buffer_1 = IO::Buffer.new(4)
+    buffer_2 = buffer_1.transfer
+    @buffer = buffer_2.transfer
+    buffer_1.null?.should be_true
+    buffer_2.null?.should be_true
+    @buffer.null?.should be_false
+  end
+
+  it "is disallowed while locked, raising IO::Buffer::LockedError" do
+    @buffer = IO::Buffer.new(4)
+    @buffer.locked do
+      -> { @buffer.transfer }.should raise_error(IO::Buffer::LockedError, "Cannot transfer ownership of locked buffer!")
+    end
+  end
+
+  context "with a slice of a buffer" do
+    it "transfers source to a new slice, not touching the buffer" do
+      @buffer = IO::Buffer.new(4)
+      slice = @buffer.slice(0, 2)
+      @buffer.set_string("test")
+
+      new_slice = slice.transfer
+      slice.null?.should be_true
+      new_slice.null?.should be_false
+      @buffer.null?.should be_false
+
+      new_slice.set_string("ea")
+      @buffer.get_string.should == "east"
+    end
+
+    it "nullifies buffer, invalidating the slice" do
+      buffer = IO::Buffer.new(4)
+      slice = buffer.slice(0, 2)
+      @buffer = buffer.transfer
+
+      slice.null?.should be_false
+      slice.valid?.should be_false
+      -> { slice.get_string }.should raise_error(IO::Buffer::InvalidatedError, "Buffer has been invalidated!")
+    end
+  end
+end
diff --git a/core/io/buffer/valid_spec.rb b/core/io/buffer/valid_spec.rb
new file mode 100644
index 000000000..695415dff
--- /dev/null
+++ b/core/io/buffer/valid_spec.rb
@@ -0,0 +1,119 @@
+require_relative '../../../spec_helper'
+
+describe "IO::Buffer#valid?" do
+  after :each do
+    @buffer&.free
+    @buffer = nil
+  end
+
+  # Non-slices are always valid
+  context "with a non-slice buffer" do
+    it "is true for a regular buffer" do
+      @buffer = IO::Buffer.new(4)
+      @buffer.valid?.should be_true
+    end
+
+    it "is true for a 0-size buffer" do
+      @buffer = IO::Buffer.new(0)
+      @buffer.valid?.should be_true
+    end
+
+    it "is true for a freed buffer" do
+      @buffer = IO::Buffer.new(4)
+      @buffer.free
+      @buffer.valid?.should be_true
+    end
+
+    it "is true for a freed file-backed buffer" do
+      File.open(__FILE__, "r") do |file|
+        @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+        @buffer.valid?.should be_true
+        @buffer.free
+        @buffer.valid?.should be_true
+      end
+    end
+
+    it "is true for a freed string-backed buffer" do
+      @buffer = IO::Buffer.for("hello")
+      @buffer.valid?.should be_true
+      @buffer.free
+      @buffer.valid?.should be_true
+    end
+  end
+
+  # "A buffer becomes invalid if it is a slice of another buffer (or string)
+  # which has been freed or re-allocated at a different address."
+  context "with a slice" do
+    it "is true for a slice of a live buffer" do
+      @buffer = IO::Buffer.new(4)
+      slice = @buffer.slice(0, 2)
+      slice.valid?.should be_true
+    end
+
+    context "when buffer is resized" do
+      platform_is_not :windows do
+        it "is true when slice is still inside the buffer" do
+          @buffer = IO::Buffer.new(4)
+          slice = @buffer.slice(1, 2)
+          @buffer.resize(3)
+          slice.valid?.should be_true
+        end
+      end
+
+      it "is false when slice becomes outside the buffer" do
+        @buffer = IO::Buffer.new(4)
+        slice = @buffer.slice(2, 2)
+        @buffer.resize(3)
+        slice.valid?.should be_false
+      end
+
+      platform_is_not :linux do
+        # This test does not cause a copy-resize on Linux.
+        # `#resize` MAY cause the buffer to move, but there is no guarantee.
+        it "is false when buffer is copied on resize" do
+          @buffer = IO::Buffer.new(4, IO::Buffer::MAPPED)
+          slice = @buffer.slice(0, 2)
+          @buffer.resize(8)
+          slice.valid?.should be_false
+        end
+      end
+    end
+
+    it "is false for a slice of a transferred buffer" do
+      buffer = IO::Buffer.new(4)
+      slice = buffer.slice(0, 2)
+      @buffer = buffer.transfer
+      slice.valid?.should be_false
+    end
+
+    it "is false for a slice of a freed buffer" do
+      @buffer = IO::Buffer.new(4)
+      slice = @buffer.slice(0, 2)
+      @buffer.free
+      slice.valid?.should be_false
+    end
+
+    it "is false for a slice of a freed file-backed buffer" do
+      File.open(__FILE__, "r") do |file|
+        @buffer = IO::Buffer.map(file, nil, 0, IO::Buffer::READONLY)
+        slice = @buffer.slice(0, 2)
+        slice.valid?.should be_true
+        @buffer.free
+        slice.valid?.should be_false
+      end
+    end
+
+    it "is true for a slice of a freed string-backed buffer while string is alive" do
+      @buffer = IO::Buffer.for("alive")
+      slice = @buffer.slice(0, 2)
+      slice.valid?.should be_true
+      @buffer.free
+      slice.valid?.should be_true
+    end
+
+    # There probably should be a test with a garbage-collected string,
+    # but it's not clear how to force that.
+
+    it "needs to be reviewed for spec completeness"
+  end
+end