From cbbeb1ad14864504d85793341ac3200828fc802e Mon Sep 17 00:00:00 2001
From: Chad Wilson <29788154+chadlwilson@users.noreply.github.com>
Date: Sun, 16 Nov 2025 16:46:43 +0800
Subject: [PATCH 1/6] [chore] Improve ease of switching JRuby versions by
 enforcing cleaner bundler env

---
 .bundle/config                  | 2 ++
 examples/camping/.bundle/config | 2 ++
 examples/rails8/.bundle/config  | 2 ++
 examples/sinatra/.bundle/config | 2 ++
 gemfiles/.bundle/config         | 2 +-
 5 files changed, 9 insertions(+), 1 deletion(-)
 create mode 100644 .bundle/config
 create mode 100644 examples/camping/.bundle/config
 create mode 100644 examples/rails8/.bundle/config
 create mode 100644 examples/sinatra/.bundle/config

diff --git a/.bundle/config b/.bundle/config
new file mode 100644
index 000000000..dc82af0e9
--- /dev/null
+++ b/.bundle/config
@@ -0,0 +1,2 @@
+---
+BUNDLE_VERSION: "system"
diff --git a/examples/camping/.bundle/config b/examples/camping/.bundle/config
new file mode 100644
index 000000000..dc82af0e9
--- /dev/null
+++ b/examples/camping/.bundle/config
@@ -0,0 +1,2 @@
+---
+BUNDLE_VERSION: "system"
diff --git a/examples/rails8/.bundle/config b/examples/rails8/.bundle/config
new file mode 100644
index 000000000..dc82af0e9
--- /dev/null
+++ b/examples/rails8/.bundle/config
@@ -0,0 +1,2 @@
+---
+BUNDLE_VERSION: "system"
diff --git a/examples/sinatra/.bundle/config b/examples/sinatra/.bundle/config
new file mode 100644
index 000000000..dc82af0e9
--- /dev/null
+++ b/examples/sinatra/.bundle/config
@@ -0,0 +1,2 @@
+---
+BUNDLE_VERSION: "system"
diff --git a/gemfiles/.bundle/config b/gemfiles/.bundle/config
index c127f8025..dc82af0e9 100644
--- a/gemfiles/.bundle/config
+++ b/gemfiles/.bundle/config
@@ -1,2 +1,2 @@
 ---
-BUNDLE_RETRY: "1"
+BUNDLE_VERSION: "system"

From e7392078bd79fa7a3d57a900c719cb31f3c326af Mon Sep 17 00:00:00 2001
From: Chad Wilson <29788154+chadlwilson@users.noreply.github.com>
Date: Sun, 16 Nov 2025 17:41:06 +0800
Subject: [PATCH 2/6] [tests] Improve reliability of pool wait sleep tests

---
 src/spec/ruby/rack/application_spec.rb | 63 ++++++++++++--------------
 src/spec/ruby/spec_helper.rb           |  1 +
 2 files changed, 31 insertions(+), 33 deletions(-)

diff --git a/src/spec/ruby/rack/application_spec.rb b/src/spec/ruby/rack/application_spec.rb
index 30dcd43a3..fe5b7dece 100644
--- a/src/spec/ruby/rack/application_spec.rb
+++ b/src/spec/ruby/rack/application_spec.rb
@@ -516,7 +516,7 @@ def reset_config
 
 describe org.jruby.rack.rails.RailsRackApplicationFactory do
 
-  java_import org.jruby.rack.rails.RailsRackApplicationFactory
+  require 'jruby/rack/rails_booter'
 
   before :each do
     @app_factory = RailsRackApplicationFactory.new
@@ -665,7 +665,7 @@ def createRackServletWrapper(runtime, rackup, filename)
     allow(@factory).to receive(:newApplication) do
       app = double "app"
       allow(app).to receive(:init) do
-        sleep(0.10)
+        sleep(0.05)
       end
       app
     end
@@ -679,6 +679,7 @@ def createRackServletWrapper(runtime, rackup, filename)
 
   it "throws an exception from getApplication when an app failed to initialize " +
      "(even when only a single application initialization fails)" do
