tequilaOS/platform_build
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Product configuration in Starlark support files.

Browse source 
Bug: 170637441
Test: rbcrun build/make/tests/run.rbc
Change-Id: Ie8f0c3dea66a287f2b0a3b588c446bfbb2c9a978
This commit is contained in:
Sasha Smundak 2020-11-03 23:44:14 -08:00
parent 24159db21e
commit 5c8b09b2ef
7 changed files with 848 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
core/build_id.rbc Normal file
View file

@ -0,0 +1,21 @@
# Copyright 2021 Google LLC
#
# 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.
# This file has been manually converted from build_id.mk
def init(g):
# BUILD_ID is usually used to specify the branch name (like "MAIN") or a branch name and a release candidate
# (like "CRB01"). It must be a single word, and is capitalized by convention.
g["BUILD_ID"]="AOSP.MASTER"

199
core/envsetup.rbc Normal file
View file

@ -0,0 +1,199 @@
# Copyright 2021 Google LLC
#
# 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.
load(":build_id.rbc|init", _build_id_init="init")
def _all_versions():
"""Returns all known versions."""
versions = ["OPR1", "OPD1", "OPD2","OPM1", "OPM2", "PPR1", "PPD1", "PPD2", "PPM1", "PPM2", "QPR1" ]
for v in ("Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"):
for e in ("P1A", "P1B", "P2A", "P2B", "D1A", "D1B", "D2A", "D2B", "Q1A", "Q1B", "Q2A", "Q2B", "Q3A", "Q3B"):
versions.append(v+e)
return versions
def _allowed_versions(all_versions, min_version, max_version, default_version):
"""Checks that version range and default versions is valid, returns all versions in range."""
for v in (min_version, max_version, default_version):
if v not in all_versions:
fail("% is invalid" % v)
min_i = all_versions.index(min_version)
max_i = all_versions.index(max_version)
def_i = all_versions.index(default_version)
if min_i > max_i:
fail("%s should come before %s in the version list" % (min_version, max_version))
if def_i < min_i or def_i > max_i:
fail("%s should come between % and %s" % (default_version, min_version, max_version))
return all_versions[min_i:max_i+1]
# This function is a manual conversion of the version_defaults.mk
def _versions_default(g, all_versions):
"""Handle various build version information.
Guarantees that the following are defined:
PLATFORM_VERSION
PLATFORM_SDK_VERSION
PLATFORM_VERSION_CODENAME
DEFAULT_APP_TARGET_SDK
BUILD_ID
BUILD_NUMBER
PLATFORM_SECURITY_PATCH
PLATFORM_VNDK_VERSION
PLATFORM_SYSTEMSDK_VERSIONS
"""
# If build_id.rbc exists, it may override some of the defaults.
# Note that build.prop target also wants INTERNAL_BUILD_ID_MAKEFILE to be set if the file exists.
if _build_id_init != None:
_build_id_init(g)
g["INTERNAL_BUILD_ID_MAKEFILE"] = "build/make/core/build_id"
allowed_versions = _allowed_versions(all_versions, v_min, v_max, v_default)
g.setdefault("TARGET_PLATFORM_VERSION", v_default)
if g["TARGET_PLATFORM_VERSION"] not in allowed_versions:
fail("% is not valid, must be one of %s" % (g["TARGET_PLATFORM_VERSION"], allowed_versions))
g["DEFAULT_PLATFORM_VERSION"] = v_default
g["PLATFORM_VERSION_LAST_STABLE"] = 11
g.setdefault("PLATFORM_VERSION_CODENAME", g["TARGET_PLATFORM_VERSION"])
# TODO(asmundak): set PLATFORM_VERSION_ALL_CODENAMES
g.setdefault("PLATFORM_VERSION",
g["PLATFORM_VERSION_LAST_STABLE"] if g["PLATFORM_VERSION_CODENAME"] == "REL" else g["PLATFORM_VERSION_CODENAME"])
g.setdefault("PLATFORM_SDK_VERSION", 30)
if g["PLATFORM_VERSION_CODENAME"] == "REL":
g["PLATFORM_PREVIEW_SDK_VERSION"] = 0
else:
g.setdefault("PLATFORM_PREVIEW_SDK_VERSION", 1)
g.setdefault("DEFAULT_APP_TARGET_SDK",
g["PLATFORM_SDK_VERSION"] if g["PLATFORM_VERSION_CODENAME"] == "REL" else g["PLATFORM_VERSION_CODENAME"])
g.setdefault("PLATFORM_VNDK_VERSION",
g["PLATFORM_SDK_VERSION"] if g["PLATFORM_VERSION_CODENAME"] == "REL" else g["PLATFORM_VERSION_CODENAME"])
g.setdefault("PLATFORM_SYSTEMSDK_MIN_VERSION", 28)
versions = [str(i) for i in range(g["PLATFORM_SYSTEMSDK_MIN_VERSION"], g["PLATFORM_SDK_VERSION"] + 1)]
versions.append(g["PLATFORM_VERSION_CODENAME"])
g["PLATFORM_SYSTEMSDK_VERSIONS"] = sorted(versions)
# Used to indicate the security patch that has been applied to the device.
# It must signify that the build includes all security patches issued up through the designated Android Public Security Bulletin.
# It must be of the form "YYYY-MM-DD" on production devices.
# It must match one of the Android Security Patch Level strings of the Public Security Bulletins.
# If there is no $PLATFORM_SECURITY_PATCH set, keep it empty.
g.setdefault("PLATFORM_SECURITY_PATCH", "2021-03-05")
dt = 'TZ="GMT" %s' % g["PLATFORM_SECURITY_PATCH"]
g.setdefault("PLATFORM_SECURITY_PATCH_TIMESTAMP", rblf_shell("date -d '%s' +%%s" % dt))
# Used to indicate the base os applied to the device. Can be an arbitrary string, but must be a single word.
# If there is no $PLATFORM_BASE_OS set, keep it empty.
g.setdefault("PLATFORM_BASE_OS", "")
# Used to signify special builds. E.g., branches and/or releases, like "M5-RC7". Can be an arbitrary string, but
# must be a single word and a valid file name. If there is no BUILD_ID set, make it obvious.
g.setdefault("BUILD_ID", "UNKNOWN")
# BUILD_NUMBER should be set to the source control value that represents the current state of the source code.
# E.g., a perforce changelist number or a git hash. Can be an arbitrary string (to allow for source control that
# uses something other than numbers), but must be a single word and a valid file name.
#
# If no BUILD_NUMBER is set, create a useful "I am an engineering build from this date/time" value. Make it start
# with a non-digit so that anyone trying to parse it as an integer will probably get "0".
g.setdefault("BUILD_NUMBER", "eng.%s.%s" % (g["USER"], "TIMESTAMP"))
# Used to set minimum supported target sdk version. Apps targeting SDK version lower than the set value will result
# in a warning being shown when any activity from the app is started.
g.setdefault("PLATFORM_MIN_SUPPORTED_TARGET_SDK_VERSION", 23)
def init(g):
all_versions = _all_versions()
_versions_default(g, all_versions)
for v in all_versions:
g["IS_AT_LEAST" + v] = True
if v == g["TARGET_PLATFORM_VERSION"]:
break
# ---------------------------------------------------------------
# If you update the build system such that the environment setup or buildspec.mk need to be updated,
# increment this number, and people who haven't re-run those will have to do so before they can build.
# Make sure to also update the corresponding value in buildspec.mk.default and envsetup.sh.
g["CORRECT_BUILD_ENV_SEQUENCE_NUMBER"] = 13
g.setdefault("TARGET_PRODUCT", "aosp_arm")
g.setdefault("TARGET_BUILD_VARIANT", "eng")
g.setdefault("TARGET_BUILD_APPS", [])
g["TARGET_BUILD_UNBUNDLED"] = (g["TARGET_BUILD_APPS"] != []) or (getattr(g, "TARGET_BUILD_UNBUNDLED_IMAGE", "") != "")
# ---------------------------------------------------------------
# Set up configuration for host machine. We don't do cross-compiles except for arm, so the HOST
# is whatever we are running on.
host = rblf_shell("uname -sm")
if host.find("Linux") >= 0:
g["HOST_OS"] = "linux"
elif host.find("Darwin") >= 0:
g["HOST_OS"] = "darwin"
else:
fail("Cannot run on %s OS" % host)
# TODO(asmundak): set g.HOST_OS_EXTRA
g["BUILD_OS"] = g["HOST_OS"]
# TODO(asmundak): check cross-OS build
if host.find("x86_64") >= 0:
g["HOST_ARCH"] = "x86_64"
g["HOST_2ND_ARCH"] = "x86"
g["HOST_IS_64_BIT"] = True
elif host.find("i686") >= 0 or host.find("x86") >= 0:
fail("Building on a 32-bit x86 host is not supported: %s" % host)
elif g["HOST_OS"] == "darwin":
g["HOST_2ND_ARCH"] = ""
g["HOST_2ND_ARCH_VAR_PREFIX"] = "2ND_"
g["HOST_2ND_ARCH_MODULE_SUFFIX"] = "_32"
g["HOST_CROSS_2ND_ARCH_VAR_PREFIX"] = "2ND_"
g["HOST_CROSS_2ND_ARCH_MODULE_SUFFIX"] = "_64"
g["TARGET_2ND_ARCH_VAR_PREFIX"] = "2ND_"
# TODO(asmundak): combo-related stuff
# on windows, the tools have .exe at the end, and we depend on the
# host config stuff being done first
g["BUILD_ARCH"] = g["HOST_ARCH"]
g["BUILD_2ND_ARCH"] = g["HOST_2ND_ARCH"]
# the host build defaults to release, and it must be release or debug
g.setdefault("HOST_BUILD_TYPE", "release")
if g["HOST_BUILD_TYPE"] != "release" and g["HOST_BUILD_TYPE"] != "debug":
fail("HOST_BUILD_TYPE must be either release or debug, not '%s'" % g["HOST_BUILD_TYPE"])
# TODO(asmundak): a lot more, but not needed for the product configuration
g["ART_APEX_JARS"] = [
"com.android.art:core-oj",
"com.android.art:core-libart",
"com.android.art:okhttp",
"com.android.art:bouncycastle",
"com.android.art:apache-xml"
]
if g.get("TARGET_BUILD_TYPE", "") != "debug":
g["TARGET_BUILD_TYPE"] = "release"
v_default = "SP1A"
v_min = "SP1A"
v_max = "SP1A"

