libt2n: (gerd) command handling, unit-test still bailing out

diff --git a/acinclude.m4 b/acinclude.m4
new file mode 100644 (file)
index 0000000..863245a
--- /dev/null
+++ b/acinclude.m4
@@ -0,0 +1,488 @@
+dnl @synopsis AX_BOOST([MINIMUM-VERSION], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+dnl
+dnl Test for the Boost C++ libraries of a particular version (or newer)
+dnl
+dnl If no path to the installed boost library is given the macro
+dnl searchs under /usr, /usr/local, and /opt, and evaluates the
+dnl $BOOST_ROOT environment variable. Further documentation is
+dnl available at <http://randspringer.de/boost/index.html>.
+dnl
+dnl This macro calls:
+dnl
+dnl   AC_SUBST(BOOST_CPPFLAGS) / AC_SUBST(BOOST_LDFLAGS)
+dnl   AC_SUBST(BOOST_FILESYSTEM_LIB)
+dnl   AC_SUBST(BOOST_PROGRAM_OPTIONS_LIB)
+dnl   AC_SUBST(BOOST_THREAD_LIB)
+dnl   AC_SUBST(BOOST_IOSTREAMS_LIB)
+dnl   AC_SUBST(BOOST_SERIALIZATION_LIB)
+dnl   AC_SUBST(BOOST_WSERIALIZATION_LIB)
+dnl   AC_SUBST(BOOST_SIGNALS_LIB)
+dnl   AC_SUBST(BOOST_DATE_TIME_LIB)
+dnl   AC_SUBST(BOOST_REGEX_LIB)
+dnl   AC_SUBST(BOOST_UNIT_TEST_FRAMEWORK_LIB)
+dnl
+dnl And sets:
+dnl
+dnl   HAVE_BOOST
+dnl   HAVE_BOOST_FILESYSTEM
+dnl   HAVE_BOOST_PROGRAM_OPTIONS
+dnl   HAVE_BOOST_THREAD
+dnl   HAVE_BOOST_IOSTREAMS
+dnl   HAVE_BOOST_SERIALIZATION
+dnl   HAVE_BOOST_SIGNALS
+dnl   HAVE_BOOST_DATE_TIME
+dnl   HAVE_BOOST_REGEX
+dnl   HAVE_BOOST_UNIT_TEST_FRAMEWORK
+dnl
+dnl @category InstalledPackages
+dnl @category Cxx
+dnl @author Thomas Porschberg <thomas@randspringer.de>
+dnl @version 2006-06-15
+dnl @license AllPermissive
+
+AC_DEFUN([AX_BOOST],
+[
+    AC_ARG_WITH([boost],,
+                [
+                if test "$withval" = "no"; then
+                           want_boost="no"
+                elif test "$withval" = "yes"; then
+                    want_boost="yes"
+                    ac_boost_path=""
+                else
+                               want_boost="yes"
+                       ac_boost_path="$withval"
+                       fi
+               ],
+                [want_boost="yes"])
+
+    AC_CANONICAL_BUILD
+       if test "x$want_boost" = "xyes"; then
+        AC_REQUIRE([AC_PROG_CC])
+               boost_lib_version_req=ifelse([$1], ,1.20.0,$1)
+               boost_lib_version_req_shorten=`expr $boost_lib_version_req : '\([[0-9]]*\.[[0-9]]*\)'`
+               boost_lib_version_req_major=`expr $boost_lib_version_req : '\([[0-9]]*\)'`
+               boost_lib_version_req_minor=`expr $boost_lib_version_req : '[[0-9]]*\.\([[0-9]]*\)'`
+               boost_lib_version_req_sub_minor=`expr $boost_lib_version_req : '[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)'`
+               if test "x$boost_lib_version_req_sub_minor" = "x" ; then
+                       boost_lib_version_req_sub_minor="0"
+       fi
+               WANT_BOOST_VERSION=`expr $boost_lib_version_req_major \* 100000 \+  $boost_lib_version_req_minor \* 100 \+ $boost_lib_version_req_sub_minor`
+               AC_MSG_CHECKING(for boostlib >= $boost_lib_version_req)
+               succeeded=no
+
+               dnl first we check the system location for boost libraries
+               dnl this location ist chosen if boost libraries are installed with the --layout=system option
+               dnl or if you install boost with RPM
+               if test "$ac_boost_path" != ""; then
+                       BOOST_LDFLAGS="-L$ac_boost_path/lib"
+                       BOOST_CPPFLAGS="-I$ac_boost_path/include"
+               else
+                       for ac_boost_path_tmp in /usr /usr/local /opt ; do
+                               if test -d "$ac_boost_path_tmp/include/boost" && test -r "$ac_boost_path_tmp/include/boost"; then
+                                       BOOST_LDFLAGS="-L$ac_boost_path_tmp/lib"
+                                       BOOST_CPPFLAGS="-I$ac_boost_path_tmp/include"
+                                       break;
+                               fi
+                       done
+               fi
+
+               CPPFLAGS_SAVED="$CPPFLAGS"
+               CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
+               export CPPFLAGS
+
+               LDFLAGS_SAVED="$LDFLAGS"
+               LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
+               export LDFLAGS
+
+       AC_LANG_PUSH(C++)
+       AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+@%:@include <boost/version.hpp>
+]],
+       [[
+#if BOOST_VERSION >= $WANT_BOOST_VERSION
+// Everything is okay
+#else
+#  error Boost version is too old
+#endif
+
+               ]])],
+       [
+         AC_MSG_RESULT(yes)
+                succeeded=yes
+                found_system=yes
+         ifelse([$2], , :, [$2])
+       ],
+       [
+       ])
+       AC_LANG_POP([C++])
+               dnl if we found no boost with system layout we search for boost libraries
+               dnl built and installed without the --layout=system option or for a staged(not installed) version
+               if test "x$succeeded" != "xyes"; then
+                       _version=0
+                       if test "$ac_boost_path" != ""; then
+                BOOST_LDFLAGS="-L$ac_boost_path/lib"
+                               if test -d "$ac_boost_path" && test -r "$ac_boost_path"; then
+                                       for i in `ls -d $ac_boost_path/include/boost-* 2>/dev/null`; do
+                                               _version_tmp=`echo $i | sed "s#$ac_boost_path##" | sed 's/\/include\/boost-//' | sed 's/_/./'`
+                                               V_CHECK=`expr $_version_tmp \> $_version`
+                                               if test "$V_CHECK" = "1" ; then
+                                                       _version=$_version_tmp
+                                               fi
+                                               VERSION_UNDERSCORE=`echo $_version | sed 's/\./_/'`
+                                               BOOST_CPPFLAGS="-I$ac_boost_path/include/boost-$VERSION_UNDERSCORE"
+                                       done
+                               fi
+                       else
+                               for ac_boost_path in /usr /usr/local /opt ; do
+                                       if test -d "$ac_boost_path" && test -r "$ac_boost_path"; then
+                                               for i in `ls -d $ac_boost_path/include/boost-* 2>/dev/null`; do
+                                                       _version_tmp=`echo $i | sed "s#$ac_boost_path##" | sed 's/\/include\/boost-//' | sed 's/_/./'`
+                                                       V_CHECK=`expr $_version_tmp \> $_version`
+                                                       if test "$V_CHECK" = "1" ; then
+                                                               _version=$_version_tmp
+                                                               best_path=$ac_boost_path
+                                                       fi
+                                               done
+                                       fi
+                               done
+
+                               VERSION_UNDERSCORE=`echo $_version | sed 's/\./_/'`
+                               BOOST_CPPFLAGS="-I$best_path/include/boost-$VERSION_UNDERSCORE"
+                               BOOST_LDFLAGS="-L$best_path/lib"
+
+                       if test "x$BOOST_ROOT" != "x"; then
+                    if test -d "$BOOST_ROOT" && test -r "$BOOST_ROOT" && test -d "$BOOST_ROOT/stage/lib" && test -r "$BOOST_ROOT/stage/lib"; then
+                                               version_dir=`expr //$BOOST_ROOT : '.*/\(.*\)'`
+                                               stage_version=`echo $version_dir | sed 's/boost_//' | sed 's/_/./g'`
+                                               stage_version_shorten=`expr $stage_version : '\([[0-9]]*\.[[0-9]]*\)'`
+                                               V_CHECK=`expr $stage_version_shorten \>\= $_version`
+                                               if test "$V_CHECK" = "1" ; then
+                                                       AC_MSG_NOTICE(We will use a staged boost library from $BOOST_ROOT)
+                                                       BOOST_CPPFLAGS="-I$BOOST_ROOT"
+                                                       BOOST_LDFLAGS="-L$BOOST_ROOT/stage/lib"
+                                               fi
+                                       fi
+                       fi
+                       fi
+
+                       CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
+                       export CPPFLAGS
+                       LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
+                       export LDFLAGS
+
+            AC_LANG_PUSH(C++)
+            AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+@%:@include <boost/version.hpp>
+]],
+       [[
+#if BOOST_VERSION >= $WANT_BOOST_VERSION
+// Everything is okay
+#else
+#  error Boost version is too old
+#endif
+
+               ]])],
+       [
+         AC_MSG_RESULT(yes ($_version))
+                succeeded=yes
+         ifelse([$2], , :, [$2])
+       ],
+       [
+         AC_MSG_RESULT(no ($_version))
+         ifelse([$3], , :, [$3])
+       ])
+       AC_LANG_POP([C++])
+               fi
+
+               if test "$succeeded" != "yes" ; then
+                       if test "$_version" = "0" ; then
+                               AC_MSG_ERROR([[We could not detect the boost libraries (version $boost_lib_version_req_shorten or higher). If you have a staged boost library (still not installed) please specify \$BOOST_ROOT in your environment and do not give a PATH to --with-boost option.  If you are sure you have boost installed, then check your version number looking in <boost/version.hpp>. See http://randspringer.de/boost for more documentation.]])
+                       else
+                               AC_MSG_ERROR('Your boost libraries seems to old (version $_version).  We need at least $boost_lib_version_shorten')
+                       fi
+               else
+                       AC_SUBST(BOOST_CPPFLAGS)
+                       AC_SUBST(BOOST_LDFLAGS)
+                       AC_DEFINE(HAVE_BOOST,,[define if the Boost library is available])
+
+                       AC_CACHE_CHECK([whether the Boost::Filesystem library is available],
+                                                  ax_cv_boost_filesystem,
+                                               [AC_LANG_PUSH([C++])
+                        AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[@%:@include <boost/filesystem/path.hpp>]],
+                                   [[using namespace boost::filesystem;
+                                   path my_path( "foo/bar/data.txt" );
+                                   return 0;]]),
+                                              ax_cv_boost_filesystem=yes, ax_cv_boost_filesystem=no)
+                                   AC_LANG_POP([C++])
+                       ])
+                       if test "$ax_cv_boost_filesystem" = "yes"; then
+                               AC_DEFINE(HAVE_BOOST_FILESYSTEM,,[define if the Boost::FILESYSTEM library is available])
+                               BN=boost_filesystem
+                               for ax_lib in $BN $BN-$CC $BN-$CC-mt $BN-$CC-mt-s $BN-$CC-s \
+                              lib$BN lib$BN-$CC lib$BN-$CC-mt lib$BN-$CC-mt-s lib$BN-$CC-s \
+                              $BN-mgw $BN-mgw $BN-mgw-mt $BN-mgw-mt-s $BN-mgw-s ; do
+                                   AC_CHECK_LIB($ax_lib, main,
+                                 [BOOST_FILESYSTEM_LIB="-l$ax_lib" AC_SUBST(BOOST_FILESYSTEM_LIB) link_filesystem="yes" break],
+                                 [link_filesystem="no"])
+                               done
+                               if test "x$link_filesystem" = "xno"; then
+                                       AC_MSG_NOTICE(Could not link against $ax_lib !)
+                               fi
+                       fi
+
+                       AC_CACHE_CHECK([whether the Boost::Program_Options library is available],
+                                                  ax_cv_boost_program_options,
+                                                  [AC_LANG_PUSH([C++])
+                                      AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[@%:@include <boost/program_options.hpp>]],
+                                   [[boost::program_options::options_description generic("Generic options");
+                                   return 0;]]),
+                           ax_cv_boost_program_options=yes, ax_cv_boost_program_options=no)
+                           AC_LANG_POP([C++])
+                       ])
+                       if test "$ax_cv_boost_program_options" = yes; then
+                               AC_DEFINE(HAVE_BOOST_PROGRAM_OPTIONS,,[define if the Boost::PROGRAM_OPTIONS library is available])
+                               BN=boost_program_options
+                               for ax_lib in $BN $BN-$CC $BN-$CC-mt $BN-$CC-mt-s $BN-$CC-s \
+                              lib$BN lib$BN-$CC lib$BN-$CC-mt lib$BN-$CC-mt-s lib$BN-$CC-s \
+                              $BN-mgw $BN-mgw $BN-mgw-mt $BN-mgw-mt-s $BN-mgw-s ; do
+                                   AC_CHECK_LIB($ax_lib, main,
+                                 [BOOST_PROGRAM_OPTIONS_LIB="-l$ax_lib" AC_SUBST(BOOST_PROGRAM_OPTIONS_LIB) link_program_options="yes" break],
+                                 [link_program_options="no"])
+                               done
+                               if test "x$link_program_options="no"" = "xno"; then
+                                       AC_MSG_NOTICE(Could not link against $ax_lib !)
+                               fi
+                       fi
+
+                       AC_CACHE_CHECK(whether the Boost::Thread library is available,
+                                                  ax_cv_boost_thread,
+                                               [AC_LANG_PUSH([C++])
+                        CXXFLAGS_SAVE=$CXXFLAGS
+
+                        if test "x$build_os" = "xsolaris" ; then
+                                CXXFLAGS="-pthreads $CXXFLAGS"
+                        elif test "x$build_os" = "xming32" ; then
+                                CXXFLAGS="-mthreads $CXXFLAGS"
+                        else
+                               CXXFLAGS="-pthread $CXXFLAGS"
+                        fi
+                        AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[@%:@include <boost/thread/thread.hpp>]],
+                                   [[boost::thread_group thrds;
+                                   return 0;]]),
+                   ax_cv_boost_thread=yes, ax_cv_boost_thread=no)
+                        CXXFLAGS=$CXXFLAGS_SAVE
+             AC_LANG_POP([C++])
+                       ])
+                       if test "x$ax_cv_boost_thread" = "xyes"; then
+               if test "x$build_os" = "xsolaris" ; then
+                                 BOOST_CPPFLAGS="-pthreads $BOOST_CPPFLAGS"
+                          elif test "x$build_os" = "xming32" ; then
+                                 BOOST_CPPFLAGS="-mthreads $BOOST_CPPFLAGS"
+                          else
+                                 BOOST_CPPFLAGS="-pthread $BOOST_CPPFLAGS"
+                          fi
+
+                               AC_SUBST(BOOST_CPPFLAGS)
+                               AC_DEFINE(HAVE_BOOST_THREAD,,[define if the Boost::THREAD library is available])
+                               BN=boost_thread
+                               for ax_lib in $BN $BN-$CC $BN-$CC-mt $BN-$CC-mt-s $BN-$CC-s \
+                              lib$BN lib$BN-$CC lib$BN-$CC-mt lib$BN-$CC-mt-s lib$BN-$CC-s \
+                              $BN-mgw $BN-mgw $BN-mgw-mt $BN-mgw-mt-s $BN-mgw-s ; do
+                                   AC_CHECK_LIB($ax_lib, main, [BOOST_THREAD_LIB="-l$ax_lib" AC_SUBST(BOOST_THREAD_LIB) link_thread="yes" break],
+                                 [link_thread="no"])
+                               done
+                               if test "x$link_thread" = "xno"; then
+                                       AC_MSG_NOTICE(Could not link against $ax_lib !)
+                               fi
+                       fi
+
+                       AC_CACHE_CHECK(whether the Boost::IOStreams library is available,
+                                                  ax_cv_boost_iostreams,
+                                               [AC_LANG_PUSH([C++])
+                        AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[@%:@include <boost/iostreams/filtering_stream.hpp>
+                                                                                                @%:@include <boost/range/iterator_range.hpp>
+                                                                                               ]],
+                                   [[std::string  input = "Hello World!";
+                                                                        namespace io = boost::iostreams;
+                                                                        io::filtering_istream  in(boost::make_iterator_range(input));
+                                                                        return 0;
+                                   ]]),
+                   ax_cv_boost_iostreams=yes, ax_cv_boost_iostreams=no)
+                        AC_LANG_POP([C++])
+                       ])
+                       if test "x$ax_cv_boost_iostreams" = "xyes"; then
+                               AC_DEFINE(HAVE_BOOST_IOSTREAMS,,[define if the Boost::IOStreams library is available])
+                               BN=boost_iostreams
+                               for ax_lib in $BN $BN-$CC $BN-$CC-mt $BN-$CC-mt-s $BN-$CC-s \
+                              lib$BN lib$BN-$CC lib$BN-$CC-mt lib$BN-$CC-mt-s lib$BN-$CC-s \
+                              $BN-mgw $BN-mgw $BN-mgw-mt $BN-mgw-mt-s $BN-mgw-s ; do
+                                   AC_CHECK_LIB($ax_lib, main, [BOOST_IOSTREAMS_LIB="-l$ax_lib" AC_SUBST(BOOST_IOSTREAMS_LIB) link_thread="yes" break],
+                                 [link_thread="no"])
+                               done
+                               if test "x$link_thread" = "xno"; then
+                                       AC_MSG_NOTICE(Could not link against $ax_lib !)
+                               fi
+                       fi
+
+                       AC_CACHE_CHECK(whether the Boost::Serialization library is available,
+                                                  ax_cv_boost_serialization,
+                                               [AC_LANG_PUSH([C++])
+                        AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[@%:@include <fstream>
+                                                                                                @%:@include <boost/archive/text_oarchive.hpp>
+                                                 @%:@include <boost/archive/text_iarchive.hpp>
+                                                                                               ]],
+                                   [[std::ofstream ofs("filename");
+                                                                       boost::archive::text_oarchive oa(ofs);
+                                                                        return 0;
+                                   ]]),
+                   ax_cv_boost_serialization=yes, ax_cv_boost_serialization=no)
+                        AC_LANG_POP([C++])
+                       ])
+                       if test "x$ax_cv_boost_serialization" = "xyes"; then
+                               AC_DEFINE(HAVE_BOOST_SERIALIZATION,,[define if the Boost::Serialization library is available])
+                               BN=boost_serialization
+                               for ax_lib in $BN $BN-$CC $BN-$CC-mt $BN-$CC-mt-s $BN-$CC-s \
+                              lib$BN lib$BN-$CC lib$BN-$CC-mt lib$BN-$CC-mt-s lib$BN-$CC-s \
+                              $BN-mgw $BN-mgw $BN-mgw-mt $BN-mgw-mt-s $BN-mgw-s ; do
+                                   AC_CHECK_LIB($ax_lib, main,
+                                 [BOOST_SERIALIZATION_LIB="-l$ax_lib" AC_SUBST(BOOST_SERIALIZATION_LIB) link_serialization="yes" break],
+                                 [link_serialization="no"])
+                               done
+                               if test "x$link_serialization" = "xno"; then
+                                       AC_MSG_NOTICE(Could not link against $ax_lib !)
+                               fi
+
+                               BN=boost_wserialization
+                               for ax_lib in $BN $BN-$CC $BN-$CC-mt $BN-$CC-mt-s $BN-$CC-s \
+                              lib$BN lib$BN-$CC lib$BN-$CC-mt lib$BN-$CC-mt-s lib$BN-$CC-s \
+                              $BN-mgw $BN-mgw $BN-mgw-mt $BN-mgw-mt-s $BN-mgw-s ; do
+                                   AC_CHECK_LIB($ax_lib, main,
+                                 [BOOST_WSERIALIZATION_LIB="-l$ax_lib" AC_SUBST(BOOST_WSERIALIZATION_LIB) link_wserialization="yes" break],
+                                 [link_wserialization="no"])
+                               done
+                               if test "x$link_wserialization" = "xno"; then
+                                       AC_MSG_NOTICE(Could not link against $ax_lib !)
+                               fi
+                       fi
+
+                       AC_CACHE_CHECK(whether the Boost::Signals library is available,
+                                                  ax_cv_boost_signals,
+                                               [AC_LANG_PUSH([C++])
+                        AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[@%:@include <boost/signal.hpp>
+                                                                                               ]],
+                                   [[boost::signal<void ()> sig;
+                                     return 0;
+                                   ]]),
+                   ax_cv_boost_signals=yes, ax_cv_boost_signals=no)
+                        AC_LANG_POP([C++])
+                       ])
+                       if test "x$ax_cv_boost_signals" = "xyes"; then
+                               AC_DEFINE(HAVE_BOOST_SIGNALS,,[define if the Boost::Signals library is available])
+                               BN=boost_signals
+                               for ax_lib in $BN $BN-$CC $BN-$CC-mt $BN-$CC-mt-s $BN-$CC-s \
+                              lib$BN lib$BN-$CC lib$BN-$CC-mt lib$BN-$CC-mt-s lib$BN-$CC-s \
+                              $BN-mgw $BN-mgw $BN-mgw-mt $BN-mgw-mt-s $BN-mgw-s ; do
+                                   AC_CHECK_LIB($ax_lib, main, [BOOST_SIGNALS_LIB="-l$ax_lib" AC_SUBST(BOOST_SIGNALS_LIB) link_signals="yes" break],
+                                 [link_signals="no"])
+                               done
+                               if test "x$link_signals" = "xno"; then
+                                       AC_MSG_NOTICE(Could not link against $ax_lib !)
+                               fi
+                       fi
+
+                       AC_CACHE_CHECK(whether the Boost::Date_Time library is available,
+                                                  ax_cv_boost_date_time,
+                                               [AC_LANG_PUSH([C++])
+                        AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[@%:@include <boost/date_time/gregorian/gregorian_types.hpp>
+                                                                                               ]],
+                                   [[using namespace boost::gregorian; date d(2002,Jan,10);
+                                     return 0;
+                                   ]]),
+                   ax_cv_boost_date_time=yes, ax_cv_boost_date_time=no)
+                        AC_LANG_POP([C++])
+                       ])
+                       if test "x$ax_cv_boost_date_time" = "xyes"; then
+                               AC_DEFINE(HAVE_BOOST_DATE_TIME,,[define if the Boost::Date_Time library is available])
+                               BN=boost_date_time
+                               for ax_lib in $BN $BN-$CC $BN-$CC-mt $BN-$CC-mt-s $BN-$CC-s \
+                              lib$BN lib$BN-$CC lib$BN-$CC-mt lib$BN-$CC-mt-s lib$BN-$CC-s \
+                              $BN-mgw $BN-mgw $BN-mgw-mt $BN-mgw-mt-s $BN-mgw-s ; do
+                                   AC_CHECK_LIB($ax_lib, main, [BOOST_DATE_TIME_LIB="-l$ax_lib" AC_SUBST(BOOST_DATE_TIME_LIB) link_thread="yes" break],
+                                 [link_thread="no"])
+                               done
+                               if test "x$link_thread"="no" = "xno"; then
+                                       AC_MSG_NOTICE(Could not link against $ax_lib !)
+                               fi
+                       fi
+
+                       AC_CACHE_CHECK(whether the Boost::Regex library is available,
+                                                  ax_cv_boost_regex,
+                                               [AC_LANG_PUSH([C++])
+                        AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[@%:@include <boost/regex.hpp>
+                                                                                               ]],
+                                   [[boost::regex r(); return 0;]]),
+                   ax_cv_boost_regex=yes, ax_cv_boost_regex=no)
+                        AC_LANG_POP([C++])
+                       ])
+                       if test "x$ax_cv_boost_regex" = "xyes"; then
+                               AC_DEFINE(HAVE_BOOST_REGEX,,[define if the Boost::Regex library is available])
+                               BN=boost_regex
+                               for ax_lib in $BN $BN-$CC $BN-$CC-mt $BN-$CC-mt-s $BN-$CC-s \
+                              lib$BN lib$BN-$CC lib$BN-$CC-mt lib$BN-$CC-mt-s lib$BN-$CC-s \
+                              $BN-mgw $BN-mgw $BN-mgw-mt $BN-mgw-mt-s $BN-mgw-s ; do
+                                   AC_CHECK_LIB($ax_lib, main, [BOOST_REGEX_LIB="-l$ax_lib" AC_SUBST(BOOST_REGEX_LIB) link_regex="yes" break],
+                                 [link_regex="no"])
+                               done
+                               if test "x$link_regex" = "xno"; then
+                                       AC_MSG_NOTICE(Could not link against $ax_lib !)
+                               fi
+                       fi
+
+                       AC_CACHE_CHECK(whether the Boost::UnitTestFramework library is available,
+                                                  ax_cv_boost_unit_test_framework,
+                                               [AC_LANG_PUSH([C++])
+                        AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[@%:@include <boost/test/unit_test.hpp>]],
+                                    [[using boost::unit_test::test_suite;
+                                                        test_suite* test= BOOST_TEST_SUITE( "Unit test example 1" ); return 0;]]),
+                   ax_cv_boost_unit_test_framework=yes, ax_cv_boost_unit_test_framework=no)
+                        AC_LANG_POP([C++])
+                       ])
+                       if test "x$ax_cv_boost_unit_test_framework" = "xyes"; then
+               AC_DEFINE(HAVE_BOOST_UNIT_TEST_FRAMEWORK,,[define if the Boost::Unit_test_framework library is available])
+                       BN=boost_unit_test_framework
+               saved_ldflags="${LDFLAGS}"
+                       for ax_lib in $BN $BN-$CC $BN-$CC-mt $BN-$CC-mt-s $BN-$CC-s \
+                          lib$BN lib$BN-$CC lib$BN-$CC-mt lib$BN-$CC-mt-s lib$BN-$CC-s \
+                          $BN-mgw $BN-mgw $BN-mgw-mt $BN-mgw-mt-s $BN-mgw-s ; do
+                LDFLAGS="${LDFLAGS} -l$ax_lib"
+                       AC_CACHE_CHECK(the name of the Boost::UnitTestFramework library,
+                                                  ax_cv_boost_unit_test_framework_link,
+                                               [AC_LANG_PUSH([C++])
+                   AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@include <boost/test/unit_test.hpp>
+                                                     using boost::unit_test::test_suite;
+                                                     test_suite* init_unit_test_suite( int argc, char * argv[] ) {
+                                                     test_suite* test= BOOST_TEST_SUITE( "Unit test example 1" );
+                                                     return test;
+                                                     }
+                                                   ]],
+                                 [[ return 0;]])],
+                                 link_unit_test_framework="yes",link_unit_test_framework="no")
+                        AC_LANG_POP([C++])
+               ])
+                LDFLAGS="${saved_ldflags}"
+                           if test "x$link_unit_test_framework" = "xyes"; then
+                    BOOST_UNIT_TEST_FRAMEWORK_LIB="-l$ax_lib"
+                    AC_SUBST(BOOST_UNIT_TEST_FRAMEWORK_LIB)
+                                       break
+                               fi
+              done
+                           if test "x$link_unit_test_framework" = "xno"; then
+                                  AC_MSG_NOTICE(Could not link against $ax_lib !)
+                               fi
+                       fi
+               fi
+        CPPFLAGS="$CPPFLAGS_SAVED"
+        LDFLAGS="$LDFLAGS_SAVED"
+       fi
+])

