class Object

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 361
def arg_error_msg(error = nil)
  error ||= ArgumentError.new('other error')
  "#{error.class}: #{error.message}"
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 337
def bad_status(_req, _call)
  fail GRPC::BadStatus.new(@bs_code, 'NOK')
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 345
def bad_status_alt(_call)
  fail GRPC::BadStatus.new(@bs_code, 'NOK')
end

# File src/ruby/spec/pb/duplicate/codegen_spec.rb, line 19
def can_run_codegen_check
  system('which grpc_ruby_plugin') && system('which protoc')
end

# File src/ruby/spec/generic/rpc_server_spec.rb, line 22
def check_md(wanted_md, received_md)
  wanted_md.zip(received_md).each do |w, r|
    w.each do |key, value|
      expect(r[key]).to eq(value)
    end
  end
end

# File src/ruby/spec/generic/rpc_server_spec.rb, line 646
def check_multi_req_view_of_finished_call(call)
  common_check_of_finished_server_call(call)

  expect do
    call.each_remote_read.each { |r| p r }
  end.to raise_error(GRPC::Core::CallError)
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 40
def check_op_view_of_finished_client_call(op_view,
                                          expected_metadata,
                                          expected_trailing_metadata)
  # use read_response_stream to try to iterate through
  # possible response stream
  fail('need something to attempt reads') unless block_given?
  expect do
    resp = op_view.execute
    yield resp
  end.to raise_error(GRPC::Core::CallError)

  expect { op_view.start_call }.to raise_error(RuntimeError)

  sanity_check_values_of_accessors(op_view,
                                   expected_metadata,
                                   expected_trailing_metadata)

  expect do
    op_view.wait
    op_view.cancel
    op_view.write_flag = 1
  end.to_not raise_error
end

# File src/ruby/spec/generic/rpc_server_spec.rb, line 639
def check_single_req_view_of_finished_call(call)
  common_check_of_finished_server_call(call)

  expect(call.peer).to be_a(String)
  expect(call.peer_cert).to be(nil)
end

# File src/ruby/spec/client_server_spec.rb, line 277
def client_cancel_test(cancel_proc, expected_code,
                       expected_details)
  call = new_client_call
  server_call = nil

  server_thread = Thread.new do
    server_call = server_allows_client_to_proceed
  end

  client_ops = {
    CallOps::SEND_INITIAL_METADATA => {},
    CallOps::RECV_INITIAL_METADATA => nil
  }
  client_batch = call.run_batch(client_ops)
  expect(client_batch.send_metadata).to be true
  expect(client_batch.metadata).to eq({})

  cancel_proc.call(call)

  server_thread.join
  server_ops = {
    CallOps::RECV_CLOSE_ON_SERVER => nil
  }
  server_batch = server_call.run_batch(server_ops)
  expect(server_batch.send_close).to be true

  client_ops = {
    CallOps::RECV_STATUS_ON_CLIENT => {}
  }
  client_batch = call.run_batch(client_ops)

  expect(client_batch.status.code).to be expected_code
  expect(client_batch.status.details).to eq expected_details
end

# File src/ruby/spec/client_auth_spec.rb, line 24
def client_cert
  test_root = File.join(File.dirname(__FILE__), 'testdata')
  cert = File.open(File.join(test_root, 'client.pem')).read
  fail unless cert.is_a?(String)
  cert
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 86
def close_active_server_call(active_server_call)
  active_server_call.send(:set_input_stream_done)
  active_server_call.send(:set_output_stream_done)
end

# File src/ruby/spec/generic/rpc_server_spec.rb, line 654
def common_check_of_finished_server_call(call)
  expect do
    call.merge_metadata_to_send({})
  end.to raise_error(RuntimeError)

  expect do
    call.send_initial_metadata
  end.to_not raise_error

  expect(call.cancelled?).to be(false)
  expect(call.metadata).to be_a(Hash)
  expect(call.metadata['user-agent']).to be_a(String)

  expect(call.metadata_sent).to be(true)
  expect(call.output_metadata).to eq({})
  expect(call.metadata_to_send).to eq({})
  expect(call.deadline.is_a?(Time)).to be(true)
