diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
commit | 19fcec84d8d7d21e796c7624e521b60d28ee21ed (patch) | |
tree | 42d26aa27d1e3f7c0b8bd3fd14e7d7082f5008dc /src/boost/tools/build/test/core_dependencies.py | |
parent | Initial commit. (diff) | |
download | ceph-19fcec84d8d7d21e796c7624e521b60d28ee21ed.tar.xz ceph-19fcec84d8d7d21e796c7624e521b60d28ee21ed.zip |
Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/boost/tools/build/test/core_dependencies.py')
-rw-r--r-- | src/boost/tools/build/test/core_dependencies.py | 157 |
1 files changed, 157 insertions, 0 deletions
diff --git a/src/boost/tools/build/test/core_dependencies.py b/src/boost/tools/build/test/core_dependencies.py new file mode 100644 index 000000000..4c60537d9 --- /dev/null +++ b/src/boost/tools/build/test/core_dependencies.py @@ -0,0 +1,157 @@ +#!/usr/bin/python + +# Copyright 2003 Vladimir Prus +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) + +# This tests correct handling of dependencies, specifically, on generated +# sources, and from generated sources. + +import BoostBuild + +import string + +t = BoostBuild.Tester(pass_toolset=0) + +t.write("core-dependency-helpers", """ +rule hdrrule +{ + INCLUDES $(1) : $(2) ; +} +actions copy +{ + cp $(>) $(<) +} +""") + +code = """include core-dependency-helpers ; +DEPENDS all : a ; +DEPENDS a : b ; + +actions create-b +{ + echo '#include <foo.h>' > $(<) +} +copy a : b ; +create-b b ; +HDRRULE on b foo.h bar.h = hdrrule ; +HDRSCAN on b foo.h bar.h = \"#include <(.*)>\" ; +""" + +# This creates 'a' which depends on 'b', which is generated. The generated 'b' +# contains '#include <foo.h>' and no rules for foo.h are given. The system +# should error out on the first invocation. +t.run_build_system("-f-", stdin=code) +t.fail_test(t.stdout().find("...skipped a for lack of foo.h...") == -1) + +t.rm('b') + +# Now test that if target 'c' also depends on 'b', then it will not be built, as +# well. +t.run_build_system("-f-", stdin=code + " copy c : b ; DEPENDS c : b ; DEPENDS all : c ; ") +t.fail_test(t.stdout().find("...skipped c for lack of foo.h...") == -1) + +t.rm('b') + +# Now add a rule for creating foo.h. +code += """ +actions create-foo +{ + echo // > $(<) +} +create-foo foo.h ; +""" +t.run_build_system("-f-", stdin=code) + +# Run two times, adding explicit dependency from all to foo.h at the beginning +# and at the end, to make sure that foo.h is generated before 'a' in all cases. + +def mk_correct_order_func(s1, s2): + def correct_order(s): + n1 = s.find(s1) + n2 = s.find(s2) + return ( n1 != -1 ) and ( n2 != -1 ) and ( n1 < n2 ) + return correct_order + +correct_order = mk_correct_order_func("create-foo", "copy a") + +t.rm(["a", "b", "foo.h"]) +t.run_build_system("-d+2 -f-", stdin=code + " DEPENDS all : foo.h ;") +t.fail_test(not correct_order(t.stdout())) + +t.rm(["a", "b", "foo.h"]) +t.run_build_system("-d+2 -f-", stdin=" DEPENDS all : foo.h ; " + code) +t.fail_test(not correct_order(t.stdout())) + +# Now foo.h exists. Test include from b -> foo.h -> bar.h -> biz.h. b and foo.h +# already have updating actions. +t.rm(["a", "b"]) +t.write("foo.h", "#include <bar.h>") +t.write("bar.h", "#include <biz.h>") +t.run_build_system("-d+2 -f-", stdin=code) +t.fail_test(t.stdout().find("...skipped a for lack of biz.h...") == -1) + +# Add an action for biz.h. +code += """ +actions create-biz +{ + echo // > $(<) +} +create-biz biz.h ; +""" + +t.rm(["b"]) +correct_order = mk_correct_order_func("create-biz", "copy a") +t.run_build_system("-d+2 -f-", stdin=code + " DEPENDS all : biz.h ;") +t.fail_test(not correct_order(t.stdout())) + +t.rm(["a", "biz.h"]) +t.run_build_system("-d+2 -f-", stdin=" DEPENDS all : biz.h ; " + code) +t.fail_test(not correct_order(t.stdout())) + +t.write("a", "") + +code=""" +DEPENDS all : main d ; + +actions copy +{ + cp $(>) $(<) ; +} + +DEPENDS main : a ; +copy main : a ; + +INCLUDES a : <1>c ; + +NOCARE <1>c ; +SEARCH on <1>c = . ; + +actions create-c +{ + echo d > $(<) +} + +actions create-d +{ + echo // > $(<) +} + +create-c <2>c ; +LOCATE on <2>c = . ; +create-d d ; + +HDRSCAN on <1>c = (.*) ; +HDRRULE on <1>c = hdrrule ; + +rule hdrrule +{ + INCLUDES $(1) : d ; +} +""" + +correct_order = mk_correct_order_func("create-d", "copy main") +t.run_build_system("-d2 -f-", stdin=code) +t.fail_test(not correct_order(t.stdout())) + +t.cleanup() |