tg_geometry 0.1.0

data/spec/block_20_concurrency_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Release Core Block 20 concurrency hardening" do
+  let(:zone_a) { '{"type":"Polygon","coordinates":[[[0,0],[10,0],[10,10],[0,10],[0,0]]]}' }
+  let(:zone_b) { '{"type":"Polygon","coordinates":[[[5,5],[15,5],[15,15],[5,15],[5,5]]]}' }
+  let(:zone_c) { '{"type":"Polygon","coordinates":[[[100,100],[110,100],[110,110],[100,110],[100,100]]]}' }
+
+  let(:entries) do
+    [
+      [:zone_a, zone_a],
+      [:zone_b, zone_b],
+      [:zone_c, zone_c]
+    ]
+  end
+
+  describe "multi-thread read-only queries on a single Index" do
+    %i[flat rtree].each do |strategy|
+      it "returns identical results across many threads for strategy: #{strategy}" do
+        index = TG::Geometry::Index.build(entries, via: :geojson, strategy: strategy)
+
+        query_points = Array.new(200) do |q|
+          [(q % 200) / 10.0, ((q * 7) % 200) / 10.0]
+        end
+
+        thread_count = 8
+        iterations_per_thread = 50
+
+        threads = thread_count.times.map do
+          Thread.new do
+            results = []
+            iterations_per_thread.times do
+              query_points.each do |lon, lat|
+                results << [
+                  index.find_covering(lon, lat),
+                  index.covering_ids(lon, lat),
+                  index.intersecting_rect(lon, lat, lon + 1.0, lat + 1.0)
+                ]
+              end
+            end
+            results
+          end
+        end
+
+        results_per_thread = threads.map(&:value)
+
+        expect(results_per_thread.uniq.length).to eq(1)
+        expect(results_per_thread.first.length).to eq(iterations_per_thread * query_points.length)
+      end
+    end
+
+    it "preserves Ruby id object identity under concurrent reads with GC.compact" do
+      index = TG::Geometry::Index.build(entries, via: :geojson, strategy: :rtree)
+      expected = entries.map(&:first)
+
+      compactor = Thread.new do
+        10.times do
+          GC.start
+          GC.compact if GC.respond_to?(:compact)
+          sleep 0.001
+        end
+      end
+
+      readers = 4.times.map do
+        Thread.new do
+          1_000.times do
+            ids = index.covering_ids(7.0, 7.0)
+            ids.each do |id|
+              raise "unexpected id: #{id.inspect}" unless expected.include?(id)
+            end
+          end
+        end
+      end
+
+      compactor.join
+      readers.each(&:join)
+    end
+  end
+
+  describe "reload pattern: old index survives while new index is swapped in" do
+    it "lets active readers finish on the old index after a new index replaces it" do
+      old_index = TG::Geometry::Index.build(entries, via: :geojson, strategy: :rtree)
+      registry = { current: old_index }
+
+      reader_stop = false
+      reader_errors = []
+      reader_observations = Queue.new
+
+      readers = 4.times.map do
+        Thread.new do
+          local = registry[:current]
+          until reader_stop
+            begin
+              reader_observations << local.find_covering(7, 7)
+              reader_observations << local.covering_ids(7, 7).length
+            rescue StandardError => e
+              reader_errors << e
+              reader_stop = true
+            end
+          end
+        end
+      end
+
+      sleep 0.01
+
+      new_entries = entries + [[:zone_d, zone_a]]
+      new_index = TG::Geometry::Index.build(new_entries, via: :geojson, strategy: :rtree)
+      registry[:current] = new_index
+
+      sleep 0.05
+
+      reader_stop = true
+      readers.each(&:join)
+
+      expect(reader_errors).to be_empty
+      expect(reader_observations.size).to be > 0
+      expect(old_index.size).to eq(3)
+      expect(old_index.find_covering(7, 7)).to eq(:zone_a)
+      expect(new_index.size).to eq(4)
+    end
+
+    it "lets the old index become collectable once readers release their reference" do
+      geom_a = TG::Geometry.parse_geojson(zone_a)
+      geom_b = TG::Geometry.parse_geojson(zone_b)
+
+      old_index = TG::Geometry::Index.build([[:old, geom_a]], via: :geom, strategy: :rtree)
+      new_index = TG::Geometry::Index.build([[:new_a, geom_a], [:new_b, geom_b]],
+                                             via: :geom, strategy: :rtree)
+
+      old_index = nil
+      GC.start
+      GC.compact if GC.respond_to?(:compact)
+      GC.start
+
+      expect(new_index.find_covering(5, 5)).to eq(:new_a)
+      expect(new_index.size).to eq(2)
+    end
+  end
+
+  describe "no mutation after build" do
+    it "exposes no public mutation methods on Index" do
+      index = TG::Geometry::Index.build(entries, via: :geojson, strategy: :rtree)
+
+      %i[add delete rebuild! clear << push add_entry append].each do |forbidden|
+        expect(index.respond_to?(forbidden)).to be(false), "Index must not respond to ##{forbidden}"
+      end
+    end
+
+    it "marks Index as frozen at the Ruby level" do
+      index = TG::Geometry::Index.build(entries, via: :geojson, strategy: :rtree)
+
+      expect(index).to be_frozen
+      expect { index.instance_variable_set(:@hacked, true) }.to raise_error(FrozenError)
+    end
+  end
+end

