# Copyright 2019 The Pigweed Authors
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations under
# the License.

import("$dir_pw_build/pw_executable.gni")
import("$dir_pw_build/python_script.gni")

# Defines a target if enable_if is true. Otherwise, it defines that target as
# <target_name>_DISABLED and creates an empty <target_name> group. This can be
# used to conditionally create targets without having to conditionally add them
# to groups. This results in simpler BUILD.gn files.
template("_pw_disableable_target") {
  assert(defined(invoker.enable_if),
         "`enable_if` is required for _pw_disableable_target")
  assert(defined(invoker.target_type),
         "`target_type` is required for _pw_disableable_target")

  if (invoker.enable_if) {
    _actual_target_name = target_name
  } else {
    _actual_target_name = target_name + "_DISABLED"

    group(target_name) {
      forward_variables_from(invoker, [ "testonly" ])
    }
  }

  target(invoker.target_type, _actual_target_name) {
    forward_variables_from(invoker,
                           "*",
                           [
                             "enable_if",
                             "target_type",
                           ])
  }
}

# Creates an executable target for a unit test.
#
# If the pw_automatic_test_runner variable is set, this template also creates a
# "${test_name}_run" target which runs the unit test executable after building
# it.
#
# Args:
#   - enable_if: (optional) Conditionally enables or disables this test. The test
#         target and *_run target do nothing when the test is disabled. The
#         disabled test can still be built and run with the
#         <target_name>_DISABLED and <target_name>_DISABLED_run targets.
#         Defaults to true (enable_if).
#   - All of the regular "executable" target args are accepted.
template("pw_test") {
  # This is required in order to reference the pw_test template's target name
  # within the test_metadata of the metadata group below. The group() definition
  # creates a new scope where the "target_name" variable is set to its target,
  # shadowing the one in this scope.
  _test_target_name = target_name

  _test_is_enabled = !defined(invoker.enable_if) || invoker.enable_if

  _pw_disableable_target(_test_target_name) {
    target_type = "pw_executable"
    enable_if = _test_is_enabled

    # Metadata for this test when used as part of a pw_test_group target.
    metadata = {
      tests = [
        {
          type = "test"
          test_name = _test_target_name
          test_directory = rebase_path(target_out_dir, root_build_dir)
        },
      ]
    }

    forward_variables_from(invoker, "*", [ "metadata" ])

    if (!defined(deps)) {
      deps = []
    }
    deps += [ pw_unit_test_main ]
  }

  if (pw_automatic_test_runner != "") {
    # When the automatic runner is set, create an action which runs the unit
    # test executable using the test runner script.
    if (_test_is_enabled) {
      _test_to_run = _test_target_name
    } else {
      # Create a run target for the _DISABLED version of the test.
      _test_to_run = _test_target_name + "_DISABLED"

      # Create a dummy _run target for the regular version of the test.
      group(_test_target_name + "_run") {
        deps = [ ":$_test_target_name" ]
      }
    }

    pw_python_script(_test_to_run + "_run") {
      deps = [ ":$_test_target_name" ]
      inputs = [ pw_automatic_test_runner ]
      script = "$dir_pw_unit_test/py/pw_unit_test/test_runner.py"
      args = [
        "--runner",
        pw_automatic_test_runner,
        "--test",
        get_path_info("$target_out_dir:$_test_to_run", "abspath"),
      ]
      stamp = true
    }
  }
}

# Defines a related collection of unit tests.
#
# pw_test_group targets output a JSON metadata file for the Pigweed test runner.
#
# Args:
#  tests: List of pw_test targets for each of the tests in the group.
#  group_deps: Optional pw_test_group targets on which this group depends.
template("pw_test_group") {
  _group_target = target_name
  _group_deps_metadata = []
  if (defined(invoker.tests)) {
    _deps = invoker.tests
  } else {
    _deps = []
  }

  if (defined(invoker.group_deps)) {
    # If the group specified any other group dependencies, create a metadata
    # entry for each of them indicating that they are another group and a group
    # target to collect that metadata.
    foreach(dep, invoker.group_deps) {
      _group_deps_metadata += [
        {
          type = "dep"
          group = get_path_info(dep, "abspath")
        },
      ]
    }

    _deps += invoker.group_deps
  }

  _metadata_group_target = "${target_name}_pw_test_group_metadata"
  group(_metadata_group_target) {
    metadata = {
      group_deps = _group_deps_metadata
      self = [
        {
          type = "self"
          name = get_path_info(":$_group_target", "abspath")
        },
      ]

      # Metadata from the group's own unit test targets is forwarded through
      # the group dependencies group. This entry is listed as a "walk_key" in
      # the generated file so that only test targets' metadata (not group
      # targets) appear in the output.
      if (defined(invoker.tests)) {
        propagate_metadata_from = invoker.tests
      }
    }
    deps = _deps
  }

  _test_group_deps = [ ":$_metadata_group_target" ]

  generated_file(_group_target) {
    outputs = [ "$target_out_dir/$target_name.testinfo.json" ]
    data_keys = [
      "group_deps",
      "self",
      "tests",
    ]
    walk_keys = [ "propagate_metadata_from" ]
    output_conversion = "json"
    deps = _test_group_deps
  }

  # If automatic test running is enabled, create a *_run group that collects all
  # of the individual *_run targets and groups.
  if (pw_automatic_test_runner != "") {
    group(_group_target + "_run") {
      deps = [ ":$_group_target" ]
      foreach(_target, _deps) {
        deps += [ "${_target}_run" ]
      }
    }
  }
}