end

# File src/ruby/spec/channel_spec.rb, line 116
def construct_with_args(a)
  proc { GRPC::Core::Channel.new('dummy_host', a, create_test_cert) }
end

# File src/ruby/spec/client_auth_spec.rb, line 17
def create_channel_creds
  test_root = File.join(File.dirname(__FILE__), 'testdata')
  files = ['ca.pem', 'client.key', 'client.pem']
  creds = files.map { |f| File.open(File.join(test_root, f)).read }
  GRPC::Core::ChannelCredentials.new(creds[0], creds[1], creds[2])
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 1059
def create_secure_test_server
  certs = load_test_certs
  secure_credentials = GRPC::Core::ServerCredentials.new(
    nil, [{ private_key: certs[1], cert_chain: certs[2] }], false)

  @server = new_core_server_for_testing(nil)
  @server.add_http2_port('0.0.0.0:0', secure_credentials)
end

# File src/ruby/spec/client_auth_spec.rb, line 31
def create_server_creds
  test_root = File.join(File.dirname(__FILE__), 'testdata')
  GRPC.logger.info("test root: #{test_root}")
  files = ['ca.pem', 'server1.key', 'server1.pem']
  creds = files.map { |f| File.open(File.join(test_root, f)).read }
  GRPC::Core::ServerCredentials.new(
    creds[0],
    [{ private_key: creds[1], cert_chain: creds[2] }],
    true) # force client auth
end

# File src/ruby/spec/channel_spec.rb, line 27
def create_test_cert
  GRPC::Core::ChannelCredentials.new(load_test_certs[0])
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 1068
def create_test_server
  @server = new_core_server_for_testing(nil)
  @server.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
end

# File src/ruby/spec/client_server_spec.rb, line 597
def credentials_update_test(creds_update_md)
  auth_proc = proc { creds_update_md }
  call_creds = GRPC::Core::CallCredentials.new(auth_proc)

  initial_md_key = 'k2'
  initial_md_val = 'v2'
  initial_md = { initial_md_key => initial_md_val }
  expected_md = creds_update_md.clone
  fail 'bad test param' unless expected_md[initial_md_key].nil?
  expected_md[initial_md_key] = initial_md_val

  recvd_rpc = nil
  rcv_thread = Thread.new do
    recvd_rpc = @server.request_call
  end

  call = new_client_call
  call.set_credentials! call_creds

  client_batch = call.run_batch(
    CallOps::SEND_INITIAL_METADATA => initial_md,
    CallOps::SEND_CLOSE_FROM_CLIENT => nil)
  expect(client_batch.send_metadata).to be true
  expect(client_batch.send_close).to be true

  # confirm the server can receive the client metadata
  rcv_thread.join
  expect(recvd_rpc).to_not eq nil
  recvd_md = recvd_rpc.metadata
  replace_symbols = Hash[expected_md.each_pair.collect { |x, y| [x.to_s, y] }]
  expect(recvd_md).to eq(recvd_md.merge(replace_symbols))

  credentials_update_test_finish_call(call, recvd_rpc.call)
end

# File src/ruby/spec/client_server_spec.rb, line 632
def credentials_update_test_finish_call(client_call, server_call)
  final_server_batch = server_call.run_batch(
    CallOps::RECV_CLOSE_ON_SERVER => nil,
    CallOps::SEND_INITIAL_METADATA => nil,
    CallOps::SEND_STATUS_FROM_SERVER => ok_status)
  expect(final_server_batch.send_close).to be(true)
  expect(final_server_batch.send_metadata).to be(true)
  expect(final_server_batch.send_status).to be(true)

  final_client_batch = client_call.run_batch(
    CallOps::RECV_INITIAL_METADATA => nil,
    CallOps::RECV_STATUS_ON_CLIENT => nil)
  expect(final_client_batch.metadata).to eq({})
  expect(final_client_batch.status.code).to eq(0)