diff --git a/config.h.in b/config.h.in
index bdf21b4..e427590 100644 (file)
--- a/config.h.in
+++ b/config.h.in
@@ -1,5 +1,35 @@
 /* config.h.in.  Generated automatically from configure.in by autoheader.  */
 
+/* define if the Boost library is available */
+#undef HAVE_BOOST
+
+/* define if the Boost::Date_Time library is available */
+#undef HAVE_BOOST_DATE_TIME
+
+/* define if the Boost::FILESYSTEM library is available */
+#undef HAVE_BOOST_FILESYSTEM
+
+/* define if the Boost::IOStreams library is available */
+#undef HAVE_BOOST_IOSTREAMS
+
+/* define if the Boost::PROGRAM_OPTIONS library is available */
+#undef HAVE_BOOST_PROGRAM_OPTIONS
+
+/* define if the Boost::Regex library is available */
+#undef HAVE_BOOST_REGEX
+
+/* define if the Boost::Serialization library is available */
+#undef HAVE_BOOST_SERIALIZATION
+
+/* define if the Boost::Signals library is available */
+#undef HAVE_BOOST_SIGNALS
+
+/* define if the Boost::THREAD library is available */
+#undef HAVE_BOOST_THREAD
+
+/* define if the Boost::Unit_test_framework library is available */
+#undef HAVE_BOOST_UNIT_TEST_FRAMEWORK
+
 /* Define if you have the <dlfcn.h> header file. */
 #undef HAVE_DLFCN_H
 