data/spec/block_20_fuzz_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "fileutils"
+
+RSpec.describe "Release Core Block 20 fuzz hardening" do
+  ITERATIONS = Integer(ENV.fetch("TG_GEOMETRY_FUZZ_ITERATIONS", "2000")).freeze
+  SEED = Integer(ENV.fetch("TG_GEOMETRY_FUZZ_SEED", "20260524")).freeze
+  CORPUS_DIR = File.expand_path("fixtures/fuzz_corpus", __dir__).freeze
+
+  ACCEPTABLE_ERRORS = [
+    TG::Geometry::ParseError,
+    TG::Geometry::ArgumentError,
+    ::ArgumentError,
+    ::EncodingError,
+    ::NoMemoryError,
+    ::SystemStackError
+  ].freeze
+
+  def acceptable?(error)
+    ACCEPTABLE_ERRORS.any? { |k| error.is_a?(k) }
+  end
+
+  def persist_failure(format, input, error)
+    FileUtils.mkdir_p(CORPUS_DIR)
+    digest = input.hash.abs.to_s(16)
+    path = File.join(CORPUS_DIR, "#{format}_#{digest}.bin")
+    File.binwrite(path, input)
+    warn "[fuzz] persisted crash input for #{format}: #{path} (#{error.class}: #{error.message[0, 80]})"
+  end
+
+  def feed(format, input)
+    case format
+    when :geojson then TG::Geometry.parse_geojson(input)
+    when :wkt     then TG::Geometry.parse_wkt(input)
+    when :wkb     then TG::Geometry.parse_wkb(input)
+    when :auto    then TG::Geometry.parse(input)
+    else raise ArgumentError, "unknown format #{format.inspect}"
+    end
+  end
+
+  def fuzz_one(format, input)
+    feed(format, input)
+    :parsed
+  rescue Exception => e # rubocop:disable Lint/RescueException
+    if acceptable?(e)
+      :rejected
+    else
+      persist_failure(format, input, e)
+      raise
+    end
+  end
+
+  shared_examples "fuzz parser" do |format|
+    it "tolerates random ASCII strings for #{format}" do
+      rng = Random.new(SEED + format.hash)
+      results = Hash.new(0)
+
+      ITERATIONS.times do
+        len = rng.rand(0..512)
+        input = Array.new(len) { rng.rand(32..126).chr }.join
+        results[fuzz_one(format, input)] += 1
+      end
+
+      expect(results.values.sum).to eq(ITERATIONS)
+    end
+
+    it "tolerates random raw bytes for #{format}" do
+      rng = Random.new(SEED + format.hash + 1)
+      results = Hash.new(0)
+
+      ITERATIONS.times do
+        len = rng.rand(0..512)
+        input = rng.bytes(len).force_encoding(Encoding::ASCII_8BIT)
+        results[fuzz_one(format, input)] += 1
+      end
+
+      expect(results.values.sum).to eq(ITERATIONS)
+    end
+
+    it "tolerates the empty string for #{format}" do
+      fuzz_one(format, "")
+    end
+
+    it "tolerates strings of NUL bytes for #{format}" do
+      [1, 16, 256, 4096].each do |size|
+        input = ("\x00" * size).force_encoding(Encoding::ASCII_8BIT)
+        fuzz_one(format, input)
+      end
+    end
+  end
+
+  include_examples "fuzz parser", :geojson
+  include_examples "fuzz parser", :wkt
+  include_examples "fuzz parser", :wkb
+  include_examples "fuzz parser", :auto
+
+  describe "deeply nested GeoJSON" do
+    it "rejects pathological nesting without stack-corrupting the process" do
+      input = ("{\"type\":\"GeometryCollection\",\"geometries\":[" * 1000) +
+              "{\"type\":\"Point\",\"coordinates\":[0,0]}" +
+              ("]}" * 1000)
+
+      fuzz_one(:geojson, input)
+    end
+
+    it "rejects deeply nested JSON arrays" do
+      depth = 5_000
+      input = ("[" * depth) + ("]" * depth)
+      fuzz_one(:geojson, input)
+    end
+  end
+
+  describe "huge inputs" do
+    it "tolerates a 1 MiB random WKB blob" do
+      rng = Random.new(SEED + 9999)
+      input = rng.bytes(1 << 20).force_encoding(Encoding::ASCII_8BIT)
+      fuzz_one(:wkb, input)
+    end
+
+    it "tolerates a 1 MiB random text blob via auto-detect" do
+      rng = Random.new(SEED + 8888)
+      bytes = rng.bytes(1 << 20)
+      input = bytes.tr("\x00-\x1f", " ").force_encoding(Encoding::UTF_8)
+      fuzz_one(:auto, input)
+    end
+  end
+
+  describe "regression corpus" do
+    it "re-parses every previously persisted crash input without crashing" do
+      skip "no corpus directory" unless Dir.exist?(CORPUS_DIR)
+
+      paths = Dir.glob(File.join(CORPUS_DIR, "*.bin"))
+      skip "corpus is empty" if paths.empty?
+
+      paths.each do |path|
+        format = File.basename(path).split("_", 2).first.to_sym
+        next unless %i[geojson wkt wkb auto].include?(format)
+
+        input = File.binread(path)
+        fuzz_one(format, input)
+      end
+    end
+  end
+end