end

# File src/ruby/spec/call_spec.rb, line 177
def deadline
  Time.now + 2  # in 2 seconds; arbitrary
end

# File src/ruby/bin/math_client.rb, line 44
def do_div(stub)
  GRPC.logger.info('request_response')
  GRPC.logger.info('----------------')
  req = Math::DivArgs.new(dividend: 7, divisor: 3)
  GRPC.logger.info("div(7/3): req=#{req.inspect}")
  resp = stub.div(req)
  GRPC.logger.info("Answer: #{resp.inspect}")
  GRPC.logger.info('----------------')
end

# File src/ruby/bin/math_client.rb, line 77
def do_div_many(stub)
  GRPC.logger.info('bidi_streamer')
  GRPC.logger.info('-------------')
  reqs = []
  reqs << Math::DivArgs.new(dividend: 7, divisor: 3)
  reqs << Math::DivArgs.new(dividend: 5, divisor: 2)
  reqs << Math::DivArgs.new(dividend: 7, divisor: 2)
  GRPC.logger.info("div(7/3), div(5/2), div(7/2): reqs=#{reqs.inspect}")
  resp = stub.div_many(reqs)
  resp.each do |r|
    GRPC.logger.info("Answer: #{r.inspect}")
  end
  GRPC.logger.info('----------------')
end

# File src/ruby/bin/math_client.rb, line 65
def do_fib(stub)
  GRPC.logger.info('server_streamer')
  GRPC.logger.info('----------------')
  req = Math::FibArgs.new(limit: 11)
  GRPC.logger.info("fib(11): req=#{req.inspect}")
  resp = stub.fib(req)
  resp.each do |r|
    GRPC.logger.info("Answer: #{r.inspect}")
  end
  GRPC.logger.info('----------------')
end

# File src/ruby/bin/math_client.rb, line 54
def do_sum(stub)
  # to make client streaming requests, pass an enumerable of the inputs
  GRPC.logger.info('client_streamer')
  GRPC.logger.info('---------------')
  reqs = [1, 2, 3, 4, 5].map { |x| Math::Num.new(num: x) }
  GRPC.logger.info("sum(1, 2, 3, 4, 5): reqs=#{reqs.inspect}")
  resp = stub.sum(reqs)  # reqs.is_a?(Enumerable)
  GRPC.logger.info("Answer: #{resp.inspect}")
  GRPC.logger.info('---------------')
end

# File src/ruby/spec/generic/active_call_spec.rb, line 656
def expect_server_to_be_invoked(**kw)
  recvd_rpc =  @server.request_call
  expect(recvd_rpc).to_not eq nil
  recvd_call = recvd_rpc.call
  recvd_call.run_batch(CallOps::SEND_INITIAL_METADATA => kw)
  ActiveCall.new(recvd_call, @pass_through, @pass_through, deadline,
                 metadata_received: true, started: true)
end

# File src/ruby/spec/generic/active_call_spec.rb, line 650
def expect_server_to_receive(sent_text, **kw)
  c = expect_server_to_be_invoked(**kw)
  expect(c.remote_read).to eq(sent_text)
  c
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 333
def fake_bidistream(an_array)
  an_array
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 204
def fake_clstream(_arg)
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 321
def fake_reqresp(_req, _call)
  @ok_response
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 207
def fake_svstream(_arg1, _arg2)
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 210
def fake_three_args(_arg1, _arg2, _arg3)
end

