Fix formats in evaluation methods for protocol tests

CONTRIBUTING.md

@@ -381,17 +381,35 @@ Sends request to rdbg to terminate the debuggee.
 
 Passes if reattaching to rdbg is successful.
 
-- assert_hover_result(expected, expression: nil)
+- assert_hover_result(expected, expression)
 
-Passes if result of `expression` is equal to `expected`.
+Passes if result of `expression` matches `expected`.
 
-- assert_repl_result(expected, expression: nil)
+`expected` need to be a Hash object as follows:
 
-Passes if result of `expression` is equal to `expected`.
+`assert_hover_result({value: '2', type: 'Integer'}, 'a')`
 
-- assert_watch_result(expected, expression: nil)
+NOTE: `value` and `type` need to be strings.
 
-Passes if result of `expression` is equal to `expected`.
+- assert_repl_result(expected, expression)
+
+Passes if result of `expression` matches `expected`.
+
+`expected` need to be a Hash object as follows:
+
+`assert_repl_result({value: '2', type: 'Integer'}, 'a')`
+
+NOTE: `value` and `type` need to be strings.
+
+- assert_watch_result(expected, expression)
+
+Passes if result of `expression` matches `expected`.
+
+`expected` need to be a Hash object as follows:
+
+`assert_watch_result({value: '2', type: 'Integer'}, 'a')`
+
+NOTE: `value` and `type` need to be strings.
 
 - assert_line_num(expected)
 

test/protocol/eval_test.rb

@@ -17,9 +17,9 @@ def test_eval_evaluates_arithmetic_expressions
       run_protocol_scenario PROGRAM do
         req_add_breakpoint 5
         req_continue
-        assert_repl_result 2, expression: 'a'
-        assert_repl_result 4, expression: 'd'
-        assert_repl_result 3, expression: '1+2'
+        assert_repl_result({value: '2', type: 'Integer'}, 'a')
+        assert_repl_result({value: '4', type: 'Integer'}, 'd')
+        assert_repl_result({value: '3', type: 'Integer'}, '1+2')
         req_terminate_debuggee
       end
     end

test/protocol/hover_test.rb

@@ -17,9 +17,9 @@ def test_hover_matches_with_stopped_place
       run_protocol_scenario PROGRAM do
         req_add_breakpoint 4
         req_continue
-        assert_hover_result 2, expression: 'b'
-        assert_hover_result 3, expression: 'c'
-        assert_hover_result 1, expression: 'a'
+        assert_hover_result({value: '2', type: 'Integer'}, 'b')
+        assert_hover_result({value: '3', type: 'Integer'}, 'c')
+        assert_hover_result({value: '1', type: 'Integer'}, 'a')
         req_terminate_debuggee
       end
     end
@@ -32,8 +32,7 @@ class HoverTest2 < ProtocolTestCase
 
     def test_hover_returns_method_info
       run_protocol_scenario PROGRAM do