483
core/product_config.rbc Normal file
View file

@ -0,0 +1,483 @@
# Copyright 2021 Google LLC
#
# 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.
load("//build/make/core:envsetup.rbc", _envsetup_init="init")
"""Runtime functions."""
def _global_init():
"""Returns dict created from the runtime environment."""
globals = dict()
# Environment variables
for k in dir(rblf_env):
globals[k] = getattr(rblf_env, k)
# Variables set as var=value command line arguments
for k in dir(rblf_cli):
globals[k] = getattr(rblf_cli, k)
globals.setdefault("PRODUCT_SOONG_NAMESPACES", [])
_envsetup_init(globals)
# Variables that should be defined.
mandatory_vars = [
"PLATFORM_VERSION_CODENAME", "PLATFORM_VERSION",
"PRODUCT_SOONG_NAMESPACES",
# TODO(asmundak): do we need TARGET_ARCH? AOSP does not reference it
"TARGET_BUILD_TYPE", "TARGET_BUILD_VARIANT", "TARGET_PRODUCT",
]
for bv in mandatory_vars:
if not bv in globals:
fail(bv, " is not defined")
return globals
_globals_base = _global_init()
def __print_attr(attr, value):
if not value:
return
if type(value) == "list":
if _options.rearrange:
value = __printvars_rearrange_list(value)
if _options.format == "pretty":
print(attr, "=", repr(value))
elif _options.format == "make":
print(attr, ":=", " ".join(value))
else:
if _options.format == "pretty":
print(attr, "=", repr(value))
elif _options.format == "make":
print(attr, ":=", value)
else:
fail("bad output format", _options.format)
def _printvars(globals, cfg):
"""Prints known configuration variables."""
for attr, val in sorted(cfg.items()):
__print_attr(attr, val)
if _options.print_globals:
for attr, val in sorted(globals.items()):
print()
if attr not in _globals_base:
__print_attr(attr, val)
def __printvars_rearrange_list(l):
"""Rearrange value list: return only distinct elements, maybe sorted."""
seen = { item: 0 for item in l}
return sorted(seen.keys()) if _options.rearrange == "sort" else seen.keys()
def _product_configuration(top_pcm_name, top_pcm):
"""Creates configuration."""
# Product configuration is created by traversing product's inheritance
# tree. It is traversed twice.
# First, beginning with top-level module we execute a module and find
# its ancestors, repeating this recursively. At the end of this phase
# we get the full inheritance tree.
# Second, we traverse the tree in the postfix order (i.e., visiting a
# node after its ancestors) to calculate the product configuration.
#
# PCM means "Product Configuration Module", i.e., a Starlark file
# whose body consists of a single init function.
globals = dict(**_globals_base)
config_postfix = [] # Configs in postfix order
# Each PCM is represented by a quadruple of function, config, children names
# and readyness (that is, the configurations from inherited PCMs have been
# substituted).
configs = { top_pcm_name: (top_pcm, None, [], False)} # All known PCMs
stash = [] # Configs to push once their descendants are done
# Stack maintaining PCMs to be processed. An item in the stack
# is a pair of PCMs name and its height in the product inheritance tree.
pcm_stack = []
pcm_stack.append((top_pcm_name, 0))
pcm_count = 0
# Run it until pcm_stack is exhausted, but no more than N times
for n in range(1000):
if not pcm_stack:
break
(name, height) = pcm_stack.pop()
pcm, cfg, c, _ = configs[name]
# each PCM is executed once
if cfg != None:
continue
# Push ancestors until we reach this node's height
config_postfix.extend([stash.pop() for i in range(len(stash) - height)])
# Run this one, obtaining its configuration and child PCMs.
if _options.trace_modules:
print("%s:" % n[0])
# The handle passed to the PCM consists of config and inheritance state.dict of inherited modules
# and a list containing the current default value of a list variable.
handle = __h_new()
pcm(globals, handle)
children = __h_inherited_modules(handle)
if _options.trace_modules:
print(" ", " ".join(children.keys()))
configs[name] = (pcm, __h_cfg(handle), children.keys(), False)
pcm_count = pcm_count+1
if len(children) == 0:
# Leaf PCM goes straight to the config_postfix
config_postfix.append(name)
continue
# Stash this PCM, process children in the sorted order
stash.append(name)
for child_name in sorted(children, reverse=True):
if child_name not in configs:
configs[child_name] = (children[child_name], None, [], False)
pcm_stack.append((child_name, len(stash)))
# Flush the stash
config_postfix.extend([stash.pop() for i in range(len(stash))])
if len(config_postfix) != pcm_count:
fail("Ran %d modules but postfix tree has only %d entries" % (pcm_count, len(config_postfix)))
if _options.trace_modules:
print("\n---Postfix---")
for x in config_postfix:
print(" ", x)
# Traverse the tree from the bottom, evaluating inherited values
for pcm_name in config_postfix:
pcm, cfg, children_names, ready = configs[pcm_name]
# Should run
if cfg == None:
fail("%s: has not been run" % pcm_name)
# Ready once
if ready:
continue
# Children should be ready
for child_name in children_names:
if not configs[child_name][3]:
fail("%s: child is not ready" % child_name)
# if _options.trace_modules:
# print(">%s: %s" % (pcm_name, cfg))
_substitute_inherited(configs, pcm_name, cfg)
_percolate_inherited(configs, pcm_name, cfg, children_names)
configs[pcm_name] = pcm, cfg, children_names, True
# if _options.trace_modules:
# print("<%s: %s" % (pcm_name, cfg))
return globals, configs[top_pcm_name][1]
def _substitute_inherited(configs, pcm_name, cfg):
"""Substitutes inherited values in all the configuration settings."""
for attr, val in cfg.items():
trace_it = attr in _options.trace_variables
if trace_it:
old_val = val
# TODO(asmundak): should we handle single vars?
if type(val) != "list":
continue
if trace_it:
new_val = _value_expand(configs, attr, val)
if new_val != old_val:
print("%s(i): %s=%s (was %s)" % (pcm_name, attr, new_val, old_val))
cfg[attr] = new_val
continue
cfg[attr] = _value_expand(configs, attr, val)
def _value_expand(configs, attr, values_list):
"""Expands references to inherited values in a given list."""
result = []
expanded={}
for item in values_list:
# Inherited values are 1-tuples
if type(item) != "tuple":
result.append(item)
continue
child_name = item[0]
if child_name in expanded:
continue
expanded[child_name] = True
child = configs[child_name]
if not child[3]:
fail("%s should be ready" % child_name)
__move_items(result, child[1], attr)
return result
def _percolate_inherited(configs, cfg_name, cfg, children_names):
"""Percolates the settings that are present only in children."""
percolated_attrs = {}
for child_name in children_names:
child_cfg = configs[child_name][1]
for attr, value in child_cfg.items():
if type(value) != "list":
if attr in percolated_attrs or not attr in cfg:
cfg[attr] = value
percolated_attrs[attr] = True
continue
if attr in percolated_attrs:
# We already are percolating this one, just add this list
__move_items(cfg[attr], child_cfg, attr)
elif not attr in cfg:
percolated_attrs[attr] = True
cfg[attr] = []
__move_items(cfg[attr], child_cfg, attr)
for attr in _options.trace_variables:
if attr in percolated_attrs:
print("%s: %s^=%s" % (cfg_name, attr, cfg[attr]))
def __move_items(to_list, from_cfg, attr):
l = from_cfg.get(attr, [])
if l:
to_list.extend(l)
from_cfg[attr] = []
def _indirect(pcm_name):
"""Returns configuration item for the inherited module."""
return (pcm_name,)
def _addprefix(prefix, string_or_list):
"""Adds prefix and returns a list.
If string_or_list is a list, prepends prefix to each element.
Otherwise, string_or_list is considered to be a string which
is split into words and then prefix is prepended to each one.
Args:
prefix
string_or_list
"""
return [ prefix + x for x in __words(string_or_list)]
def _addsuffix(suffix, string_or_list):
"""Adds suffix and returns a list.
If string_or_list is a list, appends suffix to each element.
Otherwise, string_or_list is considered to be a string which
is split into words and then suffix is appended to each one.
Args:
suffix
string_or_list
"""
return [ x + suffix for x in __words(string_or_list)]
def __words(string_or_list):
if type(string_or_list) == "list":
return string_or_list
return string_or_list.split()
def __h_new():
"""Constructs a handle which is passed to PCM."""
return (dict(), dict(), list())
def __h_inherited_modules(handle):
return handle[1]
def __h_cfg(handle):
return handle[0]
def _setdefault(handle, attr):
"""Sets given attribute's value if it has not been set."""
cfg = handle[0]
if cfg.get(attr) == None:
cfg[attr] = list(handle[2])
return cfg[attr]
def _inherit(handle, pcm_name, pcm):
"""Records inheritance."""
cfg, inherited, default_lv = handle
inherited[pcm_name]=pcm
default_lv.append(_indirect(pcm_name))
# Add inherited module reference to all configuration values
for attr, val in cfg.items():
if type(val) == "list":
val.append(_indirect(pcm_name))
def _copy_if_exists(path_pair):
"""If from file exists, returns [from:to] pair."""
l = path_pair.split(":", 2)
# Check that l[0] exists
return [":".join(l)] if rblf_file_exists(l[0]) else []
def _enforce_product_packages_exist(pkg_string_or_list):
"""Makes including non-existent modules in PRODUCT_PACKAGES an error."""
#TODO(asmundak)
pass
def _file_wildcard_exists(file_pattern):
"""Return True if there are files matching given bash pattern."""
return len(rblf_wildcard(file_pattern)) > 0
def _find_and_copy(pattern, from_dir, to_dir):
"""Return a copy list for the files matching the pattern."""
return ["%s/%s:%s/%s" % (from_dir, f, to_dir, f) for f in rblf_wildcard(pattern, from_dir)]
def _filter_out(pattern, text):
"""Return all the words from `text' that do not match any word in `pattern'.
Args:
pattern: string or list of words. '%' stands for wildcard (in regex terms, '.*')
text: string or list of words
Return:
list of words
"""
rex = __mk2regex(__words(pattern))
res = []
for w in __words(text):
if not _regex_match(rex, w):
res.append(w)
return res
def _filter(pattern, text):
"""Return all the words in `text` that match `pattern`.
Args:
pattern: strings of words or a list. A word can contain '%',
which stands for any sequence of characters.
text: string or list of words.
"""
rex = __mk2regex(__words(pattern))
res = []
for w in __words(text):
if _regex_match(rex, w):
res.append(w)
return res
def __mk2regex(words):
"""Returns regular expression equivalent to Make pattern."""
# TODO(asmundak): this will mishandle '\%'
return "^(" + "|".join([w.replace("%", ".*", 1) for w in words]) + ")"
def _regex_match(regex, w):
return rblf_regex(regex, w)
def _require_artifacts_in_path(paths, allowed_paths):
"""TODO."""
#print("require_artifacts_in_path(", __words(paths), ",", __words(allowed_paths), ")")
pass
def _require_artifacts_in_path_relaxed(paths, allowed_paths):
"""TODO."""
pass
def _expand_wildcard(pattern):
"""Expands shell wildcard pattern."""
return rblf_wildcard(pattern)
def _mkerror(file, message=""):
"""Prints error and stops."""
fail("%s: %s. Stop" % (file, message))
def _mkwarning(file, message=""):
"""Prints warning."""
print("%s: warning: %s" % (file, message))
def _mkinfo(file, message=""):
"""Prints info."""
print(message)
def __get_options():
"""Returns struct containing runtime global settings."""
settings = dict(
format = "pretty",
print_globals = False,
rearrange = "",
trace_modules = False,
trace_variables = [],
)
for x in getattr(rblf_cli, "RBC_OUT", "").split(","):
if x == "sort" or x == "unique":
if settings["rearrange"]:
fail("RBC_OUT: either sort or unique is allowed (and sort implies unique)")
settings["rearrange"] = x
elif x == "pretty" or x == "make":
settings["format"] = x
elif x == "global":
settings["print_globals"] = True
elif x != "":
fail("RBC_OUT: got %s, should be one of: [pretty|make] [sort|unique]" % x)
for x in getattr(rblf_cli, "RBC_DEBUG", "").split(","):
if x == "!trace":
settings["trace_modules"] = True
elif x != "":
settings["trace_variables"].append(x)
return struct(**settings)
# Settings used during debugging.
_options = __get_options()
rblf = struct(addprefix=_addprefix,
addsuffix=_addsuffix,
copy_if_exists=_copy_if_exists,
cfg=__h_cfg,
enforce_product_packages_exist=_enforce_product_packages_exist,
expand_wildcard=_expand_wildcard,
file_exists=rblf_file_exists,
file_wildcard_exists=_file_wildcard_exists,
filter=_filter,
filter_out=_filter_out,
find_and_copy=_find_and_copy,
global_init=_global_init,
inherit=_inherit,
indirect=_indirect,
mkinfo=_mkinfo,
mkerror=_mkerror,
mkwarning=_mkwarning,
printvars=_printvars,
product_configuration=_product_configuration,
require_artifacts_in_path=_require_artifacts_in_path,
require_artifacts_in_path_relaxed=_require_artifacts_in_path_relaxed,
setdefault=_setdefault,
shell=rblf_shell,
warning=_mkwarning,
)