diff --git a/configure.in b/configure.in
index b7d9353..6e8b944 100644 (file)
--- a/configure.in
+++ b/configure.in
@@ -14,4 +14,10 @@ AM_CONDITIONAL(HAVE_DOXYGEN, test -n $DOXYGEN);
 AM_CONDITIONAL(AUTOCHECK, test "$enable_autocheck" = yes)
 AM_PATH_CPPUNIT(1.8.0)
 
+AX_BOOST([1.33])
+if test "x$BOOST_SERIALIZATION_LIB" = "x"; then
+           echo "Sorry, we need the Serialization-Lib from Boost."
+           exit 1
+fi
+
 AC_OUTPUT(Makefile doc/Doxyfile doc/Makefile src/Makefile libt2n.pc libt2n.spec test/Makefile)

diff --git a/libt2n.kdevelop b/libt2n.kdevelop
index 7024d3f..971a4bb 100644 (file)
--- a/libt2n.kdevelop
+++ b/libt2n.kdevelop
@@ -14,7 +14,7 @@
   </general>
   <kdevautoproject>
     <general>
-      <activetarget>test/server</activetarget>
+      <activetarget>test/test</activetarget>
       <useconfiguration>debug</useconfiguration>
     </general>
     <run>
@@ -22,8 +22,8 @@
       <terminal>true</terminal>
       <directoryradio>executable</directoryradio>
       <runarguments>
