tryouts 3.0.0.pre2 → 3.1.0

data/lib/tryouts/expectation_evaluators/expectation_result.rb

@@ -0,0 +1,67 @@
+# lib/tryouts/expectation_evaluators/expectation_result.rb
+
+class Tryouts
+  module ExpectationEvaluators
+    # Extensible container for evaluation context data
+    #
+    # Provides immutable data structure for passing test results and timing data to evaluators.
+    # Uses Data.define for lightweight implementation. Stores timing in nanoseconds internally,
+    # converts to milliseconds for display. Enables adding future metrics (memory, CPU) without
+    # breaking evaluator method signatures.
+    #
+    # Usage:
+    #   ExpectationResult.from_result(actual_result)                           # Regular expectations
+    #   ExpectationResult.from_timing(actual_result, execution_time_ns)        # Performance expectations
+    #   ExpectationResult.from_execution_with_output(actual_result, stdout, stderr) # Output expectations
+    #
+    # Variables available in eval_expectation_content:
+    #   result, _ : actual_result (regular) or execution_time_ms (performance)
+    ExpectationResult = Data.define(:actual_result, :execution_time_ns, :start_time_ns, :end_time_ns, :stdout_content, :stderr_content) do
+      # Convert nanoseconds to milliseconds for human-readable timing
+      # Used for display and as the value of `result`/`_` variables in performance expectations
+      def execution_time_ms
+        execution_time_ns ? (execution_time_ns / 1_000_000.0).round(2) : nil
+      end
+
+      # Helper to create a basic packet with just actual result
+      # Used by: regular, true, false, boolean, result_type, regex_match, exception evaluators
+      def self.from_result(actual_result)
+        new(
+          actual_result: actual_result,
+          execution_time_ns: nil,
+          start_time_ns: nil,
+          end_time_ns: nil,
+          stdout_content: nil,
+          stderr_content: nil
+        )
+      end
+
+      # Helper to create a timing packet with execution data
+      # Used by: performance_time evaluator
+      # Future: Could accept additional timing or resource metrics
+      def self.from_timing(actual_result, execution_time_ns, start_time_ns = nil, end_time_ns = nil)
+        new(
+          actual_result: actual_result,
+          execution_time_ns: execution_time_ns,
+          start_time_ns: start_time_ns,
+          end_time_ns: end_time_ns,
+          stdout_content: nil,
+          stderr_content: nil
+        )
+      end
+
+      # Helper to create a packet with captured output data
+      # Used by: output evaluator for stdout/stderr expectations
+      def self.from_execution_with_output(actual_result, stdout_content, stderr_content, execution_time_ns = nil)
+        new(
+          actual_result: actual_result,
+          execution_time_ns: execution_time_ns,
+          start_time_ns: nil,
+          end_time_ns: nil,
+          stdout_content: stdout_content,
+          stderr_content: stderr_content
+        )
+      end
+    end
+  end
+end

data/lib/tryouts/expectation_evaluators/false.rb

@@ -0,0 +1,60 @@
+# lib/tryouts/expectation_evaluators/false.rb
+
+require_relative 'base'
+
+class Tryouts
+  module ExpectationEvaluators
+    # Evaluator for boolean false expectations using syntax: #=/=> expression
+    #
+    # PURPOSE:
+    # - Validates that an expression evaluates to exactly false (not falsy)
+    # - Provides explicit boolean validation for documentation-style tests
+    # - Distinguishes between true/false and truthy/falsy values
+    #
+    # SYNTAX: #=/=> boolean_expression
+    # Examples:
+    #   [1, 2, 3]  #=/=> result.empty?            # Pass: expression is false
+    #   [1, 2, 3]  #=/=> result.include?(5)       # Pass: expression is false
+    #   []         #=/=> result.include?(1)       # Pass: expression is false
+    #   []         #=/=> result.empty?            # Fail: expression is true
+    #   [1, 2, 3]  #=/=> result.first             # Fail: expression is 1 (truthy but not false)
+    #   []         #=/=> result.first             # Fail: expression is nil (falsy but not false)
+    #
+    # BOOLEAN STRICTNESS:
+    # - Only passes when expression evaluates to exactly false (not falsy)
+    # - Fails for true, nil, 0, "", [], {}, or any non-false value
+    # - Uses Ruby's === comparison for exact boolean matching
+    # - Encourages explicit boolean expressions in documentation
+    #
+    # IMPLEMENTATION DETAILS:
+    # - Expression has access to `result` and `_` variables (actual_result)
+    # - Expected display shows 'false (exactly)' for clarity
+    # - Actual display shows the evaluated expression result
+    # - Distinguishes from regular expectations through strict false matching
+    #
+    # DESIGN DECISIONS:
+    # - Strict false matching prevents accidental falsy value acceptance
+    # - Clear expected display explains the exact requirement
+    # - Expression evaluation provides flexible boolean logic testing
+    # - Part of unified #= prefix convention for all expectation types
+    # - Uses #=/=> syntax to visually distinguish from true expectations
+    class False < Base
+      def self.handles?(expectation_type)
+        expectation_type == :false # rubocop:disable Lint/BooleanSymbol
+      end
+
+      def evaluate(actual_result = nil)
+        expectation_result = ExpectationResult.from_result(actual_result)
+        expression_result = eval_expectation_content(@expectation.content, expectation_result)
+
+        build_result(
+          passed: expression_result == false,
+          actual: expression_result,
+          expected: false,
+        )
+      rescue StandardError => ex
+        handle_evaluation_error(ex, actual_result)
+      end
+    end
+  end
+end

