Initial commit.

Completed GNU Autoconf setup, with Catch2 and Fakeit Support

.gitignore

@@ -0,0 +1,108 @@
+
+# Created by https://www.gitignore.io/api/c++,autotools
+
+### Autotools ###
+# http://www.gnu.org/software/automake
+
+Makefile.in
+/ar-lib
+/mdate-sh
+/py-compile
+/test-driver
+/ylwrap
+
+# http://www.gnu.org/software/autoconf
+
+autom4te.cache
+/autoscan.log
+/autoscan-*.log
+/aclocal.m4
+/compile
+/config.guess
+/config.h.in
+/config.log
+/config.status
+/config.sub
+/configure
+/configure.scan
+/depcomp
+/install-sh
+/missing
+/stamp-h1
+
+# https://www.gnu.org/software/libtool/
+
+/ltmain.sh
+
+# http://www.gnu.org/software/texinfo
+
+/texinfo.tex
+
+# http://www.gnu.org/software/m4/
+
+m4/libtool.m4
+m4/ltoptions.m4
+m4/ltsugar.m4
+m4/ltversion.m4
+m4/lt~obsolete.m4
+
+### Autotools Patch ###
+
+### C++ ###
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+
+# End of https://www.gitignore.io/api/c++,autotools
+
+*.*~
+Makefile
+*.deps
+.dirstamp
+bin/*
+build/*
+release/*
+debug/*
+build-*/*
+test-*.log
+compile_commands.json
+*.bak
+docs/*
+tags
+*cache
+.DS_Store
+.clangd
+hooks/samples/*
+.workdir/*
+*~
+*.ui.hpp

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "third_party/FakeIt"]
+	path = third_party/FakeIt
+	url = https://github.com/eranpeer/FakeIt.git

Makefile.am

@@ -0,0 +1,63 @@
+srcdir = @srcdir@
+VPATH = @srcdir@
+
+ACLOCAL_AMFLAGS=-I m4
+# Variable declarations to be reused and appended with targets
+bin_PROGRAMS=
+check_PROGRAMS=
+noinst_LIBRARIES=
+
+noinst_LTLIBRARIES=
+pkglib_LTLIBRARIES=
+include_HEADERS=
+
+EXTRA_LIBRARIES=
+
+phony_targets=
+warning_flags=
+disabled_warnings=
+
+#qt5_extra_cxxflags=-fPIC -DPIC
+
+warning_flags+=-Werror -Wall
+
+#example:
+#if HAVE_BUILD_SERVER
+#disabled_warnings+=-Wno-c++20-extensions
+#else
+#warning_flags+=-pedantic
+#endif
+
+warning_flags+=-pedantic
+
+project_include_flags=
+project_include_flags+=-I ${srcdir}/src
+
+#example third party lib
+#project_include_flags+=$(NLOHMANN_JSON_CFLAGS)
+
+
+AM_CFLAGS=
+AM_CXXFLAGS=
+AM_CPPFLAGS=
+
+AM_CFLAGS+=${warning_flags}
+AM_CXXFLAGS+= ${warning_flags} ${disabled_warnings}
+AM_CPPFLAGS+=$(project_include_flags)
+
+# example third-party libs
+#AM_LDFLAGS=$(NLOHMANN_JSON_LIBS)
+
+#rebuild-qtforms:
+#	$(abs_top_srcdir)/rebuild-qtforms.sh
+
+#run: ${bin_PROGRAMS}
+#	@./quartz-warriors
+
+# Always make sure the resources/ folder is linked to the build directory
+all-am: @top_builddir@/resources
+
+include src/Makefile.am
+include editorconfig/vim-completion.am
+.PHONY:  $(phony_targets)
+# vim: set ts=4 sts=4 noet foldmethod=marker foldmarker=#region,#endregion :

configure.ac

@@ -0,0 +1,105 @@
+dnl                                               -*- Autoconf -*-
+dnl Process this file with autoconf to produce a configure script.
+
+AC_PREREQ([2.69])
+AC_INIT([cpp-project], [0.0.1], [bugs@cpp-project.com])
+
+AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_SRCDIR([src])
+AC_CONFIG_HEADERS([config.h])
+AC_CONFIG_FILES([Makefile])
+
+AC_CANONICAL_HOST
+
+dnl Helps with detection of specific OSes when this is built in a CI server
+AC_ARG_VAR([BUILD_SERVER], [Use this to alter compile flags or disable features on CI/CD build servers])
+AM_CONDITIONAL([HAVE_BUILD_SERVER], [ test -n "${BUILD_SERVER}" && test "x${BUILD_SERVER}" != "xno" ])
+
+AM_COND_IF([HAVE_BUILD_SERVER],
+	  AC_MSG_NOTICE([Buildserver detected. Some features might be disabled.]),
+)
+
+dnl Predefine some shell variables for error messages
+err_inplace_build="In-place builds are forbidden
+
+Try:
+$ mkdir build && cd build ;
+$ ../configure
+"
+
+AC_MSG_CHECKING([that this is an out-of-source build])
+case $srcdir in
+	.)  dnl We are building in place
+		dnl Forbid users from building outside a build directory. No in-place builds!!
+		AC_MSG_RESULT([no])
+		AC_MSG_ERROR([$err_inplace_build])
+		AS_EXIT(255)
+		;;
+	*)
+		AC_MSG_RESULT([yes])
+		;;
+esac
+
+dnl link the project resources/ directory to the build directory
+AC_CONFIG_LINKS([${builddir}resources:${top_srcdir}resources])
+AM_INIT_AUTOMAKE([1.15] [foreign subdir-objects dist-xz])
+AM_SILENT_RULES([yes])
+
+dnl libtool support
+LT_INIT
+
+dnl pkg-config support
+PKG_PROG_PKG_CONFIG dnl enable pkg-config support
+
+dnl Checks for programs.
+dnl AC_PROG_RANLIB
+AC_PROG_CXX
+AX_CXX_COMPILE_STDCXX(17, [noext], [mandatory])
+
+dnl check for compiledb. Useful to generate .clang_completion information for
+dnl vim autocomplete
+AC_CHECK_PROG([_ac_compiledb_detected], [compiledb], [true], [false])
+AM_CONDITIONAL([HAVE_COMPILEDB], [test x$_ac_compiledb_detected = xtrue ])
+
+AM_COND_IF([HAVE_COMPILEDB],
+	  AC_MSG_NOTICE([compiledb found!  vim-completion make target enabled]),
+	  AC_MSG_WARN([compiledb not found. vim-completion make target disabled])
+)
+
+dnl Checks for libraries.
+dnl PKG_CHECK_MODULES([SDL2], [sdl2 >= 2 SDL2_image >= 0.29.0 SDL2_gfx >= 1.0.2])
+
+dnl AC_REQUIRE_HEADER([stdint.h])
+
+dnl Switch to C++ mode
+AC_LANG_PUSH([C++])
+
+BOOST_REQUIRE([1.7.2])
+dnl BOOST_SYSTEM([mt-sdg])
+dnl BOOST_FILESYSTEM([mt-sdg])
+
+PKG_CHECK_MODULES([CATCH2], [catch2-with-main >= 2.13.7])
+
+dnl Example Qt5 integration
+dnl PKG_CHECK_MODULES([QT], [Qt5Core >= 5.15 Qt5Widgets Qt5Gui], [
+dnl 	QT_PATH="$(eval $PKG_CONFIG --variable=exec_prefix Qt5Core)"
+dnl 	QT_HOST_PATH="$(eval $PKG_CONFIG --variable=host_bins Qt5Core)"
+dnl 	QT_VERSION="$(eval $PKG_CONFIG --modversion Qt5Gui)"
+dnl 	AC_PATH_PROGS(MOC, [moc-qt5 moc], moc, ["${QT_HOST_PATH}" "${QT_PATH}/bin"])
+dnl     AC_PATH_PROGS(RCC, [rcc-qt5 rcc], rcc, ["${QT_HOST_PATH}" "${QT_PATH}/bin"])
+dnl     AC_PATH_PROGS(UIC, [uic-qt5 uic], uic, ["${QT_HOST_PATH}" "${QT_PATH}/bin"])
+dnl     AC_PATH_PROGS(QMLCACHE, [qmlcachegen-qt5 qmlcachegen], no, ["${QT_HOST_PATH}" "${QT_PATH}/bin"])
+dnl ])
+AC_LANG_POP
+
+dnl Check if we have a libexecinfo.
+dnl On non-glibc systems, using backtrace requires linking to libexecinfo.o
+dnl AC_CHECK_HEADERS([execinfo.h])
+dnl AC_CHECK_LIB([execinfo], [backtrace],
+dnl      [LIBS="${LIBS} -lexecinfo"; BOOST_FIND_HEADER([boost/stacktrace.hpp])])
+dnl
+dnl AC_CHECK_FUNCS([backtrace backtrace_symbols])
+dnl
+dnl AC_CHECK_LIB([pthread], [pthread_create])
+
+AC_OUTPUT

editorconfig/local.vimrc

@@ -0,0 +1,52 @@
+" quartz-warriors/local.vimrc
+" License: The Unlicense {
+" This is free and unencumbered software released into the public domain.
+"
+" Anyone is free to copy, modify, publish, use, compile, sell, or
+" distribute this software, either in source code form or as a compiled
+" binary, for any purpose, commercial or non-commercial, and by any
+" means.
+"
+" In jurisdictions that recognize copyright laws, the author or authors
+" of this software dedicate any and all copyright interest in the
+" software to the public domain. We make this dedication for the benefit
+" of the public at large and to the detriment of our heirs and
+" successors. We intend this dedication to be an overt act of
+" relinquishment in perpetuity of all present and future rights to this
+" software under copyright law.
+"
+" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+" EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+" IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+" OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+" ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+" OTHER DEALINGS IN THE SOFTWARE.
+"
+" For more information, please refer to <http://unlicense.org/>
+" }
+
+if ! get(s:, 'defined', 0) " -- prevents the function from being redefined after compiling
+	function! BuildDebug()
+		let s:defined = 1
+
+		wall
+		cd ./debug
+
+		if exists(':Make')
+			:Make -j 3 all check
+			cd ..
+		else
+			make -j 3 all check
+			vert botright copen
+			vert resize +100
+		endif
+
+	endfunction
+endif
+
+nnoremap <leader>bd :call BuildDebug()<CR>
+
+set path+=src
+
+" vim: set ts=4 sts=4 noet sw=4 foldmethod=marker foldmarker={,} :

editorconfig/vim-completion.am

@@ -0,0 +1,20 @@
+
+if HAVE_COMPILEDB
+
+@abs_top_srcdir@/compile_commands.json:
+	rm -f @abs_top_srcdir@/compile_commands.json
+	make clean
+	compiledb `basename ${MAKE}` -j 1 all
+	ln  @top_builddir@/compile_commands.json @abs_top_srcdir@
+
+phony_targets+= vim-completion
+
+vim-completion: @abs_top_srcdir@/compile_commands.json
+else
+vim-completion:
+	echo "compiledb not found; vim-completion disabled"
+endif
+
+# vim: sts=4 ts=4 noet ft=automake :
+
+

m4/ax_cxx_compile_stdcxx.m4

@@ -0,0 +1,962 @@
+# ===========================================================================
+#  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the specified
+#   version of the C++ standard.  If necessary, add switches to CXX and
+#   CXXCPP to enable support.  VERSION may be '11' (for the C++11 standard)
+#   or '14' (for the C++14 standard).
+#
+#   The second argument, if specified, indicates whether you insist on an
+#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
+#   -std=c++11).  If neither is specified, you get whatever works, with
+#   preference for no added switch, and then for an extended mode.
+#
+#   The third argument, if specified 'mandatory' or if left unspecified,
+#   indicates that baseline support for the specified C++ standard is
+#   required and that the macro should error out if no mode with that
+#   support is found.  If specified 'optional', then configuration proceeds
+#   regardless, after defining HAVE_CXX${VERSION} if and only if a
+#   supporting mode is found.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
+#   Copyright (c) 2015 Paul Norman <penorman@mac.com>
+#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
+#   Copyright (c) 2016, 2018 Krzesimir Nowak <qdlacz@gmail.com>
+#   Copyright (c) 2019 Enji Cooper <yaneurabeya@gmail.com>
+#   Copyright (c) 2020 Jason Merrill <jason@redhat.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved.  This file is offered as-is, without any
+#   warranty.
+
+#serial 12
+
+dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
+dnl  (serial version number 13).
+
+AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
+  m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"],
+        [$1], [14], [ax_cxx_compile_alternatives="14 1y"],
+        [$1], [17], [ax_cxx_compile_alternatives="17 1z"],
+        [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
+  m4_if([$2], [], [],
+        [$2], [ext], [],
+        [$2], [noext], [],
+        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl
+  m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],
+        [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],
+        [$3], [optional], [ax_cxx_compile_cxx$1_required=false],
+        [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
+  AC_LANG_PUSH([C++])dnl
+  ac_success=no
+
+  m4_if([$2], [], [dnl
+    AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
+		   ax_cv_cxx_compile_cxx$1,
+      [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+        [ax_cv_cxx_compile_cxx$1=yes],
+        [ax_cv_cxx_compile_cxx$1=no])])
+    if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
+      ac_success=yes
+    fi])
+
+  m4_if([$2], [noext], [], [dnl
+  if test x$ac_success = xno; then
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      switch="-std=gnu++${alternative}"
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                     $cachevar,
+        [ac_save_CXX="$CXX"
+         CXX="$CXX $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXX="$ac_save_CXX"])
+      if eval test x\$$cachevar = xyes; then
+        CXX="$CXX $switch"
+        if test -n "$CXXCPP" ; then
+          CXXCPP="$CXXCPP $switch"
+        fi
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+
+  m4_if([$2], [ext], [], [dnl
+  if test x$ac_success = xno; then
+    dnl HP's aCC needs +std=c++11 according to:
+    dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
+    dnl Cray's crayCC needs "-h std=c++11"
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
+        cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
+        AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                       $cachevar,
+          [ac_save_CXX="$CXX"
+           CXX="$CXX $switch"
+           AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+            [eval $cachevar=yes],
+            [eval $cachevar=no])
+           CXX="$ac_save_CXX"])
+        if eval test x\$$cachevar = xyes; then
+          CXX="$CXX $switch"
+          if test -n "$CXXCPP" ; then
+            CXXCPP="$CXXCPP $switch"
+          fi
+          ac_success=yes
+          break
+        fi
+      done
+      if test x$ac_success = xyes; then
+        break
+      fi
+    done
+  fi])
+  AC_LANG_POP([C++])
+  if test x$ax_cxx_compile_cxx$1_required = xtrue; then
+    if test x$ac_success = xno; then
+      AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])
+    fi
+  fi
+  if test x$ac_success = xno; then
+    HAVE_CXX$1=0
+    AC_MSG_NOTICE([No compiler with C++$1 support was found])
+  else
+    HAVE_CXX$1=1
+    AC_DEFINE(HAVE_CXX$1,1,
+              [define if the compiler supports basic C++$1 syntax])
+  fi
+  AC_SUBST(HAVE_CXX$1)
+])
+
+
+dnl  Test body for checking C++11 support
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+)
+
+
+dnl  Test body for checking C++14 support
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+)
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
+)
+
+dnl  Tests for new features in C++11
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual ~Base() {}
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual ~Derived() override {}
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = [](){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = [](int i, int j){ return i + j; }(1, 2);
+      auto b = []() -> int { return '0'; }();
+      auto c = [=](){ return a + b; }();
+      auto d = [&](){ return c; }();
+      auto e = [a, &b](int x) mutable {
+        const auto identity = [](int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = [](){ return 0; };
+      const auto unary = [](int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = [](nullary_t f){ return f(); };
+      const auto higher2nd = [unary](nullary_t f1){
+        return [unary, f1](unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+]])
+
+
+dnl  Tests for new features in C++14
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[
+
+// If the compiler admits that it is not ready for C++14, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201402L
+
+#error "This is not a C++14 compiler"
+
+#else
+
+namespace cxx14
+{
+
+  namespace test_polymorphic_lambdas
+  {
+
+    int
+    test()
+    {
+      const auto lambda = [](auto&&... args){
+        const auto istiny = [](auto x){
+          return (sizeof(x) == 1UL) ? 1 : 0;
+        };
+        const int aretiny[] = { istiny(args)... };
+        return aretiny[0];
+      };
+      return lambda(1, 1L, 1.0f, '1');
+    }
+
+  }
+
+  namespace test_binary_literals
+  {
+
+    constexpr auto ivii = 0b0000000000101010;
+    static_assert(ivii == 42, "wrong value");
+
+  }
+
+  namespace test_generalized_constexpr
+  {
+
+    template < typename CharT >
+    constexpr unsigned long
+    strlen_c(const CharT *const s) noexcept
+    {
+      auto length = 0UL;
+      for (auto p = s; *p; ++p)
+        ++length;
+      return length;
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("x") == 1UL, "");
+    static_assert(strlen_c("test") == 4UL, "");
+    static_assert(strlen_c("another\0test") == 7UL, "");
+
+  }
+
+  namespace test_lambda_init_capture
+  {
+
+    int
+    test()
+    {
+      auto x = 0;
+      const auto lambda1 = [a = x](int b){ return a + b; };
+      const auto lambda2 = [a = lambda1(x)](){ return a; };
+      return lambda2();
+    }
+
+  }
+
+  namespace test_digit_separators
+  {
+
+    constexpr auto ten_million = 100'000'000;
+    static_assert(ten_million == 100000000, "");
+
+  }
+
+  namespace test_return_type_deduction
+  {
+
+    auto f(int& x) { return x; }
+    decltype(auto) g(int& x) { return x; }
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static constexpr auto value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static constexpr auto value = true;
+    };
+
+    int
+    test()
+    {
+      auto x = 0;
+      static_assert(is_same<int, decltype(f(x))>::value, "");
+      static_assert(is_same<int&, decltype(g(x))>::value, "");
+      return x;
+    }
+
+  }
+
+}  // namespace cxx14
+
+#endif  // __cplusplus >= 201402L
+
+]])
+
+
+dnl  Tests for new features in C++17
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[
+
+// If the compiler admits that it is not ready for C++17, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201703L
+
+#error "This is not a C++17 compiler"
+
+#else
+
+#include <initializer_list>
+#include <utility>
+#include <type_traits>
+
+namespace cxx17
+{
+
+  namespace test_constexpr_lambdas
+  {
+
+    constexpr int foo = [](){return 42;}();
+
+  }
+
+  namespace test::nested_namespace::definitions
+  {
+
+  }
+
+  namespace test_fold_expression
+  {
+
+    template<typename... Args>
+    int multiply(Args... args)
+    {
+      return (args * ... * 1);
+    }
+
+    template<typename... Args>
+    bool all(Args... args)
+    {
+      return (args && ...);
+    }
+
+  }
+
+  namespace test_extended_static_assert
+  {
+
+    static_assert (true);
+
+  }
+
+  namespace test_auto_brace_init_list
+  {
+
+    auto foo = {5};
+    auto bar {5};
+
+    static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value);
+    static_assert(std::is_same<int, decltype(bar)>::value);
+  }
+
+  namespace test_typename_in_template_template_parameter
+  {
+
+    template<template<typename> typename X> struct D;
+
+  }
+
+  namespace test_fallthrough_nodiscard_maybe_unused_attributes
+  {
+
+    int f1()
+    {
+      return 42;
+    }
+
+    [[nodiscard]] int f2()
+    {
+      [[maybe_unused]] auto unused = f1();
+
+      switch (f1())
+      {
+      case 17:
+        f1();
+        [[fallthrough]];
+      case 42:
+        f1();
+      }
+      return f1();
+    }
+
+  }
+
+  namespace test_extended_aggregate_initialization
+  {
+
+    struct base1
+    {
+      int b1, b2 = 42;
+    };
+
+    struct base2
+    {
+      base2() {
+        b3 = 42;
+      }
+      int b3;
+    };
+
+    struct derived : base1, base2
+    {
+        int d;
+    };
+
+    derived d1 {{1, 2}, {}, 4};  // full initialization
+    derived d2 {{}, {}, 4};      // value-initialized bases
+
+  }
+
+  namespace test_general_range_based_for_loop
+  {
+
+    struct iter
+    {
+      int i;
+
+      int& operator* ()
+      {
+        return i;
+      }
+
+      const int& operator* () const
+      {
+        return i;
+      }
+
+      iter& operator++()
+      {
+        ++i;
+        return *this;
+      }
+    };
+
+    struct sentinel
+    {
+      int i;
+    };
+
+    bool operator== (const iter& i, const sentinel& s)
+    {
+      return i.i == s.i;
+    }
+
+    bool operator!= (const iter& i, const sentinel& s)
+    {
+      return !(i == s);
+    }
+
+    struct range
+    {
+      iter begin() const
+      {
+        return {0};
+      }
+
+      sentinel end() const
+      {
+        return {5};
+      }
+    };
+
+    void f()
+    {
+      range r {};
+
+      for (auto i : r)
+      {
+        [[maybe_unused]] auto v = i;
+      }
+    }
+
+  }
+
+  namespace test_lambda_capture_asterisk_this_by_value
+  {
+
+    struct t
+    {
+      int i;
+      int foo()
+      {
+        return [*this]()
+        {
+          return i;
+        }();
+      }
+    };
+
+  }
+
+  namespace test_enum_class_construction
+  {
+
+    enum class byte : unsigned char
+    {};
+
+    byte foo {42};
+
+  }
+
+  namespace test_constexpr_if
+  {
+
+    template <bool cond>
+    int f ()
+    {
+      if constexpr(cond)
+      {
+        return 13;
+      }
+      else
+      {
+        return 42;
+      }
+    }
+
+  }
+
+  namespace test_selection_statement_with_initializer
+  {
+
+    int f()
+    {
+      return 13;
+    }
+
+    int f2()
+    {
+      if (auto i = f(); i > 0)
+      {
+        return 3;
+      }
+
+      switch (auto i = f(); i + 4)
+      {
+      case 17:
+        return 2;
+
+      default:
+        return 1;
+      }
+    }
+
+  }
+
+  namespace test_template_argument_deduction_for_class_templates
+  {
+
+    template <typename T1, typename T2>
+    struct pair
+    {
+      pair (T1 p1, T2 p2)
+        : m1 {p1},
+          m2 {p2}
+      {}
+
+      T1 m1;
+      T2 m2;
+    };
+
+    void f()
+    {
+      [[maybe_unused]] auto p = pair{13, 42u};
+    }
+
+  }
+
+  namespace test_non_type_auto_template_parameters
+  {
+
+    template <auto n>
+    struct B
+    {};
+
+    B<5> b1;
+    B<'a'> b2;
+
+  }
+
+  namespace test_structured_bindings
+  {
+
+    int arr[2] = { 1, 2 };
+    std::pair<int, int> pr = { 1, 2 };
+
+    auto f1() -> int(&)[2]
+    {
+      return arr;
+    }
+
+    auto f2() -> std::pair<int, int>&
+    {
+      return pr;
+    }
+
+    struct S
+    {
+      int x1 : 2;
+      volatile double y1;
+    };
+
+    S f3()
+    {
+      return {};
+    }
+
+    auto [ x1, y1 ] = f1();
+    auto& [ xr1, yr1 ] = f1();
+    auto [ x2, y2 ] = f2();
+    auto& [ xr2, yr2 ] = f2();
+    const auto [ x3, y3 ] = f3();
+
+  }
+
+  namespace test_exception_spec_type_system
+  {
+
+    struct Good {};
+    struct Bad {};
+
+    void g1() noexcept;
+    void g2();
+
+    template<typename T>
+    Bad
+    f(T*, T*);
+
+    template<typename T1, typename T2>
+    Good
+    f(T1*, T2*);
+
+    static_assert (std::is_same_v<Good, decltype(f(g1, g2))>);
+
+  }
+
+  namespace test_inline_variables
+  {
+
+    template<class T> void f(T)
+    {}
+
+    template<class T> inline T g(T)
+    {
+      return T{};
+    }
+
+    template<> inline void f<>(int)
+    {}
+
+    template<> int g<>(int)
+    {
+      return 5;
+    }
+
+  }
+
+}  // namespace cxx17
+
+#endif  // __cplusplus < 201703L
+
+]])

m4/ax_cxx_compile_stdcxx_11.m4

@@ -0,0 +1,39 @@
+# =============================================================================
+#  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
+# =============================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX_11([ext|noext], [mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the C++11
+#   standard; if necessary, add switches to CXX and CXXCPP to enable
+#   support.
+#
+#   This macro is a convenience alias for calling the AX_CXX_COMPILE_STDCXX
+#   macro with the version set to C++11.  The two optional arguments are
+#   forwarded literally as the second and third argument respectively.
+#   Please see the documentation for the AX_CXX_COMPILE_STDCXX macro for
+#   more information.  If you want to use this macro, you also need to
+#   download the ax_cxx_compile_stdcxx.m4 file.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
+#   Copyright (c) 2015 Paul Norman <penorman@mac.com>
+#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 18
+
+AX_REQUIRE_DEFINED([AX_CXX_COMPILE_STDCXX])
+AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [AX_CXX_COMPILE_STDCXX([11], [$1], [$2])])

m4/ax_cxx_compile_stdcxx_14.m4

@@ -0,0 +1,34 @@
+# =============================================================================
+#  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_14.html
+# =============================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX_14([ext|noext], [mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the C++14
+#   standard; if necessary, add switches to CXX and CXXCPP to enable
+#   support.
+#
+#   This macro is a convenience alias for calling the AX_CXX_COMPILE_STDCXX
+#   macro with the version set to C++14.  The two optional arguments are
+#   forwarded literally as the second and third argument respectively.
+#   Please see the documentation for the AX_CXX_COMPILE_STDCXX macro for
+#   more information.  If you want to use this macro, you also need to
+#   download the ax_cxx_compile_stdcxx.m4 file.
+#
+# LICENSE
+#
+#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 5
+
+AX_REQUIRE_DEFINED([AX_CXX_COMPILE_STDCXX])
+AC_DEFUN([AX_CXX_COMPILE_STDCXX_14], [AX_CXX_COMPILE_STDCXX([14], [$1], [$2])])

m4/ax_cxx_compile_stdcxx_17.m4

@@ -0,0 +1,35 @@
+# =============================================================================
+#  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_17.html
+# =============================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX_17([ext|noext], [mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the C++17
+#   standard; if necessary, add switches to CXX and CXXCPP to enable
+#   support.
+#
+#   This macro is a convenience alias for calling the AX_CXX_COMPILE_STDCXX
+#   macro with the version set to C++17.  The two optional arguments are
+#   forwarded literally as the second and third argument respectively.
+#   Please see the documentation for the AX_CXX_COMPILE_STDCXX macro for
+#   more information.  If you want to use this macro, you also need to
+#   download the ax_cxx_compile_stdcxx.m4 file.
+#
+# LICENSE
+#
+#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
+#   Copyright (c) 2016 Krzesimir Nowak <qdlacz@gmail.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 2
+
+AX_REQUIRE_DEFINED([AX_CXX_COMPILE_STDCXX])
+AC_DEFUN([AX_CXX_COMPILE_STDCXX_17], [AX_CXX_COMPILE_STDCXX([17], [$1], [$2])])

src/Makefile.am

@@ -0,0 +1,3 @@
+
+include src/app/Makefile.am
+include src/tests/Makefile.am

src/app/Makefile.am

@@ -0,0 +1,13 @@
+bin_PROGRAMS+= cpp-project
+
+cpp_project_SOURCES=
+cpp_project_SOURCES+=src/app/main.cpp
+
+cpp_project_CPPFLAGS=
+cpp_project_CPPFLAGS+= $(AM_CPPFLAGS)
+cpp_project_CPPFLAGS+= $(project_include_flags)
+
+cpp_project_LDADD=
+
+#cpp_project_CPPFLAGS+= $(SDL2_CFLAGS)
+#cpp_project_LDADD+=  libframework-core.la

src/app/main.cpp

@@ -0,0 +1,18 @@
+/* main.cpp
+ * Copyright © 2022 Saul D. Beniquez 
+ * License: Mozilla Public License v. 2.0
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v.2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <iostream>
+
+int main(int argc, char *argv[])
+{
+	std::cout << "Hello World" << std::endl;
+	return 0;
+}
+// clang-format off
+// vim: set foldmethod=marker foldmarker=#region,#endregion textwidth=80 ts=8 sts=0 sw=8  noexpandtab ft=cpp.doxygen :

src/tests/Makefile.am

@@ -0,0 +1,28 @@
+TESTS=
+check_PROGRAMS+= app-test
+TESTS+=$(check_PROGRAMS)
+
+tests_c_flags=
+tests_c_flags+= -I ${srcdir}/src/tests
+tests_c_flags+= -I ${srcdir}/third_party/FakeIt/include -I ${srcdir}/third_party/FakeIt/config/catch
+tests_c_flags+= $(CATCH2_CFLAGS)
+
+# Ignore errors that are usually coming from the testing frameworks themselves
+test_disabled_warnings=-Wno-deprecated-declarations -Wno-defaulted-function-deleted\
+				  -Wno-zero-length-array
+
+app_test_SOURCES=
+app_test_LDADD=
+app_test_CXXFLAGS=
+app_test_CPPFLAGS=
+app_test_SOURCES+=src/tests/runtime.tests.cpp
+
+
+app_test_CXXFLAGS+= ${AM_CXXFLAGS} ${test_disabled_warnings}
+app_test_CPPFLAGS+= $(AM_CPPFLAGS) $(PROJECT_INCLUDE_FLAGS)
+app_test_CPPFLAGS+= $(tests_c_flags)
+app_test_CPPFLAGS+= -DUNIT_TEST=1
+
+app_test_LDADD+= $(CATCH2_LIBS)
+#app_test_LDADD+=$(SDL2_LIBS) $(NLOHMANN_JSON_LIBS)
+

src/tests/runtime.tests.cpp

@@ -0,0 +1,83 @@
+/* test-frameworks.cpp
+ * Copyright © 2018-2022 Saul D. Beniquez
+ * License: Mozilla Public License v. 2.0
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ License, v. 2.0. If a copy of the MPL was not distributed with this
+ file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include "test-includes.hpp"
+
+#include <boost/lexical_cast.hpp>
+
+using fakeit::Mock;
+using fakeit::When;
+
+class SomeInterface
+{
+    public:
+	virtual int foo(int) = 0;
+	virtual int bar(char*)= 0;
+};
+
+TEST_CASE("Catch2 works with Fakeit", "[integrity-check]")
+{
+	Mock<SomeInterface> mock_obj;
+	Mock<SomeInterface> other_obj;
+
+	// Use the preprocessor and template generator to create
+	// two implementations of SomeInterface
+	When(Method(mock_obj, foo)).Return(1);   // returns 1 once
+	When(Method(other_obj, foo)).Return(-1); //  returns 0 once
+
+	// Get an instance of the generated mock class
+	auto& iface = mock_obj.get();
+
+	REQUIRE(iface.foo(0) == 1);
+
+	auto& otheriface = other_obj.get();
+	REQUIRE(otheriface.foo(0) == -1);
+}
+
+// #region seraization test setup
+//struct DataRecord
+//{
+//	id_t id;
+//	std::string name;
+//
+//	bool operator==(const DataRecord& rhs) const
+//	{
+//		return (this->id == rhs.id) && (this->name == rhs.name);
+//	}
+//
+//	NLOHMANN_DEFINE_TYPE_INTRUSIVE(DataRecord, id, name)
+//};
+//struct DataRecordCollection
+//{
+//	std::unordered_map<id_t, DataRecord> collection;
+//
+//	NLOHMANN_DEFINE_TYPE_INTRUSIVE(DataRecordCollection, collection)
+//
+//};
+
+/*TEST_CASE("serizalization works as expected", "[integrity-check]")
+{
+	DataRecord testRecord;
+	DataRecord expectedResult{ .id = 52, .name = "expected" };
+
+	json json_object = expectedResult;
+	std::string json_string = json_object.dump(4);
+
+	// print out the generated json so we can see it when the test runs
+	std::cout << json_string << std::endl;
+
+	auto from_string = json::parse(json_string);
+	testRecord = from_string.get<DataRecord>();
+
+	REQUIRE(expectedResult == testRecord);
+}*/
+// #endregion
+
+// clang-format off
+// vim: set foldmethod=marker foldmarker=#region,#endregion textwidth=80 ts=8 sts=0 sw=8  noexpandtab ft=cpp.doxygen :

src/tests/test-includes.hpp

@@ -0,0 +1,28 @@
+/* test-includes.hpp
+ * Copyright © 2020-2022 Saul D. Beniquez
+ * License: Mozilla Public License v. 2.0
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ License, v. 2.0. If a copy of the MPL was not distributed with this
+ file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include <catch2/catch_test_macros.hpp>
+#include <fakeit.hpp>
+
+#define BEGIN_TEST_SUITE(name)\
+	namespace {\
+	const char* TEST_SUITE_NAME = "[" name "]";
+
+#define END_TEST_SUITE }
+
+#define FIXTURE_CASE(testname)\
+	TEST_CASE_METHOD(TestFixture, #testname, TEST_SUITE_NAME)
+
+#ifdef VIM_COMPLETION
+#define UNIT_TEST
+#endif
+// clang-format off
+// vim: set foldmethod=marker foldmarker=#region,#endregion textwidth=80 ts=8 sts=0 sw=8  noexpandtab ft=cpp.doxygen :

third_party/FakeIt

@@ -0,0 +1 @@
+Subproject commit 78ca536e6b32f11e2883d474719a447915e40005