data/spec/block_2_vendor_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "open3"
+require "tmpdir"
+
+RSpec.describe "Release Core Block 2 vendored build" do
+  let(:vendor_dir) { File.join(ROOT, "ext", "tg_geometry", "vendor") }
+
+  it "keeps tidwall/tg vendored under the contract path" do
+    %w[tg.c tg.h VERSION].each do |name|
+      expect(File.file?(File.join(vendor_dir, "tg", name))).to be(true), "missing vendor/tg/#{name}"
+    end
+  end
+
+  it "keeps rtree.c vendored under the contract path" do
+    %w[rtree.c rtree.h VERSION].each do |name|
+      expect(File.file?(File.join(vendor_dir, "rtree", name))).to be(true), "missing vendor/rtree/#{name}"
+    end
+  end
+
+  it "pins upstream commits in VERSION files" do
+    tg_version = File.read(File.join(vendor_dir, "tg", "VERSION"))
+    rtree_version = File.read(File.join(vendor_dir, "rtree", "VERSION"))
+
+    expect(tg_version).to include("repo=https://github.com/tidwall/tg.git")
+    expect(tg_version).to match(/commit=[0-9a-f]{40}/)
+    expect(rtree_version).to include("repo=https://github.com/tidwall/rtree.c.git")
+    expect(rtree_version).to match(/commit=[0-9a-f]{40}/)
+  end
+
+  it "verifies the vendor tree without network access" do
+    out, err, status = Open3.capture3(RbConfig.ruby, File.join(ROOT, "script", "vendor_libs.rb"), "--verify", chdir: ROOT)
+
+    expect(status).to be_success, err
+    expect(out).to include("vendor verify: ok")
+  end
+
+  it "skips network clone on sync when pinned vendor tree is already current" do
+    Dir.mktmpdir("tg-geometry-fake-git-") do |dir|
+      fake_git = File.join(dir, "git")
+      File.write(fake_git, "#!/bin/sh\necho git must not be called >&2\nexit 99\n")
+      File.chmod(0o755, fake_git)
+
+      env = { "PATH" => "#{dir}#{File::PATH_SEPARATOR}#{ENV.fetch('PATH', '')}" }
+      out, err, status = Open3.capture3(env, RbConfig.ruby, File.join(ROOT, "script", "vendor_libs.rb"), chdir: ROOT)
+
+      expect(status).to be_success, err
+      expect(out).to include("vendor sync: up to date")
+      expect(err).not_to include("git must not be called")
+    end
+  end
+
+  it "uses the release-core compiler warning flags" do
+    extconf = File.read(File.join(ROOT, "ext", "tg_geometry", "extconf.rb"))
+
+    expect(extconf).to include('"-std=c11"')
+    expect(extconf).to include('"-Wall"')
+    expect(extconf).to include('"-Wextra"')
+    expect(extconf).to include('"-Wpedantic"')
+    expect(extconf).to include('"-O2"')
+    expect(extconf).not_to include('"-Werror"')
+    expect(extconf).not_to include('"-fvisibility=hidden"')
+  end
+
+  it "does not define forbidden no-atomics macros" do
+    extconf = File.read(File.join(ROOT, "ext", "tg_geometry", "extconf.rb"))
+    c_extension = File.read(File.join(ROOT, "ext", "tg_geometry", "tg_geometry_ext.c"))
+
+    expect(extconf).not_to include("-DTG_NOATOMICS")
+    expect(extconf).not_to include("-DRTREE_NOATOMICS")
+    expect(c_extension).not_to include("rtree_opt_relaxed_atomics")
+  end
+
+  it "builds and loads the extension with vendored sources" do
+    expect(File.file?(EXT_SO)).to be(true)
+    expect(defined?(TG::Geometry)).to eq("constant")
+  end
+end