+    app_init_secs = 0.05
     allow(@factory).to receive(:init)
     app_count = java.util.concurrent.atomic.AtomicInteger.new(0)
     allow(@factory).to receive(:newApplication) do
@@ -687,7 +688,7 @@ def createRackServletWrapper(runtime, rackup, filename)
         if app_count.addAndGet(1) == 2
           raise org.jruby.rack.RackInitializationException.new('failed app init')
         end
-        sleep(0.05)
+        sleep(app_init_secs)
       end
       app
     end
@@ -701,7 +702,7 @@ def createRackServletWrapper(runtime, rackup, filename)
     rescue org.jruby.rack.RackInitializationException
       # ignore - sometimes initialization happens fast enough that the init error is thrown already
     end
-    sleep(0.20)
+    sleep(num_runtimes * app_init_secs + 0.07) # sleep with a buffer
 
     failed = 0
     num_runtimes.times do
@@ -717,10 +718,11 @@ def createRackServletWrapper(runtime, rackup, filename)
   end
 
   it "wait until pool is filled when invoking getApplication (with wait set to false)" do
+    app_init_secs = 0.2
     allow(@factory).to receive(:init)
     allow(@factory).to receive(:newApplication) do
       app = double "app"
-      allow(app).to receive(:init) { sleep(0.2) }
+      allow(app).to receive(:init) { sleep(app_init_secs) }
       app
     end
     allow(@rack_config).to receive(:getBooleanProperty).with("jruby.runtime.init.wait").and_return false
@@ -728,17 +730,17 @@ def createRackServletWrapper(runtime, rackup, filename)
     expect(@rack_config).to receive(:getMaximumRuntimes).and_return 4
 
     @pooling_factory.init(@rack_context)
-    millis = java.lang.System.currentTimeMillis
+    start = java.lang.System.currentTimeMillis
     expect(@pooling_factory.getApplication).not_to be nil
-    millis = java.lang.System.currentTimeMillis - millis
-    expect(millis).to be >= 150 # getApplication waited ~ 0.2 secs
+    expect(java.lang.System.currentTimeMillis - start).to be_within(70).of(app_init_secs * 1000) # getApplication waited ~ sleep time
   end
 
   it "waits acquire timeout till an application is available from the pool (than raises)" do
+    app_init_secs = 0.2
     allow(@factory).to receive(:init)
     expect(@factory).to receive(:newApplication).twice do
       app = double "app"
-      expect(app).to receive(:init) { sleep(0.2) }
+      expect(app).to receive(:init) { sleep(app_init_secs) }
       app
     end
     allow(@rack_config).to receive(:getBooleanProperty).with("jruby.runtime.init.wait").and_return false
@@ -747,57 +749,56 @@ def createRackServletWrapper(runtime, rackup, filename)
 
     @pooling_factory.init(@rack_context)
     @pooling_factory.acquire_timeout = 1.to_java # second
-    millis = java.lang.System.currentTimeMillis
+    start = java.lang.System.currentTimeMillis
     expect(@pooling_factory.getApplication).not_to be nil
-    millis = java.lang.System.currentTimeMillis - millis
-    expect(millis).to be >= 150 # getApplication waited ~ 0.2 secs
+    expect(java.lang.System.currentTimeMillis - start).to be_within(70).of(app_init_secs * 1000)
 
     app2 = @pooling_factory.getApplication # now the pool is empty
-
-    @pooling_factory.acquire_timeout = 0.1.to_java # second
-    millis = java.lang.System.currentTimeMillis
+    timeout_secs = 0.1
+    @pooling_factory.acquire_timeout = (timeout_secs).to_java
+    start = java.lang.System.currentTimeMillis
     expect { @pooling_factory.getApplication }.to raise_error(org.jruby.rack.AcquireTimeoutException)
-    millis = java.lang.System.currentTimeMillis - millis
-    expect(millis).to be >= 90 # waited about ~ 0.1 secs
+    expect(java.lang.System.currentTimeMillis - start).to be_within(20).of(timeout_secs * 1000)
 
     @pooling_factory.finishedWithApplication(app2) # gets back to the pool
     expect(@pooling_factory.getApplication).to eq app2
   end
 
   it "gets and initializes new applications until maximum allows to create more" do