# File src/ruby/spec/channel_spec.rb, line 31
def fork_with_propagated_error_message
  pipe_read, pipe_write = IO.pipe
  pid = fork do
    pipe_read.close
    begin
      yield
    rescue => exc
      pipe_write.syswrite(exc.message)
    end
    pipe_write.close
  end
  pipe_write.close

  exc_message = pipe_read.read
  Process.wait(pid)

  unless $CHILD_STATUS.success?
    raise "forked process failed with #{$CHILD_STATUS}"
  end
  raise exc_message unless exc_message.empty?
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 295
def get_response(stub, credentials: nil)
  GRPC.logger.info(credentials.inspect)
  stub.request_response(@method, @sent_msg, noop, noop,
                        metadata: @metadata,
                        credentials: credentials)
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 538
def get_responses(stub, unmarshal: noop)
  e = stub.server_streamer(@method, @sent_msg, noop, unmarshal,
                           metadata: @metadata)
  expect(e).to be_a(Enumerator)
  e
end

# File src/ruby/spec/generic/active_call_spec.rb, line 36
def inner_call_of_active_call(active_call)
  active_call.instance_variable_get(:@call)
end

# File src/ruby/bin/math_client.rb, line 92
def load_test_certs
  this_dir = File.expand_path(File.dirname(__FILE__))
  data_dir = File.join(File.dirname(this_dir), 'spec/testdata')
  files = ['ca.pem', 'server1.key', 'server1.pem']
  files.map { |f| File.open(File.join(data_dir, f)).read }
end

# File src/ruby/bin/math_client.rb, line 104
def main
  options = {
    'host' => 'localhost:7071',
    'secure' => false
  }
  OptionParser.new do |opts|
    opts.banner = 'Usage: [--host <hostname>:<port>] [--secure|-s]'
    opts.on('--host HOST', '<hostname>:<port>') do |v|
      options['host'] = v
    end
    opts.on('-s', '--secure', 'access using test creds') do |v|
      options['secure'] = v
    end
  end.parse!

  # The Math::Math:: module occurs because the service has the same name as its
  # package. That practice should be avoided by defining real services.
  if options['secure']
    stub_opts = {
      :creds => test_creds,
      GRPC::Core::Channel::SSL_TARGET => 'foo.test.google.fr',
      timeout: INFINITE_FUTURE,
    }
    stub = Math::Math::Stub.new(options['host'], **stub_opts)
    GRPC.logger.info("... connecting securely on #{options['host']}")
  else
    stub = Math::Math::Stub.new(options['host'], :this_channel_is_insecure, timeout: INFINITE_FUTURE)
    GRPC.logger.info("... connecting insecurely on #{options['host']}")
  end

  do_div(stub)
  do_sum(stub)
  do_fib(stub)
  do_div_many(stub)
end

# File src/ruby/spec/call_spec.rb, line 173
def make_test_call
  @ch.create_call(nil, nil, 'dummy_method', nil, deadline)
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 181
def metadata_test(md)
  server_port = create_test_server
  host = "localhost:#{server_port}"
  th = run_request_response(@sent_msg, @resp, @pass,
                            expected_metadata: md)
  stub = GRPC::ClientStub.new(host, :this_channel_is_insecure)
  @metadata = md
  expect(get_response(stub)).to eq(@resp)
  th.join
end

# File src/ruby/spec/client_server_spec.rb, line 37
def new_client_call
  @ch.create_call(nil, nil, '/method', nil, deadline)
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 201
def no_arg
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 353
def not_implemented(_req, _call)
  fail not_implemented_error
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 357
def not_implemented_alt(_call)
  fail not_implemented_error
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 366
def not_implemented_error
  NotImplementedError.new('some OS feature not implemented')
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 370
def not_implemented_error_msg(error = nil)
  error ||= not_implemented_error
  "#{error.class}: #{error.message}"
end

# File src/ruby/spec/client_server_spec.rb, line 41
def ok_status
  Struct::Status.new(StatusCodes::OK, 'OK')
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 341
def other_error(_req, _call)
  fail(ArgumentError, 'other error')
end

