class Tryouts::ExpectationEvaluators::IntentionalFailure

  • Provides clear messaging about intentional failure semantics
    - Inverts the passed result while preserving actual/expected values
    - Delegates evaluation to Regular evaluator
    - Creates a temporary regular expectation with same content
    DELEGATION PATTERN:
    - Part of unified #= prefix convention for all expectation types
    - Clear messaging indicates this is an intentional failure test
    - Preserves original expectation details for debugging
    - Delegates to regular evaluator to maintain consistency
    - Uses #=<> syntax (angle brackets suggest “opposite/inverted direction”)
    DESIGN DECISIONS:
    - Inverts only the final passed/failed status, preserving other metadata
    - Actual display shows the test result value
    - Expected display shows the evaluated expression result for clarity
    - Expression has access to ‘result` and `_` variables (actual_result)
    - Uses delegation pattern to wrap the regular evaluator
    IMPLEMENTATION DETAILS:
    - Preserves all error details and content from underlying expectation
    - If underlying expectation would fail, intentional failure passes
    - If underlying expectation would pass, intentional failure fails
    - Takes any valid expectation expression and inverts the result
    FAILURE INVERSION:
    “test” #=<> /d+/ # Pass: “test” doesn’t match digits
    [1, 2, 3] #=<> result.empty? # Pass: array is not empty
    “hello” #=<> result.include?(“x”) # Pass: “hello” doesn’t contain “x”
    1 + 1 #=<> 3 # Pass: 1+1 ≠ 3, so failure expected
    Examples:
    SYNTAX: #=<> expression
    - Useful for testing error conditions and boundary cases
    - Provides ability to test negative cases and expected failures
    - Validates that an expectation intentionally fails (passes when the underlying expectation fails)
    PURPOSE:
    Evaluator for intentional failure expectations using syntax: #=<> expression

def self.handles?(expectation_type) 

def self.handles?(expectation_type)
  expectation_type == :intentional_failure
end

def evaluate(actual_result = nil) 

def evaluate(actual_result = nil)
  # Create a temporary regular expectation for delegation
  regular_expectation = Expectation.new(content: @expectation.content, type: :regular)
  # Delegate to regular evaluator
  regular_evaluator = Regular.new(regular_expectation, @test_case, @context)
  regular_result    = regular_evaluator.evaluate(actual_result)
  # Invert the result while preserving metadata
  build_result(
    passed: !regular_result[:passed],
    actual: regular_result[:actual],
    expected: "NOT #{regular_result[:expected]} (intentional failure)",
    expectation: @expectation.content,
  )
rescue StandardError => ex
  # If evaluation itself fails (not the expectation), that's a real error
  handle_evaluation_error(ex, actual_result)
end