+    app_init_secs = 0.1
     allow(@factory).to receive(:init)
     expect(@factory).to receive(:newApplication).twice do
       app = double "app (new)"
-      expect(app).to receive(:init) { sleep(0.1) }
+      expect(app).to receive(:init) { sleep(app_init_secs) }
       app
     end
     allow(@rack_config).to receive(:getBooleanProperty).with("jruby.runtime.init.wait").and_return false
     allow(@rack_config).to receive(:getInitialRuntimes).and_return 2
     allow(@rack_config).to receive(:getMaximumRuntimes).and_return 4
 
+    timeout_secs = 0.1
     @pooling_factory.init(@rack_context)
-    @pooling_factory.acquire_timeout = 0.10.to_java # second
+    @pooling_factory.acquire_timeout = (timeout_secs).to_java # second
 
     2.times { expect(@pooling_factory.getApplication).not_to be nil }
 
+    app_get_secs = 0.15
     expect(@factory).to receive(:getApplication).twice do
-      app = double "app (get)"; sleep(0.15); app
+      app = double "app (get)"; sleep(app_get_secs); app
     end
 
-    millis = java.lang.System.currentTimeMillis
+    start = java.lang.System.currentTimeMillis
     2.times { expect(@pooling_factory.getApplication).not_to be nil }
-    millis = java.lang.System.currentTimeMillis - millis
-    expect(millis).to be >= 300 # waited about 2 x 0.15 secs
+    expect(java.lang.System.currentTimeMillis - start).to be_within(70).of(2 * app_get_secs * 1000)
 
-    millis = java.lang.System.currentTimeMillis
+    start = java.lang.System.currentTimeMillis
     expect {
       @pooling_factory.getApplication
     }.to raise_error(org.jruby.rack.AcquireTimeoutException)
-    millis = java.lang.System.currentTimeMillis - millis
-    expect(millis).to be >= 90 # waited about ~ 0.10 secs
+    expect(java.lang.System.currentTimeMillis - start).to be_within(20).of(timeout_secs * 1000)
   end
 
-  it "initializes initial runtimes in paralel (with wait set to false)" do
+  it "initializes initial runtimes in parallel (with wait set to false)" do
     allow(@factory).to receive(:init)
     allow(@factory).to receive(:newApplication) do
       app = double "app"
@@ -821,12 +822,11 @@ def createRackServletWrapper(runtime, rackup, filename)
   end
 
   it "throws from init when application initialization in thread failed" do
+    app_init_secs = 0.05
     allow(@factory).to receive(:init)
     allow(@factory).to receive(:newApplication) do
       app = double "app"
-      allow(app).to receive(:init) do
-        sleep(0.05); raise "app.init raising"
-      end
+      allow(app).to receive(:init) { sleep(app_init_secs); raise "app.init raising" }
       app
     end
     allow(@rack_config).to receive(:getInitialRuntimes).and_return 2
@@ -845,9 +845,6 @@ def createRackServletWrapper(runtime, rackup, filename)
 
     expect { @pooling_factory.init(@rack_context) }.to raise_error org.jruby.rack.RackInitializationException
     expect(raise_error_logged).to eql 1 # logs same init exception once
-
-    # NOTE: seems it's not such a good idea to return empty on init error
-    #     expect(@pooling_factory.getManagedApplications).to be_empty
   end
 
 end
diff --git a/src/spec/ruby/spec_helper.rb b/src/spec/ruby/spec_helper.rb
index d8c354496..8d661cdfc 100644
--- a/src/spec/ruby/spec_helper.rb
+++ b/src/spec/ruby/spec_helper.rb
@@ -10,6 +10,7 @@
 
 java_import 'org.jruby.rack.RackApplicationFactory'
 java_import 'org.jruby.rack.DefaultRackApplicationFactory'
+java_import 'org.jruby.rack.rails.RailsRackApplicationFactory'
 java_import 'org.jruby.rack.servlet.RequestCapture'
 java_import 'org.jruby.rack.servlet.ResponseCapture'
 java_import 'org.jruby.rack.servlet.RewindableInputStream'

