#!/usr/bin/python # Test the 'symlink' rule from BoostBuild import Tester, List import os t = Tester() if os.name != "posix": print "The symlink tests can be run on posix only" sys.exit(1) t.write("project-root.jam", "import gcc ;") t.write( "Jamfile", """ exe hello : hello.cpp ; symlink hello_release : hello/<variant>release ; symlink hello_debug : hello/<variant>debug ; symlink links/hello_release : hello/<variant>release ; """, ) t.write( "hello.cpp", """ int main() { return 0; } """,
#!/usr/bin/python # Test that default build clause actually has any effect. from BoostBuild import Tester, List t = Tester() t.write("project-root.jam", "import gcc ;") t.write("Jamfile", "exe a : a.cpp : : debug release ;") t.write("a.cpp", "int main() { return 0; }\n") t.run_build_system() t.expect_addition("bin/$toolset/debug/a.exe") t.expect_addition("bin/$toolset/release/a.exe") # Check that explictly-specified build variant supresses # default-build t.rm("bin") t.run_build_system("release") t.expect_addition(List("bin/$toolset/release/") * "a.exe a.obj") t.expect_nothing_more() # Now check that we can specify explicit build request and # default-build will be combined with it t.run_build_system("optimization=space") t.expect_addition("bin/$toolset/debug/optimization-space/a.exe") t.expect_addition("bin/$toolset/release/optimization-space/a.exe") # Test that default-build must be identical in all alternatives. Error case. t.write(
t.write( "Jamroot", """ exe a1 : a1.cpp : <conditional>@a1-rule ; rule a1-rule ( properties * ) { if <variant>debug in $(properties) { return <define>OK ; } } exe a2 : a2.cpp : <conditional>@$(__name__).a2-rule <variant>debug:<optimization>speed ; rule a2-rule ( properties * ) { if <optimization>speed in $(properties) { return <define>OK ; } } exe a3 : a3.cpp : <conditional>@$(__name__).a3-rule-1 <conditional>@$(__name__).a3-rule-2 ; rule a3-rule-1 ( properties * ) { if <optimization>speed in $(properties) { return <define>OK ; } } rule a3-rule-2 ( properties * ) { if <variant>debug in $(properties) { return <optimization>speed ; } } """)
#!/usr/bin/python # This tests a bug where files were places to a directory corresponding to a main # target that was using its main target. from BoostBuild import Tester t = Tester() # In order to correctly link this app, 'b.cpp', created by 'make' # rule, should be compiled. t.write("project-root.jam", "import gcc ;") t.write("Jamfile", """ lib b : b.cpp : <define>BAR ; exe a : a.cpp b ; """) t.write("a.cpp", """ void foo(); int main() { foo(); } """) t.write("b.cpp", "void foo() {}\n") t.run_build_system() t.expect_addition("bin/$toolset/debug/main-target-b/b.o") # This tests another bug: when source file was used by two main targets, # one without any requirements and another with free requirements, it # was compiled twice with to the same locaiton. t.write("Jamfile", """ exe a : a.cpp ; exe b : a.cpp : <define>FOO ;
#!/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) # Test that conditional properties work, even if property is free, and # value includes colon. from BoostBuild import Tester, List t = Tester() # Create the needed files t.write("project-root.jam", "") t.write( "Jamfile", """ exe hello : hello.cpp : <variant>debug:<define>CLASS=Foo::Bar ; """) t.write( "hello.cpp", """ namespace Foo { class Bar { } ; } int main() { CLASS c; return 0; } """) # Don't check stderr, which can include warning about unused 'c'. t.run_build_system(stdout=None, stderr=None)
#!/usr/bin/python # Test the 'make' rule from BoostBuild import Tester from string import find t = Tester(pass_toolset=0) t.write("project-root.jam", "") t.write( "Jamfile", """ rule creator ( string targets * : sources * : * ) { STRING on $(targets) = $(string) ; creator2 $(targets) : $(sources) ; } actions creator2 { echo $(STRING) > $(<) } make foo.bar : : creator foobar ; """) t.run_build_system() t.expect_addition("bin/$toolset/debug/foo.bar") t.fail_test(find(t.read("bin/$toolset/debug/foo.bar"), "foobar") == -1)
#!/usr/bin/python # Copyright 2002 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) # Test that we cannot specify targets of unknown type as sources. # This is based on the fact that Unix 'ar' will happily consume # just about anything. from BoostBuild import Tester t = Tester() t.write("project-root.jam", "import gcc ;") t.write("Jamfile", """ static-lib a : a.foo ; """) t.write("a.foo", "") t.run_build_system(status=1) t.cleanup()
#!/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) # Test that composite properties are handled correctly. from BoostBuild import Tester, List t = Tester() t.write("project-root.jam", "") t.write("Jamfile", """ exe hello : hello.cpp : <variant>release ; """) t.write("hello.cpp", """ int main() { return 0; } """) t.run_build_system() t.expect_addition("bin/$toolset/release/hello.exe") t.cleanup()
# 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 file is template for Boost.Build tests. It creates a simple # project that builds one exe from one source, and checks that the exe # is really created. from BoostBuild import Tester, List t = Tester() t.write("a.cpp", """ #ifdef CF_IS_OFF int main() { return 0; } #endif """) t.write("b.cpp", """ #ifdef CF_1 int main() { return 0; } #endif """) t.write("c.cpp", """ #ifdef FOO int main() { return 0; } #endif
#!/usr/bin/python # Test that default build clause actually has any effect. from BoostBuild import Tester, List t = Tester() t.write("project-root.jam", "import gcc ;") t.write("Jamfile", "exe a : a.cpp : : debug release ;") t.write("a.cpp", "int main() { return 0; }\n") t.run_build_system() t.expect_addition("bin/$toolset/debug/a.exe") t.expect_addition("bin/$toolset/release/a.exe") # Check that explictly-specified build variant supresses # default-build t.rm("bin") t.run_build_system("release") t.expect_addition(List("bin/$toolset/release/") * "a.exe a.obj") t.expect_nothing_more() # Now check that we can specify explicit build request and # default-build will be combined with it t.run_build_system("optimization=space") t.expect_addition("bin/$toolset/debug/optimization-space/a.exe") t.expect_addition("bin/$toolset/release/optimization-space/a.exe") # Test that default-build must be identical in all alternatives. Error case. t.write("Jamfile", """ exe a : a.cpp : : debug ;
#!/usr/bin/python # Test the 'make' rule from BoostBuild import Tester from string import find t = Tester(pass_toolset=1) t.write("project-root.jam", "") t.write("Jamfile", """ rule creator ( string targets * : sources * : * ) { STRING on $(targets) = $(string) ; creator2 $(targets) : $(sources) ; } actions creator2 { echo $(STRING) > $(<) } make foo.bar : : creator foobar ; """) t.run_build_system() t.expect_addition("bin/$toolset/debug/foo.bar") t.fail_test(find(t.read("bin/$toolset/debug/foo.bar"), "foobar") == -1) # Regression test. Make sure that if main target requested two times,
# Copyright (C) Vladimir Prus 2006. # Distributed under the Boost Software License, Version 1.0. (See # accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # Regression test: if a library had no explicit sources, but # only <source> properties, it was built as it it were searched # library, and the specified sources were not compiled. from BoostBuild import Tester, List # Create a temporary working directory t = Tester() # Create the needed files t.write("Jamroot", """ lib a : : <source>a.cpp ; """) t.write("a.cpp", """ #ifdef _WIN32 __declspec(dllexport) #endif void foo() {} """) t.run_build_system() t.expect_addition("bin/$toolset/debug/a.obj") t.rm("bin") # Now try with <conditional>
# Previously, it affected all targets, so # # project : requirements <library>foo ; # exe a : a.cpp helper ; # obj helper : helper.cpp : <optimization>off ; # # caused 'foo' to be built with and without optimization. from BoostBuild import Tester, List # Create a temporary working directory t = Tester() t.write( "Jamfile", """ project : requirements <library>lib//x ; exe a : a.cpp foo ; obj foo : foo.cpp : <variant>release ; """) t.write("a.cpp", """ void aux(); int main() { aux(); } """) t.write("foo.cpp", """ void gee(); void aux() { gee(); } """) t.write("project-root.jam", """
#!/usr/bin/python from BoostBuild import Tester, List import os from string import strip t = Tester() # First check some startup t.set_tree("direct-request-test") t.run_build_system(extra_args="define=MACROS") t.expect_addition("bin/$toolset/debug/" * (List("a.o b.o b.dll a.exe"))) # Regression test: direct build request was not working # when there's more than one level of 'build-project' t.rm(".") t.write('project-root.jam', '') t.write('Jamfile', 'build-project a ;') t.write('a/Jamfile', 'build-project b ;') t.write('a/b/Jamfile', '') t.run_build_system("release") t.cleanup()
#!/usr/bin/python # Copyright (C) Vladimir Prus 2003. Permission to copy, use, modify, sell and # distribute this software is granted provided this copyright notice appears in # all copies. This software is provided "as is" without express or implied # warranty, and with no claim as to its suitability for any purpose. # Test that conditional properties work, even if property is free, and # value includes colon. from BoostBuild import Tester, List t = Tester() # Create the needed files t.write("project-root.jam", "") t.write("Jamfile", """ exe hello : hello.cpp : <variant>debug:<define>CLASS=Foo::Bar ; """) t.write("hello.cpp", """ namespace Foo { class Bar { } ; } int main() { CLASS c; return 0; } """) # Don't check stderr, which can include warning about unused 'c'. t.run_build_system(stdout=None, stderr=None)
<optimization>space <rtti>on <runtime-link>dynamic <toolset>yfc <variant>debug b.cpp """) # Check that we have vanilla target names available in subdirs t.touch("auxillary/b.cpp") t.run_build_system("-sTOOLSET b.obj", subdir="auxillary") t.expect_touch("auxillary/bin/b.obj/yfc/debug/runtime-link-dynamic/optimization-space/b.obj") t.expect_no_modification("bin/a.obj/yfc/debug/runtime-link-dynamic/a.obj") t.expect_no_modification("bin/a/yfc/debug/runtime-link-dynamic/a") # Check that we cannot request link-incompatible property for source target t.write('Jamfile', t.read('Jamfile2')) stdout="""Error: subvariant of target ./a with properties <optimization>off <rtti>on <runtime-link>dynamic <toolset>yfc <variant>debug requests link-incompatible property <rtti>off for source @auxillary/b.obj """ t.run_build_system("-sTOOLSET=yfc", stdout=stdout) # Check that if we request link-compatible property then requirement for # the source target will override it, with warning. This is similar to # the way build requests are satisfied (see the first test) # CONSIDER: should be print the main target which requests this one # (and modifies requiremenets)? t.write('Jamfile3', t.read('Jamfile3'))
# Test that unused sources are at least reported. from BoostBuild import Tester from string import find t = Tester() t.set_tree("unused") t.run_build_system() # The second invocation should do nothing, and produce # no warning. The previous invocation might have printed # executed actions and other things, so it's not easy # to check if warning was issued or not. t.run_build_system() t.fail_test(find(t.stdout(), "warning: Unused source { b.X } in main target ./a") == -1) t.run_build_system("-sGENERATE_ONLY_UNUSABLE=1") t.fail_test(find(t.stdout(), "warning: Unused source { b.X } in main target ./a") == -1) # Now check that even if main target generates nothing, its # usage requirements are still propagated to dependents. t.write("a.cpp",""" #ifdef FOO int main() {} #endif """) t.run_build_system("-sGENERATE_NOTHING=1") t.cleanup()
#!/usr/bin/python from BoostBuild import Tester, List import os from string import strip t = Tester() # First check some startup t.set_tree("direct-request-test") t.run_build_system(extra_args="define=MACROS") t.expect_addition("bin/$toolset/debug/" * (List("a.o b.o b.dll a.exe"))) # Regression test: direct build request was not working # when there's more than one level of 'build-project' t.rm(".") t.write('project-root.jam', '') t.write('Jamfile', 'build-project a ;') t.write('a/Jamfile', 'build-project b ;') t.write('a/b/Jamfile', '') t.run_build_system("release") t.cleanup()
#!/usr/bin/python # Copyright (C) Pedro Ferreira 2003. Permission to copy, use, modify, sell and # distribute this software is granted provided this copyright notice appears in # all copies. This software is provided "as is" without express or implied # warranty, and with no claim as to its suitability for any purpose. from BoostBuild import Tester, List import string t = Tester() t.write("project-root.jam", "") t.write("Jamfile", """ import virtual-target ; rule tag ( name : type ? : property-set ) { local tags ; local v = [ $(property-set).get <variant> ] ; if $(v) = debug { tags += d ; } else if $(v) = release { tags += r ; } local l = [ $(property-set).get <link> ] ; if $(l) = shared {
#!/usr/bin/python # Test usage of searched-libs: one which are found via -l # switch to the linker/compiler. from BoostBuild import Tester, get_toolset import string import os t = Tester() # To start with, we have to prepate a library to link with t.write("lib/project-root.jam", "") t.write("lib/Jamfile", "lib libtest_lib : test_lib.cpp ;") t.write("lib/test_lib.cpp", """ #ifdef _WIN32 __declspec(dllexport) #endif void foo() {} """); t.run_build_system(subdir="lib") t.expect_addition("lib/bin/$toolset/debug/libtest_lib.dll") # Auto adjusting of suffixes does not work, since we need to # change dll to lib. # if (os.name == 'nt' or os.uname()[0].lower().startswith('cygwin')) and get_toolset() != 'gcc': t.copy("lib/bin/$toolset/debug/libtest_lib.lib", "lib/test_lib.lib") else: t.copy("lib/bin/$toolset/debug/libtest_lib.dll", "lib/libtest_lib.dll")
#!/usr/bin/python # Copyright (C) Vladimir Prus 2003. Permission to copy, use, modify, sell and # distribute this software is granted provided this copyright notice appears in # all copies. This software is provided "as is" without express or implied # warranty, and with no claim as to its suitability for any purpose. # Test that V2 does not fail gracelessy when any target is skipped. from BoostBuild import Tester, List # Create a temporary working directory t = Tester() t.write("a.cpp", """ int main() {} """) t.write("b.cpp", """ int main() {} """) t.write("c.cpp", """ int main() {} """) t.write("Jamfile", """ import feature : feature ; feature foo : 1 2 : link-incompatible ; exe a : a.cpp : <foo>1 ; exe b : b.cpp : <foo>2 ;
#!/usr/bin/python # Copyright (C) Vladimir Prus 2003. Permission to copy, use, modify, sell and # distribute this software is granted provided this copyright notice appears in # all copies. This software is provided "as is" without express or implied # warranty, and with no claim as to its suitability for any purpose. # Test that we can access project-root attributes from Jamfiles. from BoostBuild import Tester, List # Create a temporary working directory t = Tester() t.write("Jamfile", """ local l = [ project-root get-location ] ; ECHO XXX $(l) ; """) t.write("project-root.jam", "") t.run_build_system(stdout="XXX .\n") t.cleanup()
#!/usr/bin/python from BoostBuild import Tester, List t = Tester() # Test that top-level project can affect build dir t.write("project-root.jam", "") t.write( "Jamfile", """ exe a : a.cpp ; exe b : b.cpp ; exe c : c.cpp ; alias bin1 : a ; alias bin2 : a b ; alias src : s.cpp ; exe hello : hello.cpp src ; """) t.write("a.cpp", "int main() { return 0; }\n") t.copy("a.cpp", "b.cpp") t.copy("a.cpp", "c.cpp") t.copy("a.cpp", "hello.cpp") t.write("s.cpp", "") # Check that targets to which "bin1" refers are updated, # and only those. t.run_build_system("bin1") t.ignore("*.tds")
# Copyright 2004 Vladimir Prus. # Distributed under the Boost Software License, Version 1.0. (See # accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # Test that we load parent projects before loading children. from BoostBuild import Tester, List from string import find t = Tester() t.write("Jamfile", """ use-project /child : child ; ECHO "Setting parent requirements" ; project : requirements <define>PASS_THE_TEST ; alias x : child//main ; """) t.write("project-root.jam", """ """) t.write("child/Jamfile", """ ECHO "Setting child requirements" ; project /child ; exe main : main.cpp ; """)
#!/usr/bin/python # Test staging from BoostBuild import Tester t = Tester() t.write("project-root.jam", "import gcc ;") t.write("Jamfile", """ lib a : a.cpp ; stage dist : a a.h auxilliary/1 ; """) t.write("a.cpp", "") t.write("a.h", "") t.write("auxilliary/1", "") t.run_build_system() t.expect_addition(["dist/a.dll", "dist/a.h", "dist/1"]) # Test the <location> property t.write( "Jamfile", """ lib a : a.cpp ; stage dist : a : <variant>debug:<location>ds <variant>release:<location>rs ; """) t.run_build_system() t.expect_addition("ds/a.dll")
#!/usr/bin/python # Test that we can change build directory using # the 'build-dir' project attribute. from BoostBuild import Tester t = Tester() # Test that top-level project can affect build dir t.write("project-root.jam", "import gcc ; ") t.write( "Jamfile", """ project : build-dir build ; exe a : a.cpp ; build-project src ; """) t.write("a.cpp", "int main() { return 0; }\n") t.write("src/Jamfile", "exe b : b.cpp ; ") t.write("src/b.cpp", "int main() { return 0; }\n") t.run_build_system() t.expect_addition( ["build/bin/$toolset/debug/a.exe", "build/src/bin/$toolset/debug/b.exe"]) # Test that building from child projects work t.run_build_system(subdir='src')
#!/usr/bin/python # Test usage of searched-libs: one which are found via -l # switch to the linker/compiler. from BoostBuild import Tester import string t = Tester() # To start with, we have to prepate a library to link with t.write("lib/project-root.jam", "import gcc ; ") t.write("lib/Jamfile", "lib test_lib : test_lib.cpp ;") t.write("lib/test_lib.cpp", "void foo() {}\n"); t.run_build_system(subdir="lib") t.expect_addition("lib/bin/$toolset/debug/test_lib.dll") t.copy("lib/bin/$toolset/debug/test_lib.dll", "lib/libtest_lib.dll") # A regression test: <library>property referring to # searched-lib was mishandled. As the result, we were # putting target name to the command line! # Note that # g++ ...... <.>z # works nicely in some cases, sending output from compiler # to file 'z'. # This problem shows up when searched libs are in usage # requirements. t.write('project-root.jam', 'import gcc ;')
#!/usr/bin/python # Copyright 2003, 2004 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) # Test that sources with absolute names are handled OK. from BoostBuild import Tester t = Tester() t.write("project-root.jam", """ path-constant TOP : . ; """) t.write("Jamfile", """ local pwd = [ PWD ] ; ECHO $(pwd) XXXXX ; exe hello : $(pwd)/hello.cpp $(TOP)/empty.cpp ; """) t.write("hello.cpp", "int main() { return 0; }\n") t.write("empty.cpp", "\n") t.run_build_system() t.expect_addition("bin/$toolset/debug/hello.exe") # Test a contrived case. There, absolute name is used in # standalone project (not Jamfile). Moreover, the target with # absolute name is returned by 'alias' and used from other project. t.write("a.cpp", """ int main() {
#!/usr/bin/python # Copyright 2003 Dave Abrahams # Copyright 2002, 2003, 2004, 2005, 2006 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) # Test staging from BoostBuild import Tester t = Tester() t.write("project-root.jam", "import gcc ;") t.write( "Jamfile", """ lib a : a.cpp ; stage dist : a a.h auxilliary/1 ; """) t.write( "a.cpp", """ int #ifdef _WIN32 __declspec(dllexport) #endif must_export_something; """)
# accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # Test that projects with multiple source-location directories are handled OK. from BoostBuild import Tester t = Tester() t.write("Jamroot", """ path-constant SRC1 : "./src1" ; path-constant SRC2 : "./src2" ; path-constant SRC3 : "./src3" ; path-constant BUILD : "build" ; project : requirements <include>$(SRC1)/include <threading>multi : build-dir $(BUILD) ; build-project project1 ; """) t.write("project1/Jamfile", """ project project1 : source-location $(SRC1) $(SRC2) $(SRC3) ; SRCS = s1.cpp
# Copyright (C) Vladimir Prus 2006. # Distributed under the Boost Software License, Version 1.0. (See # accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # Tests for the target id resolution process. from BoostBuild import Tester, List # Create a temporary working directory t = Tester() # Create the needed files t.write("Jamroot", """ exe hello : hello.cpp ; # This should use the 'hello' target, even if there's # 'hello' file in current dir. install s : hello : <location>. ; """) t.write("hello.cpp", """ int main() { return 0; } """) t.run_build_system() t.expect_addition("bin/$toolset/debug/hello.obj") t.touch("hello.cpp") t.run_build_system("s")
# Copyright 2002, 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 that # 1) the 'make' correctly assigns types to produced targets # 2) than if 'make' create targets of type CPP, they are # correctly used (there was a bug with it). from BoostBuild import Tester t = Tester() # In order to correctly link this app, 'b.cpp', created by 'make' # rule, should be compiled. t.write("project-root.jam", "import gcc ;") t.write( "Jamfile", r''' rule create ( dst : src * : properties * ) { # hack to echo a space under NT setup on $(dst) = "set x=int main(){ return 0; }" ; } import modules ; if [ modules.peek : NT ] { actions create { $(setup) echo %x% > $(<)
from BoostBuild import Tester import os, string t = Tester( executable="jam" , workdir = os.getcwd() , pass_toolset=0 ) jamfile=""" actions print_pwd { pwd ; } print_pwd pwd ; Always pwd ; """ t.write("Jamfile", jamfile) t.write("project-root.jam", " ") t.run_build_system(status=0, extra_args = "pwd") if 'TMP' in os.environ: tmp_dir =os.environ.get('TMP') else: tmp_dir ="/tmp" if string.rfind(t.stdout(), tmp_dir) != -1: t.fail_test(1) if string.rfind(t.stdout(), 'build/v2/test') == -1: t.fail_test(1)
#!/usr/bin/python # Test conditional properties from BoostBuild import Tester, List import os from string import strip t = Tester() # Arrange a project which will build only if # 'a.cpp' is compiled with "STATIC" define. t.write("project-root.jam", "import gcc ;") t.write("a.cpp", """ #ifdef STATIC int main() { return 0; } #endif """) t.write("Jamfile", "exe a : a.cpp : <link>static:<define>STATIC ;") t.run_build_system("link=static") t.expect_addition("bin/$toolset/debug/link-static/a.exe") t.write( "Jamfile", """ project : requirements <link>static:<define>STATIC ; exe a : a.cpp ; """) t.rm("bin") t.run_build_system("link=static") t.expect_addition("bin/$toolset/debug/link-static/a.exe")
# Distributed under the Boost Software License, Version 1.0. (See # accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) # Test that it's possible to add a suffix to a main target name to # disambiguate that main target from another, and that this does not # affect the names of the generated targets. from BoostBuild import Tester, List # Create a temporary working directory t = Tester() # Create the needed files t.write("Jamroot", """ exe hello.exe : hello.obj ; obj hello.obj : hello.cpp : <variant>debug ; obj hello.obj2 : hello.cpp : <variant>release ; """) t.write("hello.cpp", """ int main() { return 0; } """) t.run_build_system() t.expect_addition("bin/$toolset/debug/hello.exe") t.expect_addition("bin/$toolset/debug/hello.obj") t.expect_addition("bin/$toolset/release/hello.obj")
# Niklaus Giger, 2005-03-15 # Testing whether we may run a test in a absolute directories # There are no tests for temporary directories as this is implictly tested in a lot of other cases from BoostBuild import Tester import os, string t = Tester(executable="jam", workdir=os.getcwd(), pass_toolset=0) jamfile = """ actions print_pwd { pwd ; } print_pwd pwd ; Always pwd ; """ t.write("Jamfile", jamfile) t.write("project-root.jam", " ") t.run_build_system(status=0, extra_args="pwd") if 'TMP' in os.environ: tmp_dir = os.environ.get('TMP') else: tmp_dir = "/tmp" if string.rfind(t.stdout(), tmp_dir) != -1: t.fail_test(1) if string.rfind(t.stdout(), 'build/v2/test') == -1: t.fail_test(1)
#!/usr/bin/python # Test usage of searched-libs: one which are found via -l # switch to the linker/compiler. from BoostBuild import Tester import string t = Tester() # To start with, we have to prepate a library to link with t.write("lib/project-root.jam", "import gcc ; ") t.write("lib/Jamfile", "lib test_lib : test_lib.cpp ;") t.write("lib/test_lib.cpp", "void foo() {}\n") t.run_build_system(subdir="lib") t.expect_addition("lib/bin/$toolset/debug/test_lib.dll") t.copy("lib/bin/$toolset/debug/test_lib.dll", "lib/libtest_lib.dll") # A regression test: <library>property referring to # searched-lib was mishandled. As the result, we were # putting target name to the command line! # Note that # g++ ...... <.>z # works nicely in some cases, sending output from compiler # to file 'z'. # This problem shows up when searched libs are in usage # requirements. t.write('project-root.jam', 'import gcc ;') t.write('Jamfile', 'exe main : main.cpp d/d2/a ;')
# Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt # or copy at http://www.boost.org/LICENSE_1_0.txt) # Regression test. When Jamfile contained "using whatever ; " and the # 'whatever' module declared a project, then all targets in Jamfile were # considered to be declared in the project associated with 'whatever', # not with the Jamfile. from BoostBuild import Tester, List t = Tester() # Remove temporary directories t.write("a.cpp", """ int main() { return 0; } """) t.write("Jamroot", """ using some_tool ; exe a : a.cpp ; """) t.write( "some_tool.jam", """ import project ; project.initialize $(__name__) ; rule init ( ) { }
# Basic tests for the 'notfile' rule. from BoostBuild import Tester, List import string import os t = Tester() t.write("Jamroot", """ import notfile ; notfile say : "echo hi" ; exe hello : hello.cpp ; notfile hello_valgrind : @valgrind : hello ; actions valgrind { valgrind $(>) } """) t.write("hello.cpp", """ #include <iostream> int main() { std::cout << "Hello!\\n"; return 1;
# Copyright 2002, 2003, 2004 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) # Test that we can specify a dependency property # in project requirements, and that it won't # cause every main target in the project to # be generated in it's own subdirectory. # The whole test is somewhat moot now. from BoostBuild import Tester, List t = Tester() t.write("Jamroot", "build-project src ;") t.write("lib/Jamfile", "lib lib1 : lib1.cpp ;") t.write("lib/lib1.cpp", """ #ifdef _WIN32 __declspec(dllexport) #endif void foo() {}\n """) t.write( "src/Jamfile", """ project : requirements <library>../lib//lib1 ; exe a : a.cpp ; exe b : b.cpp ;
# Copyright 2003 Dave Abrahams # Copyright 2002, 2003, 2005 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) # Test that we can change build directory using # the 'build-dir' project attribute. from BoostBuild import Tester import string import os t = Tester() # Test that top-level project can affect build dir t.write("project-root.jam", "import gcc ; ") t.write( "Jamfile", """ project : build-dir build ; exe a : a.cpp ; build-project src ; """) t.write("a.cpp", "int main() { return 0; }\n") t.write("src/Jamfile", "exe b : b.cpp ; ") t.write("src/b.cpp", "int main() { return 0; }\n") t.run_build_system()
#!/usr/bin/python # Copyright 2003 Dave Abrahams # Copyright 2002, 2006 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) # Test that we can specify sources using relative names. from BoostBuild import Tester t = Tester() t.write("project-root.jam", "import gcc ;") t.write("Jamfile", "exe a : src/a.cpp ;") t.write("src/a.cpp", "int main() { return 0; }\n") t.run_build_system() t.cleanup()
#!/usr/bin/python # Copyright (C) Vladimir Prus 2003. Permission to copy, use, modify, sell and # distribute this software is granted provided this copyright notice appears in # all copies. This software is provided "as is" without express or implied # warranty, and with no claim as to its suitability for any purpose. from BoostBuild import Tester, List import string t = Tester() # Regression test for double loading of the same Jamfile. t.write("Jamfile", """ build-project subdir ; """) t.write("project-root.jam", """ """) t.write("subdir/Jamfile", """ ECHO "Loaded subdir" ; """) t.run_build_system(subdir="subdir") t.fail_test(string.count(t.stdout(), "Loaded subdir") != 1) # Regression test for a more contrived case. The top-level # jamfile refers to subdir via use-project, while subdir's # Jamfile is being loaded. The motivation why use-project # referring to subprojects are usefull can be found at
# Copyright 2003, 2004, 2005, 2006 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) # Test that a chain of libraries work ok, not matter if we use static or # shared linking. from BoostBuild import Tester, List, get_toolset import string import os t = Tester() t.write("Jamfile", """ # Stage the binary, so that it will be relinked # without hardcode-dll-paths. That will chech that # we pass correct -rpath-link, even if not passing # -rpath. stage dist : main ; exe main : main.cpp b ; """) t.write("main.cpp", """ void foo(); int main() { foo(); return 0; } """) t.write("project-root.jam", """ """) t.write("a/a.cpp", """
#!/usr/bin/python # Copyright (C) Vladimir Prus 2003. Permission to copy, use, modify, sell and # distribute this software is granted provided this copyright notice appears in # all copies. This software is provided "as is" without express or implied # warranty, and with no claim as to its suitability for any purpose. # Test that we can access project-root attributes from Jamfiles. from BoostBuild import Tester, List # Create a temporary working directory t = Tester() t.write("Jamfile", """ local l = [ project-root get-location ] ; ECHO XXX $(l) ; """) t.write("project-root.jam", "") t.run_build_system(stdout="XXX .\n") t.cleanup()
#!/usr/bin/python # Test that sources with absolute names are handled OK. from BoostBuild import Tester t = Tester() t.write("project-root.jam", """ path-constant TOP : . ; """) t.write( "Jamfile", """ local pwd = [ PWD ] ; ECHO $(pwd) XXXXX ; exe hello : $(pwd)/hello.cpp $(TOP)/empty.cpp ; """) t.write("hello.cpp", "int main() { return 0; }\n") t.write("empty.cpp", "\n") t.run_build_system() t.expect_addition("bin/$toolset/debug/hello.exe") # Test a contrived case. There, absolute name is used in # standalone project (not Jamfile). Moreover, the target with # absolute name is returned by 'alias' and used from other project. t.write("a.cpp", """ int main() { return 0; }
#!/usr/bin/python # Copyright (C) Vladimir Prus 2003. Permission to copy, use, modify, sell and # distribute this software is granted provided this copyright notice appears in # all copies. This software is provided "as is" without express or implied # warranty, and with no claim as to its suitability for any purpose. from BoostBuild import Tester, List from string import find t = Tester() t.write("project-root.jam", "") t.write("Jamfile", """ lib main : main.cpp l ; lib l : l.cpp main ; """) t.write("main.cpp", "") t.write("l.cpp", "") t.run_build_system("--no-error-backtrace", status=1) t.fail_test(find(t.stdout(), "error: Recursion in main target references") == -1) t.fail_test(find(t.stdout(), "./main ./l ./main") == -1) t.cleanup()
#!/usr/bin/python from BoostBuild import Tester t = Tester() t.write("project-root.jam", "import gcc ;") t.write("Jamfile", "lib a : a.cpp : <include>. ;") t.write("a.cpp", """ #include <a.h> void # ifdef _WIN32 __declspec(dllexport) # endif foo() {} """) t.write("a.h", "//empty file\n") t.write("d/Jamfile", "exe b : b.cpp ..//a ; ") t.write("d/b.cpp", """ void foo(); int main() { foo(); } """) t.run_build_system(subdir="d") # Now test the path features with condition work as well t.write("Jamfile", "lib a : a.cpp : <variant>debug:<include>. ;") t.rm("bin") t.run_build_system(subdir="d") # Test path features with condtion in usage requirements
#!/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) # Test that composite properties are handled correctly. from BoostBuild import Tester, List t = Tester() t.write("project-root.jam", "") t.write("Jamfile", """ exe hello : hello.cpp : <variant>release ; """) t.write("hello.cpp", """ int main() { return 0; } """) t.run_build_system() t.expect_addition("bin/$toolset/release/hello.exe") t.cleanup()
# Copyright 2002, 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 that # 1) the 'make' correctly assigns types to produced targets # 2) than if 'make' create targets of type CPP, they are # correctly used (there was a bug with it). from BoostBuild import Tester t = Tester() # In order to correctly link this app, 'b.cpp', created by 'make' # rule, should be compiled. t.write("project-root.jam", "import gcc ;") t.write( "Jamfile", r""" rule create ( dst : src * : properties * ) { # hack to echo a space under NT setup on $(dst) = "set x=int main(){ return 0; }" ; } import modules ; if [ modules.peek : NT ] { actions create { $(setup)
#!/usr/bin/python # Copyright 2003, 2006 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) from BoostBuild import Tester, List t = Tester() t.write("Jamroot", """ project : requirements <link>static ; exe a : a.cpp [ lib helper : helper.cpp ] ; """) t.write("a.cpp", """ extern void helper(); int main() { return 0; } """) t.write("helper.cpp", """ void helper() { } """) t.run_build_system()
# all copies. This software is provided "as is" without express or implied # warranty, and with no claim as to its suitability for any purpose. # Test that a chain of libraries work ok, not matter if we use static or # shared linking. from BoostBuild import Tester, List, get_toolset import string import os t = Tester() t.write( "Jamfile", """ # Stage the binary, so that it will be relinked # without hardcode-dll-paths. That will chech that # we pass correct -rpath-link, even if not passing # -rpath. stage dist : main ; exe main : main.cpp b ; """) t.write("main.cpp", """ void foo(); int main() { foo(); return 0; } """) t.write("project-root.jam", """ """)