client/BUILD.gn

# Copyright 2014 The Goma Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

proto_out_dir = "prototmp"
generate_compiler_proxy_info = "generate_compiler_proxy_info.py"

import("//testing/libfuzzer/fuzzer_test.gni")
import("//third_party/protobuf/proto_library.gni")
import("//build/util/lastchange.gni")

group("client") {
  deps = [
    ":compiler_proxy",
    ":goma_fetch",
    ":gomacc",
  ]

  if (is_official_build) {
    deps += [ ":calc_sha256_checksum" ]
  }
}

# "common" contains sources that will be used in compiler_proxy and gomacc.
static_library("common") {
  sources = [
    "atomic_stats_counter.cc",
    "atomic_stats_counter.h",
    "autolock_timer.cc",
    "autolock_timer.h",
    "callback.h",
    "counterz.cc",
    "counterz.h",
    "env_flags.cc",
    "env_flags.h",
    "file_stat.cc",
    "file_stat.h",
    "goma_flags.cc",
    "goma_ipc_addr.cc",
    "goma_ipc_addr.h",
    "goma_ipc_peer.cc",
    "goma_ipc_peer.h",
    "json_util.cc",
    "json_util.h",
    "machine_info.cc",
    "machine_info.h",
    "mypath.cc",
    "mypath.h",
    "mypath_helper.h",
    "simple_timer.cc",
    "simple_timer.h",
    "spawner.h",
    "util.cc",
    "util.h",
  ]
  public_configs = [ ":client_config" ]

  public_deps = [
    ":counterz_proto",
    "//base",
    "//third_party/jsoncpp",
  ]
  deps = [
    "//lib",
    "//third_party:glog",
    "//third_party/chromium_base:cpu",
  ]
  if (os == "win") {
    sources += [
      "filetime_win.cc",
      "filetime_win.h",
      "mypath_helper_win.cc",
      "named_pipe_client_win.cc",
      "named_pipe_client_win.h",
      "named_pipe_win.cc",
      "named_pipe_win.h",
      "posix_helper_win.cc",
      "posix_helper_win.h",
      "simple_timer_win.cc",
    ]

    public_deps += [ ":rand_util_lib" ]  # posix_helper_win always require this
  }

  if (os == "linux") {
    sources += [
      "mypath_helper_linux.cc",
      "simple_timer_linux.cc",
    ]
    libs = [ "rt" ]
  }
  if (os == "mac") {
    sources += [
      "mypath_helper_mac.mm",
      "simple_timer_mac.cc",
    ]
    libs = [ "Foundation.framework" ]
  }
}

static_library("oauth2_lib") {
  sources = [
    "oauth2.cc",
    "oauth2.h",
  ]
  deps = [
    ":common",
    ":ioutil_lib",
    "//lib",
    "//third_party/abseil",
  ]
}

static_library("subprocess_lib") {
  sources = [
    "subprocess.cc",
    "subprocess.h",
  ]

  if (os == "win") {
    sources += [
      "spawner_win.cc",
      "spawner_win.h",
    ]
  } else {
    sources += [
      "spawner_posix.cc",
      "spawner_posix.h",
    ]
  }

  public_deps = [
    "//base",
    "//lib",
  ]

  deps = [
    ":common",
    ":file_path_util_lib",
    ":ioutil_lib",
  ]
}

static_library("time_util_lib") {
  sources = [
    "time_util.cc",
    "time_util.h",
  ]
  public_deps = [
    "//third_party:glog",
    "//third_party/abseil",
  ]
}

proto_library("compiler_info_data_proto") {
  sources = [
    "compiler_info_data.proto",
  ]
}

proto_library("counterz_proto") {
  sources = [
    "counterz.proto",
  ]
}

proto_library("deps_cache_proto") {
  sources = [
    "deps_cache_data.proto",
  ]
}

proto_library("error_notice") {
  sources = [
    "error_notice.proto",
  ]
}

proto_library("local_output_cache_proto") {
  sources = [
    "local_output_cache_data.proto",
  ]
}

proto_library("subprocess_proto") {
  sources = [
    "subprocess.protodevel",
  ]
}

proto_library("settings_proto") {
  sources = [
    "settings.proto",
  ]
}

config("include_target_gen_dir") {
  include_dirs = [ "$target_gen_dir" ]
}

config("client_config") {
  include_dirs = [ "." ]
}

action("gen_compiler_proxy_info") {
  script = generate_compiler_proxy_info
  outputs = [
    "$target_gen_dir/compiler_proxy_info.h",
  ]
  args = [
    "--out-dir",
    rebase_path("$target_gen_dir"),
  ]
  public_configs = [ ":include_target_gen_dir" ]
}

static_library("gomacc_lib") {
  sources = [
    "goma_ipc.cc",
    "goma_ipc.h",
    "gomacc_argv.cc",
    "gomacc_argv.h",
    "gomacc_common.cc",
    "gomacc_common.h",

    # generated files.
    "$target_gen_dir/compiler_proxy_info.h",
  ]
  deps = [
    ":common",
    ":file_path_util_lib",
    ":gen_compiler_proxy_info",
    ":ioutil_lib",
    ":subprocess_lib",
    "//lib",
    "//lib:compiler_flag_type_specific",
    "//third_party:glog",
    "//third_party/protobuf:protobuf_lite",
  ]
  include_dirs = [ "." ]
  if (os == "linux") {
    sources += [
      "cros_util.cc",
      "cros_util.h",
    ]
  }
}

static_library("content_lib") {
  sources = [
    "content.cc",
    "content.h",
    "content_cursor.cc",
    "content_cursor.h",
  ]

  public_deps = [
    "//base",
    "//third_party/abseil",
  ]
  deps = [
    "//lib",
  ]
}