data/lib/tryouts/expectation_evaluators/intentional_failure.rb

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

data/lib/tryouts/expectation_evaluators/output.rb

@@ -0,0 +1,101 @@
+# lib/tryouts/expectation_evaluators/output.rb
+
+require_relative 'base'
+
+class Tryouts
+  module ExpectationEvaluators
+    # Evaluator for output expectations using syntax: #=1> content, #=2> content
+    #
+    # PURPOSE:
+    # - Validates that stdout (pipe 1) or stderr (pipe 2) contains expected content
+    # - Provides ability to test console output, error messages, and logging
+    # - Supports both string contains and regex pattern matching
+    #
+    # SYNTAX:
+    # - #=1> expression  - Test stdout content
+    # - #=2> expression  - Test stderr content
+    #
+    # Examples:
+    #   puts "Hello World"           #=1> "Hello"            # String contains check
+    #   puts "Hello World"           #=1> /Hello.*World/     # Regex pattern match
+    #   $stderr.puts "Error!"        #=2> "Error"            # Stderr contains check
+    #   $stderr.puts "Warning: 404"  #=2> /Warning.*\d+/     # Stderr regex match
+    #
+    # MATCHING BEHAVIOR:
+    # - String expectations: Uses String#include? for substring matching
+    # - Regex expectations: Uses =~ operator for pattern matching
+    # - Auto-detects expectation type based on content (literal string vs regex)
+    # - Case-sensitive matching for both strings and regex patterns
+    #
+    # IMPLEMENTATION DETAILS:
+    # - Requires output capture during test execution
+    # - Expression has access to `result` and `_` variables (actual_result)
+    # - Expected display shows the evaluated expression result
+    # - Actual display shows captured output content for the specific pipe
+    # - Supports evaluation of dynamic expressions in expectation content
+    #
+    # DESIGN DECISIONS:
+    # - Uses POSIX pipe convention: 1=stdout, 2=stderr
+    # - Always captures output for debugging regardless of expectations
+    # - Supports both literal strings and regex patterns seamlessly
+    # - Part of unified #= prefix convention for all expectation types
+    # - Uses #=N> syntax where N is the pipe number (following shell convention)
+    #
+    # PIPE MAPPING:
+    # - Pipe 1: Standard output (stdout) - $stdout, puts, print, p
+    # - Pipe 2: Standard error (stderr) - $stderr, warn, STDERR.puts
+    # - Future pipes (3+) could support custom streams if needed
+    class Output < Base
+      def self.handles?(expectation_type)
+        expectation_type == :output
+      end
+
+      def evaluate(actual_result = nil, stdout_content = nil, stderr_content = nil)
+        # Determine which pipe we're testing based on expectation metadata
+        pipe_number = @expectation.respond_to?(:pipe) ? @expectation.pipe : 1
+
+        # Get the appropriate captured content
+        captured_content = case pipe_number
+                          when 1 then stdout_content || ""
+                          when 2 then stderr_content || ""
+                          else ""
+                          end
+
+        # Create result packet for expression evaluation
+        expectation_result = ExpectationResult.from_execution_with_output(actual_result, stdout_content, stderr_content)
+
+        # Evaluate the expectation expression (could be string literal or regex)
+        expected_pattern = eval_expectation_content(@expectation.content, expectation_result)
+
+        # Determine matching strategy based on expectation type
+        matched = case expected_pattern
+                  when Regexp
+                    # Regex pattern matching
+                    !!(captured_content =~ expected_pattern)
+                  when String
+                    # String contains matching
+                    captured_content.include?(expected_pattern)
+                  else
+                    # Convert to string and do contains check
+                    captured_content.include?(expected_pattern.to_s)
+                  end
+
+        # Build result with appropriate pipe description
+        pipe_name = case pipe_number
+                   when 1 then "stdout"
+                   when 2 then "stderr"
+                   else "pipe#{pipe_number}"
+                   end
+
+        build_result(
+          passed: matched,
+          actual: "#{pipe_name}: #{captured_content.inspect}",
+          expected: expected_pattern.inspect,
+          expectation: @expectation.content
+        )
+      rescue StandardError => ex
+        handle_evaluation_error(ex, actual_result)
+      end
+    end
+  end
+end