42
tests/device.rbc Normal file
View file

@ -0,0 +1,42 @@
# Copyright 2021 Google LLC
#
# 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.
# Top-level test configuration.
# Converted from the following makefile
### PRODUCT_PACKAGES += dev
### PRODUCT_HOST_PACKAGES += host
### $(call inherit-product, $(LOCAL_PATH)/part1.mk)
### PRODUCT_COPY_FILES += device_from:device_to
### include $(LOCAL_PATH)/include1.mk
### PRODUCT_PACKAGES += dev_after
### PRODUCT_COPY_FILES += $(call find-copy-subdir-files,audio_platform_info*.xml,device/google/redfin/audio,$(TARGET_COPY_OUT_VENDOR)/etc) xyz
load("//build/make/core:product_config.rbc", "rblf")
load(":part1.rbc", _part1_init = "init")
load(":include1.rbc", _include1_init = "init")
def init(g, handle):
cfg = rblf.cfg(handle)
rblf.setdefault(handle, "PRODUCT_PACKAGES")
cfg["PRODUCT_PACKAGES"] += ["dev"]
rblf.setdefault(handle, "PRODUCT_HOST_PACKAGES")
cfg["PRODUCT_HOST_PACKAGES"] += ["host"]
rblf.inherit(handle, "test/part1", _part1_init)
rblf.setdefault(handle, "PRODUCT_COPY_FILES")
cfg["PRODUCT_COPY_FILES"] += ["device_from:device_to"]
_include1_init(g, handle)
cfg["PRODUCT_PACKAGES"] += ["dev_after"]
cfg["PRODUCT_COPY_FILES"] += (rblf.find_and_copy("audio_platform_info*.xml", "device/google/redfin/audio", "||VENDOR-PATH-PH||/etc") +
["xyz"])