# compiler_proxy_base contains sources for compiler_proxy.
# This should not depend on language-specific (c/c++ specific, or java specific)
# source code.
static_library("compiler_proxy_base_lib") {
  sources = [
    "descriptor_event_type.h",
    "descriptor_poller.cc",
    "descriptor_poller.h",
    "framework_path_resolver.cc",
    "framework_path_resolver.h",
    "histogram.cc",
    "histogram.h",
    "linked_unordered_map.h",
    "list_dir_cache.cc",
    "list_dir_cache.h",
    "socket_descriptor.cc",
    "socket_descriptor.h",
    "socket_pool.cc",
    "socket_pool.h",
    "worker_thread.cc",
    "worker_thread.h",
    "worker_thread_manager.cc",
    "worker_thread_manager.h",
  ]

  if (os == "linux") {
    sources += [ "descriptor_poller_epoll.cc" ]
  } else if (os == "mac" || os == "freebsd") {
    sources += [ "descriptor_poller_kqueue.cc" ]
  } else {
    sources += [ "descriptor_poller_select.cc" ]
  }

  deps = [
    ":ioutil_lib",
    ":time_util_lib",
  ]

  public_deps = [
    ":common",
    ":content_lib",
    "//base",
    "//lib",
    "//lib:goma_hash",
    "//lib:goma_stats_proto",
    "//third_party/abseil",
  ]

  # Do not depend on compiler-type specific libraries.
  assert_no_deps = [
    "//lib:compiler_flag_type_specific",
    "//lib:gcc_specific",
    "//lib:vc_specific",
    "//lib:clang_tidy_specific",
    "//lib:java_specific",
    "//lib:fake_specific",
  ]
}

static_library("compiler_proxy_lib") {
  libs = []
  sources = [
    "auto_updater.cc",
    "auto_updater.h",
    "compilation_database_reader.cc",
    "compilation_database_reader.h",
    "compile_service.cc",
    "compile_service.h",
    "compile_stats.cc",
    "compile_stats.h",
    "compile_task.cc",
    "compile_task.h",
    "compiler_flags_util.cc",
    "compiler_flags_util.h",
    "compiler_info_cache.cc",
    "compiler_info_cache.h",
    "compiler_info_state.cc",
    "compiler_info_state.h",
    "compiler_proxy_histogram.cc",
    "compiler_proxy_histogram.h",
    "compiler_proxy_http_handler.cc",
    "compiler_proxy_http_handler.h",
    "compiler_type_specific_collection.cc",
    "compiler_type_specific_collection.h",
    "goma_blob.cc",
    "goma_blob.h",
    "goma_file_dump.cc",
    "goma_file_dump.h",
    "goma_file_http.cc",
    "goma_file_http.h",
    "goma_init.cc",
    "goma_init.h",
    "hash_rewrite_parser.cc",
    "hash_rewrite_parser.h",
    "http.cc",
    "http.h",
    "http_init.cc",
    "http_init.h",
    "http_rpc.cc",
    "http_rpc.h",
    "http_rpc_init.cc",
    "http_rpc_init.h",
    "log_cleaner.cc",
    "log_cleaner.h",
    "log_service_client.cc",
    "log_service_client.h",
    "luci_context.cc",
    "luci_context.h",
    "multi_http_rpc.cc",
    "multi_http_rpc.h",
    "oauth2_token.cc",
    "oauth2_token.h",
    "openssl_engine.cc",
    "openssl_engine.h",
    "rpc_controller.cc",
    "rpc_controller.h",
    "settings.cc",
    "settings.h",
    "subprocess_controller.cc",
    "subprocess_controller.h",
    "subprocess_controller_client.cc",
    "subprocess_controller_client.h",
    "subprocess_controller_server.cc",
    "subprocess_controller_server.h",
    "subprocess_impl.cc",
    "subprocess_impl.h",
    "subprocess_option_setter.cc",
    "subprocess_option_setter.h",
    "subprocess_task.cc",
    "subprocess_task.h",
    "task/compiler_flag_utils.cc",
    "task/compiler_flag_utils.h",
    "task/input_file_task.cc",
    "task/input_file_task.h",
    "task/local_output_file_task.cc",
    "task/local_output_file_task.h",
    "task/output_file_task.cc",
    "task/output_file_task.h",
    "threadpool_http_server.cc",
    "threadpool_http_server.h",
    "tls_descriptor.cc",
    "tls_descriptor.h",
    "trustedipsmanager.cc",
    "trustedipsmanager.h",
    "watchdog.cc",
    "watchdog.h",
    "zero_copy_stream_impl.cc",
    "zero_copy_stream_impl.h",

    # generated files.
    "$target_gen_dir/compiler_proxy_info.h",
    "$target_gen_dir/resources/compiler_proxy_contentionz_script.c",
    "$target_gen_dir/resources/compiler_proxy_contentionz_script.h",
    "$target_gen_dir/resources/compiler_proxy_status_html5.c",
    "$target_gen_dir/resources/compiler_proxy_status_html5.h",
    "$target_gen_dir/resources/compiler_proxy_status_logo.c",
    "$target_gen_dir/resources/compiler_proxy_status_logo.h",
    "$target_gen_dir/resources/compiler_proxy_status_script.c",
    "$target_gen_dir/resources/compiler_proxy_status_script.h",
    "$target_gen_dir/resources/compiler_proxy_status_style.c",
    "$target_gen_dir/resources/compiler_proxy_status_style.h",
    "$target_gen_dir/resources/compilerz_html.c",
    "$target_gen_dir/resources/compilerz_html.h",
    "$target_gen_dir/resources/compilerz_script.c",
    "$target_gen_dir/resources/compilerz_script.h",
    "$target_gen_dir/resources/compilerz_style.c",
    "$target_gen_dir/resources/compilerz_style.h",
    "$target_gen_dir/resources/legend_help.c",
    "$target_gen_dir/resources/legend_help.h",
  ]
  include_dirs = [ "." ]
  deps = [
    ":breakpad_lib",
    ":common",
    ":compiler_info_data_proto",
    ":compiler_info_lib",
    ":compiler_type_specific_lib",
    ":content_lib",
    ":deps_cache_lib",
    ":error_notice",
    ":file_hash_cache_lib",
    ":file_path_util_lib",
    ":file_stat_cache_lib",
    ":ioutil_lib",
    ":jwt_lib",
    ":local_output_cache_lib",
    ":local_output_cache_proto",  # for compile_task
    ":oauth2_lib",
    ":rand_util_lib",
    ":scoped_tmp_file_lib",
    ":settings_proto",
    ":sha256_hash_cache_lib",
    ":subprocess_lib",
    ":subprocess_proto",
    ":time_util_lib",
    "//client/clang_tidy:clang_tidy_compiler_info_builder_lib",
    "//client/clang_tidy:clang_tidy_compiler_type_specific",
    "//client/cxx:cxx_compiler_info_lib",
    "//client/cxx:gcc_compiler_info_builder_lib",
    "//client/cxx:gcc_compiler_type_specific",
    "//client/cxx:vc_compiler_info_builder_lib",
    "//client/cxx:vc_compiler_type_specific",
    "//client/cxx/include_processor:cpp_include_processor_lib",
    "//client/cxx/include_processor:directive_filter_lib",
    "//client/cxx/include_processor:include_cache_lib",
    "//client/fake:fake_compiler_info_builder_lib",
    "//client/fake:fake_compiler_info_lib",
    "//client/fake:fake_compiler_type_specific",
    "//client/java:jar_parser_lib",
    "//client/java:java_compiler_info_builder_lib",
    "//client/java:java_compiler_info_lib",
    "//client/java:java_compiler_type_specific",
    "//client/linker/linker_input_processor:arfile_reader_lib",
    "//client/linker/linker_input_processor:linker_input_processor_lib",
    "//client/linker/linker_input_processor:thinlto_import_processor_lib",
    "//lib:compiler_flag_type_specific",
    "//third_party:zlib",
    "//third_party/abseil",
    "//third_party/boringssl",
    "//third_party/chromium_base:cpu",
    "//third_party/jsoncpp",
    "//third_party/protobuf:protobuf_lite",
  ]
  public_deps = [
    ":common",
    ":compiler_proxy_base_lib",
    ":gen_compiler_proxy_info",
    ":subprocess_proto",
    "//client/java:jarfile_reader_lib",
    "//client/resources:gen_compiler_proxy_contentionz_script",
    "//client/resources:gen_compiler_proxy_status_html5",
    "//client/resources:gen_compiler_proxy_status_logo",
    "//client/resources:gen_compiler_proxy_status_script",
    "//client/resources:gen_compiler_proxy_status_style",
    "//client/resources:gen_compilerz_html",
    "//client/resources:gen_compilerz_script",
    "//client/resources:gen_compilerz_style",
    "//client/resources:gen_legend_help",
    "//lib",
    "//lib:goma_file",
    "//lib:goma_hash",
    "//lib:goma_stats_proto",
    "//lib:goma_statz_stats_proto",
    "//third_party:glog",
    "//third_party:gtest_prod",
    "//third_party/chartjs:chartjs",
    "//third_party/jquery:jquery",
    "//third_party/jsoncpp",
  ]

  if (os == "mac") {
    deps += [ "//third_party/chromium_base:mac_version" ]
  }
  if (os == "win") {
    sources += [
      "named_pipe_server_win.cc",
      "named_pipe_server_win.h",
      "openssl_engine_helper.h",
      "openssl_engine_helper_win.cc",
    ]
    deps += [ "//client/certs:certs_resource" ]
  }
  if (os != "win") {
    sources += [
      "openssl_engine_helper.h",
      "openssl_engine_helper_generic.cc",
    ]
    deps += [ "//client/certs" ]
  }
}