-        <client></client>
-        <server></server>
+        <client/>
+        <server/>
         <test></test>
       </runarguments>
     </run>

diff --git a/src/command.cpp b/src/command.cpp
index e1b5b7f..59eae7c 100644 (file)
--- a/src/command.cpp
+++ b/src/command.cpp
@@ -18,6 +18,9 @@
  ***************************************************************************/
 
 #include "command.hxx"
+#include <boost/serialization/export.hpp>
 
-BOOST_CLASS_EXPORT(libt2n::result)
-BOOST_CLASS_EXPORT(libt2n::command)
+using namespace libt2n;
+
+BOOST_CLASS_EXPORT(result)
+BOOST_CLASS_EXPORT(command)

diff --git a/src/command.hxx b/src/command.hxx
index 98f5004..ce67ebe 100644 (file)
--- a/src/command.hxx
+++ b/src/command.hxx
@@ -19,8 +19,10 @@
 #ifndef __LIBT2N_COMMAND
 #define __LIBT2N_COMMAND
 
+#include <iostream>
+
 #include <boost/serialization/serialization.hpp>
-#include <boost/serialization/export.hpp>
+#include <boost/serialization/tracking.hpp>
 
 namespace libt2n
 {
@@ -41,6 +43,7 @@ class result
 };
 }
 //BOOST_IS_ABSTRACT(libt2n::result)