25
tests/include1.rbc Normal file
View file

@ -0,0 +1,25 @@
# Copyright 2021 Google LLC
#
# 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.
# Included file (not inherited)
# Converted from makefile
### PRODUCT_PACKAGES += inc
load("//build/make/core:product_config.rbc", "rblf")
def init(g, handle):
cfg = rblf.cfg(handle)
rblf.setdefault(handle, "PRODUCT_PACKAGES")
cfg["PRODUCT_PACKAGES"] += ["inc"]

28
tests/part1.rbc Normal file
View file

@ -0,0 +1,28 @@
# Copyright 2021 Google LLC
#
# 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.
# Part configuration
# Converted from
### PRODUCT_COPY_FILES += part_from:part_to
### PRODUCT_PRODUCT_PROPERTIES += part_properties
load("//build/make/core:product_config.rbc", "rblf")
def init(g, handle):
cfg = rblf.cfg(handle)
rblf.setdefault(handle, "PRODUCT_COPY_FILES")
cfg["PRODUCT_COPY_FILES"] += ["part_from:part_to"]
rblf.setdefault(handle, "PRODUCT_PRODUCT_PROPERTIES")
cfg["PRODUCT_PRODUCT_PROPERTIES"] += ["part_properties"]

50
tests/run.rbc Normal file
View file

@ -0,0 +1,50 @@
# Copyright 2021 Google LLC
#
# 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.
# Run test configuration and verify its result.
# The main configuration file is device.rbc.
# It inherits part1.rbc and also includes include1.rbc
# TODO(asmundak): more tests are needed to verify that:
# * multi-level inheritance works as expected
# * all runtime functions (wildcard, regex, etc.) work
load("//build/make/core:product_config.rbc", "rblf")
load(":device.rbc", "init")
def assert_eq(expected, actual):
if expected != actual:
fail("Expected %s, got %s" % (expected, actual))
globals, config = rblf.product_configuration("test/device", init)
assert_eq(
{
"PRODUCT_COPY_FILES": [
"part_from:part_to",
"device_from:device_to",
"device/google/redfin/audio/audio_platform_info_noextcodec_snd.xml:||VENDOR-PATH-PH||/etc/audio_platform_info_noextcodec_snd.xml",
"xyz"
],
"PRODUCT_HOST_PACKAGES": ["host"],
"PRODUCT_PACKAGES": [
"dev",
"inc",
"dev_after"
],
"PRODUCT_PRODUCT_PROPERTIES": ["part_properties"]
},
{ k:v for k, v in sorted(config.items()) }
)