static_library("base64_lib") {
  sources = [
    "base64.cc",
    "base64.h",
  ]
  deps = [
    "//base",
  ]
}

static_library("file_path_util_lib") {
  sources = [
    "file_path_util.cc",
    "file_path_util.h",
  ]
  public_deps = [
    "//base",
    "//third_party/abseil",
  ]
  deps = [
    ":common",
    ":ioutil_lib",
    "//lib",
    "//lib:compiler_flag_type_specific",
    "//lib:vc_specific",
    "//third_party:glog",
  ]
}

static_library("jwt_lib") {
  if (os == "win") {
    cflags = [
      # C4267: conversion from 'size_t' to 'int', possible loss of data
      # Come from passing string::size() to
      # BIO_new_mem_buf(const void*, int len).
      "/wd4267",
    ]
  }

  sources = [
    "jwt.cc",
    "jwt.h",
  ]
  deps = [
    ":base64_lib",
    ":ioutil_lib",
    "//base",
    "//third_party:glog",
    "//third_party:gtest_prod",
    "//third_party/boringssl",
  ]
}

static_library("sha256_hash_cache_lib") {
  sources = [
    "sha256_hash_cache.cc",
    "sha256_hash_cache.h",
  ]
  deps = [
    "//lib:goma_hash",
  ]
  public_deps = [
    ":common",
    "//base",
  ]
}

static_library("compiler_type_specific_lib") {
  sources = [
    "compiler_type_specific.cc",
    "compiler_type_specific.h",
  ]

  public_deps = [
    ":compiler_info_lib",
    ":file_stat_cache_lib",
    "//lib",
    "//third_party/abseil",
  ]
}

static_library("compiler_info_lib") {
  sources = [
    "compiler_info.cc",
    "compiler_info.h",
    "compiler_info_builder.cc",
    "compiler_info_builder.h",
  ]

  deps = [
    ":common",
    ":ioutil_lib",
    ":scoped_tmp_file_lib",
    ":sha256_hash_cache_lib",
    "//client/cxx/include_processor:cpp_directive_lib",
    "//lib:compiler_flag_type_specific",
    "//lib:goma_hash",
    "//third_party/jsoncpp",
  ]

  public_deps = [
    ":compiler_info_data_proto",
    "//lib",
    "//third_party:gtest_prod",
    "//third_party/abseil",
    "//third_party/protobuf:protobuf_lite",
  ]

  public_configs = [ ":client_config" ]
}