# File src/ruby/spec/generic/rpc_desc_spec.rb, line 349
def other_error_alt(_call)
  fail(ArgumentError, 'other error')
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 995
def run_bidi_streamer_echo_ping_pong(expected_inputs, status, client_starts,
                                     expected_metadata: {},
                                     server_initial_md: {},
                                     server_trailing_md: {})
  wanted_metadata = expected_metadata.clone
  wakey_thread do |notifier|
    c = expect_server_to_be_invoked(
      notifier, metadata_to_send: server_initial_md)
    wanted_metadata.each do |k, v|
      expect(c.metadata[k.to_s]).to eq(v)
    end
    expected_inputs.each do |i|
      if client_starts
        expect(c.remote_read).to eq(i)
        c.remote_send(i)
      else
        c.remote_send(i)
        expect(c.remote_read).to eq(i)
      end
    end
    c.send_status(status, status == @pass ? 'OK' : 'NOK', true,
                  metadata: server_trailing_md)
    close_active_server_call(c)
  end
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 984
def run_bidi_streamer_handle_inputs_first(expected_inputs, replys,
                                          status)
  wakey_thread do |notifier|
    c = expect_server_to_be_invoked(notifier)
    expected_inputs.each { |i| expect(c.remote_read).to eq(i) }
    replys.each { |r| c.remote_send(r) }
    c.send_status(status, status == @pass ? 'OK' : 'NOK', true)
    close_active_server_call(c)
  end
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 1021
def run_client_streamer(expected_inputs, resp, status,
                        expected_metadata: {},
                        server_initial_md: {},
                        server_trailing_md: {})
  wanted_metadata = expected_metadata.clone
  wakey_thread do |notifier|
    c = expect_server_to_be_invoked(
      notifier, metadata_to_send: server_initial_md)
    expected_inputs.each { |i| expect(c.remote_read).to eq(i) }
    wanted_metadata.each do |k, v|
      expect(c.metadata[k.to_s]).to eq(v)
    end
    c.remote_send(resp)
    c.send_status(status, status == @pass ? 'OK' : 'NOK', true,
                  metadata: server_trailing_md)
    close_active_server_call(c)
  end
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 733
def run_error_in_client_request_stream_test(requests_to_push,
                                            expected_error_message)
  # start a server that waits on a read indefinitely - it should
  # see a cancellation and be able to break out
  th = Thread.new { run_server_bidi_send_one_then_read_indefinitely }
  stub = GRPC::ClientStub.new(@host, :this_channel_is_insecure)

  request_queue = Queue.new
  @sent_msgs = BidiErrorTestingEnumerateForeverQueue.new(request_queue)

  verify_error_from_write_thread(stub,
                                 requests_to_push,
                                 request_queue,
                                 expected_error_message)
  # the write loop errror should cancel the call and end the
  # server's request stream
  th.join
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 324
def run_op_view_metadata_test(run_start_call_first)
  server_port = create_test_server
  host = "localhost:#{server_port}"

  @server_initial_md = { 'sk1' => 'sv1', 'sk2' => 'sv2' }
  @server_trailing_md = { 'tk1' => 'tv1', 'tk2' => 'tv2' }
  th = run_request_response(
    @sent_msg, @resp, @pass,
    expected_metadata: @metadata,
    server_initial_md: @server_initial_md,
    server_trailing_md: @server_trailing_md)
  stub = GRPC::ClientStub.new(host, :this_channel_is_insecure)
  expect(
    get_response(stub,
                 run_start_call_first: run_start_call_first)).to eq(@resp)
  th.join
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 1040
def run_request_response(expected_input, resp, status,
                         expected_metadata: {},
                         server_initial_md: {},
                         server_trailing_md: {})
  wanted_metadata = expected_metadata.clone
  wakey_thread do |notifier|
    c = expect_server_to_be_invoked(
      notifier, metadata_to_send: server_initial_md)
    expect(c.remote_read).to eq(expected_input)
    wanted_metadata.each do |k, v|
      expect(c.metadata[k.to_s]).to eq(v)
    end
    c.remote_send(resp)
    c.send_status(status, status == @pass ? 'OK' : 'NOK', true,
                  metadata: server_trailing_md)
    close_active_server_call(c)
  end
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 914
def run_server_bidi_expect_client_to_cancel(wait_for_shutdown_ok_callback)
  @server.start
  recvd_rpc = @server.request_call
  recvd_call = recvd_rpc.call
  server_call = GRPC::ActiveCall.new(
    recvd_call, noop, noop, INFINITE_FUTURE,
    metadata_received: true, started: false)
  server_call.send_initial_metadata
  server_call.remote_send('server call received')
  wait_for_shutdown_ok_callback.call
  # since the client is cancelling the call,
  # we should be able to shut down cleanly
  @server.shutdown_and_notify(nil)
  @server.close
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 681
def run_server_bidi_send_one_then_read_indefinitely
  @server.start
  recvd_rpc = @server.request_call
  recvd_call = recvd_rpc.call
  server_call = GRPC::ActiveCall.new(
    recvd_call, noop, noop, INFINITE_FUTURE,
    metadata_received: true, started: false)
  server_call.send_initial_metadata
  server_call.remote_send('server response')
  loop do
    m = server_call.remote_read
    break if m.nil?
  end
  # can't fail since initial metadata already sent
  server_call.send_status(@pass, 'OK', true)
  close_active_server_call(server_call)
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 786
def run_server_bidi_shutdown_after_one_read
  @server.start
  recvd_rpc = @server.request_call
  recvd_call = recvd_rpc.call
  server_call = GRPC::ActiveCall.new(
    recvd_call, noop, noop, INFINITE_FUTURE,
    metadata_received: true, started: false)
  expect(server_call.remote_read).to eq('first message')
  @server.shutdown_and_notify(from_relative_time(0))
  @server.close
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 824
def run_server_bidi_shutdown_after_one_write
  @server.start
  recvd_rpc = @server.request_call
  recvd_call = recvd_rpc.call
  server_call = GRPC::ActiveCall.new(
    recvd_call, noop, noop, INFINITE_FUTURE,
    metadata_received: true, started: false)
  server_call.send_initial_metadata
  server_call.remote_send('message')
  @server.shutdown_and_notify(from_relative_time(0))
  @server.close
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 965
def run_server_streamer(expected_input, replys, status,
                        expected_metadata: {},
                        server_initial_md: {},
                        server_trailing_md: {})
  wanted_metadata = expected_metadata.clone
  wakey_thread do |notifier|
    c = expect_server_to_be_invoked(
      notifier, metadata_to_send: server_initial_md)
    wanted_metadata.each do |k, v|
      expect(c.metadata[k.to_s]).to eq(v)
    end
    expect(c.remote_read).to eq(expected_input)
    replys.each { |r| c.remote_send(r) }
    c.send_status(status, status == @pass ? 'OK' : 'NOK', true,
                  metadata: server_trailing_md)
    close_active_server_call(c)
  end
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 501
def run_server_streamer_against_client_with_unmarshal_error(
  expected_input, replys)
  wakey_thread do |notifier|
    c = expect_server_to_be_invoked(notifier)
    expect(c.remote_read).to eq(expected_input)
    begin
      replys.each { |r| c.remote_send(r) }
    rescue GRPC::Core::CallError
      # An attempt to write to the client might fail. This is ok
      # because the client call is expected to fail when
      # unmarshalling the first response, and to cancel the call,
      # and there is a race as for when the server-side call will
      # start to fail.
      p 'remote_send failed (allowed because call expected to cancel)'
    ensure
      c.send_status(OK, 'OK', true)
      close_active_server_call(c)
    end
  end
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 64
def sanity_check_values_of_accessors(op_view,
                                     expected_metadata,
                                     expected_trailing_metadata)
  expected_status = Struct::Status.new
  expected_status.code = 0
  expected_status.details = 'OK'
  expected_status.metadata = expected_trailing_metadata

  expect(op_view.status).to eq(expected_status)
  expect(op_view.metadata).to eq(expected_metadata)
  expect(op_view.trailing_metadata).to eq(expected_trailing_metadata)

  expect(op_view.cancelled?).to be(false)
  expect(op_view.write_flag).to be(nil)

  # The deadline attribute of a call can be either
  # a GRPC::Core::TimeSpec or a Time, which are mutually exclusive.
  # TODO: fix so that the accessor always returns the same type.
  expect(op_view.deadline.is_a?(GRPC::Core::TimeSpec) ||
         op_view.deadline.is_a?(Time)).to be(true)
