# Boost serialization Library test Jamfile

#  (C) Copyright Robert Ramey 2002-2004.
#  Use, modification, and distribution are subject to 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)
#

project libs/serialization/test ;

# these are used to shorten testing while in development.  It permits
# testing to be applied to just a particular type of archive
if ! $(BOOST_ARCHIVE_LIST) {
    BOOST_ARCHIVE_LIST = 
        "text_archive.hpp" 
        "text_warchive.hpp" 
        "binary_archive.hpp" 
        "xml_archive.hpp" 
        "xml_warchive.hpp" 
    ;
    # enable the tests which don't depend on a particular archive
    BOOST_SERIALIZATION_TEST = true ;
}


rule run-template ( test-name : sources * : requirements * ) {
    return [
        run
            ../../test/build//boost_test_exec_monitor/<link>static
            $(sources)
        : # command
        : # input files
        : # requirements


            # FIXME: Not ported yet.
            #std::locale-support
            #toolset::require-boost-spirit-support
            #toolset::suppress-warnings
            #toolset::optimizations

            $(requirements)
        : # test name
            $(test-name)
        : # default-build
            debug
    ] ;
}

# Given a name of test, return the 'save' test that must be run
# before the named test, or empty string if there's no such test.
rule dependency-save-test ( test )
{
    local m = [ MATCH (.*)load(.*) : $(test) ] ;
    if $(m)
    {
        return $(m[1])save$(m[2]) ;
    }  
}

# each of the following tests is run with each type of archive
rule run-invoke ( test-name : sources * : defns * )
{
#    FIXME
#    if [ in-invocation-subdir ] { Echo $(test-name) ; }

    local save-test = [ dependency-save-test $(test-name) ] ;

    local tests ;
    tests += [ 
        run-template $(test-name)
        : # sources
            $(sources)
            ../build//boost_serialization/<link>static
        : # requirements

            # msvc stlport 4.5.3 only works with static lib
            <toolset>msvc,<stdlib>stlport:<runtime-link>static
            <define>$(defns)
            <define>BOOST_LIB_DIAGNOSTIC=1
            <dependency>$(save-test)
    ] ;
#   FIXME
#    if [ in-invocation-subdir ] { Echo $(test-name)_dll ; }
    tests += [ 
        run-template $(test-name)_dll
        : # sources
            $(sources)
            ../build//boost_serialization
        : # requiremens

        # FIXME:
        #            toolset::require-shared-libraries-support
            <define>$(defns)
            <define>BOOST_LIB_DIAGNOSTIC=1
            <define>BOOST_ALL_DYN_LINK=1
            <runtime-link>shared
            <dependency>$(save-test)_dll
    ] ;
    return $(tests) ;
}

# each of the following tests is run with each type of archive
rule run-winvoke ( test-name : sources * : defns * )
{
# FIXME
#    if [ in-invocation-subdir ] { Echo $(test-name) ; }

    local save-test = [ dependency-save-test $(test-name) ] ;

    local tests ;
    tests += [ 
        run-template $(test-name)
        : # sources
            $(sources)
            ../build//boost_serialization/<link>static
            ../build//boost_wserialization/<link>static
        : # requirements

         # FIXME:
         #   toolset::require-wide-char-io-support
            <define>$(defns)
            <define>BOOST_LIB_DIAGNOSTIC=1
            # msvc stlport 4.5.3 only works with static lib
            <toolset>msvc,<stdlib>stlport:<runtime-link>static
            # both stlport and msvc6 define iswspace
            <toolset>msvc,<stdlib>stlport:<linkflags>"-force:multiple"
            <dependency>$(save-test)
    ] ;
# FIXME
#    if [ in-invocation-subdir ] { Echo $(test-name)_dll ; }
    tests += [ 
        run-template $(test-name)_dll
        : # sources
            $(sources)
            ../build//boost_serialization
            ../build//boost_wserialization
        : # requirements
        # FIXME
        #    toolset::require-wide-char-io-support
        #    toolset::require-shared-libraries-support
            <define>$(defns)
            <define>BOOST_LIB_DIAGNOSTIC=1
            <define>BOOST_ALL_DYN_LINK=1
            <runtime-link>shared
            <dependency>$(save-test)_dll
    ] ;
    return $(tests) ;
}