static_library("file_stat_cache_lib") {
  sources = [
    "file_stat_cache.cc",
    "file_stat_cache.h",
  ]
  public_deps = [
    "//base",
    "//third_party/abseil",
  ]
  deps = [
    ":common",
    "//third_party:glog",
  ]
}

static_library("ioutil_lib") {
  sources = [
    "http_util.cc",
    "http_util.h",
    "ioutil.cc",
    "ioutil.h",
  ]
  public_deps = [
    "//base",
    "//third_party/abseil",
  ]
  deps = [
    ":common",
    "//lib",
    "//third_party:glog",
    "//third_party:zlib",
  ]
}

static_library("rand_util_lib") {
  sources = [
    "rand_util.cc",
    "rand_util.h",
  ]
  public_deps = [
    "//third_party/abseil",
  ]
  deps = [
    "//third_party:glog",
    "//third_party/boringssl",
  ]
}

static_library("cache_file_lib") {
  sources = [
    "cache_file.cc",
    "cache_file.h",
  ]
  public_deps = [
    "//base",
  ]
  deps = [
    "//lib:goma_hash",
  ]
}

static_library("file_hash_cache_lib") {
  sources = [
    "file_hash_cache.cc",
    "file_hash_cache.h",
  ]
  public_deps = [
    ":common",
  ]
  deps = [
    "//third_party:glog",
  ]
}

static_library("deps_cache_lib") {
  sources = [
    "deps_cache.cc",
    "deps_cache.h",
    "filename_id_table.cc",
    "filename_id_table.h",
  ]
  public_deps = [
    ":cache_file_lib",
    ":common",
    ":compiler_proxy_base_lib",
    ":file_stat_cache_lib",
    "//lib:goma_hash",
  ]
  deps = [
    ":compiler_info_lib",
    ":content_lib",
    ":deps_cache_proto",
    ":gen_compiler_proxy_info",
    "//client/cxx:cxx_compiler_info_lib",
    "//client/cxx/include_processor:directive_filter_lib",
    "//client/cxx/include_processor:include_cache_lib",
    "//lib:gcc_specific",
    "//lib:vc_specific",
  ]
}

static_library("local_output_cache_lib") {
  sources = [
    "local_output_cache.cc",
    "local_output_cache.h",
  ]
  deps = [
    ":common",
    ":compiler_proxy_base_lib",
    ":local_output_cache_proto",
    "//lib:compiler_flag_type_specific",
    "//lib:goma_hash",
  ]
}

static_library("scoped_tmp_file_lib") {
  sources = [
    "scoped_tmp_file.cc",
    "scoped_tmp_file.h",
  ]
  public_deps = [
    "//lib",
  ]
  deps = [
    ":common",
    ":rand_util_lib",
    "//base",
  ]
}

static_library("breakpad_lib") {
  sources = [
    "breakpad.h",
  ]
  if (os == "linux") {
    sources += [ "breakpad_linux.cc" ]
    deps = [
      "//base",
      "//third_party:glog",
      "//third_party/breakpad:client",
    ]
  }
  if (os == "mac") {
    sources += [ "breakpad_mac.cc" ]
    deps = [
      "//base",
      "//third_party:glog",
      "//third_party/breakpad:breakpad",
    ]
    libs = [ "Foundation.framework" ]
  }
  if (os == "win") {
    sources += [ "breakpad_win.cc" ]
    deps = [
      "//third_party:glog",
      "//third_party/breakpad:breakpad_handler",
    ]
  }
  include_dirs = [
    "//third_party/breakpad/breakpad/src",

    # For including third_party/lss/linux_syscall_support.h from
    # third_party/breakpad/src/common/memory.h.
    # linux_syscall_support.h do not have .c or .cc file.
    "//",
  ]
}

executable("gomacc") {
  sources = [
    "gomacc.cc",
  ]
  include_dirs = [ "." ]
  deps = [
    ":breakpad_lib",
    ":common",
    ":file_path_util_lib",
    ":gomacc_lib",
    ":ioutil_lib",
    ":subprocess_lib",
    "//build/config:exe_and_shlib_deps",
    "//lib",
    "//lib:compiler_flag_type_specific",
    "//third_party:glog",
    "//third_party/abseil",
    "//third_party/protobuf:protobuf_lite",
  ]
  if (os == "linux" && may_make_pie) {
    ldflags = [ "-pie" ]
  }
}

executable("compiler_proxy") {
  sources = [
    "compiler_proxy.cc",
  ]
  include_dirs = [ "." ]
  deps = [
    ":breakpad_lib",
    ":compiler_proxy_lib",
    ":deps_cache_lib",
    ":file_hash_cache_lib",
    ":file_stat_cache_lib",
    ":ioutil_lib",
    ":local_output_cache_lib",
    ":oauth2_lib",
    ":rand_util_lib",
    ":subprocess_lib",
    "//build/config:exe_and_shlib_deps",
    "//client/clang_modules/modulemap:modulemap_cache_lib",
    "//client/cxx:cxx_compiler_info_builder_lib",
    "//client/cxx/include_processor:cpp_include_processor_lib",
    "//client/cxx/include_processor:include_cache_lib",
    "//client/java:jar_parser_lib",
    "//client/linker/linker_input_processor:arfile_lib",
    "//client/linker/linker_input_processor:arfile_reader_lib",
    "//third_party/boringssl",
    "//third_party/protobuf:protobuf_lite",
  ]

  if (os == "win") {
    deps += [ "//client/certs:certs_resource" ]
  }

  if (os == "linux" && may_make_pie) {
    ldflags = [ "-pie" ]
  }
}