data/spec/block_3_geom_parse_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "objspace"
+
+RSpec.describe "Release Core Block 3 Geom parsing" do
+  let(:geojson_point) { %({"type":"Point","coordinates":[1.0,2.0]}) }
+  let(:wkt_point) { "POINT (1 2)" }
+  let(:wkb_point) { [1, 1].pack("CL<") + [1.0, 2.0].pack("E2") }
+  let(:wkb_point_hex) { wkb_point.unpack1("H*") }
+
+  it "parses GeoJSON into an immutable Geom" do
+    geom = TG::Geometry.parse_geojson(geojson_point)
+
+    expect(geom).to be_a(TG::Geometry::Geom)
+    expect(geom).to be_frozen
+  end
+
+  it "parses WKT into an immutable Geom" do
+    geom = TG::Geometry.parse_wkt(wkt_point)
+
+    expect(geom).to be_a(TG::Geometry::Geom)
+    expect(geom).to be_frozen
+  end
+
+  it "parses WKB into an immutable Geom" do
+    geom = TG::Geometry.parse_wkb(wkb_point)
+
+    expect(geom).to be_a(TG::Geometry::Geom)
+    expect(geom).to be_frozen
+  end
+
+  it "supports parse(format:) mapping for auto, GeoJSON, WKT, WKB, hex, and GeoBIN" do
+    expect(TG::Geometry.parse(geojson_point, format: :auto)).to be_a(TG::Geometry::Geom)
+    expect(TG::Geometry.parse(geojson_point, format: :geojson)).to be_a(TG::Geometry::Geom)
+    expect(TG::Geometry.parse(wkt_point, format: :wkt)).to be_a(TG::Geometry::Geom)
+    expect(TG::Geometry.parse(wkb_point, format: :wkb)).to be_a(TG::Geometry::Geom)
+    expect(TG::Geometry.parse(wkb_point_hex, format: :hex)).to be_a(TG::Geometry::Geom)
+    expect { TG::Geometry.parse("invalid geobin".b, format: :geobin) }
+      .to raise_error(TG::Geometry::ParseError)
+  end
+
+  it "supports index: symbol mapping" do
+    %i[default none natural ystripes].each do |index|
+      expect(TG::Geometry.parse_geojson(geojson_point, index: index)).to be_a(TG::Geometry::Geom)
+    end
+  end
+
+  it "raises TG::Geometry::ParseError for invalid GeoJSON" do
+    expect { TG::Geometry.parse_geojson("not json") }.to raise_error(TG::Geometry::ParseError)
+  end
+
+  it "raises TG::Geometry::ArgumentError for invalid format symbols" do
+    expect { TG::Geometry.parse(geojson_point, format: :shape) }
+      .to raise_error(TG::Geometry::ArgumentError)
+  end
+
+  it "raises TG::Geometry::ArgumentError for invalid index symbols" do
+    expect { TG::Geometry.parse_geojson(geojson_point, index: :packed) }
+      .to raise_error(TG::Geometry::ArgumentError)
+  end
+
+  it "reports native memory through ObjectSpace.memsize_of" do
+    geom = TG::Geometry.parse_geojson(geojson_point)
+
+    expect(ObjectSpace.memsize_of(geom)).to be > ObjectSpace.memsize_of(Object.new)
+  end
+
+  it "survives GC.stress parse/free lifecycle" do
+    old_stress = GC.stress
+    GC.stress = true
+
+    25.times do
+      expect(TG::Geometry.parse_wkt(wkt_point)).to be_frozen
+    end
+  ensure
+    GC.stress = old_stress
+  end
+
+  it "survives GC.compact after parse when supported" do
+    geom = TG::Geometry.parse_geojson(geojson_point)
+
+    GC.start
+    GC.compact if GC.respond_to?(:compact)
+
+    expect(geom).to be_a(TG::Geometry::Geom)
+    expect(geom).to be_frozen
+  end
+end