+BOOST_CLASS_TRACKING(libt2n::result, boost::serialization::track_never)
 
 namespace libt2n
 {
@@ -52,16 +55,18 @@ class command
         friend class boost::serialization::access;
         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
-        { }
+        { 
+            std::cerr << "ser: command" << std::endl;
+        }
 
     public:
         /// this calls the wanted target function on the server
-        virtual result* operator()() = 0;
+        virtual result* operator()()=0;
         virtual ~command() {}
 };
 } // namespace libt2n
 //BOOST_IS_ABSTRACT(libt2n::command)
-
+BOOST_CLASS_TRACKING(libt2n::command, boost::serialization::track_never)
 
 
 #endif

diff --git a/src/container.cpp b/src/container.cpp
index bff9bb3..2973d54 100644 (file)
--- a/src/container.cpp
+++ b/src/container.cpp
@@ -19,5 +19,9 @@
 
 #include "container.hxx"
 
-BOOST_CLASS_EXPORT(libt2n::result_container)
-BOOST_CLASS_EXPORT(libt2n::command_container)
+#include <boost/serialization/export.hpp>
+
+using namespace libt2n;
+
+BOOST_CLASS_EXPORT(result_container)
+BOOST_CLASS_EXPORT(command_container)

diff --git a/src/container.hxx b/src/container.hxx
index 90053c6..8491926 100644 (file)
--- a/src/container.hxx
+++ b/src/container.hxx
@@ -22,6 +22,8 @@
 #include "command.hxx"
 #include "t2n_exception.hxx"
 