executable("goma_fetch") {
  sources = [
    "goma_fetch.cc",
  ]
  include_dirs = [ "." ]
  deps = [
    ":compiler_proxy_lib",
    ":ioutil_lib",
    ":oauth2_lib",
    "//build/config:exe_and_shlib_deps",
    "//third_party/gflags",
    "//third_party/protobuf:protobuf_lite",
  ]

  if (os == "win") {
    deps += [ "//client/certs:certs_resource" ]
  }
}

action("generate_license") {
  script = "//tools/licenses.py"
  inputs = [
    lastchange_file,
  ]
  outputs = [
    "$root_out_dir/LICENSE",
  ]
  args = [
    rebase_path("../LICENSE", root_build_dir),
    rebase_path("../third_party", root_build_dir),
    rebase_path("$root_out_dir/LICENSE", root_build_dir),
  ]
}

copy("copy_goma_auth_py") {
  sources = [
    "goma_auth.py",
  ]
  outputs = [
    "$root_out_dir/{{source_file_part}}",
  ]
}

copy("copy_goma_ctl_py") {
  sources = [
    "goma_ctl.py",
  ]
  outputs = [
    "$root_out_dir/{{source_file_part}}",
  ]
}

copy("copy_vpython") {
  sources = [
    ".vpython",
  ]
  outputs = [
    "$root_out_dir/{{source_file_part}}",
  ]
}

copy("copy_diagnose_goma_log_py") {
  sources = [
    "diagnose_goma_log.py",
  ]
  outputs = [
    "$root_out_dir/{{source_file_part}}",
  ]
}

if (os != "win") {
  copy("goma_tool") {
    sources = [
      "report_env.sh",
    ]
    if (os == "linux") {
      sources += [
        # for chromeos
        "goma-make",
        "goma-make_unittest",
        "goma-wrapper",
      ]
    }
    outputs = [
      "$root_out_dir/{{source_file_part}}",
    ]
  }

  action("symlink_gomacc") {
    script = "symlink.py"
    deps = [
      ":gomacc",
    ]
    outputs = [
      "$root_out_dir/g++",
      "$root_out_dir/gcc",
      "$root_out_dir/javac",
      "$root_out_dir/cc",
      "$root_out_dir/c++",
      "$root_out_dir/clang",
      "$root_out_dir/clang++",
    ]
    args = [
             "--force",
             "--target",
             "gomacc",
           ] + rebase_path(outputs)
  }

  if (is_official_build) {
    action("dump_compiler_proxy_symbols") {
      script = "dump_syms.py"
      deps = [
        ":compiler_proxy",
        "//third_party/breakpad:dump_syms",
      ]
      outputs = [
        "$root_out_dir/compiler_proxy.sym",
      ]
      args = [
        "--dump_syms",
        rebase_path("$root_out_dir/dump_syms"),
        "--input",
        rebase_path("$root_out_dir/compiler_proxy"),
        "--output",
        rebase_path("$root_out_dir/compiler_proxy.sym"),
      ]
    }

    action("dump_gomacc_symbols") {
      script = "dump_syms.py"
      deps = [
        ":gomacc",
        "//third_party/breakpad:dump_syms",
      ]
      outputs = [
        "$root_out_dir/gomacc.sym",
      ]
      args = [
        "--dump_syms",
        rebase_path("$root_out_dir/dump_syms"),
        "--input",
        rebase_path("$root_out_dir/gomacc"),
        "--output",
        rebase_path("$root_out_dir/gomacc.sym"),
      ]
    }

    action("calc_sha256_checksum") {
      script = "calculate_sha256.py"
      deps = [
        ":compiler_proxy",
        ":copy_diagnose_goma_log_py",
        ":copy_goma_auth_py",
        ":copy_goma_ctl_py",
        ":copy_vpython",
        ":dump_compiler_proxy_symbols",
        ":dump_gomacc_symbols",
        ":generate_license",
        ":goma_fetch",
        ":goma_tool",
        ":gomacc",
      ]
      outputs = [
        "$root_out_dir/sha256.json",
      ]
      args = [
        "--output",
        rebase_path("$root_out_dir/sha256.json"),
        rebase_path("$root_out_dir/compiler_proxy"),
        rebase_path("$root_out_dir/compiler_proxy.sym"),
        rebase_path("$root_out_dir/diagnose_goma_log.py"),
        rebase_path("$root_out_dir/goma_auth.py"),
        rebase_path("$root_out_dir/gomacc"),
        rebase_path("$root_out_dir/gomacc.sym"),
        rebase_path("$root_out_dir/goma_ctl.py"),
        rebase_path("$root_out_dir/.vpython"),
        rebase_path("$root_out_dir/goma_fetch"),
        rebase_path("$root_out_dir/report_env.sh"),
        rebase_path("$root_out_dir/LICENSE"),
      ]
    }
  }
} else {  # win
  executable("vcflags") {
    sources = [
      "vcflags.c",
    ]
    deps = [
      "//build/config:exe_and_shlib_deps",
    ]
  }
  copy("goma_tool") {
    sources = [
      "goma_ctl.bat",
    ]
    outputs = [
      "$root_out_dir/{{source_file_part}}",
    ]
  }

  if (is_official_build) {
    action("dump_gomacc_symbols") {
      script = "dump_syms.py"
      deps = [
        ":gomacc",
        "//third_party/breakpad:dump_syms",
      ]
      outputs = [
        "$root_out_dir/gomacc.sym",
      ]
      args = [
        "--dump_syms",
        rebase_path("$root_out_dir/dump_syms.exe"),
        "--input",
        rebase_path("$root_out_dir/gomacc.exe"),
        "--output",
        rebase_path("$root_out_dir/gomacc.sym"),
      ]
    }

    action("dump_compiler_proxy_symbols") {
      script = "dump_syms.py"
      deps = [
        ":compiler_proxy",
        "//third_party/breakpad:dump_syms",
      ]
      outputs = [
        "$root_out_dir/compiler_proxy.sym",
      ]
      args = [
        "--dump_syms",
        rebase_path("$root_out_dir/dump_syms.exe"),
        "--input",
        rebase_path("$root_out_dir/compiler_proxy.exe"),
        "--output",
        rebase_path("$root_out_dir/compiler_proxy.sym"),
      ]
    }

    action("calc_sha256_checksum") {
      script = "calculate_sha256.py"
      deps = [
        ":compiler_proxy",
        ":copy_diagnose_goma_log_py",
        ":copy_goma_auth_py",
        ":copy_goma_ctl_py",
        ":copy_vpython",
        ":dump_compiler_proxy_symbols",
        ":dump_gomacc_symbols",
        ":generate_license",
        ":goma_fetch",
        ":goma_tool",
        ":gomacc",
        ":vcflags",
      ]
      outputs = [
        "$root_out_dir/sha256.json",
      ]
      args = [
        "--output",
        rebase_path("$root_out_dir/sha256.json"),
        rebase_path("$root_out_dir/compiler_proxy.exe"),
        rebase_path("$root_out_dir/compiler_proxy.exe.pdb"),
        rebase_path("$root_out_dir/compiler_proxy.sym"),
        rebase_path("$root_out_dir/diagnose_goma_log.py"),
        rebase_path("$root_out_dir/goma_auth.py"),
        rebase_path("$root_out_dir/gomacc.exe"),
        rebase_path("$root_out_dir/gomacc.exe.pdb"),
        rebase_path("$root_out_dir/gomacc.sym"),
        rebase_path("$root_out_dir/goma_ctl.bat"),
        rebase_path("$root_out_dir/goma_ctl.py"),
        rebase_path("$root_out_dir/.vpython"),
        rebase_path("$root_out_dir/goma_fetch.exe"),
        rebase_path("$root_out_dir/goma_fetch.exe.pdb"),
        rebase_path("$root_out_dir/vcflags.exe"),
        rebase_path("$root_out_dir/vcflags.exe.pdb"),
        rebase_path("$root_out_dir/LICENSE"),
      ]
    }
  }
}