From dcdecf1d8efd5df97180e3660228180296274119 Mon Sep 17 00:00:00 2001
From: Chad Wilson <29788154+chadlwilson@users.noreply.github.com>
Date: Sun, 16 Nov 2025 17:26:50 +0800
Subject: [PATCH 3/6] [tests] Fix threading issue with parallel testing with
 non-threadsafe rspec mocks

---
 src/spec/ruby/rack/application_spec.rb | 60 +++++++++++++++++---------
 1 file changed, 39 insertions(+), 21 deletions(-)

diff --git a/src/spec/ruby/rack/application_spec.rb b/src/spec/ruby/rack/application_spec.rb
index fe5b7dece..dbc728a3d 100644
--- a/src/spec/ruby/rack/application_spec.rb
+++ b/src/spec/ruby/rack/application_spec.rb
@@ -557,8 +557,20 @@ def createRackServletWrapper(runtime, rackup, filename)
 
 describe org.jruby.rack.PoolingRackApplicationFactory do
 
+  # Workaround rspec mocks/proxies not being thread-safe which causes occasional failures
+  class Synchronized
+    def initialize(obj)
+      @delegate = obj
+      @lock = Mutex.new
+    end
+
+    def method_missing(name, *args, &block)
+      @lock.synchronize { @delegate.send(name, *args, &block) }
+    end
+  end
+
   before :each do
-    @factory = double "factory"
+    @factory = Synchronized.new(double("factory").as_null_object)
     @pooling_factory = org.jruby.rack.PoolingRackApplicationFactory.new @factory
     @pooling_factory.context = @rack_context
   end
@@ -608,7 +620,7 @@ def createRackServletWrapper(runtime, rackup, filename)
   it "creates applications during initialization according to the jruby.min.runtimes context parameter" do
     allow(@factory).to receive(:init)
     allow(@factory).to receive(:newApplication) do
-      app = double "app"
+      app = Synchronized.new(double("app").as_null_object)
       expect(app).to receive(:init)
       app
     end
@@ -641,7 +653,7 @@ def createRackServletWrapper(runtime, rackup, filename)
   it "forces the maximum size to be greater or equal to the initial size" do
     allow(@factory).to receive(:init)
     allow(@factory).to receive(:newApplication) do
-      app = double "app"
+      app = Synchronized.new(double("app").as_null_object)
       expect(app).to receive(:init)
       app
     end
@@ -655,7 +667,7 @@ def createRackServletWrapper(runtime, rackup, filename)
   end
 
   it "retrieves the error application from the delegate factory" do
-    app = double("app")
+    app = double "app"
     expect(@factory).to receive(:getErrorApplication).and_return app
     expect(@pooling_factory.getErrorApplication).to eq app
   end
@@ -663,7 +675,7 @@ def createRackServletWrapper(runtime, rackup, filename)
   it "waits till initial runtimes get initialized (with wait set to true)" do
     allow(@factory).to receive(:init)
     allow(@factory).to receive(:newApplication) do
-      app = double "app"
+      app = Synchronized.new(double("app").as_null_object)
       allow(app).to receive(:init) do
         sleep(0.05)
       end
@@ -683,7 +695,7 @@ def createRackServletWrapper(runtime, rackup, filename)
     allow(@factory).to receive(:init)
     app_count = java.util.concurrent.atomic.AtomicInteger.new(0)
     allow(@factory).to receive(:newApplication) do
-      app = double "app"
+      app = Synchronized.new(double("app").as_null_object)
       allow(app).to receive(:init) do
         if app_count.addAndGet(1) == 2
           raise org.jruby.rack.RackInitializationException.new('failed app init')
@@ -721,7 +733,7 @@ def createRackServletWrapper(runtime, rackup, filename)
     app_init_secs = 0.2
     allow(@factory).to receive(:init)
     allow(@factory).to receive(:newApplication) do
-      app = double "app"
+      app = Synchronized.new(double("app").as_null_object)
       allow(app).to receive(:init) { sleep(app_init_secs) }
       app
     end
@@ -739,7 +751,7 @@ def createRackServletWrapper(runtime, rackup, filename)
     app_init_secs = 0.2
     allow(@factory).to receive(:init)
     expect(@factory).to receive(:newApplication).twice do