end

# File src/ruby/spec/generic/active_call_spec.rb, line 29
def send_and_receive_close_and_status(client_call, server_call)
  client_call.run_batch(CallOps::SEND_CLOSE_FROM_CLIENT => nil)
  server_call.run_batch(CallOps::RECV_CLOSE_ON_SERVER => nil,
                        CallOps::SEND_STATUS_FROM_SERVER => ok_status)
  client_call.run_batch(CallOps::RECV_STATUS_ON_CLIENT => nil)
end

# File src/ruby/spec/client_server_spec.rb, line 27
def server_allows_client_to_proceed(metadata = {})
  recvd_rpc = @server.request_call
  expect(recvd_rpc).to_not eq nil
  server_call = recvd_rpc.call
  ops = { CallOps::SEND_INITIAL_METADATA => metadata }
  server_batch = server_call.run_batch(ops)
  expect(server_batch.send_metadata).to be true
  server_call
end

# File src/ruby/spec/server_spec.rb, line 203
def start_a_server
  s = new_core_server_for_testing(nil)
  s.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
  s.start
  s
end

# File src/ruby/spec/channel_connection_spec.rb, line 21
def start_server(port = 0)
  @srv = new_rpc_server_for_testing(pool_size: 1)
  server_port = @srv.add_http2_port("localhost:#{port}", :this_port_is_insecure)
  @srv.handle(EchoService)
  @server_thd = Thread.new { @srv.run }
  @srv.wait_till_running
  server_port