static_library("goma_test_lib") {
  testonly = true
  sources = [
    "unittest_util.cc",
    "unittest_util.h",
  ]
  if (os == "win") {
    sources += [
      "vsvars.cc",
      "vsvars.h",
    ]
  }
  deps = [
    ":common",
    "//base",
    "//base:goma_unittest",
    "//lib",
    "//third_party:glog",
  ]
  public_deps = [
    "//third_party:gtest",
    "//third_party/abseil",
  ]
}

static_library("gomacc_test_lib") {
  testonly = true
  sources = [
    "unittest_util.cc",
    "unittest_util.h",
  ]
  deps = [
    ":common",
    ":gomacc_lib",
    ":ioutil_lib",
    "//base:goma_unittest",
    "//lib",
    "//third_party:glog",
    "//third_party:gtest",
  ]
}

executable("atomic_stats_counter_unittest") {
  testonly = true
  sources = [
    "atomic_stats_counter_unittest.cc",
  ]
  deps = [
    ":common",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("base64_unittest") {
  testonly = true
  sources = [
    "base64_unittest.cc",
  ]
  deps = [
    ":base64_lib",
    ":goma_test_lib",
    "//base",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("callback_unittest") {
  testonly = true
  sources = [
    "callback_unittest.cc",
  ]
  deps = [
    ":common",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("compilation_database_reader_unittest") {
  testonly = true
  sources = [
    "compilation_database_reader_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("compile_task_unittest") {
  testonly = true
  sources = [
    "compile_task_unittest.cc",
  ]
  deps = [
    ":breakpad_lib",
    ":compiler_proxy_lib",
    ":goma_test_lib",
    ":local_output_cache_lib",
    "//build/config:exe_and_shlib_deps",
    "//client/cxx:cxx_compiler_info_builder_lib",
    "//client/cxx/include_processor:cpp_include_processor_lib",
    "//client/java:jar_parser_lib",
    "//lib:compiler_flag_type_specific",
  ]
}

executable("compiler_type_specific_unittest") {
  testonly = true
  sources = [
    "compiler_type_specific_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":compiler_type_specific_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
    "//lib:gcc_specific",
    "//lib:vc_specific",
  ]
}

executable("compiler_info_builder_unittest") {
  testonly = true
  sources = [
    "compiler_info_builder_unittest.cc",
  ]
  deps = [
    ":compiler_info_lib",
    ":compiler_proxy_lib",
    ":goma_test_lib",
    ":subprocess_lib",
    "//build/config:exe_and_shlib_deps",
    "//client/cxx:gcc_compiler_info_builder_lib",
    "//client/cxx/include_processor:cpp_parser_lib",
    "//lib:compiler_flag_type_specific",
  ]
}

executable("compiler_info_cache_unittest") {
  testonly = true
  sources = [
    "compiler_info_cache_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    ":subprocess_lib",
    "//build/config:exe_and_shlib_deps",
    "//client/cxx:gcc_compiler_info_builder_lib",
    "//client/cxx/include_processor:cpp_parser_lib",
    "//lib:compiler_flag_type_specific",
  ]
}

executable("compiler_info_state_unittest") {
  testonly = true
  sources = [
    "compiler_info_state_unittest.cc",
  ]
  deps = [
    ":compiler_info_lib",
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
    "//client/cxx/include_processor:cpp_parser_lib",
  ]
}

executable("compile_stats_unittest") {
  testonly = true
  sources = [
    "compile_stats_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    ":time_util_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("content_cursor_unittest") {
  testonly = true
  sources = [
    "content_cursor_unittest.cc",
  ]
  deps = [
    ":content_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("counterz_unittest") {
  testonly = true
  sources = [
    "counterz_unittest.cc",
  ]
  deps = [
    ":common",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
    "//third_party:glog",
  ]
}

executable("deps_cache_unittest") {
  testonly = true
  sources = [
    "deps_cache_unittest.cc",
  ]
  deps = [
    ":compiler_info_lib",
    ":deps_cache_lib",
    ":deps_cache_proto",
    ":file_hash_cache_lib",
    ":goma_test_lib",
    ":subprocess_lib",
    "//build/config:exe_and_shlib_deps",
    "//client/cxx:cxx_compiler_info_lib",
    "//client/cxx/include_processor:cpp_parser_lib",
    "//client/cxx/include_processor:include_cache_lib",
    "//client/java:java_compiler_info_lib",
    "//lib:compiler_flag_type_specific",
  ]
}

executable("env_flags_unittest") {
  testonly = true
  sources = [
    "env_flags_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("file_path_util_unittest") {
  testonly = true
  sources = [
    "file_path_util_unittest.cc",
  ]
  deps = [
    ":common",
    ":file_path_util_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
    "//lib",
    "//lib:compiler_flag_type_specific",
    "//third_party:glog",
  ]
}

executable("file_stat_unittest") {
  testonly = true
  sources = [
    "file_stat_unittest.cc",
  ]
  deps = [
    ":common",
    ":goma_test_lib",
    ":scoped_tmp_file_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("filename_id_table_unittest") {
  testonly = true
  sources = [
    "filename_id_table_unittest.cc",
  ]
  deps = [
    ":deps_cache_lib",
    ":deps_cache_proto",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("goma_blob_unittest") {
  testonly = true
  sources = [
    "goma_blob_unittest.cc",
  ]
  deps = [
    ":common",
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("goma_ipc_unittest") {
  testonly = true
  sources = [
    "goma_ipc_unittest.cc",
    "mock_socket_factory.cc",
    "mock_socket_factory.h",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    ":gomacc_lib",
    ":ioutil_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("gomacc_argv_unittest") {
  testonly = true
  sources = [
    "gomacc_argv_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    ":gomacc_lib",
    ":ioutil_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("hash_rewrite_parser_unittest") {
  testonly = true
  sources = [
    "hash_rewrite_parser_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("histogram_unittest") {
  testonly = true
  sources = [
    "histogram_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    ":scoped_tmp_file_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("http_unittest") {
  testonly = true
  sources = [
    "http_unittest.cc",
    "mock_socket_factory.cc",
    "mock_socket_factory.h",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    ":scoped_tmp_file_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("http_rpc_unittest") {
  testonly = true
  sources = [
    "fake_tls_engine.cc",
    "fake_tls_engine.h",
    "http_rpc_unittest.cc",
    "mock_socket_factory.cc",
    "mock_socket_factory.h",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    ":ioutil_lib",
    "//build/config:exe_and_shlib_deps",
    "//third_party:minizip",
  ]
}

executable("http_util_unittest") {
  testonly = true
  sources = [
    "http_util_unittest.cc",
  ]
  deps = [
    ":goma_test_lib",
    ":ioutil_lib",
    "//build/config:exe_and_shlib_deps",
    "//third_party/abseil",
  ]
}

executable("ioutil_unittest") {
  testonly = true
  sources = [
    "ioutil_unittest.cc",
  ]
  deps = [
    ":goma_test_lib",
    ":ioutil_lib",
    "//build/config:exe_and_shlib_deps",
    "//lib",
    "//third_party/abseil",
  ]
}

executable("jwt_unittest") {
  testonly = true
  sources = [
    "jwt_unittest.cc",
  ]
  deps = [
    ":base64_lib",
    ":common",
    ":goma_test_lib",
    ":jwt_lib",
    "//base",
    "//build/config:exe_and_shlib_deps",
    "//third_party:glog",
    "//third_party/boringssl",
  ]
}

executable("linked_unordered_map_unittest") {
  testonly = true
  sources = [
    "linked_unordered_map_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("list_dir_cache_unittest") {
  testonly = true
  sources = [
    "list_dir_cache_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("local_output_cache_unittest") {
  testonly = true
  sources = [
    "local_output_cache_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":content_lib",
    ":goma_test_lib",
    ":local_output_cache_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("log_cleaner_unittest") {
  testonly = true
  sources = [
    "log_cleaner_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("luci_context_unittest") {
  testonly = true
  sources = [
    "luci_context_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("machine_info_unittest") {
  testonly = true
  sources = [
    "machine_info_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("mypath_unittest") {
  testonly = true
  sources = [
    "mypath_unittest.cc",
  ]
  deps = [
    ":common",
    ":goma_test_lib",
    ":ioutil_lib",
    "//base",
    "//build/config:exe_and_shlib_deps",
    "//lib",
    "//third_party:glog",
  ]
}

executable("oauth2_unittest") {
  testonly = true
  sources = [
    "oauth2_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    ":oauth2_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("openssl_engine_unittest") {
  testonly = true
  sources = [
    "openssl_engine_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
    "//third_party/boringssl",
  ]
  if (os == "win") {
    deps += [ "//client/certs:certs_resource" ]
  }
}

executable("rand_util_unittest") {
  testonly = true
  sources = [
    "rand_util_unittest.cc",
  ]
  deps = [
    ":goma_test_lib",
    ":rand_util_lib",
    "//build/config:exe_and_shlib_deps",
    "//third_party/boringssl",
  ]
}

executable("sha256_hash_cache_unittest") {
  testonly = true
  sources = [
    "sha256_hash_cache_unittest.cc",
  ]
  deps = [
    ":goma_test_lib",
    ":sha256_hash_cache_lib",
    "//build/config:exe_and_shlib_deps",
    "//third_party/abseil",
  ]
}

executable("simple_timer_unittest") {
  testonly = true
  sources = [
    "simple_timer_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("subprocess_task_unittest") {
  testonly = true
  sources = [
    "subprocess_task_unittest.cc",
  ]
  deps = [
    ":breakpad_lib",
    ":compiler_proxy_lib",
    ":goma_test_lib",
    ":scoped_tmp_file_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("threadpool_http_server_unittest") {
  testonly = true
  sources = [
    "threadpool_http_server_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("time_util_unittest") {
  testonly = true
  sources = [
    "time_util_unittest.cc",
  ]
  deps = [
    ":goma_test_lib",
    ":time_util_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("trustedipsmanager_unittest") {
  testonly = true
  sources = [
    "trustedipsmanager_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("util_unittest") {
  testonly = true
  sources = [
    "util_unittest.cc",
  ]
  deps = [
    ":common",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
    "//third_party:glog",
  ]
}

executable("worker_thread_unittest") {
  testonly = true
  sources = [
    "worker_thread_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("worker_thread_manager_unittest") {
  testonly = true
  sources = [
    "mock_socket_factory.cc",
    "mock_socket_factory.h",
    "worker_thread_manager_unittest.cc",
  ]
  deps = [
    ":compiler_proxy_lib",
    ":goma_test_lib",
    "//build/config:exe_and_shlib_deps",
  ]
}

executable("zero_copy_stream_impl_unittest") {
  testonly = true
  sources = [
    "zero_copy_stream_impl_unittest.cc",
  ]
  deps = [
    # TODO: factor out zero_copy_stream_lib from compiler_proxy_lib
    ":compiler_proxy_lib",
    ":goma_test_lib",
    ":ioutil_lib",
    "//build/config:exe_and_shlib_deps",
    "//third_party/abseil",
  ]
}

if (os == "linux") {
  executable("cros_util_unittest") {
    testonly = true
    sources = [
      "cros_util_unittest.cc",
    ]
    deps = [
      ":gomacc_lib",
      ":gomacc_test_lib",
      "//build/config:exe_and_shlib_deps",
      "//third_party:gtest",
      "//third_party/abseil",
    ]
  }
}

if (os == "win") {
  executable("dump_env") {
    testonly = true
    sources = [
      "dump_env.c",
    ]
    deps = [
      "//build/config:exe_and_shlib_deps",
    ]
  }
  executable("filetime_win_unittest") {
    testonly = true
    sources = [
      "filetime_win_unittest.cc",
    ]
    deps = [
      ":common",
      ":goma_test_lib",
      "//build/config:exe_and_shlib_deps",
      "//third_party:gtest",
      "//third_party/abseil",
    ]
  }
  executable("named_pipe_client_win_unittest") {
    testonly = true
    sources = [
      "named_pipe_client_win_unittest.cc",
    ]
    deps = [
      ":compiler_proxy_lib",
      ":goma_test_lib",
      "//build/config:exe_and_shlib_deps",
      "//third_party/abseil",
    ]
  }
  executable("named_pipe_server_win_unittest") {
    testonly = true
    sources = [
      "named_pipe_server_win_unittest.cc",
    ]
    deps = [
      ":compiler_proxy_lib",
      ":goma_test_lib",
      "//build/config:exe_and_shlib_deps",
    ]
  }
  executable("posix_helper_win_unittest") {
    testonly = true
    sources = [
      "posix_helper_win_unittest.cc",
    ]
    deps = [
      ":compiler_proxy_lib",
      ":goma_test_lib",
      ":ioutil_lib",
      "//build/config:exe_and_shlib_deps",
    ]
  }
  executable("spawner_win_unittest") {
    testonly = true
    sources = [
      "spawner_win_unittest.cc",
    ]
    deps = [
      ":compiler_proxy_lib",
      ":goma_test_lib",
      ":subprocess_lib",
      "//base",
      "//build/config:exe_and_shlib_deps",
      "//third_party/abseil",
    ]
  }
  executable("vstestrun") {
    testonly = true
    sources = [
      "vstestrun.cc",
    ]
    deps = [
      ":compiler_proxy_lib",
      ":goma_test_lib",
      "//build/config:exe_and_shlib_deps",
    ]
  }
} else {
  executable("compiler_flags_util_unittest") {
    testonly = true
    sources = [
      "compiler_flags_util_unittest.cc",
    ]
    deps = [
      ":compiler_info_lib",
      ":compiler_proxy_lib",
      ":goma_test_lib",
      "//build/config:exe_and_shlib_deps",
      "//client/cxx:cxx_compiler_info_lib",
      "//client/cxx/include_processor:cpp_parser_lib",
    ]
  }
  executable("spawner_posix_unittest") {
    testonly = true
    sources = [
      "spawner_posix_unittest.cc",
    ]
    deps = [
      ":gomacc_test_lib",
      ":subprocess_lib",
      "//build/config:exe_and_shlib_deps",
      "//third_party:gtest",
    ]
  }
}

fuzzer_test("base64_fuzzer") {
  sources = [
    "base64_fuzzer.cc",
  ]
  deps = [
    ":common",
    "//base",
  ]
}

fuzzer_test("ioutil_parse_http_response_fuzzer") {
  sources = [
    "ioutil_parse_http_response_fuzzer.cc",
  ]
  deps = [
    ":common",
    "//base",
  ]
  dict = "data/fuzzer_dictionaries/net_url_request_fuzzer.dict"
}

executable("execreq_normalizer_diff") {
  sources = [
    "execreq_normalizer_diff.cc",
  ]

  deps = [
    "//build/config:exe_and_shlib_deps",
    "//lib",
    "//lib:compiler_flag_type_specific",
    "//third_party:glog",
    "//third_party/protobuf:protobuf_lite",
  ]
}

# fake is a fake compiler.
# This works like a fake compiler.
# It just copied input *.fake to *.out.
executable("fake_compiler") {
  output_name = "fake"
  sources = [
    "fake_compiler.cc",
  ]

  deps = [
    "//base",
    "//build/config:exe_and_shlib_deps",
    "//third_party/abseil",
  ]
}