-      app = double "app"
+      app = Synchronized.new(double("app").as_null_object)
       expect(app).to receive(:init) { sleep(app_init_secs) }
       app
     end
@@ -768,7 +780,7 @@ def createRackServletWrapper(runtime, rackup, filename)
     app_init_secs = 0.1
     allow(@factory).to receive(:init)
     expect(@factory).to receive(:newApplication).twice do
-      app = double "app (new)"
+      app = Synchronized.new(double("app (new)").as_null_object)
       expect(app).to receive(:init) { sleep(app_init_secs) }
       app
     end
@@ -784,7 +796,9 @@ def createRackServletWrapper(runtime, rackup, filename)
 
     app_get_secs = 0.15
     expect(@factory).to receive(:getApplication).twice do
-      app = double "app (get)"; sleep(app_get_secs); app
+      app = Synchronized.new(double("app (get)").as_null_object)
+      sleep(app_get_secs)
+      app
     end
 
     start = java.lang.System.currentTimeMillis
@@ -799,33 +813,37 @@ def createRackServletWrapper(runtime, rackup, filename)
   end
 
   it "initializes initial runtimes in parallel (with wait set to false)" do
+    app_init_secs = 0.15
     allow(@factory).to receive(:init)
     allow(@factory).to receive(:newApplication) do
-      app = double "app"
-      allow(app).to receive(:init) do
-        sleep(0.15)
-      end
+      app = Synchronized.new(double("app").as_null_object)
+      allow(app).to receive(:init) { sleep(app_init_secs) }
       app
     end
+
+    init_threads = 4
+    init_runtimes = 6
     allow(@rack_config).to receive(:getBooleanProperty).with("jruby.runtime.init.wait").and_return false
-    allow(@rack_config).to receive(:getInitialRuntimes).and_return 6
+    allow(@rack_config).to receive(:getRuntimeInitThreads).and_return init_threads
+    allow(@rack_config).to receive(:getInitialRuntimes).and_return init_runtimes
     allow(@rack_config).to receive(:getMaximumRuntimes).and_return 8
 
+    expected_initial_init_time = 1.1 * (init_runtimes.to_f / init_threads.to_f).ceil * app_init_secs # 10% margin
     @pooling_factory.init(@rack_context)
-    sleep(0.10)
-    expect(@pooling_factory.getApplicationPool.size).to be < 6
-    sleep(0.9)
-    expect(@pooling_factory.getApplicationPool.size).to be >= 6
+    sleep(app_init_secs) # wait for at some (but not possibly all) to finish
+    expect(@pooling_factory.getApplicationPool.size).to be < init_runtimes
+    sleep(expected_initial_init_time - app_init_secs) # remaining time
+    expect(@pooling_factory.getApplicationPool.size).to be >= init_runtimes
 
     expect(@pooling_factory.getManagedApplications).to_not be_empty
-    expect(@pooling_factory.getManagedApplications.size).to eql 6
+    expect(@pooling_factory.getManagedApplications.size).to eql init_runtimes
   end
 
   it "throws from init when application initialization in thread failed" do
     app_init_secs = 0.05
     allow(@factory).to receive(:init)
     allow(@factory).to receive(:newApplication) do
-      app = double "app"
+      app = Synchronized.new(double("app").as_null_object)
       allow(app).to receive(:init) { sleep(app_init_secs); raise "app.init raising" }
       app
     end

From 49e0fece4e695504cd5ca8880723cd404a060fc0 Mon Sep 17 00:00:00 2001
From: Chad Wilson <29788154+chadlwilson@users.noreply.github.com>
Date: Sun, 16 Nov 2025 23:25:32 +0800
Subject: [PATCH 4/6] [chore] Fix minor log typo

---
 .../java/org/jruby/rack/RackApplicationFactoryDecorator.java  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/jruby/rack/RackApplicationFactoryDecorator.java b/src/main/java/org/jruby/rack/RackApplicationFactoryDecorator.java