data/spec/block_4_geom_api_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Release Core Block 4 Geom API" do
+  let(:polygon_wkt) { "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))" }
+  let(:inner_point_wkt) { "POINT (5 5)" }
+  let(:boundary_point_wkt) { "POINT (0 5)" }
+  let(:outside_point_wkt) { "POINT (11 5)" }
+
+  it "maps geometry types to Ruby symbols" do
+    expect(TG::Geometry.parse_wkt("POINT (1 2)").type).to eq(:point)
+    expect(TG::Geometry.parse_wkt(polygon_wkt).type).to eq(:polygon)
+  end
+
+  it "returns a frozen Rect bbox with coordinate accessors" do
+    bbox = TG::Geometry.parse_wkt(polygon_wkt).bbox
+
+    expect(bbox).to be_a(TG::Geometry::Rect)
+    expect(bbox).to be_frozen
+    expect([bbox.min_x, bbox.min_y, bbox.max_x, bbox.max_y]).to eq([0.0, 0.0, 10.0, 10.0])
+  end
+
+  it "checks covers_xy? for inside, outside, and boundary points" do
+    geom = TG::Geometry.parse_wkt(polygon_wkt)
+
+    expect(geom.covers_xy?(5, 5)).to be(true)
+    expect(geom.covers_xy?(0, 5)).to be(true)
+    expect(geom.covers_xy?(11, 5)).to be(false)
+  end
+
+  it "keeps contains? strict while covers_xy? includes boundary" do
+    geom = TG::Geometry.parse_wkt(polygon_wkt)
+    inner = TG::Geometry.parse_wkt(inner_point_wkt)
+    boundary = TG::Geometry.parse_wkt(boundary_point_wkt)
+    outside = TG::Geometry.parse_wkt(outside_point_wkt)
+
+    expect(geom.contains?(inner)).to be(true)
+    expect(geom.contains?(boundary)).to be(false)
+    expect(geom.contains?(outside)).to be(false)
+  end
+
+  it "checks intersects? for basic geometry pairs" do
+    geom = TG::Geometry.parse_wkt(polygon_wkt)
+    overlapping = TG::Geometry.parse_wkt("POLYGON ((5 5, 12 5, 12 12, 5 12, 5 5))")
+    disjoint = TG::Geometry.parse_wkt("POLYGON ((20 20, 30 20, 30 30, 20 30, 20 20))")
+
+    expect(geom.intersects?(overlapping)).to be(true)
+    expect(geom.intersects?(disjoint)).to be(false)
+  end
+
+  it "roundtrips through GeoJSON, WKT, and WKB writers" do
+    geom = TG::Geometry.parse_wkt(polygon_wkt)
+
+    geojson = geom.to_geojson
+    wkt = geom.to_wkt
+    wkb = geom.to_wkb
+
+    expect(geojson.encoding).to eq(Encoding::UTF_8)
+    expect(wkt.encoding).to eq(Encoding::UTF_8)
+    expect(wkb.encoding).to eq(Encoding::BINARY)
+
+    expect(TG::Geometry.parse_geojson(geojson).type).to eq(:polygon)
+    expect(TG::Geometry.parse_wkt(wkt).bbox.max_x).to eq(10.0)
+    expect(TG::Geometry.parse_wkb(wkb).covers_xy?(10, 10)).to be(true)
+  end
+
+  it "serializes WKB point output without losing binary bytes" do
+    point = TG::Geometry.parse_wkt("POINT (1 2)")
+    wkb = point.to_wkb
+
+    expect(wkb.bytesize).to eq(21)
+    expect(wkb.encoding).to eq(Encoding::BINARY)
+    expect(TG::Geometry.parse_wkb(wkb).bbox.min_x).to eq(1.0)
+  end
+
+  it "raises TypeError for predicate arguments that are not Geom" do
+    geom = TG::Geometry.parse_wkt(polygon_wkt)
+
+    expect { geom.contains?("not a geom") }.to raise_error(TypeError)
+    expect { geom.intersects?(Object.new) }.to raise_error(TypeError)
+  end
+
+  it "rejects non-finite covers_xy? coordinates" do
+    geom = TG::Geometry.parse_wkt(polygon_wkt)
+
+    expect { geom.covers_xy?(Float::NAN, 1.0) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { geom.covers_xy?(1.0, Float::INFINITY) }.to raise_error(TG::Geometry::ArgumentError)
+  end
+end

data/spec/block_5_rect_api_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Release Core Block 5 Rect API" do
+  it "constructs an immutable rect with coordinate accessors" do
+    rect = TG::Geometry::Rect.new(1, 2, 5, 8)
+
+    expect(rect).to be_a(TG::Geometry::Rect)
+    expect(rect).to be_frozen
+    expect([rect.min_x, rect.min_y, rect.max_x, rect.max_y]).to eq([1.0, 2.0, 5.0, 8.0])
+  end
+
+  it "requires explicit constructor coordinates" do
+    expect { TG::Geometry::Rect.new }.to raise_error(ArgumentError)
+    expect { TG::Geometry::Rect.new(0, 0, 1) }.to raise_error(ArgumentError)
+  end
+
+  it "rejects invalid coordinate order" do
+    expect { TG::Geometry::Rect.new(5, 0, 1, 1) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { TG::Geometry::Rect.new(0, 5, 1, 1) }.to raise_error(TG::Geometry::ArgumentError)
+  end
+
+  it "rejects non-finite coordinates" do
+    expect { TG::Geometry::Rect.new(Float::NAN, 0, 1, 1) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { TG::Geometry::Rect.new(0, 0, Float::INFINITY, 1) }.to raise_error(TG::Geometry::ArgumentError)
+  end
+
+  it "returns center as two floats" do
+    expect(TG::Geometry::Rect.new(0, 2, 10, 8).center).to eq([5.0, 5.0])
+  end
+
+  it "checks rectangle intersection inclusively at boundaries" do
+    rect = TG::Geometry::Rect.new(0, 0, 10, 10)
+
+    expect(rect.intersects?(TG::Geometry::Rect.new(5, 5, 12, 12))).to be(true)
+    expect(rect.intersects?(TG::Geometry::Rect.new(10, 10, 20, 20))).to be(true)
+    expect(rect.intersects?(TG::Geometry::Rect.new(11, 11, 20, 20))).to be(false)
+  end
+
+  it "requires Rect argument for intersects? and expand_to_include" do
+    rect = TG::Geometry::Rect.new(0, 0, 10, 10)
+
+    expect { rect.intersects?(Object.new) }.to raise_error(TypeError)
+    expect { rect.expand_to_include("not a rect") }.to raise_error(TypeError)
+  end
+
+  it "checks point containment inclusively at boundaries" do
+    rect = TG::Geometry::Rect.new(0, 0, 10, 10)
+
+    expect(rect.contains_point?(5, 5)).to be(true)
+    expect(rect.contains_point?(0, 10)).to be(true)
+    expect(rect.contains_point?(11, 5)).to be(false)
+  end
+
+  it "rejects non-finite contains_point? inputs" do
+    rect = TG::Geometry::Rect.new(0, 0, 10, 10)
+
+    expect { rect.contains_point?(Float::NAN, 5) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { rect.contains_point?(5, -Float::INFINITY) }.to raise_error(TG::Geometry::ArgumentError)
+  end
+
+  it "expands to include another rect and returns a new frozen rect" do
+    rect = TG::Geometry::Rect.new(0, 0, 10, 10)
+    expanded = rect.expand_to_include(TG::Geometry::Rect.new(-2, 3, 12, 8))
+
+    expect(expanded).to be_a(TG::Geometry::Rect)
+    expect(expanded).to be_frozen
+    expect(expanded).not_to equal(rect)
+    expect([expanded.min_x, expanded.min_y, expanded.max_x, expanded.max_y]).to eq([-2.0, 0.0, 12.0, 10.0])
+    expect([rect.min_x, rect.min_y, rect.max_x, rect.max_y]).to eq([0.0, 0.0, 10.0, 10.0])
+  end
+
+  it "expands to include a point and returns a new frozen rect" do
+    rect = TG::Geometry::Rect.new(0, 0, 10, 10)
+    expanded = rect.expand_to_include_point(-3, 12)
+
+    expect(expanded).to be_a(TG::Geometry::Rect)
+    expect(expanded).to be_frozen
+    expect(expanded).not_to equal(rect)
+    expect([expanded.min_x, expanded.min_y, expanded.max_x, expanded.max_y]).to eq([-3.0, 0.0, 10.0, 12.0])
+  end
+
+  it "rejects non-finite expand_to_include_point inputs" do
+    rect = TG::Geometry::Rect.new(0, 0, 10, 10)
+
+    expect { rect.expand_to_include_point(Float::NAN, 5) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { rect.expand_to_include_point(5, Float::INFINITY) }.to raise_error(TG::Geometry::ArgumentError)
+  end
+
+  it "does not expose ambiguous contains? method" do
+    rect = TG::Geometry::Rect.new(0, 0, 10, 10)
+
+    expect(rect).not_to respond_to(:contains?)
+  end
+end