tests: finish rspec usage-focused rationalization pass

Trim remaining overlapping RSpec tree specs to common API usage examples and representative behavior checks.

Keep exhaustive edge-case and regression scenarios in Test::Unit coverage.

Validation: rake lint, rake test:all, rake doc:check.

Author: evolve75

CHANGELOG.md

@@ -11,6 +11,8 @@ Changes section to scan for breaking or behavioral changes.
 * Rationalize RSpec coverage for core tree families so specs emphasize common
   API usage readability, while exhaustive edge-case and regression coverage
   remains in the Test::Unit suite.
+* Continue RSpec rationalization across the remaining overlapping tree-family
+  specs to keep examples usage-oriented and reduce duplicate scenario matrices.
 * Add non-breaking API aliases for consistency:
   `Tree::AATree#lookup`, `Tree::BTree#lookup`,
   `Tree::FenwickTree#query`, `Tree::SegmentTree#query`,

spec/tree/binary_search_tree_node_spec.rb

@@ -11,84 +11,36 @@ def inorder_contents(node)
     result
   end
 
-  def build_leaf_tree
-    root = described_class.new('root', 10)
-    root.insert('n5', 5)
-    root.insert('n15', 15)
-    root.insert('n2', 2)
+  def build_tree(values)
+    root = described_class.new('root', values.first)
+    values.drop(1).each_with_index do |value, index|
+      root.insert("n#{index}", value)
+    end
     root
   end
 
-  def build_one_child_tree
-    root = described_class.new('root', 10)
-    root.insert('n5', 5)
-    root.insert('n2', 2)
-    root
-  end
-
-  def build_two_children_tree
-    root = described_class.new('root', 10)
-    root.insert('n5', 5)
-    root.insert('n15', 15)
-    root.insert('n12', 12)
-    root.insert('n18', 18)
-    root.insert('n2', 2)
-    root
-  end
-
-  def build_root_single_child_tree
-    root = described_class.new('root', 10)
-    root.insert('n5', 5)
-    root
-  end
-
-  def build_root_leaf_tree
-    described_class.new('root', 10)
-  end
+  let(:root) { build_tree([10, 5, 15, 12, 18, 2]) }
 
   it 'orders inserts by key' do
-    expect(inorder_contents(build_two_children_tree)).to eq([2, 5, 10, 12, 15, 18])
+    expect(inorder_contents(root)).to eq([2, 5, 10, 12, 15, 18])
   end
 
-  it 'finds a matching key' do
-    expect(build_two_children_tree.search(15).name).to eq('n15')
+  it 'finds matching keys' do
+    expect(root.search(15).content).to eq(15)
   end
 
-  it 'returns nil for a missing key' do
-    expect(build_two_children_tree.search(7)).to be_nil
+  it 'returns nil for missing keys' do
+    expect(root.search(7)).to be_nil
   end
 
-  it 'returns the removed node when deleting a leaf' do
-    expect(build_leaf_tree.delete(2).content).to eq(2)
-  end
-
-  it 'updates order when deleting a leaf' do
-    root = build_leaf_tree
-    root.delete(2)
-    expect(inorder_contents(root)).to eq([5, 10, 15])
-  end
-
-  it 'updates order when deleting a node with one child' do
-    root = build_one_child_tree
-    root.delete(5)
-    expect(inorder_contents(root)).to eq([2, 10])
-  end
-
-  it 'updates order when deleting a node with two children' do
-    root = build_two_children_tree
-    root.delete(15)
-    expect(inorder_contents(root)).to eq([2, 5, 10, 12, 18])
-  end
-
-  it 'replaces root content when deleting root with one child' do
-    root = build_root_single_child_tree
-    root.delete(10)
-    expect(root.content).to eq(5)
-  end
+  describe 'delete usage' do
+    it 'returns the removed node' do
+      expect(root.delete(2).content).to eq(2)
+    end
 
-  it 'clears root content when deleting a root leaf' do
-    root = build_root_leaf_tree
-    root.delete(10)
-    expect(root.content).to be_nil
+    it 'removes deleted keys from traversal results' do
+      root.delete(15)
+      expect(inorder_contents(root)).to eq([2, 5, 10, 12, 18])
+    end
   end
 end

spec/tree/fenwick_tree_spec.rb

@@ -9,107 +9,35 @@ def build_tree(values)
     described_class.new(values.length, values)
   end
 
-  describe 'initialize' do
-    it 'applies initial values' do
-      tree = build_tree([1, 2, 3])
-      expect(tree.sum(2)).to eq(6)
-    end
+  let(:tree) { build_tree([1, 2, 3, 4, 5]) }
 
-    it 'raises for invalid size' do
-      expect { described_class.new(0) }.to raise_error(ArgumentError)
-    end
+  it 'supports prefix-sum queries for common usage' do
+    expect(tree.sum(3)).to eq(10)
   end
 
-  describe 'update' do
-    it 'updates prefix sums' do
-      tree = build_tree([1, 2, 3, 4])
-      tree.update(2, 5)
-      expect(tree.sum(2)).to eq(11)
-    end
+  it 'supports range-sum queries for common usage' do
+    expect(tree.range_sum(1, 3)).to eq(9)
   end
 
-  describe 'sum' do
-    it 'returns a prefix sum' do
-      tree = build_tree([1, 2, 3, 4, 5])
-      expect(tree.sum(3)).to eq(10)
-    end
+  it 'supports indexed updates via []=' do
+    tree[1] = 5
+    expect(tree[1]).to eq(7)
   end
 
-  describe 'range_sum' do
-    it 'returns a range sum' do
-      tree = build_tree([1, 2, 3, 4, 5])
-      expect(tree.range_sum(1, 3)).to eq(9)
-    end
+  it 'supports enumeration in index order' do
+    expect(tree.each.to_a).to eq([1, 2, 3, 4, 5])
   end
 