data/lib/tryouts/expectation_evaluators/performance_time.rb

@@ -0,0 +1,81 @@
+# lib/tryouts/expectation_evaluators/performance_time.rb
+
+require_relative 'base'
+
+class Tryouts
+  module ExpectationEvaluators
+    # Evaluator for performance time expectations using syntax: #=%> milliseconds
+    #
+    # PURPOSE:
+    # - Validates that test execution time meets performance thresholds
+    # - Supports both static thresholds and dynamic expressions using timing data
+    # - Provides performance regression testing for documentation-style tests
+    #
+    # SYNTAX: #=%> threshold_expression
+    # Examples:
+    #   1 + 1           #=%> 100           # Pass: simple addition under 100ms
+    #   sleep(0.01)     #=%> 15            # Pass: 10ms sleep under 15ms (+10% tolerance)
+    #   Array.new(1000) #=%> 1             # Pass: array creation under 1ms
+    #   sleep(0.005)    #=%> result * 2    # Pass: 5ms execution, 10ms threshold
+    #   sleep(0.001)    #=%> 0.1           # Fail: 1ms execution exceeds 0.1ms + 10%
+    #
+    # TIMING DATA AVAILABILITY:
+    # In performance expectations, the timing data is available as:
+    # - `result`: execution time in milliseconds (e.g., 5.23)
+    # - `_`: alias for the same timing data
+    # This allows expressions like: #=%> result * 2, #=%> _ + 10
+    #
+    # TOLERANCE LOGIC:
+    # - Performance expectations use "less than or equal to + 10%" logic
+    # - Formula: actual_time_ms <= expected_limit_ms * 1.1
+    # - This differs from strict window matching - only cares about upper bound
+    # - Designed for performance regression testing, not precision timing
+    #
+    # IMPLEMENTATION DETAILS:
+    # - Timing captured in nanoseconds for precision, displayed in milliseconds
+    # - Uses Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond) for accuracy
+    # - Expected display shows evaluated threshold (e.g., "100", "10.5")
+    # - Actual display shows formatted timing (e.g., "5.23ms")
+    # - Timing data passed via ExpectationResult for extensibility
+    #
+    # DESIGN DECISIONS:
+    # - Chosen "less than or equal to + 10%" over strict window for usability
+    # - Nanosecond capture → millisecond display for precision + readability
+    # - Expression evaluation with timing context for flexible thresholds
+    # - Separate evaluate method signature to receive timing data from testbatch
+    class PerformanceTime < Base
+      def self.handles?(expectation_type)
+        expectation_type == :performance_time
+      end
+
+      def evaluate(actual_result = nil, execution_time_ns = nil)
+        if execution_time_ns.nil?
+          return build_result(
+            passed: false,
+            actual: 'No timing data available',
+            expected: 'Performance measurement',
+            error: 'Performance expectations require execution timing data'
+          )
+        end
+
+        # Create result packet with timing data available to expectation
+        expectation_result = ExpectationResult.from_timing(actual_result, execution_time_ns)
+        expected_limit_ms = eval_expectation_content(@expectation.content, expectation_result)
+
+        actual_time_ms = expectation_result.execution_time_ms
+
+        # Performance tolerance: actual <= expected + 10% (not strict window)
+        max_allowed_ms = expected_limit_ms * 1.1
+        within_tolerance = actual_time_ms <= max_allowed_ms
+
+        build_result(
+          passed: within_tolerance,
+          actual: "#{actual_time_ms}ms",
+          expected: expected_limit_ms,
+        )
+      rescue StandardError => ex
+        handle_evaluation_error(ex, actual_result)
+      end
+    end
+  end
+end

data/lib/tryouts/expectation_evaluators/regex_match.rb

