Add the new test framework for DAP

Author: ono-max

.gitignore

@@ -10,3 +10,4 @@
 /Gemfile.lock
 /lib/debug/debug.so
 .ruby-version
+/debugAdapterProtocol.json

Gemfile

@@ -6,3 +6,4 @@ gem "rake"
 gem "rake-compiler"
 gem "test-unit", "~> 3.0"
 gem "test-unit-rr"
+gem "json-schema"

lib/debug/server_dap.rb

@@ -145,8 +145,8 @@ def dap_setup bytes
     def send **kw
       kw[:seq] = @seq += 1
       str = JSON.dump(kw)
-      show_protocol '<', str
       @sock.write "Content-Length: #{str.bytesize}\r\n\r\n#{str}"
+      show_protocol '<', str
     end
 
     def send_response req, success: true, message: nil, **kw

test/support/assertions.rb

@@ -12,6 +12,15 @@ def assert_line_num(expected)
             expected == test_info.internal_info['line']
           end
         })
+      when 'vscode'
+        send_request 'stackTrace',
+                      threadId: 1,
+                      startFrame: 0,
+                      levels: 20
+        res = find_crt_response
+        failure_msg = FailureMessage.new{create_protocol_message "result:\n#{JSON.pretty_generate res}"}
+        result = res.dig(:body, :stackFrames, 0, :line)
+        assert_equal expected, result, failure_msg
       else
         raise 'Invalid environment variable'
       end

test/support/protocol_utils.rb

