add ode

3 files changed, 9626 insertions, 0 deletions

diff --git a/libs/ode-0.16.1/ou/test/Makefile.am b/libs/ode-0.16.1/ou/test/Makefile.am
new file mode 100644
index 0000000..c0f973f
--- /dev/null
+++ b/libs/ode-0.16.1/ou/test/Makefile.am
@@ -0,0 +1,10 @@
+AM_CPPFLAGS = -I$(top_srcdir)/include
+AM_CXXFLAGS = -fno-exceptions -fno-rtti
+AM_LDFLAGS = -fno-exceptions -fno-rtti
+
+check_PROGRAMS = outest
+
+outest_SOURCES = outest.cpp
+
+outest_LDADD = $(top_builddir)/src/ou/libou.la
+
diff --git a/libs/ode-0.16.1/ou/test/Makefile.in b/libs/ode-0.16.1/ou/test/Makefile.in
new file mode 100644
index 0000000..0c299c5
--- /dev/null
+++ b/libs/ode-0.16.1/ou/test/Makefile.in
@@ -0,0 +1,589 @@
+# Makefile.in generated by automake 1.15 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2014 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+check_PROGRAMS = outest$(EXEEXT)
+subdir = test
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am_outest_OBJECTS = outest.$(OBJEXT)
+outest_OBJECTS = $(am_outest_OBJECTS)
+outest_DEPENDENCIES = $(top_builddir)/src/ou/libou.la
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 = 
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+DEFAULT_INCLUDES = -I.@am__isrc@
+depcomp = $(SHELL) $(top_srcdir)/../depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo "  CXX     " $@;
+am__v_CXX_1 = 
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+	$(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo "  CXXLD   " $@;
+am__v_CXXLD_1 = 
+SOURCES = $(outest_SOURCES)
+DIST_SOURCES = $(outest_SOURCES)
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/../depcomp
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+OU_FEATURE_SET = @OU_FEATURE_SET@
+OU_NAMESPACE = @OU_NAMESPACE@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(top_srcdir)/include
+AM_CXXFLAGS = -fno-exceptions -fno-rtti
+AM_LDFLAGS = -fno-exceptions -fno-rtti
+outest_SOURCES = outest.cpp
+outest_LDADD = $(top_builddir)/src/ou/libou.la
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cpp .lo .o .obj
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign test/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign test/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+clean-checkPROGRAMS:
+	@list='$(check_PROGRAMS)'; test -n "$$list" || exit 0; \
+	echo " rm -f" $$list; \
+	rm -f $$list || exit $$?; \
+	test -n "$(EXEEXT)" || exit 0; \
+	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+	echo " rm -f" $$list; \
+	rm -f $$list
+
+outest$(EXEEXT): $(outest_OBJECTS) $(outest_DEPENDENCIES) $(EXTRA_outest_DEPENDENCIES) 
+	@rm -f outest$(EXEEXT)
+	$(AM_V_CXXLD)$(CXXLINK) $(outest_OBJECTS) $(outest_LDADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/outest.Po@am__quote@
+
+.cpp.o:
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cpp.obj:
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cpp.lo:
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LTCXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+	$(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	set x; \
+	here=`pwd`; \
+	$(am__define_uniq_tagged_files); \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	$(am__define_uniq_tagged_files); \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+	list='$(am__tagged_files)'; \
+	case "$(srcdir)" in \
+	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+	  *) sdir=$(subdir)/$(srcdir) ;; \
+	esac; \
+	for i in $$list; do \
+	  if test -f "$$i"; then \
+	    echo "$(subdir)/$$i"; \
+	  else \
+	    echo "$$sdir/$$i"; \
+	  fi; \
+	done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
+check: check-am
+all-am: Makefile
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-checkPROGRAMS clean-generic clean-libtool \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am:
+
+.MAKE: check-am install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
+	clean-checkPROGRAMS clean-generic clean-libtool cscopelist-am \
+	ctags ctags-am distclean distclean-compile distclean-generic \
+	distclean-libtool distclean-tags distdir dvi dvi-am html \
+	html-am info info-am install install-am install-data \
+	install-data-am install-dvi install-dvi-am install-exec \
+	install-exec-am install-html install-html-am install-info \
+	install-info-am install-man install-pdf install-pdf-am \
+	install-ps install-ps-am install-strip installcheck \
+	installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-compile \
+	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+	tags tags-am uninstall uninstall-am
+
+.PRECIOUS: Makefile
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/libs/ode-0.16.1/ou/test/outest.cpp b/libs/ode-0.16.1/ou/test/outest.cpp
new file mode 100644
index 0000000..2ddfdef
--- /dev/null
+++ b/libs/ode-0.16.1/ou/test/outest.cpp
@@ -0,0 +1,9027 @@
+/*************************************************************************
+ *                                                                       *
+ * ODER's Utilities Library. Copyright (C) 2008 Oleh Derevenko.          *
+ * All rights reserved.  e-mail: odar@eleks.com (change all "a" to "e")  *
+ *                                                                       *
+ * This library is free software; you can redistribute it and/or         *
+ * modify it under the terms of EITHER:                                  *
+ *   (1) The GNU Lesser General Public License as published by the Free  *
+ *       Software Foundation; either version 3 of the License, or (at    *
+ *       your option) any later version. The text of the GNU Lesser      *
+ *       General Public License is included with this library in the     *
+ *       file LICENSE-LESSER.TXT. Since LGPL is the extension of GPL     *
+ *       the text of GNU General Public License is also provided for     *
+ *       your information in file LICENSE.TXT.                           *
+ *   (2) The BSD-style license that is included with this library in     *
+ *       the file LICENSE-BSD.TXT.                                       *
+ *   (3) The zlib/libpng license that is included with this library in   *
+ *       the file LICENSE-ZLIB.TXT                                       *
+ *                                                                       *
+ * This library is distributed WITHOUT ANY WARRANTY, including implied   *
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.      *
+ * See the files LICENSE.TXT and LICENSE-LESSER.TXT or LICENSE-BSD.TXT   *
+ * or LICENSE-ZLIB.TXT for more details.                                 *
+ *                                                                       *
+ *************************************************************************/
+
+#include <ou/features.h>
+#include <ou/platform.h>
+
+#if _OU_COMPILER == _OU_COMPILER_MSVC
+
+#pragma warning(disable:4786)
+
+
+#endif
+
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_TLS
+#include <ou/threadlocalstorage.h>
+#endif
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS
+#include <ou/atomic.h>
+#endif
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS
+#include <ou/atomicflags.h>
+#endif
+#include <ou/simpleflags.h>
+#include <ou/flagsdefines.h>
+#include <ou/enumarrays.h>
+#include <ou/templates.h>
+#include <ou/typewrapper.h>
+#include <ou/customization.h>
+#include <ou/inttypes.h>
+#include <ou/macros.h>
+#include <ou/malloc.h>
+
+#include <ou/namespace.h>
+using namespace _OU_NAMESPACE;
+
+#include <stdio.h>
+#include <string.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+
+typedef bool (*CFeatureTestProcedure)();
+
+
+bool TestSubsystem(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount,
+	const unsigned int uiFeatureMax, const char *const *aszFeatureNames, CFeatureTestProcedure const *afnFeatureTests)
+{
+	unsigned int nSuccessCount = 0;
+	
+	for (unsigned int uiSubsystemFeature = 0; uiSubsystemFeature != uiFeatureMax; ++uiSubsystemFeature)
+	{
+		const char *szFeatureName = aszFeatureNames[uiSubsystemFeature];
+		printf("Testing %34s: ", szFeatureName);
+		
+		CFeatureTestProcedure fnTestProcedure = afnFeatureTests[uiSubsystemFeature];
+		bool bTestResult = fnTestProcedure();
+		printf("%s\n", bTestResult ? "success" : "*** failure ***");
+		
+		if (bTestResult)
+		{
+			nSuccessCount += 1;
+		}
+	}
+	
+	nOutSuccessCount = nSuccessCount;
+	nOutTestCount = uiFeatureMax;
+	return nSuccessCount == uiFeatureMax;
+}
+
+
+
+//////////////////////////////////////////////////////////////////////////
+
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_TLS
+
+bool g_bTestTLSAPIInitialized = false;
+HTLSKEY g_htkTestTLSKey;
+
+enum ETESTTLSVALUES
+{
+	TTV_FIRSTVALUE,
+	TTV_SECONDVALUE,
+
+	TTV__MAX,
+};
+
+unsigned int g_uiTestTLSDestructorCallCount = 0;
+unsigned int g_uiTestTLSDestructorSuccessCount = 0;
+
+void _OU_CONVENTION_CALLBACK TestTlsSecondValueDestructor(void *pv_Value)
+{
+	g_uiTestTLSDestructorCallCount += 1;
+
+	if (pv_Value == (void *)(&TestTlsSecondValueDestructor))
+	{
+		g_uiTestTLSDestructorSuccessCount += 1;
+	}
+}
+
+
+bool TestTls_Initialization()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (!CTLSInitialization::InitializeTLSAPI(g_htkTestTLSKey, 1, 0))
+		{
+			break;
+		}
+
+		CTLSInitialization::FinalizeTLSAPI();
+
+		if (!CTLSInitialization::InitializeTLSAPI(g_htkTestTLSKey, TTV__MAX, CTLSInitialization::SIF_MANUAL_CLEANUP_ON_THREAD_EXIT))
+		{
+			break;
+		}
+
+		g_bTestTLSAPIInitialized = true;
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestTls_GetSetValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		tlsvaluetype vtFirstValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE);
+
+		if (vtFirstValue != 0)
+		{
+			break;
+		}
+	
+		tlsvaluetype vtSecondValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE);
+		
+		if (vtSecondValue != 0)
+		{
+			break;
+		}
+
+		if (!CThreadLocalStorage::SetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE, (tlsvaluetype)&TestTls_GetSetValue))
+		{
+			break;
+		}
+		
+		if (!CThreadLocalStorage::SetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, (tlsvaluetype)&TestTlsSecondValueDestructor, &TestTlsSecondValueDestructor))
+		{
+			break;
+		}
+
+		vtFirstValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE);
+
+		if ((void *)vtFirstValue != &TestTls_GetSetValue)
+		{
+			break;
+		}
+
+		vtSecondValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE);
+
+		if ((void *)vtSecondValue != &TestTlsSecondValueDestructor)
+		{
+			break;
+		}
+		
+		if (!CThreadLocalStorage::SetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, 0, &TestTlsSecondValueDestructor))
+		{
+			break;
+		}
+
+		vtSecondValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE);
+		
+		if (vtSecondValue != 0)
+		{
+			break;
+		}
+		
+		if (!CThreadLocalStorage::SetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, (tlsvaluetype)&TestTlsSecondValueDestructor, &TestTlsSecondValueDestructor))
+		{
+			break;
+		}
+		
+		if (g_uiTestTLSDestructorCallCount != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestTls_UnsafeGetSetValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		tlsvaluetype vtFirstValue = CThreadLocalStorage::UnsafeGetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE);
+		
+		if ((void *)vtFirstValue != &TestTls_GetSetValue)
+		{
+			break;
+		}
+		
+		tlsvaluetype vtSecondValue = CThreadLocalStorage::UnsafeGetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE);
+		
+		if ((void *)vtSecondValue != &TestTlsSecondValueDestructor)
+		{
+			break;
+		}
+
+		CThreadLocalStorage::UnsafeSetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE, (tlsvaluetype)(size_t)(-1));
+		CThreadLocalStorage::UnsafeSetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, (tlsvaluetype)(size_t)(-1));
+
+		vtFirstValue = CThreadLocalStorage::UnsafeGetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE);
+		
+		if ((size_t)vtFirstValue != (size_t)(-1))
+		{
+			break;
+		}
+		
+		vtSecondValue = CThreadLocalStorage::UnsafeGetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE);
+		
+		if ((size_t)vtSecondValue != (size_t)(-1))
+		{
+			break;
+		}
+		
+		// Safe function used by intent !!!
+		vtFirstValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE);
+		
+		if ((size_t)vtFirstValue != (size_t)(-1))
+		{
+			break;
+		}
+		
+		// Safe function used by intent !!!
+		vtSecondValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE);
+		
+		if ((size_t)vtSecondValue != (size_t)(-1))
+		{
+			break;
+		}
+	
+		CThreadLocalStorage::UnsafeSetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, (tlsvaluetype)(&TestTlsSecondValueDestructor));
+
+		if (g_uiTestTLSDestructorCallCount != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestTls_CleanupDestructor()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CTLSInitialization::CleanupOnThreadExit();
+
+		if (g_uiTestTLSDestructorCallCount != 1 || g_uiTestTLSDestructorSuccessCount != 1)
+		{
+			break;
+		}
+		
+		tlsvaluetype vtFirstValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE);
+		
+		if (vtFirstValue != 0)
+		{
+			break;
+		}
+		
+		// Safe function used by intent !!!
+		tlsvaluetype vtSecondValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE);
+		
+		if (vtSecondValue != 0)
+		{
+			break;
+		}
+
+		g_uiTestTLSDestructorCallCount = 0;
+		g_uiTestTLSDestructorSuccessCount = 0;
+
+		CTLSInitialization::CleanupOnThreadExit();
+		
+		if (g_uiTestTLSDestructorCallCount != 0)
+		{
+			break;
+		}
+		
+		if (!CThreadLocalStorage::SetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, 0, &TestTlsSecondValueDestructor))
+		{
+			break;
+		}
+	
+		CTLSInitialization::CleanupOnThreadExit();
+		
+		if (g_uiTestTLSDestructorCallCount != 0)
+		{
+			break;
+		}
+		
+		if (!CThreadLocalStorage::SetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, (tlsvaluetype)(size_t)(-1), &TestTlsSecondValueDestructor))
+		{
+			break;
+		}
+		
+		if (g_uiTestTLSDestructorCallCount != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestTls_Finalization()
+{
+	OU_ASSERT(g_bTestTLSAPIInitialized);
+
+	bool bResult = false;
+	
+	do
+	{
+		CTLSInitialization::FinalizeTLSAPI();
+		
+		g_bTestTLSAPIInitialized = false;
+
+		if (g_uiTestTLSDestructorCallCount != 1 || g_uiTestTLSDestructorSuccessCount != 0)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+
+enum EOUTLSFEATURE
+{
+	OHF__MIN,
+	
+	OHF_INITIALIZATION = OHF__MIN,
+	OHF_GETSETVALUE,
+	OHF_UNSAFEGETSETVALUE,
+	OHF_CLEANUPDESTRUCTOR,
+	OHF_FINALIZATION,
+	
+	OHF__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUTLSFEATURE, OHF__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestTls_Initialization, // OHF_INITIALIZATION
+	&TestTls_GetSetValue, // OHF_GETSETVALUE,
+	&TestTls_UnsafeGetSetValue, // OHF_UNSAFEGETSETVALUE,
+	&TestTls_CleanupDestructor, // OHF_CLEANUPDESTRUCTOR,
+	&TestTls_Finalization, // OHF_FINALIZATION,
+};
+static const CEnumUnsortedElementArray<EOUTLSFEATURE, OHF__MAX, CFeatureTestProcedure> g_afnTlsFeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUTLSFEATURE, OHF__MAX, const char *>::m_aetElementArray[] =
+{
+	"API Initialization", // OHF_INITIALIZATION
+	"Get.../SetStorageValue", // OHF_GETSETVALUE,
+	"UnsafeGet.../UnsafeSetStorageValue", // OHF_UNSAFEGETSETVALUE,
+	"Storage Cleanup/Value Destructors", // OHF_CLEANUPDESTRUCTOR,
+	"API Finalization", // OHF_FINALIZATION,
+};
+static const CEnumUnsortedElementArray<EOUTLSFEATURE, OHF__MAX, const char *> g_aszTlsFeatureTestNames;
+
+
+bool TestTLS(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	bool bResult = TestSubsystem(nOutSuccessCount, nOutTestCount, OHF__MAX, g_aszTlsFeatureTestNames.GetStoragePointer(), g_afnTlsFeatureTestProcedures.GetStoragePointer());
+
+	if (g_bTestTLSAPIInitialized)
+	{
+		CTLSInitialization::FinalizeTLSAPI();
+	}
+	
+	return bResult;
+}
+
+
+#endif // #if _OU_FEATURE_SET >= _OU_FEATURE_SET_TLS
+
+
+//////////////////////////////////////////////////////////////////////////
+
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS
+
+bool TestAtomic_Increment()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = (atomicord32)(-1);
+
+		// Putting function inside of conditional operator causes
+		// incorrect code generation by GCC 4.0.1 on MacOS X Leopard 64 bit.
+		atomicord32 aoIncrementFirstResult = AtomicIncrement(&aoStorage);
+		if (aoIncrementFirstResult != 0 || aoStorage != (atomicord32)0)
+		{
+			break;
+		}
+		
+		if (AtomicIncrement(&aoStorage) != (atomicord32)1 || aoStorage != (atomicord32)1)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_Decrement()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = (atomicord32)1;
+		
+		// Putting function inside of conditional operator causes
+		// incorrect code generation by GCC 4.0.1 on MacOS X Leopard 64 bit.
+		atomicord32 aoDecrementFirstResult = AtomicDecrement(&aoStorage);
+		if (aoDecrementFirstResult != (atomicord32)0 || aoStorage != (atomicord32)0)
+		{
+			break;
+		}
+		
+		if (AtomicDecrement(&aoStorage) != (atomicord32)(-1) || aoStorage != (atomicord32)(-1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_IncrementNoResult()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = (atomicord32)(-1);
+		
+		AtomicIncrementNoResult(&aoStorage);
+
+		if (aoStorage != (atomicord32)0)
+		{
+			break;
+		}
+		
+		AtomicIncrementNoResult(&aoStorage);
+
+		if (aoStorage != (atomicord32)1)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_DecrementNoResult()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = (atomicord32)1;
+		
+		AtomicDecrementNoResult(&aoStorage);
+
+		if (aoStorage != (atomicord32)0)
+		{
+			break;
+		}
+		
+		AtomicDecrementNoResult(&aoStorage);
+
+		if (aoStorage != (atomicord32)(-1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_Exchange()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = 0;
+
+		if (AtomicExchange(&aoStorage, (atomicord32)1) != 0 || aoStorage != (atomicord32)1)
+		{
+			break;
+		}
+		
+		if (AtomicExchange(&aoStorage, (atomicord32)(-1)) != (atomicord32)1 || aoStorage != (atomicord32)(-1))
+		{
+			break;
+		}
+		
+		if (AtomicExchange(&aoStorage, 0) != (atomicord32)(-1) || aoStorage != 0)
+		{
+			break;
+		}
+		
+		if (AtomicExchange(&aoStorage, 0) != 0 || aoStorage != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+
+}
+
+bool TestAtomic_ExchangeAdd()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = 0;
+
+		if (AtomicExchangeAdd(&aoStorage, (atomicord32)1) != 0 || aoStorage != (atomicord32)1)
+		{
+			break;
+		}
+		
+		if (AtomicExchangeAdd(&aoStorage, (atomicord32)(-2)) != 1 || aoStorage != (atomicord32)(-1))
+		{
+			break;
+		}
+		
+		if (AtomicExchangeAdd(&aoStorage, (atomicord32)1) != (atomicord32)(-1) || aoStorage != 0)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_ExchangeAddNoResult()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = 0;
+		
+		AtomicExchangeAddNoResult(&aoStorage, (atomicord32)1);
+		
+		if (aoStorage != (atomicord32)1)
+		{
+			break;
+		}
+		
+		AtomicExchangeAddNoResult(&aoStorage, (atomicord32)(-2));
+
+		if (aoStorage != (atomicord32)(-1))
+		{
+			break;
+		}
+		
+		AtomicExchangeAddNoResult(&aoStorage, (atomicord32)1);
+		
+		if (aoStorage != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_CompareExchange()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = 0;
+
+		if (AtomicCompareExchange(&aoStorage, 1, 1) || aoStorage != 0)
+		{
+			break;
+		}
+		
+		if (!AtomicCompareExchange(&aoStorage, 0, 1) || aoStorage != 1)
+		{
+			break;
+		}
+		
+		if (!AtomicCompareExchange(&aoStorage, 1, 1) || aoStorage != 1)
+		{
+			break;
+		}
+		
+		if (!AtomicCompareExchange(&aoStorage, 1, (atomicord32)(-1)) || aoStorage != (atomicord32)(-1))
+		{
+			break;
+		}
+		
+		if (AtomicCompareExchange(&aoStorage, 1, (atomicord32)(-1)) || aoStorage != (atomicord32)(-1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+const atomicord32 g_aoBitmask = (atomicord32)(OU_INT32_MIN + 1);
+
+bool TestAtomic_And()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = (atomicord32)OU_UINT32_MAX;
+
+		if (AtomicAnd(&aoStorage, g_aoBitmask) != (atomicord32)OU_UINT32_MAX || aoStorage != g_aoBitmask)
+		{
+			break;
+		}
+
+		if (AtomicAnd(&aoStorage, 0) != g_aoBitmask || aoStorage != 0)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_Or()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = 0;
+		
+		if (AtomicOr(&aoStorage, g_aoBitmask) != 0 || aoStorage != g_aoBitmask)
+		{
+			break;
+		}
+		
+		if (AtomicOr(&aoStorage, (atomicord32)OU_UINT32_MAX) != g_aoBitmask || aoStorage != (atomicord32)OU_UINT32_MAX)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_Xor()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = 0;
+		
+		if (AtomicXor(&aoStorage, g_aoBitmask) != 0 || aoStorage != g_aoBitmask)
+		{
+			break;
+		}
+		
+		if (AtomicXor(&aoStorage, (atomicord32)OU_UINT32_MAX) != g_aoBitmask || aoStorage != (atomicord32)(OU_UINT32_MAX ^ g_aoBitmask))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_AndNoResult()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = (atomicord32)OU_UINT32_MAX;
+		
+		AtomicAndNoResult(&aoStorage, g_aoBitmask);
+
+		if (aoStorage != g_aoBitmask)
+		{
+			break;
+		}
+		
+		AtomicAndNoResult(&aoStorage, 0);
+
+		if (aoStorage != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_OrNoResult()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = 0;
+		
+		AtomicOrNoResult(&aoStorage, g_aoBitmask);
+
+		if (aoStorage != g_aoBitmask)
+		{
+			break;
+		}
+		
+		AtomicOrNoResult(&aoStorage, (atomicord32)OU_UINT32_MAX);
+
+		if (aoStorage != (atomicord32)OU_UINT32_MAX)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_XorNoResult()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicord32 aoStorage = 0;
+		
+		AtomicXorNoResult(&aoStorage, g_aoBitmask);
+
+		if (aoStorage != g_aoBitmask)
+		{
+			break;
+		}
+		
+		AtomicXorNoResult(&aoStorage, (atomicord32)OU_UINT32_MAX);
+
+		if (aoStorage != (atomicord32)(OU_UINT32_MAX ^ g_aoBitmask))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_ExchangePointer()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicptr apStorage = NULL;
+
+		if (AtomicExchangePointer(&apStorage, (atomicptr)(&TestAtomic_ExchangePointer)) != NULL || apStorage != (atomicptr)(&TestAtomic_ExchangePointer))
+		{
+			break;
+		}
+	
+		if (AtomicExchangePointer(&apStorage, (atomicptr)(&apStorage)) != (atomicptr)(&TestAtomic_ExchangePointer) || apStorage != (atomicptr)(&apStorage))
+		{
+			break;
+		}
+		
+		if (AtomicExchangePointer(&apStorage, NULL) != (atomicptr)(&apStorage) || apStorage != NULL)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomic_CompareExchangePointer()
+{
+	bool bResult = false;
+	
+	do
+	{
+		volatile atomicptr apStorage = NULL;
+		
+		if (AtomicCompareExchangePointer(&apStorage, (atomicptr)(&TestAtomic_CompareExchangePointer), (atomicptr)(&TestAtomic_CompareExchangePointer)) || apStorage != NULL)
+		{
+			break;
+		}
+		
+		if (!AtomicCompareExchangePointer(&apStorage, NULL, (atomicptr)(&TestAtomic_CompareExchangePointer)) || apStorage != (atomicptr)(&TestAtomic_CompareExchangePointer))
+		{
+			break;
+		}
+		
+		if (!AtomicCompareExchangePointer(&apStorage, (atomicptr)(&TestAtomic_CompareExchangePointer), (atomicptr)(&apStorage)) || apStorage != (atomicptr)(&apStorage))
+		{
+			break;
+		}
+		
+		if (!AtomicCompareExchangePointer(&apStorage, (atomicptr)(&apStorage), (atomicptr)(&apStorage)) || apStorage != (atomicptr)(&apStorage))
+		{
+			break;
+		}
+		
+		if (AtomicCompareExchangePointer(&apStorage, NULL, NULL) || apStorage != (atomicptr)(&apStorage))
+		{
+			break;
+		}
+		
+		if (!AtomicCompareExchangePointer(&apStorage, (atomicptr)(&apStorage), NULL) || apStorage != NULL)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+
+enum EOUATOMICFEATURE
+{
+	OOF__MIN,
+		
+	OOF_INCREMENT = OOF__MIN,
+	OOF_DECREMENT,
+	OOF_INCREMENTNORESULT,
+	OOF_DECREMENTNORESULT,
+	OOF_EXCHANGE,
+	OOF_EXCHANGEADD,
+	OOF_EXCHANGEADDNORESULT,
+	OOF_COMPAREEXCHANGE,
+	OOF_AND,
+	OOF_OR,
+	OOF_XOR,
+	OOF_ANDNORESULT,
+	OOF_ORNORESULT,
+	OOF_XORNORESULT,
+	OOF_EXCHANGEPOINTER,
+	OOF_COMPAREEXCHANGEPOINTER,
+	
+	OOF__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUATOMICFEATURE, OOF__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestAtomic_Increment, // OOF_INCREMENT,
+	&TestAtomic_Decrement, // OOF_DECREMENT,
+	&TestAtomic_IncrementNoResult, // OOF_INCREMENTNORESULT,
+	&TestAtomic_DecrementNoResult, // OOF_DECREMENTNORESULT,
+	&TestAtomic_Exchange, // OOF_EXCHANGE,
+	&TestAtomic_ExchangeAdd, // OOF_EXCHANGEADD,
+	&TestAtomic_ExchangeAddNoResult, // OOF_EXCHANGEADDNORESULT,
+	&TestAtomic_CompareExchange, // OOF_COMPAREEXCHANGE,
+	&TestAtomic_And, // OOF_AND,
+	&TestAtomic_Or, // OOF_OR,
+	&TestAtomic_Xor, // OOF_XOR,
+	&TestAtomic_AndNoResult, // OOF_ANDNORESULT,
+	&TestAtomic_OrNoResult, // OOF_ORNORESULT,
+	&TestAtomic_XorNoResult, // OOF_XORNORESULT,
+	&TestAtomic_ExchangePointer, // OOF_EXCHANGEPOINTER,
+	&TestAtomic_CompareExchangePointer, // OOF_COMPAREEXCHANGEPOINTER,
+};
+static const CEnumUnsortedElementArray<EOUATOMICFEATURE, OOF__MAX, CFeatureTestProcedure> g_afnAtomicFeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUATOMICFEATURE, OOF__MAX, const char *>::m_aetElementArray[] =
+{
+	"AtomicIncrement", // OOF_INCREMENT,
+	"AtomicDecrement", // OOF_DECREMENT,
+	"AtomicIncrementNoResult", // OOF_INCREMENTNORESULT,
+	"AtomicDecrementNoResult", // OOF_DECREMENTNORESULT,
+	"AtomicExchange", // OOF_EXCHANGE,
+	"AtomicExchangeAdd", // OOF_EXCHANGEADD,
+	"AtomicExchangeAddNoResult", // OOF_EXCHANGEADDNORESULT,
+	"AtomicCompareExchange", // OOF_COMPAREEXCHANGE,
+	"AtomicAnd", // OOF_AND,
+	"AtomicOr", // OOF_OR,
+	"AtomicXor", // OOF_XOR,
+	"AtomicAndNoResult", // OOF_ANDNORESULT,
+	"AtomicOrNoResult", // OOF_ORNORESULT,
+	"AtomicXorNoResult", // OOF_XORNORESULT,
+	"AtomicExchangePointer", // OOF_EXCHANGEPOINTER,
+	"AtomicCompareExchangePointer", // OOF_COMPAREEXCHANGEPOINTER,
+};
+static const CEnumUnsortedElementArray<EOUATOMICFEATURE, OOF__MAX, const char *> g_aszAtomicFeatureTestNames;
+
+
+bool TestAtomic(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	bool bResult = false;
+	nOutSuccessCount = 0;
+	nOutTestCount = OOF__MAX;
+
+	bool bAPIInitialized = false;
+	
+	do
+	{
+		if (!InitializeAtomicAPI())
+		{
+			break;
+		}
+		
+		bAPIInitialized = true;
+
+		if (!TestSubsystem(nOutSuccessCount, nOutTestCount, OOF__MAX, g_aszAtomicFeatureTestNames.GetStoragePointer(), g_afnAtomicFeatureTestProcedures.GetStoragePointer()))
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+	
+	if (bAPIInitialized)
+	{
+		FinalizeAtomicAPI();
+	}
+
+	return bResult;
+}
+
+
+#endif // #if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS
+
+
+//////////////////////////////////////////////////////////////////////////
+
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS
+
+const atomicord32 g_aoTestValue32 = (atomicord32)0xA5A5A5A5;
+const atomicord32 g_aoTestMask32 = (atomicord32)0xC6C6C6C6;
+const atomicord32 g_aoTestBit32 = (atomicord32)OU_INT32_MIN;
+const atomicord32 g_aoTestAnotherBit32 = (atomicord32)((uint32ou)OU_INT32_MIN >> 1);
+
+
+bool TestAtomicFlags_Constructors()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(CAtomicFlags::value_type) != sizeof(atomicord32))
+		{
+			break;
+		}
+
+		CAtomicFlags afEmptyFlags;
+
+		if (afEmptyFlags.QueryFlagsAllValues())
+		{
+			break;
+		}
+
+		CAtomicFlags afFullFlags(OU_UINT32_MAX);
+		
+		if (afFullFlags.QueryFlagsAllValues() != (atomicord32)OU_UINT32_MAX)
+		{
+			break;
+		}
+
+		CAtomicFlags afCopyOfFullFlags(afFullFlags);
+
+		if (afCopyOfFullFlags.QueryFlagsAllValues() != (atomicord32)OU_UINT32_MAX)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_AssignFlagsAllValues()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags;
+
+		afTestFlags.AssignFlagsAllValues(OU_UINT32_MAX);
+
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)OU_UINT32_MAX)
+		{
+			break;
+		}
+
+		afTestFlags.AssignFlagsAllValues(0);
+
+		if (afTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_QueryFlagsAllValues()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(g_aoTestValue32);
+		
+		if (afTestFlags.QueryFlagsAllValues() != g_aoTestValue32)
+		{
+			break;
+		}
+
+		// Double check to be sure ;-)
+		if (afTestFlags.QueryFlagsAllValues() != g_aoTestValue32)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_SetFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(g_aoTestValue32);
+
+		afTestFlags.SetFlagsMaskValue(g_aoTestMask32, true);
+
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(g_aoTestValue32 | g_aoTestMask32))
+		{
+			break;
+		}
+
+		afTestFlags.SetFlagsMaskValue(g_aoTestValue32, false);
+
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(~g_aoTestValue32 & g_aoTestMask32))
+		{
+			break;
+		}
+		
+
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_SignalFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(g_aoTestValue32);
+		
+		afTestFlags.SignalFlagsMaskValue(g_aoTestMask32);
+		
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(g_aoTestValue32 | g_aoTestMask32))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_DropFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(g_aoTestValue32);
+		
+		afTestFlags.DropFlagsMaskValue(g_aoTestMask32);
+		
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(g_aoTestValue32 & ~g_aoTestMask32))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_ToggleSingleFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(g_aoTestValue32);
+		
+		bool bPreviousValue = afTestFlags.ToggleSingleFlagValue(g_aoTestBit32);
+		
+		if (bPreviousValue != ((g_aoTestValue32 & g_aoTestBit32) != 0) || afTestFlags.QueryFlagsAllValues() != (atomicord32)(g_aoTestValue32 ^ g_aoTestBit32))
+		{
+			break;
+		}
+
+		bool bAnotherPreviousValue = afTestFlags.ToggleSingleFlagValue(g_aoTestBit32);
+		
+		if (bAnotherPreviousValue == bPreviousValue || afTestFlags.QueryFlagsAllValues() != g_aoTestValue32)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_ModifySingleFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(g_aoTestValue32);
+		
+		bool bFirstModification = afTestFlags.ModifySingleFlagValue(g_aoTestBit32, true);
+		
+		if (bFirstModification != ((g_aoTestValue32 & g_aoTestBit32) != g_aoTestBit32) || afTestFlags.QueryFlagsAllValues() != (atomicord32)(g_aoTestValue32 | g_aoTestBit32))
+		{
+			break;
+		}
+		
+		bool bAnotherModification = afTestFlags.ModifySingleFlagValue(g_aoTestBit32, bFirstModification);
+		
+		if (bAnotherModification == bFirstModification || afTestFlags.QueryFlagsAllValues() != (bFirstModification ? (atomicord32)(g_aoTestValue32 | g_aoTestBit32) : (atomicord32)(g_aoTestValue32 & ~g_aoTestBit32)))
+		{
+			break;
+		}
+
+		bool bYetAnotherModification = afTestFlags.ModifySingleFlagValue(g_aoTestBit32, bAnotherModification);
+
+		if (bYetAnotherModification != bAnotherModification || afTestFlags.QueryFlagsAllValues() != (bAnotherModification ? (atomicord32)(g_aoTestValue32 | g_aoTestBit32) : (atomicord32)(g_aoTestValue32 & ~g_aoTestBit32)))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_AssignFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(g_aoTestValue32);
+
+		atomicord32 aoPreviousFlags = afTestFlags.AssignFlagsByMask(g_aoTestMask32, g_aoTestMask32);
+
+		const atomicord32 aoNewFlags = (g_aoTestValue32 & ~g_aoTestMask32) | g_aoTestMask32;
+
+		if (aoPreviousFlags != g_aoTestValue32 || afTestFlags.QueryFlagsAllValues() != aoNewFlags)
+		{
+			break;
+		}
+
+		atomicord32 aoAnotherPreviousFlags = afTestFlags.AssignFlagsByMask(g_aoTestValue32, 0);
+
+		const atomicord32 aoAnotherNewFlags = aoNewFlags & ~g_aoTestValue32;
+
+		if (aoAnotherPreviousFlags != aoNewFlags || afTestFlags.QueryFlagsAllValues() != aoAnotherNewFlags)
+		{
+			break;
+		}
+	
+		atomicord32 aoYetAnotherPreviousFlags = afTestFlags.AssignFlagsByMask(g_aoTestMask32, g_aoTestMask32 & g_aoTestValue32);
+		OU_ASSERT((g_aoTestMask32 & g_aoTestValue32) != 0); // Test degeneration
+		
+		const atomicord32 aoYetAnotherNewFlags = (aoAnotherNewFlags & ~g_aoTestMask32) | (g_aoTestMask32 & g_aoTestValue32);
+		OU_ASSERT(aoYetAnotherNewFlags != (atomicord32)OU_UINT32_MAX); // Test degeneration
+		
+		if (aoYetAnotherPreviousFlags != aoAnotherNewFlags || afTestFlags.QueryFlagsAllValues() != aoYetAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_AlterFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(g_aoTestValue32);
+		
+		bool bWasModification = afTestFlags.AlterFlagsByMask(g_aoTestMask32, g_aoTestMask32);
+		
+		const atomicord32 aoNewFlags = (g_aoTestValue32 & ~g_aoTestMask32) | g_aoTestMask32;
+		
+		if (bWasModification != ((g_aoTestValue32 & g_aoTestMask32) != g_aoTestMask32) || afTestFlags.QueryFlagsAllValues() != aoNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasAnotherModification = afTestFlags.AlterFlagsByMask(g_aoTestValue32, 0);
+		
+		const atomicord32 aoAnotherNewFlags = aoNewFlags & ~g_aoTestValue32;
+		
+		if (bWasAnotherModification != ((aoNewFlags & g_aoTestValue32) != 0) || afTestFlags.QueryFlagsAllValues() != aoAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasAnotherModificationRepeated = afTestFlags.AlterFlagsByMask(g_aoTestValue32, 0);
+		
+		if (bWasAnotherModificationRepeated || afTestFlags.QueryFlagsAllValues() != aoAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasYetAnotherModification = afTestFlags.AlterFlagsByMask(g_aoTestMask32, g_aoTestMask32 & g_aoTestValue32);
+		OU_ASSERT((g_aoTestMask32 & g_aoTestValue32) != 0); // Test degeneration
+		
+		const atomicord32 aoYetAnotherNewFlags = (aoAnotherNewFlags & ~g_aoTestMask32) | (g_aoTestMask32 & g_aoTestValue32);
+		OU_ASSERT(aoYetAnotherNewFlags != (atomicord32)OU_UINT32_MAX); // Test degeneration
+		
+		if (bWasYetAnotherModification != ((aoAnotherNewFlags & g_aoTestMask32) != (g_aoTestMask32 & g_aoTestValue32)) || afTestFlags.QueryFlagsAllValues() != aoYetAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_GetFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(g_aoTestValue32);
+		
+		if (afTestFlags.GetFlagsMaskValue(g_aoTestMask32) != ((g_aoTestValue32 & g_aoTestMask32) != 0))
+		{
+			break;
+		}
+		
+		if (afTestFlags.GetFlagsMaskValue(~g_aoTestValue32))
+		{
+			break;
+		}
+		
+		if (!afTestFlags.GetFlagsMaskValue(OU_UINT32_MAX))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_QueryFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(g_aoTestValue32);
+		
+		if (afTestFlags.QueryFlagsByMask(g_aoTestMask32) != (atomicord32)(g_aoTestValue32 & g_aoTestMask32))
+		{
+			break;
+		}
+		
+		if (afTestFlags.QueryFlagsByMask(0))
+		{
+			break;
+		}
+		
+		if (afTestFlags.QueryFlagsByMask(OU_UINT32_MAX) != g_aoTestValue32)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_OnlySignalSingleFlagOutOfMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(g_aoTestValue32);
+		OU_ASSERT(g_aoTestValue32 != 0); // Test degeneration
+		
+		if (afTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT32_MAX, g_aoTestBit32))
+		{
+			break;
+		}
+
+		if (afTestFlags.QueryFlagsAllValues() != g_aoTestValue32)
+		{
+			break;
+		}
+		
+		afTestFlags.AssignFlagsAllValues(0);
+
+		if (!afTestFlags.OnlySignalSingleFlagOutOfMask(g_aoTestBit32, g_aoTestBit32))
+		{
+			break;
+		}
+		
+		if (afTestFlags.QueryFlagsAllValues() != g_aoTestBit32)
+		{
+			break;
+		}
+		
+		if (afTestFlags.OnlySignalSingleFlagOutOfMask(g_aoTestBit32, g_aoTestBit32))
+		{
+			break;
+		}
+		
+		if (afTestFlags.QueryFlagsAllValues() != g_aoTestBit32)
+		{
+			break;
+		}
+		
+		if (afTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT32_MAX, g_aoTestAnotherBit32))
+		{
+			break;
+		}
+		
+		if (afTestFlags.QueryFlagsAllValues() != g_aoTestBit32)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumSetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags;
+		
+		afTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT32_BITS, true);
+
+		if (afTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+	
+		afTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, true);
+		
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		afTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT32_BITS, false);
+		
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)OU_INT32_MIN)
+		{
+			break;
+		}
+		
+		afTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, false);
+		
+		if (afTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumSignalEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags;
+		
+		afTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (afTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		afTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		afTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		afTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumDropEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(OU_UINT32_MAX);
+		
+		afTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_UINT32_MAX ^ 1))
+		{
+			break;
+		}
+		
+		afTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)~(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		afTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)~(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		afTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)~(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumToggleEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags;
+		
+		bool bToggleFirstResult = afTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (bToggleFirstResult || afTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bToggleSecondResult = afTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (bToggleSecondResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bToggleThirdResult = afTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (!bToggleThirdResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)OU_INT32_MIN)
+		{
+			break;
+		}
+		
+		bool bToggleFourthResult = afTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (!bToggleFourthResult || afTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumModifyEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags;
+		
+		bool bModifyFirstResult = afTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT32_BITS, true);
+		
+		if (!bModifyFirstResult || afTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bModifySecondResult = afTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, true);
+		
+		if (!bModifySecondResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyThirdResult = afTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT32_BITS, true);
+		
+		if (bModifyThirdResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyFourthResult = afTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, true);
+		
+		if (bModifyFourthResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyFifthResult = afTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT32_BITS, false);
+		
+		if (!bModifyFifthResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)OU_INT32_MIN)
+		{
+			break;
+		}
+		
+		bool bModifySixthResult = afTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, false);
+		
+		if (!bModifySixthResult || afTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumSignalFirstEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags;
+
+		bool bFirstResult = afTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+
+		if (!bFirstResult || afTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bSecondResult = afTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (bSecondResult || afTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bThirdResult = afTestFlags.EnumSignalFirstEnumeratedFlagValue(2, 0, OU_UINT32_BITS - 1);
+		
+		if (!bThirdResult || afTestFlags.QueryFlagsAllValues() != 3)
+		{
+			break;
+		}
+		
+		bool bFourthResult = afTestFlags.EnumSignalFirstEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (bFourthResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 3))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumSignalLastEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags;
+		
+		bool bFirstResult = afTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1);
+		
+		if (!bFirstResult || afTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bSecondResult = afTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1);
+		
+		if (bSecondResult || afTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bThirdResult = afTestFlags.EnumSignalLastEnumeratedFlagValue(1, 1, 2);
+		
+		if (!bThirdResult || afTestFlags.QueryFlagsAllValues() != 3)
+		{
+			break;
+		}
+		
+		bool bFourthResult = afTestFlags.EnumSignalLastEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (bFourthResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 3))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumGetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags((atomicord32)(OU_INT32_MIN + 1));
+		
+		if (!afTestFlags.EnumGetEnumeratedFlagValue(1, 0, OU_UINT32_BITS))
+		{
+			break;
+		}
+	
+		if (afTestFlags.EnumGetEnumeratedFlagValue(2, 0, OU_UINT32_BITS - 1))
+		{
+			break;
+		}
+		
+		if (afTestFlags.EnumGetEnumeratedFlagValue(1, 1, OU_UINT32_BITS - 1))
+		{
+			break;
+		}
+		
+		if (!afTestFlags.EnumGetEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumFindFirstEnumeratedFlag()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags((atomicord32)(OU_INT32_MIN + 1));
+
+		unsigned int uiFirstResult = afTestFlags.EnumFindFirstEnumeratedFlag(1, OU_UINT32_BITS);
+		if (uiFirstResult != 0)
+		{
+			break;
+		}
+
+		unsigned int uiSecondResult = afTestFlags.EnumFindFirstEnumeratedFlag(2, OU_UINT32_BITS - 1);
+		if (uiSecondResult != OU_UINT32_BITS - 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumAllSignalEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags;
+		
+		afTestFlags.EnumAllSignalEnumeratedFlags(1, 1);
+
+		if (afTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+
+		afTestFlags.EnumAllSignalEnumeratedFlags(4, OU_UINT32_BITS - 2);
+
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_UINT32_MAX ^ 2))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumAllDropEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags(OU_UINT32_MAX);
+		
+		afTestFlags.EnumAllDropEnumeratedFlags(1, 1);
+		
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_UINT32_MAX ^ 1))
+		{
+			break;
+		}
+		
+		afTestFlags.EnumAllDropEnumeratedFlags(4, OU_UINT32_BITS - 2);
+		
+		if (afTestFlags.QueryFlagsAllValues() != 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumAllQueryEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags((atomicord32)(OU_INT32_MIN + 1));
+		
+		atomicord32 aoFirstResult = afTestFlags.EnumAllQueryEnumeratedFlags(1, OU_UINT32_BITS);
+		if (aoFirstResult != (atomicord32)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		atomicord32 aoSecondResult = afTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT32_BITS - 1);
+		if (aoSecondResult != (atomicord32)(OU_INT32_MIN))
+		{
+			break;
+		}
+		
+		atomicord32 aoThirdResult = afTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT32_BITS - 2);
+		if (aoThirdResult != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_EnumAnyGetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags((atomicord32)(OU_INT32_MIN + 1));
+		
+		bool bFirstResult = afTestFlags.EnumAnyGetEnumeratedFlagValue(1, OU_UINT32_BITS);
+		if (!bFirstResult)
+		{
+			break;
+		}
+		
+		bool bSecondResult = afTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT32_BITS - 1);
+		if (!bSecondResult)
+		{
+			break;
+		}
+		
+		bool bThirdResult = afTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT32_BITS - 2);
+		if (bThirdResult)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_StoreFlagsEnumeratedValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags;
+
+		afTestFlags.StoreFlagsEnumeratedValue(0x03, 1, 2);
+
+		if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(2 << 1))
+		{
+			break;
+		}
+	
+		afTestFlags.StoreFlagsEnumeratedValue(0x03, OU_UINT32_BITS - 2, 3);
+		
+		if (afTestFlags.QueryFlagsAllValues() != ((atomicord32)(2 << 1) | (atomicord32)(OU_INT32_MIN | (OU_INT32_MIN >> 1))))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestAtomicFlags_RetrieveFlagsEnumeratedValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CAtomicFlags afTestFlags((atomicord32)(OU_INT32_MIN + 1));
+		
+		unsigned int aoFirstResult = afTestFlags.RetrieveFlagsEnumeratedValue(0x3, 1);
+		if (aoFirstResult != 0)
+		{
+			break;
+		}
+		
+		unsigned int aoSecondResult = afTestFlags.RetrieveFlagsEnumeratedValue(0x3, OU_UINT32_BITS - 2);
+		if (aoSecondResult != 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+
+enum EOUATOMICFLAGSFEATURE
+{
+	OAF__MIN,
+		
+	OAF_CONSTRUCTORS = OAF__MIN,
+	OAF_ASSIGNFLAGSALLVALUES,
+	OAF_QUERYFLAGSALLVALUES,
+	OAF_SETFLAGSMASKVALUE,
+	OAF_SIGNALFLAGSMASKVALUE,
+	OAF_DROPFLAGSMASKVALUE,
+	OAF_TOGGLESINGLEFLAGVALUE,
+	OAF_MODIFYSINGLEFLAGVALUE,
+	OAF_ASSIGNFLAGSBYMASK,
+	OAF_ALTERFLAGSBYMASK,
+	OAF_GETFLAGSMASKVALUE,
+	OAF_QUERYFLAGSBYMASK,
+	OAF_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	OAF_ENUMSETENUMERATEDFLAGVALUE,
+	OAF_ENUMSIGNALENUMERATEDFLAGVALUE,
+	OAF_ENUMDROPENUMERATEDFLAGVALUE,
+	OAF_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	OAF_ENUMMODIFYENUMERATEDFLAGVALUE,
+	OAF_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	OAF_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	OAF_ENUMGETENUMERATEDFLAGVALUE,
+	OAF_ENUMFINDFIRSTENUMERATEDFLAG,
+	OAF_ENUMALLSIGNALENUMERATEDFLAGS,
+	OAF_ENUMALLDROPENUMERATEDFLAGS,
+	OAF_ENUMALLQUERYENUMERATEDFLAGS,
+	OAF_ENUMANYGETENUMERATEDFLAGVALUE,
+	OAF_STOREFLAGSENUMERATEDVALUE,
+	OAF_RETRIEVEFLAGSENUMERATEDVALUE,
+
+	OAF__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUATOMICFLAGSFEATURE, OAF__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestAtomicFlags_Constructors, // OAF_CONSTRUCTORS
+	&TestAtomicFlags_AssignFlagsAllValues, // OAF_ASSIGNFLAGSALLVALUES,
+	&TestAtomicFlags_QueryFlagsAllValues, // OAF_QUERYFLAGSALLVALUES,
+	&TestAtomicFlags_SetFlagsMaskValue, // OAF_SETFLAGSMASKVALUE,
+	&TestAtomicFlags_SignalFlagsMaskValue, // OAF_SIGNALFLAGSMASKVALUE,
+	&TestAtomicFlags_DropFlagsMaskValue, // OAF_DROPFLAGSMASKVALUE,
+	&TestAtomicFlags_ToggleSingleFlagValue, // OAF_TOGGLESINGLEFLAGVALUE,
+	&TestAtomicFlags_ModifySingleFlagValue, // OAF_MODIFYSINGLEFLAGVALUE,
+	&TestAtomicFlags_AssignFlagsByMask, // OAF_ASSIGNFLAGSBYMASK,
+	&TestAtomicFlags_AlterFlagsByMask, // OAF_ALTERFLAGSBYMASK,
+	&TestAtomicFlags_GetFlagsMaskValue, // OAF_GETFLAGSMASKVALUE,
+	&TestAtomicFlags_QueryFlagsByMask, // OAF_QUERYFLAGSBYMASK,
+	&TestAtomicFlags_OnlySignalSingleFlagOutOfMask, // OAF_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	&TestAtomicFlags_EnumSetEnumeratedFlagValue, // OAF_ENUMSETENUMERATEDFLAGVALUE,
+	&TestAtomicFlags_EnumSignalEnumeratedFlagValue, // OAF_ENUMSIGNALENUMERATEDFLAGVALUE,
+	&TestAtomicFlags_EnumDropEnumeratedFlagValue, // OAF_ENUMDROPENUMERATEDFLAGVALUE,
+	&TestAtomicFlags_EnumToggleEnumeratedFlagValue, // OAF_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	&TestAtomicFlags_EnumModifyEnumeratedFlagValue, // OAF_ENUMMODIFYENUMERATEDFLAGVALUE,
+	&TestAtomicFlags_EnumSignalFirstEnumeratedFlagValue, // OAF_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	&TestAtomicFlags_EnumSignalLastEnumeratedFlagValue, // OAF_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	&TestAtomicFlags_EnumGetEnumeratedFlagValue, // OAF_ENUMGETENUMERATEDFLAGVALUE,
+	&TestAtomicFlags_EnumFindFirstEnumeratedFlag, // OAF_ENUMFINDFIRSTENUMERATEDFLAG,
+	&TestAtomicFlags_EnumAllSignalEnumeratedFlags, // OAF_ENUMALLSIGNALENUMERATEDFLAGS,
+	&TestAtomicFlags_EnumAllDropEnumeratedFlags, // OAF_ENUMALLDROPENUMERATEDFLAGS,
+	&TestAtomicFlags_EnumAllQueryEnumeratedFlags, // OAF_ENUMALLQUERYENUMERATEDFLAGS,
+	&TestAtomicFlags_EnumAnyGetEnumeratedFlagValue, // OAF_ENUMANYGETENUMERATEDFLAGVALUE,
+	&TestAtomicFlags_StoreFlagsEnumeratedValue, // OAF_STOREFLAGSENUMERATEDVALUE,
+	&TestAtomicFlags_RetrieveFlagsEnumeratedValue, // OAF_RETRIEVEFLAGSENUMERATEDVALUE,
+};
+static const CEnumUnsortedElementArray<EOUATOMICFLAGSFEATURE, OAF__MAX, CFeatureTestProcedure> g_afnAtomicFlagsFeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUATOMICFLAGSFEATURE, OAF__MAX, const char *>::m_aetElementArray[] =
+{
+	"Constructors", // OAF_CONSTRUCTORS
+	"AssignFlagsAllValues", // OAF_ASSIGNFLAGSALLVALUES,
+	"QueryFlagsAllValues", // OAF_QUERYFLAGSALLVALUES,
+	"SetFlagsMaskValue", // OAF_SETFLAGSMASKVALUE,
+	"SignalFlagsMaskValue", // OAF_SIGNALFLAGSMASKVALUE,
+	"DropFlagsMaskValue", // OAF_DROPFLAGSMASKVALUE,
+	"ToggleSingleFlagValue", // OAF_TOGGLESINGLEFLAGVALUE,
+	"ModifySingleFlagValue", // OAF_MODIFYSINGLEFLAGVALUE,
+	"AssignFlagsByMask", // OAF_ASSIGNFLAGSBYMASK,
+	"AlterFlagsByMask", // OAF_ALTERFLAGSBYMASK,
+	"GetFlagsMaskValue", // OAF_GETFLAGSMASKVALUE,
+	"QueryFlagsByMask", // OAF_QUERYFLAGSBYMASK,
+	"OnlySignalSingleFlagOutOfMask", // OAF_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	"EnumSetEnumeratedFlagValue", // OAF_ENUMSETENUMERATEDFLAGVALUE,
+	"EnumSignalEnumeratedFlagValue", // OAF_ENUMSIGNALENUMERATEDFLAGVALUE,
+	"EnumDropEnumeratedFlagValue", // OAF_ENUMDROPENUMERATEDFLAGVALUE,
+	"EnumToggleEnumeratedFlagValue", // OAF_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	"EnumModifyEnumeratedFlagValue", // OAF_ENUMMODIFYENUMERATEDFLAGVALUE,
+	"EnumSignalFirstEnumeratedFlagValue", // OAF_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	"EnumSignalLastEnumeratedFlagValue", // OAF_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	"EnumGetEnumeratedFlagValue", // OAF_ENUMGETENUMERATEDFLAGVALUE,
+	"EnumFindFirstEnumeratedFlag", // OAF_ENUMFINDFIRSTENUMERATEDFLAG,
+	"EnumAllSignalEnumeratedFlags", // OAF_ENUMALLSIGNALENUMERATEDFLAGS,
+	"EnumAllDropEnumeratedFlags", // OAF_ENUMALLDROPENUMERATEDFLAGS,
+	"EnumAllQueryEnumeratedFlags", // OAF_ENUMALLQUERYENUMERATEDFLAGS,
+	"EnumAnyGetEnumeratedFlagValue", // OAF_ENUMANYGETENUMERATEDFLAGVALUE,
+	"StoreFlagsEnumeratedValue", // OAF_STOREFLAGSENUMERATEDVALUE,
+	"RetrieveFlagsEnumeratedValue", // OAF_RETRIEVEFLAGSENUMERATEDVALUE,
+};
+static const CEnumUnsortedElementArray<EOUATOMICFLAGSFEATURE, OAF__MAX, const char *> g_aszAtomicFlagsFeatureTestNames;
+
+
+bool TestAtomicFlags(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	bool bResult = false;
+	nOutSuccessCount = 0;
+	nOutTestCount = OAF__MAX;
+	
+	bool bAPIInitialized = false;
+	
+	do
+	{
+		if (!InitializeAtomicAPI())
+		{
+			break;
+		}
+		
+		bAPIInitialized = true;
+		
+		if (!TestSubsystem(nOutSuccessCount, nOutTestCount, OAF__MAX, g_aszAtomicFlagsFeatureTestNames.GetStoragePointer(), g_afnAtomicFlagsFeatureTestProcedures.GetStoragePointer()))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	if (bAPIInitialized)
+	{
+		FinalizeAtomicAPI();
+	}
+	
+	return bResult;
+}
+
+
+#endif // #if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS
+
+
+//////////////////////////////////////////////////////////////////////////
+
+typedef CSimpleFlagsTemplate<uint64ou> CSimpleFlags64;
+
+const uint64ou g_uiTestValue64 = ((uint64ou)0xA5A5A5A5 << 32) | 0xA5A5A5A5;
+const uint64ou g_uiTestMask64 = ((uint64ou)0xC6C6C6C6 << 32) | 0xC6C6C6C6;
+const uint64ou g_uiTestBit64 = (uint64ou)OU_INT64_MIN;
+const uint64ou g_uiTestAnotherBit64 = (uint64ou)((uint64ou)OU_INT64_MIN >> 1);
+
+
+bool TestSimpleFlags64_Constructors()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(CSimpleFlags64::value_type) != sizeof(uint64ou) || sizeof(CSimpleFlags64) != sizeof(uint64ou))
+		{
+			break;
+		}
+
+		CSimpleFlags64 sfEmptyFlags;
+
+		if (sfEmptyFlags.QueryFlagsAllValues())
+		{
+			break;
+		}
+
+		CSimpleFlags64 sfFullFlags(OU_UINT64_MAX);
+		
+		if (sfFullFlags.QueryFlagsAllValues() != OU_UINT64_MAX)
+		{
+			break;
+		}
+
+		CSimpleFlags64 sfCopyOfFullFlags(sfFullFlags);
+
+		if (sfCopyOfFullFlags.QueryFlagsAllValues() != OU_UINT64_MAX)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_AssignFlagsAllValues()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags;
+
+		sfTestFlags.AssignFlagsAllValues(OU_UINT64_MAX);
+
+		if (sfTestFlags.QueryFlagsAllValues() != OU_UINT64_MAX)
+		{
+			break;
+		}
+
+		sfTestFlags.AssignFlagsAllValues(0);
+
+		if (sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_QueryFlagsAllValues()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(g_uiTestValue64);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue64)
+		{
+			break;
+		}
+
+		// Double check to be sure ;-)
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue64)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_SetFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(g_uiTestValue64);
+
+		sfTestFlags.SetFlagsMaskValue(g_uiTestMask64, true);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(g_uiTestValue64 | g_uiTestMask64))
+		{
+			break;
+		}
+
+		sfTestFlags.SetFlagsMaskValue(g_uiTestValue64, false);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(~g_uiTestValue64 & g_uiTestMask64))
+		{
+			break;
+		}
+		
+
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_SignalFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(g_uiTestValue64);
+		
+		sfTestFlags.SignalFlagsMaskValue(g_uiTestMask64);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(g_uiTestValue64 | g_uiTestMask64))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_DropFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(g_uiTestValue64);
+		
+		sfTestFlags.DropFlagsMaskValue(g_uiTestMask64);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(g_uiTestValue64 & ~g_uiTestMask64))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_ToggleSingleFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(g_uiTestValue64);
+		
+		bool bPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit64);
+		
+		if (bPreviousValue != ((g_uiTestValue64 & g_uiTestBit64) != 0) || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(g_uiTestValue64 ^ g_uiTestBit64))
+		{
+			break;
+		}
+
+		bool bAnotherPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit64);
+		
+		if (bAnotherPreviousValue == bPreviousValue || sfTestFlags.QueryFlagsAllValues() != g_uiTestValue64)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_ModifySingleFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(g_uiTestValue64);
+		
+		bool bFirstModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit64, true);
+		
+		if (bFirstModification != ((g_uiTestValue64 & g_uiTestBit64) != g_uiTestBit64) || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(g_uiTestValue64 | g_uiTestBit64))
+		{
+			break;
+		}
+		
+		bool bAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit64, bFirstModification);
+		
+		if (bAnotherModification == bFirstModification || sfTestFlags.QueryFlagsAllValues() != (bFirstModification ? (uint64ou)(g_uiTestValue64 | g_uiTestBit64) : (uint64ou)(g_uiTestValue64 & ~g_uiTestBit64)))
+		{
+			break;
+		}
+
+		bool bYetAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit64, bAnotherModification);
+
+		if (bYetAnotherModification != bAnotherModification || sfTestFlags.QueryFlagsAllValues() != (bAnotherModification ? (uint64ou)(g_uiTestValue64 | g_uiTestBit64) : (uint64ou)(g_uiTestValue64 & ~g_uiTestBit64)))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_AssignFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(g_uiTestValue64);
+
+		uint64ou uiPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask64, g_uiTestMask64);
+
+		const uint64ou uiNewFlags = (g_uiTestValue64 & ~g_uiTestMask64) | g_uiTestMask64;
+
+		if (uiPreviousFlags != g_uiTestValue64 || sfTestFlags.QueryFlagsAllValues() != uiNewFlags)
+		{
+			break;
+		}
+
+		uint64ou uiAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestValue64, 0);
+
+		const uint64ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue64;
+
+		if (uiAnotherPreviousFlags != uiNewFlags || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags)
+		{
+			break;
+		}
+	
+		uint64ou uiYetAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask64, g_uiTestMask64 & g_uiTestValue64);
+		OU_ASSERT((g_uiTestMask64 & g_uiTestValue64) != 0); // Test degeneration
+		
+		const uint64ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask64) | (g_uiTestMask64 & g_uiTestValue64);
+		OU_ASSERT(uiYetAnotherNewFlags != OU_UINT64_MAX); // Test degeneration
+		
+		if (uiYetAnotherPreviousFlags != uiAnotherNewFlags || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_AlterFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(g_uiTestValue64);
+		
+		bool bWasModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask64, g_uiTestMask64);
+		
+		const uint64ou uiNewFlags = (g_uiTestValue64 & ~g_uiTestMask64) | g_uiTestMask64;
+		
+		if (bWasModification != ((g_uiTestValue64 & g_uiTestMask64) != g_uiTestMask64) || sfTestFlags.QueryFlagsAllValues() != uiNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestValue64, 0);
+		
+		const uint64ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue64;
+		
+		if (bWasAnotherModification != ((uiNewFlags & g_uiTestValue64) != 0) || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasAnotherModificationRepeated = sfTestFlags.AlterFlagsByMask(g_uiTestValue64, 0);
+		
+		if (bWasAnotherModificationRepeated || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasYetAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask64, g_uiTestMask64 & g_uiTestValue64);
+		OU_ASSERT((g_uiTestMask64 & g_uiTestValue64) != 0); // Test degeneration
+		
+		const uint64ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask64) | (g_uiTestMask64 & g_uiTestValue64);
+		OU_ASSERT(uiYetAnotherNewFlags != OU_UINT64_MAX); // Test degeneration
+		
+		if (bWasYetAnotherModification != ((uiAnotherNewFlags & g_uiTestMask64) != (g_uiTestMask64 & g_uiTestValue64)) || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_GetFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(g_uiTestValue64);
+		
+		if (sfTestFlags.GetFlagsMaskValue(g_uiTestMask64) != ((g_uiTestValue64 & g_uiTestMask64) != 0))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.GetFlagsMaskValue(~g_uiTestValue64))
+		{
+			break;
+		}
+		
+		if (!sfTestFlags.GetFlagsMaskValue(OU_UINT64_MAX))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_QueryFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(g_uiTestValue64);
+		
+		if (sfTestFlags.QueryFlagsByMask(g_uiTestMask64) != (uint64ou)(g_uiTestValue64 & g_uiTestMask64))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsByMask(0))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsByMask(OU_UINT64_MAX) != g_uiTestValue64)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_OnlySignalSingleFlagOutOfMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(g_uiTestValue64);
+		OU_ASSERT(g_uiTestValue64 != 0); // Test degeneration
+		
+		if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT64_MAX, g_uiTestBit64))
+		{
+			break;
+		}
+
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue64)
+		{
+			break;
+		}
+		
+		sfTestFlags.AssignFlagsAllValues(0);
+
+		if (!sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit64, g_uiTestBit64))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit64)
+		{
+			break;
+		}
+		
+		if (sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit64, g_uiTestBit64))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit64)
+		{
+			break;
+		}
+		
+		if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT64_MAX, g_uiTestAnotherBit64))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit64)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumSetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags;
+		
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT64_BITS, true);
+
+		if (sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+	
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS, true);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT64_BITS, false);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)OU_INT64_MIN)
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS, false);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumSignalEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags;
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT64_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT64_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumDropEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(OU_UINT64_MAX);
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT64_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (OU_UINT64_MAX ^ 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)~(OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT64_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)~(OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)~(OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumToggleEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags;
+		
+		bool bToggleFirstResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT64_BITS);
+		
+		if (bToggleFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bToggleSecondResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS);
+		
+		if (bToggleSecondResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bToggleThirdResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT64_BITS);
+		
+		if (!bToggleThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)OU_INT64_MIN)
+		{
+			break;
+		}
+		
+		bool bToggleFourthResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS);
+		
+		if (!bToggleFourthResult || sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumModifyEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags;
+		
+		bool bModifyFirstResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT64_BITS, true);
+		
+		if (!bModifyFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bModifySecondResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS, true);
+		
+		if (!bModifySecondResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyThirdResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT64_BITS, true);
+		
+		if (bModifyThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyFourthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS, true);
+		
+		if (bModifyFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyFifthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT64_BITS, false);
+		
+		if (!bModifyFifthResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)OU_INT64_MIN)
+		{
+			break;
+		}
+		
+		bool bModifySixthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS, false);
+		
+		if (!bModifySixthResult || sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumSignalFirstEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags;
+
+		bool bFirstResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT64_BITS);
+
+		if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bSecondResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT64_BITS);
+		
+		if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bThirdResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(2, 0, OU_UINT64_BITS - 1);
+		
+		if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3)
+		{
+			break;
+		}
+		
+		bool bFourthResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS);
+		
+		if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 3))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumSignalLastEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags;
+		
+		bool bFirstResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1);
+		
+		if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bSecondResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1);
+		
+		if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bThirdResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 1, 2);
+		
+		if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3)
+		{
+			break;
+		}
+		
+		bool bFourthResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS);
+		
+		if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 3))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumGetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags((uint64ou)(OU_INT64_MIN + 1));
+		
+		if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, 0, OU_UINT64_BITS))
+		{
+			break;
+		}
+	
+		if (sfTestFlags.EnumGetEnumeratedFlagValue(2, 0, OU_UINT64_BITS - 1))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.EnumGetEnumeratedFlagValue(1, 1, OU_UINT64_BITS - 1))
+		{
+			break;
+		}
+		
+		if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumFindFirstEnumeratedFlag()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags((uint64ou)(OU_INT64_MIN + 1));
+
+		unsigned int uiFirstResult = sfTestFlags.EnumFindFirstEnumeratedFlag(1, OU_UINT64_BITS);
+		if (uiFirstResult != 0)
+		{
+			break;
+		}
+
+		unsigned int uiSecondResult = sfTestFlags.EnumFindFirstEnumeratedFlag(2, OU_UINT64_BITS - 1);
+		if (uiSecondResult != OU_UINT64_BITS - 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumAllSignalEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags;
+		
+		sfTestFlags.EnumAllSignalEnumeratedFlags(1, 1);
+
+		if (sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+
+		sfTestFlags.EnumAllSignalEnumeratedFlags(4, OU_UINT64_BITS - 2);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_UINT64_MAX ^ 2))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumAllDropEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags(OU_UINT64_MAX);
+		
+		sfTestFlags.EnumAllDropEnumeratedFlags(1, 1);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_UINT64_MAX ^ 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumAllDropEnumeratedFlags(4, OU_UINT64_BITS - 2);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumAllQueryEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags((uint64ou)(OU_INT64_MIN + 1));
+		
+		uint64ou uiFirstResult = sfTestFlags.EnumAllQueryEnumeratedFlags(1, OU_UINT64_BITS);
+		if (uiFirstResult != (uint64ou)(OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		uint64ou uiSecondResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT64_BITS - 1);
+		if (uiSecondResult != (uint64ou)(OU_INT64_MIN))
+		{
+			break;
+		}
+		
+		uint64ou uiThirdResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT64_BITS - 2);
+		if (uiThirdResult != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_EnumAnyGetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags((uint64ou)(OU_INT64_MIN + 1));
+		
+		bool bFirstResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(1, OU_UINT64_BITS);
+		if (!bFirstResult)
+		{
+			break;
+		}
+		
+		bool bSecondResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT64_BITS - 1);
+		if (!bSecondResult)
+		{
+			break;
+		}
+		
+		bool bThirdResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT64_BITS - 2);
+		if (bThirdResult)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_StoreFlagsEnumeratedValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags;
+
+		sfTestFlags.StoreFlagsEnumeratedValue(0x03, 1, 2);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(2 << 1))
+		{
+			break;
+		}
+	
+		sfTestFlags.StoreFlagsEnumeratedValue(0x03, OU_UINT64_BITS - 2, 3);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != ((uint64ou)(2 << 1) | (uint64ou)(OU_INT64_MIN | (OU_INT64_MIN >> 1))))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags64_RetrieveFlagsEnumeratedValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags64 sfTestFlags((uint64ou)(OU_INT64_MIN + 1));
+		
+		unsigned int uiFirstResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, 1);
+		if (uiFirstResult != 0)
+		{
+			break;
+		}
+		
+		unsigned int uiSecondResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, OU_UINT64_BITS - 2);
+		if (uiSecondResult != 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+
+enum EOUSIMPLEFLAGSFEATURE64
+{
+	OSF64__MIN,
+		
+	OSF64_CONSTRUCTORS = OSF64__MIN,
+	OSF64_ASSIGNFLAGSALLVALUES,
+	OSF64_QUERYFLAGSALLVALUES,
+	OSF64_SETFLAGSMASKVALUE,
+	OSF64_SIGNALFLAGSMASKVALUE,
+	OSF64_DROPFLAGSMASKVALUE,
+	OSF64_TOGGLESINGLEFLAGVALUE,
+	OSF64_MODIFYSINGLEFLAGVALUE,
+	OSF64_ASSIGNFLAGSBYMASK,
+	OSF64_ALTERFLAGSBYMASK,
+	OSF64_GETFLAGSMASKVALUE,
+	OSF64_QUERYFLAGSBYMASK,
+	OSF64_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	OSF64_ENUMSETENUMERATEDFLAGVALUE,
+	OSF64_ENUMSIGNALENUMERATEDFLAGVALUE,
+	OSF64_ENUMDROPENUMERATEDFLAGVALUE,
+	OSF64_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	OSF64_ENUMMODIFYENUMERATEDFLAGVALUE,
+	OSF64_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	OSF64_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	OSF64_ENUMGETENUMERATEDFLAGVALUE,
+	OSF64_ENUMFINDFIRSTENUMERATEDFLAG,
+	OSF64_ENUMALLSIGNALENUMERATEDFLAGS,
+	OSF64_ENUMALLDROPENUMERATEDFLAGS,
+	OSF64_ENUMALLQUERYENUMERATEDFLAGS,
+	OSF64_ENUMANYGETENUMERATEDFLAGVALUE,
+	OSF64_STOREFLAGSENUMERATEDVALUE,
+	OSF64_RETRIEVEFLAGSENUMERATEDVALUE,
+
+	OSF64__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE64, OSF64__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestSimpleFlags64_Constructors, // OSF64_CONSTRUCTORS
+	&TestSimpleFlags64_AssignFlagsAllValues, // OSF64_ASSIGNFLAGSALLVALUES,
+	&TestSimpleFlags64_QueryFlagsAllValues, // OSF64_QUERYFLAGSALLVALUES,
+	&TestSimpleFlags64_SetFlagsMaskValue, // OSF64_SETFLAGSMASKVALUE,
+	&TestSimpleFlags64_SignalFlagsMaskValue, // OSF64_SIGNALFLAGSMASKVALUE,
+	&TestSimpleFlags64_DropFlagsMaskValue, // OSF64_DROPFLAGSMASKVALUE,
+	&TestSimpleFlags64_ToggleSingleFlagValue, // OSF64_TOGGLESINGLEFLAGVALUE,
+	&TestSimpleFlags64_ModifySingleFlagValue, // OSF64_MODIFYSINGLEFLAGVALUE,
+	&TestSimpleFlags64_AssignFlagsByMask, // OSF64_ASSIGNFLAGSBYMASK,
+	&TestSimpleFlags64_AlterFlagsByMask, // OSF64_ALTERFLAGSBYMASK,
+	&TestSimpleFlags64_GetFlagsMaskValue, // OSF64_GETFLAGSMASKVALUE,
+	&TestSimpleFlags64_QueryFlagsByMask, // OSF64_QUERYFLAGSBYMASK,
+	&TestSimpleFlags64_OnlySignalSingleFlagOutOfMask, // OSF64_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	&TestSimpleFlags64_EnumSetEnumeratedFlagValue, // OSF64_ENUMSETENUMERATEDFLAGVALUE,
+	&TestSimpleFlags64_EnumSignalEnumeratedFlagValue, // OSF64_ENUMSIGNALENUMERATEDFLAGVALUE,
+	&TestSimpleFlags64_EnumDropEnumeratedFlagValue, // OSF64_ENUMDROPENUMERATEDFLAGVALUE,
+	&TestSimpleFlags64_EnumToggleEnumeratedFlagValue, // OSF64_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	&TestSimpleFlags64_EnumModifyEnumeratedFlagValue, // OSF64_ENUMMODIFYENUMERATEDFLAGVALUE,
+	&TestSimpleFlags64_EnumSignalFirstEnumeratedFlagValue, // OSF64_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	&TestSimpleFlags64_EnumSignalLastEnumeratedFlagValue, // OSF64_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	&TestSimpleFlags64_EnumGetEnumeratedFlagValue, // OSF64_ENUMGETENUMERATEDFLAGVALUE,
+	&TestSimpleFlags64_EnumFindFirstEnumeratedFlag, // OSF64_ENUMFINDFIRSTENUMERATEDFLAG,
+	&TestSimpleFlags64_EnumAllSignalEnumeratedFlags, // OSF64_ENUMALLSIGNALENUMERATEDFLAGS,
+	&TestSimpleFlags64_EnumAllDropEnumeratedFlags, // OSF64_ENUMALLDROPENUMERATEDFLAGS,
+	&TestSimpleFlags64_EnumAllQueryEnumeratedFlags, // OSF64_ENUMALLQUERYENUMERATEDFLAGS,
+	&TestSimpleFlags64_EnumAnyGetEnumeratedFlagValue, // OSF64_ENUMANYGETENUMERATEDFLAGVALUE,
+	&TestSimpleFlags64_StoreFlagsEnumeratedValue, // OSF64_STOREFLAGSENUMERATEDVALUE,
+	&TestSimpleFlags64_RetrieveFlagsEnumeratedValue, // OSF64_RETRIEVEFLAGSENUMERATEDVALUE,
+};
+static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE64, OSF64__MAX, CFeatureTestProcedure> g_afnSimpleFlags64FeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE64, OSF64__MAX, const char *>::m_aetElementArray[] =
+{
+	"Constructors", // OSF64_CONSTRUCTORS
+	"AssignFlagsAllValues", // OSF64_ASSIGNFLAGSALLVALUES,
+	"QueryFlagsAllValues", // OSF64_QUERYFLAGSALLVALUES,
+	"SetFlagsMaskValue", // OSF64_SETFLAGSMASKVALUE,
+	"SignalFlagsMaskValue", // OSF64_SIGNALFLAGSMASKVALUE,
+	"DropFlagsMaskValue", // OSF64_DROPFLAGSMASKVALUE,
+	"ToggleSingleFlagValue", // OSF64_TOGGLESINGLEFLAGVALUE,
+	"ModifySingleFlagValue", // OSF64_MODIFYSINGLEFLAGVALUE,
+	"AssignFlagsByMask", // OSF64_ASSIGNFLAGSBYMASK,
+	"AlterFlagsByMask", // OSF64_ALTERFLAGSBYMASK,
+	"GetFlagsMaskValue", // OSF64_GETFLAGSMASKVALUE,
+	"QueryFlagsByMask", // OSF64_QUERYFLAGSBYMASK,
+	"OnlySignalSingleFlagOutOfMask", // OSF64_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	"EnumSetEnumeratedFlagValue", // OSF64_ENUMSETENUMERATEDFLAGVALUE,
+	"EnumSignalEnumeratedFlagValue", // OSF64_ENUMSIGNALENUMERATEDFLAGVALUE,
+	"EnumDropEnumeratedFlagValue", // OSF64_ENUMDROPENUMERATEDFLAGVALUE,
+	"EnumToggleEnumeratedFlagValue", // OSF64_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	"EnumModifyEnumeratedFlagValue", // OSF64_ENUMMODIFYENUMERATEDFLAGVALUE,
+	"EnumSignalFirstEnumeratedFlagValue", // OSF64_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	"EnumSignalLastEnumeratedFlagValue", // OSF64_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	"EnumGetEnumeratedFlagValue", // OSF64_ENUMGETENUMERATEDFLAGVALUE,
+	"EnumFindFirstEnumeratedFlag", // OSF64_ENUMFINDFIRSTENUMERATEDFLAG,
+	"EnumAllSignalEnumeratedFlags", // OSF64_ENUMALLSIGNALENUMERATEDFLAGS,
+	"EnumAllDropEnumeratedFlags", // OSF64_ENUMALLDROPENUMERATEDFLAGS,
+	"EnumAllQueryEnumeratedFlags", // OSF64_ENUMALLQUERYENUMERATEDFLAGS,
+	"EnumAnyGetEnumeratedFlagValue", // OSF64_ENUMANYGETENUMERATEDFLAGVALUE,
+	"StoreFlagsEnumeratedValue", // OSF64_STOREFLAGSENUMERATEDVALUE,
+	"RetrieveFlagsEnumeratedValue", // OSF64_RETRIEVEFLAGSENUMERATEDVALUE,
+};
+static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE64, OSF64__MAX, const char *> g_aszSimpleFlags64FeatureTestNames;
+
+
+bool TestSimpleFlags64(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, OSF64__MAX, g_aszSimpleFlags64FeatureTestNames.GetStoragePointer(), g_afnSimpleFlags64FeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+typedef CSimpleFlags CSimpleFlags32;
+
+const uint32ou g_uiTestValue32 = (uint32ou)0xA5A5A5A5;
+const uint32ou g_uiTestMask32 = (uint32ou)0xC6C6C6C6;
+const uint32ou g_uiTestBit32 = (uint32ou)OU_INT32_MIN;
+const uint32ou g_uiTestAnotherBit32 = (uint32ou)((uint32ou)OU_INT32_MIN >> 1);
+
+
+bool TestSimpleFlags32_Constructors()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(CSimpleFlags32::value_type) != sizeof(uint32ou) || sizeof(CSimpleFlags32) != sizeof(uint32ou))
+		{
+			break;
+		}
+
+		CSimpleFlags32 sfEmptyFlags;
+
+		if (sfEmptyFlags.QueryFlagsAllValues())
+		{
+			break;
+		}
+
+		CSimpleFlags32 sfFullFlags(OU_UINT32_MAX);
+		
+		if (sfFullFlags.QueryFlagsAllValues() != OU_UINT32_MAX)
+		{
+			break;
+		}
+
+		CSimpleFlags32 sfCopyOfFullFlags(sfFullFlags);
+
+		if (sfCopyOfFullFlags.QueryFlagsAllValues() != OU_UINT32_MAX)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_AssignFlagsAllValues()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags;
+
+		sfTestFlags.AssignFlagsAllValues(OU_UINT32_MAX);
+
+		if (sfTestFlags.QueryFlagsAllValues() != OU_UINT32_MAX)
+		{
+			break;
+		}
+
+		sfTestFlags.AssignFlagsAllValues(0);
+
+		if (sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_QueryFlagsAllValues()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(g_uiTestValue32);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue32)
+		{
+			break;
+		}
+
+		// Double check to be sure ;-)
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue32)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_SetFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(g_uiTestValue32);
+
+		sfTestFlags.SetFlagsMaskValue(g_uiTestMask32, true);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(g_uiTestValue32 | g_uiTestMask32))
+		{
+			break;
+		}
+
+		sfTestFlags.SetFlagsMaskValue(g_uiTestValue32, false);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(~g_uiTestValue32 & g_uiTestMask32))
+		{
+			break;
+		}
+		
+
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_SignalFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(g_uiTestValue32);
+		
+		sfTestFlags.SignalFlagsMaskValue(g_uiTestMask32);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(g_uiTestValue32 | g_uiTestMask32))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_DropFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(g_uiTestValue32);
+		
+		sfTestFlags.DropFlagsMaskValue(g_uiTestMask32);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(g_uiTestValue32 & ~g_uiTestMask32))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_ToggleSingleFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(g_uiTestValue32);
+		
+		bool bPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit32);
+		
+		if (bPreviousValue != ((g_uiTestValue32 & g_uiTestBit32) != 0) || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(g_uiTestValue32 ^ g_uiTestBit32))
+		{
+			break;
+		}
+
+		bool bAnotherPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit32);
+		
+		if (bAnotherPreviousValue == bPreviousValue || sfTestFlags.QueryFlagsAllValues() != g_uiTestValue32)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_ModifySingleFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(g_uiTestValue32);
+		
+		bool bFirstModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit32, true);
+		
+		if (bFirstModification != ((g_uiTestValue32 & g_uiTestBit32) != g_uiTestBit32) || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(g_uiTestValue32 | g_uiTestBit32))
+		{
+			break;
+		}
+		
+		bool bAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit32, bFirstModification);
+		
+		if (bAnotherModification == bFirstModification || sfTestFlags.QueryFlagsAllValues() != (bFirstModification ? (uint32ou)(g_uiTestValue32 | g_uiTestBit32) : (uint32ou)(g_uiTestValue32 & ~g_uiTestBit32)))
+		{
+			break;
+		}
+
+		bool bYetAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit32, bAnotherModification);
+
+		if (bYetAnotherModification != bAnotherModification || sfTestFlags.QueryFlagsAllValues() != (bAnotherModification ? (uint32ou)(g_uiTestValue32 | g_uiTestBit32) : (uint32ou)(g_uiTestValue32 & ~g_uiTestBit32)))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_AssignFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(g_uiTestValue32);
+
+		uint32ou uiPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask32, g_uiTestMask32);
+
+		const uint32ou uiNewFlags = (g_uiTestValue32 & ~g_uiTestMask32) | g_uiTestMask32;
+
+		if (uiPreviousFlags != g_uiTestValue32 || sfTestFlags.QueryFlagsAllValues() != uiNewFlags)
+		{
+			break;
+		}
+
+		uint32ou uiAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestValue32, 0);
+
+		const uint32ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue32;
+
+		if (uiAnotherPreviousFlags != uiNewFlags || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags)
+		{
+			break;
+		}
+	
+		uint32ou uiYetAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask32, g_uiTestMask32 & g_uiTestValue32);
+		OU_ASSERT((g_uiTestMask32 & g_uiTestValue32) != 0); // Test degeneration
+		
+		const uint32ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask32) | (g_uiTestMask32 & g_uiTestValue32);
+		OU_ASSERT(uiYetAnotherNewFlags != OU_UINT32_MAX); // Test degeneration
+		
+		if (uiYetAnotherPreviousFlags != uiAnotherNewFlags || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_AlterFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(g_uiTestValue32);
+		
+		bool bWasModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask32, g_uiTestMask32);
+		
+		const uint32ou uiNewFlags = (g_uiTestValue32 & ~g_uiTestMask32) | g_uiTestMask32;
+		
+		if (bWasModification != ((g_uiTestValue32 & g_uiTestMask32) != g_uiTestMask32) || sfTestFlags.QueryFlagsAllValues() != uiNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestValue32, 0);
+		
+		const uint32ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue32;
+		
+		if (bWasAnotherModification != ((uiNewFlags & g_uiTestValue32) != 0) || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasAnotherModificationRepeated = sfTestFlags.AlterFlagsByMask(g_uiTestValue32, 0);
+		
+		if (bWasAnotherModificationRepeated || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasYetAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask32, g_uiTestMask32 & g_uiTestValue32);
+		OU_ASSERT((g_uiTestMask32 & g_uiTestValue32) != 0); // Test degeneration
+		
+		const uint32ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask32) | (g_uiTestMask32 & g_uiTestValue32);
+		OU_ASSERT(uiYetAnotherNewFlags != OU_UINT32_MAX); // Test degeneration
+		
+		if (bWasYetAnotherModification != ((uiAnotherNewFlags & g_uiTestMask32) != (g_uiTestMask32 & g_uiTestValue32)) || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_GetFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(g_uiTestValue32);
+		
+		if (sfTestFlags.GetFlagsMaskValue(g_uiTestMask32) != ((g_uiTestValue32 & g_uiTestMask32) != 0))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.GetFlagsMaskValue(~g_uiTestValue32))
+		{
+			break;
+		}
+		
+		if (!sfTestFlags.GetFlagsMaskValue(OU_UINT32_MAX))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_QueryFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(g_uiTestValue32);
+		
+		if (sfTestFlags.QueryFlagsByMask(g_uiTestMask32) != (uint32ou)(g_uiTestValue32 & g_uiTestMask32))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsByMask(0))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsByMask(OU_UINT32_MAX) != g_uiTestValue32)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_OnlySignalSingleFlagOutOfMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(g_uiTestValue32);
+		OU_ASSERT(g_uiTestValue32 != 0); // Test degeneration
+		
+		if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT32_MAX, g_uiTestBit32))
+		{
+			break;
+		}
+
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue32)
+		{
+			break;
+		}
+		
+		sfTestFlags.AssignFlagsAllValues(0);
+
+		if (!sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit32, g_uiTestBit32))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit32)
+		{
+			break;
+		}
+		
+		if (sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit32, g_uiTestBit32))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit32)
+		{
+			break;
+		}
+		
+		if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT32_MAX, g_uiTestAnotherBit32))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit32)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumSetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags;
+		
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT32_BITS, true);
+
+		if (sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+	
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, true);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT32_BITS, false);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)OU_INT32_MIN)
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, false);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumSignalEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags;
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumDropEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(OU_UINT32_MAX);
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (OU_UINT32_MAX ^ 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)~(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)~(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)~(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumToggleEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags;
+		
+		bool bToggleFirstResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (bToggleFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bToggleSecondResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (bToggleSecondResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bToggleThirdResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (!bToggleThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)OU_INT32_MIN)
+		{
+			break;
+		}
+		
+		bool bToggleFourthResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (!bToggleFourthResult || sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumModifyEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags;
+		
+		bool bModifyFirstResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT32_BITS, true);
+		
+		if (!bModifyFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bModifySecondResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, true);
+		
+		if (!bModifySecondResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyThirdResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT32_BITS, true);
+		
+		if (bModifyThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyFourthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, true);
+		
+		if (bModifyFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyFifthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT32_BITS, false);
+		
+		if (!bModifyFifthResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)OU_INT32_MIN)
+		{
+			break;
+		}
+		
+		bool bModifySixthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, false);
+		
+		if (!bModifySixthResult || sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumSignalFirstEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags;
+
+		bool bFirstResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+
+		if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bSecondResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT32_BITS);
+		
+		if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bThirdResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(2, 0, OU_UINT32_BITS - 1);
+		
+		if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3)
+		{
+			break;
+		}
+		
+		bool bFourthResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 3))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumSignalLastEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags;
+		
+		bool bFirstResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1);
+		
+		if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bSecondResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1);
+		
+		if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bThirdResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 1, 2);
+		
+		if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3)
+		{
+			break;
+		}
+		
+		bool bFourthResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS);
+		
+		if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 3))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumGetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags((uint32ou)(OU_INT32_MIN + 1));
+		
+		if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, 0, OU_UINT32_BITS))
+		{
+			break;
+		}
+	
+		if (sfTestFlags.EnumGetEnumeratedFlagValue(2, 0, OU_UINT32_BITS - 1))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.EnumGetEnumeratedFlagValue(1, 1, OU_UINT32_BITS - 1))
+		{
+			break;
+		}
+		
+		if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumFindFirstEnumeratedFlag()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags((uint32ou)(OU_INT32_MIN + 1));
+
+		unsigned int uiFirstResult = sfTestFlags.EnumFindFirstEnumeratedFlag(1, OU_UINT32_BITS);
+		if (uiFirstResult != 0)
+		{
+			break;
+		}
+
+		unsigned int uiSecondResult = sfTestFlags.EnumFindFirstEnumeratedFlag(2, OU_UINT32_BITS - 1);
+		if (uiSecondResult != OU_UINT32_BITS - 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumAllSignalEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags;
+		
+		sfTestFlags.EnumAllSignalEnumeratedFlags(1, 1);
+
+		if (sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+
+		sfTestFlags.EnumAllSignalEnumeratedFlags(4, OU_UINT32_BITS - 2);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_UINT32_MAX ^ 2))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumAllDropEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags(OU_UINT32_MAX);
+		
+		sfTestFlags.EnumAllDropEnumeratedFlags(1, 1);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_UINT32_MAX ^ 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumAllDropEnumeratedFlags(4, OU_UINT32_BITS - 2);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumAllQueryEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags((uint32ou)(OU_INT32_MIN + 1));
+		
+		uint32ou uiFirstResult = sfTestFlags.EnumAllQueryEnumeratedFlags(1, OU_UINT32_BITS);
+		if (uiFirstResult != (uint32ou)(OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		uint32ou uiSecondResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT32_BITS - 1);
+		if (uiSecondResult != (uint32ou)(OU_INT32_MIN))
+		{
+			break;
+		}
+		
+		uint32ou uiThirdResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT32_BITS - 2);
+		if (uiThirdResult != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_EnumAnyGetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags((uint32ou)(OU_INT32_MIN + 1));
+		
+		bool bFirstResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(1, OU_UINT32_BITS);
+		if (!bFirstResult)
+		{
+			break;
+		}
+		
+		bool bSecondResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT32_BITS - 1);
+		if (!bSecondResult)
+		{
+			break;
+		}
+		
+		bool bThirdResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT32_BITS - 2);
+		if (bThirdResult)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_StoreFlagsEnumeratedValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags;
+
+		sfTestFlags.StoreFlagsEnumeratedValue(0x03, 1, 2);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(2 << 1))
+		{
+			break;
+		}
+	
+		sfTestFlags.StoreFlagsEnumeratedValue(0x03, OU_UINT32_BITS - 2, 3);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != ((uint32ou)(2 << 1) | (uint32ou)(OU_INT32_MIN | (OU_INT32_MIN >> 1))))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags32_RetrieveFlagsEnumeratedValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags32 sfTestFlags((uint32ou)(OU_INT32_MIN + 1));
+		
+		unsigned int uiFirstResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, 1);
+		if (uiFirstResult != 0)
+		{
+			break;
+		}
+		
+		unsigned int uiSecondResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, OU_UINT32_BITS - 2);
+		if (uiSecondResult != 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+
+enum EOUSIMPLEFLAGSFEATURE32
+{
+	OSF32__MIN,
+		
+	OSF32_CONSTRUCTORS = OSF32__MIN,
+	OSF32_ASSIGNFLAGSALLVALUES,
+	OSF32_QUERYFLAGSALLVALUES,
+	OSF32_SETFLAGSMASKVALUE,
+	OSF32_SIGNALFLAGSMASKVALUE,
+	OSF32_DROPFLAGSMASKVALUE,
+	OSF32_TOGGLESINGLEFLAGVALUE,
+	OSF32_MODIFYSINGLEFLAGVALUE,
+	OSF32_ASSIGNFLAGSBYMASK,
+	OSF32_ALTERFLAGSBYMASK,
+	OSF32_GETFLAGSMASKVALUE,
+	OSF32_QUERYFLAGSBYMASK,
+	OSF32_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	OSF32_ENUMSETENUMERATEDFLAGVALUE,
+	OSF32_ENUMSIGNALENUMERATEDFLAGVALUE,
+	OSF32_ENUMDROPENUMERATEDFLAGVALUE,
+	OSF32_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	OSF32_ENUMMODIFYENUMERATEDFLAGVALUE,
+	OSF32_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	OSF32_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	OSF32_ENUMGETENUMERATEDFLAGVALUE,
+	OSF32_ENUMFINDFIRSTENUMERATEDFLAG,
+	OSF32_ENUMALLSIGNALENUMERATEDFLAGS,
+	OSF32_ENUMALLDROPENUMERATEDFLAGS,
+	OSF32_ENUMALLQUERYENUMERATEDFLAGS,
+	OSF32_ENUMANYGETENUMERATEDFLAGVALUE,
+	OSF32_STOREFLAGSENUMERATEDVALUE,
+	OSF32_RETRIEVEFLAGSENUMERATEDVALUE,
+
+	OSF32__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE32, OSF32__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestSimpleFlags32_Constructors, // OSF32_CONSTRUCTORS
+	&TestSimpleFlags32_AssignFlagsAllValues, // OSF32_ASSIGNFLAGSALLVALUES,
+	&TestSimpleFlags32_QueryFlagsAllValues, // OSF32_QUERYFLAGSALLVALUES,
+	&TestSimpleFlags32_SetFlagsMaskValue, // OSF32_SETFLAGSMASKVALUE,
+	&TestSimpleFlags32_SignalFlagsMaskValue, // OSF32_SIGNALFLAGSMASKVALUE,
+	&TestSimpleFlags32_DropFlagsMaskValue, // OSF32_DROPFLAGSMASKVALUE,
+	&TestSimpleFlags32_ToggleSingleFlagValue, // OSF32_TOGGLESINGLEFLAGVALUE,
+	&TestSimpleFlags32_ModifySingleFlagValue, // OSF32_MODIFYSINGLEFLAGVALUE,
+	&TestSimpleFlags32_AssignFlagsByMask, // OSF32_ASSIGNFLAGSBYMASK,
+	&TestSimpleFlags32_AlterFlagsByMask, // OSF32_ALTERFLAGSBYMASK,
+	&TestSimpleFlags32_GetFlagsMaskValue, // OSF32_GETFLAGSMASKVALUE,
+	&TestSimpleFlags32_QueryFlagsByMask, // OSF32_QUERYFLAGSBYMASK,
+	&TestSimpleFlags32_OnlySignalSingleFlagOutOfMask, // OSF32_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	&TestSimpleFlags32_EnumSetEnumeratedFlagValue, // OSF32_ENUMSETENUMERATEDFLAGVALUE,
+	&TestSimpleFlags32_EnumSignalEnumeratedFlagValue, // OSF32_ENUMSIGNALENUMERATEDFLAGVALUE,
+	&TestSimpleFlags32_EnumDropEnumeratedFlagValue, // OSF32_ENUMDROPENUMERATEDFLAGVALUE,
+	&TestSimpleFlags32_EnumToggleEnumeratedFlagValue, // OSF32_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	&TestSimpleFlags32_EnumModifyEnumeratedFlagValue, // OSF32_ENUMMODIFYENUMERATEDFLAGVALUE,
+	&TestSimpleFlags32_EnumSignalFirstEnumeratedFlagValue, // OSF32_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	&TestSimpleFlags32_EnumSignalLastEnumeratedFlagValue, // OSF32_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	&TestSimpleFlags32_EnumGetEnumeratedFlagValue, // OSF32_ENUMGETENUMERATEDFLAGVALUE,
+	&TestSimpleFlags32_EnumFindFirstEnumeratedFlag, // OSF32_ENUMFINDFIRSTENUMERATEDFLAG,
+	&TestSimpleFlags32_EnumAllSignalEnumeratedFlags, // OSF32_ENUMALLSIGNALENUMERATEDFLAGS,
+	&TestSimpleFlags32_EnumAllDropEnumeratedFlags, // OSF32_ENUMALLDROPENUMERATEDFLAGS,
+	&TestSimpleFlags32_EnumAllQueryEnumeratedFlags, // OSF32_ENUMALLQUERYENUMERATEDFLAGS,
+	&TestSimpleFlags32_EnumAnyGetEnumeratedFlagValue, // OSF32_ENUMANYGETENUMERATEDFLAGVALUE,
+	&TestSimpleFlags32_StoreFlagsEnumeratedValue, // OSF32_STOREFLAGSENUMERATEDVALUE,
+	&TestSimpleFlags32_RetrieveFlagsEnumeratedValue, // OSF32_RETRIEVEFLAGSENUMERATEDVALUE,
+};
+static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE32, OSF32__MAX, CFeatureTestProcedure> g_afnSimpleFlags32FeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE32, OSF32__MAX, const char *>::m_aetElementArray[] =
+{
+	"Constructors", // OSF32_CONSTRUCTORS
+	"AssignFlagsAllValues", // OSF32_ASSIGNFLAGSALLVALUES,
+	"QueryFlagsAllValues", // OSF32_QUERYFLAGSALLVALUES,
+	"SetFlagsMaskValue", // OSF32_SETFLAGSMASKVALUE,
+	"SignalFlagsMaskValue", // OSF32_SIGNALFLAGSMASKVALUE,
+	"DropFlagsMaskValue", // OSF32_DROPFLAGSMASKVALUE,
+	"ToggleSingleFlagValue", // OSF32_TOGGLESINGLEFLAGVALUE,
+	"ModifySingleFlagValue", // OSF32_MODIFYSINGLEFLAGVALUE,
+	"AssignFlagsByMask", // OSF32_ASSIGNFLAGSBYMASK,
+	"AlterFlagsByMask", // OSF32_ALTERFLAGSBYMASK,
+	"GetFlagsMaskValue", // OSF32_GETFLAGSMASKVALUE,
+	"QueryFlagsByMask", // OSF32_QUERYFLAGSBYMASK,
+	"OnlySignalSingleFlagOutOfMask", // OSF32_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	"EnumSetEnumeratedFlagValue", // OSF32_ENUMSETENUMERATEDFLAGVALUE,
+	"EnumSignalEnumeratedFlagValue", // OSF32_ENUMSIGNALENUMERATEDFLAGVALUE,
+	"EnumDropEnumeratedFlagValue", // OSF32_ENUMDROPENUMERATEDFLAGVALUE,
+	"EnumToggleEnumeratedFlagValue", // OSF32_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	"EnumModifyEnumeratedFlagValue", // OSF32_ENUMMODIFYENUMERATEDFLAGVALUE,
+	"EnumSignalFirstEnumeratedFlagValue", // OSF32_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	"EnumSignalLastEnumeratedFlagValue", // OSF32_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	"EnumGetEnumeratedFlagValue", // OSF32_ENUMGETENUMERATEDFLAGVALUE,
+	"EnumFindFirstEnumeratedFlag", // OSF32_ENUMFINDFIRSTENUMERATEDFLAG,
+	"EnumAllSignalEnumeratedFlags", // OSF32_ENUMALLSIGNALENUMERATEDFLAGS,
+	"EnumAllDropEnumeratedFlags", // OSF32_ENUMALLDROPENUMERATEDFLAGS,
+	"EnumAllQueryEnumeratedFlags", // OSF32_ENUMALLQUERYENUMERATEDFLAGS,
+	"EnumAnyGetEnumeratedFlagValue", // OSF32_ENUMANYGETENUMERATEDFLAGVALUE,
+	"StoreFlagsEnumeratedValue", // OSF32_STOREFLAGSENUMERATEDVALUE,
+	"RetrieveFlagsEnumeratedValue", // OSF32_RETRIEVEFLAGSENUMERATEDVALUE,
+};
+static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE32, OSF32__MAX, const char *> g_aszSimpleFlags32FeatureTestNames;
+
+
+bool TestSimpleFlags32(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, OSF32__MAX, g_aszSimpleFlags32FeatureTestNames.GetStoragePointer(), g_afnSimpleFlags32FeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+typedef CSimpleFlagsTemplate<uint16ou> CSimpleFlags16;
+
+const uint16ou g_uiTestValue16 = (uint16ou)0xA5A5;
+const uint16ou g_uiTestMask16 = (uint16ou)0xC6C6;
+const uint16ou g_uiTestBit16 = (uint16ou)OU_INT16_MIN;
+const uint16ou g_uiTestAnotherBit16 = (uint16ou)((uint16ou)OU_INT16_MIN >> 1);
+
+
+bool TestSimpleFlags16_Constructors()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(CSimpleFlags16::value_type) != sizeof(uint16ou) || sizeof(CSimpleFlags16) != sizeof(uint16ou))
+		{
+			break;
+		}
+
+		CSimpleFlags16 sfEmptyFlags;
+
+		if (sfEmptyFlags.QueryFlagsAllValues())
+		{
+			break;
+		}
+
+		CSimpleFlags16 sfFullFlags(OU_UINT16_MAX);
+		
+		if (sfFullFlags.QueryFlagsAllValues() != OU_UINT16_MAX)
+		{
+			break;
+		}
+
+		CSimpleFlags16 sfCopyOfFullFlags(sfFullFlags);
+
+		if (sfCopyOfFullFlags.QueryFlagsAllValues() != OU_UINT16_MAX)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_AssignFlagsAllValues()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags;
+
+		sfTestFlags.AssignFlagsAllValues(OU_UINT16_MAX);
+
+		if (sfTestFlags.QueryFlagsAllValues() != OU_UINT16_MAX)
+		{
+			break;
+		}
+
+		sfTestFlags.AssignFlagsAllValues(0);
+
+		if (sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_QueryFlagsAllValues()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(g_uiTestValue16);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue16)
+		{
+			break;
+		}
+
+		// Double check to be sure ;-)
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue16)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_SetFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(g_uiTestValue16);
+
+		sfTestFlags.SetFlagsMaskValue(g_uiTestMask16, true);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(g_uiTestValue16 | g_uiTestMask16))
+		{
+			break;
+		}
+
+		sfTestFlags.SetFlagsMaskValue(g_uiTestValue16, false);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(~g_uiTestValue16 & g_uiTestMask16))
+		{
+			break;
+		}
+		
+
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_SignalFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(g_uiTestValue16);
+		
+		sfTestFlags.SignalFlagsMaskValue(g_uiTestMask16);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(g_uiTestValue16 | g_uiTestMask16))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_DropFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(g_uiTestValue16);
+		
+		sfTestFlags.DropFlagsMaskValue(g_uiTestMask16);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(g_uiTestValue16 & ~g_uiTestMask16))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_ToggleSingleFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(g_uiTestValue16);
+		
+		bool bPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit16);
+		
+		if (bPreviousValue != ((g_uiTestValue16 & g_uiTestBit16) != 0) || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(g_uiTestValue16 ^ g_uiTestBit16))
+		{
+			break;
+		}
+
+		bool bAnotherPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit16);
+		
+		if (bAnotherPreviousValue == bPreviousValue || sfTestFlags.QueryFlagsAllValues() != g_uiTestValue16)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_ModifySingleFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(g_uiTestValue16);
+		
+		bool bFirstModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit16, true);
+		
+		if (bFirstModification != ((g_uiTestValue16 & g_uiTestBit16) != g_uiTestBit16) || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(g_uiTestValue16 | g_uiTestBit16))
+		{
+			break;
+		}
+		
+		bool bAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit16, bFirstModification);
+		
+		if (bAnotherModification == bFirstModification || sfTestFlags.QueryFlagsAllValues() != (bFirstModification ? (uint16ou)(g_uiTestValue16 | g_uiTestBit16) : (uint16ou)(g_uiTestValue16 & ~g_uiTestBit16)))
+		{
+			break;
+		}
+
+		bool bYetAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit16, bAnotherModification);
+
+		if (bYetAnotherModification != bAnotherModification || sfTestFlags.QueryFlagsAllValues() != (bAnotherModification ? (uint16ou)(g_uiTestValue16 | g_uiTestBit16) : (uint16ou)(g_uiTestValue16 & ~g_uiTestBit16)))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_AssignFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(g_uiTestValue16);
+
+		uint16ou uiPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask16, g_uiTestMask16);
+
+		const uint16ou uiNewFlags = (g_uiTestValue16 & ~g_uiTestMask16) | g_uiTestMask16;
+
+		if (uiPreviousFlags != g_uiTestValue16 || sfTestFlags.QueryFlagsAllValues() != uiNewFlags)
+		{
+			break;
+		}
+
+		uint16ou uiAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestValue16, 0);
+
+		const uint16ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue16;
+
+		if (uiAnotherPreviousFlags != uiNewFlags || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags)
+		{
+			break;
+		}
+	
+		uint16ou uiYetAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask16, g_uiTestMask16 & g_uiTestValue16);
+		OU_ASSERT((g_uiTestMask16 & g_uiTestValue16) != 0); // Test degeneration
+		
+		const uint16ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask16) | (g_uiTestMask16 & g_uiTestValue16);
+		OU_ASSERT(uiYetAnotherNewFlags != OU_UINT16_MAX); // Test degeneration
+		
+		if (uiYetAnotherPreviousFlags != uiAnotherNewFlags || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_AlterFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(g_uiTestValue16);
+		
+		bool bWasModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask16, g_uiTestMask16);
+		
+		const uint16ou uiNewFlags = (g_uiTestValue16 & ~g_uiTestMask16) | g_uiTestMask16;
+		
+		if (bWasModification != ((g_uiTestValue16 & g_uiTestMask16) != g_uiTestMask16) || sfTestFlags.QueryFlagsAllValues() != uiNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestValue16, 0);
+		
+		const uint16ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue16;
+		
+		if (bWasAnotherModification != ((uiNewFlags & g_uiTestValue16) != 0) || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasAnotherModificationRepeated = sfTestFlags.AlterFlagsByMask(g_uiTestValue16, 0);
+		
+		if (bWasAnotherModificationRepeated || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasYetAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask16, g_uiTestMask16 & g_uiTestValue16);
+		OU_ASSERT((g_uiTestMask16 & g_uiTestValue16) != 0); // Test degeneration
+		
+		const uint16ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask16) | (g_uiTestMask16 & g_uiTestValue16);
+		OU_ASSERT(uiYetAnotherNewFlags != OU_UINT16_MAX); // Test degeneration
+		
+		if (bWasYetAnotherModification != ((uiAnotherNewFlags & g_uiTestMask16) != (g_uiTestMask16 & g_uiTestValue16)) || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_GetFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(g_uiTestValue16);
+		
+		if (sfTestFlags.GetFlagsMaskValue(g_uiTestMask16) != ((g_uiTestValue16 & g_uiTestMask16) != 0))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.GetFlagsMaskValue((uint16ou)(~g_uiTestValue16)))
+		{
+			break;
+		}
+		
+		if (!sfTestFlags.GetFlagsMaskValue(OU_UINT16_MAX))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_QueryFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(g_uiTestValue16);
+		
+		if (sfTestFlags.QueryFlagsByMask(g_uiTestMask16) != (uint16ou)(g_uiTestValue16 & g_uiTestMask16))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsByMask(0))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsByMask(OU_UINT16_MAX) != g_uiTestValue16)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_OnlySignalSingleFlagOutOfMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(g_uiTestValue16);
+		OU_ASSERT(g_uiTestValue16 != 0); // Test degeneration
+		
+		if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT16_MAX, g_uiTestBit16))
+		{
+			break;
+		}
+
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue16)
+		{
+			break;
+		}
+		
+		sfTestFlags.AssignFlagsAllValues(0);
+
+		if (!sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit16, g_uiTestBit16))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit16)
+		{
+			break;
+		}
+		
+		if (sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit16, g_uiTestBit16))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit16)
+		{
+			break;
+		}
+		
+		if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT16_MAX, g_uiTestAnotherBit16))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit16)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumSetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags;
+		
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT16_BITS, true);
+
+		if (sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+	
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS, true);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT16_BITS, false);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)OU_INT16_MIN)
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS, false);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumSignalEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags;
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT16_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT16_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumDropEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(OU_UINT16_MAX);
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT16_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (OU_UINT16_MAX ^ 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)~(OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT16_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)~(OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)~(OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumToggleEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags;
+		
+		bool bToggleFirstResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT16_BITS);
+		
+		if (bToggleFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bToggleSecondResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS);
+		
+		if (bToggleSecondResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bToggleThirdResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT16_BITS);
+		
+		if (!bToggleThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)OU_INT16_MIN)
+		{
+			break;
+		}
+		
+		bool bToggleFourthResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS);
+		
+		if (!bToggleFourthResult || sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumModifyEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags;
+		
+		bool bModifyFirstResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT16_BITS, true);
+		
+		if (!bModifyFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bModifySecondResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS, true);
+		
+		if (!bModifySecondResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyThirdResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT16_BITS, true);
+		
+		if (bModifyThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyFourthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS, true);
+		
+		if (bModifyFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyFifthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT16_BITS, false);
+		
+		if (!bModifyFifthResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)OU_INT16_MIN)
+		{
+			break;
+		}
+		
+		bool bModifySixthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS, false);
+		
+		if (!bModifySixthResult || sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumSignalFirstEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags;
+
+		bool bFirstResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT16_BITS);
+
+		if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bSecondResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT16_BITS);
+		
+		if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bThirdResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(2, 0, OU_UINT16_BITS - 1);
+		
+		if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3)
+		{
+			break;
+		}
+		
+		bool bFourthResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS);
+		
+		if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 3))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumSignalLastEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags;
+		
+		bool bFirstResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1);
+		
+		if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bSecondResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1);
+		
+		if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bThirdResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 1, 2);
+		
+		if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3)
+		{
+			break;
+		}
+		
+		bool bFourthResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS);
+		
+		if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 3))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumGetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags((uint16ou)(OU_INT16_MIN + 1));
+		
+		if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, 0, OU_UINT16_BITS))
+		{
+			break;
+		}
+	
+		if (sfTestFlags.EnumGetEnumeratedFlagValue(2, 0, OU_UINT16_BITS - 1))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.EnumGetEnumeratedFlagValue(1, 1, OU_UINT16_BITS - 1))
+		{
+			break;
+		}
+		
+		if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumFindFirstEnumeratedFlag()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags((uint16ou)(OU_INT16_MIN + 1));
+
+		unsigned int uiFirstResult = sfTestFlags.EnumFindFirstEnumeratedFlag(1, OU_UINT16_BITS);
+		if (uiFirstResult != 0)
+		{
+			break;
+		}
+
+		unsigned int uiSecondResult = sfTestFlags.EnumFindFirstEnumeratedFlag(2, OU_UINT16_BITS - 1);
+		if (uiSecondResult != OU_UINT16_BITS - 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumAllSignalEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags;
+		
+		sfTestFlags.EnumAllSignalEnumeratedFlags(1, 1);
+
+		if (sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+
+		sfTestFlags.EnumAllSignalEnumeratedFlags(4, OU_UINT16_BITS - 2);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_UINT16_MAX ^ 2))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumAllDropEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags(OU_UINT16_MAX);
+		
+		sfTestFlags.EnumAllDropEnumeratedFlags(1, 1);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_UINT16_MAX ^ 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumAllDropEnumeratedFlags(4, OU_UINT16_BITS - 2);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumAllQueryEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags((uint16ou)(OU_INT16_MIN + 1));
+		
+		uint16ou uiFirstResult = sfTestFlags.EnumAllQueryEnumeratedFlags(1, OU_UINT16_BITS);
+		if (uiFirstResult != (uint16ou)(OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		uint16ou uiSecondResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT16_BITS - 1);
+		if (uiSecondResult != (uint16ou)(OU_INT16_MIN))
+		{
+			break;
+		}
+		
+		uint16ou uiThirdResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT16_BITS - 2);
+		if (uiThirdResult != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_EnumAnyGetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags((uint16ou)(OU_INT16_MIN + 1));
+		
+		bool bFirstResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(1, OU_UINT16_BITS);
+		if (!bFirstResult)
+		{
+			break;
+		}
+		
+		bool bSecondResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT16_BITS - 1);
+		if (!bSecondResult)
+		{
+			break;
+		}
+		
+		bool bThirdResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT16_BITS - 2);
+		if (bThirdResult)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_StoreFlagsEnumeratedValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags;
+
+		sfTestFlags.StoreFlagsEnumeratedValue(0x03, 1, 2);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(2 << 1))
+		{
+			break;
+		}
+	
+		sfTestFlags.StoreFlagsEnumeratedValue(0x03, OU_UINT16_BITS - 2, 3);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != ((uint16ou)(2 << 1) | (uint16ou)(OU_INT16_MIN | (OU_INT16_MIN >> 1))))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags16_RetrieveFlagsEnumeratedValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags16 sfTestFlags((uint16ou)(OU_INT16_MIN + 1));
+		
+		unsigned int uiFirstResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, 1);
+		if (uiFirstResult != 0)
+		{
+			break;
+		}
+		
+		unsigned int uiSecondResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, OU_UINT16_BITS - 2);
+		if (uiSecondResult != 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+
+enum EOUSIMPLEFLAGSFEATURE16
+{
+	OSF16__MIN,
+		
+	OSF16_CONSTRUCTORS = OSF16__MIN,
+	OSF16_ASSIGNFLAGSALLVALUES,
+	OSF16_QUERYFLAGSALLVALUES,
+	OSF16_SETFLAGSMASKVALUE,
+	OSF16_SIGNALFLAGSMASKVALUE,
+	OSF16_DROPFLAGSMASKVALUE,
+	OSF16_TOGGLESINGLEFLAGVALUE,
+	OSF16_MODIFYSINGLEFLAGVALUE,
+	OSF16_ASSIGNFLAGSBYMASK,
+	OSF16_ALTERFLAGSBYMASK,
+	OSF16_GETFLAGSMASKVALUE,
+	OSF16_QUERYFLAGSBYMASK,
+	OSF16_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	OSF16_ENUMSETENUMERATEDFLAGVALUE,
+	OSF16_ENUMSIGNALENUMERATEDFLAGVALUE,
+	OSF16_ENUMDROPENUMERATEDFLAGVALUE,
+	OSF16_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	OSF16_ENUMMODIFYENUMERATEDFLAGVALUE,
+	OSF16_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	OSF16_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	OSF16_ENUMGETENUMERATEDFLAGVALUE,
+	OSF16_ENUMFINDFIRSTENUMERATEDFLAG,
+	OSF16_ENUMALLSIGNALENUMERATEDFLAGS,
+	OSF16_ENUMALLDROPENUMERATEDFLAGS,
+	OSF16_ENUMALLQUERYENUMERATEDFLAGS,
+	OSF16_ENUMANYGETENUMERATEDFLAGVALUE,
+	OSF16_STOREFLAGSENUMERATEDVALUE,
+	OSF16_RETRIEVEFLAGSENUMERATEDVALUE,
+
+	OSF16__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE16, OSF16__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestSimpleFlags16_Constructors, // OSF16_CONSTRUCTORS
+	&TestSimpleFlags16_AssignFlagsAllValues, // OSF16_ASSIGNFLAGSALLVALUES,
+	&TestSimpleFlags16_QueryFlagsAllValues, // OSF16_QUERYFLAGSALLVALUES,
+	&TestSimpleFlags16_SetFlagsMaskValue, // OSF16_SETFLAGSMASKVALUE,
+	&TestSimpleFlags16_SignalFlagsMaskValue, // OSF16_SIGNALFLAGSMASKVALUE,
+	&TestSimpleFlags16_DropFlagsMaskValue, // OSF16_DROPFLAGSMASKVALUE,
+	&TestSimpleFlags16_ToggleSingleFlagValue, // OSF16_TOGGLESINGLEFLAGVALUE,
+	&TestSimpleFlags16_ModifySingleFlagValue, // OSF16_MODIFYSINGLEFLAGVALUE,
+	&TestSimpleFlags16_AssignFlagsByMask, // OSF16_ASSIGNFLAGSBYMASK,
+	&TestSimpleFlags16_AlterFlagsByMask, // OSF16_ALTERFLAGSBYMASK,
+	&TestSimpleFlags16_GetFlagsMaskValue, // OSF16_GETFLAGSMASKVALUE,
+	&TestSimpleFlags16_QueryFlagsByMask, // OSF16_QUERYFLAGSBYMASK,
+	&TestSimpleFlags16_OnlySignalSingleFlagOutOfMask, // OSF16_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	&TestSimpleFlags16_EnumSetEnumeratedFlagValue, // OSF16_ENUMSETENUMERATEDFLAGVALUE,
+	&TestSimpleFlags16_EnumSignalEnumeratedFlagValue, // OSF16_ENUMSIGNALENUMERATEDFLAGVALUE,
+	&TestSimpleFlags16_EnumDropEnumeratedFlagValue, // OSF16_ENUMDROPENUMERATEDFLAGVALUE,
+	&TestSimpleFlags16_EnumToggleEnumeratedFlagValue, // OSF16_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	&TestSimpleFlags16_EnumModifyEnumeratedFlagValue, // OSF16_ENUMMODIFYENUMERATEDFLAGVALUE,
+	&TestSimpleFlags16_EnumSignalFirstEnumeratedFlagValue, // OSF16_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	&TestSimpleFlags16_EnumSignalLastEnumeratedFlagValue, // OSF16_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	&TestSimpleFlags16_EnumGetEnumeratedFlagValue, // OSF16_ENUMGETENUMERATEDFLAGVALUE,
+	&TestSimpleFlags16_EnumFindFirstEnumeratedFlag, // OSF16_ENUMFINDFIRSTENUMERATEDFLAG,
+	&TestSimpleFlags16_EnumAllSignalEnumeratedFlags, // OSF16_ENUMALLSIGNALENUMERATEDFLAGS,
+	&TestSimpleFlags16_EnumAllDropEnumeratedFlags, // OSF16_ENUMALLDROPENUMERATEDFLAGS,
+	&TestSimpleFlags16_EnumAllQueryEnumeratedFlags, // OSF16_ENUMALLQUERYENUMERATEDFLAGS,
+	&TestSimpleFlags16_EnumAnyGetEnumeratedFlagValue, // OSF16_ENUMANYGETENUMERATEDFLAGVALUE,
+	&TestSimpleFlags16_StoreFlagsEnumeratedValue, // OSF16_STOREFLAGSENUMERATEDVALUE,
+	&TestSimpleFlags16_RetrieveFlagsEnumeratedValue, // OSF16_RETRIEVEFLAGSENUMERATEDVALUE,
+};
+static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE16, OSF16__MAX, CFeatureTestProcedure> g_afnSimpleFlags16FeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE16, OSF16__MAX, const char *>::m_aetElementArray[] =
+{
+	"Constructors", // OSF16_CONSTRUCTORS
+	"AssignFlagsAllValues", // OSF16_ASSIGNFLAGSALLVALUES,
+	"QueryFlagsAllValues", // OSF16_QUERYFLAGSALLVALUES,
+	"SetFlagsMaskValue", // OSF16_SETFLAGSMASKVALUE,
+	"SignalFlagsMaskValue", // OSF16_SIGNALFLAGSMASKVALUE,
+	"DropFlagsMaskValue", // OSF16_DROPFLAGSMASKVALUE,
+	"ToggleSingleFlagValue", // OSF16_TOGGLESINGLEFLAGVALUE,
+	"ModifySingleFlagValue", // OSF16_MODIFYSINGLEFLAGVALUE,
+	"AssignFlagsByMask", // OSF16_ASSIGNFLAGSBYMASK,
+	"AlterFlagsByMask", // OSF16_ALTERFLAGSBYMASK,
+	"GetFlagsMaskValue", // OSF16_GETFLAGSMASKVALUE,
+	"QueryFlagsByMask", // OSF16_QUERYFLAGSBYMASK,
+	"OnlySignalSingleFlagOutOfMask", // OSF16_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	"EnumSetEnumeratedFlagValue", // OSF16_ENUMSETENUMERATEDFLAGVALUE,
+	"EnumSignalEnumeratedFlagValue", // OSF16_ENUMSIGNALENUMERATEDFLAGVALUE,
+	"EnumDropEnumeratedFlagValue", // OSF16_ENUMDROPENUMERATEDFLAGVALUE,
+	"EnumToggleEnumeratedFlagValue", // OSF16_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	"EnumModifyEnumeratedFlagValue", // OSF16_ENUMMODIFYENUMERATEDFLAGVALUE,
+	"EnumSignalFirstEnumeratedFlagValue", // OSF16_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	"EnumSignalLastEnumeratedFlagValue", // OSF16_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	"EnumGetEnumeratedFlagValue", // OSF16_ENUMGETENUMERATEDFLAGVALUE,
+	"EnumFindFirstEnumeratedFlag", // OSF16_ENUMFINDFIRSTENUMERATEDFLAG,
+	"EnumAllSignalEnumeratedFlags", // OSF16_ENUMALLSIGNALENUMERATEDFLAGS,
+	"EnumAllDropEnumeratedFlags", // OSF16_ENUMALLDROPENUMERATEDFLAGS,
+	"EnumAllQueryEnumeratedFlags", // OSF16_ENUMALLQUERYENUMERATEDFLAGS,
+	"EnumAnyGetEnumeratedFlagValue", // OSF16_ENUMANYGETENUMERATEDFLAGVALUE,
+	"StoreFlagsEnumeratedValue", // OSF16_STOREFLAGSENUMERATEDVALUE,
+	"RetrieveFlagsEnumeratedValue", // OSF16_RETRIEVEFLAGSENUMERATEDVALUE,
+};
+static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE16, OSF16__MAX, const char *> g_aszSimpleFlags16FeatureTestNames;
+
+
+bool TestSimpleFlags16(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, OSF16__MAX, g_aszSimpleFlags16FeatureTestNames.GetStoragePointer(), g_afnSimpleFlags16FeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+typedef CSimpleFlagsTemplate<uint8ou> CSimpleFlags8;
+
+const uint8ou g_uiTestValue8 = (uint8ou)0xA5;
+const uint8ou g_uiTestMask8 = (uint8ou)0xC6;
+const uint8ou g_uiTestBit8 = (uint8ou)OU_INT8_MIN;
+const uint8ou g_uiTestAnotherBit8 = (uint8ou)((uint8ou)OU_INT8_MIN >> 1);
+
+
+bool TestSimpleFlags8_Constructors()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(CSimpleFlags8::value_type) != sizeof(uint8ou) || sizeof(CSimpleFlags8) != sizeof(uint8ou))
+		{
+			break;
+		}
+
+		CSimpleFlags8 sfEmptyFlags;
+
+		if (sfEmptyFlags.QueryFlagsAllValues())
+		{
+			break;
+		}
+
+		CSimpleFlags8 sfFullFlags(OU_UINT8_MAX);
+		
+		if (sfFullFlags.QueryFlagsAllValues() != OU_UINT8_MAX)
+		{
+			break;
+		}
+
+		CSimpleFlags8 sfCopyOfFullFlags(sfFullFlags);
+
+		if (sfCopyOfFullFlags.QueryFlagsAllValues() != OU_UINT8_MAX)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_AssignFlagsAllValues()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags;
+
+		sfTestFlags.AssignFlagsAllValues(OU_UINT8_MAX);
+
+		if (sfTestFlags.QueryFlagsAllValues() != OU_UINT8_MAX)
+		{
+			break;
+		}
+
+		sfTestFlags.AssignFlagsAllValues(0);
+
+		if (sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_QueryFlagsAllValues()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(g_uiTestValue8);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue8)
+		{
+			break;
+		}
+
+		// Double check to be sure ;-)
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue8)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_SetFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(g_uiTestValue8);
+
+		sfTestFlags.SetFlagsMaskValue(g_uiTestMask8, true);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(g_uiTestValue8 | g_uiTestMask8))
+		{
+			break;
+		}
+
+		sfTestFlags.SetFlagsMaskValue(g_uiTestValue8, false);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(~g_uiTestValue8 & g_uiTestMask8))
+		{
+			break;
+		}
+		
+
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_SignalFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(g_uiTestValue8);
+		
+		sfTestFlags.SignalFlagsMaskValue(g_uiTestMask8);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(g_uiTestValue8 | g_uiTestMask8))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_DropFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(g_uiTestValue8);
+		
+		sfTestFlags.DropFlagsMaskValue(g_uiTestMask8);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(g_uiTestValue8 & ~g_uiTestMask8))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_ToggleSingleFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(g_uiTestValue8);
+		
+		bool bPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit8);
+		
+		if (bPreviousValue != ((g_uiTestValue8 & g_uiTestBit8) != 0) || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(g_uiTestValue8 ^ g_uiTestBit8))
+		{
+			break;
+		}
+
+		bool bAnotherPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit8);
+		
+		if (bAnotherPreviousValue == bPreviousValue || sfTestFlags.QueryFlagsAllValues() != g_uiTestValue8)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_ModifySingleFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(g_uiTestValue8);
+		
+		bool bFirstModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit8, true);
+		
+		if (bFirstModification != ((g_uiTestValue8 & g_uiTestBit8) != g_uiTestBit8) || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(g_uiTestValue8 | g_uiTestBit8))
+		{
+			break;
+		}
+		
+		bool bAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit8, bFirstModification);
+		
+		if (bAnotherModification == bFirstModification || sfTestFlags.QueryFlagsAllValues() != (bFirstModification ? (uint8ou)(g_uiTestValue8 | g_uiTestBit8) : (uint8ou)(g_uiTestValue8 & ~g_uiTestBit8)))
+		{
+			break;
+		}
+
+		bool bYetAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit8, bAnotherModification);
+
+		if (bYetAnotherModification != bAnotherModification || sfTestFlags.QueryFlagsAllValues() != (bAnotherModification ? (uint8ou)(g_uiTestValue8 | g_uiTestBit8) : (uint8ou)(g_uiTestValue8 & ~g_uiTestBit8)))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_AssignFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(g_uiTestValue8);
+
+		uint8ou uiPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask8, g_uiTestMask8);
+
+		const uint8ou uiNewFlags = (g_uiTestValue8 & ~g_uiTestMask8) | g_uiTestMask8;
+
+		if (uiPreviousFlags != g_uiTestValue8 || sfTestFlags.QueryFlagsAllValues() != uiNewFlags)
+		{
+			break;
+		}
+
+		uint8ou uiAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestValue8, 0);
+
+		const uint8ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue8;
+
+		if (uiAnotherPreviousFlags != uiNewFlags || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags)
+		{
+			break;
+		}
+	
+		uint8ou uiYetAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask8, g_uiTestMask8 & g_uiTestValue8);
+		OU_ASSERT((g_uiTestMask8 & g_uiTestValue8) != 0); // Test degeneration
+		
+		const uint8ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask8) | (g_uiTestMask8 & g_uiTestValue8);
+		OU_ASSERT(uiYetAnotherNewFlags != OU_UINT8_MAX); // Test degeneration
+		
+		if (uiYetAnotherPreviousFlags != uiAnotherNewFlags || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_AlterFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(g_uiTestValue8);
+		
+		bool bWasModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask8, g_uiTestMask8);
+		
+		const uint8ou uiNewFlags = (g_uiTestValue8 & ~g_uiTestMask8) | g_uiTestMask8;
+		
+		if (bWasModification != ((g_uiTestValue8 & g_uiTestMask8) != g_uiTestMask8) || sfTestFlags.QueryFlagsAllValues() != uiNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestValue8, 0);
+		
+		const uint8ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue8;
+		
+		if (bWasAnotherModification != ((uiNewFlags & g_uiTestValue8) != 0) || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasAnotherModificationRepeated = sfTestFlags.AlterFlagsByMask(g_uiTestValue8, 0);
+		
+		if (bWasAnotherModificationRepeated || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bool bWasYetAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask8, g_uiTestMask8 & g_uiTestValue8);
+		OU_ASSERT((g_uiTestMask8 & g_uiTestValue8) != 0); // Test degeneration
+		
+		const uint8ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask8) | (g_uiTestMask8 & g_uiTestValue8);
+		OU_ASSERT(uiYetAnotherNewFlags != OU_UINT8_MAX); // Test degeneration
+		
+		if (bWasYetAnotherModification != ((uiAnotherNewFlags & g_uiTestMask8) != (g_uiTestMask8 & g_uiTestValue8)) || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_GetFlagsMaskValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(g_uiTestValue8);
+		
+		if (sfTestFlags.GetFlagsMaskValue(g_uiTestMask8) != ((g_uiTestValue8 & g_uiTestMask8) != 0))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.GetFlagsMaskValue((uint8ou)(~g_uiTestValue8)))
+		{
+			break;
+		}
+		
+		if (!sfTestFlags.GetFlagsMaskValue(OU_UINT8_MAX))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_QueryFlagsByMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(g_uiTestValue8);
+		
+		if (sfTestFlags.QueryFlagsByMask(g_uiTestMask8) != (uint8ou)(g_uiTestValue8 & g_uiTestMask8))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsByMask(0))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsByMask(OU_UINT8_MAX) != g_uiTestValue8)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_OnlySignalSingleFlagOutOfMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(g_uiTestValue8);
+		OU_ASSERT(g_uiTestValue8 != 0); // Test degeneration
+		
+		if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT8_MAX, g_uiTestBit8))
+		{
+			break;
+		}
+
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue8)
+		{
+			break;
+		}
+		
+		sfTestFlags.AssignFlagsAllValues(0);
+
+		if (!sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit8, g_uiTestBit8))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit8)
+		{
+			break;
+		}
+		
+		if (sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit8, g_uiTestBit8))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit8)
+		{
+			break;
+		}
+		
+		if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT8_MAX, g_uiTestAnotherBit8))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit8)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumSetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags;
+		
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT8_BITS, true);
+
+		if (sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+	
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS, true);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT8_BITS, false);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)OU_INT8_MIN)
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS, false);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumSignalEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags;
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT8_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT8_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumDropEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(OU_UINT8_MAX);
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT8_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (OU_UINT8_MAX ^ 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)~(OU_INT8_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT8_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)~(OU_INT8_MIN + 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)~(OU_INT8_MIN + 1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumToggleEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags;
+		
+		bool bToggleFirstResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT8_BITS);
+		
+		if (bToggleFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bToggleSecondResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS);
+		
+		if (bToggleSecondResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bToggleThirdResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT8_BITS);
+		
+		if (!bToggleThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)OU_INT8_MIN)
+		{
+			break;
+		}
+		
+		bool bToggleFourthResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS);
+		
+		if (!bToggleFourthResult || sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumModifyEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags;
+		
+		bool bModifyFirstResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT8_BITS, true);
+		
+		if (!bModifyFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bModifySecondResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS, true);
+		
+		if (!bModifySecondResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyThirdResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT8_BITS, true);
+		
+		if (bModifyThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyFourthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS, true);
+		
+		if (bModifyFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1))
+		{
+			break;
+		}
+		
+		bool bModifyFifthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT8_BITS, false);
+		
+		if (!bModifyFifthResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)OU_INT8_MIN)
+		{
+			break;
+		}
+		
+		bool bModifySixthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS, false);
+		
+		if (!bModifySixthResult || sfTestFlags.QueryFlagsAllValues() != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumSignalFirstEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags;
+
+		bool bFirstResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT8_BITS);
+
+		if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bSecondResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT8_BITS);
+		
+		if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bThirdResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(2, 0, OU_UINT8_BITS - 1);
+		
+		if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3)
+		{
+			break;
+		}
+		
+		bool bFourthResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS);
+		
+		if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 3))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumSignalLastEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags;
+		
+		bool bFirstResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1);
+		
+		if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bSecondResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1);
+		
+		if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+		
+		bool bThirdResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 1, 2);
+		
+		if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3)
+		{
+			break;
+		}
+		
+		bool bFourthResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS);
+		
+		if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 3))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumGetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags((uint8ou)(OU_INT8_MIN + 1));
+		
+		if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, 0, OU_UINT8_BITS))
+		{
+			break;
+		}
+	
+		if (sfTestFlags.EnumGetEnumeratedFlagValue(2, 0, OU_UINT8_BITS - 1))
+		{
+			break;
+		}
+		
+		if (sfTestFlags.EnumGetEnumeratedFlagValue(1, 1, OU_UINT8_BITS - 1))
+		{
+			break;
+		}
+		
+		if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumFindFirstEnumeratedFlag()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags((uint8ou)(OU_INT8_MIN + 1));
+
+		unsigned int uiFirstResult = sfTestFlags.EnumFindFirstEnumeratedFlag(1, OU_UINT8_BITS);
+		if (uiFirstResult != 0)
+		{
+			break;
+		}
+
+		unsigned int uiSecondResult = sfTestFlags.EnumFindFirstEnumeratedFlag(2, OU_UINT8_BITS - 1);
+		if (uiSecondResult != OU_UINT8_BITS - 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumAllSignalEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags;
+		
+		sfTestFlags.EnumAllSignalEnumeratedFlags(1, 1);
+
+		if (sfTestFlags.QueryFlagsAllValues() != 1)
+		{
+			break;
+		}
+
+		sfTestFlags.EnumAllSignalEnumeratedFlags(4, OU_UINT8_BITS - 2);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_UINT8_MAX ^ 2))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumAllDropEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags(OU_UINT8_MAX);
+		
+		sfTestFlags.EnumAllDropEnumeratedFlags(1, 1);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_UINT8_MAX ^ 1))
+		{
+			break;
+		}
+		
+		sfTestFlags.EnumAllDropEnumeratedFlags(4, OU_UINT8_BITS - 2);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumAllQueryEnumeratedFlags()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags((uint8ou)(OU_INT8_MIN + 1));
+		
+		uint8ou uiFirstResult = sfTestFlags.EnumAllQueryEnumeratedFlags(1, OU_UINT8_BITS);
+		if (uiFirstResult != (uint8ou)(OU_INT8_MIN + 1))
+		{
+			break;
+		}
+		
+		uint8ou uiSecondResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT8_BITS - 1);
+		if (uiSecondResult != (uint8ou)(OU_INT8_MIN))
+		{
+			break;
+		}
+		
+		uint8ou uiThirdResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT8_BITS - 2);
+		if (uiThirdResult != 0)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_EnumAnyGetEnumeratedFlagValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags((uint8ou)(OU_INT8_MIN + 1));
+		
+		bool bFirstResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(1, OU_UINT8_BITS);
+		if (!bFirstResult)
+		{
+			break;
+		}
+		
+		bool bSecondResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT8_BITS - 1);
+		if (!bSecondResult)
+		{
+			break;
+		}
+		
+		bool bThirdResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT8_BITS - 2);
+		if (bThirdResult)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_StoreFlagsEnumeratedValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags;
+
+		sfTestFlags.StoreFlagsEnumeratedValue(0x03, 1, 2);
+
+		if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(2 << 1))
+		{
+			break;
+		}
+	
+		sfTestFlags.StoreFlagsEnumeratedValue(0x03, OU_UINT8_BITS - 2, 3);
+		
+		if (sfTestFlags.QueryFlagsAllValues() != ((uint8ou)(2 << 1) | (uint8ou)(OU_INT8_MIN | (OU_INT8_MIN >> 1))))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestSimpleFlags8_RetrieveFlagsEnumeratedValue()
+{
+	bool bResult = false;
+	
+	do
+	{
+		CSimpleFlags8 sfTestFlags((uint8ou)(OU_INT8_MIN + 1));
+		
+		unsigned int uiFirstResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, 1);
+		if (uiFirstResult != 0)
+		{
+			break;
+		}
+		
+		unsigned int uiSecondResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, OU_UINT8_BITS - 2);
+		if (uiSecondResult != 2)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+
+enum EOUSIMPLEFLAGSFEATURE8
+{
+	OSF8__MIN,
+		
+	OSF8_CONSTRUCTORS = OSF8__MIN,
+	OSF8_ASSIGNFLAGSALLVALUES,
+	OSF8_QUERYFLAGSALLVALUES,
+	OSF8_SETFLAGSMASKVALUE,
+	OSF8_SIGNALFLAGSMASKVALUE,
+	OSF8_DROPFLAGSMASKVALUE,
+	OSF8_TOGGLESINGLEFLAGVALUE,
+	OSF8_MODIFYSINGLEFLAGVALUE,
+	OSF8_ASSIGNFLAGSBYMASK,
+	OSF8_ALTERFLAGSBYMASK,
+	OSF8_GETFLAGSMASKVALUE,
+	OSF8_QUERYFLAGSBYMASK,
+	OSF8_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	OSF8_ENUMSETENUMERATEDFLAGVALUE,
+	OSF8_ENUMSIGNALENUMERATEDFLAGVALUE,
+	OSF8_ENUMDROPENUMERATEDFLAGVALUE,
+	OSF8_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	OSF8_ENUMMODIFYENUMERATEDFLAGVALUE,
+	OSF8_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	OSF8_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	OSF8_ENUMGETENUMERATEDFLAGVALUE,
+	OSF8_ENUMFINDFIRSTENUMERATEDFLAG,
+	OSF8_ENUMALLSIGNALENUMERATEDFLAGS,
+	OSF8_ENUMALLDROPENUMERATEDFLAGS,
+	OSF8_ENUMALLQUERYENUMERATEDFLAGS,
+	OSF8_ENUMANYGETENUMERATEDFLAGVALUE,
+	OSF8_STOREFLAGSENUMERATEDVALUE,
+	OSF8_RETRIEVEFLAGSENUMERATEDVALUE,
+
+	OSF8__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE8, OSF8__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestSimpleFlags8_Constructors, // OSF8_CONSTRUCTORS
+	&TestSimpleFlags8_AssignFlagsAllValues, // OSF8_ASSIGNFLAGSALLVALUES,
+	&TestSimpleFlags8_QueryFlagsAllValues, // OSF8_QUERYFLAGSALLVALUES,
+	&TestSimpleFlags8_SetFlagsMaskValue, // OSF8_SETFLAGSMASKVALUE,
+	&TestSimpleFlags8_SignalFlagsMaskValue, // OSF8_SIGNALFLAGSMASKVALUE,
+	&TestSimpleFlags8_DropFlagsMaskValue, // OSF8_DROPFLAGSMASKVALUE,
+	&TestSimpleFlags8_ToggleSingleFlagValue, // OSF8_TOGGLESINGLEFLAGVALUE,
+	&TestSimpleFlags8_ModifySingleFlagValue, // OSF8_MODIFYSINGLEFLAGVALUE,
+	&TestSimpleFlags8_AssignFlagsByMask, // OSF8_ASSIGNFLAGSBYMASK,
+	&TestSimpleFlags8_AlterFlagsByMask, // OSF8_ALTERFLAGSBYMASK,
+	&TestSimpleFlags8_GetFlagsMaskValue, // OSF8_GETFLAGSMASKVALUE,
+	&TestSimpleFlags8_QueryFlagsByMask, // OSF8_QUERYFLAGSBYMASK,
+	&TestSimpleFlags8_OnlySignalSingleFlagOutOfMask, // OSF8_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	&TestSimpleFlags8_EnumSetEnumeratedFlagValue, // OSF8_ENUMSETENUMERATEDFLAGVALUE,
+	&TestSimpleFlags8_EnumSignalEnumeratedFlagValue, // OSF8_ENUMSIGNALENUMERATEDFLAGVALUE,
+	&TestSimpleFlags8_EnumDropEnumeratedFlagValue, // OSF8_ENUMDROPENUMERATEDFLAGVALUE,
+	&TestSimpleFlags8_EnumToggleEnumeratedFlagValue, // OSF8_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	&TestSimpleFlags8_EnumModifyEnumeratedFlagValue, // OSF8_ENUMMODIFYENUMERATEDFLAGVALUE,
+	&TestSimpleFlags8_EnumSignalFirstEnumeratedFlagValue, // OSF8_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	&TestSimpleFlags8_EnumSignalLastEnumeratedFlagValue, // OSF8_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	&TestSimpleFlags8_EnumGetEnumeratedFlagValue, // OSF8_ENUMGETENUMERATEDFLAGVALUE,
+	&TestSimpleFlags8_EnumFindFirstEnumeratedFlag, // OSF8_ENUMFINDFIRSTENUMERATEDFLAG,
+	&TestSimpleFlags8_EnumAllSignalEnumeratedFlags, // OSF8_ENUMALLSIGNALENUMERATEDFLAGS,
+	&TestSimpleFlags8_EnumAllDropEnumeratedFlags, // OSF8_ENUMALLDROPENUMERATEDFLAGS,
+	&TestSimpleFlags8_EnumAllQueryEnumeratedFlags, // OSF8_ENUMALLQUERYENUMERATEDFLAGS,
+	&TestSimpleFlags8_EnumAnyGetEnumeratedFlagValue, // OSF8_ENUMANYGETENUMERATEDFLAGVALUE,
+	&TestSimpleFlags8_StoreFlagsEnumeratedValue, // OSF8_STOREFLAGSENUMERATEDVALUE,
+	&TestSimpleFlags8_RetrieveFlagsEnumeratedValue, // OSF8_RETRIEVEFLAGSENUMERATEDVALUE,
+};
+static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE8, OSF8__MAX, CFeatureTestProcedure> g_afnSimpleFlags8FeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE8, OSF8__MAX, const char *>::m_aetElementArray[] =
+{
+	"Constructors", // OSF8_CONSTRUCTORS
+	"AssignFlagsAllValues", // OSF8_ASSIGNFLAGSALLVALUES,
+	"QueryFlagsAllValues", // OSF8_QUERYFLAGSALLVALUES,
+	"SetFlagsMaskValue", // OSF8_SETFLAGSMASKVALUE,
+	"SignalFlagsMaskValue", // OSF8_SIGNALFLAGSMASKVALUE,
+	"DropFlagsMaskValue", // OSF8_DROPFLAGSMASKVALUE,
+	"ToggleSingleFlagValue", // OSF8_TOGGLESINGLEFLAGVALUE,
+	"ModifySingleFlagValue", // OSF8_MODIFYSINGLEFLAGVALUE,
+	"AssignFlagsByMask", // OSF8_ASSIGNFLAGSBYMASK,
+	"AlterFlagsByMask", // OSF8_ALTERFLAGSBYMASK,
+	"GetFlagsMaskValue", // OSF8_GETFLAGSMASKVALUE,
+	"QueryFlagsByMask", // OSF8_QUERYFLAGSBYMASK,
+	"OnlySignalSingleFlagOutOfMask", // OSF8_ONLYSIGNALSINGLEFLAGOUTOFMASK,
+	"EnumSetEnumeratedFlagValue", // OSF8_ENUMSETENUMERATEDFLAGVALUE,
+	"EnumSignalEnumeratedFlagValue", // OSF8_ENUMSIGNALENUMERATEDFLAGVALUE,
+	"EnumDropEnumeratedFlagValue", // OSF8_ENUMDROPENUMERATEDFLAGVALUE,
+	"EnumToggleEnumeratedFlagValue", // OSF8_ENUMTOGGLEENUMERATEDFLAGVALUE,
+	"EnumModifyEnumeratedFlagValue", // OSF8_ENUMMODIFYENUMERATEDFLAGVALUE,
+	"EnumSignalFirstEnumeratedFlagValue", // OSF8_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE,
+	"EnumSignalLastEnumeratedFlagValue", // OSF8_ENUMSIGNALLASTENUMERATEDFLAGVALUE,
+	"EnumGetEnumeratedFlagValue", // OSF8_ENUMGETENUMERATEDFLAGVALUE,
+	"EnumFindFirstEnumeratedFlag", // OSF8_ENUMFINDFIRSTENUMERATEDFLAG,
+	"EnumAllSignalEnumeratedFlags", // OSF8_ENUMALLSIGNALENUMERATEDFLAGS,
+	"EnumAllDropEnumeratedFlags", // OSF8_ENUMALLDROPENUMERATEDFLAGS,
+	"EnumAllQueryEnumeratedFlags", // OSF8_ENUMALLQUERYENUMERATEDFLAGS,
+	"EnumAnyGetEnumeratedFlagValue", // OSF8_ENUMANYGETENUMERATEDFLAGVALUE,
+	"StoreFlagsEnumeratedValue", // OSF8_STOREFLAGSENUMERATEDVALUE,
+	"RetrieveFlagsEnumeratedValue", // OSF8_RETRIEVEFLAGSENUMERATEDVALUE,
+};
+static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE8, OSF8__MAX, const char *> g_aszSimpleFlags8FeatureTestNames;
+
+
+bool TestSimpleFlags8(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, OSF8__MAX, g_aszSimpleFlags8FeatureTestNames.GetStoragePointer(), g_afnSimpleFlags8FeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+bool TestFlagsDefines_EnumFlagsMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		int64ou iMask;
+		
+		iMask = OU_FLAGS_ENUMFLAGS_MASK(uint8ou, 1, 1);
+		if (iMask - 1 != 0)
+		{
+			break;
+		}
+	
+		iMask = OU_FLAGS_ENUMFLAGS_MASK(uint8ou, 1, OU_UINT8_BITS);
+		if (iMask ^ OU_UINT8_MAX)
+		{
+			break;
+		}
+
+		iMask = OU_FLAGS_ENUMFLAGS_MASK(uint16ou, 1, 1);
+		if (iMask - 1 != 0)
+		{
+			break;
+		}
+		
+		iMask = OU_FLAGS_ENUMFLAGS_MASK(uint16ou, 1, OU_UINT16_BITS);
+		if (iMask ^ OU_UINT16_MAX)
+		{
+			break;
+		}
+		
+		iMask = OU_FLAGS_ENUMFLAGS_MASK(uint32ou, 1, 1);
+		if (iMask - 1 != 0)
+		{
+			break;
+		}
+		
+		iMask = OU_FLAGS_ENUMFLAGS_MASK(uint32ou, 1, OU_UINT32_BITS);
+		if (iMask ^ OU_UINT32_MAX)
+		{
+			break;
+		}
+		
+		iMask = OU_FLAGS_ENUMFLAGS_MASK(uint64ou, 1, 1);
+		if (iMask - 1 != 0)
+		{
+			break;
+		}
+		
+		iMask = OU_FLAGS_ENUMFLAGS_MASK(uint64ou, 1, OU_UINT64_BITS);
+		if (iMask ^ OU_UINT64_MAX)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestFlagsDefines_EnumFlagsStartValid()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (!OU_FLAGS_ENUMFLAGS_START_VALID(uint8ou, 1, OU_UINT8_BITS))
+		{
+			break;
+		}
+/*	
+		if (OU_FLAGS_ENUMFLAGS_START_VALID(uint8ou, 1, OU_UINT8_BITS + 1))
+		{
+			break;
+		}
+*/		
+		if (!OU_FLAGS_ENUMFLAGS_START_VALID(uint16ou, 1, OU_UINT16_BITS))
+		{
+			break;
+		}
+/*		
+		if (OU_FLAGS_ENUMFLAGS_START_VALID(uint16ou, 1, OU_UINT16_BITS + 1))
+		{
+			break;
+		}
+*/		
+		if (!OU_FLAGS_ENUMFLAGS_START_VALID(uint32ou, 1, OU_UINT32_BITS))
+		{
+			break;
+		}
+/*		
+		if (OU_FLAGS_ENUMFLAGS_START_VALID(uint32ou, 1, OU_UINT32_BITS + 1))
+		{
+			break;
+		}
+*/		
+		if (!OU_FLAGS_ENUMFLAGS_START_VALID(uint64ou, 1, OU_UINT64_BITS))
+		{
+			break;
+		}
+/*		
+		if (OU_FLAGS_ENUMFLAGS_START_VALID(uint64ou, 1, OU_UINT64_BITS + 1))
+		{
+			break;
+		}
+*/		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestFlagsDefines_StoreEnumValueInMask()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 0, 1) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 1, 1))
+		{
+			break;
+		}
+
+		if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 0, OU_UINT8_MAX) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, OU_UINT8_MAX, OU_UINT8_MAX))
+		{
+			break;
+		}
+
+		if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 1, 2) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 2, 1))
+		{
+			break;
+		}
+
+		if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 0, 0) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 1, 0))
+		{
+			break;
+		}
+	
+		if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 0, 1) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 1, 1))
+		{
+			break;
+		}
+		
+		if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 0, OU_UINT16_MAX) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, OU_UINT16_MAX, OU_UINT16_MAX))
+		{
+			break;
+		}
+		
+		if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 1, 2) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 2, 1))
+		{
+			break;
+		}
+		
+		if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 0, 0) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 1, 0))
+		{
+			break;
+		}
+		
+		if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 0, 1) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 1, 1))
+		{
+			break;
+		}
+		
+		if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 0, OU_UINT32_MAX) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, OU_UINT32_MAX, OU_UINT32_MAX))
+		{
+			break;
+		}
+		
+		if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 1, 2) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 2, 1))
+		{
+			break;
+		}
+		
+		if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 0, 0) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 1, 0))
+		{
+			break;
+		}
+		
+		if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 0, 1) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 1, 1))
+		{
+			break;
+		}
+		
+		if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 0, OU_UINT64_MAX) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, OU_UINT64_MAX, OU_UINT64_MAX))
+		{
+			break;
+		}
+		
+		if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 1, 2) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 2, 1))
+		{
+			break;
+		}
+		
+		if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 0, 0) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 1, 0))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+bool TestFlagsDefines_FlagIsSingle()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (!OU_FLAGS_FLAG_IS_SINGLE(uint8ou, 1) || !OU_FLAGS_FLAG_IS_SINGLE(uint8ou, OU_INT8_MIN))
+		{
+			break;
+		}
+
+		if (OU_FLAGS_FLAG_IS_SINGLE(uint8ou, 0) || OU_FLAGS_FLAG_IS_SINGLE(uint8ou, 3) || OU_FLAGS_FLAG_IS_SINGLE(uint8ou, OU_INT8_MIN + 1))
+		{
+			break;
+		}
+	
+		if (!OU_FLAGS_FLAG_IS_SINGLE(uint16ou, 1) || !OU_FLAGS_FLAG_IS_SINGLE(uint16ou, OU_INT16_MIN))
+		{
+			break;
+		}
+		
+		if (OU_FLAGS_FLAG_IS_SINGLE(uint16ou, 0) || OU_FLAGS_FLAG_IS_SINGLE(uint16ou, 3) || OU_FLAGS_FLAG_IS_SINGLE(uint16ou, OU_INT16_MIN + 1))
+		{
+			break;
+		}
+		
+		if (!OU_FLAGS_FLAG_IS_SINGLE(uint32ou, 1) || !OU_FLAGS_FLAG_IS_SINGLE(uint32ou, OU_INT32_MIN))
+		{
+			break;
+		}
+		
+		if (OU_FLAGS_FLAG_IS_SINGLE(uint32ou, 0) || OU_FLAGS_FLAG_IS_SINGLE(uint32ou, 3) || OU_FLAGS_FLAG_IS_SINGLE(uint32ou, OU_INT32_MIN + 1))
+		{
+			break;
+		}
+		
+		if (!OU_FLAGS_FLAG_IS_SINGLE(uint64ou, 1) || !OU_FLAGS_FLAG_IS_SINGLE(uint64ou, OU_INT64_MIN))
+		{
+			break;
+		}
+		
+		if (OU_FLAGS_FLAG_IS_SINGLE(uint64ou, 0) || OU_FLAGS_FLAG_IS_SINGLE(uint64ou, 3) || OU_FLAGS_FLAG_IS_SINGLE(uint64ou, OU_INT64_MIN + 1))
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+
+enum EOUFLAGSDEFINESFEATURE
+{
+	OFF__MIN,
+	
+	OFF_ENUMFLAGS_MASK = OFF__MIN,
+	OFF_ENUMFLAGS_START_VALID,
+	OFF_STOREENUM_VALUE_IN_MASK,
+	OFF_FLAG_IS_SINGLE,
+	
+	OFF__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUFLAGSDEFINESFEATURE, OFF__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestFlagsDefines_EnumFlagsMask, // OFF_ENUMFLAGS_MASK,
+	&TestFlagsDefines_EnumFlagsStartValid, // OFF_ENUMFLAGS_START_VALID,
+	&TestFlagsDefines_StoreEnumValueInMask, // OFF_STOREENUM_VALUE_IN_MASK,
+	&TestFlagsDefines_FlagIsSingle, // OFF_FLAG_IS_SINGLE,
+};
+static const CEnumUnsortedElementArray<EOUFLAGSDEFINESFEATURE, OFF__MAX, CFeatureTestProcedure> g_afnFlagsDefineFeatureTestProcedures;
+
+template<>const char *const CEnumUnsortedElementArray<EOUFLAGSDEFINESFEATURE, OFF__MAX, const char *>::m_aetElementArray[] =
+{
+	"ENUMFLAGS_MASK", // OFF_ENUMFLAGS_MASK = OFF__MIN,
+	"ENUMFLAGS_START_VALID", // OFF_ENUMFLAGS_START_VALID,
+	"STOREENUM_VALUE_IN_MASK", // OFF_STOREENUM_VALUE_IN_MASK,
+	"FLAG_IS_SINGLE", // OFF_FLAG_IS_SINGLE,
+};
+static const CEnumUnsortedElementArray<EOUFLAGSDEFINESFEATURE, OFF__MAX, const char *> g_aszFlagsDefineFeatureTestNames;
+
+
+bool TestFlagsDefines(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, OFF__MAX, g_aszFlagsDefineFeatureTestNames.GetStoragePointer(), g_afnFlagsDefineFeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+enum EENUMARRAYTESTENUM
+{
+	ATE__MIN,
+
+	ATE_FIRSTELEMENT = ATE__MIN,
+	ATE_SECONDELEMENT,
+	ATE_THIRDELEMENT,
+
+	ATE__MAX,
+};
+
+template<>
+const int CEnumUnsortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, int>::m_aetElementArray[] =
+{
+	1, // ATE_FIRSTELEMENT,
+	3, // ATE_SECONDELEMENT,
+	2, // ATE_THIRDELEMENT,
+};
+static const CEnumUnsortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, int> g_ai_IntUnsortedArray;
+
+template<>
+const int CEnumSortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, int>::m_aetElementArray[] =
+{
+	1, // ATE_FIRSTELEMENT,
+	2, // ATE_SECONDELEMENT,
+	3, // ATE_THIRDELEMENT,
+};
+static const CEnumSortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, int> g_ai_IntSortedArray;
+
+struct ConstCharPtrEq
+{
+	bool operator ()(const char *szLeftValue, const char *szRightValue) const
+	{
+		return strcmp(szLeftValue, szRightValue) == 0;
+	}
+};
+
+struct ConstCharPtrLess
+{
+	bool operator ()(const char *szLeftValue, const char *szRightValue) const
+	{
+		return strcmp(szLeftValue, szRightValue) < 0;
+	}
+};
+
+template<>
+const char *const CEnumUnsortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, const char *, 0, ConstCharPtrEq>::m_aetElementArray[] =
+{
+	"first",
+	"third",
+	"second",
+};
+static const CEnumUnsortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, const char *, 0, ConstCharPtrEq> g_aszStringUnsortedArray;
+
+template<>
+const char *const CEnumSortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, const char *, 0, ConstCharPtrLess>::m_aetElementArray[] =
+{
+	"first",
+	"second",
+	"third",
+};
+static const CEnumSortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, const char *, 0, ConstCharPtrLess> g_aszStringSortedArray;
+
+
+bool TestEnumArrays_UnsortedArray()
+{
+	EENUMARRAYTESTENUM teEnumCurrent = ATE__MIN;
+	
+	for (; teEnumCurrent != ATE__MAX; ++teEnumCurrent)
+	{
+		int iCurrentValue = g_ai_IntUnsortedArray.Encode(teEnumCurrent);
+		EENUMARRAYTESTENUM teIntDecodeCheck = g_ai_IntUnsortedArray.Decode(iCurrentValue);
+		
+		if (!g_ai_IntUnsortedArray.IsValidDecode(teIntDecodeCheck) || teIntDecodeCheck != teEnumCurrent)
+		{
+			break;
+		}
+
+		if (g_ai_IntUnsortedArray.GetStoragePointer()[teEnumCurrent] != iCurrentValue)
+		{
+			break;
+		}
+
+		const char *szCurrentString = g_aszStringUnsortedArray.Encode(teEnumCurrent);
+		EENUMARRAYTESTENUM teStringDecodeCheck = g_aszStringUnsortedArray.Decode(szCurrentString);
+		
+		if (!g_aszStringUnsortedArray.IsValidDecode(teStringDecodeCheck) || teStringDecodeCheck != teEnumCurrent)
+		{
+			break;
+		}
+
+		if (strcmp(g_aszStringUnsortedArray.GetStoragePointer()[teEnumCurrent], szCurrentString) != 0)
+		{
+			break;
+		}
+
+		EENUMARRAYTESTENUM teInvalidDecodeCheck = g_aszStringUnsortedArray.Decode(szCurrentString + 1);
+		if (teInvalidDecodeCheck != ATE__MAX || g_aszStringUnsortedArray.IsValidDecode(teInvalidDecodeCheck))
+		{
+			break;
+		}
+	}
+
+	bool bResult = teEnumCurrent == ATE__MAX;
+	return bResult;
+}
+
+bool TestEnumArrays_SortedArray()
+{
+	EENUMARRAYTESTENUM teEnumCurrent = ATE__MIN;
+	
+	for (; teEnumCurrent != ATE__MAX; ++teEnumCurrent)
+	{
+		int iCurrentValue = g_ai_IntSortedArray.Encode(teEnumCurrent);
+		EENUMARRAYTESTENUM teIntDecodeCheck = g_ai_IntSortedArray.Decode(iCurrentValue);
+		
+		if (!g_ai_IntSortedArray.IsValidDecode(teIntDecodeCheck) || teIntDecodeCheck != teEnumCurrent)
+		{
+			break;
+		}
+
+		if (g_ai_IntSortedArray.GetStoragePointer()[teEnumCurrent] != iCurrentValue)
+		{
+			break;
+		}
+
+		const char *szCurrentString = g_aszStringSortedArray.Encode(teEnumCurrent);
+		EENUMARRAYTESTENUM teStringDecodeCheck = g_aszStringSortedArray.Decode(szCurrentString);
+		
+		if (!g_aszStringSortedArray.IsValidDecode(teStringDecodeCheck) || teStringDecodeCheck != teEnumCurrent)
+		{
+			break;
+		}
+
+		if (strcmp(g_aszStringSortedArray.GetStoragePointer()[teEnumCurrent], szCurrentString) != 0)
+		{
+			break;
+		}
+
+		EENUMARRAYTESTENUM teInvalidDecodeCheck = g_aszStringSortedArray.Decode(szCurrentString + 1);
+		if (teInvalidDecodeCheck != ATE__MAX || g_aszStringSortedArray.IsValidDecode(teInvalidDecodeCheck))
+		{
+			break;
+		}
+	}
+
+	bool bResult = teEnumCurrent == ATE__MAX;
+	return bResult;
+}
+
+
+enum EOUENUMARRAYSFEATURE
+{
+	ORF__MIN,
+
+	ORF_UNSORTEDARRAY = ORF__MIN,
+	ORF_SORTEDARRAY,
+
+	ORF__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUENUMARRAYSFEATURE, ORF__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestEnumArrays_UnsortedArray, // ORF_UNSORTEDARRAY,
+	&TestEnumArrays_SortedArray, // ORF_SORTEDARRAY,
+};
+static const CEnumUnsortedElementArray<EOUENUMARRAYSFEATURE, ORF__MAX, CFeatureTestProcedure> g_afnEnumArrayFeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUENUMARRAYSFEATURE, ORF__MAX, const char *>::m_aetElementArray[] =
+{
+	"Unsorted Array", // ORF_UNSORTEDARRAY,
+	"Sorted Array", // ORF_SORTEDARRAY,
+};
+static const CEnumUnsortedElementArray<EOUENUMARRAYSFEATURE, ORF__MAX, const char *> g_aszEnumArrayFeatureTestNames;
+
+
+bool TestEnumArrays(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, ORF__MAX, g_aszEnumArrayFeatureTestNames.GetStoragePointer(), g_afnEnumArrayFeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+enum ETESTTEMPLATES8
+{
+	TT8_ONE,
+	TT8_TWO,
+};
+
+enum ETESTTEMPLATES16
+{
+	TT16_ONE = 1000,
+	TT16_TWO,
+};
+
+enum ETESTTEMPLATES32
+{
+	TT32_ONE = 100000,
+	TT32_TWO,
+};
+
+
+bool TestTemplates_PrefixIncrement()
+{
+	bool bResult = false;
+
+	do
+	{
+		ETESTTEMPLATES8 t8Test = TT8_ONE;
+		ETESTTEMPLATES16 t16Test = TT16_ONE;
+		ETESTTEMPLATES32 t32Test = TT32_ONE;
+
+		if (++t8Test != TT8_TWO || t8Test != TT8_TWO)
+		{
+			break;
+		}
+
+		++t8Test = TT8_ONE;
+		if (t8Test != TT8_ONE)
+		{
+			break;
+		}
+
+		if (++t16Test != TT16_TWO || t16Test != TT16_TWO)
+		{
+			break;
+		}
+
+		++t16Test = TT16_ONE;
+		if (t16Test != TT16_ONE)
+		{
+			break;
+		}
+
+		if (++t32Test != TT32_TWO || t32Test != TT32_TWO)
+		{
+			break;
+		}
+
+		++t32Test = TT32_ONE;
+		if (t32Test != TT32_ONE)
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+
+	return bResult;
+}
+
+bool TestTemplates_PostfixIncrement()
+{
+	bool bResult = false;
+
+	do
+	{
+		ETESTTEMPLATES8 t8Test = TT8_ONE;
+		ETESTTEMPLATES16 t16Test = TT16_ONE;
+		ETESTTEMPLATES32 t32Test = TT32_ONE;
+
+		if (t8Test++ != TT8_ONE || t8Test != TT8_TWO)
+		{
+			break;
+		}
+
+		if (t16Test++ != TT16_ONE || t16Test != TT16_TWO)
+		{
+			break;
+		}
+
+		if (t32Test++ != TT32_ONE || t32Test != TT32_TWO)
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+
+	return bResult;
+}
+
+bool TestTemplates_PrefixDecrement()
+{
+	bool bResult = false;
+
+	do
+	{
+		ETESTTEMPLATES8 t8Test = TT8_TWO;
+		ETESTTEMPLATES16 t16Test = TT16_TWO;
+		ETESTTEMPLATES32 t32Test = TT32_TWO;
+
+		if (--t8Test != TT8_ONE || t8Test != TT8_ONE)
+		{
+			break;
+		}
+
+		--t8Test = TT8_TWO;
+		if (t8Test != TT8_TWO)
+		{
+			break;
+		}
+
+		if (--t16Test != TT16_ONE || t16Test != TT16_ONE)
+		{
+			break;
+		}
+
+		--t16Test = TT16_TWO;
+		if (t16Test != TT16_TWO)
+		{
+			break;
+		}
+
+		if (--t32Test != TT32_ONE || t32Test != TT32_ONE)
+		{
+			break;
+		}
+
+		--t32Test = TT32_TWO;
+		if (t32Test != TT32_TWO)
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+
+	return bResult;
+}
+
+bool TestTemplates_PostfixDecrement()
+{
+	bool bResult = false;
+
+	do
+	{
+		ETESTTEMPLATES8 t8Test = TT8_TWO;
+		ETESTTEMPLATES16 t16Test = TT16_TWO;
+		ETESTTEMPLATES32 t32Test = TT32_TWO;
+
+		if (t8Test-- != TT8_TWO || t8Test != TT8_ONE)
+		{
+			break;
+		}
+
+		if (t16Test-- != TT16_TWO || t16Test != TT16_ONE)
+		{
+			break;
+		}
+
+		if (t32Test-- != TT32_TWO || t32Test != TT32_ONE)
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+
+	return bResult;
+}
+
+bool TestTemplates_IsEmptySz()
+{
+	bool bResult = false;
+
+	do
+	{
+		const char *szData = "a";
+		const char *szEmpty = "";
+		const char *szNull = NULL;
+
+		if (IsEmptySz(szData) || !IsEmptySz(szEmpty) || !IsEmptySz(szNull))
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+
+	return bResult;
+}
+
+
+enum EOUTEMPLATESFEATURE
+{
+	OTF__MIN,
+
+	OTF_PREFIXINCREMENT = OTF__MIN,
+	OTF_POSTFIXINCREMENT,
+	OTF_PREFIXDECREMENT,
+	OTF_POSTFIXDECREMENT,
+	OTF_ISEMPTYSZ,
+
+	OTF__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUTEMPLATESFEATURE, OTF__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestTemplates_PrefixIncrement, // OTF_PREFIXINCREMENT,
+	&TestTemplates_PostfixIncrement, // OTF_POSTFIXINCREMENT,
+	&TestTemplates_PrefixDecrement, // OTF_PREFIXDECREMENT,
+	&TestTemplates_PostfixDecrement, // OTF_POSTFIXDECREMENT,
+	&TestTemplates_IsEmptySz, // OTF_ISEMPTYSZ,
+};
+static const CEnumUnsortedElementArray<EOUTEMPLATESFEATURE, OTF__MAX, CFeatureTestProcedure> g_afnTemplateFeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUTEMPLATESFEATURE, OTF__MAX, const char *>::m_aetElementArray[] =
+{
+	"Prefix Increment", // OTF_PREFIXINCREMENT,
+	"Postfix Increment", // OTF_POSTFIXINCREMENT,
+	"Prefix Decrement", // OTF_PREFIXDECREMENT,
+	"Postfix Decrement", // OTF_POSTFIXDECREMENT,
+	"IsEmptySz", // OTF_ISEMPTYSZ,
+};
+static const CEnumUnsortedElementArray<EOUTEMPLATESFEATURE, OTF__MAX, const char *> g_aszTemplateFeatureTestNames;
+
+
+bool TestTemplates(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, OTF__MAX, g_aszTemplateFeatureTestNames.GetStoragePointer(), g_afnTemplateFeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+typedef CTypeSimpleWrapper<int> CTestWrapper;
+
+bool TestTypeWrappers_Constructors()
+{
+	CTestWrapper twEmptyWrapper;
+	CTestWrapper twZeroWrapper(0);
+	CTestWrapper twCopyWrapper(twZeroWrapper);
+
+	return true;
+}
+
+bool TestTypeWrappers_Comparison()
+{
+	bool bResult = false;
+
+	do
+	{
+		CTestWrapper twOneWrapper(1);
+		CTestWrapper twTwoWrapper(2);
+
+		if (!(twTwoWrapper == twTwoWrapper) || twOneWrapper == twTwoWrapper)
+		{
+			break;
+		}
+
+		if (twTwoWrapper != twTwoWrapper || !(twOneWrapper != twTwoWrapper))
+		{
+			break;
+		}
+
+		if (!(twOneWrapper < twTwoWrapper) || twTwoWrapper < twTwoWrapper || twTwoWrapper < twOneWrapper)
+		{
+			break;
+		}
+
+		if (twOneWrapper > twTwoWrapper || twTwoWrapper > twTwoWrapper || !(twTwoWrapper > twOneWrapper))
+		{
+			break;
+		}
+
+		if (!(twOneWrapper <= twTwoWrapper) || !(twTwoWrapper <= twTwoWrapper) || twTwoWrapper <= twOneWrapper)
+		{
+			break;
+		}
+
+		if (twOneWrapper >= twTwoWrapper || !(twTwoWrapper >= twTwoWrapper) || !(twTwoWrapper >= twOneWrapper))
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+
+	return bResult;
+}
+
+bool TestTypeWrappers_BoolCasts()
+{
+	bool bResult = false;
+
+	do
+	{
+		CTestWrapper twZeroWrapper(0);
+		CTestWrapper twOneWrapper(1);
+/* -- cast to bool is commented in definition
+		if (twZeroWrapper || !(false || twOneWrapper))
+		{
+			break;
+		}
+*/
+		if (!(!twZeroWrapper) || !twOneWrapper)
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+
+	return bResult;
+}
+
+bool TestTypeWrappers_Assignment()
+{
+	bool bResult = false;
+
+	do
+	{
+		CTestWrapper twZeroWrapper(0);
+		CTestWrapper twOneWrapper(1);
+
+		CTestWrapper twTestWrapper;
+
+		CTestWrapper &twFirstAssignmentReference = (twTestWrapper = (CTestWrapper::value_type)1);
+
+		if (twTestWrapper != twOneWrapper || &twFirstAssignmentReference != &twTestWrapper)
+		{
+			break;
+		}
+
+		CTestWrapper &twSecondAssignmentReference = (twTestWrapper = twZeroWrapper);
+
+		if (twTestWrapper != twZeroWrapper || &twSecondAssignmentReference != &twTestWrapper)
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+
+	return bResult;
+}
+
+bool TestTypeWrappers_DataCast()
+{
+	bool bResult = false;
+
+	do
+	{
+		const CTestWrapper twZeroWrapper(0);
+		CTestWrapper twOneWrapper(1);
+
+		const CTestWrapper::value_type &wtZeroValue = (const CTestWrapper::value_type &)twZeroWrapper;
+		CTestWrapper::value_type &wtOneValue = (CTestWrapper::value_type &)twOneWrapper;
+
+		if (wtZeroValue != 0 || wtOneValue != 1)
+		{
+			break;
+		}
+
+		wtOneValue = 0;
+
+		if (twOneWrapper != twZeroWrapper)
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+
+	return bResult;
+}
+
+bool TestTypeWrappers_DataComparison()
+{
+	bool bResult = false;
+
+	do
+	{
+		const CTestWrapper twZeroWrapper(0);
+		const CTestWrapper twOneWrapper(1);
+
+		const CTestWrapper::value_type &wtZeroValue = twZeroWrapper;
+		const CTestWrapper::value_type &wtOneValue = twOneWrapper;
+
+		if (!(twZeroWrapper == wtZeroValue) || (twZeroWrapper == wtOneValue))
+		{
+			break;
+		}
+
+		if (!(wtZeroValue == twZeroWrapper) || (wtOneValue == twZeroWrapper))
+		{
+			break;
+		}
+
+		if ((twZeroWrapper != wtZeroValue) || !(twZeroWrapper != wtOneValue))
+		{
+			break;
+		}
+
+		if ((wtZeroValue != twZeroWrapper) || !(wtOneValue != twZeroWrapper))
+		{
+			break;
+		}
+
+		if ((twZeroWrapper < wtZeroValue) || !(twZeroWrapper < wtOneValue) || (twOneWrapper < wtZeroValue))
+		{
+			break;
+		}
+
+		if ((wtZeroValue < twZeroWrapper) || (wtOneValue < twZeroWrapper) || !(wtZeroValue < twOneWrapper))
+		{
+			break;
+		}
+
+		if ((twZeroWrapper > wtZeroValue) || (twZeroWrapper > wtOneValue) || !(twOneWrapper > wtZeroValue))
+		{
+			break;
+		}
+
+		if ((wtZeroValue > twZeroWrapper) || !(wtOneValue > twZeroWrapper) || (wtZeroValue > twOneWrapper))
+		{
+			break;
+		}
+
+		if (!(twZeroWrapper <= wtZeroValue) || !(twZeroWrapper <= wtOneValue) || (twOneWrapper <= wtZeroValue))
+		{
+			break;
+		}
+
+		if (!(wtZeroValue <= twZeroWrapper) || (wtOneValue <= twZeroWrapper) || !(wtZeroValue <= twOneWrapper))
+		{
+			break;
+		}
+
+		if (!(twZeroWrapper >= wtZeroValue) || (twZeroWrapper >= wtOneValue) || !(twOneWrapper >= wtZeroValue))
+		{
+			break;
+		}
+
+		if (!(wtZeroValue >= twZeroWrapper) || !(wtOneValue >= twZeroWrapper) || (wtZeroValue >= twOneWrapper))
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+
+	return bResult;
+}
+
+
+enum EOUTYPEWRAPPERFEATURE
+{
+	OWF__MIN,
+
+	OWF_CONSTRUCTORS = OWF__MIN,
+	OWF_COMPARISON,
+	OWF_BOOLCASTS,
+	OWF_ASSIGNMENT,
+	OWF_DATACAST,
+	OWF_DATACOMPARISON,
+
+	OWF__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUTYPEWRAPPERFEATURE, OWF__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestTypeWrappers_Constructors, // OWF_CONSTRUCTORS,
+	&TestTypeWrappers_Comparison, // OWF_COMPARISON,
+	&TestTypeWrappers_BoolCasts, // OWF_BOOLCASTS,
+	&TestTypeWrappers_Assignment, // OWF_ASSIGNMENT,
+	&TestTypeWrappers_DataCast, // OWF_DATACAST,
+	&TestTypeWrappers_DataComparison, // OWF_DATACOMPARISON,
+};
+static const CEnumUnsortedElementArray<EOUTYPEWRAPPERFEATURE, OWF__MAX, CFeatureTestProcedure> g_afnTypeWrapperFeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUTYPEWRAPPERFEATURE, OWF__MAX, const char *>::m_aetElementArray[] =
+{
+	"Constructors", // OWF_CONSTRUCTORS,
+	"Comparison Operators", // OWF_COMPARISON,
+	"Boolean Casts", // OWF_BOOLCASTS,
+	"Assignment Operators", // OWF_ASSIGNMENT,
+	"Data Cast", // OWF_DATACAST,
+	"Data Comparisons", // OWF_DATACOMPARISON,
+};
+static const CEnumUnsortedElementArray<EOUTYPEWRAPPERFEATURE, OWF__MAX, const char *> g_aszTypeWrapperFeatureTestNames;
+
+
+bool TestTypeWrapper(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, OWF__MAX, g_aszTypeWrapperFeatureTestNames.GetStoragePointer(), g_afnTypeWrapperFeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+struct CTestCustomizations_Asserts_FailureInfo
+{
+	EASSERTIONFAILURESEVERITY m_fsFailureSeverity;
+	const char *m_szAssertionExpression;
+	const char *m_szAssertionFileName;
+	unsigned int m_uiAssertionSourceLine;
+};
+
+static const CTestCustomizations_Asserts_FailureInfo g_fiAssertInvalidInfo = { AFS__MAX, NULL, NULL, 0  };
+static CTestCustomizations_Asserts_FailureInfo g_fiAssertLastInfo;
+
+void _OU_CONVENTION_CALLBACK TestCustomizations_Asserts_AssertionFailure(EASSERTIONFAILURESEVERITY fsFailureSeverity, 
+	const char *szAssertionExpression, const char *szAssertionFileName, unsigned int uiAssertionSourceLine)
+{
+	g_fiAssertLastInfo.m_fsFailureSeverity = fsFailureSeverity;
+	g_fiAssertLastInfo.m_szAssertionExpression = szAssertionExpression;
+	g_fiAssertLastInfo.m_szAssertionFileName = szAssertionFileName;
+	g_fiAssertLastInfo.m_uiAssertionSourceLine = uiAssertionSourceLine;
+}
+
+
+bool TestCustomizations_Asserts()
+{
+	bool bResult = false;
+
+	CAssertionFailedProcedure fnAssertOldHandler = CAssertionCheckCustomization::GetAssertFailureCustomHandler();
+	CAssertionCheckCustomization::CustomizeAssertionChecks(&TestCustomizations_Asserts_AssertionFailure);
+
+	do
+	{
+#if !defined(NDEBUG)
+		// Only callback invocation is checked here.
+		// Availability of functionality depending on preprocessor defines
+		// is verified in OST_ASSERT subsystem.
+
+		OU_ASSERT(false); // const unsigned int uiAssertToVerifyLines = 14; -- see further in code
+
+		if (g_fiAssertLastInfo.m_fsFailureSeverity != AFS_ASSERT
+			|| g_fiAssertLastInfo.m_szAssertionExpression == NULL
+			|| g_fiAssertLastInfo.m_szAssertionFileName == NULL
+			|| strcmp(g_fiAssertLastInfo.m_szAssertionFileName, __FILE__) != 0
+			|| g_fiAssertLastInfo.m_uiAssertionSourceLine == 0)
+		{
+			break;
+		}
+
+		CTestCustomizations_Asserts_FailureInfo fiAssertFailureInfoSave = g_fiAssertLastInfo;
+		g_fiAssertLastInfo = g_fiAssertInvalidInfo;
+
+		OU_VERIFY(false); const unsigned int uiAssertToVerifyLines = 14;
+
+		if (g_fiAssertLastInfo.m_fsFailureSeverity != AFS_ASSERT
+			|| g_fiAssertLastInfo.m_szAssertionExpression == NULL
+			|| strcmp(g_fiAssertLastInfo.m_szAssertionExpression, fiAssertFailureInfoSave.m_szAssertionExpression) != 0
+			|| g_fiAssertLastInfo.m_szAssertionFileName == NULL
+			|| strcmp(g_fiAssertLastInfo.m_szAssertionFileName, __FILE__) != 0
+			|| g_fiAssertLastInfo.m_uiAssertionSourceLine != fiAssertFailureInfoSave.m_uiAssertionSourceLine + uiAssertToVerifyLines)
+		{
+			break;
+		}
+
+		g_fiAssertLastInfo = g_fiAssertInvalidInfo;
+
+
+#endif // #if !defined(NDEBUG)
+
+/* -- can't verify OU_CHECK() as it crashes the application on failure
+		OU_CHECK(false);
+
+		if (g_fiAssertLastInfo.m_fsFailureSeverity != AFS_CHECK
+			|| g_fiAssertLastInfo.m_szAssertionExpression == NULL
+			|| g_fiAssertLastInfo.m_szAssertionFileName == NULL
+			|| strcmp(g_fiAssertLastInfo.m_szAssertionFileName, __FILE__) != 0
+			|| g_fiAssertLastInfo.m_uiAssertionSourceLine == 0)
+		{
+			break;
+		}
+*/
+		bResult = true;
+	}
+	while (false);
+
+	CAssertionCheckCustomization::CustomizeAssertionChecks(fnAssertOldHandler);
+
+	return bResult;
+}
+
+void *const g_pv_MallocResult = (void *)(size_t)0x12345678;
+bool g_bMallocInvocation = false, g_bReallocInvocation = false;
+bool g_bFreeInvocation = false, g_bFreeSuccess = false;
+
+void *_OU_CONVENTION_CALLBACK TestCustomizations_MemMgr_Alloc(size_t nBlockSize)
+{
+	g_bMallocInvocation = true;
+	return (void *)((ptrdiff_t)g_pv_MallocResult + nBlockSize);
+}
+
+void *_OU_CONVENTION_CALLBACK TestCustomizations_MemMgr_Realloc(void *pv_OldBlock, size_t nBlockNewSize)
+{
+	g_bReallocInvocation = true;
+	return (void *)((ptrdiff_t)pv_OldBlock - nBlockNewSize);
+}
+
+void _OU_CONVENTION_CALLBACK TestCustomizations_MemMgr_Free(void *pv_OldBlock)
+{
+	g_bFreeInvocation = true;
+	g_bFreeSuccess = pv_OldBlock == g_pv_MallocResult;
+}
+
+
+bool TestCustomizations_MemMgr()
+{
+	bool bResult = false;
+
+	CMemoryAllocationProcedure fnAllocationOldProcedure = CMemoryManagerCustomization::GetMemoryAllocationCustomProcedure();
+	CMemoryReallocationProcedure fnReallocationOldProcedure = CMemoryManagerCustomization::GetMemoryReallocationCustomProcedure();
+	CMemoryDeallocationProcedure fnDeallocationOldProcedure = CMemoryManagerCustomization::GetMemoryDeallocationCustomProcedure();
+	CMemoryManagerCustomization::CustomizeMemoryManager(&TestCustomizations_MemMgr_Alloc, &TestCustomizations_MemMgr_Realloc, &TestCustomizations_MemMgr_Free);
+
+	do
+	{
+		const size_t nBlockSize = 0x1000;
+
+		void *pv_BlockAllocated = AllocateMemoryBlock(nBlockSize);
+
+		if (!g_bMallocInvocation 
+			|| pv_BlockAllocated != (void *)((size_t)g_pv_MallocResult + nBlockSize))
+		{
+			break;
+		}
+
+		void *pv_BlockReallocated = ReallocateMemoryBlock(pv_BlockAllocated, 2 * nBlockSize);
+
+		if (!g_bReallocInvocation 
+			|| pv_BlockReallocated != (void *)((size_t)g_pv_MallocResult - nBlockSize))
+		{
+			break;
+		}
+
+		FreeMemoryBlock(g_pv_MallocResult);
+
+		if (!g_bFreeInvocation || !g_bFreeSuccess)
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+
+	CMemoryManagerCustomization::CustomizeMemoryManager(fnAllocationOldProcedure, fnReallocationOldProcedure, fnDeallocationOldProcedure);
+
+	return bResult;
+}
+
+
+enum EOUCUSTOMIZATIONFEATURE
+{
+	OCF__MIN,
+		
+	OCF_ASSERTS = OCF__MIN,
+	OCF_MEMMGR,
+		
+	OCF__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUCUSTOMIZATIONFEATURE, OCF__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestCustomizations_Asserts, // OCF_ASSERTS,
+	&TestCustomizations_MemMgr, // OCF_MEMMGR,
+};
+static const CEnumUnsortedElementArray<EOUCUSTOMIZATIONFEATURE, OCF__MAX, CFeatureTestProcedure> g_afnCustomizationFeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUCUSTOMIZATIONFEATURE, OCF__MAX, const char *>::m_aetElementArray[] =
+{
+	"Asserts", // OCF_ASSERTS,
+	"Memory Manager", // OCF_MEMMGR,
+};
+static const CEnumUnsortedElementArray<EOUCUSTOMIZATIONFEATURE, OCF__MAX, const char *> g_aszCustomizationFeatureTestNames;
+
+
+bool TestCustomization(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, OCF__MAX, g_aszCustomizationFeatureTestNames.GetStoragePointer(), g_afnCustomizationFeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+static const size_t g_nTestMallocBlockInitialSize = 1001;
+static const size_t g_nTestMallocBlockNextSize = 65501;
+static const uint8ou g_uiTestMallocToken = 0xAA;
+static void *g_pv_MemoryBlock = NULL;
+
+bool TestMallocs_Allocate()
+{
+	bool bResult = false;
+
+	do
+	{
+		g_pv_MemoryBlock = AllocateMemoryBlock(g_nTestMallocBlockInitialSize);
+
+		if (g_pv_MemoryBlock == NULL || OU_ALIGNED_SIZE((size_t)g_pv_MemoryBlock, _OU_MEMORY_REQUIRED_ALIGNMENT) != (size_t)g_pv_MemoryBlock)
+		{
+			break;
+		}
+
+		*((uint8ou *)g_pv_MemoryBlock + g_nTestMallocBlockInitialSize - 1) = g_uiTestMallocToken;
+		
+		bResult = true;
+	}
+	while (false);
+
+	return bResult;
+}
+
+bool TestMallocs_Reallocate()
+{
+	OU_ASSERT(g_nTestMallocBlockNextSize > g_nTestMallocBlockInitialSize);
+
+	bool bResult = false;
+
+	do
+	{
+		void *pv_OldMemoryBlock = g_pv_MemoryBlock;
+		g_pv_MemoryBlock = ReallocateMemoryBlock(pv_OldMemoryBlock, g_nTestMallocBlockNextSize);
+
+		if (g_pv_MemoryBlock == NULL || OU_ALIGNED_SIZE((size_t)g_pv_MemoryBlock, _OU_MEMORY_REQUIRED_ALIGNMENT) != (size_t)g_pv_MemoryBlock)
+		{
+			break;
+		}
+
+		if (*((uint8ou *)g_pv_MemoryBlock + g_nTestMallocBlockInitialSize - 1) != g_uiTestMallocToken)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+
+	return bResult;
+}
+
+bool TestMallocs_Deallocate()
+{
+	FreeMemoryBlock(g_pv_MemoryBlock);
+
+	FreeMemoryBlock(NULL); // Free must survive NULL-pointer
+
+	return true;
+}
+
+
+enum EOUMALLOCFEATURE
+{
+	OLF__MIN,
+		
+	OLF_ALLOCATE = OLF__MIN,
+	OLF_REALLOCATE,
+	OLF_DEALLOCATE,
+		
+	OLF__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUMALLOCFEATURE, OLF__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestMallocs_Allocate, // OLF_ALLOCATE,
+	&TestMallocs_Reallocate, // OLF_REALLOCATE,
+	&TestMallocs_Deallocate, // OLF_DEALLOCATE,
+};
+static const CEnumUnsortedElementArray<EOUMALLOCFEATURE, OLF__MAX, CFeatureTestProcedure> g_afnMallocFeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUMALLOCFEATURE, OLF__MAX, const char *>::m_aetElementArray[] =
+{
+	"AllocateMemoryBlock", // OLF_ALLOCATE,
+	"ReallocateMemoryBlock", // OLF_REALLOCATE,
+	"FreeMemoryBlock", // OLF_DEALLOCATE,
+};
+static const CEnumUnsortedElementArray<EOUMALLOCFEATURE, OLF__MAX, const char *> g_aszMallocFeatureTestNames;
+
+
+bool TestMalloc(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, OLF__MAX, g_aszMallocFeatureTestNames.GetStoragePointer(), g_afnMallocFeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+bool TestAsserts_FalseFunction(bool &bVarInvocation)
+{
+	bool bResult = true;
+	bVarInvocation = !bVarInvocation;
+
+	bool *pv_Pointer = &bResult;
+	if (pv_Pointer)
+	{
+		bResult = false;
+	}
+
+	return bResult;
+}
+
+bool TestAsserts_TrueFunction(bool &bVarInvocation)
+{
+	bool bResult = false;
+	bVarInvocation = !bVarInvocation;
+	
+	bool *pv_Pointer = &bResult;
+	if (pv_Pointer)
+	{
+		bResult = true;
+	}
+	
+	return bResult;
+}
+
+bool TestAsserts_Assert()
+{
+	bool bNDebugInvocation = false, bOrdinaryInvocation = false;
+
+#if defined(NDEBUG)
+	
+	OU_ASSERT(TestAsserts_FalseFunction(bNDebugInvocation));
+
+	bOrdinaryInvocation = true;
+
+#endif // #if defined(NDEBUG)
+	
+	OU_ASSERT(TestAsserts_TrueFunction(bOrdinaryInvocation));
+
+	return !bNDebugInvocation && bOrdinaryInvocation;
+}
+
+bool TestAsserts_Verify()
+{
+	bool bNDebugInvocation = false, bOrdinaryInvocation = false;
+	
+#if defined(NDEBUG)
+	
+	OU_VERIFY(TestAsserts_FalseFunction(bNDebugInvocation));
+	
+
+#else // #if !defined(NDEBUG)
+
+	bNDebugInvocation = true;
+
+
+#endif // #if !defined(NDEBUG)
+	
+	OU_VERIFY(TestAsserts_TrueFunction(bOrdinaryInvocation));
+	
+	return bNDebugInvocation && bOrdinaryInvocation;
+}
+
+bool TestAsserts_Check()
+{
+	bool bOrdinaryInvocation = false;
+	
+	OU_CHECK(TestAsserts_TrueFunction(bOrdinaryInvocation));
+	
+	return bOrdinaryInvocation;
+}
+
+
+enum EOUASSERTFEATURE
+{
+	OEF__MIN,
+		
+	OEF_ASSERT = OEF__MIN,
+	OEF_VERIFY,
+	OEF_CHECK,
+	
+	OEF__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUASSERTFEATURE, OEF__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestAsserts_Assert, // OEF_ASSERT,
+	&TestAsserts_Verify, // OEF_VERIFY,
+	&TestAsserts_Check, // OEF_CHECK,
+		
+};
+static const CEnumUnsortedElementArray<EOUASSERTFEATURE, OEF__MAX, CFeatureTestProcedure> g_afnAssertFeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUASSERTFEATURE, OEF__MAX, const char *>::m_aetElementArray[] =
+{
+	"OU_ASSERT", // OEF_ASSERT,
+	"OU_VERIFY", // OEF_VERIFY,
+	"OU_CHECK", // OEF_CHECK,
+};
+static const CEnumUnsortedElementArray<EOUASSERTFEATURE, OEF__MAX, const char *> g_aszAssertFeatureTestNames;
+
+
+bool TestAssert(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, OEF__MAX, g_aszAssertFeatureTestNames.GetStoragePointer(), g_afnAssertFeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+struct CTestIntTypes_int8
+{
+	int8ou  m_iPad;
+	int8ou	m_iValue;
+};
+
+bool TestIntTypes_Int8()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(int8ou) != 1 || offsetof(CTestIntTypes_int8, m_iValue) != 1)
+		{
+			break;
+		}
+
+		if (OU_INT8_BITS != sizeof(int8ou) * OU_BITS_IN_BYTE )
+		{
+			break;
+		}
+
+		if ((int8ou)OU_INT8_MIN == 0 || (int8ou)(OU_INT8_MIN << 1) != 0)
+		{
+			break;
+		}
+
+		if (~OU_INT8_MIN != OU_INT8_MAX || ~OU_INT8_MAX != OU_INT8_MIN)
+		{
+			break;
+		}
+
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+struct CTestIntTypes_uint8
+{
+	int8ou  m_iPad;
+	uint8ou	m_iValue;
+};
+
+bool TestIntTypes_UInt8()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(uint8ou) != 1 || offsetof(CTestIntTypes_uint8, m_iValue) != 1)
+		{
+			break;
+		}
+
+		if (OU_UINT8_BITS != sizeof(uint8ou) * OU_BITS_IN_BYTE)
+		{
+			break;
+		}
+		
+		if (OU_UINT8_MIN != 0)
+		{
+			break;
+		}
+
+		if (!(OU_UINT8_MAX & (uint8ou)1) || (OU_UINT8_MAX >> 1) != (uint8ou)OU_INT8_MAX)
+		{
+			break;
+		}
+	
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+struct CTestIntTypes_int16
+{
+	int8ou  m_iPad;
+	int16ou	m_iValue;
+};
+
+bool TestIntTypes_Int16()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(int16ou) != 2 || offsetof(CTestIntTypes_int16, m_iValue) != 2)
+		{
+			break;
+		}
+		
+		if (OU_INT16_BITS != sizeof(int16ou) * OU_BITS_IN_BYTE )
+		{
+			break;
+		}
+		
+		if ((int16ou)OU_INT16_MIN == 0 || (int16ou)(OU_INT16_MIN << 1) != 0)
+		{
+			break;
+		}
+		
+		if (~OU_INT16_MIN != OU_INT16_MAX || ~OU_INT16_MAX != OU_INT16_MIN)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+struct CTestIntTypes_uint16
+{
+	int8ou  m_iPad;
+	uint16ou	m_iValue;
+};
+
+bool TestIntTypes_UInt16()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(uint16ou) != 2 || offsetof(CTestIntTypes_uint16, m_iValue) != 2)
+		{
+			break;
+		}
+		
+		if (OU_UINT16_BITS != sizeof(uint16ou) * OU_BITS_IN_BYTE)
+		{
+			break;
+		}
+		
+		if (OU_UINT16_MIN != 0)
+		{
+			break;
+		}
+		
+		if (!(OU_UINT16_MAX & (uint16ou)1) || (OU_UINT16_MAX >> 1) != (uint16ou)OU_INT16_MAX)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+struct CTestIntTypes_int32
+{
+	int8ou  m_iPad;
+	int32ou	m_iValue;
+};
+
+bool TestIntTypes_Int32()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(int32ou) != 4 || offsetof(CTestIntTypes_int32, m_iValue) != 4)
+		{
+			break;
+		}
+		
+		if (OU_INT32_BITS != sizeof(int32ou) * OU_BITS_IN_BYTE )
+		{
+			break;
+		}
+		
+		if ((int32ou)OU_INT32_MIN == 0 || (int32ou)(OU_INT32_MIN << 1) != 0)
+		{
+			break;
+		}
+		
+		if (~OU_INT32_MIN != OU_INT32_MAX || ~OU_INT32_MAX != OU_INT32_MIN)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+struct CTestIntTypes_uint32
+{
+	int8ou  m_iPad;
+	uint32ou	m_iValue;
+};
+
+bool TestIntTypes_UInt32()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(uint32ou) != 4 || offsetof(CTestIntTypes_uint32, m_iValue) != 4)
+		{
+			break;
+		}
+		
+		if (OU_UINT32_BITS != sizeof(uint32ou) * OU_BITS_IN_BYTE)
+		{
+			break;
+		}
+		
+		if (OU_UINT32_MIN != 0)
+		{
+			break;
+		}
+		
+		if (!(OU_UINT32_MAX & (uint32ou)1) || (OU_UINT32_MAX >> 1) != (uint32ou)OU_INT32_MAX)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+struct CTestIntTypes_int64
+{
+	int8ou  m_iPad;
+	int64ou	m_iValue;
+};
+
+bool TestIntTypes_Int64()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(int64ou) != 8)
+		{
+			break;
+		}
+		
+#if _OU_TARGET_ARCH == _OU_TARGET_ARCH_X86 && _OU_TARGET_OS != _OU_TARGET_OS_MAC
+		
+		if (offsetof(CTestIntTypes_int64, m_iValue) != 8)
+		{
+			break;
+		}
+
+
+#endif
+
+		if (OU_INT64_BITS != sizeof(int64ou) * OU_BITS_IN_BYTE )
+		{
+			break;
+		}
+		
+		if ((int64ou)OU_INT64_MIN == 0 || (int64ou)(OU_INT64_MIN << 1) != 0)
+		{
+			break;
+		}
+		
+		if (~OU_INT64_MIN != OU_INT64_MAX || ~OU_INT64_MAX != OU_INT64_MIN)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+struct CTestIntTypes_uint64
+{
+	int8ou  m_iPad;
+	uint64ou	m_iValue;
+};
+
+bool TestIntTypes_UInt64()
+{
+	bool bResult = false;
+	
+	do
+	{
+		if (sizeof(uint64ou) != 8)
+		{
+			break;
+		}
+		
+#if _OU_TARGET_ARCH == _OU_TARGET_ARCH_X86 && _OU_TARGET_OS != _OU_TARGET_OS_MAC
+		
+		if (offsetof(CTestIntTypes_uint64, m_iValue) != 8)
+		{
+			break;
+		}
+
+
+#endif
+
+		if (OU_UINT64_BITS != sizeof(uint64ou) * OU_BITS_IN_BYTE)
+		{
+			break;
+		}
+		
+		if (OU_UINT64_MIN != 0)
+		{
+			break;
+		}
+		
+		if (!(OU_UINT64_MAX & (uint64ou)1) || (OU_UINT64_MAX >> 1) != (uint64ou)OU_INT64_MAX)
+		{
+			break;
+		}
+		
+		bResult = true;
+	}
+	while (false);
+	
+	return bResult;
+}
+
+
+enum EOUINTTYPEFEATURE
+{
+	OIF__MIN,
+		
+	OIF_INT8 = OIF__MIN,
+	OIF_UINT8,
+	OIF_INT16,
+	OIF_UINT16,
+	OIF_INT32,
+	OIF_UINT32,
+	OIF_INT64,
+	OIF_UINT64,
+	
+	OIF__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUINTTYPEFEATURE, OIF__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestIntTypes_Int8, // OIF_INT8,
+	&TestIntTypes_UInt8, // OIF_UINT8,
+	&TestIntTypes_Int16, // OIF_INT16,
+	&TestIntTypes_UInt16, // OIF_UINT16,
+	&TestIntTypes_Int32, // OIF_INT32,
+	&TestIntTypes_UInt32, // OIF_UINT32,
+	&TestIntTypes_Int64, // OIF_INT64,
+	&TestIntTypes_UInt64, // OIF_UINT64,
+
+};
+static const CEnumUnsortedElementArray<EOUINTTYPEFEATURE, OIF__MAX, CFeatureTestProcedure> g_afnIntTypeFeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUINTTYPEFEATURE, OIF__MAX, const char *>::m_aetElementArray[] =
+{
+	"int8ou", // OIF_INT8,
+	"uint8ou", // OIF_UINT8,
+	"int16ou", // OIF_INT16,
+	"uint16ou", // OIF_UINT16,
+	"int32ou", // OIF_INT32,
+	"uint32ou", // OIF_UINT32,
+	"int64ou", // OIF_INT64,
+	"uint64ou", // OIF_UINT64,
+};
+static const CEnumUnsortedElementArray<EOUINTTYPEFEATURE, OIF__MAX, const char *> g_aszIntTypeFeatureTestNames;
+
+
+bool TestIntTypes(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, OIF__MAX, g_aszIntTypeFeatureTestNames.GetStoragePointer(), g_afnIntTypeFeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+struct CTestMacros_OffsetStruct 
+{
+	int8ou		m_i8a;
+	int16ou		m_i16a;
+	int32ou		m_i32a;
+	int64ou		m_i64;
+	int32ou		m_i32b;
+	int16ou		m_i16b;
+	int8ou		m_i8b;
+};
+
+bool TestMacros_OffsetOf()
+{
+	size_t sOffset_i8a = offsetof(CTestMacros_OffsetStruct, m_i8a);
+	size_t sOffset_i16a = offsetof(CTestMacros_OffsetStruct, m_i16a);
+	size_t sOffset_i32a = offsetof(CTestMacros_OffsetStruct, m_i32a);
+	size_t sOffset_i64 = offsetof(CTestMacros_OffsetStruct, m_i64);
+	size_t sOffset_i32b = offsetof(CTestMacros_OffsetStruct, m_i32b);
+	size_t sOffset_i16b = offsetof(CTestMacros_OffsetStruct, m_i16b);
+	size_t sOffset_i8b = offsetof(CTestMacros_OffsetStruct, m_i8b);
+	size_t sStructSize = sizeof(CTestMacros_OffsetStruct);
+
+	return true
+		&& sOffset_i8a == 0
+		&& sOffset_i16a == 2
+		&& sOffset_i32a == 4
+		&& sOffset_i64 == 8
+		&& sOffset_i32b == 16
+		&& sOffset_i16b == 20
+		&& sOffset_i8b == 22
+		&& sStructSize == 24;
+}
+
+bool TestMacros_AlignedSize()
+{
+	return true
+		&& OU_ALIGNED_SIZE(0, sizeof(int8ou)) == 0
+		&& OU_ALIGNED_SIZE(0, sizeof(int16ou)) == 0
+		&& OU_ALIGNED_SIZE(0, sizeof(int32ou)) == 0
+		&& OU_ALIGNED_SIZE(0, sizeof(int64ou)) == 0
+		&& OU_ALIGNED_SIZE(sizeof(int8ou), sizeof(int8ou)) == sizeof(int8ou)
+		&& OU_ALIGNED_SIZE(sizeof(int8ou), sizeof(int16ou)) == sizeof(int16ou)
+		&& OU_ALIGNED_SIZE(sizeof(int8ou), sizeof(int32ou)) == sizeof(int32ou)
+		&& OU_ALIGNED_SIZE(sizeof(int8ou), sizeof(int64ou)) == sizeof(int64ou)
+		&& OU_ALIGNED_SIZE(sizeof(int16ou), sizeof(int8ou)) == sizeof(int16ou)
+		&& OU_ALIGNED_SIZE(sizeof(int16ou), sizeof(int16ou)) == sizeof(int16ou)
+		&& OU_ALIGNED_SIZE(sizeof(int16ou), sizeof(int32ou)) == sizeof(int32ou)
+		&& OU_ALIGNED_SIZE(sizeof(int16ou), sizeof(int64ou)) == sizeof(int64ou)
+		&& OU_ALIGNED_SIZE(sizeof(int32ou), sizeof(int8ou)) == sizeof(int32ou)
+		&& OU_ALIGNED_SIZE(sizeof(int32ou), sizeof(int16ou)) == sizeof(int32ou)
+		&& OU_ALIGNED_SIZE(sizeof(int32ou), sizeof(int32ou)) == sizeof(int32ou)
+		&& OU_ALIGNED_SIZE(sizeof(int32ou), sizeof(int64ou)) == sizeof(int64ou)
+		&& OU_ALIGNED_SIZE(sizeof(int64ou), sizeof(int8ou)) == sizeof(int64ou)
+		&& OU_ALIGNED_SIZE(sizeof(int64ou), sizeof(int16ou)) == sizeof(int64ou)
+		&& OU_ALIGNED_SIZE(sizeof(int64ou), sizeof(int32ou)) == sizeof(int64ou)
+		&& OU_ALIGNED_SIZE(sizeof(int64ou), sizeof(int64ou)) == sizeof(int64ou);
+}
+
+bool TestMacros_ArraySize()
+{
+	static int m_ai_Array1[1];
+	static int m_aai_Array11[1][1];
+	static int m_ai_Array2[2];
+	static int m_aai_Array21[2][1];
+	static int m_aai_Array12[1][2];
+
+	return true
+		&& OU_ARRAY_SIZE(m_ai_Array1) == 1
+		&& OU_ARRAY_SIZE(m_aai_Array11[0]) == 1
+		&& OU_ARRAY_SIZE(m_aai_Array11) == 1
+		&& OU_ARRAY_SIZE(m_ai_Array2) == 2
+		&& OU_ARRAY_SIZE(m_aai_Array21[0]) == 1
+		&& OU_ARRAY_SIZE(m_aai_Array21) == 2
+		&& OU_ARRAY_SIZE(m_aai_Array12[0]) == 2
+		&& OU_ARRAY_SIZE(m_aai_Array12) == 1;
+}
+
+bool TestMacros_InIntRange()
+{
+	char iZero = 0;
+	char iOne = 1;
+	char iMinusOne = -1;
+	unsigned int uiTen = 10;
+	unsigned int uiNotZero = ~0U;
+
+	return true
+		&& !OU_IN_INT_RANGE(iZero, 0, 0)
+		&& !OU_IN_INT_RANGE(iOne, 0, 0)
+		&& !OU_IN_INT_RANGE(iMinusOne, 0, 0)
+		&& !OU_IN_INT_RANGE(uiTen, 0, 0)
+		&& !OU_IN_INT_RANGE(uiNotZero, 0, 0)
+
+		&& OU_IN_INT_RANGE(iZero, 0, 1)
+		&& !OU_IN_INT_RANGE(iOne, 0, 1)
+		&& !OU_IN_INT_RANGE(iMinusOne, 0, 1)
+		&& !OU_IN_INT_RANGE(uiTen, 0, 1)
+		&& !OU_IN_INT_RANGE(uiNotZero, 0, 1)
+
+		&& !OU_IN_INT_RANGE(iZero, 1, 2)
+		&& OU_IN_INT_RANGE(iOne, 1, 2)
+		&& !OU_IN_INT_RANGE(iMinusOne, 1, 2)
+		&& !OU_IN_INT_RANGE(uiTen, 1, 2)
+		&& !OU_IN_INT_RANGE(uiNotZero, 1, 2)
+
+		&& OU_IN_INT_RANGE(iZero, -1, 1)
+		&& !OU_IN_INT_RANGE(iOne, -1, 1)
+		&& OU_IN_INT_RANGE(iMinusOne, -1, 1)
+		&& !OU_IN_INT_RANGE(uiTen, -1, 1)
+		&& OU_IN_INT_RANGE(uiNotZero, -1, 1)
+
+		&& !OU_IN_INT_RANGE(iZero, 1, -1)
+		&& OU_IN_INT_RANGE(iOne, 1, -1)
+		&& !OU_IN_INT_RANGE(iMinusOne, 1, -1)
+		&& OU_IN_INT_RANGE(uiTen, 1, -1)
+		&& !OU_IN_INT_RANGE(uiNotZero, 1, -1);
+}
+
+bool TestMacros_InI64Range()
+{
+	char iZero = 0;
+	char iOne = 1;
+	char iMinusOne = -1;
+	unsigned int uiTen = 10;
+	unsigned int uiNotZero = ~0U;
+	
+	return true
+		&& !OU_IN_I64_RANGE(iZero, 0, 0)
+		&& !OU_IN_I64_RANGE(iOne, 0, 0)
+		&& !OU_IN_I64_RANGE(iMinusOne, 0, 0)
+		&& !OU_IN_I64_RANGE(uiTen, 0, 0)
+		&& !OU_IN_I64_RANGE(uiNotZero, 0, 0)
+		
+		&& OU_IN_I64_RANGE(iZero, 0, 1)
+		&& !OU_IN_I64_RANGE(iOne, 0, 1)
+		&& !OU_IN_I64_RANGE(iMinusOne, 0, 1)
+		&& !OU_IN_I64_RANGE(uiTen, 0, 1)
+		&& !OU_IN_I64_RANGE(uiNotZero, 0, 1)
+		
+		&& !OU_IN_I64_RANGE(iZero, 1, 2)
+		&& OU_IN_I64_RANGE(iOne, 1, 2)
+		&& !OU_IN_I64_RANGE(iMinusOne, 1, 2)
+		&& !OU_IN_I64_RANGE(uiTen, 1, 2)
+		&& !OU_IN_I64_RANGE(uiNotZero, 1, 2)
+		
+		&& OU_IN_I64_RANGE(iZero, -1, 1)
+		&& !OU_IN_I64_RANGE(iOne, -1, 1)
+		&& OU_IN_I64_RANGE(iMinusOne, -1, 1)
+		&& !OU_IN_I64_RANGE(uiTen, -1, 1)
+		&& !OU_IN_I64_RANGE(uiNotZero, -1, 1)
+		
+		&& !OU_IN_I64_RANGE(iZero, 1, -1)
+		&& OU_IN_I64_RANGE(iOne, 1, -1)
+		&& !OU_IN_I64_RANGE(iMinusOne, 1, -1)
+		&& OU_IN_I64_RANGE(uiTen, 1, -1)
+		&& OU_IN_I64_RANGE(uiNotZero, 1, -1);
+}
+
+bool TestMacros_InSizetRange()
+{
+	char iZero = 0;
+	char iOne = 1;
+	char iMinusOne = -1;
+	unsigned int uiTen = 10;
+	unsigned int uiNotZero = ~0U;
+	
+	return true
+		&& !OU_IN_SIZET_RANGE(iZero, 0, 0)
+		&& !OU_IN_SIZET_RANGE(iOne, 0, 0)
+		&& !OU_IN_SIZET_RANGE(iMinusOne, 0, 0)
+		&& !OU_IN_SIZET_RANGE(uiTen, 0, 0)
+		&& !OU_IN_SIZET_RANGE(uiNotZero, 0, 0)
+		
+		&& OU_IN_SIZET_RANGE(iZero, 0, 1)
+		&& !OU_IN_SIZET_RANGE(iOne, 0, 1)
+		&& !OU_IN_SIZET_RANGE(iMinusOne, 0, 1)
+		&& !OU_IN_SIZET_RANGE(uiTen, 0, 1)
+		&& !OU_IN_SIZET_RANGE(uiNotZero, 0, 1)
+		
+		&& !OU_IN_SIZET_RANGE(iZero, 1, 2)
+		&& OU_IN_SIZET_RANGE(iOne, 1, 2)
+		&& !OU_IN_SIZET_RANGE(iMinusOne, 1, 2)
+		&& !OU_IN_SIZET_RANGE(uiTen, 1, 2)
+		&& !OU_IN_SIZET_RANGE(uiNotZero, 1, 2)
+		
+		&& OU_IN_SIZET_RANGE(iZero, -1, 1)
+		&& !OU_IN_SIZET_RANGE(iOne, -1, 1)
+		&& OU_IN_SIZET_RANGE(iMinusOne, -1, 1)
+		&& !OU_IN_SIZET_RANGE(uiTen, -1, 1)
+		&& OU_IN_SIZET_RANGE(uiNotZero, -1, 1) == (sizeof(size_t) == sizeof(unsigned int))
+		
+		&& !OU_IN_SIZET_RANGE(iZero, 1, -1)
+		&& OU_IN_SIZET_RANGE(iOne, 1, -1)
+		&& !OU_IN_SIZET_RANGE(iMinusOne, 1, -1)
+		&& OU_IN_SIZET_RANGE(uiTen, 1, -1)
+		&& OU_IN_SIZET_RANGE(uiNotZero, 1, -1) != (sizeof(size_t) == sizeof(unsigned int));
+}
+
+
+enum EOUMACROFEATURE
+{
+	OMF__MIN,
+
+	OMF_OFFSETOF = OMF__MIN,
+	OMF_ALIGNEDSIZE,
+	OMF_ARRAYSIZE,
+	OMF_ININTRANGE,
+	OMF_INI64RANGE,
+	OMF_INSIZETRANGE,
+
+	OMF__MAX,
+};
+
+template<>
+CFeatureTestProcedure const CEnumUnsortedElementArray<EOUMACROFEATURE, OMF__MAX, CFeatureTestProcedure>::m_aetElementArray[] =
+{
+	&TestMacros_OffsetOf, // OMF_OFFSETOF,
+	&TestMacros_AlignedSize, // OMF_ALIGNEDSIZE,
+	&TestMacros_ArraySize, // OMF_ARRAYSIZE,
+	&TestMacros_InIntRange, // OMF_ININTRANGE,
+	&TestMacros_InI64Range, // OMF_INI64RANGE,
+	&TestMacros_InSizetRange, // OMF_INSIZETRANGE,
+};
+static const CEnumUnsortedElementArray<EOUMACROFEATURE, OMF__MAX, CFeatureTestProcedure> g_afnMacroFeatureTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUMACROFEATURE, OMF__MAX, const char *>::m_aetElementArray[] =
+{
+	"offsetof", // OMF_OFFSETOF,
+	"OU_ALIGNED_SIZE", // OMF_ALIGNEDSIZE,
+	"OU_ARRAY_SIZE", // OMF_ARRAYSIZE,
+	"OU_IN_INT_RANGE", // OMF_ININTRANGE,
+	"OU_IN_I64_RANGE", // OMF_INI64RANGE,
+	"OU_IN_SIZET_RANGE", // OMF_INSIZETRANGE,
+};
+static const CEnumUnsortedElementArray<EOUMACROFEATURE, OMF__MAX, const char *> g_aszMacroFeatureTestNames;
+
+
+bool TestMacros(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	return TestSubsystem(nOutSuccessCount, nOutTestCount, OMF__MAX, g_aszMacroFeatureTestNames.GetStoragePointer(), g_afnMacroFeatureTestProcedures.GetStoragePointer());
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+// Verifies that target order is not changed
+template<>
+int const CEnumSortedElementArray<int, _OU_TARGET_OS__MAX - 1, int, 100>::m_aetElementArray[] =
+{
+	_OU_TARGET_OS_GENUNIX, // _OU_TARGET_OS_GENUNIX
+	_OU_TARGET_OS_WINDOWS, // _OU_TARGET_OS_WINDOWS
+	_OU_TARGET_OS_QNX, // _OU_TARGET_OS_QNX
+	_OU_TARGET_OS_MAC, // _OU_TARGET_OS_MAC
+	_OU_TARGET_OS_AIX, // _OU_TARGET_OS_AIX
+	_OU_TARGET_OS_SUNOS, // _OU_TARGET_OS_SUNOS
+	_OU_TARGET_OS_IOS, // _OU_TARGET_OS_IOS
+};
+static const CEnumSortedElementArray<int, _OU_TARGET_OS__MAX - 1, int, 100> g_ai_TargetOrderCheck;
+
+template<>
+const char *const CEnumUnsortedElementArray<int, _OU_TARGET_OS__MAX - 1, const char *, 100>::m_aetElementArray[] =
+{
+	"GENERIC UNIX", // _OU_TARGET_OS_GENUNIX
+	"WINDOWS", // _OU_TARGET_OS_WINDOWS
+	"QNX", // _OU_TARGET_OS_QNX
+	"MAC", // _OU_TARGET_OS_MAC
+	"AIX", // _OU_TARGET_OS_AIX
+	"SunOS", // _OU_TARGET_OS_SUNOS
+	"iOS", // _OU_TARGET_OS_IOS
+};
+static const CEnumUnsortedElementArray<int, _OU_TARGET_OS__MAX - 1, const char *, 100> g_aszOSNames;
+
+// Verifies that bits order is not changed
+template<>
+int const CEnumSortedElementArray<int, _OU_TARGET_BITS__MAX - 1, int, 101>::m_aetElementArray[] =
+{
+	_OU_TARGET_BITS_32, // _OU_TARGET_BITS_32
+	_OU_TARGET_BITS_64, // _OU_TARGET_BITS_64
+};
+static const CEnumSortedElementArray<int, _OU_TARGET_BITS__MAX - 1, int, 101> g_ai_BitsOrderCheck;
+
+template<>
+const char *const CEnumUnsortedElementArray<int, _OU_TARGET_BITS__MAX - 1, const char *, 101>::m_aetElementArray[] =
+{
+	"32", // _OU_TARGET_BITS_32
+	"64", // _OU_TARGET_BITS_64
+};
+static const CEnumUnsortedElementArray<int, _OU_TARGET_BITS__MAX - 1, const char *, 101> g_aszBitsNames;
+
+// Verifies that architectures order is not changed
+template<>
+int const CEnumSortedElementArray<int, _OU_TARGET_ARCH__MAX - 1, int, 102>::m_aetElementArray[] =
+{
+	_OU_TARGET_ARCH_OTHER, // _OU_TARGET_ARCH_OTHER
+	_OU_TARGET_ARCH_X86, // _OU_TARGET_ARCH_X86
+	_OU_TARGET_ARCH_IA64, // _OU_TARGET_ARCH_IA64
+	_OU_TARGET_ARCH_X64, // _OU_TARGET_ARCH_X64
+	_OU_TARGET_ARCH_POWERPC, // _OU_TARGET_ARCH_POWERPC
+	_OU_TARGET_ARCH_SPARC, // _OU_TARGET_ARCH_SPARC
+	_OU_TARGET_ARCH_ARM, // _OU_TARGET_ARCH_ARM
+};
+static const CEnumSortedElementArray<int, _OU_TARGET_ARCH__MAX - 1, int, 102> g_ai_ArchitecturesOrderCheck;
+
+template<>
+const char *const CEnumUnsortedElementArray<int, _OU_TARGET_ARCH__MAX - 1, const char *, 102>::m_aetElementArray[] =
+{
+	"OTHER", // _OU_TARGET_ARCH_OTHER
+	"x86", // _OU_TARGET_ARCH_X86
+	"Itanium", // _OU_TARGET_ARCH_IA64
+	"x64", // _OU_TARGET_ARCH_X64
+	"PowerPC", // _OU_TARGET_ARCH_POWERPC
+	"Sparc", // _OU_TARGET_ARCH_SPARC
+	"ARM", // _OU_TARGET_ARCH_ARM
+};
+static const CEnumUnsortedElementArray<int, _OU_TARGET_ARCH__MAX - 1, const char *, 102> g_aszArchitecturesNames;
+
+// Verifies that compilers order is not changed
+template<>
+int const CEnumSortedElementArray<int, _OU_COMPILER__MAX - 1, int, 103>::m_aetElementArray[] =
+{
+	_OU_COMPILER__OTHER, // _OU_COMPILER__OTHER,
+	_OU_COMPILER_GCC, // _OU_COMPILER_GCC,
+	_OU_COMPILER_MSVC, // _OU_COMPILER_MSVC,
+};
+static const CEnumSortedElementArray<int, _OU_COMPILER__MAX - 1, int, 103> g_ai_CompilersOrderCheck;
+
+template<>
+const char *const CEnumUnsortedElementArray<int, _OU_COMPILER__MAX - 1, const char *, 103>::m_aetElementArray[] =
+{
+	"UNKNOWN", // _OU_COMPILER__OTHER,
+	"GCC", // _OU_COMPILER_GCC,
+	"MSVC", // _OU_COMPILER_MSVC,
+};
+static const CEnumUnsortedElementArray<int, _OU_COMPILER__MAX - 1, const char *, 103> g_aszCompilersNames;
+
+// Verifies that compiler versions order is not changed
+template<>
+int const CEnumSortedElementArray<int, _OU_COMPILER_VERSION__MAX - 1, int, 104>::m_aetElementArray[] =
+{
+	_OU_COMPILER_VERSION__OTHER, // _OU_COMPILER_VERSION__OTHER,
+	_OU_COMPILER_VERSION_MSVC1998, // _OU_COMPILER_VERSION_MSVC1998,
+	_OU_COMPILER_VERSION_GCCLT4, // _OU_COMPILER_VERSION_GCCLT4,
+};
+static const CEnumSortedElementArray<int, _OU_COMPILER_VERSION__MAX - 1, int, 104> g_ai_CompilersVersionOrderCheck;
+
+template<>
+const char *const CEnumUnsortedElementArray<int, _OU_COMPILER_VERSION__MAX - 1, const char *, 104>::m_aetElementArray[] =
+{
+	"OTHER", // _OU_COMPILER_VERSION__OTHER,
+	"MSVC1998", // _OU_COMPILER_VERSION_MSVC1998,
+	"GCC LESS THAN 4.0", // _OU_COMPILER_VERSION_GCCLT4,
+};
+static const CEnumUnsortedElementArray<int, _OU_COMPILER_VERSION__MAX - 1, const char *, 104> g_aszCompilerVersionNames;
+
+
+#define _TESTPLATFORM_DEFINITION_TEXT(Definition) #Definition
+#define TESTPLATFORM_TEFINITION_TEXT(Definition) _TESTPLATFORM_DEFINITION_TEXT(Definition)
+
+bool TestPlatform(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount)
+{
+	const char *szOSName = g_aszOSNames.Encode(_OU_TARGET_OS - 1);
+	const char *szBitsName = g_aszBitsNames.Encode(_OU_TARGET_BITS - 1);
+	const char *szArchitectureName = g_aszArchitecturesNames.Encode(_OU_TARGET_ARCH - 1);
+	const char *szCompilerName = g_aszCompilersNames.Encode(_OU_COMPILER - 1);
+	const char *szCompilerVersion = g_aszCompilerVersionNames.Encode(_OU_COMPILER_VERSION - 1);
+	
+	printf("Target OS:                   %s\n", szOSName);
+	printf("Target Bits:                 %s\n", szBitsName);
+	printf("Target Architecture          %s\n", szArchitectureName);
+	printf("Compiler Name:               %s\n", szCompilerName);
+	printf("Compiler Version:            %s\n", szCompilerVersion);
+	printf("Method Convention:           %s\n", TESTPLATFORM_TEFINITION_TEXT(=_OU_CONVENTION_METHOD));
+	printf("Function Convention:         %s\n", TESTPLATFORM_TEFINITION_TEXT(=_OU_CONVENTION_API));
+	printf("Callback Convention:         %s\n", TESTPLATFORM_TEFINITION_TEXT(=_OU_CONVENTION_CALLBACK));
+	printf("Alwaysinline definition:     %s\n", TESTPLATFORM_TEFINITION_TEXT(=_OU_ALWAYSINLINE));
+	printf("Inline definition:           %s\n", TESTPLATFORM_TEFINITION_TEXT(=_OU_INLINE));
+	
+	nOutSuccessCount = 0;
+	nOutTestCount = 0;
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+enum EOUSUBSYSTEMTEST
+{
+	OST__MIN,
+
+	OST_INTTYPES = OST__MIN,
+	OST_MACROS,
+	OST_TEMPLATES,
+	OST_TYPEWRAPPER,
+	OST_ASSERT,
+	OST_MALLOC,
+	OST_CUSTOMIZATION,
+	OST_ENUMARRAYS,
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS
+	OST_ATOMIC,
+#endif
+	OST_FLAGSDEFINES,
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS
+	OST_ATOMICFLAGS,
+#endif
+	OST_SIMPLEFLAGS64,
+	OST_SIMPLEFLAGS32,
+	OST_SIMPLEFLAGS16,
+	OST_SIMPLEFLAGS8,
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_TLS
+	OST_TLS,
+#endif
+	OST_PLATFORM,
+
+	OST__MAX,
+};
+
+typedef bool (*COUSubsystemTestProcedure)(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount);
+
+template<>
+COUSubsystemTestProcedure const CEnumUnsortedElementArray<EOUSUBSYSTEMTEST, OST__MAX, COUSubsystemTestProcedure>::m_aetElementArray[] =
+{
+	&TestIntTypes, // OST_INTTYPES,
+	&TestMacros, // OST_MACROS,
+	&TestTemplates, // OST_TEMPLATES,
+	&TestTypeWrapper, // OST_TYPEWRAPPER,
+	&TestAssert, // OST_ASSERT,
+	&TestMalloc, // OST_MALLOC,
+	&TestCustomization, // OST_CUSTOMIZATION,
+	&TestEnumArrays, // OST_ENUMARRAYS,
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS
+	&TestAtomic, // OST_ATOMIC,
+#endif
+	&TestFlagsDefines, // OST_FLAGSDEFINES,
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS
+	&TestAtomicFlags, // OST_ATOMICFLAGS,
+#endif
+	&TestSimpleFlags64, // OST_SIMPLEFLAGS64,
+	&TestSimpleFlags32, // OST_SIMPLEFLAGS32,
+	&TestSimpleFlags16, // OST_SIMPLEFLAGS16,
+	&TestSimpleFlags8, // OST_SIMPLEFLAGS8,
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_TLS
+	&TestTLS, // OST_TLS,
+#endif
+	&TestPlatform, // OST_PLATFORM,
+};
+static const CEnumUnsortedElementArray<EOUSUBSYSTEMTEST, OST__MAX, COUSubsystemTestProcedure> g_afnOUSubsystemTestProcedures;
+
+template<>
+const char *const CEnumUnsortedElementArray<EOUSUBSYSTEMTEST, OST__MAX, const char *>::m_aetElementArray[] =
+{
+	"IntTypes", // OST_INTTYPES,
+	"Macros", // OST_MACROS,
+	"Templates", // OST_TEMPLATES,
+	"TypeWrapper", // OST_TYPEWRAPPER,
+	"Assert", // OST_ASSERT,
+	"Malloc", // OST_MALLOC,
+	"Customization", // OST_CUSTOMIZATION,
+	"EnumArrays", // OST_ENUMARRAYS,
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS
+	"Atomic", // OST_ATOMIC,
+#endif
+	"FlagsDefines", // OST_FLAGSDEFINES,
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS
+	"AtomicFlags", // OST_ATOMICFLAGS,
+#endif
+	"SimpleFlags64", // OST_SIMPLEFLAGS64,
+	"SimpleFlags32", // OST_SIMPLEFLAGS32,
+	"SimpleFlags16", // OST_SIMPLEFLAGS16,
+	"SimpleFlags8", // OST_SIMPLEFLAGS8,
+#if _OU_FEATURE_SET >= _OU_FEATURE_SET_TLS
+	"TLS", // OST_TLS,
+#endif
+	"Platform", // OST_PLATFORM,
+};
+static const CEnumUnsortedElementArray<EOUSUBSYSTEMTEST, OST__MAX, const char *> g_aszOUSubsystemNames;
+
+
+bool ProcessOUCoverageTests(unsigned int &nOutFailureCount)
+{
+	unsigned int nSuccessCount = 0;
+
+	for (EOUSUBSYSTEMTEST stSubsystemTest = OST__MIN; stSubsystemTest != OST__MAX; ++stSubsystemTest)
+	{
+		const char *szSubsystemName = g_aszOUSubsystemNames.Encode(stSubsystemTest);
+		printf("\nTesting subsystem \"%s\"\n", szSubsystemName);
+		printf("---------------------------------------------------\n");
+
+		unsigned int nSubsysytemSuccessCount = 0, nSubsystemTestCount = 1;
+
+		COUSubsystemTestProcedure fnTestProcedure = g_afnOUSubsystemTestProcedures.Encode(stSubsystemTest);
+		if (fnTestProcedure(nSubsysytemSuccessCount, nSubsystemTestCount) && nSubsysytemSuccessCount == nSubsystemTestCount)
+		{
+			nSuccessCount += 1;
+		}
+
+		unsigned int nSubsysytemFailureCount = nSubsystemTestCount - nSubsysytemSuccessCount;
+		printf("---------------------------------------------------\n");
+		printf("Feature tests failed:                %3u out of %3u\n", nSubsysytemFailureCount, nSubsystemTestCount);
+	}
+
+	unsigned int nFailureCount = OST__MAX - nSuccessCount;
+	
+	printf("\n===================================================\n");
+	printf("Subsystem tests failed:              %3u out of %3u\n", nFailureCount, (unsigned int)OST__MAX);
+
+	nOutFailureCount = nFailureCount;
+	return nSuccessCount == OST__MAX;
+}
+
+int main(int argc, char* argv[])
+{
+	unsigned int nFailureCount;
+	ProcessOUCoverageTests(nFailureCount);
+
+	return nFailureCount;
+}
+