# for tests which don't use library code - usually just headers
rule test-bsl-run-no-lib  ( test-name : sources * )
{
# FIXME
#    if [ in-invocation-subdir ] { Echo $(test-name) ; }
    local tests ;
    tests += [ 
        run-template $(test-name)
        : # sources
            $(test-name).cpp $(sources).cpp
        : # requirements
          <toolset>msvc,<stdlib>stlport:<runtime-link>static
        
    ] ;
}

rule test-bsl-run ( test-name : sources * )
{
    local tests ;
    tests +=  [ 
        run-invoke $(test-name) 
        : 
            $(test-name).cpp $(sources).cpp
    ] ;
    return $(tests) ;
}

rule test-bsl-run_archive ( test-name : archive-name : sources * ) {
    local tests ;
    switch $(archive-name) {
    case "*_warchive" :
        tests +=  [
            run-winvoke $(test-name)_$(archive-name)
            : 
                $(sources).cpp
            :
                BOOST_ARCHIVE_TEST=$(archive-name).hpp
        ] ;
    case "*" :
        tests +=  [
            run-invoke $(test-name)_$(archive-name)
            : 
                $(sources).cpp
            : 
                BOOST_ARCHIVE_TEST=$(archive-name).hpp
        ] ;
    }
    return $(tests) ;
}

rule test-bsl-run_files ( test-name : sources * ) {
    local tests ;
    for local defn in $(BOOST_ARCHIVE_LIST) {
        tests += [ 
            test-bsl-run_archive $(test-name) 
            : $(defn:LB) 
            : $(test-name) $(sources)
        ] ;
    }
    return $(tests) ;
}
    
rule test-bsl-run_polymorphic_archive ( test-name : sources * ) {
    local tests ;
    for local defn in $(BOOST_ARCHIVE_LIST) {
        tests += [ 
            test-bsl-run_archive test
            : polymorphic_$(defn:LB)  
            : test_polymorphic $(sources)
        ] ;
    }
    return $(tests) ;
}

test-suite "serialization" :
     [ test-bsl-run_files test_array ]
     [ test-bsl-run_files test_binary ]
     [ test-bsl-run_files test_contained_class ]
     [ test-bsl-run_files test_cyclic_ptrs ]
     [ test-bsl-run_files test_delete_pointer ]
     [ test-bsl-run_files test_deque ]
     [ test-bsl-run_files test_derived ]
     [ test-bsl-run_files test_derived_class ]
     [ test-bsl-run_files test_derived_class_ptr ]
     [ test-bsl-run_files test_diamond ]
     [ test-bsl-run_files test_exported ]
     [ test-bsl-run_files test_class_info_load ]
     [ test-bsl-run_files test_class_info_save ]
     [ test-bsl-run_files test_object ]
     [ test-bsl-run_files test_primitive ]
     [ test-bsl-run_files test_list ]
     [ test-bsl-run_files test_list_ptrs ]
     [ test-bsl-run_files test_map ]
     [ test-bsl-run_files test_mi ]
     [ test-bsl-run_files test_multiple_ptrs ]
     [ test-bsl-run_files test_no_rtti ]
     [ test-bsl-run_files test_non_intrusive ]
     [ test-bsl-run_files test_non_default_ctor ]
     [ test-bsl-run_files test_non_default_ctor2 ]
     [ test-bsl-run_files test_null_ptr ]
     [ test-bsl-run_files test_nvp ]
     [ test-bsl-run_files test_recursion ]
     [ test-bsl-run_files test_registered ]
     [ test-bsl-run_files test_set ]
     [ test-bsl-run_files test_simple_class ]
     [ test-bsl-run_files test_simple_class_ptr ]
     [ test-bsl-run_files test_split ]
     [ test-bsl-run_files test_tracking ]
     [ test-bsl-run_files test_unregistered ]
     [ test-bsl-run_files test_variant ]
     [ test-bsl-run_files test_vector ]
     [ test-bsl-run_files test_optional ]
     [ test-bsl-run_files test_shared_ptr ]
     [ test-bsl-run_files test_shared_ptr_132 ]
     [ test-bsl-run_polymorphic_archive test_polymorphic : test_polymorphic_A ]
