# Copyright 2002. Dave Abrahams

# Copyright 2016. Rene Rivera

# 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)

# This build project manages running the tests for all of Boost.

# The tests to run are discovered from the structure of the libs tree.

#

# Usage:

#

# > cd boost-root/status

# > b2 [--check-libs-only] [--limit-tests=/lib-name-regex../]* [--exclude-tests=/lib-name-regex../]*

#

# --check-libs-only

#   Only runs the library conformance tests.

#

# --no-check-libs

#   Do not run the library conformance tests.

#

# --limit-tests, or --include-tests

#   Only runs the tests for whom the name matches the regex.

#   The value for the argument is a comma separated list of simple

#   regular expressions to check against the names of all the libraries.

#   If any one regex matches the matching library is tested.

#

# --exclude-tests

#   Only runs the tests for whom the names does not match the regex.

#   The argument is the same as for the limit-tests option except

#   that the result is that libraries for whom the name matches

#   are not tested.

#

# The test filters are evaluated in the order given in the command

# and can be used to selectively narrow or widen the set of libraries

# tested.

#

# Examples:

#

# > b2 --check-libs-only --include-tests=predef,config

# 

# Runs the library conformance tests for the predef and config

# libraries only.

#

# > b2 --include-tests=[n-t] --exclude-tests=rat --limit-tests=[v-w]

#

# Runs all the tests for library names that begin with "n" through "t",

# or "v" through "w", but not libraries that start with "rat".

project status

    : source-location $(BOOST_ROOT)

    : requirements <hardcode-dll-paths>true

    ;

import testing ;

import modules ;

import project ;

import regex ;

import modules ;

import path ;

import feature ;

import numbers ;

local check-libs-only = [ MATCH "^--(check-libs-only)" : [ modules.peek : ARGV ] ] ;

local no-check-libs = [ MATCH "^--(no-check-libs)$" : [ modules.peek : ARGV ] ] ;

local check-libs-only-targets = ;

local libraries = ;

local rule run-tests ( root : tests * )

{

    local filter-args = [ MATCH "^--(limit|exclude|include)-tests=(.*)" : [ modules.peek : ARGV ] ] ;

    local filter-tests ;

    while $(filter-args)

    {

        local type = $(filter-args[1]) ;

        for local test in [ regex.split-list $(filter-args[2]) : "[,]" ]

        {

            filter-tests += $(type) $(test) ;

        }

        filter-args = $(filter-args[3-]) ;

    }

    # If any filter is given we make the initial set of tested libraries we:

    # (a) make it empty if the first filter is an include.

    # (b) make it full otherwise.

    local include-default = y ;

    if $(filter-tests[1]) && ( $(filter-tests[1]) in limit include )

    {

        include-default = n ;

    }

    local location = [ project.attribute $(__name__) location ] ;

    # We only run the check library test when host-os == target-os.

    # Hence we need that information.

    local host-os-default = [ feature.defaults <host-os> ] ;

    for local test in $(tests)

    {

        local library = [ path.parent $(test) ] ;

        if $(library) = "."

        {

            library = $(test) ;

        }

        local include-test = $(include-default) ;

        local t = 1 ;

        local f = 2 ;

        while $(filter-tests[$(f)])

        {

            if [ MATCH "^($(filter-tests[$(f)]))" : $(test) ]

            {

                if $(filter-tests[$(t)]) = exclude { include-test = n ; }

                else { include-test = y ; }

            }

            t = [ CALC $(t) + 2 ] ;

            f = [ CALC $(f) + 2 ] ;

        }

        if $(include-test) = y

        {

            if [ path.exists ../$(root)/$(test) ]

            {

                use-project /boost/$(test) : ../$(root)/$(test) ;

            }

            if $(root) = libs && ! $(no-check-libs) && ( ! ( $(library) in $(libraries) ) )

            {

                libraries += $(library) ;

                local test_module = [ project.find ../$(root)/$(test) : $(location) ] ;

                modules.poke $(test_module) : __LIBRARY__ : $(root)/$(library) ;

                modules.poke $(test_module) : __JAMFILE__ : [ modules.peek project : JAMFILE ] ;

                modules.poke $(test_module) : __REQUIRE__ : <target-os>$(host-os-default:G=) ;

                project.push-current [ project.target $(test_module) ] ;

                module $(test_module)

                {

                    import testing ;

                    testing.make-test run-pyd :

                        $(BOOST_ROOT)/status/boost_check_library.py

                        :

                        <pythonpath>$(BOOST_ROOT)/status

                        <testing.arg>--boost-root=\"$(BOOST_ROOT)\"

                        <testing.arg>--library=$(__LIBRARY__)

                        <testing.arg>--jamfile=\"$(__JAMFILE__:J=;)\"

                        <testing.arg>organization

                        $(__REQUIRE__)

                        :

                        __boost_check_library__ ;

                }

                project.pop-current ;

                check-libs-only-targets += ../$(root)/$(test)//__boost_check_library__ ;

            }

            if ! $(check-libs-only)

            {

                build-project ../$(root)/$(test) ;

            }

        }

    }

}

local rule find-targets ( target : libs * )

{

    local result = ;

    for local lib in $(libs)

    {

        local path = ../libs/$(lib)/test ;

        local project = [ project.load $(path) ] ;

        local pt = [ project.target $(project) ] ;

        local mt = [ $(pt).main-target $(target) ] ;

        if $(mt)

        {

            result += $(path)//$(target) ;

        }

    }

    return $(result) ;

}

local libs-to-test = ;

for local libdir in [ path.glob $(BOOST_ROOT) : libs/* ]

{

    local jamfile = [ modules.peek project : JAMFILE ] ;

    local jamfiles = [ path.glob [ path.join $(libdir) test ] : $(jamfile) ] ;

    if $(jamfiles)

    {

        libs-to-test += $(libdir:B) ;

    }

    if [ path.glob $(libdir) : sublibs ]

    {

        jamfiles = [ path.glob $(libdir) : */test/$(jamfile) ] ;

        for local sublib_jamfile in $(jamfiles)

        {

            local sublibdir = [ path.parent [ path.parent $(sublib_jamfile) ] ] ;

            local sublib = $(libdir:B)/$(sublibdir:B) ;

            libs-to-test += $(sublib) ;

        }

    }

}

libs-to-test = [ SORT $(libs-to-test) ] ;

run-tests libs : $(libs-to-test)/test ;

# Tests from Jamfiles in individual library test subdirectories

# Please keep these in alphabetic order by test-suite name

run-tests libs :

    wave/test/build             # test-suite wave

    ;

run-tests tools :

    bcp/test

    ;

if $(check-libs-only-targets)

{

    alias check-libs-only : $(check-libs-only-targets) ;

}

alias minimal : [ find-targets minimal : $(libs-to-test) ] ;

explicit minimal ;

alias quick : [ find-targets quick : $(libs-to-test) ] ;

explicit quick ;