Add tests for multi-process debugging

Tests for breakpoint sync (fork_bp_sync_test.rb):
- Breakpoint set/deleted after fork syncs to child
- Multiple children receive synced breakpoints
- Catch breakpoint syncs to child
- Late-forked child catches up
- Stress test with binding.break

Tests for well-known lock (wk_lock_test.rb):
- Single-process debugging unaffected
- fork_mode: :both uses ProcessGroup not well-known lock
- Independent workers serialized by well-known lock

Author: st0012

test/console/fork_bp_sync_test.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative '../support/console_test_case'
+
+module DEBUGGER__
+  class ForkBpSyncTest < ConsoleTestCase
+
+    # Breakpoint set in parent AFTER fork is synced to child.
+    # The child uses binding.break as a sync checkpoint -- when it enters
+    # subsession there, bp_sync_check fires and picks up the new bp.
+    def test_bp_set_after_fork_reaches_child
+      code = <<~RUBY
+        1| pid = fork do
+        2|   sleep 2
+        3|   binding.break      # sync checkpoint
+        4|   a = 1              # bp target (set from parent after fork)
+        5| end
+        6| sleep 0.1
+        7| binding.break        # parent stops here after fork
+        8| Process.waitpid pid
+      RUBY
+
+      debug_code(code) do
+        type 'c'
+        assert_line_num 7
+        type 'b 4'            # set bp AFTER fork
+        type 'c'              # parent continues, bp_sync_publish writes to file
+        assert_line_num 3     # child at sync checkpoint
+        type 'c'              # child continues, hits synced bp
+        assert_line_num 4
+        type 'c'
+      end
+    end
+
+    # Breakpoint deleted in parent after fork is removed from child.
+    # Child inherits bp via COW, but parent deletes it and publishes.
+    # When child syncs at its binding.break, the bp is reconciled away.
+    def test_bp_deleted_after_fork_removed_from_child
+      code = <<~RUBY
+        1| pid = fork do
+        2|   sleep 2
+        3|   binding.break      # sync checkpoint
+        4|   a = 1              # bp was inherited, then deleted via sync
+        5|   binding.break      # child should stop here instead
+        6| end
+        7| sleep 0.1
+        8| binding.break        # parent stops here
+        9| Process.waitpid pid
+      RUBY
+
+      debug_code(code) do
+        type 'b 4'            # set bp (will be inherited by child via COW)
+        type 'c'
+        assert_line_num 8
+        type 'del 0'          # delete bp in parent
+        type 'c'              # parent continues, bp_sync_publish (empty set)
+        assert_line_num 3     # child at sync checkpoint
+        type 'c'              # child continues, line 4 bp was removed by sync
+        assert_line_num 5     # child skipped line 4
+        type 'c'
+      end
+    end
+
+    # Catch breakpoint syncs to child process.
+    def test_catch_bp_sync_after_fork
+      code = <<~RUBY
+        1| pid = fork do
+        2|   sleep 2
+        3|   binding.break        # sync checkpoint
+        4|   raise "test_error"
+        5| rescue
+        6|   binding.break        # child stops after rescue
+        7| end
+        8| sleep 0.5
+        9| binding.break
+       10| Process.waitpid pid
+      RUBY
+
+      debug_code(code) do
+        type 'c'
+        assert_line_num 9
+        type 'catch RuntimeError' # set catch bp after fork
+        type 'c'                  # parent continues, publish
+        assert_line_num 3         # child at sync checkpoint
+        type 'c'
+        assert_line_num 4         # catch bp fires
+        type 'c'
+        assert_line_num 6         # child at rescue binding.break
+        type 'c'
+      end
+    end
+
+    # Breakpoints set before fork work in child (inherited via COW + sync).
+    # Regression test that sync doesn't break the existing behavior.
+    def test_bp_before_fork_works_in_child
+      code = <<~RUBY
+        1| pid = fork do
+        2|   sleep 0.5
+        3|   a = 1
+        4| end
+        5| Process.waitpid pid
+      RUBY
+
+      debug_code(code) do
+        type 'b 3'
+        type 'c'
+        assert_line_num 3
+        type 'c'
+      end
+    end
+
+    # Stress test with multiple children and binding.break.
+    # Regression test that fork_mode: :both behavior isn't broken by sync.
+    def test_bp_sync_stress
+      code = <<~RUBY
+        1| pids = 3.times.map do
+        2|   fork do
+        3|     sleep 1
+        4|     2.times do
+        5|       binding.break
+        6|     end
+        7|   end
+        8| end
+        9| sleep 0.1
+       10| binding.break
+       11| pids.each { |pid| Process.waitpid pid rescue nil }
+      RUBY
+
+      debug_code(code) do
+        type 'c'
+        assert_line_num 10
+        type 'c'
+        # 3 children x 2 iterations = 6 stops at line 5
+        6.times do
+          assert_line_num 5
+          type 'c'
+        end
+      end
+    end
+  end
+end

test/console/wk_lock_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative '../support/console_test_case'
+
+module DEBUGGER__
+  class WellKnownLockConsoleTest < ConsoleTestCase
+
+    # Single-process debugging is unaffected by the well-known lock.
+    def test_single_process_unaffected
+      code = <<~RUBY
+        1| require "debug"
+        2| DEBUGGER__.start
+        3| a = 1
+        4| binding.break
+        5| b = 2
+      RUBY
+
+      run_ruby(code) do
+        assert_line_num 3
+        type 'c'
+        assert_line_num 4
+        type 'c'
+      end
+    end
+
+    # The well-known lock is skipped when MultiProcessGroup is active
+    # (fork_mode: :both via rdbg).
+    def test_fork_mode_both_uses_process_group_not_wk_lock
+      code = <<~RUBY
+        1| pid = fork do
+        2|   sleep 0.5
+        3|   a = 1
+        4| end
+        5| Process.waitpid pid
+      RUBY
+
+      debug_code(code) do
+        type 'b 3'
+        type 'c'
+        assert_line_num 3
+        type 'c'
+      end
+    end
+
+    # Independent workers that load the debugger after fork are serialized
+    # by the well-known lock. Each worker enters the debugger in sequence.
+    def test_independent_workers_serialized
+      code = <<~RUBY
+        1| 2.times do |i|
+        2|   fork do
+        3|     require "debug"
+        4|     DEBUGGER__.start(nonstop: true)
+        5|     sleep 1
+        6|     debugger
+        7|     $stdout.puts "worker_\#{i}_done"
+        8|   end
+        9| end
+       10| Process.waitall
+      RUBY
+
+      run_ruby(code) do
+        assert_line_num 6
+        type 'c'
+        assert_line_num 6
+        type 'c'
+      end
+    end
+  end
+end