-        b = TOPLEVEL_BINDING.dup
-        assert_hover_result b.eval('self').method(:p), expression: 'p'
+        assert_hover_result({value: /\#<Method:\s.*p.*/, type: 'Method'}, 'p')
         req_terminate_debuggee
       end
     end
@@ -79,13 +78,13 @@ def test_hover_returns_const_info
       run_protocol_scenario PROGRAM do
         req_add_breakpoint 31
         req_continue
-        assert_hover_result Object.const_set('Abc', Module.new), expression: 'Abc'
-        assert_hover_result Abc.const_set('Def123', Class.new), expression: 'Abc::Def123'
-        assert_hover_result Abc::Def123.const_set('Ghi', Class.new), expression: 'Abc::Def123::Ghi'
-        assert_hover_result Abc::Def123::Ghi, expression: 'Abc::Def123::Ghi.new'
-        assert_hover_result Abc, expression: '::Abc.foo'
-        assert_hover_result Abc::Def123, expression: '::Abc::Def123'
-        assert_hover_result Abc::Def123, expression: '::Abc::Def123.bar'
+        assert_hover_result({value: 'Abc', type: 'Module'}, 'Abc')
+        assert_hover_result({value: 'Abc::Def123', type: 'Class'}, 'Abc::Def123')
+        assert_hover_result({value: 'Abc::Def123::Ghi', type: 'Class'}, 'Abc::Def123::Ghi')
+        assert_hover_result({value: 'Abc::Def123::Ghi', type: 'Class'}, 'Abc::Def123::Ghi.new')
+        assert_hover_result({value: 'Abc', type: 'Module'}, '::Abc.foo')
+        assert_hover_result({value: 'Abc::Def123', type: 'Class'}, '::Abc::Def123')
+        assert_hover_result({value: 'Abc::Def123', type: 'Class'}, '::Abc::Def123.bar')
         req_terminate_debuggee
       end
     end

test/protocol/watch_test.rb

@@ -17,11 +17,11 @@ class WatchTest < ProtocolTestCase
     def test_watch_matches_with_stopped_place
       run_protocol_scenario PROGRAM do
         req_next
-        assert_watch_result 2, expression: 'a'
+        assert_watch_result({value: '2', type: 'Integer'}, 'a')
         req_next
-        assert_watch_result 3, expression: 'a'
+        assert_watch_result({value: '3', type: 'Integer'}, 'a')
         req_next
-        assert_watch_result 4, expression: 'a'
+        assert_watch_result({value: '4', type: 'Integer'}, 'a')
         req_terminate_debuggee
       end
     end

test/support/protocol_test_case.rb

@@ -250,7 +250,7 @@ def assert_threads_result(expected_names)
       end
     end
 
-    def assert_hover_result expected,  expression: nil, frame_idx: 0
+    def assert_hover_result expected, expression, frame_idx: 0
       case ENV['RUBY_DEBUG_TEST_UI']
       when 'vscode'
         assert_eval_result 'hover', expression, expected, frame_idx
@@ -259,7 +259,7 @@ def assert_hover_result expected,  expression: nil, frame_idx: 0
       end
     end
 
-    def assert_repl_result expected,  expression: nil, frame_idx: 0
+    def assert_repl_result expected,  expression, frame_idx: 0
       case ENV['RUBY_DEBUG_TEST_UI']
       when 'vscode'
         assert_eval_result 'repl', expression, expected, frame_idx
@@ -268,7 +268,7 @@ def assert_repl_result expected,  expression: nil, frame_idx: 0
       end
     end
 
-    def assert_watch_result expected,  expression: nil, frame_idx: 0
+    def assert_watch_result expected,  expression, frame_idx: 0
       case ENV['RUBY_DEBUG_TEST_UI']
       when 'vscode'
         assert_eval_result 'watch', expression, expected, frame_idx
@@ -416,6 +416,13 @@ def attach_to_cdp_server
       @crt_frames = res.dig(:params, :callFrames)
     end
 
+    JAVASCRIPT_TYPE_TO_CLASS_MAPS = {
+      'string' => String,
+      'number' => Integer,
+      'boolean' => [TrueClass, FalseClass],
+      'symbol' => Symbol
+    }
+
     def assert_eval_result context, expression, expected, frame_idx
       case ENV['RUBY_DEBUG_TEST_UI']
       when 'vscode'
@@ -430,17 +437,19 @@ def assert_eval_result context, expression, expected, frame_idx
                       context: context
 
         failure_msg = FailureMessage.new{create_protocol_message "result:\n#{JSON.pretty_generate res}"}
-        if expected.is_a? String
-          expected_val = expected
-        else
-          expected_val = expected.inspect
+        if expected[:type] == 'String'
+          expected[:value] = expected[:value].inspect
         end
-        result_val = res.dig(:body, :result)
-        assert_equal expected_val, result_val, failure_msg
 
-        expected_type = expected.class.inspect
         result_type = res.dig(:body, :type)
-        assert_equal expected_type, result_type, failure_msg
+        assert_equal expected[:type], result_type, failure_msg
+
+        result_val = res.dig(:body, :result)
+        if expected[:value].is_a? Regexp
+          assert_match expected[:value], result_val, failure_msg
+        else
+          assert_equal expected[:value], result_val, failure_msg
+        end
       when 'chrome'
         f_id = @crt_frames.dig(frame_idx, :callFrameId)
         res = send_cdp_request 'Debugger.evaluateOnCallFrame',
@@ -449,35 +458,17 @@ def assert_eval_result context, expression, expected, frame_idx
                       objectGroup: context
 
         failure_msg = FailureMessage.new{create_protocol_message "result:\n#{JSON.pretty_generate res}"}
-        if expected.is_a? String
-          expected_val = expected
-        else
-          expected_val = expected.inspect
-        end
-        result_val = res.dig(:result, :result, :description)
-        assert_equal expected_val, result_val, failure_msg
 
-        expected_type = get_expected_type expected
-        result_type = res.dig(:result, :result, :type)
-        if result_type == 'object'
-          result_type = res.dig(:result, :result, :className)
-        end
-        assert_equal expected_type, result_type, failure_msg
-      end
-    end
+        cl = res.dig(:result, :result, :className) || JAVASCRIPT_TYPE_TO_CLASS_MAPS[res.dig(:result, :result, :type)].inspect
+        result_type = Array cl
+        assert_include result_type, expected[:type], failure_msg
 
-    def get_expected_type obj
-      case obj
-      when String
-        'string'
-      when TrueClass, FalseClass
-        'boolean'
-      when Symbol
-        'symbol'
-      when Integer, Float
-        'number'
-      else
-        obj.class.inspect
+        result_val = res.dig(:result, :result, :description)
+        if expected[:value].is_a? Regexp
+          assert_match expected[:value], result_val, failure_msg
+        else
+          assert_equal expected[:value], result_val, failure_msg
+        end
       end
     end