;

if $(BOOST_SERIALIZATION_TEST) {
    test-suite "serialization2" : 
        [ test-bsl-run-no-lib test_iterators ]
        [ test-bsl-run-no-lib test_iterators_base64 ]
	[ test-bsl-run-no-lib test_inclusion ]
        [ test-bsl-run test_private_ctor ]
        [ test-bsl-run test_reset_object_address ]
        [ test-bsl-run-no-lib test_smart_cast ]
        [ test-bsl-run-no-lib test_static_warning ]
        [ test-bsl-run-no-lib test_utf8_codecvt : ../src/utf8_codecvt_facet ]
        [ test-bsl-run test_void_cast ]
        [ test-bsl-run test_mult_archive_types ]
        [ test-bsl-run-no-lib test_codecvt_null : ../src/codecvt_null ]

        # demos
        [ test-bsl-run test_demo ]
        [ test-bsl-run test_demo_auto_ptr ]
        [ test-bsl-run test_demo_exception ]
        [ test-bsl-run test_demo_fast_archive ]
        [ test-bsl-run test_demo_pimpl : ../example/demo_pimpl_A ]
        [ test-bsl-run test_demo_polymorphic : ../example/demo_polymorphic_A ]
        [ test-bsl-run test_demo_portable_archive ]
        [ test-bsl-run test_demo_shared_ptr ]
        [ test-bsl-run test_demo_xml ]
        [ test-bsl-run test_demo_xml_load ]
        [ test-bsl-run test_demo_xml_save ]

        # should fail compilation
        [ compile-fail test_not_serializable.cpp ] # FIXME std:locale-support ]
        [ compile-fail test_traits_fail.cpp ] # FIXME std:locale-support ]
        [ compile-fail test_const_save_fail1.cpp ] # FIXME std:locale-support ]
        [ compile-fail test_const_save_fail2.cpp ] # FIXME std:locale-support ]
        [ compile-fail test_const_save_fail3.cpp ] # FIXME std:locale-support ]
        # note - library unable to detect there errors for now
        #[ compile-fail test_const_save_fail1_nvp.cpp ]
        #[ compile-fail test_const_save_fail2_nvp.cpp ]
        #[ compile-fail test_const_save_fail3_nvp.cpp ]
        [ compile-fail test_const_load_fail1.cpp ] # FIXME std:locale-support ]
        [ compile-fail test_const_load_fail2.cpp ] # FIXME std:locale-support ]
        [ compile-fail test_const_load_fail3.cpp ] # FIXME std:locale-support ]
        [ compile-fail test_const_load_fail1_nvp.cpp ] # FIXME std:locale-support ]
        [ compile-fail test_const_load_fail2_nvp.cpp ] # FIXME std:locale-support ]
        [ compile-fail test_const_load_fail3_nvp.cpp ] # FIXME std:locale-support ]

        # should compile
        [ compile test_traits_pass.cpp ] # FIXME std:locale-support ]
        [ compile test_const_pass.cpp ] # FIXME std:locale-support ]
    ;
    
}

#saving-tests = [ test-bsl-run_files test_class_info_save ]
#               [ test-bsl-run test_demo_xml_save ] ;
#loading-tests = [ test-bsl-run_files test_class_info_load ]
#                [ test-bsl-run test_demo_xml_load ] ;

# FIXME
## This makes each individual load test depend on the run of the
## corresponding save test. It is important to do this one at a
## time because $(saving-tests) and $(loading-tests) can contain
## the targets for multiple toolsets.



#for local save-test-i in $(saving-tests)
#{
#    DEPENDS $(loading-tests[1]:S=.run) : $(save-test-i:S=.run) ;
#    loading-tests = $(loading-tests[2-]) ;
#}