Back to Repositories

Testing IndirectImmediateExecutor Thread Management in concurrent-ruby

This test suite validates the IndirectImmediateExecutor implementation in concurrent-ruby, focusing on synchronous task execution and thread management. It ensures proper executor service behavior while verifying tasks run immediately but on separate threads.

Test Coverage Overview

The test suite provides comprehensive coverage of the IndirectImmediateExecutor class functionality.

Key areas tested include:

Executor service compliance through shared examples
Synchronous task execution timing
Thread isolation and management
Immediate execution behavior verification

Implementation Analysis

The testing approach combines shared behavior specifications with specific execution tests. It utilizes RSpec’s shared examples pattern to verify executor service compliance while adding targeted tests for immediate execution characteristics.

Technical implementation details:

Shared executor service behaviors
Time-based execution verification
Thread context validation

Technical Details

Testing tools and configuration:

RSpec testing framework
Time-based assertions for execution validation
Thread manipulation for isolation testing
Shared example inclusion for common executor behaviors

Best Practices Demonstrated

The test suite exemplifies several testing best practices in Ruby concurrent programming.

Notable practices include:

Shared behavior utilization for common executor patterns
Precise timing validations
Thread safety verification
Clear separation of concerns in test cases

ruby-concurrency/concurrent-ruby

spec/concurrent/executor/indirect_immediate_executor_spec.rb

            
require 'concurrent/executor/indirect_immediate_executor'
require_relative 'executor_service_shared'

module Concurrent

  RSpec.describe IndirectImmediateExecutor do

    subject { IndirectImmediateExecutor.new }

    it_should_behave_like :executor_service, immediate_type: true

    it "runs its tasks synchronously" do
      start = Time.now
      subject.post { sleep 0.1 }

      expect(Time.now - start).to be >= 0.1
    end

    it "runs the task on a separate thread" do
      used_thread = nil
      subject.post { used_thread = Thread.current }

      expect(used_thread).not_to be(Thread.current)
    end
  end
end