end

# File src/ruby/spec/channel_connection_spec.rb, line 30
def stop_server
  expect(@srv.stopped?).to be(false)
  @srv.stop
  @server_thd.join
  expect(@srv.stopped?).to be(true)
end

# File src/ruby/bin/math_client.rb, line 99
def test_creds
  certs = load_test_certs
  GRPC::Core::ChannelCredentials.new(certs[0])
end

# File src/ruby/bin/math_server.rb, line 157
def test_server_creds
  certs = load_test_certs
  GRPC::Core::ServerCredentials.new(
    nil, [{ private_key: certs[1], cert_chain: certs[2] }], false)
end

# File src/ruby/spec/error_sanity_spec.rb, line 22
def upper_snake_to_camel(name)
  name.to_s.split('_').map(&:downcase).map(&:capitalize).join('')
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 699
def verify_error_from_write_thread(stub, requests_to_push,
                                   request_queue, expected_description)
  # TODO: an improvement might be to raise the original exception from
  # bidi call write loops instead of only cancelling the call
  failing_marshal_proc = proc do |req|
    fail req if req.is_a?(StandardError)
    req
  end
  begin
    e = get_responses(stub, marshal_proc: failing_marshal_proc)
    first_response = e.next
    expect(first_response).to eq('server response')
    requests_to_push.each { |req| request_queue.push(req) }
    e.collect { |r| r }
  rescue GRPC::Unknown => e
    exception = e
  end
  expect(exception.message.include?(expected_description)).to be(true)
end

# File src/ruby/spec/generic/client_stub_spec.rb, line 19
def wakey_thread(&blk)
  n = GRPC::Notifier.new
  t = Thread.new do
    blk.call(n)
  end
  t.abort_on_exception = true
  n.wait
  t
end