index 69ceff3cc..1858afb1c 100644
--- a/src/main/java/org/jruby/rack/RackApplicationFactoryDecorator.java
+++ b/src/main/java/org/jruby/rack/RackApplicationFactoryDecorator.java
@@ -133,8 +133,8 @@ public void destroy() {
     public RackApplication getApplication() throws RackException {
         final RuntimeException error = getInitError();
         if ( error != null ) {
-            log(DEBUG, "due a previous initialization failure application instance can not be returned");
-            throw error; // this is better - we shall never return null here ...
+            log(DEBUG, "due to a previous initialization failure application instance can not be returned");
+            throw error;
         }
         return getApplicationImpl();
     }

From fbc5fa7e10c78df90d206fdace538b5948092eda Mon Sep 17 00:00:00 2001
From: Chad Wilson <29788154+chadlwilson@users.noreply.github.com>
Date: Sun, 16 Nov 2025 17:01:38 +0800
Subject: [PATCH 5/6] [tests] Fix test race condition on servlet_context type

---
 src/spec/ruby/jruby/rack/rails_booter_spec.rb |  4 ----
 src/spec/ruby/rack/application_spec.rb        |  9 +++------
 src/spec/ruby/spec_helper.rb                  | 11 ++++++++---
 3 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/src/spec/ruby/jruby/rack/rails_booter_spec.rb b/src/spec/ruby/jruby/rack/rails_booter_spec.rb
index 0fdc4163c..ea394c46d 100644
--- a/src/spec/ruby/jruby/rack/rails_booter_spec.rb
+++ b/src/spec/ruby/jruby/rack/rails_booter_spec.rb
@@ -122,10 +122,6 @@
       end
     end
 
-    after :all do
-      $servlet_context = nil
-    end
-
     let(:railtie_class) { Class.new(Rails::Railtie) }
 
     it "should have loaded the railtie" do
diff --git a/src/spec/ruby/rack/application_spec.rb b/src/spec/ruby/rack/application_spec.rb
index dbc728a3d..d134e9c6c 100644
--- a/src/spec/ruby/rack/application_spec.rb
+++ b/src/spec/ruby/rack/application_spec.rb
@@ -104,6 +104,8 @@ def it_should_rewind_body
 
   before :each do
     @app_factory = DefaultRackApplicationFactory.new
+    reset_booter
+    reset_servlet_context_global
   end
 
   it "should receive a rackup script via the 'rackup' parameter" do
@@ -161,11 +163,6 @@ def it_should_rewind_body
     expect(input_stream.getMaximumBufferSize).to eq 420
   end
 
-  before do
-    reset_booter
-    JRuby::Rack.context = $servlet_context = nil
-  end
-
   it "should init and create application object without a rackup script" do
     $servlet_context = @servlet_context
     # NOTE: a workaround to be able to mock it :
@@ -340,7 +337,7 @@ def newRuntime()
 
       it "initializes the $servlet_context global variable" do
         @runtime = app_factory.new_runtime
-        should_not_eval_as_nil "defined?($servlet_context)"
+        expect(@runtime.evalScriptlet("defined?($servlet_context)")).to be_truthy
       end
 
       it "clears environment variables if the configuration ignores the environment" do
diff --git a/src/spec/ruby/spec_helper.rb b/src/spec/ruby/spec_helper.rb
index 8d661cdfc..a97c00543 100644
--- a/src/spec/ruby/spec_helper.rb
+++ b/src/spec/ruby/spec_helper.rb
@@ -51,6 +51,11 @@ def servlet_context
     mock_servlet_context
   end
 
+  def reset_servlet_context_global
+    $servlet_context = nil if defined? $servlet_context
+    JRuby::Rack.context = nil if defined?(JRuby::Rack) and JRuby::Rack.respond_to?(:context=)
+  end
+
   def silence_warnings(&block)
     JRuby::Rack::Helpers.silence_warnings(&block)
   end
@@ -125,7 +130,7 @@ def should_not_eval_as_nil(code, runtime = @runtime)
 
 STUB_DIR = File.expand_path('../stub', File.dirname(__FILE__))
 
-WD_START = Dir.getwd
+ORIGINAL_WORKING_DIR = Dir.getwd
 
 begin
   # NOTE: only if running with a `bundle exec` to better isolate
@@ -154,8 +159,8 @@ def should_not_eval_as_nil(code, runtime = @runtime)
   config.after(:each) do
     (ENV.keys - @env_save.keys).each { |k| ENV.delete k }
     @env_save.each { |k, v| ENV[k] = v }
-    Dir.chdir(WD_START) unless Dir.getwd == WD_START
-    $servlet_context = nil if defined? $servlet_context
+    Dir.chdir(ORIGINAL_WORKING_DIR) unless Dir.getwd == ORIGINAL_WORKING_DIR
+    reset_servlet_context_global
   end
 
   # NOTE: only works when no other example filtering is in place: e.g. `rspec ... --example=logger` won't filter here

From 9e80b8497cca28adc97028fc6871fc575548e624 Mon Sep 17 00:00:00 2001
From: Chad Wilson <29788154+chadlwilson@users.noreply.github.com>
Date: Mon, 17 Nov 2025 00:57:04 +0800
Subject: [PATCH 6/6] [tests] simplify custom cross-runtime expectation
 matchers

---
 src/spec/ruby/jruby/rack/booter_spec.rb | 20 ++++++------
 src/spec/ruby/rack/application_spec.rb  |  6 ++--
 src/spec/ruby/spec_helper.rb            | 41 ++++++++-----------------
 3 files changed, 25 insertions(+), 42 deletions(-)

diff --git a/src/spec/ruby/jruby/rack/booter_spec.rb b/src/spec/ruby/jruby/rack/booter_spec.rb
index 4058aa826..14e99e80e 100644
--- a/src/spec/ruby/jruby/rack/booter_spec.rb
+++ b/src/spec/ruby/jruby/rack/booter_spec.rb
@@ -294,17 +294,17 @@
         @runtime.evalScriptlet("load 'jruby/rack/boot/rack.rb'")
 
         # booter got setup :
-        should_not_eval_as_nil "defined?(JRuby::Rack.booter)"
-        should_not_eval_as_nil "JRuby::Rack.booter"
+        should_eval_as_not_nil "defined?(JRuby::Rack.booter)"
+        should_eval_as_not_nil "JRuby::Rack.booter"
         should_eval_as_eql_to "JRuby::Rack.booter.class.name", 'JRuby::Rack::Booter'
 
         # Booter.boot! run :
-        should_not_eval_as_nil "ENV['RACK_ENV']"
+        should_eval_as_not_nil "ENV['RACK_ENV']"
         # rack got required :
-        should_not_eval_as_nil "defined?(Rack::RELEASE)"
-        should_not_eval_as_nil "defined?(Rack.release)"
+        should_eval_as_not_nil "defined?(Rack::RELEASE)"
+        should_eval_as_not_nil "defined?(Rack.release)"
         # check if it got loaded correctly :
-        should_not_eval_as_nil "Rack::Request.new({}) rescue nil"
+        should_eval_as_not_nil "Rack::Request.new({}) rescue nil"
       end
 
     end
@@ -341,13 +341,13 @@
         @runtime.evalScriptlet("load 'jruby/rack/boot/rails.rb'")
 
         # booter got setup :
-        should_not_eval_as_nil "defined?(JRuby::Rack.booter)"
-        should_not_eval_as_nil "JRuby::Rack.booter"
+        should_eval_as_not_nil "defined?(JRuby::Rack.booter)"
+        should_eval_as_not_nil "JRuby::Rack.booter"
         should_eval_as_eql_to "JRuby::Rack.booter.class.name", 'JRuby::Rack::RailsBooter'
 
         # Booter.boot! run :
-        should_not_eval_as_nil "ENV['RACK_ENV']"
-        should_not_eval_as_nil "ENV['RAILS_ENV']"
+        should_eval_as_not_nil "ENV['RACK_ENV']"
+        should_eval_as_not_nil "ENV['RAILS_ENV']"
 
         # rack not yet required (let bundler decide which rack version to load) :
         should_eval_as_nil "defined?(Rack::RELEASE)"
diff --git a/src/spec/ruby/rack/application_spec.rb b/src/spec/ruby/rack/application_spec.rb
index d134e9c6c..dee169b28 100644
--- a/src/spec/ruby/rack/application_spec.rb
+++ b/src/spec/ruby/rack/application_spec.rb
@@ -300,8 +300,8 @@ def newRuntime()
 
       it "creates a new Ruby runtime with the jruby-rack environment pre-loaded" do
         @runtime = app_factory.newRuntime
-        should_not_eval_as_nil "defined?(::Rack)"
-        should_not_eval_as_nil "defined?(::Rack::Handler::Servlet)"
+        should_eval_as_not_nil "defined?(::Rack)"
+        should_eval_as_not_nil "defined?(::Rack::Handler::Servlet)"
         should_eval_as_nil "defined?(Rack::Handler::Bogus)"
       end
 
@@ -330,7 +330,7 @@ def newRuntime()
         app_factory.checkAndSetRackVersion(@runtime)
         @runtime.evalScriptlet "require 'rack'"
 
-        should_not_eval_as_nil "defined?(Bundler)"
+        should_eval_as_not_nil "defined?(Bundler)"
         should_eval_as_eql_to "Rack.release", '2.2.0'
         should_eval_as_eql_to "Gem.loaded_specs['rack'].version.to_s", '2.2.0'
       end
diff --git a/src/spec/ruby/spec_helper.rb b/src/spec/ruby/spec_helper.rb
index a97c00543..7af5be903 100644
--- a/src/spec/ruby/spec_helper.rb
+++ b/src/spec/ruby/spec_helper.rb
@@ -86,42 +86,25 @@ def expect_eql_java_bytes(actual, expected)
 
   # org.jruby.Ruby.evalScriptlet helpers - comparing values from different runtimes
 
-  def should_eval_as_eql_to(code, expected, options = {})
-    if options.is_a?(Hash)
-      runtime = options[:runtime] || @runtime
-    else
-      runtime, options = options, {}
-    end
-    message = options[:message] || "expected eval #{code.inspect} to be == $expected but was $actual"
-    be_flag = options.has_key?(:should) ? options[:should] : be_truthy
-
-    expected = expected.inspect.to_java
-    actual = runtime.evalScriptlet(code).inspect.to_java
-    expect(actual.equals(expected)).to be_flag, message.gsub('$expected', expected.to_s).gsub('$actual', actual.to_s)
+  def should_eval_as_eql_to(code, expected)
+    actual = @runtime.evalScriptlet(code)
+    expect(actual.inspect).to eq(expected.inspect), "expected eval #{code.inspect} to be == #{expected.to_s} but was #{actual.to_s}"
   end
 
-  def should_eval_as_not_eql_to(code, expected, options = {})
-    should_eval_as_eql_to(code, expected, options.merge(
-      :should => be_falsy,
-      :message => options[:message] || "expected eval #{code.inspect} to be != $expected but was not")
-    )
+  def should_eval_as_not_eql_to(code, expected)
+    actual = @runtime.evalScriptlet(code)
+    expect(actual.inspect).not_to eq(expected.inspect), "expected eval #{code.inspect} NOT to be == #{expected.to_s}"
   end
 
-  def should_eval_as_nil(code, runtime = @runtime)
-    should_eval_as_eql_to code, nil, :runtime => runtime,
-                          :message => "expected eval #{code.inspect} to be nil but was $actual"
+  def should_eval_as_nil(code)
+    actual = @runtime.evalScriptlet(code)
+    expect(actual).to be_nil, "expected eval #{code.inspect} to be nil but was #{actual.to_s}"
   end
 
-  def should_eval_as_not_nil(code, runtime = @runtime)
-    should_eval_as_eql_to code, nil, :should => be_falsy, :runtime => runtime,
-                          :message => "expected eval #{code.inspect} to not be nil but was"
+  def should_eval_as_not_nil(code)
+    actual = @runtime.evalScriptlet(code)
+    expect(actual).to_not be_nil, "expected eval #{code.inspect} to not be nil"
   end
-
-  def should_not_eval_as_nil(code, runtime = @runtime)
-    # alias
-    should_eval_as_not_nil(code, runtime)
-  end
-
 end
 
 # NOTE: avoid chunked-patch (loaded by default from a hook at