@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+module DEBUGGER__
+  module Protocol_TestUtils
+    class Detach < StandardError
+    end
+
+    DAP_JSON_PATH = "#{__dir__}/../../debugAdapterProtocol.json"
+
+    begin
+      require 'json-schema'
+      if File.exist? DAP_JSON_PATH
+        json = File.read(DAP_JSON_PATH)
+      else
+        json = Net::HTTP.get(URI.parse('https://microsoft.github.io/debug-adapter-protocol/debugAdapterProtocol.json'))
+        File.write DAP_JSON_PATH, json
+      end
+      DAP_JSON = JSON.parse(json, symbolize_names: true)
+    rescue LoadError
+    end
+
+    # API
+
+    def run_protocol_scenario program, &scenario
+      ENV['RUBY_DEBUG_TEST_PROTOCOL_MODE'] = 'true'
+      ENV['RUBY_DEBUG_TEST_UI'] = 'vscode'
+
+      write_temp_file(strip_line_num(program))
+
+      @remote_info = setup_unix_domain_socket_remote_debuggee
+      @bps_map = {} # {path: [bp_idx, lineno, condition], ...}
+      @bp_idx = 0
+      @res_backlog = []
+      @queue = Queue.new
+      @backlog = []
+
+      attach_to_rdbg
+      scenario.call
+
+      check_line_num!(program)
+      flunk create_protocol_message "Expected the debuggee program to finish" unless wait_pid @remote_info.pid, TIMEOUT_SEC
+    ensure
+      @reader_thread.kill
+      @sock.close
+      @remote_info.reader_thread.kill
+      @remote_info.r.close
+      @remote_info.w.close
+    end
+
+    def req_add_breakpoint lineno, path: temp_file_path, cond: nil
+      if @bps_map[path].nil?
+        @bps_map[path] = []
+      end
+      @bps_map[path] << [@bp_idx, lineno, cond]
+      @bp_idx += 1
+      req_set_breakpoints
+    end
+
+    def req_delete_breakpoint bpnum
+      @bps_map.each{|tar_path, bps|
+        bps.delete_if{|bp|
+          idx = bp[0]
+          bpnum == idx
+        }
+      }
+      req_set_breakpoints
+    end
+
+    def req_continue
+      send_request 'continue',
+                    threadId: 1
+      res = find_crt_response
+      assert_dap_res :ContinueResponse, res
+    end
+
+    def req_step
+      send_request 'stepIn',
+                    threadId: 1
+      res = find_crt_response
+      assert_dap_res :StepInResponse, res
+    end
+
+    def req_next
+      send_request 'next',
+                    threadId: 1
+      res = find_crt_response
+      assert_dap_res :NextResponse, res
+    end
+
+    def req_finish
+      send_request 'stepOut',
+                    threadId: 1
+      res = find_crt_response
+      assert_dap_res :StepOutResponse, res
+    end
+
+    def req_set_exception_breakpoints
+      send_request 'setExceptionBreakpoints',
+                    filters: [],
+                    filterOptions: [
+                      {
+                        filterId: 'RuntimeError'
+                      }
+                    ]
+      res = find_crt_response
+      assert_dap_res :SetExceptionBreakpointsResponse, res
+    end
+
+    def req_step_back
+      send_request 'stepBack',
+                    threadId: 1
+      # TODO: Return the response for "stepBack"
+      # res = find_crt_response
+      # assert_dap_res :StepBackResponse, res
+    end
+
+    def req_terminate_debuggee
+      send_request 'disconnect',
+                    restart: true,
+                    terminateDebuggee: true
+      assert_disconnect_result
+    end
+
+    def assert_reattach
+      req_disconnect
+      attach_to_rdbg
+      res = find_crt_response
+      result_cmd = res.dig(:command)
+      assert_equal 'configurationDone', result_cmd
+    end
+
+    def assert_hover_result expected,  expression: nil, frame_idx: 0
+      assert_eval_result 'hover', expression, expected, frame_idx
+    end
+
+    def assert_repl_result expected,  expression: nil, frame_idx: 0
+      assert_eval_result 'repl', expression, expected, frame_idx
+    end
+
+    def assert_watch_result expected,  expression: nil, frame_idx: 0
+      assert_eval_result 'watch', expression, expected, frame_idx
+    end
+
+    # Not API
+
+    def req_disconnect
+      send_request 'disconnect',
+                    restart: false,
+                    terminateDebuggee: false
+      assert_disconnect_result
+    end
+
+    def req_set_breakpoints
+      @bps_map.each{|tar_path, bps|
+        send_request 'setBreakpoints',
+                    source: {
+                      name: tar_path,
+                      path: tar_path,
+                      sourceReference: nil
+                    },
+                    breakpoints: bps.map{|_, lineno, condition|
+                      {
+                        line: lineno,
+                        condition: condition
+                      }
+                    }
+        res = find_crt_response
+        assert_dap_res :SetBreakpointsResponse, res
+      }
+    end
+
+    def assert_disconnect_result
+      res = find_crt_response
+      assert_dap_res :DisconnectResponse, res
+      @reader_thread.raise Detach
+      @sock.close
+    end
+
+    def attach_to_rdbg
+      @sock = Socket.unix @remote_info.sock_path
+      @seq = 1
+      @reader_thread = Thread.new do
+        while res = recv_response
+          @queue.push res
+        end
+      rescue Detach
+      end
+      sleep 0.001 while @reader_thread.status != 'sleep'
+      @reader_thread.run
+      INITIALIZE_DAP_MSGS.each{|msg| send **msg}
+    end
+    
+    def assert_eval_result context, expression, expected, frame_idx
+      send_request 'stackTrace',
+                    threadId: 1,
+                    startFrame: 0,
+                    levels: 20
+      res = find_crt_response
+      f_id = res.dig(:body, :stackFrames, frame_idx, :id)
+      send_request 'evaluate',
+                    expression: expression,
+                    frameId: f_id,
+                    context: context
+      res = find_crt_response
+      assert_dap_res :EvaluateResponse, res
+
+      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(: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
+    end
+
+    def send_request command, **kw
+      send type: 'request',
+            command: command,
+            arguments: kw
+    end
+
+    def send **kw
+      kw[:seq] = @seq += 1
+      str = JSON.dump(kw)
+      @sock.write "Content-Length: #{str.bytesize}\r\n\r\n#{str}"
+      @backlog << "V>D #{str}"
+    end
+
+    TIMEOUT_SEC = (ENV['RUBY_DEBUG_TIMEOUT_SEC'] || 10).to_i
+
+    def assert_dap_res expected_def, result_res
+      return unless defined? DAP_JSON
+
+      properties = DAP_JSON.dig(:definitions, expected_def, :allOf, 1)
+      err = nil
+      begin
+        JSON::Validator.validate!(DAP_JSON.merge(properties), result_res)
+      rescue JSON::Schema::ValidationError => e
+        err = e.message
+      end
+      if err
+        fail_msg = <<~MSG
+          expected:
+          #{JSON.pretty_generate properties}
+
+          result:
+          #{JSON.pretty_generate result_res}
+
+          #{err}
+        MSG
+        flunk create_protocol_message fail_msg
+      else
+        assert true
+      end
+    end
+
+    def find_crt_response
+      Timeout.timeout(TIMEOUT_SEC) do
+        loop do
+          res = @queue.pop
+          str = JSON.dump(res)
+          @backlog << "V<D #{str}"
+          if res[:request_seq] == @seq
+            return res
+          end
+        end
+      end
+    rescue Timeout::Error
+      flunk create_protocol_message "TIMEOUT ERROR (#{TIMEOUT_SEC} sec) while waiting seq: #{@seq}"
+    end
+
+    # FIXME: Commonalize this method.
+    def create_protocol_message fail_msg
+      all_protocol_msg = <<~DEBUGGER_MSG.chomp
+        -------------------------
+        | All Protocol Messages |
+        -------------------------
+
+        #{@backlog.join("\n")}
+      DEBUGGER_MSG
+
+      last_msg = @backlog.last(3).map{|log|
+        json = log.sub(/(D|V)(<|>)(D|V)\s/, '')
+        JSON.pretty_generate(JSON.parse json)
+      }.join("\n")
+
+      last_protocol_msg = <<~DEBUGGER_MSG.chomp
+        --------------------------
+        | Last Protocol Messages |
+        --------------------------
+
+        #{last_msg}
+      DEBUGGER_MSG
+
+      debuggee_msg =
+          <<~DEBUGGEE_MSG.chomp
+            --------------------
+            | Debuggee Session |
+            --------------------
+
+            > #{@remote_info.debuggee_backlog.join('> ')}
+          DEBUGGEE_MSG
+
+      failure_msg = <<~FAILURE_MSG.chomp
+        -------------------
+        | Failure Message |
+        -------------------
+
+        #{fail_msg}
+      FAILURE_MSG
+
+      <<~MSG.chomp
+        #{all_protocol_msg}
+
+        #{last_protocol_msg}
+
+        #{debuggee_msg}
+
+        #{failure_msg}
+      MSG
+    end
+
+    # FIXME: Commonalize this method.
+    def recv_response
+      case  header = @sock.gets
+      when /Content-Length: (\d+)/
+        b = @sock.read(2)
+        raise b.inspect unless b == "\r\n"
+
+        l = @sock.read $1.to_i
+        JSON.parse l, symbolize_names: true
+      when nil
+        nil
+      when /out/, /input/
+        recv_response
+      else
+        raise "unrecognized line: #{header}"
+      end
+    end
+  end
+end