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

import("//build/images/vbmeta.gni")
import("//build/testing/test_spec.gni")
import("//build/testing/zbi_test_success.gni")
import("//build/zbi/zbi.gni")
import("//build/zbi/zbi_input.gni")

declare_args() {
  # Set this variable to true to include zbi_tests into tests.json.
  include_zbi_host_tests = false
}

# Composes a host test to check for the success of the zbi tests.
#
# The test target is constructed differently based on whether it is run against
# hardware or an emulator, so the template needs to be called with device_types
# that are either only hardware or only emulators.
#
# Parameters
#
#   is_emu
#     [bool] Whether the device_types provided are all emulator types. If false,
#     all device_types are expected to be hardware.
#
#   device_types
#     [list of strings] Devices the test should run on.
#     Allowable values are those among the entries in
#     //build/testing/platforms.gni; others will be ignored.
#
#   zbi_image, vbmeta_image, qemu_kernel
#     Passed through to the environments of the associated test_spec.
#     See //build/testing/test_spec.gni.
#
template("zbi_host_test") {
  forward_variables_from(invoker, [ "is_emu" ])
  toolchain = host_toolchain
  os = host_os
  cpu = host_cpu
  if (is_emu) {
    toolchain = host_toolchain_for_target_cpu
    os = host_os
    cpu = target_cpu
  }

  # Create a script to run the seriallistener tool with the appropriate args.
  _script_file = "${target_out_dir}/${target_name}.sh"
  _test_script_target = "${target_name}_script"

  action(_test_script_target) {
    testonly = true
    script = "//build/testing/create_test.sh"
    binary_path = get_label_info("//tools/testing/seriallistener($toolchain)",
                                 "root_out_dir") + "/seriallistener"
    args = [
      rebase_path(_script_file, root_build_dir),
      rebase_path(binary_path, root_build_dir),
    ]
    args += [
      "-success-str",
      zbi_test_success_string,
    ]
    if (!is_emu) {
      args += [ "-stdout=True" ]
    }

    outputs = [ "${_script_file}" ]
    visibility = [ ":*" ]

    deps = [ "//tools/testing/seriallistener($toolchain)" ]
    metadata = {
      test_runtime_deps = [
        _script_file,
        binary_path,
      ]
    }
  }

  test_spec(target_name) {
    target = get_label_info(":${target_name}", "label_with_toolchain")
    path = _script_file
    os = os
    cpu = cpu
    isolated = true

    # Default timeout for zbi tests is 10 minutes.
    # TODO(ihuh): Once we have more data, we can override this with a more
    # sensible timeout for each test.
    timeout_secs = 600
    forward_variables_from(invoker, [ "visibility" ])

    deps = [ ":${_test_script_target}" ]

    environments = []
    if (defined(invoker.device_types)) {
      foreach(dt, invoker.device_types) {
        environments += [
          {
            dimensions = {
              device_type = dt
            }
            image_overrides = {
              zbi_image = {
                name = invoker.zbi_image
              }
              if (!is_emu && defined(invoker.vbmeta_image)) {
                vbmeta_image = {
                  name = invoker.vbmeta_image
                }
              }
              if (is_emu) {
                if (defined(invoker.qemu_kernel)) {
                  qemu_kernel = {
                    label = get_label_info(invoker.qemu_kernel,
                                           "label_with_toolchain")
                  }
                } else {  # If qemu_kernel is not provided, use the default.
                  qemu_kernel = {
                    name = "qemu-kernel"
                  }
                }
              }
            }
          },
        ]
      }
    }
  }
}