-  describe '[]' do
-    it 'returns the value at an index' do
-      tree = build_tree([1, 2, 3, 4, 5])
-      expect(tree[4]).to eq(5)
-    end
+  it 'supports hash round-trips' do
+    copy = described_class.from_hash(tree.to_h)
+    expect(copy.to_a).to eq(tree.to_a)
   end
 
-  describe '[]=' do
-    it 'adds a delta at the index' do
-      tree = build_tree([1, 2, 3])
-      tree[1] = 5
-      expect(tree[1]).to eq(7)
-    end
+  it 'rejects invalid tree size' do
+    expect { described_class.new(0) }.to raise_error(ArgumentError)
   end
 
-  describe 'each' do
-    it 'yields values in index order' do
-      tree = build_tree([3, 1, 4])
-      expect(tree.each.to_a).to eq([3, 1, 4])
-    end
-  end
-
-  describe 'keys' do
-    it 'returns indices in order' do
-      tree = build_tree([1, 2, 3])
-      expect(tree.keys).to eq([0, 1, 2])
-    end
-  end
-
-  describe 'values' do
-    it 'returns values in index order' do
-      tree = build_tree([2, 4, 6])
-      expect(tree.values).to eq([2, 4, 6])
-    end
-  end
-
-  describe 'to_h and from_hash' do
-    it 'round trips the tree' do
-      tree = build_tree([1, 3, 5])
-      copy = described_class.from_hash(tree.to_h)
-      expect(copy.to_a).to eq([1, 3, 5])
-    end
-  end
-
-  describe 'as_json' do
-    it 'returns a hash representation' do
-      tree = build_tree([1, 2])
-      expect(tree.as_json).to eq(tree.to_h)
-    end
-  end
-
-  describe '<=>' do
-    it 'compares by ordered values' do
-      left = build_tree([1, 2, 3])
-      right = build_tree([1, 2, 4])
-      expect(left < right).to be(true)
-    end
-  end
-
-  describe '<<' do
-    it 'is not supported' do
-      tree = build_tree([1, 2, 3])
-      expect(tree.respond_to?(:<<)).to be(false)
-    end
-
-    it 'raises when called' do
-      tree = build_tree([1, 2, 3])
-      expect { tree << 4 }.to raise_error(NoMethodError)
-    end
+  it 'does not support shovel insertion' do
+    expect(tree.respond_to?(:<<)).to be(false)
   end
 end

spec/tree/interval_tree_node_spec.rb

@@ -7,18 +7,12 @@
 RSpec.describe Tree::IntervalTreeNode do
   def build_tree(intervals)
     root = described_class.new('root', intervals.first)
-    intervals.drop(1).each_with_index do |interval, idx|
-      root.insert("n#{idx}", interval)
+    intervals.drop(1).each_with_index do |interval, index|
+      root.insert("n#{index}", interval)
     end
     root
   end
 
-  def inorder_keys(node)
-    result = []
-    node.inordered_each { |entry| result << entry.key }
-    result
-  end
-
   def max_end_valid?(node)
     return true unless node&.content
 
@@ -28,45 +22,24 @@ def max_end_valid?(node)
     max_end_valid?(node.left_child) && max_end_valid?(node.right_child)
   end
 
-  describe 'inserts' do
-    let(:root) { build_tree([15..20, 10..30, 17..19, 5..20, 12..15, 30..40]) }
-
-    it 'keeps in-order traversal sorted' do
-      expect(inorder_keys(root)).to eq(inorder_keys(root).sort)
-    end
+  let(:root) { build_tree([15..20, 10..30, 17..19, 5..20, 12..15, 30..40]) }
 
-    it 'maintains max_end across the subtree' do
-      expect(max_end_valid?(root)).to be(true)
-    end
+  it 'supports overlap queries for common usage' do
+    results = root.search_overlaps(14..16).map(&:content)
+    expect(results.sort_by(&:begin)).to eq([5..20, 10..30, 12..15, 15..20])
   end
 
-  describe 'search_overlaps' do
-    let(:root) { build_tree([15..20, 10..30, 17..19, 5..20, 12..15, 30..40]) }
-
-    it 'returns all overlapping intervals' do
-      results = root.search_overlaps(14..16).map(&:content)
-      expected = [15..20, 10..30, 5..20, 12..15]
-      expect(results.sort_by(&:begin)).to eq(expected.sort_by(&:begin))
-    end
+  it 'supports point queries for common usage' do
+    results = root.search_point(17).map(&:content)
+    expect(results.sort_by(&:begin)).to eq([5..20, 10..30, 15..20, 17..19])
   end
 
-  describe 'search_point' do
-    let(:root) { build_tree([15..20, 10..30, 17..19, 5..20, 12..15, 30..40]) }
-
-    it 'returns all intervals covering the point' do
-      results = root.search_point(17).map(&:content)
-      expected = [15..20, 10..30, 17..19, 5..20]
-      expect(results.sort_by(&:begin)).to eq(expected.sort_by(&:begin))
-    end
+  it 'maintains max_end metadata after inserts' do
+    expect(max_end_valid?(root)).to be(true)
   end
 
-  describe 'delete' do
-    let(:root) { build_tree([15..20, 10..30, 17..19, 5..20, 12..15, 30..40]) }
-
-    before { root.delete(10..30) }
-
-    it 'maintains max_end across the subtree' do
-      expect(max_end_valid?(root)).to be(true)
-    end
+  it 'maintains max_end metadata after delete' do
+    root.delete(10..30)
+    expect(max_end_valid?(root)).to be(true)
   end
 end