@@ -0,0 +1,57 @@
+# lib/tryouts/expectation_evaluators/regex_match.rb
+
+require_relative 'base'
+
+class Tryouts
+  module ExpectationEvaluators
+    # Evaluator for regex match expectations using syntax: #=~> /pattern/
+    #
+    # PURPOSE:
+    # - Validates that the test result matches a regular expression pattern
+    # - Supports all Ruby regex features (anchors, flags, groups, etc.)
+    # - Provides pattern matching for string validation in documentation-style tests
+    #
+    # SYNTAX: #=~> /pattern/flags
+    # Examples:
+    #   "hello world"      #=~> /hello/           # Pass: basic pattern match
+    #   "user@example.com" #=~> /^[^@]+@[^@]+$/   # Pass: email validation pattern
+    #   "Phone: 555-1234"  #=~> /\d{3}-\d{4}/     # Pass: phone number pattern
+    #   "HELLO WORLD"      #=~> /hello/i          # Pass: case insensitive match
+    #   "hello world"      #=~> /goodbye/         # Fail: pattern not found
+    #
+    # IMPLEMENTATION DETAILS:
+    # - Converts actual_result to string using to_s for regex matching
+    # - Uses Ruby's =~ operator for pattern matching (returns match position or nil)
+    # - Evaluates expectation content to resolve regex patterns with flags
+    # - Expected display shows pattern.inspect (e.g., "/hello/i", "/\d+/")
+    # - Actual display shows stringified result for pattern comparison
+    #
+    # DESIGN DECISIONS:
+    # - Always converts to string (allows regex matching on any object)
+    # - Uses =~ operator (Ruby standard) rather than match? for compatibility
+    # - Pattern evaluation supports dynamic regex construction
+    # - Displays pattern.inspect for clear regex representation
+    class RegexMatch < Base
+      def self.handles?(expectation_type)
+        expectation_type == :regex_match
+      end
+
+      def evaluate(actual_result = nil)
+        expectation_result = ExpectationResult.from_result(actual_result)
+        pattern = eval_expectation_content(@expectation.content, expectation_result)
+
+        # Convert actual_result to string for regex matching
+        string_result = actual_result.to_s
+        match_result = string_result =~ pattern
+
+        build_result(
+          passed: !match_result.nil?,
+          actual: string_result,
+          expected: pattern.inspect,
+        )
+      rescue StandardError => ex
+        handle_evaluation_error(ex, actual_result)
+      end
+    end
+  end
+end

data/lib/tryouts/expectation_evaluators/registry.rb

@@ -0,0 +1,66 @@
+# lib/tryouts/expectation_evaluators/registry.rb
+
+require_relative 'expectation_result'
+require_relative 'base'
+require_relative 'regular'
+require_relative 'exception'
+require_relative 'boolean'
+require_relative 'true'
+require_relative 'false'
+require_relative 'result_type'
+require_relative 'regex_match'
+require_relative 'performance_time'
+require_relative 'intentional_failure'
+require_relative 'output'
+
+class Tryouts
+  module ExpectationEvaluators
+    class Registry
+      @evaluators = []
+
+      class << self
+        attr_reader :evaluators
+
+        def evaluator_for(expectation, test_case, context)
+          evaluator_class = find_evaluator_class(expectation.type)
+
+          unless evaluator_class
+            raise ArgumentError, "No evaluator found for expectation type: #{expectation.type}"
+          end
+
+          evaluator_class.new(expectation, test_case, context)
+        end
+
+        def register(evaluator_class)
+          unless evaluator_class < Base
+            raise ArgumentError, 'Evaluator must inherit from ExpectationEvaluators::Base'
+          end
+
+          @evaluators << evaluator_class unless @evaluators.include?(evaluator_class)
+        end
+
+        def registered_evaluators
+          @evaluators.dup
+        end
+
+        private
+
+        def find_evaluator_class(expectation_type)
+          @evaluators.find { |evaluator_class| evaluator_class.handles?(expectation_type) }
+        end
+      end
+
+      # Auto-register built-in evaluators
+      register(Regular)
+      register(Exception)
+      register(Boolean)
+      register(True)
+      register(False)
+      register(ResultType)
+      register(RegexMatch)
+      register(PerformanceTime)
+      register(IntentionalFailure)
+      register(Output)
+    end
+  end
+end

data/lib/tryouts/expectation_evaluators/regular.rb