# Composes a test zbi out of Zircon artifacts.
#
# The $target_name target is a group() that holds the metadata and is what
# should be used in deps.  The actual zbi() target is defined as
# "$target_name.zbi" so that e.g. get_target_outputs(":$target_name.zbi")
# can be used.
#
# If `use_vbmeta` is true, an associated VBMeta image (of the same base name)
# will be output alongside the ZBI.
#
# Parameters
#
#   args (optional)
#     [list of strings] Command line arguments for the resulting zbi. ZBI tests
#     using the kernel and a non-default `userboot.next` options must add
#     `userboot.{shutdown,reboot}` as well in order to guarantee that a success
#     string is printed. See //zircon/system/utest/core:core-tests for a
#     canonical example.
#
#   device_types
#     [list of strings] Devices the test should run on.
#     Allowable values are those among the entries in
#     //build/testing/platforms.gni; others will be ignored.
#     Defaults to [ "QEMU" ].
#
#   qemu_kernel
#     [label_with_toolchain] Label corresponding to the qemu-kernel image
#     in images.json that should be used with the zbi_image. This will appear
#     as the qemu_kernel_label in a zbi_tests.json entry.
#
#   deps, data_deps, replace, complete, compress
#     See //build/zbi/zbi.gni.
template("zbi_test") {
  main_target = target_name
  zbi_target = "${target_name}.zbi"

  not_needed(invoker,
             [
               "qemu_kernel",
               "timeout",
             ])

  input_deps = []
  group_deps = []

  entries = []
  if (defined(invoker.args)) {
    entries += invoker.args
  }

  if (entries != []) {
    input_target = "${target_name}_input"
    input_deps += [ ":$input_target" ]

    zbi_input(input_target) {
      forward_variables_from(invoker, [ "deps" ])
      testonly = true
      type = "cmdline"
      args = []
      foreach(entry, entries) {
        args += [ "--entry=$entry" ]
      }
    }
  }

  forward_variables_from(invoker, [ "output_name" ])
  if (!defined(output_name)) {
    output_name = main_target
  }

  zbi(zbi_target) {
    testonly = true
    data_deps = []
    forward_variables_from(invoker,
                           [
                             "cpu",
                             "compress",
                             "data_deps",
                             "output_dir",
                             "output_extension",
                             "visibility",
                           ])
    if (defined(visibility)) {
      visibility += [ ":$main_target" ]
    }

    deps = invoker.deps + input_deps
    if (defined(invoker.qemu_kernel)) {
      data_deps += [ invoker.qemu_kernel ]
    }

    _output_dir = target_out_dir
    if (defined(output_dir)) {
      _output_dir = output_dir
    }
    _output_extension = "zbi"
    if (defined(output_extension)) {
      _output_extension = output_extension
    }
    _output_file = "${_output_dir}/${output_name}"
    if (_output_extension != "") {
      _output_file += ".${_output_extension}"
    }

    metadata = {
      images = [
        {
          label = get_label_info(":$zbi_target", "label_with_toolchain")
          name = output_name
          path = rebase_path(_output_file, root_build_dir)
          type = "zbi"
          cpu = current_cpu
          compressed =
              !defined(invoker.compressed) ||
              (invoker.compressed != false && invoker.compressed != "none")
          if (defined(testonly) && testonly) {
            testonly = true
          }
          forward_variables_from(invoker, [ "tags" ])
        },
      ]
    }
  }

  group_deps += [ ":$zbi_target" ]

  output_zbi = target_name
  if (defined(invoker.output_name)) {
    output_zbi = invoker.output_name
  }
  if (defined(invoker.output_extension)) {
    if (invoker.output_extension != "") {
      output_zbi += ".${invoker.output_extension}"
    }
  } else {
    output_zbi += ".zbi"
  }
  if (defined(invoker.output_dir)) {
    output_zbi = "${invoker.output_dir}/$output_zbi"
  } else {
    output_zbi = "$target_out_dir/$output_zbi"
  }

  if (defined(invoker.device_types)) {
    _device_types = invoker.device_types
  } else {
    _device_types = [
      "AEMU",
      "QEMU",
    ]
  }

  if (use_vbmeta) {
    vbmeta_target = "${target_name}.vbmeta"
    vbmeta(vbmeta_target) {
      forward_variables_from(invoker, [ "visibility" ])
      testonly = true
      zbi = ":$zbi_target"
    }

    vbmeta_outputs = get_target_outputs(":${vbmeta_target}")
    output_vbmeta = vbmeta_outputs[0]

    group_deps += [ ":${vbmeta_target}" ]
  }

  if (include_zbi_host_tests) {
    emu_types = []
    hardware_types = []
    foreach(dt, _device_types) {
      if (dt == "QEMU" || dt == "AEMU") {
        emu_types += [ dt ]
      } else {
        hardware_types += [ dt ]
      }
    }
    host_test_name = "${main_target}_host_test"
    if (emu_types != []) {
      zbi_host_test(host_test_name) {
        is_emu = true
        zbi_image = output_name
        if (defined(invoker.qemu_kernel)) {
          qemu_kernel = invoker.qemu_kernel
        }
        device_types = emu_types
      }
      group_deps += [ ":$host_test_name" ]
    }
    if (hardware_types != []) {
      host_test_hw_name = "${host_test_name}_for_hardware"
      zbi_host_test(host_test_hw_name) {
        is_emu = false
        zbi_image = output_name
        if (use_vbmeta) {
          vbmeta_image = vbmeta_target
        }
        device_types = hardware_types
      }
      group_deps += [ ":$host_test_hw_name" ]
    }
  }

  group(main_target) {
    forward_variables_from(invoker,
                           [
                             "assert_no_deps",
                             "visibility",
                           ])

    testonly = true

    public_deps = group_deps

    metadata = {
      # Used by the zbi() template to ensure that this is not included into
      # any ZBI that depends on this target.
      zbi_input_barrier = []

      # Used by build_api_module("zbi_tests") in //BUILD.gn
      zbi_tests = [
        {
          cpu = current_cpu
          disabled = defined(invoker.tags) && invoker.tags + [ "disabled" ] -
                                              [ "disabled" ] != invoker.tags
          name = main_target
          label = get_label_info(":$target_name", "label_with_toolchain")
          path = rebase_path(output_zbi, root_build_dir)
          if (use_vbmeta) {
            vbmeta = rebase_path(output_vbmeta, root_build_dir)
          }
          bootserver_netboot = [ "--boot" ]
          success_string = zbi_test_success_string
          device_types = _device_types
          if (defined(invoker.qemu_kernel)) {
            assert(device_types == [ "QEMU" ],
                   "`qemu_kernel` tests can only run on QEMU")
            qemu_kernel_label =
                get_label_info(invoker.qemu_kernel, "label_with_toolchain")
          }
          if (defined(invoker.timeout) && invoker.timeout != false) {
            timeout = invoker.timeout
          }
        },
      ]
    }
  }
}