+#include <iostream>
+
 namespace libt2n
 {
 
@@ -92,6 +94,7 @@ class command_container
         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
+            std::cerr << "ser: command_container" << std::endl;
             ar & BOOST_SERIALIZATION_NVP(cmd);
         }
 

diff --git a/src/t2n_exception.cpp b/src/t2n_exception.cpp
index 9c213ba..37c71b0 100644 (file)
--- a/src/t2n_exception.cpp
+++ b/src/t2n_exception.cpp
@@ -18,6 +18,7 @@
  ***************************************************************************/
 
 #include "t2n_exception.hxx"
+#include <boost/serialization/export.hpp>
 
 BOOST_CLASS_EXPORT(libt2n::t2n_exception)
 BOOST_CLASS_EXPORT(libt2n::t2n_communication_error)

diff --git a/src/t2n_exception.hxx b/src/t2n_exception.hxx
index c81ba02..7191101 100644 (file)
--- a/src/t2n_exception.hxx
+++ b/src/t2n_exception.hxx
@@ -23,7 +23,6 @@
 #include <string>
 
 #include <boost/serialization/serialization.hpp>
-#include <boost/serialization/export.hpp>
 
 namespace boost {
 namespace serialization {

diff --git a/test/Makefile.am b/test/Makefile.am
index a7a5515..989448a 100644 (file)
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -1,8 +1,9 @@
-INCLUDES = -I$(top_srcdir)/src @CPPUNIT_CFLAGS@
+INCLUDES = -I$(top_srcdir)/src @BOOST_CPPFLAGS@ @CPPUNIT_CFLAGS@
 METASOURCES = AUTO
 check_PROGRAMS = test
 
-test_LDADD = $(top_builddir)/src/libt2n.la @CPPUNIT_LIBS@
-test_SOURCES = test.cpp comm.cpp
+test_LDADD = $(top_builddir)/src/libt2n.la @BOOST_SERIALIZATION_LIB@ \
+       @BOOST_LDFLAGS@ @CPPUNIT_LIBS@
+test_SOURCES = test.cpp comm.cpp simplecmd.cpp
 
 TESTS = test

diff --git a/test/simplecmd.cpp b/test/simplecmd.cpp
new file mode 100644 (file)
index 0000000..b48fab6
--- /dev/null
+++ b/test/simplecmd.cpp
@@ -0,0 +1,169 @@
+/***************************************************************************
+ *   Copyright (C) 2004 by Intra2net AG                                    *
+ *   info@intra2net.com                                                    *
+ *                                                                         *
+ ***************************************************************************/
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+#include <signal.h>
+#include <stdio.h>
+
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <stdexcept>
+
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/ui/text/TestRunner.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+#include <container.hxx>
+#include <socket_client.hxx>
+#include <socket_server.hxx>
+#include <command_client.hxx>
+#include <command_server.hxx>
+
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/export.hpp>
+
+using namespace std;
+using namespace libt2n;
+using namespace CppUnit;
+
+string testfunc(const string& str)
+{
+    string ret(str);
+    ret+=", testfunc() was here";
+    return ret;
+}
+
+class testfunc_res : public result
+{
+    private:
+        string res;
+
+        friend class boost::serialization::access;
+        template<class Archive>
+        void serialize(Archive & ar, const unsigned int version)
+        {
+            ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(result);
+            ar & BOOST_SERIALIZATION_NVP(res);
+        }
+
+    public:
+        testfunc_res()
+            { }
+
+        testfunc_res(const string& str)
+        {
+            res=str;
+        }
+
+        string get_data()
+        {
+            return res;
+        }
+};
+
+class testfunc_cmd : public libt2n::command
+{
+    private:
+        string param;
+
+        friend class boost::serialization::access;
+        template<class Archive>
+        void serialize(Archive & ar, const unsigned int version)
+        {
+            cerr << "ser: testfunc_cmd" << endl;
+            ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(libt2n::command);
+            ar & BOOST_SERIALIZATION_NVP(param);
+        }
+
+    public:
+        testfunc_cmd()
+            { }
+
+        testfunc_cmd(const string& str)
+        {
+            param=str;
+        }
+
+        result* operator()()
+        {
+            return new testfunc_res(testfunc(param));
+        }
+};
+
+
+BOOST_CLASS_EXPORT(testfunc_cmd)
+BOOST_CLASS_EXPORT(testfunc_res)
+
+class test_simplecmd : public TestFixture
+{
+    CPPUNIT_TEST_SUITE(test_simplecmd);
+
+    CPPUNIT_TEST(SimpleCmd);
+
+    CPPUNIT_TEST_SUITE_END();
+
+    public:
+
+    void setUp()
+    {
+}
+
+    void tearDown()
+    { }
+
+    void SimpleCmd()
+    {
+        pid_t pid;
+
+        switch(pid=fork())
+        {
+            case -1:
+            {
+                CPPUNIT_FAIL("fork error");
+                break;
+            }
+            case 0:
+            // child
+            {
+                socket_server ss("./socket");
+                ss.set_logging(&cerr,debug);
+                command_server cs(ss);
+
+                // max 10 sec
+                for (int i=0; i < 10; i++)
+                    cs.handle(1000000);
+
+                // don't call atexit and stuff
+                _exit(0);
+            }
+
+            default:
+            // parent
+            {
+                // wait till server is up
+                sleep(1);
+                socket_client_connection sc("./socket");
+                command_client cc(sc);
+
+                result_container rc;
+                cc.send_command(new testfunc_cmd("hello"),rc);
+
+                string ret=dynamic_cast<testfunc_res*>(rc.get_result())->get_data();
+
+                CPPUNIT_ASSERT_EQUAL(string("hello, testfunc() was here"),ret);
+            }
+        }
+    }
+
+
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(test_simplecmd);

diff --git a/test/test.cpp b/test/test.cpp
index 4451c48..688fa37 100644 (file)
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -60,7 +60,7 @@ class VerboseTimingListener : public CppUnit::TestListener
                 resultstr="FAIL";
         }
 };
- 
+
 int main(int argc, char **argv)
 {
     CppUnit::TextTestRunner runner;