@@ -0,0 +1,67 @@
+# lib/tryouts/expectation_evaluators/regular.rb
+
+require_relative 'base'
+
+class Tryouts
+  module ExpectationEvaluators
+    # Evaluator for standard equality expectations using syntax: #=> expression
+    #
+    # PURPOSE:
+    # - Validates that test result equals the evaluated expectation expression
+    # - Provides the fundamental equality-based testing mechanism
+    # - Serves as the default and most commonly used expectation type
+    #
+    # SYNTAX: #=> expression
+    # Examples:
+    #   1 + 1         #=> 2                        # Pass: 2 == 2
+    #   [1, 2, 3]     #=> result.length            # Pass: [1,2,3] == 3 (fails, different types)
+    #   [1, 2, 3]     #=> [1, 2, 3]               # Pass: array equality
+    #   "hello"       #=> "hello"                 # Pass: string equality
+    #   [1, 2, 3]     #=> result.sort              # Pass: [1,2,3] == [1,2,3]
+    #   { a: 1 }      #=> { a: 1 }                # Pass: hash equality
+    #   1 + 1         #=> result                  # Pass: 2 == 2 (result variable access)
+    #
+    # EQUALITY SEMANTICS:
+    # - Uses Ruby's == operator for equality comparison
+    # - Supports all Ruby types: primitives, collections, objects
+    # - Type-sensitive: 2 != "2", [1] != 1, nil != false
+    # - Reference-independent: compares values not object identity
+    #
+    # IMPLEMENTATION DETAILS:
+    # - Expression has access to `result` and `_` variables (actual_result)
+    # - Expected display shows the evaluated expression result (not raw content)
+    # - Actual display shows the test result value
+    # - Most flexible evaluator supporting arbitrary Ruby expressions
+    #
+    # DESIGN DECISIONS:
+    # - Standard equality provides intuitive testing behavior
+    # - Expression evaluation enables dynamic expectations (result.length, etc.)
+    # - Uses #=> syntax as the canonical expectation notation
+    # - Evaluated expected display prevents confusion with literal text content
+    # - Part of unified #= prefix convention for all expectation types
+    # - Serves as fallback when no specialized evaluator applies
+    #
+    # VARIABLE ACCESS:
+    # - `result`: contains the actual test result value
+    # - `_`: shorthand alias for the same actual result value
+    # - Enables expectations like: #=> result.upcase, #=> _.first, #=> result * 2
+    class Regular < Base
+      def self.handles?(expectation_type)
+        expectation_type == :regular
+      end
+
+      def evaluate(actual_result = nil)
+        expectation_result = ExpectationResult.from_result(actual_result)
+        expected_value = eval_expectation_content(@expectation.content, expectation_result)
+
+        build_result(
+          passed: actual_result == expected_value,
+          actual: actual_result,
+          expected: expected_value,
+        )
+      rescue StandardError => ex
+        handle_evaluation_error(ex, actual_result)
+      end
+    end
+  end
+end

data/lib/tryouts/expectation_evaluators/result_type.rb

@@ -0,0 +1,51 @@
+# lib/tryouts/expectation_evaluators/result_type.rb
+
+require_relative 'base'
+
+class Tryouts
+  module ExpectationEvaluators
+    # Evaluator for result type expectations using syntax: #=:> ClassName
+    #
+    # PURPOSE:
+    # - Validates that the test result is an instance of the expected class or its ancestors
+    # - Supports both exact class matches and inheritance (String is_a? Object)
+    # - Provides clean type validation for documentation-style tests
+    #
+    # SYNTAX: #=:> ClassName
+    # Examples:
+    #   "hello"     #=:> String     # Pass: String.is_a?(String)
+    #   [1, 2, 3]   #=:> Array      # Pass: Array.is_a?(Array)
+    #   42          #=:> Integer    # Pass: Integer.is_a?(Integer)
+    #   "hello"     #=:> Object     # Pass: String.is_a?(Object) - inheritance
+    #   "hello"     #=:> Integer    # Fail: String is not Integer
+    #
+    # IMPLEMENTATION DETAILS:
+    # - Uses Ruby's is_a? method for type checking (supports inheritance)
+    # - Evaluates expectation content to resolve class constants (String, Array, etc.)
+    # - Expected display shows the evaluated class name (e.g., "String", "Integer")
+    # - Actual display shows the actual result's class for easy comparison
+    #
+    # DESIGN DECISIONS:
+    # - Chose is_a? over class == for inheritance support
+    # - Class resolution through evaluation allows dynamic class references
+    # - Clean expected/actual display focuses on type comparison
+    class ResultType < Base
+      def self.handles?(expectation_type)
+        expectation_type == :result_type
+      end
+
+      def evaluate(actual_result = nil)
+        expectation_result = ExpectationResult.from_result(actual_result)
+        expected_class = eval_expectation_content(@expectation.content, expectation_result)
+
+        build_result(
+          passed: actual_result.is_a?(expected_class),
+          actual: actual_result.class,
+          expected: expected_class,
+        )
+      rescue StandardError => ex
+        handle_evaluation_error(ex, actual_result)
+      end
+    end
+  end
+end