Added support for the D programming languge.

It is still a bit rough around some edges, particularly with regard to multi-threading and operator overloading, and there are some documentation bits missing, but it should be fine for basic use.

The test-suite should build and run fine with the current versions of DMD, LDC and Tango (at least) on Linux x86_64 and Mac OS X 10.6.

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@12299 626c5289-ae23-0410-ae9c-e8d60b6d4f22

Examples/test-suite/d/Makefile.in

@@ -0,0 +1,80 @@
+#######################################################################
+# Makefile for D test-suite
+#######################################################################
+
+LANGUAGE     = d
+srcdir       = @srcdir@
+top_srcdir   = ../@top_srcdir@
+top_builddir = ../@top_builddir@
+
+ifeq (2,$(D_VERSION))
+  VERSIONSUFFIX = .2
+else
+  VERSIONSUFFIX = .1
+endif
+
+TESTSUFFIX = _runme$(VERSIONSUFFIX).d
+
+CPP_TEST_CASES = \
+	d_nativepointers \
+	exception_partial_info
+
+include $(srcdir)/../common.mk
+
+# Override some variables from common.mk:
+
+TARGETSUFFIX = _wrap
+
+SWIGOPT+=-splitproxy -package $*
+
+# Rules for the different types of tests
+%.cpptest:
+	$(setup)
+	+(cd $*$(VERSIONSUFFIX) && $(swig_and_compile_cpp))
+	+$(run_testcase)
+
+%.ctest:
+	$(setup)
+	+(cd $*$(VERSIONSUFFIX) && $(swig_and_compile_c))
+	+$(run_testcase)
+
+%.multicpptest:
+	$(setup)
+	+(cd $*$(VERSIONSUFFIX) && $(swig_and_compile_multi_cpp))
+	+$(run_testcase)
+
+# Makes a directory for the testcase if it does not exist
+setup = \
+	if [ -f $(srcdir)/$(TESTPREFIX)$*$(TESTSUFFIX) ]; then			\
+	  echo "$(ACTION)ing testcase $* (with run test) under $(LANGUAGE)" ;	\
+	else									\
+	  echo "$(ACTION)ing testcase $* under $(LANGUAGE)" ;			\
+	fi;									\
+	if [ ! -d $*$(VERSIONSUFFIX) ]; then					\
+	  mkdir $*$(VERSIONSUFFIX);						\
+	fi;									\
+	if [ ! -d $*$(VERSIONSUFFIX)/$* ]; then					\
+	  mkdir $*$(VERSIONSUFFIX)/$*;						\
+	fi
+
+# Compiles D files then runs the testcase. A testcase is only run if
+# a file is found which has _runme.d appended after the testcase name.
+run_testcase = \
+	if [ -f $(srcdir)/$(TESTPREFIX)$*$(TESTSUFFIX) ]; then \
+	  cd $*$(VERSIONSUFFIX) && \
+	  $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile \
+	  DFLAGS='-of$*_runme' \
+	  DSRCS='../$(srcdir)/$(TESTPREFIX)$*$(TESTSUFFIX) $*/*.d' d_compile && \
+	  env LD_LIBRARY_PATH=".:$$LD_LIBRARY_PATH" $(RUNTOOL) ./$*_runme; \
+	else \
+	  cd $*$(VERSIONSUFFIX) && \
+	  $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile \
+	  DFLAGS='-c' \
+	  DSRCS='$*/*.d' d_compile && cd .. ; \
+	fi
+
+# Clean: remove testcase directories
+%.clean:
+	@if [ -d $* ]; then \
+	  rm -rf $*; \
+	fi

Examples/test-suite/d/README

@@ -0,0 +1,7 @@
+D language module testsuite
+---------------------------
+
+Please see ../README for the common readme file.
+
+By default the D1 version is built, set D_VERSION=2 (in the environment or at
+the make command line) to run it for D2 instead.

Examples/test-suite/d/aggregate_runme.1.d

@@ -0,0 +1,25 @@
+module aggregate_runme;
+
+import aggregate.aggregate;
+
+void main() {
+  // Confirm that move() returns correct results under normal use.
+  int result = move(UP);
+  if (result != UP) throw new Exception("UP failed");
+
+  result = move(DOWN);
+  if (result != DOWN) throw new Exception("DOWN failed");
+
+  result = move(LEFT);
+  if (result != LEFT) throw new Exception("LEFT failed");
+
+  result = move(RIGHT);
+  if (result != RIGHT) throw new Exception("RIGHT failed");
+
+  // Confirm that move() raises an exception when the contract is violated.
+  try {
+    move(0);
+    throw new Exception("0 test failed");
+  }
+  catch (Exception e) {}
+}

Examples/test-suite/d/aggregate_runme.2.d

@@ -0,0 +1,25 @@
+module aggregate_runme;
+
+import aggregate.aggregate;
+
+void main() {
+  // Confirm that move() returns correct results under normal use.
+  int result = move(UP);
+  if (result != UP) throw new Exception("UP failed");
+
+  result = move(DOWN);
+  if (result != DOWN) throw new Exception("DOWN failed");
+
+  result = move(LEFT);
+  if (result != LEFT) throw new Exception("LEFT failed");
+
+  result = move(RIGHT);
+  if (result != RIGHT) throw new Exception("RIGHT failed");
+
+  // Confirm that move() raises an exception when the contract is violated.
+  try {
+    move(0);
+    throw new Exception("0 test failed");
+  }
+  catch (Exception e) {}
+}

Examples/test-suite/d/allprotected_runme.1.d

@@ -0,0 +1,65 @@
+module allprotected_runme;
+
+import allprotected.Klass;
+import allprotected.ProtectedBase;
+
+void main() {
+  auto mpb = new MyProtectedBase("MyProtectedBase");
+  mpb.accessProtected();
+}
+
+class MyProtectedBase : ProtectedBase {
+public:
+  this(char[] name) {
+    super(name);
+  }
+
+  void accessProtected() {
+    char[] s = virtualMethod();
+    if (s != "ProtectedBase")
+      throw new Exception("Failed");
+
+    Klass k = instanceMethod(new Klass("xyz"));
+    if (k.getName() != "xyz") 
+      throw new Exception("Failed");
+
+    k = instanceOverloaded(new Klass("xyz"));
+    if (k.getName() != "xyz") 
+      throw new Exception("Failed");
+
+    k = instanceOverloaded(new Klass("xyz"), "abc");
+    if (k.getName() != "abc") 
+      throw new Exception("Failed");
+
+    k = staticMethod(new Klass("abc"));
+    if (k.getName() != "abc") 
+      throw new Exception("Failed");
+
+    k = staticOverloaded(new Klass("xyz"));
+    if (k.getName() != "xyz") 
+      throw new Exception("Failed");
+
+    k = staticOverloaded(new Klass("xyz"), "abc");
+    if (k.getName() != "abc") 
+      throw new Exception("Failed");
+
+    instanceMemberVariable = 30;
+    int i = instanceMemberVariable;
+    if (i != 30)
+      throw new Exception("Failed");
+
+    staticMemberVariable = 40;
+    i = staticMemberVariable;
+    if (i != 40)
+      throw new Exception("Failed");
+
+    i = staticConstMemberVariable;
+    if (i != 20)
+      throw new Exception("Failed");
+
+    anEnum = ProtectedBase.AnEnum.EnumVal1;
+    ProtectedBase.AnEnum ae = anEnum;
+    if (ae != ProtectedBase.AnEnum.EnumVal1)
+      throw new Exception("Failed");
+  }
+}

Examples/test-suite/d/allprotected_runme.2.d

@@ -0,0 +1,65 @@
+module allprotected_runme;
+
+import allprotected.Klass;
+import allprotected.ProtectedBase;
+
+void main() {
+  auto mpb = new MyProtectedBase("MyProtectedBase");
+  mpb.accessProtected();
+}
+
+class MyProtectedBase : ProtectedBase {
+public:
+  this(string name) {
+    super(name);
+  }
+
+  void accessProtected() {
+    string s = virtualMethod();
+    if (s != "ProtectedBase")
+      throw new Exception("Failed");
+
+    Klass k = instanceMethod(new Klass("xyz"));
+    if (k.getName() != "xyz")
+      throw new Exception("Failed");
+
+    k = instanceOverloaded(new Klass("xyz"));
+    if (k.getName() != "xyz")
+      throw new Exception("Failed");
+
+    k = instanceOverloaded(new Klass("xyz"), "abc");
+    if (k.getName() != "abc")
+      throw new Exception("Failed");
+
+    k = staticMethod(new Klass("abc"));
+    if (k.getName() != "abc")
+      throw new Exception("Failed");
+
+    k = staticOverloaded(new Klass("xyz"));
+    if (k.getName() != "xyz")
+      throw new Exception("Failed");
+
+    k = staticOverloaded(new Klass("xyz"), "abc");
+    if (k.getName() != "abc")
+      throw new Exception("Failed");
+
+    instanceMemberVariable = 30;
+    int i = instanceMemberVariable;
+    if (i != 30)
+      throw new Exception("Failed");
+
+    staticMemberVariable = 40;
+    i = staticMemberVariable;
+    if (i != 40)
+      throw new Exception("Failed");
+
+    i = staticConstMemberVariable;
+    if (i != 20)
+      throw new Exception("Failed");
+
+    anEnum = ProtectedBase.AnEnum.EnumVal1;
+    ProtectedBase.AnEnum ae = anEnum;
+    if (ae != ProtectedBase.AnEnum.EnumVal1)
+      throw new Exception("Failed");
+  }
+}

Examples/test-suite/d/apply_strings_runme.1.d

@@ -0,0 +1,12 @@
+module apply_strings_runme;
+
+import apply_strings.apply_strings;
+
+const char[] TEST_MESSAGE = "A message from target language to the C++ world and back again.";
+
+void main() {
+  if (UCharFunction(TEST_MESSAGE) != TEST_MESSAGE) throw new Exception("UCharFunction failed");
+  if (SCharFunction(TEST_MESSAGE) != TEST_MESSAGE) throw new Exception("SCharFunction failed");
+  auto pChar = CharFunction(null);
+  if (pChar !is null) throw new Exception("CharFunction failed");
+}

Examples/test-suite/d/apply_strings_runme.2.d

@@ -0,0 +1,12 @@
+module apply_strings_runme;
+
+import apply_strings.apply_strings;
+
+enum string TEST_MESSAGE = "A message from target language to the C++ world and back again.";
+
+void main() {
+  if (UCharFunction(TEST_MESSAGE) != TEST_MESSAGE) throw new Exception("UCharFunction failed");
+  if (SCharFunction(TEST_MESSAGE) != TEST_MESSAGE) throw new Exception("SCharFunction failed");
+  auto pChar = CharFunction(null);
+  if (pChar !is null) throw new Exception("CharFunction failed");
+}

Examples/test-suite/d/bools_runme.1.d

@@ -0,0 +1,20 @@
+/// This is the bool runtime testcase. It checks that the C++ bool type works.
+module bools_runme;
+
+import bools.bools;
+
+void main() {
+  bool t = true;
+  bool f = false;
+
+  check_bo(f);
+  check_bo(t);
+}
+
+void check_bo(bool input) {
+  for (int i = 0; i < 1000; ++i) {
+    if (bo(input) != input) {
+      throw new Exception("Runtime test check_bo failed.");
+    }
+  }
+}

Examples/test-suite/d/bools_runme.2.d

@@ -0,0 +1,20 @@
+/// This is the bool runtime testcase. It checks that the C++ bool type works.
+module bools_runme;
+
+import bools.bools;
+
+void main() {
+  bool t = true;
+  bool f = false;
+
+  check_bo(f);
+  check_bo(t);
+}
+
+void check_bo(bool input) {
+  for (int i = 0; i < 1000; ++i) {
+    if (bo(input) != input) {
+      throw new Exception("Runtime test check_bo failed.");
+    }
+  }
+}

Examples/test-suite/d/catches_runme.1.d

@@ -0,0 +1,33 @@
+module catches_runme;
+
+import catches.catches;
+
+void main() {
+  test({ test_catches(1); }, "C++ int exception thrown, value: 1");
+  test({ test_catches(2); }, "two");
+  test({ test_catches(3); }, "C++ ThreeException const & exception thrown");
+
+  test({ test_exception_specification(1); }, "C++ int exception thrown, value: 1");
+  test({ test_exception_specification(2); }, "unknown exception");
+  test({ test_exception_specification(3); }, "unknown exception");
+
+  test({ test_catches_all(1); }, "unknown exception");
+}
+
+void test(void delegate() command, char[] expectedMessage) {
+  bool didntThrow;
+  try {
+    command();
+    didntThrow = true;
+  } catch (Exception e) {
+    if (e.msg != expectedMessage) {
+      throw new Exception("Failed to propagate C++ exception. Expected '" ~
+	expectedMessage ~ "', but received '" ~ e.msg ~ "'.");
+    }
+  }
+
+  if (didntThrow) {
+    throw new Exception("Failed to propagate C++ exception. Expected '" ~
+      expectedMessage ~ "', but no exception was thrown.");
+  }
+}

Examples/test-suite/d/catches_runme.2.d

@@ -0,0 +1,33 @@
+module catches_runme;
+
+import catches.catches;
+
+void main() {
+  test({ test_catches(1); }, "C++ int exception thrown, value: 1");
+  test({ test_catches(2); }, "two");
+  test({ test_catches(3); }, "C++ ThreeException const & exception thrown");
+
+  test({ test_exception_specification(1); }, "C++ int exception thrown, value: 1");
+  test({ test_exception_specification(2); }, "unknown exception");
+  test({ test_exception_specification(3); }, "unknown exception");
+
+  test({ test_catches_all(1); }, "unknown exception");
+}
+
+void test(void delegate() command, string expectedMessage) {
+  bool didntThrow;
+  try {
+    command();
+    didntThrow = true;
+  } catch (Exception e) {
+    if (e.msg != expectedMessage) {
+      throw new Exception("Failed to propagate C++ exception. Expected '" ~
+	expectedMessage ~ "', but received '" ~ e.msg ~ "'.");
+    }
+  }
+
+  if (didntThrow) {
+    throw new Exception("Failed to propagate C++ exception. Expected '" ~
+      expectedMessage ~ "', but no exception was thrown.");
+  }
+}

Examples/test-suite/d/char_strings_runme.1.d

@@ -0,0 +1,151 @@
+module char_strings_runme;
+
+import tango.text.convert.Integer;
+import char_strings.char_strings;
+
+const char[] CPLUSPLUS_MSG = "A message from the deep dark world of C++, where anything is possible.";
+const char[] OTHERLAND_MSG = "Little message from the safe world.";
+
+void main() {
+  const uint count = 10000;
+  uint i = 0;
+
+  // get functions
+  for (i=0; i<count; i++) {
+    char[] str = GetCharHeapString();
+    if (str != CPLUSPLUS_MSG)
+      throw new Exception("Test char get 1 failed, iteration " ~ toString(i));
+    DeleteCharHeapString();
+  }
+
+  for (i=0; i<count; i++) {
+    char[] str = GetConstCharProgramCodeString();
+    if (str != CPLUSPLUS_MSG)
+      throw new Exception("Test char get 2 failed, iteration " ~ toString(i));
+    DeleteCharHeapString();
+  }
+
+  for (i=0; i<count; i++) {
+    char[] str = GetCharStaticString();
+    if (str != CPLUSPLUS_MSG)
+      throw new Exception("Test char get 3 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    char[] str = GetCharStaticStringFixed();
+    if (str != CPLUSPLUS_MSG)
+      throw new Exception("Test char get 4 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    char[] str = GetConstCharStaticStringFixed();
+    if (str != CPLUSPLUS_MSG)
+      throw new Exception("Test char get 5 failed, iteration " ~ toString(i));
+  }
+
+  // set functions
+  for (i=0; i<count; i++) {
+    if (!SetCharHeapString(OTHERLAND_MSG ~ toString(i), i))
+      throw new Exception("Test char set 1 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    if (!SetCharStaticString(OTHERLAND_MSG ~ toString(i), i))
+      throw new Exception("Test char set 2 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    if (!SetCharArrayStaticString(OTHERLAND_MSG ~ toString(i), i))
+      throw new Exception("Test char set 3 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    if (!SetConstCharHeapString(OTHERLAND_MSG ~ toString(i), i))
+      throw new Exception("Test char set 4 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    if (!SetConstCharStaticString(OTHERLAND_MSG ~ toString(i), i))
+      throw new Exception("Test char set 5 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    if (!SetConstCharArrayStaticString(OTHERLAND_MSG ~ toString(i), i))
+      throw new Exception("Test char set 6 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    if (!SetCharConstStaticString(OTHERLAND_MSG ~ toString(i), i))
+      throw new Exception("Test char set 7 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    if (!SetConstCharConstStaticString(OTHERLAND_MSG ~ toString(i), i))
+      throw new Exception("Test char set 8 failed, iteration " ~ toString(i));
+  }
+
+  // get set function
+  for (i=0; i<count*10; i++) {
+    char[] ping = OTHERLAND_MSG ~ toString(i);
+    char[] pong = CharPingPong(ping);
+    if (ping != pong)
+      throw new Exception("Test PingPong 1 failed.\nExpected:" ~ ping ~ "\nReceived:" ~ pong);
+  }
+
+  // variables
+  for (i=0; i<count; i++) {
+    global_char = OTHERLAND_MSG ~ toString(i);
+    if (global_char != OTHERLAND_MSG ~ toString(i))
+      throw new Exception("Test variables 1 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    global_char_array1 = OTHERLAND_MSG ~ toString(i);
+    if (global_char_array1 != OTHERLAND_MSG ~ toString(i))
+      throw new Exception("Test variables 2 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    global_char_array2 = OTHERLAND_MSG ~ toString(i);
+    if (global_char_array2 != OTHERLAND_MSG ~ toString(i))
+      throw new Exception("Test variables 3 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    if (global_const_char != CPLUSPLUS_MSG)
+      throw new Exception("Test variables 4 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    if (global_const_char_array1 != CPLUSPLUS_MSG)
+      throw new Exception("Test variables 5 failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    if (global_const_char_array2 != CPLUSPLUS_MSG)
+      throw new Exception("Test variables 6 failed, iteration " ~ toString(i));
+  }
+
+  // char *& tests
+  for (i=0; i<count; i++) {
+    char[] str = GetCharPointerRef();
+    if (str != CPLUSPLUS_MSG)
+      throw new Exception("Test char pointer ref get failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    if (!SetCharPointerRef(OTHERLAND_MSG ~ toString(i), i))
+      throw new Exception("Test char pointer ref set failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    char[] str = GetConstCharPointerRef();
+    if (str != CPLUSPLUS_MSG)
+      throw new Exception("Test const char pointer ref get failed, iteration " ~ toString(i));
+  }
+
+  for (i=0; i<count; i++) {
+    if (!SetConstCharPointerRef(OTHERLAND_MSG ~ toString(i), i))
+      throw new Exception("Test const char pointer ref set failed, iteration " ~ toString(i));
+  }
+}

Examples/test-suite/d/char_strings_runme.2.d

@@ -0,0 +1,123 @@
+module char_strings_runme;
+
+import std.conv;
+import std.exception;
+import std.range;
+import char_strings.char_strings;
+
+enum CPLUSPLUS_MSG = "A message from the deep dark world of C++, where anything is possible.";
+enum OTHERLAND_MSG = "Little message from the safe world.";
+enum TEST_RANGE = iota(0, 10000);
+
+void main() {
+  // get functions
+  foreach (i; TEST_RANGE) {
+    enforce(GetCharHeapString() == CPLUSPLUS_MSG, "Test char get 1 failed, iteration " ~ to!string(i));
+    DeleteCharHeapString();
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(GetConstCharProgramCodeString() == CPLUSPLUS_MSG, "Test char get 2 failed, iteration " ~ to!string(i));
+    DeleteCharHeapString();
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(GetCharStaticString() == CPLUSPLUS_MSG, "Test char get 3 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(GetCharStaticStringFixed() == CPLUSPLUS_MSG, "Test char get 4 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(GetConstCharStaticStringFixed() == CPLUSPLUS_MSG, "Test char get 5 failed, iteration " ~ to!string(i));
+  }
+
+  // set functions
+  foreach (i; TEST_RANGE) {
+    enforce(SetCharHeapString(OTHERLAND_MSG ~ to!string(i), i), "Test char set 1 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(SetCharStaticString(OTHERLAND_MSG ~ to!string(i), i), "Test char set 2 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(SetCharArrayStaticString(OTHERLAND_MSG ~ to!string(i), i), "Test char set 3 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(SetConstCharHeapString(OTHERLAND_MSG ~ to!string(i), i), "Test char set 4 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(SetConstCharStaticString(OTHERLAND_MSG ~ to!string(i), i), "Test char set 5 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(SetConstCharArrayStaticString(OTHERLAND_MSG ~ to!string(i), i), "Test char set 6 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(SetCharConstStaticString(OTHERLAND_MSG ~ to!string(i), i), "Test char set 7 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(SetConstCharConstStaticString(OTHERLAND_MSG ~ to!string(i), i), "Test char set 8 failed, iteration " ~ to!string(i));
+  }
+
+  // get set function
+  foreach (i; TEST_RANGE) {
+    string ping = OTHERLAND_MSG ~ to!string(i);
+    string pong = CharPingPong(ping);
+    enforce(ping == pong, "Test PingPong 1 failed.\nExpected:" ~ ping ~ "\nReceived:" ~ pong);
+  }
+
+  // variables
+  foreach (i; TEST_RANGE) {
+    const msg = OTHERLAND_MSG ~ to!string(i);
+    global_char = msg;
+    enforce(global_char == msg, "Test variables 1 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    const msg = OTHERLAND_MSG ~ to!string(i);
+    global_char_array1 = msg;
+    enforce(global_char_array1 == msg, "Test variables 2 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    const msg = OTHERLAND_MSG ~ to!string(i);
+    global_char_array2 = msg;
+    enforce(global_char_array2 == msg, "Test variables 2 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(global_const_char == CPLUSPLUS_MSG, "Test variables 4 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(global_const_char_array1 == CPLUSPLUS_MSG, "Test variables 5 failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(global_const_char_array2 == CPLUSPLUS_MSG, "Test variables 6 failed, iteration " ~ to!string(i));
+  }
+
+  // char *& tests
+  foreach (i; TEST_RANGE) {
+    enforce(GetCharPointerRef() == CPLUSPLUS_MSG, "Test char pointer ref get failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(SetCharPointerRef(OTHERLAND_MSG ~ to!string(i), i), "Test char pointer ref set failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(GetConstCharPointerRef() == CPLUSPLUS_MSG, "Test const char pointer ref get failed, iteration " ~ to!string(i));
+  }
+
+  foreach (i; TEST_RANGE) {
+    enforce(SetConstCharPointerRef(OTHERLAND_MSG ~ to!string(i), i), "Test const char pointer ref set failed, iteration " ~ to!string(i));
+  }
+}

Examples/test-suite/d/constover_runme.1.d

@@ -0,0 +1,31 @@
+module constover_runme;
+
+import constover.constover;
+import constover.Foo;
+
+void main() {
+  char[] p = test("test");
+  if (p != "test")
+    throw new Exception("test failed!");
+
+  p = test_pconst("test");
+  if (p != "test_pconst")
+    throw new Exception("test_pconst failed!");
+
+  auto f = new Foo();
+  p = f.test("test");
+  if (p != "test")
+    throw new Exception("member-test failed!");
+
+  p = f.test_pconst("test");
+  if (p != "test_pconst")
+    throw new Exception("member-test_pconst failed!");
+
+  p = f.test_constm("test");
+  if (p != "test_constmethod")
+    throw new Exception("member-test_constm failed!");
+
+  p = f.test_pconstm("test");
+  if (p != "test_pconstmethod")
+    throw new Exception("member-test_pconstm failed!");
+}

Examples/test-suite/d/constover_runme.2.d

@@ -0,0 +1,16 @@
+module constover_runme;
+
+import std.exception;
+import constover.constover;
+import constover.Foo;
+
+void main() {
+  enforce(test("test") == "test", "test failed!");
+  enforce(test_pconst("test") == "test_pconst", "test_pconst failed!");
+
+  auto f = new Foo();
+  enforce(f.test("test") == "test", "member-test failed!");
+  enforce(f.test_pconst("test") == "test_pconst", "member-test_pconst failed!");
+  enforce(f.test_constm("test") == "test_constmethod", "member-test_constm failed!");
+  enforce(f.test_pconstm("test") == "test_pconstmethod", "member-test_pconstm failed!");
+}

Examples/test-suite/d/d_nativepointers_runme.1.d

@@ -0,0 +1,23 @@
+module d_nativepointers_runnme;
+
+import d_nativepointers.d_nativepointers;
+import d_nativepointers.SomeClass;
+import d_nativepointers.SWIGTYPE_p_OpaqueClass;
+import d_nativepointers.SWIGTYPE_p_p_SomeClass;
+import d_nativepointers.SWIGTYPE_p_p_f_p_p_int_p_SomeClass__void;
+
+void main() {
+   check!(a, int*);
+   check!(b, float**);
+   check!(c, char***);
+   check!(d, SomeClass);
+   check!(e, SWIGTYPE_p_p_SomeClass);
+   check!(f, SWIGTYPE_p_OpaqueClass);
+   check!(g, void function(int**, char***));
+   check!(h, SWIGTYPE_p_p_f_p_p_int_p_SomeClass__void);
+}
+
+void check(alias F, T)() {
+   static assert(is(T function(T) == typeof(&F)));
+   assert(F(null) is null);
+}

Examples/test-suite/d/d_nativepointers_runme.2.d

@@ -0,0 +1,23 @@
+module d_nativepointers_runnme;
+
+import d_nativepointers.d_nativepointers;
+import d_nativepointers.SomeClass;
+import d_nativepointers.SWIGTYPE_p_OpaqueClass;
+import d_nativepointers.SWIGTYPE_p_p_SomeClass;
+import d_nativepointers.SWIGTYPE_p_p_f_p_p_int_p_SomeClass__void;
+
+void main() {
+   check!(a, int*);
+   check!(b, float**);
+   check!(c, char***);
+   check!(d, SomeClass);
+   check!(e, SWIGTYPE_p_p_SomeClass);
+   check!(f, SWIGTYPE_p_OpaqueClass);
+   check!(g, void function(int**, char***));
+   check!(h, SWIGTYPE_p_p_f_p_p_int_p_SomeClass__void);
+}
+
+void check(alias F, T)() {
+   static assert(is(T function(T) == typeof(&F)));
+   assert(F(null) is null);
+}

Examples/test-suite/d/default_args_runme.1.d

@@ -0,0 +1,127 @@
+module default_args_runme;
+
+import default_args.default_args;
+import default_args.ConstMethods;
+import default_args.EnumClass;
+import default_args.Except;
+import default_args.Foo;
+import default_args.Klass;
+import default_args.Statics;
+import default_args.Tricky;
+
+void main() {
+  if (anonymous() != 7771)
+    throw new Exception("anonymous (1) failed");
+  if (anonymous(1234) != 1234)
+    throw new Exception("anonymous (2) failed");
+
+  if (booltest() != true)
+    throw new Exception("booltest (1) failed");
+  if (booltest(true) != true)
+    throw new Exception("booltest (2) failed");
+  if (booltest(false) != false)
+    throw new Exception("booltest (3) failed");
+
+  auto ec = new EnumClass();
+  if (ec.blah() != true)
+    throw new Exception("EnumClass failed");
+
+  if (casts1() != null)
+    throw new Exception("casts1 failed");
+
+  if (casts2() != "Hello")
+    throw new Exception("casts2 failed");
+
+  if (casts1("Ciao") != "Ciao")
+    throw new Exception("casts1 not default failed");
+
+  if (chartest1() != 'x')
+    throw new Exception("chartest1 failed");
+
+  if (chartest2() != '\0')
+    throw new Exception("chartest2 failed");
+
+  if (chartest1('y') != 'y')
+    throw new Exception("chartest1 not default failed");
+
+  if (chartest1('y') != 'y')
+    throw new Exception("chartest1 not default failed");
+
+  if (reftest1() != 42)
+    throw new Exception("reftest1 failed");
+
+  if (reftest1(400) != 400)
+    throw new Exception("reftest1 not default failed");
+
+  if (reftest2() != "hello")
+    throw new Exception("reftest2 failed");
+
+  // rename
+  auto foo = new Foo();
+  foo.newname();
+  foo.newname(10);
+  foo.renamed3arg(10, 10.0);
+  foo.renamed2arg(10);
+  foo.renamed1arg();
+
+  // exception specifications
+  testException( { exceptionspec(); }, "exceptionspec 1" );
+  testException( { exceptionspec(-1); }, "exceptionspec 2" );
+  testException( { exceptionspec(100); }, "exceptionspec 3" );
+
+  auto ex = new Except(false);
+  testException( { ex.exspec(); }, "exspec 1" );
+  testException( { ex.exspec(-1); }, "exspec 2" );
+  testException( { ex.exspec(100); }, "exspec 3" );
+  testException( { ex = new Except(true); }, "Except constructor 1" );
+  testException( { ex = new Except(true, -2); }, "Except constructor 2" );
+
+  // Default parameters in static class methods
+  if (Statics.staticmethod() != 10+20+30)
+    throw new Exception("staticmethod 1 failed");
+  if (Statics.staticmethod(100) != 100+20+30)
+    throw new Exception("staticmethod 2 failed");
+  if (Statics.staticmethod(100,200,300) != 100+200+300)
+    throw new Exception("staticmethod 3 failed");
+
+
+  auto tricky = new Tricky();
+  if (tricky.privatedefault() != 200)
+    throw new Exception("privatedefault failed");
+  if (tricky.protectedint() != 2000)
+    throw new Exception("protectedint failed");
+  if (tricky.protecteddouble() != 987.654)
+    throw new Exception("protecteddouble failed");
+  if (tricky.functiondefault() != 500)
+    throw new Exception("functiondefault failed");
+  if (tricky.contrived() != 'X')
+    throw new Exception("contrived failed");
+
+  if (constructorcall().val != -1)
+    throw new Exception("constructorcall test 1 failed");
+
+  if (constructorcall(new Klass(2222)).val != 2222)
+    throw new Exception("constructorcall test 2 failed");
+
+  if (constructorcall(new Klass()).val != -1)
+    throw new Exception("constructorcall test 3 failed");
+
+  // const methods
+  auto cm = new ConstMethods();
+  if (cm.coo() != 20)
+    throw new Exception("coo test 1 failed");
+  if (cm.coo(1.0) != 20)
+    throw new Exception("coo test 2 failed");
+}
+
+void testException(void delegate() command, char[] testName) {
+  bool didntThrow;
+  try {
+    command();
+    didntThrow = true;
+  } catch (Exception e) {}
+
+  if (didntThrow) {
+    throw new Exception(testName ~ " failed");
+  }
+}

Examples/test-suite/d/default_args_runme.2.d

@@ -0,0 +1,84 @@
+module default_args_runme;
+
+import std.exception;
+import default_args.default_args;
+import default_args.ConstMethods;
+import default_args.EnumClass;
+import default_args.Except;
+import default_args.Foo;
+import default_args.Klass;
+import default_args.Statics;
+import default_args.Tricky;
+
+void main() {
+  enforce(anonymous() == 7771, "anonymous (1) failed");
+  enforce(anonymous(1234) == 1234,"anonymous (2) failed");
+  enforce(booltest() == true, "booltest (1) failed");
+  enforce(booltest(true) == true, "booltest (2) failed");
+  enforce(booltest(false) == false, "booltest (3) failed");
+  enforce((new EnumClass()).blah() == true, "EnumClass failed");
+  enforce(casts1() == null, "casts1 failed");
+  enforce(casts2() == "Hello", "casts2 failed");
+  enforce(casts1("Ciao") == "Ciao", "casts1 not default failed");
+  enforce(chartest1() == 'x', "chartest1 failed");
+  enforce(chartest2() == '\0', "chartest2 failed");
+  enforce(chartest1('y') == 'y', "chartest1 not default failed");
+  enforce(chartest1('y') == 'y', "chartest1 not default failed");
+  enforce(reftest1() == 42, "reftest1 failed");
+  enforce(reftest1(400) == 400, "reftest1 not default failed");
+  enforce(reftest2() == "hello", "reftest2 failed");
+
+  // rename
+  auto foo = new Foo();
+  foo.newname();
+  foo.newname(10);
+  foo.renamed3arg(10, 10.0);
+  foo.renamed2arg(10);
+  foo.renamed1arg();
+
+  // exception specifications
+  enforceThrows( (){ exceptionspec(); }, "exceptionspec 1" );
+  enforceThrows( (){ exceptionspec(-1); }, "exceptionspec 2" );
+  enforceThrows( (){ exceptionspec(100); }, "exceptionspec 3" );
+
+  auto ex = new Except(false);
+  enforceThrows( (){ ex.exspec(); }, "exspec 1" );
+  enforceThrows( (){ ex.exspec(-1); }, "exspec 2" );
+  enforceThrows( (){ ex.exspec(100); }, "exspec 3" );
+  enforceThrows( (){ ex = new Except(true); }, "Except constructor 1" );
+  enforceThrows( (){ ex = new Except(true, -2); }, "Except constructor 2" );
+
+  // Default parameters in static class methods
+  enforce(Statics.staticmethod() == 10+20+30, "staticmethod 1 failed");
+  enforce(Statics.staticmethod(100) == 100+20+30, "staticmethod 2 failed");
+  enforce(Statics.staticmethod(100,200,300) == 100+200+300, "staticmethod 3 failed");
+
+  auto tricky = new Tricky();
+  enforce(tricky.privatedefault() == 200, "privatedefault failed");
+  enforce(tricky.protectedint() == 2000, "protectedint failed");
+  enforce(tricky.protecteddouble() == 987.654, "protecteddouble failed");
+  enforce(tricky.functiondefault() == 500, "functiondefault failed");
+  enforce(tricky.contrived() == 'X', "contrived failed");
+
+  enforce(constructorcall().val == -1, "constructorcall test 1 failed");
+  enforce(constructorcall(new Klass(2222)).val == 2222, "constructorcall test 2 failed");
+  enforce(constructorcall(new Klass()).val == -1, "constructorcall test 3 failed");
+
+  // const methods
+  const cm = new ConstMethods();
+  enforce(cm.coo() == 20, "coo test 1 failed");
+  enforce(cm.coo(1.0) == 20, "coo test 2 failed");
+}
+
+private void enforceThrows(void delegate() dg, string errorMessage) {
+  bool hasThrown;
+  try {
+    dg();
+  } catch (Exception) {
+    hasThrown = true;
+  } finally {
+    if (!hasThrown) {
+      throw new Exception(errorMessage);
+    }
+  }
+}

Examples/test-suite/d/default_constructor_runme.1.d

@@ -0,0 +1,30 @@
+module default_constructor_runme;
+
+import default_constructor.FFF;
+import default_constructor.G;
+
+void main() {
+  // Protected destructor test.
+  try {
+    {
+      scope g = new G();
+    }
+    throw new Exception("Protected destructor exception should have been thrown");
+  } catch (Exception e) {
+    if (e.msg != "C++ destructor does not have public access") {
+      throw e;
+    }
+  }
+
+  // Private destructor test.
+  try {
+    {
+      scope f = new FFF();
+    }
+    throw new Exception("Private destructor exception should have been thrown");
+  } catch (Exception e) {
+    if (e.msg != "C++ destructor does not have public access") {
+      throw e;
+    }
+  }
+}

Examples/test-suite/d/default_constructor_runme.2.d

@@ -0,0 +1,25 @@
+module default_constructor_runme;
+
+import default_constructor.FFF;
+import default_constructor.G;
+
+void main() {
+  // D2 does not support something akin to D1/Tango dispose() for deterministic
+  // destruction yet.
+
+  // enforceThrows((){ scope g = new G(); }, "Protected destructor exception should have been thrown");
+  // enforceThrows((){ scope f = new FFF(); }, "Private destructor exception should have been thrown");
+}
+
+private void enforceThrows(void delegate() dg, string errorMessage) {
+  bool hasThrown;
+  try {
+    dg();
+  } catch (Exception) {
+    hasThrown = true;
+  } finally {
+    if (!hasThrown) {
+      throw new Exception(errorMessage);
+    }
+  }
+}

Examples/test-suite/d/director_basic_runme.1.d

@@ -0,0 +1,59 @@
+module director_basic_runme;
+
+import director_basic.A1;
+import director_basic.Bar;
+import director_basic.Foo;
+import director_basic.MyClass;
+
+void main() {
+  auto a = new director_basic_MyFoo();
+  if (a.ping() != "director_basic_MyFoo::ping()") {
+    throw new Exception("a.ping()");
+  }
+  if (a.pong() != "Foo::pong();director_basic_MyFoo::ping()") {
+    throw new Exception("a.pong()");
+  }
+
+  auto b = new Foo();
+  if (b.ping() != "Foo::ping()") {
+    throw new Exception("b.ping()");
+  }
+  if (b.pong() != "Foo::pong();Foo::ping()") {
+    throw new Exception("b.pong()");
+  }
+
+  {
+    scope a1 = new A1(1, false);
+  }
+
+  {
+    auto my = new MyOverriddenClass();
+
+    my.expectNull = true;
+    if (MyClass.call_pmethod(my, null) !is null)
+      throw new Exception("null pointer conversion problem");
+
+    auto myBar = new Bar();
+    my.expectNull = false;
+    auto myNewBar = MyClass.call_pmethod(my, myBar);
+    if (myNewBar is null)
+      throw new Exception("non-null pointer conversion problem");
+    myNewBar.x = 10;
+  }
+}
+
+class director_basic_MyFoo : Foo {
+  public override char[] ping() {
+    return "director_basic_MyFoo::ping()";
+  }
+}
+
+class MyOverriddenClass : MyClass {
+  public bool expectNull = false;
+  public bool nonNullReceived = false;
+  public override Bar pmethod(Bar b) {
+    if (expectNull && (b !is null))
+      throw new Exception("null not received as expected");
+    return b;
+  }
+}

Examples/test-suite/d/director_basic_runme.2.d

@@ -0,0 +1,46 @@
+module director_basic_runme;
+
+import std.exception;
+import director_basic.A1;
+import director_basic.Bar;
+import director_basic.Foo;
+import director_basic.MyClass;
+
+void main() {
+  auto a = new director_basic_MyFoo();
+  enforce(a.ping() == "director_basic_MyFoo::ping()", "a.ping()");
+  enforce(a.pong() == "Foo::pong();director_basic_MyFoo::ping()", "a.pong()");
+
+  auto b = new Foo();
+  enforce(b.ping() == "Foo::ping()", "b.ping()");
+  enforce(b.pong() == "Foo::pong();Foo::ping()", "b.pong()");
+
+  {
+    scope a1 = new A1(1, false);
+  }
+
+  auto my = new MyOverriddenClass();
+  my.expectNull = true;
+  enforce(MyClass.call_pmethod(my, null) is null, "null pointer conversion problem");
+  auto myBar = new Bar();
+  my.expectNull = false;
+  auto myNewBar = MyClass.call_pmethod(my, myBar);
+  enforce(myNewBar !is null, "non-null pointer conversion problem");
+  myNewBar.x = 10;
+}
+
+class director_basic_MyFoo : Foo {
+  public override string ping() {
+    return "director_basic_MyFoo::ping()";
+  }
+}
+
+class MyOverriddenClass : MyClass {
+  public bool expectNull = false;
+  public bool nonNullReceived = false;
+  public override Bar pmethod(Bar b) {
+    if (expectNull && (b !is null))
+      throw new Exception("null not received as expected");
+    return b;
+  }
+}

Examples/test-suite/d/director_classes_runme.1.d

@@ -0,0 +1,168 @@
+/**
+ * This test demonstrates director classes when the types are classes. Shown are
+ * virtual function calls which use classes passed by
+ *  - Value
+ *  - Reference
+ *  - Pointer
+ * as both parameters and return values
+ *
+ * The test also demonstrates directors used with:
+ *  - method overloading
+ *  - default parameters
+ *
+ * Note: Methods with default parameters that call up from C++ cannot call the
+ * overloaded D methods, see DefaultParms method.
+
+ * Expected output if PrintDebug enabled:
+ * ------------ Start ------------
+ * Base - Val(444.555)
+ * Base - Ref(444.555)
+ * Base - Ptr(444.555)
+ * Base - FullyOverloaded(int 10)
+ * Base - FullyOverloaded(bool 1)
+ * Base - SemiOverloaded(int -678)
+ * Base - SemiOverloaded(bool 1)
+ * Base - DefaultParms(10, 2.2)
+ * Base - DefaultParms(10, 1.1)
+ * --------------------------------
+ * Derived - Val(444.555)
+ * Derived - Ref(444.555)
+ * Derived - Ptr(444.555)
+ * Derived - FullyOverloaded(int 10)
+ * Derived - FullyOverloaded(bool 1)
+ * Derived - SemiOverloaded(int -678)
+ * Base - SemiOverloaded(bool 1)
+ * Derived - DefaultParms(10, 2.2)
+ * Derived - DefaultParms(10, 1.1)
+ * --------------------------------
+ * DDerived - Val(444.555)
+ * DDerived - Ref(444.555)
+ * DDerived - Ptr(444.555)
+ * DDerived - FullyOverloaded(int 10)
+ * DDerived - FullyOverloaded(bool True)
+ * DDerived - SemiOverloaded(-678)
+ * Base - SemiOverloaded(bool 1)
+ * DDerived - DefaultParms(10, 2.2)
+ * DDerived - DefaultParms(10, 1.1)
+ * ------------ Finish ------------
+ */
+module director_classes_runme;
+
+import tango.io.Stdout;
+import tango.text.Util;
+import director_classes.director_classes;
+import director_classes.Caller;
+import director_classes.Base;
+import director_classes.Derived;
+import director_classes.DoubleHolder;
+
+void main() {
+  if (PrintDebug) Stdout.formatln("------------ Start ------------ ");
+
+  auto myCaller = new Caller();
+
+  // Test C++ base class.
+  {
+    scope myBase = new Base(100.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) Stdout.formatln("--------------------------------");
+
+  // Test vanilla C++ wrapped derived class.
+  {
+    scope myBase = new Derived(200.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) Stdout.formatln("--------------------------------");
+
+  // Test director / D derived class.
+  {
+    scope myBase = new DDerived(300.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) Stdout.formatln("------------ Finish ------------ ");
+}
+
+void makeCalls(Caller myCaller, Base myBase) {
+  char[] myBaseType = myBase.classinfo.name.split(".")[$-1];
+  myCaller.set(myBase);
+
+  DoubleHolder dh = new DoubleHolder(444.555);
+
+  // Class pointer, reference and pass by value tests
+  if (myCaller.ValCall(dh).val != dh.val) throw new Exception("[1] failed");
+  if (myCaller.RefCall(dh).val != dh.val) throw new Exception("[2] failed");
+  if (myCaller.PtrCall(dh).val != dh.val) throw new Exception("[3] failed");
+
+  // Fully overloaded method test (all methods in base class are overloaded)
+  if (myCaller.FullyOverloadedCall(10) != myBaseType ~ "::FullyOverloaded(int)") throw new Exception("[4] failed");
+  if (myCaller.FullyOverloadedCall(true) != myBaseType ~ "::FullyOverloaded(bool)") throw new Exception("[5] failed");
+
+  // Semi overloaded method test (some methods in base class are overloaded)
+  if (myCaller.SemiOverloadedCall(-678) != myBaseType ~ "::SemiOverloaded(int)") throw new Exception("[6] failed");
+  if (myCaller.SemiOverloadedCall(true) != "Base" ~ "::SemiOverloaded(bool)") throw new Exception("[7] failed");
+
+  // Default parameters methods test
+  if (myCaller.DefaultParmsCall(10, 2.2) != myBaseType ~ "::DefaultParms(int, double)") throw new Exception("[8] failed");
+  if (myBase.classinfo == DDerived.classinfo) { // special handling for D derived classes, there is no way to do this any other way
+    if (myCaller.DefaultParmsCall(10) != myBaseType ~ "::DefaultParms(int, double)") throw new Exception("[9] failed");
+  } else {
+    if (myCaller.DefaultParmsCall(10) != myBaseType ~ "::DefaultParms(int)") throw new Exception("[10] failed");
+  }
+
+  myCaller.reset();
+}
+
+public class DDerived : Base {
+  public this(double dd) {
+    super(dd);
+  }
+
+  public override DoubleHolder Val(DoubleHolder x) {
+    if (PrintDebug) Stdout.formatln("DDerived - Val({0:d3})", x.val);
+    return x;
+  }
+
+  public override DoubleHolder Ref(DoubleHolder x) {
+    if (PrintDebug) Stdout.formatln("DDerived - Ref({0:d3})", x.val);
+    return x;
+  }
+
+  public override DoubleHolder Ptr(DoubleHolder x) {
+    if (PrintDebug) Stdout.formatln("DDerived - Ptr({0:d3})", x.val);
+    return x;
+  }
+
+  public override char[] FullyOverloaded(int x) {
+    if (PrintDebug) Stdout.formatln("DDerived - FullyOverloaded(int {0})", x);
+    return "DDerived::FullyOverloaded(int)";
+  }
+
+  public override char[] FullyOverloaded(bool x) {
+    if (PrintDebug) Stdout.formatln("DDerived - FullyOverloaded(bool {0})", x);
+    return "DDerived::FullyOverloaded(bool)";
+  }
+
+  public override char[] SemiOverloaded(int x) {
+    char[] ret = "DDerived::SemiOverloaded(int)";
+    if (PrintDebug) Stdout.formatln("DDerived - SemiOverloaded({0})", x);
+    return ret;
+  }
+  alias Base.SemiOverloaded SemiOverloaded; // Alias in SemiOverloaded(bool x).
+
+  public override char[] DefaultParms(int x, double y) {
+    char[] ret = "DDerived::DefaultParms(int, double)";
+    if (PrintDebug) Stdout.formatln("DDerived - DefaultParms({0}, {1:d1})", x, y);
+    return ret;
+  }
+  // This method will never be called from C++ code because the two-parameter
+  // DefaultParams() has a default value for the second parameter there. It is
+  // only here to ensure consistent behavior for calls from C++ and D code.
+  public override char[] DefaultParms(int x) {
+    if (PrintDebug) Stdout.formatln("DDerived - DefaultParms({0})", x);
+    return DefaultParms(x, 1.1/*use C++ default here*/);
+  }
+}

Examples/test-suite/d/director_classes_runme.2.d

@@ -0,0 +1,169 @@
+/**
+ * This test demonstrates director classes when the types are classes. Shown are
+ * virtual function calls which use classes passed by
+ *  - Value
+ *  - Reference
+ *  - Pointer
+ * as both parameters and return values
+ *
+ * The test also demonstrates directors used with:
+ *  - method overloading
+ *  - default parameters
+ *
+ * Note: Methods with default parameters that call up from C++ cannot call the
+ * overloaded D methods, see DefaultParms method.
+
+ * Expected output if PrintDebug enabled:
+ * ------------ Start ------------
+ * Base - Val(444.555)
+ * Base - Ref(444.555)
+ * Base - Ptr(444.555)
+ * Base - FullyOverloaded(int 10)
+ * Base - FullyOverloaded(bool 1)
+ * Base - SemiOverloaded(int -678)
+ * Base - SemiOverloaded(bool 1)
+ * Base - DefaultParms(10, 2.2)
+ * Base - DefaultParms(10, 1.1)
+ * --------------------------------
+ * Derived - Val(444.555)
+ * Derived - Ref(444.555)
+ * Derived - Ptr(444.555)
+ * Derived - FullyOverloaded(int 10)
+ * Derived - FullyOverloaded(bool 1)
+ * Derived - SemiOverloaded(int -678)
+ * Base - SemiOverloaded(bool 1)
+ * Derived - DefaultParms(10, 2.2)
+ * Derived - DefaultParms(10, 1.1)
+ * --------------------------------
+ * DDerived - Val(444.555)
+ * DDerived - Ref(444.555)
+ * DDerived - Ptr(444.555)
+ * DDerived - FullyOverloaded(int 10)
+ * DDerived - FullyOverloaded(bool true)
+ * DDerived - SemiOverloaded(-678)
+ * Base - SemiOverloaded(bool 1)
+ * DDerived - DefaultParms(10, 2.2)
+ * DDerived - DefaultParms(10, 1.1)
+ * ------------ Finish ------------
+ */
+module director_classes_runme;
+
+import std.exception;
+import std.stdio;
+import std.string;
+import director_classes.director_classes;
+import director_classes.Caller;
+import director_classes.Base;
+import director_classes.Derived;
+import director_classes.DoubleHolder;
+
+void main() {
+  if (PrintDebug) writeln("------------ Start ------------ ");
+
+  auto myCaller = new Caller();
+
+  // Test C++ base class.
+  {
+    scope myBase = new Base(100.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) writeln("--------------------------------");
+
+  // Test vanilla C++ wrapped derived class.
+  {
+    scope myBase = new Derived(200.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) writeln("--------------------------------");
+
+  // Test director / D derived class.
+  {
+    scope myBase = new DDerived(300.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) writeln("------------ Finish ------------ ");
+}
+
+void makeCalls(Caller myCaller, Base myBase) {
+  string myBaseType = myBase.classinfo.name.split(".")[$-1];
+  myCaller.set(myBase);
+
+  DoubleHolder dh = new DoubleHolder(444.555);
+
+  // Class pointer, reference and pass by value tests
+  enforce(myCaller.ValCall(dh).val == dh.val, "[1] failed");
+  enforce(myCaller.RefCall(dh).val == dh.val, "[2] failed");
+  enforce(myCaller.PtrCall(dh).val == dh.val, "[3] failed");
+
+  // Fully overloaded method test (all methods in base class are overloaded)
+  enforce(myCaller.FullyOverloadedCall(10) == myBaseType ~ "::FullyOverloaded(int)", "[4] failed");
+  enforce(myCaller.FullyOverloadedCall(true) == myBaseType ~ "::FullyOverloaded(bool)", "[5] failed");
+
+  // Semi overloaded method test (some methods in base class are overloaded)
+  enforce(myCaller.SemiOverloadedCall(-678) == myBaseType ~ "::SemiOverloaded(int)", "[6] failed");
+  enforce(myCaller.SemiOverloadedCall(true) == "Base" ~ "::SemiOverloaded(bool)", "[7] failed");
+
+  // Default parameters methods test
+  enforce(myCaller.DefaultParmsCall(10, 2.2) == myBaseType ~ "::DefaultParms(int, double)", "[8] failed");
+  if (myBase.classinfo == DDerived.classinfo) { // special handling for D derived classes, there is no other way to do this
+    enforce(myCaller.DefaultParmsCall(10) == myBaseType ~ "::DefaultParms(int, double)", "[9] failed");
+  } else {
+    enforce(myCaller.DefaultParmsCall(10) == myBaseType ~ "::DefaultParms(int)", "[10] failed");
+  }
+
+  myCaller.reset();
+}
+
+public class DDerived : Base {
+  public this(double dd) {
+    super(dd);
+  }
+
+  public override DoubleHolder Val(DoubleHolder x) {
+    if (PrintDebug) writefln("DDerived - Val(%s)", x.val);
+    return x;
+  }
+
+  public override DoubleHolder Ref(DoubleHolder x) {
+    if (PrintDebug) writefln("DDerived - Ref(%s)", x.val);
+    return x;
+  }
+
+  public override DoubleHolder Ptr(DoubleHolder x) {
+    if (PrintDebug) writefln("DDerived - Ptr(%s)", x.val);
+    return x;
+  }
+
+  public override string FullyOverloaded(int x) {
+    if (PrintDebug) writefln("DDerived - FullyOverloaded(int %s)", x);
+    return "DDerived::FullyOverloaded(int)";
+  }
+
+  public override string FullyOverloaded(bool x) {
+    if (PrintDebug) writefln("DDerived - FullyOverloaded(bool %s)", x);
+    return "DDerived::FullyOverloaded(bool)";
+  }
+
+  public override string SemiOverloaded(int x) {
+    string ret = "DDerived::SemiOverloaded(int)";
+    if (PrintDebug) writefln("DDerived - SemiOverloaded(%s)", x);
+    return ret;
+  }
+  alias Base.SemiOverloaded SemiOverloaded; // Alias in SemiOverloaded(bool x).
+
+  public override string DefaultParms(int x, double y) {
+    string ret = "DDerived::DefaultParms(int, double)";
+    if (PrintDebug) writefln("DDerived - DefaultParms(%s, %s)", x, y);
+    return ret;
+  }
+  // This method will never be called from C++ code because the two-parameter
+  // DefaultParams() has a default value for the second parameter there. It is
+  // only here to ensure consistent behavior for calls from C++ and D code.
+  public override string DefaultParms(int x) {
+    if (PrintDebug) writefln("DDerived - DefaultParms(%s)", x);
+    return DefaultParms(x, 1.1/*use C++ default here*/);
+  }
+}

Examples/test-suite/d/director_classic_runme.1.d

@@ -0,0 +1,207 @@
+module director_classic_runme;
+
+import tango.io.Stdout;
+import director_classic.Caller;
+import director_classic.Person;
+import director_classic.Child;
+import director_classic.GrandChild;
+import director_classic.OrphanPerson;
+import director_classic.OrphanChild;
+
+const bool TRACE = false;
+
+void main() {
+  {
+    scope person = new Person();
+    check(person, "Person");
+  }
+  {
+    scope person = new Child();
+    check(person, "Child");
+  }
+  {
+    scope person = new GrandChild();
+    check(person, "GrandChild");
+  }
+  {
+    scope person = new TargetLangPerson();
+    check(person, "TargetLangPerson");
+  }
+  {
+    scope person = new TargetLangChild();
+    check(person, "TargetLangChild");
+  }
+  {
+    scope person = new TargetLangGrandChild();
+    check(person, "TargetLangGrandChild");
+  }
+
+  // Semis - don't override id() in target language
+  {
+    scope person = new TargetLangSemiPerson();
+    check(person, "Person");
+  }
+  {
+    scope person = new TargetLangSemiChild();
+    check(person, "Child");
+  }
+  {
+    scope person = new TargetLangSemiGrandChild();
+    check(person, "GrandChild");
+  }
+
+  // Orphans - don't override id() in C++
+  {
+    scope person = new OrphanPerson();
+    check(person, "Person");
+  }
+  {
+    scope person = new OrphanChild();
+    check(person, "Child");
+  }
+  {
+    scope person = new TargetLangOrphanPerson();
+    check(person, "TargetLangOrphanPerson");
+  }
+  {
+    scope person = new TargetLangOrphanChild();
+    check(person, "TargetLangOrphanChild");
+  }
+
+  // Duals - id() makes an upcall to the base id()
+  {
+    scope person = new TargetLangDualPerson();
+    check(person, "TargetLangDualPerson + Person");
+  }
+  {
+    scope person = new TargetLangDualChild();
+    check(person, "TargetLangDualChild + Child");
+  }
+  {
+    scope person = new TargetLangDualGrandChild();
+    check(person, "TargetLangDualGrandChild + GrandChild");
+  }
+
+  // Mix Orphans and Duals
+  {
+    scope person = new TargetLangDualOrphanPerson();
+    check(person, "TargetLangDualOrphanPerson + Person");
+  }
+  {
+    scope person = new TargetLangDualOrphanChild();
+    check(person, "TargetLangDualOrphanChild + Child");
+  }
+}
+
+void check(Person person, char[] expected) {
+  char[] ret;
+  // Normal D polymorphic call.
+  ret = person.id();
+  if (TRACE)
+    Stdout(ret).newline;
+  if (ret != expected)
+    throw new Exception("Failed. Received: " ~ ret ~ " Expected: " ~ expected);
+
+  // Polymorphic call from C++.
+  Caller caller = new Caller();
+  caller.setCallback(person);
+  ret = caller.call();
+  if (TRACE)
+    Stdout(ret).newline;
+  if (ret != expected)
+    throw new Exception("Failed. Received: " ~ ret ~ " Expected: " ~ expected);
+
+  // Polymorphic call of object created in D and passed to C++ and back again.
+  Person baseclass = caller.baseClass();
+  ret = baseclass.id();
+  if (TRACE)
+    Stdout(ret).newline;
+  if (ret != expected)
+    throw new Exception("Failed. Received: " ~ ret ~ " Expected: " ~ expected);
+
+  caller.resetCallback();
+  if (TRACE)
+    Stdout("----------------------------------------").newline;
+}
+
+
+// »Full« target language persons.
+class TargetLangPerson : Person {
+  public override char[] id() {
+    return "TargetLangPerson";
+  }
+}
+
+class TargetLangChild : Child {
+  public override char[] id() {
+    return "TargetLangChild";
+  }
+}
+
+class TargetLangGrandChild : GrandChild {
+  public override char[] id() {
+    return "TargetLangGrandChild";
+  }
+}
+
+
+// Semis - don't override id() in target language
+class TargetLangSemiPerson : Person {
+  // No id() override
+}
+
+class TargetLangSemiChild : Child {
+  // No id() override
+}
+
+class TargetLangSemiGrandChild : GrandChild {
+  // No id() override
+}
+
+
+// Orphans - don't override id() in C++
+class TargetLangOrphanPerson : OrphanPerson {
+  public override char[] id() {
+    return "TargetLangOrphanPerson";
+  }
+}
+
+class TargetLangOrphanChild : OrphanChild {
+  public override char[] id() {
+    return "TargetLangOrphanChild";
+  }
+}
+
+
+// Duals - id() makes an upcall to the base id()
+class TargetLangDualPerson : Person {
+  public override char[] id() {
+    return "TargetLangDualPerson + " ~ super.id();
+  }
+}
+
+class TargetLangDualChild : Child {
+  public override char[] id() {
+    return "TargetLangDualChild + " ~ super.id();
+  }
+}
+
+class TargetLangDualGrandChild : GrandChild {
+  public override char[] id() {
+    return "TargetLangDualGrandChild + " ~ super.id();
+  }
+}
+
+
+// Mix Orphans and Duals
+class TargetLangDualOrphanPerson : OrphanPerson {
+  public override char[] id() {
+    return "TargetLangDualOrphanPerson + " ~ super.id();
+  }
+}
+
+class TargetLangDualOrphanChild : OrphanChild {
+  public override char[] id() {
+    return "TargetLangDualOrphanChild + " ~ super.id();
+  }
+}

Examples/test-suite/d/director_classic_runme.2.d

@@ -0,0 +1,202 @@
+module director_classic_runme;
+
+import std.exception;
+import std.stdio;
+import director_classic.Caller;
+import director_classic.Person;
+import director_classic.Child;
+import director_classic.GrandChild;
+import director_classic.OrphanPerson;
+import director_classic.OrphanChild;
+
+enum TRACE = false;
+
+void main() {
+  {
+    scope person = new Person();
+    check(person, "Person");
+  }
+  {
+    scope person = new Child();
+    check(person, "Child");
+  }
+  {
+    scope person = new GrandChild();
+    check(person, "GrandChild");
+  }
+  {
+    scope person = new TargetLangPerson();
+    check(person, "TargetLangPerson");
+  }
+  {
+    scope person = new TargetLangChild();
+    check(person, "TargetLangChild");
+  }
+  {
+    scope person = new TargetLangGrandChild();
+    check(person, "TargetLangGrandChild");
+  }
+
+  // Semis - don't override id() in target language
+  {
+    scope person = new TargetLangSemiPerson();
+    check(person, "Person");
+  }
+  {
+    scope person = new TargetLangSemiChild();
+    check(person, "Child");
+  }
+  {
+    scope person = new TargetLangSemiGrandChild();
+    check(person, "GrandChild");
+  }
+
+  // Orphans - don't override id() in C++
+  {
+    scope person = new OrphanPerson();
+    check(person, "Person");
+  }
+  {
+    scope person = new OrphanChild();
+    check(person, "Child");
+  }
+  {
+    scope person = new TargetLangOrphanPerson();
+    check(person, "TargetLangOrphanPerson");
+  }
+  {
+    scope person = new TargetLangOrphanChild();
+    check(person, "TargetLangOrphanChild");
+  }
+
+  // Duals - id() makes an upcall to the base id()
+  {
+    scope person = new TargetLangDualPerson();
+    check(person, "TargetLangDualPerson + Person");
+  }
+  {
+    scope person = new TargetLangDualChild();
+    check(person, "TargetLangDualChild + Child");
+  }
+  {
+    scope person = new TargetLangDualGrandChild();
+    check(person, "TargetLangDualGrandChild + GrandChild");
+  }
+
+  // Mix Orphans and Duals
+  {
+    scope person = new TargetLangDualOrphanPerson();
+    check(person, "TargetLangDualOrphanPerson + Person");
+  }
+  {
+    scope person = new TargetLangDualOrphanChild();
+    check(person, "TargetLangDualOrphanChild + Child");
+  }
+}
+
+void check(Person person, string expected) {
+  string ret;
+  // Normal D polymorphic call.
+  ret = person.id();
+  if (TRACE) writeln(ret);
+  enforce(ret == expected, "Failed. Received: " ~ ret ~ " Expected: " ~ expected);
+
+  // Polymorphic call from C++.
+  auto caller = new Caller();
+  caller.setCallback(person);
+  ret = caller.call();
+  if (TRACE) writeln(ret);
+  enforce(ret == expected, "Failed. Received: " ~ ret ~ " Expected: " ~ expected);
+
+  // Polymorphic call of object created in D and passed to C++ and back again.
+  Person baseclass = caller.baseClass();
+  ret = baseclass.id();
+  if (TRACE) writeln(ret);
+  enforce(ret == expected, "Failed. Received: " ~ ret ~ " Expected: " ~ expected);
+
+  caller.resetCallback();
+  if (TRACE)
+    writeln("----------------------------------------");
+}
+
+
+// »Full« target language persons.
+class TargetLangPerson : Person {
+  public override string id() {
+    return "TargetLangPerson";
+  }
+}
+
+class TargetLangChild : Child {
+  public override string id() {
+    return "TargetLangChild";
+  }
+}
+
+class TargetLangGrandChild : GrandChild {
+  public override string id() {
+    return "TargetLangGrandChild";
+  }
+}
+
+
+// Semis - don't override id() in target language
+class TargetLangSemiPerson : Person {
+  // No id() override
+}
+
+class TargetLangSemiChild : Child {
+  // No id() override
+}
+
+class TargetLangSemiGrandChild : GrandChild {
+  // No id() override
+}
+
+
+// Orphans - don't override id() in C++
+class TargetLangOrphanPerson : OrphanPerson {
+  public override string id() {
+    return "TargetLangOrphanPerson";
+  }
+}
+
+class TargetLangOrphanChild : OrphanChild {
+  public override string id() {
+    return "TargetLangOrphanChild";
+  }
+}
+
+
+// Duals - id() makes an upcall to the base id()
+class TargetLangDualPerson : Person {
+  public override string id() {
+    return "TargetLangDualPerson + " ~ super.id();
+  }
+}
+
+class TargetLangDualChild : Child {
+  public override string id() {
+    return "TargetLangDualChild + " ~ super.id();
+  }
+}
+
+class TargetLangDualGrandChild : GrandChild {
+  public override string id() {
+    return "TargetLangDualGrandChild + " ~ super.id();
+  }
+}
+
+
+// Mix Orphans and Duals
+class TargetLangDualOrphanPerson : OrphanPerson {
+  public override string id() {
+    return "TargetLangDualOrphanPerson + " ~ super.id();
+  }
+}
+
+class TargetLangDualOrphanChild : OrphanChild {
+  public override string id() {
+    return "TargetLangDualOrphanChild + " ~ super.id();
+  }
+}

Examples/test-suite/d/director_ignore_runme.1.d

@@ -0,0 +1,39 @@
+module director_ignore_runme;
+
+import director_ignore.DIgnores;
+import director_ignore.DAbstractIgnores;
+
+void main() {
+  // Just check the classes can be instantiated and other methods work as expected
+  auto a = new DIgnoresDerived();
+  if (a.Triple(5) != 15)
+    throw new Exception("Triple failed");
+
+  auto b = new DAbstractIgnoresDerived();
+  if (b.Quadruple(5) != 20)
+    throw new Exception("Quadruple failed");
+}
+
+class DIgnoresDerived : DIgnores {
+public:
+  // These will give a warning if the %ignore is not working
+  int OverloadedMethod(int n, int xoffset, int yoffset) { return 0; }
+  int OverloadedMethod(int n, int xoffset) { return 0; }
+  int OverloadedMethod(int n) { return 0; }
+
+  int OverloadedProtectedMethod(int n, int xoffset, int yoffset) { return 0; }
+  int OverloadedProtectedMethod(int n, int xoffset) { return 0; }
+  int OverloadedProtectedMethod(int n) { return 0; }
+}
+
+class DAbstractIgnoresDerived : DAbstractIgnores {
+public:
+  // These will give a warning if the %ignore is not working
+  int OverloadedMethod(int n, int xoffset, int yoffset) { return 0; }
+  int OverloadedMethod(int n, int xoffset) { return 0; }
+  int OverloadedMethod(int n) { return 0; }
+
+  int OverloadedProtectedMethod(int n, int xoffset, int yoffset) { return 0; }
+  int OverloadedProtectedMethod(int n, int xoffset) { return 0; }
+  int OverloadedProtectedMethod(int n) { return 0; }
+}

Examples/test-suite/d/director_ignore_runme.2.d

@@ -0,0 +1,38 @@
+module director_ignore_runme;
+
+import std.exception;
+import director_ignore.DIgnores;
+import director_ignore.DAbstractIgnores;
+
+void main() {
+  // Just check the classes can be instantiated and other methods work as expected
+  auto a = new DIgnoresDerived();
+  enforce(a.Triple(5) == 15, "Triple failed");
+
+  auto b = new DAbstractIgnoresDerived();
+  enforce(b.Quadruple(5) == 20, "Quadruple failed");
+}
+
+class DIgnoresDerived : DIgnores {
+public:
+  // These will give a warning if the %ignore is not working
+  int OverloadedMethod(int n, int xoffset, int yoffset) { return 0; }
+  int OverloadedMethod(int n, int xoffset) { return 0; }
+  int OverloadedMethod(int n) { return 0; }
+
+  int OverloadedProtectedMethod(int n, int xoffset, int yoffset) { return 0; }
+  int OverloadedProtectedMethod(int n, int xoffset) { return 0; }
+  int OverloadedProtectedMethod(int n) { return 0; }
+}
+
+class DAbstractIgnoresDerived : DAbstractIgnores {
+public:
+  // These will give a warning if the %ignore is not working
+  int OverloadedMethod(int n, int xoffset, int yoffset) { return 0; }
+  int OverloadedMethod(int n, int xoffset) { return 0; }
+  int OverloadedMethod(int n) { return 0; }
+
+  int OverloadedProtectedMethod(int n, int xoffset, int yoffset) { return 0; }
+  int OverloadedProtectedMethod(int n, int xoffset) { return 0; }
+  int OverloadedProtectedMethod(int n) { return 0; }
+}

Examples/test-suite/d/director_primitives_runme.1.d

@@ -0,0 +1,122 @@
+/**
+ * This test program shows a D class DDerived inheriting from Base.
+ *
+ * Three types of classes are created and the virtual methods called to
+ * demonstrate:
+ *  - Wide variety of primitive types
+ *  - Calling methods with zero, one or more parameters
+ *  - Director methods that are not overridden in D
+ *  - Director classes that are not overridden at all in D, i.e. non-director
+ *    behaviour is as expected for director classes
+ *  - Inheritance hierarchy using director methods
+ *  - Return types working as well as parameters
+ *
+ * The Caller class is a tester class which calls the virtual functions from C++.
+ */
+module director_primitives_runme;
+
+import tango.io.Stdout;
+import director_primitives.director_primitives;
+import director_primitives.Base;
+import director_primitives.Caller;
+import director_primitives.Derived;
+import director_primitives.HShadowMode;
+
+void main() {
+  PrintDebug = false;
+  if (PrintDebug) Stdout("------------ Start ------------ ").newline;
+
+  Caller myCaller = new Caller();
+
+  // Test C++ base class.
+  {
+    scope myBase = new Base(100.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) Stdout("--------------------------------").newline;
+
+  // Test vanilla C++ wrapped derived class.
+  {
+    scope Base myBase = new Derived(100.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) Stdout("--------------------------------").newline;
+
+  // Test director/D derived class.
+  {
+    scope Base myBase = new DDerived(300.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) Stdout("------------ Finish ------------ ").newline;
+}
+
+void makeCalls(Caller myCaller, Base myBase) {
+  myCaller.set(myBase);
+
+  myCaller.NoParmsMethodCall();
+  if (myCaller.BoolMethodCall(true) != true) throw new Exception("failed");
+  if (myCaller.BoolMethodCall(false) != false) throw new Exception("failed");
+  if (myCaller.IntMethodCall(-123) != -123) throw new Exception("failed");
+  if (myCaller.UIntMethodCall(123) != 123) throw new Exception("failed");
+  if (myCaller.FloatMethodCall(-123.456f) != -123.456f) throw new Exception("failed");
+  if (myCaller.CharPtrMethodCall("test string") != "test string") throw new Exception("failed");
+  if (myCaller.ConstCharPtrMethodCall("another string") != "another string") throw new Exception("failed");
+  if (myCaller.EnumMethodCall(HShadowMode.HShadowHard) != HShadowMode.HShadowHard) throw new Exception("failed");
+  myCaller.ManyParmsMethodCall(true, -123, 123, 123.456f, "test string", "another string", HShadowMode.HShadowHard);
+  myCaller.NotOverriddenMethodCall();
+
+  myCaller.reset();
+}
+
+class DDerived : Base {
+public:
+  this(double dd) {
+    super(dd);
+  }
+
+  override void NoParmsMethod() {
+    if (PrintDebug) Stdout("DDerived - NoParmsMethod()").newline;
+  }
+
+  override bool BoolMethod(bool x) {
+    if (PrintDebug) Stdout.formatln("DDerived - BoolMethod({0})", x);
+    return x;
+  }
+
+  override int IntMethod(int x) {
+    if (PrintDebug) Stdout.formatln("DDerived - IntMethod({0})", x);
+    return x;
+  }
+
+  override uint UIntMethod(uint x) {
+    if (PrintDebug) Stdout.formatln("DDerived - UIntMethod({0})", x);
+    return x;
+  }
+
+  override float FloatMethod(float x) {
+    if (PrintDebug) Stdout.formatln("DDerived - FloatMethod({0})", x);
+    return x;
+  }
+
+  override char[] CharPtrMethod(char[] x) {
+    if (PrintDebug) Stdout.formatln("DDerived - CharPtrMethod({0})", x);
+    return x;
+  }
+
+  override char[] ConstCharPtrMethod(char[] x) {
+    if (PrintDebug) Stdout.formatln("DDerived - ConstCharPtrMethod({0})", x);
+    return x;
+  }
+
+  override HShadowMode EnumMethod(HShadowMode x) {
+    if (PrintDebug) Stdout.formatln("DDerived - EnumMethod({0})", x);
+    return x;
+  }
+
+  override void ManyParmsMethod(bool b, int i, uint u, float f, char[] c, char[] cc, HShadowMode h) {
+    if (PrintDebug) Stdout.formatln("DDerived - ManyParmsMethod({0}, {1}, {2}, {3:d3}, {4}, {5}, {6})", b, i, u, f, c, cc, h);
+  }
+}

Examples/test-suite/d/director_primitives_runme.2.d

@@ -0,0 +1,123 @@
+/**
+ * This test program shows a D class DDerived inheriting from Base.
+ *
+ * Three types of classes are created and the virtual methods called to
+ * demonstrate:
+ *  - Wide variety of primitive types
+ *  - Calling methods with zero, one or more parameters
+ *  - Director methods that are not overridden in D
+ *  - Director classes that are not overridden at all in D, i.e. non-director
+ *    behaviour is as expected for director classes
+ *  - Inheritance hierarchy using director methods
+ *  - Return types working as well as parameters
+ *
+ * The Caller class is a tester class which calls the virtual functions from C++.
+ */
+module director_primitives_runme;
+
+import std.exception;
+import std.stdio;
+import director_primitives.director_primitives;
+import director_primitives.Base;
+import director_primitives.Caller;
+import director_primitives.Derived;
+import director_primitives.HShadowMode;
+
+void main() {
+  PrintDebug = false;
+  if (PrintDebug) writeln("------------ Start ------------ ");
+
+  auto myCaller = new Caller();
+
+  // Test C++ base class.
+  {
+    scope myBase = new Base(100.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) writeln("--------------------------------");
+
+  // Test vanilla C++ wrapped derived class.
+  {
+    scope Base myBase = new Derived(100.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) writeln("--------------------------------");
+
+  // Test director/D derived class.
+  {
+    scope Base myBase = new DDerived(300.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) writeln("------------ Finish ------------ ");
+}
+
+void makeCalls(Caller myCaller, Base myBase) {
+  myCaller.set(myBase);
+
+  myCaller.NoParmsMethodCall();
+  enforce(myCaller.BoolMethodCall(true) == true, "failed");
+  enforce(myCaller.BoolMethodCall(false) == false, "failed");
+  enforce(myCaller.IntMethodCall(-123) == -123, "failed");
+  enforce(myCaller.UIntMethodCall(123) == 123, "failed");
+  enforce(myCaller.FloatMethodCall(-123.456f) == -123.456f, "failed");
+  enforce(myCaller.CharPtrMethodCall("test string") == "test string", "failed");
+  enforce(myCaller.ConstCharPtrMethodCall("another string") == "another string", "failed");
+  enforce(myCaller.EnumMethodCall(HShadowMode.HShadowHard) == HShadowMode.HShadowHard, "failed");
+  myCaller.ManyParmsMethodCall(true, -123, 123, 123.456f, "test string", "another string", HShadowMode.HShadowHard);
+  myCaller.NotOverriddenMethodCall();
+
+  myCaller.reset();
+}
+
+class DDerived : Base {
+public:
+  this(double dd) {
+    super(dd);
+  }
+
+  override void NoParmsMethod() {
+    if (PrintDebug) writeln("DDerived - NoParmsMethod()");
+  }
+
+  override bool BoolMethod(bool x) {
+    if (PrintDebug) writefln("DDerived - BoolMethod(%s)", x);
+    return x;
+  }
+
+  override int IntMethod(int x) {
+    if (PrintDebug) writefln("DDerived - IntMethod(%s)", x);
+    return x;
+  }
+
+  override uint UIntMethod(uint x) {
+    if (PrintDebug) writefln("DDerived - UIntMethod(%s)", x);
+    return x;
+  }
+
+  override float FloatMethod(float x) {
+    if (PrintDebug) writefln("DDerived - FloatMethod(%s)", x);
+    return x;
+  }
+
+  override string CharPtrMethod(string x) {
+    if (PrintDebug) writefln("DDerived - CharPtrMethod(%s)", x);
+    return x;
+  }
+
+  override string ConstCharPtrMethod(string x) {
+    if (PrintDebug) writefln("DDerived - ConstCharPtrMethod(%s)", x);
+    return x;
+  }
+
+  override HShadowMode EnumMethod(HShadowMode x) {
+    if (PrintDebug) writefln("DDerived - EnumMethod(%s)", x);
+    return x;
+  }
+
+  override void ManyParmsMethod(bool b, int i, uint u, float f, string c, string cc, HShadowMode h) {
+    if (PrintDebug) writefln("DDerived - ManyParmsMethod(%s, %s, %s, %s, %s, %s, %s)", b, i, u, f, c, cc, h);
+  }
+}

Examples/test-suite/d/director_protected_runme.1.d

@@ -0,0 +1,50 @@
+module director_protected_runme;
+
+import director_protected.Foo;
+import director_protected.Bar;
+
+void main() {
+  Bar b = new Bar();
+  Foo f = b.create();
+  auto fb = new FooBar();
+  auto fb2 = new FooBar2();
+
+  char[] s;
+  s = fb.used();
+  if ( s != ("Foo::pang();Bar::pong();Foo::pong();FooBar::ping();"))
+    throw new Exception("bad FooBar::used" ~ " - " ~ s);
+
+  s = fb2.used();
+  if ( s != ("FooBar2::pang();Bar::pong();Foo::pong();FooBar2::ping();"))
+    throw new Exception("bad FooBar2::used");
+
+  s = b.pong();
+  if ( s != ("Bar::pong();Foo::pong();Bar::ping();"))
+    throw new Exception("bad Bar::pong");
+
+  s = f.pong();
+  if ( s != ("Bar::pong();Foo::pong();Bar::ping();"))
+    throw new Exception("bad Foo::pong");
+
+  s = fb.pong();
+  if ( s != ("Bar::pong();Foo::pong();FooBar::ping();"))
+    throw new Exception("bad FooBar::pong");
+}
+
+class FooBar : Bar {
+protected:
+  override char[] ping() {
+    return "FooBar::ping();";
+  }
+}
+
+class FooBar2 : Bar{
+protected:
+  override char[] ping() {
+    return "FooBar2::ping();";
+  }
+
+  override char[] pang() {
+    return "FooBar2::pang();";
+  }
+}

Examples/test-suite/d/director_protected_runme.2.d

@@ -0,0 +1,36 @@
+module director_protected_runme;
+
+import std.exception;
+import director_protected.Foo;
+import director_protected.Bar;
+
+void main() {
+  Bar b = new Bar();
+  Foo f = b.create();
+  auto fb = new FooBar();
+  scope fb2 = new FooBar2();
+
+  enforce(fb.used() == "Foo::pang();Bar::pong();Foo::pong();FooBar::ping();", "bad FooBar::used" ~ " - " ~ fb.used());
+  enforce(fb2.used() == "FooBar2::pang();Bar::pong();Foo::pong();FooBar2::ping();", "bad FooBar2::used");
+  enforce(b.pong() == "Bar::pong();Foo::pong();Bar::ping();", "bad Bar::pong");
+  enforce(f.pong() == "Bar::pong();Foo::pong();Bar::ping();", "bad Foo::pong");
+  enforce(fb.pong() == "Bar::pong();Foo::pong();FooBar::ping();", "bad FooBar::pong");
+}
+
+class FooBar : Bar {
+protected:
+  override string ping() {
+    return "FooBar::ping();";
+  }
+}
+
+class FooBar2 : Bar {
+protected:
+  override string ping() {
+    return "FooBar2::ping();";
+  }
+
+  override string pang() {
+    return "FooBar2::pang();";
+  }
+}

Examples/test-suite/d/director_string_runme.1.d

@@ -0,0 +1,46 @@
+module director_string_runme;
+
+import Integer = tango.text.convert.Integer;
+import director_string.A;
+
+void main() {
+  char[] s;
+
+  auto c = new director_string_A("hi");
+  for (int i=0; i<3; ++i) {
+    s = c.call_get(i);
+    if (s != Integer.toString(i)) throw new Exception("director_string_A.get(" ~ Integer.toString(i) ~ ") failed. Got:" ~ s);
+  }
+
+  auto b = new director_string_B("hello");
+
+  s = b.call_get_first();
+  if (s != "director_string_B.get_first") throw new Exception("call_get_first() failed");
+
+  s = b.call_get(0);
+  if (s != "director_string_B.get: hello") throw new Exception("get(0) failed");
+}
+
+class director_string_B : A {
+public:
+  this(char[] first) {
+    super(first);
+  }
+  override char[] get_first() {
+    return "director_string_B.get_first";
+  }
+
+  override char[] get(int n) {
+    return "director_string_B.get: " ~ super.get(n);
+  }
+}
+
+class director_string_A : A {
+public:
+  this(char[] first) {
+    super(first);
+  }
+  override char[] get(int n) {
+    return Integer.toString(n);
+  }
+}

Examples/test-suite/d/director_string_runme.2.d

@@ -0,0 +1,42 @@
+module director_string_runme;
+
+import std.conv;
+import std.exception;
+import director_string.A;
+
+void main() {
+  auto c = new director_string_A("hi");
+  for (int i=0; i<3; ++i) {
+    auto s = c.call_get(i);
+    auto expected = to!string(i);
+    enforce(s == expected, "director_string_A.get(" ~ expected ~ ") failed. Got:" ~ s);
+  }
+
+  auto b = new director_string_B("hello");
+  enforce(b.call_get_first() == "director_string_B.get_first", "call_get_first() failed");
+  enforce(b.call_get(0) == "director_string_B.get: hello", "get(0) failed");
+}
+
+class director_string_B : A {
+public:
+  this(string first) {
+    super(first);
+  }
+  override string get_first() const {
+    return "director_string_B.get_first";
+  }
+
+  override string get(int n) const {
+    return "director_string_B.get: " ~ super.get(n);
+  }
+}
+
+class director_string_A : A {
+public:
+  this(string first) {
+    super(first);
+  }
+  override string get(int n) const {
+    return to!string(n);
+  }
+}

Examples/test-suite/d/enum_thorough_runme.1.d

@@ -0,0 +1,424 @@
+module enum_thorough_runme;
+
+import enum_thorough.enum_thorough;
+import enum_thorough.AnonStruct;
+import enum_thorough.colour;
+import enum_thorough.FirStruct;
+import enum_thorough.HairStruct;
+import enum_thorough.IgnoreTest;
+import enum_thorough.Instances;
+import enum_thorough.namedanon;
+import enum_thorough.namedanonspace;
+import enum_thorough.newname;
+import enum_thorough.NewNameStruct;
+import enum_thorough.repeat;
+import enum_thorough.SpeedClass;
+import enum_thorough.TClassInt;
+import enum_thorough.TemplateClassInt;
+import enum_thorough.TreesClass;
+import enum_thorough.twonames;
+import enum_thorough.TwoNamesStruct;
+
+void main() {
+  {
+    // Anonymous enums
+    int i = AnonEnum1;
+    if (ReallyAnInteger != 200) throw new Exception("Test Anon 1 failed");
+    i += AnonSpaceEnum1;
+    i += AnonStruct.AnonStructEnum1;
+  }
+  {
+    auto red = colour.red;
+    colourTest1(red);
+    colourTest2(red);
+    colourTest3(red);
+    colourTest4(red);
+    myColour = red;
+  }
+  {
+    auto s = new SpeedClass();
+    auto speed = SpeedClass.speed.slow;
+    if (s.speedTest1(speed) != speed) throw new Exception("speedTest 1 failed");
+    if (s.speedTest2(speed) != speed) throw new Exception("speedTest 2 failed");
+    if (s.speedTest3(speed) != speed) throw new Exception("speedTest 3 failed");
+    if (s.speedTest4(speed) != speed) throw new Exception("speedTest 4 failed");
+    if (s.speedTest5(speed) != speed) throw new Exception("speedTest 5 failed");
+    if (s.speedTest6(speed) != speed) throw new Exception("speedTest 6 failed");
+    if (s.speedTest7(speed) != speed) throw new Exception("speedTest 7 failed");
+    if (s.speedTest8(speed) != speed) throw new Exception("speedTest 8 failed");
+
+    if (speedTest1(speed) != speed) throw new Exception("speedTest Global 1 failed");
+    if (speedTest2(speed) != speed) throw new Exception("speedTest Global 2 failed");
+    if (speedTest3(speed) != speed) throw new Exception("speedTest Global 3 failed");
+    if (speedTest4(speed) != speed) throw new Exception("speedTest Global 4 failed");
+    if (speedTest5(speed) != speed) throw new Exception("speedTest Global 5 failed");
+  }
+  {
+    auto s = new SpeedClass();
+    auto slow = SpeedClass.speed.slow;
+    auto lightning = SpeedClass.speed.lightning;
+
+    if (s.mySpeedtd1 != slow) throw new Exception("mySpeedtd1 1 failed");
+    if (cast(int)s.mySpeedtd1 != 10) throw new Exception("mySpeedtd1 2 failed");
+
+    s.mySpeedtd1 = lightning;
+    if (s.mySpeedtd1 != lightning) throw new Exception("mySpeedtd1 3 failed");
+    if (cast(int)s.mySpeedtd1 != 31) throw new Exception("mySpeedtd1 4 failed");
+  }
+  {
+    if (namedanonTest1(namedanon.NamedAnon2) != namedanon.NamedAnon2) throw new Exception("namedanonTest 1 failed");
+  }
+  {
+    auto val = twonames.TwoNames2;
+    if (twonamesTest1(val) != val) throw new Exception("twonamesTest 1 failed");
+    if (twonamesTest2(val) != val) throw new Exception("twonamesTest 2 failed");
+    if (twonamesTest3(val) != val) throw new Exception("twonamesTest 3 failed");
+  }
+  {
+    auto t = new TwoNamesStruct();
+    auto val = TwoNamesStruct.twonames.TwoNamesStruct1;
+    if (t.twonamesTest1(val) != val) throw new Exception("twonamesTest 1 failed");
+    if (t.twonamesTest2(val) != val) throw new Exception("twonamesTest 2 failed");
+    if (t.twonamesTest3(val) != val) throw new Exception("twonamesTest 3 failed");
+  }
+  {
+    auto val = namedanonspace.NamedAnonSpace2;
+    if (namedanonspaceTest1(val) != val) throw new Exception("namedanonspaceTest 1 failed");
+    if (namedanonspaceTest2(val) != val) throw new Exception("namedanonspaceTest 2 failed");
+    if (namedanonspaceTest3(val) != val) throw new Exception("namedanonspaceTest 3 failed");
+    if (namedanonspaceTest4(val) != val) throw new Exception("namedanonspaceTest 4 failed");
+  }
+  {
+    auto t = new TemplateClassInt();
+    auto galileo = TemplateClassInt.scientists.galileo;
+    if (t.scientistsTest1(galileo) != galileo) throw new Exception("scientistsTest 1 failed");
+    if (t.scientistsTest2(galileo) != galileo) throw new Exception("scientistsTest 2 failed");
+    if (t.scientistsTest3(galileo) != galileo) throw new Exception("scientistsTest 3 failed");
+    if (t.scientistsTest4(galileo) != galileo) throw new Exception("scientistsTest 4 failed");
+    if (t.scientistsTest5(galileo) != galileo) throw new Exception("scientistsTest 5 failed");
+    if (t.scientistsTest6(galileo) != galileo) throw new Exception("scientistsTest 6 failed");
+    if (t.scientistsTest7(galileo) != galileo) throw new Exception("scientistsTest 7 failed");
+    if (t.scientistsTest8(galileo) != galileo) throw new Exception("scientistsTest 8 failed");
+    if (t.scientistsTest9(galileo) != galileo) throw new Exception("scientistsTest 9 failed");
+//      if (t.scientistsTestA(galileo) != galileo) throw new Exception("scientistsTest A failed");
+    if (t.scientistsTestB(galileo) != galileo) throw new Exception("scientistsTest B failed");
+//      if (t.scientistsTestC(galileo) != galileo) throw new Exception("scientistsTest C failed");
+    if (t.scientistsTestD(galileo) != galileo) throw new Exception("scientistsTest D failed");
+    if (t.scientistsTestE(galileo) != galileo) throw new Exception("scientistsTest E failed");
+    if (t.scientistsTestF(galileo) != galileo) throw new Exception("scientistsTest F failed");
+    if (t.scientistsTestG(galileo) != galileo) throw new Exception("scientistsTest G failed");
+    if (t.scientistsTestH(galileo) != galileo) throw new Exception("scientistsTest H failed");
+    if (t.scientistsTestI(galileo) != galileo) throw new Exception("scientistsTest I failed");
+    if (t.scientistsTestJ(galileo) != galileo) throw new Exception("scientistsTest J failed");
+
+    if (scientistsTest1(galileo) != galileo) throw new Exception("scientistsTest Global 1 failed");
+    if (scientistsTest2(galileo) != galileo) throw new Exception("scientistsTest Global 2 failed");
+    if (scientistsTest3(galileo) != galileo) throw new Exception("scientistsTest Global 3 failed");
+    if (scientistsTest4(galileo) != galileo) throw new Exception("scientistsTest Global 4 failed");
+    if (scientistsTest5(galileo) != galileo) throw new Exception("scientistsTest Global 5 failed");
+    if (scientistsTest6(galileo) != galileo) throw new Exception("scientistsTest Global 6 failed");
+    if (scientistsTest7(galileo) != galileo) throw new Exception("scientistsTest Global 7 failed");
+    if (scientistsTest8(galileo) != galileo) throw new Exception("scientistsTest Global 8 failed");
+  }
+  {
+    auto t = new TClassInt();
+    auto bell = TClassInt.scientists.bell;
+    auto galileo = TemplateClassInt.scientists.galileo;
+    if (t.scientistsNameTest1(bell) != bell) throw new Exception("scientistsNameTest 1 failed");
+    if (t.scientistsNameTest2(bell) != bell) throw new Exception("scientistsNameTest 2 failed");
+    if (t.scientistsNameTest3(bell) != bell) throw new Exception("scientistsNameTest 3 failed");
+    if (t.scientistsNameTest4(bell) != bell) throw new Exception("scientistsNameTest 4 failed");
+    if (t.scientistsNameTest5(bell) != bell) throw new Exception("scientistsNameTest 5 failed");
+    if (t.scientistsNameTest6(bell) != bell) throw new Exception("scientistsNameTest 6 failed");
+    if (t.scientistsNameTest7(bell) != bell) throw new Exception("scientistsNameTest 7 failed");
+    if (t.scientistsNameTest8(bell) != bell) throw new Exception("scientistsNameTest 8 failed");
+    if (t.scientistsNameTest9(bell) != bell) throw new Exception("scientistsNameTest 9 failed");
+//      if (t.scientistsNameTestA(bell) != bell) throw new Exception("scientistsNameTest A failed");
+    if (t.scientistsNameTestB(bell) != bell) throw new Exception("scientistsNameTest B failed");
+//      if (t.scientistsNameTestC(bell) != bell) throw new Exception("scientistsNameTest C failed");
+    if (t.scientistsNameTestD(bell) != bell) throw new Exception("scientistsNameTest D failed");
+    if (t.scientistsNameTestE(bell) != bell) throw new Exception("scientistsNameTest E failed");
+    if (t.scientistsNameTestF(bell) != bell) throw new Exception("scientistsNameTest F failed");
+    if (t.scientistsNameTestG(bell) != bell) throw new Exception("scientistsNameTest G failed");
+    if (t.scientistsNameTestH(bell) != bell) throw new Exception("scientistsNameTest H failed");
+    if (t.scientistsNameTestI(bell) != bell) throw new Exception("scientistsNameTest I failed");
+
+    if (t.scientistsNameSpaceTest1(bell) != bell) throw new Exception("scientistsNameSpaceTest 1 failed");
+    if (t.scientistsNameSpaceTest2(bell) != bell) throw new Exception("scientistsNameSpaceTest 2 failed");
+    if (t.scientistsNameSpaceTest3(bell) != bell) throw new Exception("scientistsNameSpaceTest 3 failed");
+    if (t.scientistsNameSpaceTest4(bell) != bell) throw new Exception("scientistsNameSpaceTest 4 failed");
+    if (t.scientistsNameSpaceTest5(bell) != bell) throw new Exception("scientistsNameSpaceTest 5 failed");
+    if (t.scientistsNameSpaceTest6(bell) != bell) throw new Exception("scientistsNameSpaceTest 6 failed");
+    if (t.scientistsNameSpaceTest7(bell) != bell) throw new Exception("scientistsNameSpaceTest 7 failed");
+
+    if (t.scientistsOtherTest1(galileo) != galileo) throw new Exception("scientistsOtherTest 1 failed");
+    if (t.scientistsOtherTest2(galileo) != galileo) throw new Exception("scientistsOtherTest 2 failed");
+    if (t.scientistsOtherTest3(galileo) != galileo) throw new Exception("scientistsOtherTest 3 failed");
+    if (t.scientistsOtherTest4(galileo) != galileo) throw new Exception("scientistsOtherTest 4 failed");
+    if (t.scientistsOtherTest5(galileo) != galileo) throw new Exception("scientistsOtherTest 5 failed");
+    if (t.scientistsOtherTest6(galileo) != galileo) throw new Exception("scientistsOtherTest 6 failed");
+    if (t.scientistsOtherTest7(galileo) != galileo) throw new Exception("scientistsOtherTest 7 failed");
+
+    if (scientistsNameTest1(bell) != bell) throw new Exception("scientistsNameTest Global 1 failed");
+    if (scientistsNameTest2(bell) != bell) throw new Exception("scientistsNameTest Global 2 failed");
+    if (scientistsNameTest3(bell) != bell) throw new Exception("scientistsNameTest Global 3 failed");
+    if (scientistsNameTest4(bell) != bell) throw new Exception("scientistsNameTest Global 4 failed");
+    if (scientistsNameTest5(bell) != bell) throw new Exception("scientistsNameTest Global 5 failed");
+    if (scientistsNameTest6(bell) != bell) throw new Exception("scientistsNameTest Global 6 failed");
+    if (scientistsNameTest7(bell) != bell) throw new Exception("scientistsNameTest Global 7 failed");
+
+    if (scientistsNameSpaceTest1(bell) != bell) throw new Exception("scientistsNameSpaceTest Global 1 failed");
+    if (scientistsNameSpaceTest2(bell) != bell) throw new Exception("scientistsNameSpaceTest Global 2 failed");
+    if (scientistsNameSpaceTest3(bell) != bell) throw new Exception("scientistsNameSpaceTest Global 3 failed");
+    if (scientistsNameSpaceTest4(bell) != bell) throw new Exception("scientistsNameSpaceTest Global 4 failed");
+    if (scientistsNameSpaceTest5(bell) != bell) throw new Exception("scientistsNameSpaceTest Global 5 failed");
+    if (scientistsNameSpaceTest6(bell) != bell) throw new Exception("scientistsNameSpaceTest Global 6 failed");
+    if (scientistsNameSpaceTest7(bell) != bell) throw new Exception("scientistsNameSpaceTest Global 7 failed");
+
+    if (scientistsNameSpaceTest8(bell) != bell) throw new Exception("scientistsNameSpaceTest Global 8 failed");
+    if (scientistsNameSpaceTest9(bell) != bell) throw new Exception("scientistsNameSpaceTest Global 9 failed");
+    if (scientistsNameSpaceTestA(bell) != bell) throw new Exception("scientistsNameSpaceTest Global A failed");
+    if (scientistsNameSpaceTestB(bell) != bell) throw new Exception("scientistsNameSpaceTest Global B failed");
+    if (scientistsNameSpaceTestC(bell) != bell) throw new Exception("scientistsNameSpaceTest Global C failed");
+    if (scientistsNameSpaceTestD(bell) != bell) throw new Exception("scientistsNameSpaceTest Global D failed");
+    if (scientistsNameSpaceTestE(bell) != bell) throw new Exception("scientistsNameSpaceTest Global E failed");
+
+    if (scientistsNameSpaceTestF(bell) != bell) throw new Exception("scientistsNameSpaceTest Global F failed");
+    if (scientistsNameSpaceTestG(bell) != bell) throw new Exception("scientistsNameSpaceTest Global G failed");
+    if (scientistsNameSpaceTestH(bell) != bell) throw new Exception("scientistsNameSpaceTest Global H failed");
+    if (scientistsNameSpaceTestI(bell) != bell) throw new Exception("scientistsNameSpaceTest Global I failed");
+    if (scientistsNameSpaceTestJ(bell) != bell) throw new Exception("scientistsNameSpaceTest Global J failed");
+    if (scientistsNameSpaceTestK(bell) != bell) throw new Exception("scientistsNameSpaceTest Global K failed");
+    if (scientistsNameSpaceTestL(bell) != bell) throw new Exception("scientistsNameSpaceTest Global L failed");
+  }
+  {
+    auto val = newname.argh;
+    if (renameTest1(val) != val) throw new Exception("renameTest Global 1 failed");
+    if (renameTest2(val) != val) throw new Exception("renameTest Global 2 failed");
+  }
+  {
+    auto n = new NewNameStruct();
+    if (n.renameTest1(NewNameStruct.enumeration.bang) != NewNameStruct.enumeration.bang) throw new Exception("renameTest 1 failed");
+    if (n.renameTest2(NewNameStruct.enumeration.bang) != NewNameStruct.enumeration.bang) throw new Exception("renameTest 2 failed");
+    if (n.renameTest3(NewNameStruct.simplerenamed.simple1) != NewNameStruct.simplerenamed.simple1) throw new Exception("renameTest 3 failed");
+    if (n.renameTest4(NewNameStruct.doublenamerenamed.doublename1) != NewNameStruct.doublenamerenamed.doublename1) throw new Exception("renameTest 4 failed");
+    if (n.renameTest5(NewNameStruct.doublenamerenamed.doublename1) != NewNameStruct.doublenamerenamed.doublename1) throw new Exception("renameTest 5 failed");
+    if (n.renameTest6(NewNameStruct.singlenamerenamed.singlename1) != NewNameStruct.singlenamerenamed.singlename1) throw new Exception("renameTest 6 failed");
+  }
+  {
+    if (renameTest3(NewNameStruct.enumeration.bang) != NewNameStruct.enumeration.bang) throw new Exception("renameTest Global 3 failed");
+    if (renameTest4(NewNameStruct.simplerenamed.simple1) != NewNameStruct.simplerenamed.simple1) throw new Exception("renameTest Global 4 failed");
+    if (renameTest5(NewNameStruct.doublenamerenamed.doublename1) != NewNameStruct.doublenamerenamed.doublename1) throw new Exception("renameTest Global 5 failed");
+    if (renameTest6(NewNameStruct.doublenamerenamed.doublename1) != NewNameStruct.doublenamerenamed.doublename1) throw new Exception("renameTest Global 6 failed");
+    if (renameTest7(NewNameStruct.singlenamerenamed.singlename1) != NewNameStruct.singlenamerenamed.singlename1) throw new Exception("renameTest Global 7 failed");
+  }
+  {
+    auto t = new TreesClass();
+    auto pine = TreesClass.trees.pine;
+
+    if (t.treesTest1(pine) != pine) throw new Exception("treesTest 1 failed");
+    if (t.treesTest2(pine) != pine) throw new Exception("treesTest 2 failed");
+    if (t.treesTest3(pine) != pine) throw new Exception("treesTest 3 failed");
+    if (t.treesTest4(pine) != pine) throw new Exception("treesTest 4 failed");
+    if (t.treesTest5(pine) != pine) throw new Exception("treesTest 5 failed");
+    if (t.treesTest6(pine) != pine) throw new Exception("treesTest 6 failed");
+    if (t.treesTest7(pine) != pine) throw new Exception("treesTest 7 failed");
+    if (t.treesTest8(pine) != pine) throw new Exception("treesTest 8 failed");
+    if (t.treesTest9(pine) != pine) throw new Exception("treesTest 9 failed");
+    if (t.treesTestA(pine) != pine) throw new Exception("treesTest A failed");
+    if (t.treesTestB(pine) != pine) throw new Exception("treesTest B failed");
+    if (t.treesTestC(pine) != pine) throw new Exception("treesTest C failed");
+    if (t.treesTestD(pine) != pine) throw new Exception("treesTest D failed");
+    if (t.treesTestE(pine) != pine) throw new Exception("treesTest E failed");
+    if (t.treesTestF(pine) != pine) throw new Exception("treesTest F failed");
+    if (t.treesTestG(pine) != pine) throw new Exception("treesTest G failed");
+    if (t.treesTestH(pine) != pine) throw new Exception("treesTest H failed");
+    if (t.treesTestI(pine) != pine) throw new Exception("treesTest I failed");
+    if (t.treesTestJ(pine) != pine) throw new Exception("treesTest J failed");
+    if (t.treesTestK(pine) != pine) throw new Exception("treesTest K failed");
+    if (t.treesTestL(pine) != pine) throw new Exception("treesTest L failed");
+    if (t.treesTestM(pine) != pine) throw new Exception("treesTest M failed");
+    if (t.treesTestN(pine) != pine) throw new Exception("treesTest N failed");
+    if (t.treesTestO(pine) != pine) throw new Exception("treesTest O failed");
+
+    if (treesTest1(pine) != pine) throw new Exception("treesTest Global 1 failed");
+    if (treesTest2(pine) != pine) throw new Exception("treesTest Global 2 failed");
+    if (treesTest3(pine) != pine) throw new Exception("treesTest Global 3 failed");
+    if (treesTest4(pine) != pine) throw new Exception("treesTest Global 4 failed");
+    if (treesTest5(pine) != pine) throw new Exception("treesTest Global 5 failed");
+    if (treesTest6(pine) != pine) throw new Exception("treesTest Global 6 failed");
+    if (treesTest7(pine) != pine) throw new Exception("treesTest Global 7 failed");
+    if (treesTest8(pine) != pine) throw new Exception("treesTest Global 8 failed");
+    if (treesTest9(pine) != pine) throw new Exception("treesTest Global 9 failed");
+    if (treesTestA(pine) != pine) throw new Exception("treesTest Global A failed");
+    if (treesTestB(pine) != pine) throw new Exception("treesTest Global B failed");
+    if (treesTestC(pine) != pine) throw new Exception("treesTest Global C failed");
+    if (treesTestD(pine) != pine) throw new Exception("treesTest Global D failed");
+    if (treesTestE(pine) != pine) throw new Exception("treesTest Global E failed");
+    if (treesTestF(pine) != pine) throw new Exception("treesTest Global F failed");
+    if (treesTestG(pine) != pine) throw new Exception("treesTest Global G failed");
+    if (treesTestH(pine) != pine) throw new Exception("treesTest Global H failed");
+    if (treesTestI(pine) != pine) throw new Exception("treesTest Global I failed");
+    if (treesTestJ(pine) != pine) throw new Exception("treesTest Global J failed");
+    if (treesTestK(pine) != pine) throw new Exception("treesTest Global K failed");
+    if (treesTestL(pine) != pine) throw new Exception("treesTest Global L failed");
+    if (treesTestM(pine) != pine) throw new Exception("treesTest Global M failed");
+//      if (treesTestN(pine) != pine) throw new Exception("treesTest Global N failed");
+    if (treesTestO(pine) != pine) throw new Exception("treesTest Global O failed");
+    if (treesTestP(pine) != pine) throw new Exception("treesTest Global P failed");
+    if (treesTestQ(pine) != pine) throw new Exception("treesTest Global Q failed");
+    if (treesTestR(pine) != pine) throw new Exception("treesTest Global R failed");
+  }
+  {
+    auto h = new HairStruct();
+    auto ginger = HairStruct.hair.ginger;
+
+    if (h.hairTest1(ginger) != ginger) throw new Exception("hairTest 1 failed");
+    if (h.hairTest2(ginger) != ginger) throw new Exception("hairTest 2 failed");
+    if (h.hairTest3(ginger) != ginger) throw new Exception("hairTest 3 failed");
+    if (h.hairTest4(ginger) != ginger) throw new Exception("hairTest 4 failed");
+    if (h.hairTest5(ginger) != ginger) throw new Exception("hairTest 5 failed");
+    if (h.hairTest6(ginger) != ginger) throw new Exception("hairTest 6 failed");
+    if (h.hairTest7(ginger) != ginger) throw new Exception("hairTest 7 failed");
+    if (h.hairTest8(ginger) != ginger) throw new Exception("hairTest 8 failed");
+    if (h.hairTest9(ginger) != ginger) throw new Exception("hairTest 9 failed");
+    if (h.hairTestA(ginger) != ginger) throw new Exception("hairTest A failed");
+    if (h.hairTestB(ginger) != ginger) throw new Exception("hairTest B failed");
+
+    auto red = colour.red;
+    if (h.colourTest1(red) != red) throw new Exception("colourTest HairStruct 1 failed");
+    if (h.colourTest2(red) != red) throw new Exception("colourTest HairStruct 2 failed");
+    if (h.namedanonTest1(namedanon.NamedAnon2) != namedanon.NamedAnon2) throw new Exception("namedanonTest HairStruct 1 failed");
+    if (h.namedanonspaceTest1(namedanonspace.NamedAnonSpace2) != namedanonspace.NamedAnonSpace2) throw new Exception("namedanonspaceTest HairStruct 1 failed");
+
+    auto fir = TreesClass.trees.fir;
+    if (h.treesGlobalTest1(fir) != fir) throw new Exception("treesGlobalTest1 HairStruct 1 failed");
+    if (h.treesGlobalTest2(fir) != fir) throw new Exception("treesGlobalTest1 HairStruct 2 failed");
+    if (h.treesGlobalTest3(fir) != fir) throw new Exception("treesGlobalTest1 HairStruct 3 failed");
+    if (h.treesGlobalTest4(fir) != fir) throw new Exception("treesGlobalTest1 HairStruct 4 failed");
+  }
+  {
+    auto blonde = HairStruct.hair.blonde;
+    if (hairTest1(blonde) != blonde) throw new Exception("hairTest Global 1 failed");
+    if (hairTest2(blonde) != blonde) throw new Exception("hairTest Global 2 failed");
+    if (hairTest3(blonde) != blonde) throw new Exception("hairTest Global 3 failed");
+    if (hairTest4(blonde) != blonde) throw new Exception("hairTest Global 4 failed");
+    if (hairTest5(blonde) != blonde) throw new Exception("hairTest Global 5 failed");
+    if (hairTest6(blonde) != blonde) throw new Exception("hairTest Global 6 failed");
+    if (hairTest7(blonde) != blonde) throw new Exception("hairTest Global 7 failed");
+    if (hairTest8(blonde) != blonde) throw new Exception("hairTest Global 8 failed");
+    if (hairTest9(blonde) != blonde) throw new Exception("hairTest Global 9 failed");
+    if (hairTestA(blonde) != blonde) throw new Exception("hairTest Global A failed");
+    if (hairTestB(blonde) != blonde) throw new Exception("hairTest Global B failed");
+    if (hairTestC(blonde) != blonde) throw new Exception("hairTest Global C failed");
+
+    if (hairTestA1(blonde) != blonde) throw new Exception("hairTest Global A1 failed");
+    if (hairTestA2(blonde) != blonde) throw new Exception("hairTest Global A2 failed");
+    if (hairTestA3(blonde) != blonde) throw new Exception("hairTest Global A3 failed");
+    if (hairTestA4(blonde) != blonde) throw new Exception("hairTest Global A4 failed");
+    if (hairTestA5(blonde) != blonde) throw new Exception("hairTest Global A5 failed");
+    if (hairTestA6(blonde) != blonde) throw new Exception("hairTest Global A6 failed");
+    if (hairTestA7(blonde) != blonde) throw new Exception("hairTest Global A7 failed");
+    if (hairTestA8(blonde) != blonde) throw new Exception("hairTest Global A8 failed");
+    if (hairTestA9(blonde) != blonde) throw new Exception("hairTest Global A9 failed");
+    if (hairTestAA(blonde) != blonde) throw new Exception("hairTest Global AA failed");
+    if (hairTestAB(blonde) != blonde) throw new Exception("hairTest Global AB failed");
+    if (hairTestAC(blonde) != blonde) throw new Exception("hairTest Global AC failed");
+
+    if (hairTestB1(blonde) != blonde) throw new Exception("hairTest Global B1 failed");
+    if (hairTestB2(blonde) != blonde) throw new Exception("hairTest Global B2 failed");
+    if (hairTestB3(blonde) != blonde) throw new Exception("hairTest Global B3 failed");
+    if (hairTestB4(blonde) != blonde) throw new Exception("hairTest Global B4 failed");
+    if (hairTestB5(blonde) != blonde) throw new Exception("hairTest Global B5 failed");
+    if (hairTestB6(blonde) != blonde) throw new Exception("hairTest Global B6 failed");
+    if (hairTestB7(blonde) != blonde) throw new Exception("hairTest Global B7 failed");
+    if (hairTestB8(blonde) != blonde) throw new Exception("hairTest Global B8 failed");
+    if (hairTestB9(blonde) != blonde) throw new Exception("hairTest Global B9 failed");
+    if (hairTestBA(blonde) != blonde) throw new Exception("hairTest Global BA failed");
+    if (hairTestBB(blonde) != blonde) throw new Exception("hairTest Global BB failed");
+    if (hairTestBC(blonde) != blonde) throw new Exception("hairTest Global BC failed");
+
+    if (hairTestC1(blonde) != blonde) throw new Exception("hairTest Global C1 failed");
+    if (hairTestC2(blonde) != blonde) throw new Exception("hairTest Global C2 failed");
+    if (hairTestC3(blonde) != blonde) throw new Exception("hairTest Global C3 failed");
+    if (hairTestC4(blonde) != blonde) throw new Exception("hairTest Global C4 failed");
+    if (hairTestC5(blonde) != blonde) throw new Exception("hairTest Global C5 failed");
+    if (hairTestC6(blonde) != blonde) throw new Exception("hairTest Global C6 failed");
+    if (hairTestC7(blonde) != blonde) throw new Exception("hairTest Global C7 failed");
+    if (hairTestC8(blonde) != blonde) throw new Exception("hairTest Global C8 failed");
+    if (hairTestC9(blonde) != blonde) throw new Exception("hairTest Global C9 failed");
+    if (hairTestCA(blonde) != blonde) throw new Exception("hairTest Global CA failed");
+    if (hairTestCB(blonde) != blonde) throw new Exception("hairTest Global CB failed");
+    if (hairTestCC(blonde) != blonde) throw new Exception("hairTest Global CC failed");
+  }
+  {
+    auto f = new FirStruct();
+    auto blonde = HairStruct.hair.blonde;
+
+    if (f.hairTestFir1(blonde) != blonde) throw new Exception("hairTestFir 1 failed");
+    if (f.hairTestFir2(blonde) != blonde) throw new Exception("hairTestFir 2 failed");
+    if (f.hairTestFir3(blonde) != blonde) throw new Exception("hairTestFir 3 failed");
+    if (f.hairTestFir4(blonde) != blonde) throw new Exception("hairTestFir 4 failed");
+    if (f.hairTestFir5(blonde) != blonde) throw new Exception("hairTestFir 5 failed");
+    if (f.hairTestFir6(blonde) != blonde) throw new Exception("hairTestFir 6 failed");
+    if (f.hairTestFir7(blonde) != blonde) throw new Exception("hairTestFir 7 failed");
+    if (f.hairTestFir8(blonde) != blonde) throw new Exception("hairTestFir 8 failed");
+    if (f.hairTestFir9(blonde) != blonde) throw new Exception("hairTestFir 9 failed");
+    if (f.hairTestFirA(blonde) != blonde) throw new Exception("hairTestFir A failed");
+  }
+  {
+    GlobalInstance = globalinstance2;
+    if (GlobalInstance != globalinstance2) throw new Exception("GlobalInstance 1 failed");
+
+    auto i = new Instances();
+    i.MemberInstance = Instances.memberinstance3;
+    if (i.MemberInstance != Instances.memberinstance3) throw new Exception("MemberInstance 1 failed");
+  }
+  // ignore enum item tests start
+  {
+    if (cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_zero) != 0) throw new Exception("ignoreATest 0 failed");
+    if (cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_three) != 3) throw new Exception("ignoreATest 3 failed");
+    if (cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_ten) != 10) throw new Exception("ignoreATest 10 failed");
+    if (cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_eleven) != 11) throw new Exception("ignoreATest 11 failed");
+    if (cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_thirteen) != 13) throw new Exception("ignoreATest 13 failed");
+    if (cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_fourteen) != 14) throw new Exception("ignoreATest 14 failed");
+    if (cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_twenty) != 20) throw new Exception("ignoreATest 20 failed");
+    if (cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_thirty) != 30) throw new Exception("ignoreATest 30 failed");
+    if (cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_thirty_two) != 32) throw new Exception("ignoreATest 32 failed");
+    if (cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_thirty_three) != 33) throw new Exception("ignoreATest 33 failed");
+  }
+  {
+    if (cast(int)ignoreBTest(IgnoreTest.IgnoreB.ignoreB_eleven) != 11) throw new Exception("ignoreBTest 11 failed");
+    if (cast(int)ignoreBTest(IgnoreTest.IgnoreB.ignoreB_twelve) != 12) throw new Exception("ignoreBTest 12 failed");
+    if (cast(int)ignoreBTest(IgnoreTest.IgnoreB.ignoreB_thirty_one) != 31) throw new Exception("ignoreBTest 31 failed");
+    if (cast(int)ignoreBTest(IgnoreTest.IgnoreB.ignoreB_thirty_two) != 32) throw new Exception("ignoreBTest 32 failed");
+    if (cast(int)ignoreBTest(IgnoreTest.IgnoreB.ignoreB_forty_one) != 41) throw new Exception("ignoreBTest 41 failed");
+    if (cast(int)ignoreBTest(IgnoreTest.IgnoreB.ignoreB_forty_two) != 42) throw new Exception("ignoreBTest 42 failed");
+  }
+  {
+    if (cast(int)ignoreCTest(IgnoreTest.IgnoreC.ignoreC_ten) != 10) throw new Exception("ignoreCTest 10 failed");
+    if (cast(int)ignoreCTest(IgnoreTest.IgnoreC.ignoreC_twelve) != 12) throw new Exception("ignoreCTest 12 failed");
+    if (cast(int)ignoreCTest(IgnoreTest.IgnoreC.ignoreC_thirty) != 30) throw new Exception("ignoreCTest 30 failed");
+    if (cast(int)ignoreCTest(IgnoreTest.IgnoreC.ignoreC_thirty_two) != 32) throw new Exception("ignoreCTest 32 failed");
+    if (cast(int)ignoreCTest(IgnoreTest.IgnoreC.ignoreC_forty) != 40) throw new Exception("ignoreCTest 40 failed");
+    if (cast(int)ignoreCTest(IgnoreTest.IgnoreC.ignoreC_forty_two) != 42) throw new Exception("ignoreCTest 42 failed");
+  }
+  {
+    if (cast(int)ignoreDTest(IgnoreTest.IgnoreD.ignoreD_twenty_one) != 21) throw new Exception("ignoreDTest 21 failed");
+    if (cast(int)ignoreDTest(IgnoreTest.IgnoreD.ignoreD_twenty_two) != 22) throw new Exception("ignoreDTest 22 failed");
+  }
+  {
+    if (cast(int)ignoreETest(IgnoreTest.IgnoreE.ignoreE_zero) != 0) throw new Exception("ignoreETest 0 failed");
+    if (cast(int)ignoreETest(IgnoreTest.IgnoreE.ignoreE_twenty_one) != 21) throw new Exception("ignoreETest 21 failed");
+    if (cast(int)ignoreETest(IgnoreTest.IgnoreE.ignoreE_twenty_two) != 22) throw new Exception("ignoreETest 22 failed");
+  }
+  // ignore enum item tests end
+  {
+    if (cast(int)repeatTest(repeat.one) != 1) throw new Exception("repeatTest 1 failed");
+    if (cast(int)repeatTest(repeat.initial) != 1) throw new Exception("repeatTest 2 failed");
+    if (cast(int)repeatTest(repeat.two) != 2) throw new Exception("repeatTest 3 failed");
+    if (cast(int)repeatTest(repeat.three) != 3) throw new Exception("repeatTest 4 failed");
+    if (cast(int)repeatTest(repeat.llast) != 3) throw new Exception("repeatTest 5 failed");
+    if (cast(int)repeatTest(repeat.end) != 3) throw new Exception("repeatTest 6 failed");
+  }
+}

Examples/test-suite/d/enum_thorough_runme.2.d

@@ -0,0 +1,425 @@
+module enum_thorough_runme;
+
+import std.exception;
+import enum_thorough.enum_thorough;
+import enum_thorough.AnonStruct;
+import enum_thorough.colour;
+import enum_thorough.FirStruct;
+import enum_thorough.HairStruct;
+import enum_thorough.IgnoreTest;
+import enum_thorough.Instances;
+import enum_thorough.namedanon;
+import enum_thorough.namedanonspace;
+import enum_thorough.newname;
+import enum_thorough.NewNameStruct;
+import enum_thorough.repeat;
+import enum_thorough.SpeedClass;
+import enum_thorough.TClassInt;
+import enum_thorough.TemplateClassInt;
+import enum_thorough.TreesClass;
+import enum_thorough.twonames;
+import enum_thorough.TwoNamesStruct;
+
+void main() {
+  {
+    // Anonymous enums
+    int i = AnonEnum1;
+    enforce(ReallyAnInteger == 200, "Test Anon 1 failed");
+    i += AnonSpaceEnum1;
+    i += AnonStruct.AnonStructEnum1;
+  }
+  {
+    auto red = colour.red;
+    colourTest1(red);
+    colourTest2(red);
+    colourTest3(red);
+    colourTest4(red);
+    myColour = red;
+  }
+  {
+    auto s = new SpeedClass();
+    auto speed = SpeedClass.speed.slow;
+    enforce(s.speedTest1(speed) == speed, "speedTest 1 failed");
+    enforce(s.speedTest2(speed) == speed, "speedTest 2 failed");
+    enforce(s.speedTest3(speed) == speed, "speedTest 3 failed");
+    enforce(s.speedTest4(speed) == speed, "speedTest 4 failed");
+    enforce(s.speedTest5(speed) == speed, "speedTest 5 failed");
+    enforce(s.speedTest6(speed) == speed, "speedTest 6 failed");
+    enforce(s.speedTest7(speed) == speed, "speedTest 7 failed");
+    enforce(s.speedTest8(speed) == speed, "speedTest 8 failed");
+
+    enforce(speedTest1(speed) == speed, "speedTest Global 1 failed");
+    enforce(speedTest2(speed) == speed, "speedTest Global 2 failed");
+    enforce(speedTest3(speed) == speed, "speedTest Global 3 failed");
+    enforce(speedTest4(speed) == speed, "speedTest Global 4 failed");
+    enforce(speedTest5(speed) == speed, "speedTest Global 5 failed");
+  }
+  {
+    auto s = new SpeedClass();
+    auto slow = SpeedClass.speed.slow;
+    auto lightning = SpeedClass.speed.lightning;
+
+    enforce(s.mySpeedtd1 == slow, "mySpeedtd1 1 failed");
+    enforce(cast(int)s.mySpeedtd1 == 10, "mySpeedtd1 2 failed");
+
+    s.mySpeedtd1 = lightning;
+    enforce(s.mySpeedtd1 == lightning, "mySpeedtd1 3 failed");
+    enforce(cast(int)s.mySpeedtd1 == 31, "mySpeedtd1 4 failed");
+  }
+  {
+    enforce(namedanonTest1(namedanon.NamedAnon2) == namedanon.NamedAnon2, "namedanonTest 1 failed");
+  }
+  {
+    auto val = twonames.TwoNames2;
+    enforce(twonamesTest1(val) == val, "twonamesTest 1 failed");
+    enforce(twonamesTest2(val) == val, "twonamesTest 2 failed");
+    enforce(twonamesTest3(val) == val, "twonamesTest 3 failed");
+  }
+  {
+    auto t = new TwoNamesStruct();
+    auto val = TwoNamesStruct.twonames.TwoNamesStruct1;
+    enforce(t.twonamesTest1(val) == val, "twonamesTest 1 failed");
+    enforce(t.twonamesTest2(val) == val, "twonamesTest 2 failed");
+    enforce(t.twonamesTest3(val) == val, "twonamesTest 3 failed");
+  }
+  {
+    auto val = namedanonspace.NamedAnonSpace2;
+    enforce(namedanonspaceTest1(val) == val, "namedanonspaceTest 1 failed");
+    enforce(namedanonspaceTest2(val) == val, "namedanonspaceTest 2 failed");
+    enforce(namedanonspaceTest3(val) == val, "namedanonspaceTest 3 failed");
+    enforce(namedanonspaceTest4(val) == val, "namedanonspaceTest 4 failed");
+  }
+  {
+    auto t = new TemplateClassInt();
+    auto galileo = TemplateClassInt.scientists.galileo;
+    enforce(t.scientistsTest1(galileo) == galileo, "scientistsTest 1 failed");
+    enforce(t.scientistsTest2(galileo) == galileo, "scientistsTest 2 failed");
+    enforce(t.scientistsTest3(galileo) == galileo, "scientistsTest 3 failed");
+    enforce(t.scientistsTest4(galileo) == galileo, "scientistsTest 4 failed");
+    enforce(t.scientistsTest5(galileo) == galileo, "scientistsTest 5 failed");
+    enforce(t.scientistsTest6(galileo) == galileo, "scientistsTest 6 failed");
+    enforce(t.scientistsTest7(galileo) == galileo, "scientistsTest 7 failed");
+    enforce(t.scientistsTest8(galileo) == galileo, "scientistsTest 8 failed");
+    enforce(t.scientistsTest9(galileo) == galileo, "scientistsTest 9 failed");
+//      enforce(t.scientistsTestA(galileo) == galileo, "scientistsTest A failed");
+    enforce(t.scientistsTestB(galileo) == galileo, "scientistsTest B failed");
+//      enforce(t.scientistsTestC(galileo) == galileo, "scientistsTest C failed");
+    enforce(t.scientistsTestD(galileo) == galileo, "scientistsTest D failed");
+    enforce(t.scientistsTestE(galileo) == galileo, "scientistsTest E failed");
+    enforce(t.scientistsTestF(galileo) == galileo, "scientistsTest F failed");
+    enforce(t.scientistsTestG(galileo) == galileo, "scientistsTest G failed");
+    enforce(t.scientistsTestH(galileo) == galileo, "scientistsTest H failed");
+    enforce(t.scientistsTestI(galileo) == galileo, "scientistsTest I failed");
+    enforce(t.scientistsTestJ(galileo) == galileo, "scientistsTest J failed");
+
+    enforce(scientistsTest1(galileo) == galileo, "scientistsTest Global 1 failed");
+    enforce(scientistsTest2(galileo) == galileo, "scientistsTest Global 2 failed");
+    enforce(scientistsTest3(galileo) == galileo, "scientistsTest Global 3 failed");
+    enforce(scientistsTest4(galileo) == galileo, "scientistsTest Global 4 failed");
+    enforce(scientistsTest5(galileo) == galileo, "scientistsTest Global 5 failed");
+    enforce(scientistsTest6(galileo) == galileo, "scientistsTest Global 6 failed");
+    enforce(scientistsTest7(galileo) == galileo, "scientistsTest Global 7 failed");
+    enforce(scientistsTest8(galileo) == galileo, "scientistsTest Global 8 failed");
+  }
+  {
+    auto t = new TClassInt();
+    auto bell = TClassInt.scientists.bell;
+    auto galileo = TemplateClassInt.scientists.galileo;
+    enforce(t.scientistsNameTest1(bell) == bell, "scientistsNameTest 1 failed");
+    enforce(t.scientistsNameTest2(bell) == bell, "scientistsNameTest 2 failed");
+    enforce(t.scientistsNameTest3(bell) == bell, "scientistsNameTest 3 failed");
+    enforce(t.scientistsNameTest4(bell) == bell, "scientistsNameTest 4 failed");
+    enforce(t.scientistsNameTest5(bell) == bell, "scientistsNameTest 5 failed");
+    enforce(t.scientistsNameTest6(bell) == bell, "scientistsNameTest 6 failed");
+    enforce(t.scientistsNameTest7(bell) == bell, "scientistsNameTest 7 failed");
+    enforce(t.scientistsNameTest8(bell) == bell, "scientistsNameTest 8 failed");
+    enforce(t.scientistsNameTest9(bell) == bell, "scientistsNameTest 9 failed");
+//      enforce(t.scientistsNameTestA(bell) == bell, "scientistsNameTest A failed");
+    enforce(t.scientistsNameTestB(bell) == bell, "scientistsNameTest B failed");
+//      enforce(t.scientistsNameTestC(bell) == bell, "scientistsNameTest C failed");
+    enforce(t.scientistsNameTestD(bell) == bell, "scientistsNameTest D failed");
+    enforce(t.scientistsNameTestE(bell) == bell, "scientistsNameTest E failed");
+    enforce(t.scientistsNameTestF(bell) == bell, "scientistsNameTest F failed");
+    enforce(t.scientistsNameTestG(bell) == bell, "scientistsNameTest G failed");
+    enforce(t.scientistsNameTestH(bell) == bell, "scientistsNameTest H failed");
+    enforce(t.scientistsNameTestI(bell) == bell, "scientistsNameTest I failed");
+
+    enforce(t.scientistsNameSpaceTest1(bell) == bell, "scientistsNameSpaceTest 1 failed");
+    enforce(t.scientistsNameSpaceTest2(bell) == bell, "scientistsNameSpaceTest 2 failed");
+    enforce(t.scientistsNameSpaceTest3(bell) == bell, "scientistsNameSpaceTest 3 failed");
+    enforce(t.scientistsNameSpaceTest4(bell) == bell, "scientistsNameSpaceTest 4 failed");
+    enforce(t.scientistsNameSpaceTest5(bell) == bell, "scientistsNameSpaceTest 5 failed");
+    enforce(t.scientistsNameSpaceTest6(bell) == bell, "scientistsNameSpaceTest 6 failed");
+    enforce(t.scientistsNameSpaceTest7(bell) == bell, "scientistsNameSpaceTest 7 failed");
+
+    enforce(t.scientistsOtherTest1(galileo) == galileo, "scientistsOtherTest 1 failed");
+    enforce(t.scientistsOtherTest2(galileo) == galileo, "scientistsOtherTest 2 failed");
+    enforce(t.scientistsOtherTest3(galileo) == galileo, "scientistsOtherTest 3 failed");
+    enforce(t.scientistsOtherTest4(galileo) == galileo, "scientistsOtherTest 4 failed");
+    enforce(t.scientistsOtherTest5(galileo) == galileo, "scientistsOtherTest 5 failed");
+    enforce(t.scientistsOtherTest6(galileo) == galileo, "scientistsOtherTest 6 failed");
+    enforce(t.scientistsOtherTest7(galileo) == galileo, "scientistsOtherTest 7 failed");
+
+    enforce(scientistsNameTest1(bell) == bell, "scientistsNameTest Global 1 failed");
+    enforce(scientistsNameTest2(bell) == bell, "scientistsNameTest Global 2 failed");
+    enforce(scientistsNameTest3(bell) == bell, "scientistsNameTest Global 3 failed");
+    enforce(scientistsNameTest4(bell) == bell, "scientistsNameTest Global 4 failed");
+    enforce(scientistsNameTest5(bell) == bell, "scientistsNameTest Global 5 failed");
+    enforce(scientistsNameTest6(bell) == bell, "scientistsNameTest Global 6 failed");
+    enforce(scientistsNameTest7(bell) == bell, "scientistsNameTest Global 7 failed");
+
+    enforce(scientistsNameSpaceTest1(bell) == bell, "scientistsNameSpaceTest Global 1 failed");
+    enforce(scientistsNameSpaceTest2(bell) == bell, "scientistsNameSpaceTest Global 2 failed");
+    enforce(scientistsNameSpaceTest3(bell) == bell, "scientistsNameSpaceTest Global 3 failed");
+    enforce(scientistsNameSpaceTest4(bell) == bell, "scientistsNameSpaceTest Global 4 failed");
+    enforce(scientistsNameSpaceTest5(bell) == bell, "scientistsNameSpaceTest Global 5 failed");
+    enforce(scientistsNameSpaceTest6(bell) == bell, "scientistsNameSpaceTest Global 6 failed");
+    enforce(scientistsNameSpaceTest7(bell) == bell, "scientistsNameSpaceTest Global 7 failed");
+
+    enforce(scientistsNameSpaceTest8(bell) == bell, "scientistsNameSpaceTest Global 8 failed");
+    enforce(scientistsNameSpaceTest9(bell) == bell, "scientistsNameSpaceTest Global 9 failed");
+    enforce(scientistsNameSpaceTestA(bell) == bell, "scientistsNameSpaceTest Global A failed");
+    enforce(scientistsNameSpaceTestB(bell) == bell, "scientistsNameSpaceTest Global B failed");
+    enforce(scientistsNameSpaceTestC(bell) == bell, "scientistsNameSpaceTest Global C failed");
+    enforce(scientistsNameSpaceTestD(bell) == bell, "scientistsNameSpaceTest Global D failed");
+    enforce(scientistsNameSpaceTestE(bell) == bell, "scientistsNameSpaceTest Global E failed");
+
+    enforce(scientistsNameSpaceTestF(bell) == bell, "scientistsNameSpaceTest Global F failed");
+    enforce(scientistsNameSpaceTestG(bell) == bell, "scientistsNameSpaceTest Global G failed");
+    enforce(scientistsNameSpaceTestH(bell) == bell, "scientistsNameSpaceTest Global H failed");
+    enforce(scientistsNameSpaceTestI(bell) == bell, "scientistsNameSpaceTest Global I failed");
+    enforce(scientistsNameSpaceTestJ(bell) == bell, "scientistsNameSpaceTest Global J failed");
+    enforce(scientistsNameSpaceTestK(bell) == bell, "scientistsNameSpaceTest Global K failed");
+    enforce(scientistsNameSpaceTestL(bell) == bell, "scientistsNameSpaceTest Global L failed");
+  }
+  {
+    auto val = newname.argh;
+    enforce(renameTest1(val) == val, "renameTest Global 1 failed");
+    enforce(renameTest2(val) == val, "renameTest Global 2 failed");
+  }
+  {
+    auto n = new NewNameStruct();
+    enforce(n.renameTest1(NewNameStruct.enumeration.bang) == NewNameStruct.enumeration.bang, "renameTest 1 failed");
+    enforce(n.renameTest2(NewNameStruct.enumeration.bang) == NewNameStruct.enumeration.bang, "renameTest 2 failed");
+    enforce(n.renameTest3(NewNameStruct.simplerenamed.simple1) == NewNameStruct.simplerenamed.simple1, "renameTest 3 failed");
+    enforce(n.renameTest4(NewNameStruct.doublenamerenamed.doublename1) == NewNameStruct.doublenamerenamed.doublename1, "renameTest 4 failed");
+    enforce(n.renameTest5(NewNameStruct.doublenamerenamed.doublename1) == NewNameStruct.doublenamerenamed.doublename1, "renameTest 5 failed");
+    enforce(n.renameTest6(NewNameStruct.singlenamerenamed.singlename1) == NewNameStruct.singlenamerenamed.singlename1, "renameTest 6 failed");
+  }
+  {
+    enforce(renameTest3(NewNameStruct.enumeration.bang) == NewNameStruct.enumeration.bang, "renameTest Global 3 failed");
+    enforce(renameTest4(NewNameStruct.simplerenamed.simple1) == NewNameStruct.simplerenamed.simple1, "renameTest Global 4 failed");
+    enforce(renameTest5(NewNameStruct.doublenamerenamed.doublename1) == NewNameStruct.doublenamerenamed.doublename1, "renameTest Global 5 failed");
+    enforce(renameTest6(NewNameStruct.doublenamerenamed.doublename1) == NewNameStruct.doublenamerenamed.doublename1, "renameTest Global 6 failed");
+    enforce(renameTest7(NewNameStruct.singlenamerenamed.singlename1) == NewNameStruct.singlenamerenamed.singlename1, "renameTest Global 7 failed");
+  }
+  {
+    auto t = new TreesClass();
+    auto pine = TreesClass.trees.pine;
+
+    enforce(t.treesTest1(pine) == pine, "treesTest 1 failed");
+    enforce(t.treesTest2(pine) == pine, "treesTest 2 failed");
+    enforce(t.treesTest3(pine) == pine, "treesTest 3 failed");
+    enforce(t.treesTest4(pine) == pine, "treesTest 4 failed");
+    enforce(t.treesTest5(pine) == pine, "treesTest 5 failed");
+    enforce(t.treesTest6(pine) == pine, "treesTest 6 failed");
+    enforce(t.treesTest7(pine) == pine, "treesTest 7 failed");
+    enforce(t.treesTest8(pine) == pine, "treesTest 8 failed");
+    enforce(t.treesTest9(pine) == pine, "treesTest 9 failed");
+    enforce(t.treesTestA(pine) == pine, "treesTest A failed");
+    enforce(t.treesTestB(pine) == pine, "treesTest B failed");
+    enforce(t.treesTestC(pine) == pine, "treesTest C failed");
+    enforce(t.treesTestD(pine) == pine, "treesTest D failed");
+    enforce(t.treesTestE(pine) == pine, "treesTest E failed");
+    enforce(t.treesTestF(pine) == pine, "treesTest F failed");
+    enforce(t.treesTestG(pine) == pine, "treesTest G failed");
+    enforce(t.treesTestH(pine) == pine, "treesTest H failed");
+    enforce(t.treesTestI(pine) == pine, "treesTest I failed");
+    enforce(t.treesTestJ(pine) == pine, "treesTest J failed");
+    enforce(t.treesTestK(pine) == pine, "treesTest K failed");
+    enforce(t.treesTestL(pine) == pine, "treesTest L failed");
+    enforce(t.treesTestM(pine) == pine, "treesTest M failed");
+    enforce(t.treesTestN(pine) == pine, "treesTest N failed");
+    enforce(t.treesTestO(pine) == pine, "treesTest O failed");
+
+    enforce(treesTest1(pine) == pine, "treesTest Global 1 failed");
+    enforce(treesTest2(pine) == pine, "treesTest Global 2 failed");
+    enforce(treesTest3(pine) == pine, "treesTest Global 3 failed");
+    enforce(treesTest4(pine) == pine, "treesTest Global 4 failed");
+    enforce(treesTest5(pine) == pine, "treesTest Global 5 failed");
+    enforce(treesTest6(pine) == pine, "treesTest Global 6 failed");
+    enforce(treesTest7(pine) == pine, "treesTest Global 7 failed");
+    enforce(treesTest8(pine) == pine, "treesTest Global 8 failed");
+    enforce(treesTest9(pine) == pine, "treesTest Global 9 failed");
+    enforce(treesTestA(pine) == pine, "treesTest Global A failed");
+    enforce(treesTestB(pine) == pine, "treesTest Global B failed");
+    enforce(treesTestC(pine) == pine, "treesTest Global C failed");
+    enforce(treesTestD(pine) == pine, "treesTest Global D failed");
+    enforce(treesTestE(pine) == pine, "treesTest Global E failed");
+    enforce(treesTestF(pine) == pine, "treesTest Global F failed");
+    enforce(treesTestG(pine) == pine, "treesTest Global G failed");
+    enforce(treesTestH(pine) == pine, "treesTest Global H failed");
+    enforce(treesTestI(pine) == pine, "treesTest Global I failed");
+    enforce(treesTestJ(pine) == pine, "treesTest Global J failed");
+    enforce(treesTestK(pine) == pine, "treesTest Global K failed");
+    enforce(treesTestL(pine) == pine, "treesTest Global L failed");
+    enforce(treesTestM(pine) == pine, "treesTest Global M failed");
+//      enforce(treesTestN(pine) == pine, "treesTest Global N failed");
+    enforce(treesTestO(pine) == pine, "treesTest Global O failed");
+    enforce(treesTestP(pine) == pine, "treesTest Global P failed");
+    enforce(treesTestQ(pine) == pine, "treesTest Global Q failed");
+    enforce(treesTestR(pine) == pine, "treesTest Global R failed");
+  }
+  {
+    auto h = new HairStruct();
+    auto ginger = HairStruct.hair.ginger;
+
+    enforce(h.hairTest1(ginger) == ginger, "hairTest 1 failed");
+    enforce(h.hairTest2(ginger) == ginger, "hairTest 2 failed");
+    enforce(h.hairTest3(ginger) == ginger, "hairTest 3 failed");
+    enforce(h.hairTest4(ginger) == ginger, "hairTest 4 failed");
+    enforce(h.hairTest5(ginger) == ginger, "hairTest 5 failed");
+    enforce(h.hairTest6(ginger) == ginger, "hairTest 6 failed");
+    enforce(h.hairTest7(ginger) == ginger, "hairTest 7 failed");
+    enforce(h.hairTest8(ginger) == ginger, "hairTest 8 failed");
+    enforce(h.hairTest9(ginger) == ginger, "hairTest 9 failed");
+    enforce(h.hairTestA(ginger) == ginger, "hairTest A failed");
+    enforce(h.hairTestB(ginger) == ginger, "hairTest B failed");
+
+    auto red = colour.red;
+    enforce(h.colourTest1(red) == red, "colourTest HairStruct 1 failed");
+    enforce(h.colourTest2(red) == red, "colourTest HairStruct 2 failed");
+    enforce(h.namedanonTest1(namedanon.NamedAnon2) == namedanon.NamedAnon2, "namedanonTest HairStruct 1 failed");
+    enforce(h.namedanonspaceTest1(namedanonspace.NamedAnonSpace2) == namedanonspace.NamedAnonSpace2, "namedanonspaceTest HairStruct 1 failed");
+
+    auto fir = TreesClass.trees.fir;
+    enforce(h.treesGlobalTest1(fir) == fir, "treesGlobalTest1 HairStruct 1 failed");
+    enforce(h.treesGlobalTest2(fir) == fir, "treesGlobalTest1 HairStruct 2 failed");
+    enforce(h.treesGlobalTest3(fir) == fir, "treesGlobalTest1 HairStruct 3 failed");
+    enforce(h.treesGlobalTest4(fir) == fir, "treesGlobalTest1 HairStruct 4 failed");
+  }
+  {
+    auto blonde = HairStruct.hair.blonde;
+    enforce(hairTest1(blonde) == blonde, "hairTest Global 1 failed");
+    enforce(hairTest2(blonde) == blonde, "hairTest Global 2 failed");
+    enforce(hairTest3(blonde) == blonde, "hairTest Global 3 failed");
+    enforce(hairTest4(blonde) == blonde, "hairTest Global 4 failed");
+    enforce(hairTest5(blonde) == blonde, "hairTest Global 5 failed");
+    enforce(hairTest6(blonde) == blonde, "hairTest Global 6 failed");
+    enforce(hairTest7(blonde) == blonde, "hairTest Global 7 failed");
+    enforce(hairTest8(blonde) == blonde, "hairTest Global 8 failed");
+    enforce(hairTest9(blonde) == blonde, "hairTest Global 9 failed");
+    enforce(hairTestA(blonde) == blonde, "hairTest Global A failed");
+    enforce(hairTestB(blonde) == blonde, "hairTest Global B failed");
+    enforce(hairTestC(blonde) == blonde, "hairTest Global C failed");
+
+    enforce(hairTestA1(blonde) == blonde, "hairTest Global A1 failed");
+    enforce(hairTestA2(blonde) == blonde, "hairTest Global A2 failed");
+    enforce(hairTestA3(blonde) == blonde, "hairTest Global A3 failed");
+    enforce(hairTestA4(blonde) == blonde, "hairTest Global A4 failed");
+    enforce(hairTestA5(blonde) == blonde, "hairTest Global A5 failed");
+    enforce(hairTestA6(blonde) == blonde, "hairTest Global A6 failed");
+    enforce(hairTestA7(blonde) == blonde, "hairTest Global A7 failed");
+    enforce(hairTestA8(blonde) == blonde, "hairTest Global A8 failed");
+    enforce(hairTestA9(blonde) == blonde, "hairTest Global A9 failed");
+    enforce(hairTestAA(blonde) == blonde, "hairTest Global AA failed");
+    enforce(hairTestAB(blonde) == blonde, "hairTest Global AB failed");
+    enforce(hairTestAC(blonde) == blonde, "hairTest Global AC failed");
+
+    enforce(hairTestB1(blonde) == blonde, "hairTest Global B1 failed");
+    enforce(hairTestB2(blonde) == blonde, "hairTest Global B2 failed");
+    enforce(hairTestB3(blonde) == blonde, "hairTest Global B3 failed");
+    enforce(hairTestB4(blonde) == blonde, "hairTest Global B4 failed");
+    enforce(hairTestB5(blonde) == blonde, "hairTest Global B5 failed");
+    enforce(hairTestB6(blonde) == blonde, "hairTest Global B6 failed");
+    enforce(hairTestB7(blonde) == blonde, "hairTest Global B7 failed");
+    enforce(hairTestB8(blonde) == blonde, "hairTest Global B8 failed");
+    enforce(hairTestB9(blonde) == blonde, "hairTest Global B9 failed");
+    enforce(hairTestBA(blonde) == blonde, "hairTest Global BA failed");
+    enforce(hairTestBB(blonde) == blonde, "hairTest Global BB failed");
+    enforce(hairTestBC(blonde) == blonde, "hairTest Global BC failed");
+
+    enforce(hairTestC1(blonde) == blonde, "hairTest Global C1 failed");
+    enforce(hairTestC2(blonde) == blonde, "hairTest Global C2 failed");
+    enforce(hairTestC3(blonde) == blonde, "hairTest Global C3 failed");
+    enforce(hairTestC4(blonde) == blonde, "hairTest Global C4 failed");
+    enforce(hairTestC5(blonde) == blonde, "hairTest Global C5 failed");
+    enforce(hairTestC6(blonde) == blonde, "hairTest Global C6 failed");
+    enforce(hairTestC7(blonde) == blonde, "hairTest Global C7 failed");
+    enforce(hairTestC8(blonde) == blonde, "hairTest Global C8 failed");
+    enforce(hairTestC9(blonde) == blonde, "hairTest Global C9 failed");
+    enforce(hairTestCA(blonde) == blonde, "hairTest Global CA failed");
+    enforce(hairTestCB(blonde) == blonde, "hairTest Global CB failed");
+    enforce(hairTestCC(blonde) == blonde, "hairTest Global CC failed");
+  }
+  {
+    auto f = new FirStruct();
+    auto blonde = HairStruct.hair.blonde;
+
+    enforce(f.hairTestFir1(blonde) == blonde, "hairTestFir 1 failed");
+    enforce(f.hairTestFir2(blonde) == blonde, "hairTestFir 2 failed");
+    enforce(f.hairTestFir3(blonde) == blonde, "hairTestFir 3 failed");
+    enforce(f.hairTestFir4(blonde) == blonde, "hairTestFir 4 failed");
+    enforce(f.hairTestFir5(blonde) == blonde, "hairTestFir 5 failed");
+    enforce(f.hairTestFir6(blonde) == blonde, "hairTestFir 6 failed");
+    enforce(f.hairTestFir7(blonde) == blonde, "hairTestFir 7 failed");
+    enforce(f.hairTestFir8(blonde) == blonde, "hairTestFir 8 failed");
+    enforce(f.hairTestFir9(blonde) == blonde, "hairTestFir 9 failed");
+    enforce(f.hairTestFirA(blonde) == blonde, "hairTestFir A failed");
+  }
+  {
+    GlobalInstance = globalinstance2;
+    enforce(GlobalInstance == globalinstance2, "GlobalInstance 1 failed");
+
+    auto i = new Instances();
+    i.MemberInstance = Instances.memberinstance3;
+    enforce(i.MemberInstance == Instances.memberinstance3, "MemberInstance 1 failed");
+  }
+  // ignore enum item tests start
+  {
+    enforce(cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_zero) == 0, "ignoreATest 0 failed");
+    enforce(cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_three) == 3, "ignoreATest 3 failed");
+    enforce(cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_ten) == 10, "ignoreATest 10 failed");
+    enforce(cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_eleven) == 11, "ignoreATest 11 failed");
+    enforce(cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_thirteen) == 13, "ignoreATest 13 failed");
+    enforce(cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_fourteen) == 14, "ignoreATest 14 failed");
+    enforce(cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_twenty) == 20, "ignoreATest 20 failed");
+    enforce(cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_thirty) == 30, "ignoreATest 30 failed");
+    enforce(cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_thirty_two) == 32, "ignoreATest 32 failed");
+    enforce(cast(int)ignoreATest(IgnoreTest.IgnoreA.ignoreA_thirty_three) == 33, "ignoreATest 33 failed");
+  }
+  {
+    enforce(cast(int)ignoreBTest(IgnoreTest.IgnoreB.ignoreB_eleven) == 11, "ignoreBTest 11 failed");
+    enforce(cast(int)ignoreBTest(IgnoreTest.IgnoreB.ignoreB_twelve) == 12, "ignoreBTest 12 failed");
+    enforce(cast(int)ignoreBTest(IgnoreTest.IgnoreB.ignoreB_thirty_one) == 31, "ignoreBTest 31 failed");
+    enforce(cast(int)ignoreBTest(IgnoreTest.IgnoreB.ignoreB_thirty_two) == 32, "ignoreBTest 32 failed");
+    enforce(cast(int)ignoreBTest(IgnoreTest.IgnoreB.ignoreB_forty_one) == 41, "ignoreBTest 41 failed");
+    enforce(cast(int)ignoreBTest(IgnoreTest.IgnoreB.ignoreB_forty_two) == 42, "ignoreBTest 42 failed");
+  }
+  {
+    enforce(cast(int)ignoreCTest(IgnoreTest.IgnoreC.ignoreC_ten), "ignoreCTest 10 failed");
+    enforce(cast(int)ignoreCTest(IgnoreTest.IgnoreC.ignoreC_twelve) == 12, "ignoreCTest 12 failed");
+    enforce(cast(int)ignoreCTest(IgnoreTest.IgnoreC.ignoreC_thirty) == 30, "ignoreCTest 30 failed");
+    enforce(cast(int)ignoreCTest(IgnoreTest.IgnoreC.ignoreC_thirty_two) == 32, "ignoreCTest 32 failed");
+    enforce(cast(int)ignoreCTest(IgnoreTest.IgnoreC.ignoreC_forty) == 40, "ignoreCTest 40 failed");
+    enforce(cast(int)ignoreCTest(IgnoreTest.IgnoreC.ignoreC_forty_two) == 42, "ignoreCTest 42 failed");
+  }
+  {
+    enforce(cast(int)ignoreDTest(IgnoreTest.IgnoreD.ignoreD_twenty_one) == 21, "ignoreDTest 21 failed");
+    enforce(cast(int)ignoreDTest(IgnoreTest.IgnoreD.ignoreD_twenty_two) == 22, "ignoreDTest 22 failed");
+  }
+  {
+    enforce(cast(int)ignoreETest(IgnoreTest.IgnoreE.ignoreE_zero) == 0, "ignoreETest 0 failed");
+    enforce(cast(int)ignoreETest(IgnoreTest.IgnoreE.ignoreE_twenty_one) == 21, "ignoreETest 21 failed");
+    enforce(cast(int)ignoreETest(IgnoreTest.IgnoreE.ignoreE_twenty_two) == 22, "ignoreETest 22 failed");
+  }
+  // ignore enum item tests end
+  {
+    enforce(cast(int)repeatTest(repeat.one) == 1, "repeatTest 1 failed");
+    enforce(cast(int)repeatTest(repeat.initial) == 1, "repeatTest 2 failed");
+    enforce(cast(int)repeatTest(repeat.two) == 2, "repeatTest 3 failed");
+    enforce(cast(int)repeatTest(repeat.three) == 3, "repeatTest 4 failed");
+    enforce(cast(int)repeatTest(repeat.llast) == 3, "repeatTest 5 failed");
+    enforce(cast(int)repeatTest(repeat.end) == 3, "repeatTest 6 failed");
+  }
+}

Examples/test-suite/d/inherit_target_language_runme.1.d

@@ -0,0 +1,29 @@
+module inherit_target_language_runme;
+
+import inherit_target_language.BaseX;
+import inherit_target_language.Derived1;
+import inherit_target_language.Derived2;
+import inherit_target_language.DerivedX;
+import inherit_target_language.MultipleDerived1;
+import inherit_target_language.MultipleDerived2;
+import inherit_target_language.MultipleDerived3;
+import inherit_target_language.MultipleDerived4;
+
+void main() {
+  (new Derived1()).targetLanguageBaseMethod();
+  (new Derived2()).targetLanguageBaseMethod();
+
+  (new MultipleDerived1()).targetLanguageBaseMethod();
+  (new MultipleDerived2()).targetLanguageBaseMethod();
+  (new MultipleDerived3()).f();
+  (new MultipleDerived4()).g();
+
+  auto baseX = new BaseX();
+  baseX.basex();
+  baseX.targetLanguageBase2Method();
+
+  auto derivedX = new DerivedX();
+  derivedX.basex();
+  derivedX.derivedx();
+  derivedX.targetLanguageBase2Method();
+}

Examples/test-suite/d/inherit_target_language_runme.2.d

@@ -0,0 +1,29 @@
+module inherit_target_language_runme;
+
+import inherit_target_language.BaseX;
+import inherit_target_language.Derived1;
+import inherit_target_language.Derived2;
+import inherit_target_language.DerivedX;
+import inherit_target_language.MultipleDerived1;
+import inherit_target_language.MultipleDerived2;
+import inherit_target_language.MultipleDerived3;
+import inherit_target_language.MultipleDerived4;
+
+void main() {
+  (new Derived1()).targetLanguageBaseMethod();
+  (new Derived2()).targetLanguageBaseMethod();
+
+  (new MultipleDerived1()).targetLanguageBaseMethod();
+  (new MultipleDerived2()).targetLanguageBaseMethod();
+  (new MultipleDerived3()).f();
+  (new MultipleDerived4()).g();
+
+  auto baseX = new BaseX();
+  baseX.basex();
+  baseX.targetLanguageBase2Method();
+
+  auto derivedX = new DerivedX();
+  derivedX.basex();
+  derivedX.derivedx();
+  derivedX.targetLanguageBase2Method();
+}

Examples/test-suite/d/li_attribute_runme.1.d

@@ -0,0 +1,75 @@
+module li_attribute_runme;
+
+import li_attribute.A;
+import li_attribute.B;
+import li_attribute.MyClass;
+import li_attribute.MyClassVal;
+import li_attribute.MyStringyClass;
+import li_attribute.MyFoo;
+import li_attribute.Param_i;
+
+void main() {
+  auto aa = new A(1,2,3);
+
+  if (aa.a != 1)
+    throw new Exception("error");
+  aa.a = 3;
+  if (aa.a != 3)
+    throw new Exception("error");
+
+  if (aa.b != 2)
+    throw new Exception("error");
+  aa.b = 5;
+  if (aa.b != 5)
+    throw new Exception("error");
+
+  if (aa.d != aa.b)
+    throw new Exception("error");
+
+  if (aa.c != 3)
+    throw new Exception("error");
+
+  auto pi = new Param_i(7);
+  if (pi.value != 7)
+    throw new Exception("error");
+
+  pi.value=3;
+  if (pi.value != 3)
+    throw new Exception("error");
+
+  auto b = new B(aa);
+  if (b.a.c != 3)
+    throw new Exception("error");
+
+  // class/struct attribute with get/set methods using return/pass by reference
+  auto myFoo = new MyFoo();
+  myFoo.x = 8;
+  auto myClass = new MyClass();
+  myClass.Foo = myFoo;
+  if (myClass.Foo.x != 8)
+    throw new Exception("error");
+
+  // class/struct attribute with get/set methods using return/pass by value
+  auto myClassVal = new MyClassVal();
+  if (myClassVal.ReadWriteFoo.x != -1)
+    throw new Exception("error");
+  if (myClassVal.ReadOnlyFoo.x != -1)
+    throw new Exception("error");
+  myClassVal.ReadWriteFoo = myFoo;
+  if (myClassVal.ReadWriteFoo.x != 8)
+    throw new Exception("error");
+  if (myClassVal.ReadOnlyFoo.x != 8)
+    throw new Exception("error");
+
+  // string attribute with get/set methods using return/pass by value
+  auto myStringClass = new MyStringyClass("initial string");
+  if (myStringClass.ReadWriteString != "initial string")
+    throw new Exception("error");
+  if (myStringClass.ReadOnlyString != "initial string")
+    throw new Exception("error");
+  myStringClass.ReadWriteString = "changed string";
+  if (myStringClass.ReadWriteString != "changed string")
+    throw new Exception("error");
+  if (myStringClass.ReadOnlyString != "changed string")
+    throw new Exception("error");
+}

Examples/test-suite/d/li_attribute_runme.2.d

@@ -0,0 +1,58 @@
+module li_attribute_runme;
+
+import std.exception;
+import li_attribute.A;
+import li_attribute.B;
+import li_attribute.MyClass;
+import li_attribute.MyClassVal;
+import li_attribute.MyStringyClass;
+import li_attribute.MyFoo;
+import li_attribute.Param_i;
+
+void main() {
+  auto aa = new A(1,2,3);
+
+  enforce(aa.a == 1);
+  aa.a = 3;
+  enforce(aa.a == 3);
+
+  enforce(aa.b == 2);
+  aa.b = 5;
+  enforce(aa.b == 5);
+
+  enforce(aa.d == aa.b);
+
+  enforce(aa.c == 3);
+
+  auto pi = new Param_i(7);
+  enforce(pi.value == 7);
+
+  pi.value=3;
+  enforce(pi.value == 3);
+
+  auto b = new B(aa);
+  enforce(b.a.c == 3);
+
+  // class/struct attribute with get/set methods using return/pass by reference
+  auto myFoo = new MyFoo();
+  myFoo.x = 8;
+  auto myClass = new MyClass();
+  myClass.Foo = myFoo;
+  enforce(myClass.Foo.x == 8);
+
+  // class/struct attribute with get/set methods using return/pass by value
+  auto myClassVal = new MyClassVal();
+  enforce(myClassVal.ReadWriteFoo.x == -1);
+  enforce(myClassVal.ReadOnlyFoo.x == -1);
+  myClassVal.ReadWriteFoo = myFoo;
+  enforce(myClassVal.ReadWriteFoo.x == 8);
+  enforce(myClassVal.ReadOnlyFoo.x == 8);
+
+  // string attribute with get/set methods using return/pass by value
+  auto myStringClass = new MyStringyClass("initial string");
+  enforce(myStringClass.ReadWriteString == "initial string");
+  enforce(myStringClass.ReadOnlyString == "initial string");
+  myStringClass.ReadWriteString = "changed string";
+  enforce(myStringClass.ReadWriteString == "changed string");
+  enforce(myStringClass.ReadOnlyString == "changed string");
+}

Examples/test-suite/d/li_boost_shared_ptr_bits_runme.1.d

@@ -0,0 +1,21 @@
+module li_boost_shared_ptr_runme_bits;
+
+import li_boost_shared_ptr_bits.li_boost_shared_ptr_bits;
+import li_boost_shared_ptr_bits.HiddenDestructor;
+import li_boost_shared_ptr_bits.IntHolder;
+import li_boost_shared_ptr_bits.VectorIntHolder;
+
+void main() {
+  auto v = new VectorIntHolder();
+  v ~= new IntHolder(11);
+  v ~= new IntHolder(22);
+  v ~= new IntHolder(33);
+
+  if (sum(v) != 66) {
+    throw new Exception("sum is wrong");
+  }
+
+  {
+    scope hidden = HiddenDestructor.create();
+  }
+}

Examples/test-suite/d/li_boost_shared_ptr_bits_runme.2.d

@@ -0,0 +1,19 @@
+module li_boost_shared_ptr_runme_bits;
+
+import std.exception;
+import li_boost_shared_ptr_bits.li_boost_shared_ptr_bits;
+import li_boost_shared_ptr_bits.HiddenDestructor;
+import li_boost_shared_ptr_bits.IntHolder;
+import li_boost_shared_ptr_bits.VectorIntHolder;
+
+void main() {
+  auto v = new VectorIntHolder();
+  v ~= new IntHolder(11);
+  v ~= new IntHolder(22);
+  v ~= new IntHolder(33);
+  enforce(sum(v) == 66, "sum is wrong");
+
+  {
+    scope hidden = HiddenDestructor.create();
+  }
+}

Examples/test-suite/d/li_boost_shared_ptr_runme.1.d

@@ -0,0 +1,604 @@
+module li_boost_shared_ptr_runme;
+
+import tango.io.Stdout;
+import tango.core.Exception;
+import tango.core.Memory;
+import tango.core.Thread;
+import tango.text.convert.Integer;
+import li_boost_shared_ptr.li_boost_shared_ptr;
+import li_boost_shared_ptr.Klass;
+import li_boost_shared_ptr.KlassDerived;
+import li_boost_shared_ptr.Klass3rdDerived;
+import li_boost_shared_ptr.MemberVariables;
+import li_boost_shared_ptr.PairIntDouble;
+
+// Debugging flag
+const bool TRACE = false;
+
+void main() {
+  if (TRACE)
+    Stdout("---> STARTED <---").newline;
+
+  debug_shared=TRACE;
+
+  // Change loop count to run for a long time to monitor memory
+  const int LOOP_COUNT = 1; // 50000;
+  for (int i = 0; i < LOOP_COUNT; ++i) {
+    runTest();
+    GC.collect();
+  }
+
+  if (TRACE)
+    Stdout("---> NEARLY FINISHED <---").newline;
+
+  // Try to get the GC to collect everything not referenced anymore.
+  int countdown = 100;
+  while (--countdown) {
+    GC.collect();
+    if (Klass.getTotal_count() == 1)
+      break;
+    Thread.sleep(0.01);
+  }
+
+  // A single remaining instance expected: the global variable (GlobalValue).
+  if (Klass.getTotal_count() != 1)
+    throw new Exception("Klass.total_count=" ~ toString(Klass.getTotal_count()));
+
+  // A single remaining instance expected: the global variable (GlobalSmartValue).
+  int wrapper_count = shared_ptr_wrapper_count();
+  if (wrapper_count != NOT_COUNTING)
+    if (wrapper_count != 1)
+      throw new Exception("shared_ptr wrapper count=" ~ toString(wrapper_count));
+
+  if (TRACE)
+    Stdout("---> FINISHED <---").newline;
+}
+
+void runTest() {
+  // simple shared_ptr usage - created in C++
+  {
+    auto k = new Klass("me oh my");
+    char[] val = k.getValue();
+    verifyValue("me oh my", val);
+    verifyCount(1, k);
+  }
+
+  // simple shared_ptr usage - not created in C++
+  {
+    auto k = factorycreate();
+    char[] val = k.getValue();
+    verifyValue("factorycreate", val);
+    verifyCount(1, k);
+  }
+
+  // pass by shared_ptr
+  {
+    auto k = new Klass("me oh my");
+    auto kret = smartpointertest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my smartpointertest", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // pass by shared_ptr pointer
+  {
+    auto k = new Klass("me oh my");
+    auto kret = smartpointerpointertest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my smartpointerpointertest", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // pass by shared_ptr reference
+  {
+    auto k = new Klass("me oh my");
+    auto kret = smartpointerreftest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my smartpointerreftest", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // pass by shared_ptr pointer reference
+  {
+    auto k = new Klass("me oh my");
+    auto kret = smartpointerpointerreftest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my smartpointerpointerreftest", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // const pass by shared_ptr
+  {
+    auto k = new Klass("me oh my");
+    auto kret = constsmartpointertest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // const pass by shared_ptr pointer
+  {
+    auto k = new Klass("me oh my");
+    auto kret = constsmartpointerpointertest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // const pass by shared_ptr reference
+  {
+    auto k = new Klass("me oh my");
+    auto kret = constsmartpointerreftest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // pass by value
+  {
+    auto k = new Klass("me oh my");
+    auto kret = valuetest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my valuetest", val);
+    verifyCount(1, k);
+    verifyCount(1, kret);
+  }
+
+  // pass by pointer
+  {
+    auto k = new Klass("me oh my");
+    auto kret = pointertest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my pointertest", val);
+    verifyCount(1, k);
+    verifyCount(1, kret);
+  }
+
+  // pass by reference
+  {
+    auto k = new Klass("me oh my");
+    auto kret = reftest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my reftest", val);
+    verifyCount(1, k);
+    verifyCount(1, kret);
+  }
+
+  // pass by pointer reference
+  {
+    auto k = new Klass("me oh my");
+    auto kret = pointerreftest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my pointerreftest", val);
+    verifyCount(1, k);
+    verifyCount(1, kret);
+  }
+
+  // null tests
+  {
+    Klass k = null;
+
+    // TODO: add in const versions too
+    if (smartpointertest(k) !is null)
+      throw new Exception("return was not null");
+
+    if (smartpointerpointertest(k) !is null)
+      throw new Exception("return was not null");
+
+    if (smartpointerreftest(k) !is null)
+      throw new Exception("return was not null");
+
+    if (smartpointerpointerreftest(k) !is null)
+      throw new Exception("return was not null");
+
+    if (nullsmartpointerpointertest(null) != "null pointer")
+      throw new Exception("not null smartpointer pointer");
+
+    try { valuetest(k); throw new Exception("Failed to catch null pointer"); } catch (IllegalArgumentException) {}
+
+    if (pointertest(k) !is null)
+      throw new Exception("return was not null");
+
+    try { reftest(k); throw new Exception("Failed to catch null pointer"); } catch (IllegalArgumentException) {}
+  }
+
+  // $owner
+  {
+    auto k = pointerownertest();
+    char[] val = k.getValue();
+    verifyValue("pointerownertest", val);
+    verifyCount(1, k);
+  }
+  {
+    auto k = smartpointerpointerownertest();
+    char[] val = k.getValue();
+    verifyValue("smartpointerpointerownertest", val);
+    verifyCount(1, k);
+  }
+
+  ////////////////////////////////// Derived classes ////////////////////////////////////////
+  // derived pass by shared_ptr
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = derivedsmartptrtest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my derivedsmartptrtest-Derived", val);
+    verifyCount(4, k); // includes two extra references for upcasts in the proxy classes
+    verifyCount(4, kret);
+  }
+  // derived pass by shared_ptr pointer
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = derivedsmartptrpointertest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my derivedsmartptrpointertest-Derived", val);
+    verifyCount(4, k); // includes two extra references for upcasts in the proxy classes
+    verifyCount(4, kret);
+  }
+  // derived pass by shared_ptr ref
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = derivedsmartptrreftest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my derivedsmartptrreftest-Derived", val);
+    verifyCount(4, k); // includes two extra references for upcasts in the proxy classes
+    verifyCount(4, kret);
+  }
+  // derived pass by shared_ptr pointer ref
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = derivedsmartptrpointerreftest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val);
+    verifyCount(4, k); // includes two extra references for upcasts in the proxy classes
+    verifyCount(4, kret);
+  }
+  // derived pass by pointer
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = derivedpointertest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my derivedpointertest-Derived", val);
+    verifyCount(2, k); // includes an extra reference for the upcast in the proxy class
+    verifyCount(2, kret);
+  }
+  // derived pass by ref
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = derivedreftest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my derivedreftest-Derived", val);
+    verifyCount(2, k); // includes an extra reference for the upcast in the proxy class
+    verifyCount(2, kret);
+  }
+
+  ////////////////////////////////// Derived and base class mixed ////////////////////////////////////////
+  // pass by shared_ptr (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = smartpointertest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my smartpointertest-Derived", val);
+    verifyCount(3, k); // an extra reference for the upcast in the proxy class
+    verifyCount(3, kret);
+  }
+
+  // pass by shared_ptr pointer (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = smartpointerpointertest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my smartpointerpointertest-Derived", val);
+    verifyCount(3, k); // an extra reference for the upcast in the proxy class
+    verifyCount(3, kret);
+  }
+
+  // pass by shared_ptr reference (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = smartpointerreftest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my smartpointerreftest-Derived", val);
+    verifyCount(3, k); // an extra reference for the upcast in the proxy class
+    verifyCount(3, kret);
+  }
+
+  // pass by shared_ptr pointer reference (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = smartpointerpointerreftest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my smartpointerpointerreftest-Derived", val);
+    verifyCount(3, k); // an extra reference for the upcast in the proxy class
+    verifyCount(3, kret);
+  }
+
+  // pass by value (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = valuetest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my valuetest", val); // note slicing
+    verifyCount(2, k); // an extra reference for the upcast in the proxy class
+    verifyCount(1, kret);
+  }
+
+  // pass by pointer (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = pointertest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my pointertest-Derived", val);
+    verifyCount(2, k); // an extra reference for the upcast in the proxy class
+    verifyCount(1, kret);
+  }
+
+  // pass by ref (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = reftest(k);
+    char[] val = kret.getValue();
+    verifyValue("me oh my reftest-Derived", val);
+    verifyCount(2, k); // an extra reference for the upcast in the proxy class
+    verifyCount(1, kret);
+  }
+
+  // 3rd derived class
+  {
+    auto k = new Klass3rdDerived("me oh my");
+    char[] val = k.getValue();
+    verifyValue("me oh my-3rdDerived", val);
+    verifyCount(3, k); // 3 classes in inheritance chain == 3 swigCPtr values
+    val = test3rdupcast(k);
+    verifyValue("me oh my-3rdDerived", val);
+    verifyCount(3, k);
+  }
+
+  ////////////////////////////////// Member variables ////////////////////////////////////////
+  // smart pointer by value
+  {
+    auto m = new MemberVariables();
+    auto k = new Klass("smart member value");
+    m.SmartMemberValue = k;
+    char[] val = k.getValue();
+    verifyValue("smart member value", val);
+    verifyCount(2, k);
+
+    auto kmember = m.SmartMemberValue;
+    val = kmember.getValue();
+    verifyValue("smart member value", val);
+    verifyCount(3, kmember);
+    verifyCount(3, k);
+
+    delete m;
+
+    verifyCount(2, kmember);
+    verifyCount(2, k);
+  }
+  // smart pointer by pointer
+  {
+    auto m = new MemberVariables();
+    auto k = new Klass("smart member pointer");
+    m.SmartMemberPointer = k;
+    char[] val = k.getValue();
+    verifyValue("smart member pointer", val);
+    verifyCount(1, k);
+
+    auto kmember = m.SmartMemberPointer;
+    val = kmember.getValue();
+    verifyValue("smart member pointer", val);
+    verifyCount(2, kmember);
+    verifyCount(2, k);
+
+    delete m;
+
+    verifyCount(2, kmember);
+    verifyCount(2, k);
+  }
+  // smart pointer by reference
+  {
+    auto m = new MemberVariables();
+    auto k = new Klass("smart member reference");
+    m.SmartMemberReference = k;
+    char[] val = k.getValue();
+    verifyValue("smart member reference", val);
+    verifyCount(2, k);
+
+    auto kmember = m.SmartMemberReference;
+    val = kmember.getValue();
+    verifyValue("smart member reference", val);
+    verifyCount(3, kmember);
+    verifyCount(3, k);
+
+    // The C++ reference refers to SmartMemberValue...
+    auto kmemberVal = m.SmartMemberValue;
+    val = kmember.getValue();
+    verifyValue("smart member reference", val);
+    verifyCount(4, kmemberVal);
+    verifyCount(4, kmember);
+    verifyCount(4, k);
+
+    delete m;
+
+    verifyCount(3, kmember);
+    verifyCount(3, k);
+  }
+  // plain by value
+  {
+    auto m = new MemberVariables();
+    auto k = new Klass("plain member value");
+    m.MemberValue = k;
+    char[] val = k.getValue();
+    verifyValue("plain member value", val);
+    verifyCount(1, k);
+
+    auto kmember = m.MemberValue;
+    val = kmember.getValue();
+    verifyValue("plain member value", val);
+    verifyCount(1, kmember);
+    verifyCount(1, k);
+
+    delete m;
+
+    verifyCount(1, kmember);
+    verifyCount(1, k);
+  }
+  // plain by pointer
+  {
+    auto m = new MemberVariables();
+    auto k = new Klass("plain member pointer");
+    m.MemberPointer = k;
+    char[] val = k.getValue();
+    verifyValue("plain member pointer", val);
+    verifyCount(1, k);
+
+    auto kmember = m.MemberPointer;
+    val = kmember.getValue();
+    verifyValue("plain member pointer", val);
+    verifyCount(1, kmember);
+    verifyCount(1, k);
+
+    delete m;
+
+    verifyCount(1, kmember);
+    verifyCount(1, k);
+  }
+  // plain by reference
+  {
+    auto m = new MemberVariables();
+    auto k = new Klass("plain member reference");
+    m.MemberReference = k;
+    char[] val = k.getValue();
+    verifyValue("plain member reference", val);
+    verifyCount(1, k);
+
+    auto kmember = m.MemberReference;
+    val = kmember.getValue();
+    verifyValue("plain member reference", val);
+    verifyCount(1, kmember);
+    verifyCount(1, k);
+
+    delete m;
+
+    verifyCount(1, kmember);
+    verifyCount(1, k);
+  }
+
+  // null member variables
+  {
+    auto m = new MemberVariables();
+
+    // shared_ptr by value
+    auto k = m.SmartMemberValue;
+    if (k !is null)
+      throw new Exception("expected null");
+    m.SmartMemberValue = null;
+    k = m.SmartMemberValue;
+    if (k !is null)
+      throw new Exception("expected null");
+    verifyCount(0, k);
+
+    // plain by value
+    try { m.MemberValue = null; throw new Exception("Failed to catch null pointer"); } catch (IllegalArgumentException) {}
+  }
+
+  ////////////////////////////////// Global variables ////////////////////////////////////////
+  // smart pointer
+  {
+    auto kglobal = GlobalSmartValue;
+    if (kglobal !is null)
+      throw new Exception("expected null");
+
+    auto k = new Klass("smart global value");
+    GlobalSmartValue = k;
+    verifyCount(2, k);
+
+    kglobal = GlobalSmartValue;
+    char[] val = kglobal.getValue();
+    verifyValue("smart global value", val);
+    verifyCount(3, kglobal);
+    verifyCount(3, k);
+    verifyValue("smart global value", GlobalSmartValue.getValue());
+    GlobalSmartValue = null;
+  }
+  // plain value
+  {
+    Klass kglobal;
+
+    auto k = new Klass("global value");
+    GlobalValue = k;
+    verifyCount(1, k);
+
+    kglobal = GlobalValue;
+    char[] val = kglobal.getValue();
+    verifyValue("global value", val);
+    verifyCount(1, kglobal);
+    verifyCount(1, k);
+    verifyValue("global value", GlobalValue.getValue());
+
+    try { GlobalValue = null; throw new Exception("Failed to catch null pointer"); } catch (IllegalArgumentException) {}
+  }
+  // plain pointer
+  {
+    auto kglobal = GlobalPointer;
+    if (kglobal !is null)
+      throw new Exception("expected null");
+
+    auto k = new Klass("global pointer");
+    GlobalPointer = k;
+    verifyCount(1, k);
+
+    kglobal = GlobalPointer;
+    char[] val = kglobal.getValue();
+    verifyValue("global pointer", val);
+    verifyCount(1, kglobal);
+    verifyCount(1, k);
+    GlobalPointer = null;
+  }
+  // plain reference
+  {
+    Klass kglobal;
+
+    auto k = new Klass("global reference");
+    GlobalReference = k;
+    verifyCount(1, k);
+
+    kglobal = GlobalReference;
+    char[] val = kglobal.getValue();
+    verifyValue("global reference", val);
+    verifyCount(1, kglobal);
+    verifyCount(1, k);
+
+    try { GlobalReference = null; throw new Exception("Failed to catch null pointer"); } catch (IllegalArgumentException) {}
+  }
+
+  ////////////////////////////////// Templates ////////////////////////////////////////
+  {
+    PairIntDouble pid = new PairIntDouble(10, 20.2);
+    if (pid.baseVal1 != 20 || pid.baseVal2 != 40.4)
+      throw new Exception("Base values wrong");
+    if (pid.val1 != 10 || pid.val2 != 20.2)
+      throw new Exception("Derived Values wrong");
+  }
+}
+
+private void verifyValue(char[] expected, char[] got) {
+  if (expected != got)
+    throw new Exception("verify value failed. Expected: " ~ expected ~ " Got: " ~ got);
+}
+
+private void verifyCount(int expected, Klass k) {
+  // We deliberately call the use_count(Klass) overload also for objects which
+  // are instances of a subclass of Klass (due to static dispatch); things still
+  // have to work.
+  int got = use_count(k);
+  if (expected != got)
+    throw new Exception("verify use_count failed. Expected: " ~ toString(expected) ~ " Got: " ~ toString(got));
+}

Examples/test-suite/d/li_boost_shared_ptr_runme.2.d

@@ -0,0 +1,602 @@
+module li_boost_shared_ptr_runme;
+
+import core.memory;
+import core.thread;
+import std.conv;
+import std.exception;
+import std.stdio;
+import li_boost_shared_ptr.li_boost_shared_ptr;
+import li_boost_shared_ptr.Klass;
+import li_boost_shared_ptr.KlassDerived;
+import li_boost_shared_ptr.Klass3rdDerived;
+import li_boost_shared_ptr.MemberVariables;
+import li_boost_shared_ptr.PairIntDouble;
+
+// Debugging flag
+enum TRACE = false;
+
+void main() {
+  if (TRACE)
+    writeln("---> STARTED <---");
+
+  debug_shared = TRACE;
+
+  // Change loop count to run for a long time to monitor memory
+  enum LOOP_COUNT = 1; // 50000;
+  for (int i = 0; i < LOOP_COUNT; ++i) {
+    runTest();
+    GC.collect();
+  }
+
+  if (TRACE)
+    writeln("---> NEARLY FINISHED <---");
+
+  // Try to get the GC to collect everything not referenced anymore.
+  int countdown = 100;
+  while (--countdown) {
+    GC.collect();
+    if (Klass.getTotal_count() == 1)
+      break;
+    Thread.sleep(100);
+  }
+
+  // A single remaining instance expected: the global variable (GlobalValue).
+  if (Klass.getTotal_count() != 1)
+    throw new Exception("Klass.total_count=" ~ to!string(Klass.getTotal_count()));
+
+  // A single remaining instance expected: the global variable (GlobalSmartValue).
+  int wrapper_count = shared_ptr_wrapper_count();
+  if (wrapper_count != NOT_COUNTING)
+    if (wrapper_count != 1)
+      throw new Exception("shared_ptr wrapper count=" ~ to!string(wrapper_count));
+
+  if (TRACE)
+    writeln("---> FINISHED <---");
+}
+
+void runTest() {
+  // simple shared_ptr usage - created in C++
+  {
+    auto k = new Klass("me oh my");
+    string val = k.getValue();
+    verifyValue("me oh my", val);
+    verifyCount(1, k);
+  }
+
+  // simple shared_ptr usage - not created in C++
+  {
+    auto k = factorycreate();
+    string val = k.getValue();
+    verifyValue("factorycreate", val);
+    verifyCount(1, k);
+  }
+
+  // pass by shared_ptr
+  {
+    auto k = new Klass("me oh my");
+    auto kret = smartpointertest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my smartpointertest", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // pass by shared_ptr pointer
+  {
+    auto k = new Klass("me oh my");
+    auto kret = smartpointerpointertest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my smartpointerpointertest", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // pass by shared_ptr reference
+  {
+    auto k = new Klass("me oh my");
+    auto kret = smartpointerreftest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my smartpointerreftest", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // pass by shared_ptr pointer reference
+  {
+    auto k = new Klass("me oh my");
+    auto kret = smartpointerpointerreftest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my smartpointerpointerreftest", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // const pass by shared_ptr
+  {
+    auto k = new Klass("me oh my");
+    auto kret = constsmartpointertest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // const pass by shared_ptr pointer
+  {
+    auto k = new Klass("me oh my");
+    auto kret = constsmartpointerpointertest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // const pass by shared_ptr reference
+  {
+    auto k = new Klass("me oh my");
+    auto kret = constsmartpointerreftest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my", val);
+    verifyCount(2, k);
+    verifyCount(2, kret);
+  }
+
+  // pass by value
+  {
+    auto k = new Klass("me oh my");
+    auto kret = valuetest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my valuetest", val);
+    verifyCount(1, k);
+    verifyCount(1, kret);
+  }
+
+  // pass by pointer
+  {
+    auto k = new Klass("me oh my");
+    auto kret = pointertest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my pointertest", val);
+    verifyCount(1, k);
+    verifyCount(1, kret);
+  }
+
+  // pass by reference
+  {
+    auto k = new Klass("me oh my");
+    auto kret = reftest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my reftest", val);
+    verifyCount(1, k);
+    verifyCount(1, kret);
+  }
+
+  // pass by pointer reference
+  {
+    auto k = new Klass("me oh my");
+    auto kret = pointerreftest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my pointerreftest", val);
+    verifyCount(1, k);
+    verifyCount(1, kret);
+  }
+
+  // null tests
+  {
+    Klass k = null;
+
+    // TODO: add in const versions too
+    enforce(smartpointertest(k) is null, "return was not null");
+    enforce(smartpointerpointertest(k) is null, "return was not null");
+    enforce(smartpointerreftest(k) is null, "return was not null");
+    enforce(smartpointerpointerreftest(k) is null, "return was not null");
+    enforce(nullsmartpointerpointertest(null) == "null pointer",
+      "not null smartpointer pointer");
+
+    enforceThrows( (){ valuetest(k); }, "Failed to catch null pointer");
+    enforce(pointertest(k) is null, "return was not null");
+    enforceThrows( (){ reftest(k); }, "Failed to catch null pointer");
+  }
+
+  // $owner
+  {
+    auto k = pointerownertest();
+    string val = k.getValue();
+    verifyValue("pointerownertest", val);
+    verifyCount(1, k);
+  }
+  {
+    auto k = smartpointerpointerownertest();
+    string val = k.getValue();
+    verifyValue("smartpointerpointerownertest", val);
+    verifyCount(1, k);
+  }
+
+  ////////////////////////////////// Derived classes ////////////////////////////////////////
+  // derived pass by shared_ptr
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = derivedsmartptrtest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my derivedsmartptrtest-Derived", val);
+    verifyCount(4, k); // includes two extra references for upcasts in the proxy classes
+    verifyCount(4, kret);
+  }
+  // derived pass by shared_ptr pointer
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = derivedsmartptrpointertest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my derivedsmartptrpointertest-Derived", val);
+    verifyCount(4, k); // includes two extra references for upcasts in the proxy classes
+    verifyCount(4, kret);
+  }
+  // derived pass by shared_ptr ref
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = derivedsmartptrreftest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my derivedsmartptrreftest-Derived", val);
+    verifyCount(4, k); // includes two extra references for upcasts in the proxy classes
+    verifyCount(4, kret);
+  }
+  // derived pass by shared_ptr pointer ref
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = derivedsmartptrpointerreftest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val);
+    verifyCount(4, k); // includes two extra references for upcasts in the proxy classes
+    verifyCount(4, kret);
+  }
+  // derived pass by pointer
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = derivedpointertest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my derivedpointertest-Derived", val);
+    verifyCount(2, k); // includes an extra reference for the upcast in the proxy class
+    verifyCount(2, kret);
+  }
+  // derived pass by ref
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = derivedreftest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my derivedreftest-Derived", val);
+    verifyCount(2, k); // includes an extra reference for the upcast in the proxy class
+    verifyCount(2, kret);
+  }
+
+  ////////////////////////////////// Derived and base class mixed ////////////////////////////////////////
+  // pass by shared_ptr (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = smartpointertest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my smartpointertest-Derived", val);
+    verifyCount(3, k); // an extra reference for the upcast in the proxy class
+    verifyCount(3, kret);
+  }
+
+  // pass by shared_ptr pointer (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = smartpointerpointertest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my smartpointerpointertest-Derived", val);
+    verifyCount(3, k); // an extra reference for the upcast in the proxy class
+    verifyCount(3, kret);
+  }
+
+  // pass by shared_ptr reference (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = smartpointerreftest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my smartpointerreftest-Derived", val);
+    verifyCount(3, k); // an extra reference for the upcast in the proxy class
+    verifyCount(3, kret);
+  }
+
+  // pass by shared_ptr pointer reference (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = smartpointerpointerreftest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my smartpointerpointerreftest-Derived", val);
+    verifyCount(3, k); // an extra reference for the upcast in the proxy class
+    verifyCount(3, kret);
+  }
+
+  // pass by value (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = valuetest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my valuetest", val); // note slicing
+    verifyCount(2, k); // an extra reference for the upcast in the proxy class
+    verifyCount(1, kret);
+  }
+
+  // pass by pointer (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = pointertest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my pointertest-Derived", val);
+    verifyCount(2, k); // an extra reference for the upcast in the proxy class
+    verifyCount(1, kret);
+  }
+
+  // pass by ref (mixed)
+  {
+    auto k = new KlassDerived("me oh my");
+    auto kret = reftest(k);
+    string val = kret.getValue();
+    verifyValue("me oh my reftest-Derived", val);
+    verifyCount(2, k); // an extra reference for the upcast in the proxy class
+    verifyCount(1, kret);
+  }
+
+  // 3rd derived class
+  {
+    auto k = new Klass3rdDerived("me oh my");
+    string val = k.getValue();
+    verifyValue("me oh my-3rdDerived", val);
+    verifyCount(3, k); // 3 classes in inheritance chain == 3 swigCPtr values
+    val = test3rdupcast(k);
+    verifyValue("me oh my-3rdDerived", val);
+    verifyCount(3, k);
+  }
+
+  ////////////////////////////////// Member variables ////////////////////////////////////////
+  // smart pointer by value
+  {
+    auto m = new MemberVariables();
+    auto k = new Klass("smart member value");
+    m.SmartMemberValue = k;
+    string val = k.getValue();
+    verifyValue("smart member value", val);
+    verifyCount(2, k);
+
+    auto kmember = m.SmartMemberValue;
+    val = kmember.getValue();
+    verifyValue("smart member value", val);
+    verifyCount(3, kmember);
+    verifyCount(3, k);
+
+    delete m;
+
+    verifyCount(2, kmember);
+    verifyCount(2, k);
+  }
+  // smart pointer by pointer
+  {
+    auto m = new MemberVariables();
+    auto k = new Klass("smart member pointer");
+    m.SmartMemberPointer = k;
+    string val = k.getValue();
+    verifyValue("smart member pointer", val);
+    verifyCount(1, k);
+
+    auto kmember = m.SmartMemberPointer;
+    val = kmember.getValue();
+    verifyValue("smart member pointer", val);
+    verifyCount(2, kmember);
+    verifyCount(2, k);
+
+    delete m;
+
+    verifyCount(2, kmember);
+    verifyCount(2, k);
+  }
+  // smart pointer by reference
+  {
+    auto m = new MemberVariables();
+    auto k = new Klass("smart member reference");
+    m.SmartMemberReference = k;
+    string val = k.getValue();
+    verifyValue("smart member reference", val);
+    verifyCount(2, k);
+
+    auto kmember = m.SmartMemberReference;
+    val = kmember.getValue();
+    verifyValue("smart member reference", val);
+    verifyCount(3, kmember);
+    verifyCount(3, k);
+
+    // The C++ reference refers to SmartMemberValue...
+    auto kmemberVal = m.SmartMemberValue;
+    val = kmember.getValue();
+    verifyValue("smart member reference", val);
+    verifyCount(4, kmemberVal);
+    verifyCount(4, kmember);
+    verifyCount(4, k);
+
+    delete m;
+
+    verifyCount(3, kmember);
+    verifyCount(3, k);
+  }
+  // plain by value
+  {
+    auto m = new MemberVariables();
+    auto k = new Klass("plain member value");
+    m.MemberValue = k;
+    string val = k.getValue();
+    verifyValue("plain member value", val);
+    verifyCount(1, k);
+
+    auto kmember = m.MemberValue;
+    val = kmember.getValue();
+    verifyValue("plain member value", val);
+    verifyCount(1, kmember);
+    verifyCount(1, k);
+
+    delete m;
+
+    verifyCount(1, kmember);
+    verifyCount(1, k);
+  }
+  // plain by pointer
+  {
+    auto m = new MemberVariables();
+    auto k = new Klass("plain member pointer");
+    m.MemberPointer = k;
+    string val = k.getValue();
+    verifyValue("plain member pointer", val);
+    verifyCount(1, k);
+
+    auto kmember = m.MemberPointer;
+    val = kmember.getValue();
+    verifyValue("plain member pointer", val);
+    verifyCount(1, kmember);
+    verifyCount(1, k);
+
+    delete m;
+
+    verifyCount(1, kmember);
+    verifyCount(1, k);
+  }
+  // plain by reference
+  {
+    auto m = new MemberVariables();
+    auto k = new Klass("plain member reference");
+    m.MemberReference = k;
+    string val = k.getValue();
+    verifyValue("plain member reference", val);
+    verifyCount(1, k);
+
+    auto kmember = m.MemberReference;
+    val = kmember.getValue();
+    verifyValue("plain member reference", val);
+    verifyCount(1, kmember);
+    verifyCount(1, k);
+
+    delete m;
+
+    verifyCount(1, kmember);
+    verifyCount(1, k);
+  }
+
+  // null member variables
+  {
+    auto m = new MemberVariables();
+
+    // shared_ptr by value
+    auto k = m.SmartMemberValue;
+    if (k !is null)
+      throw new Exception("expected null");
+    m.SmartMemberValue = null;
+    k = m.SmartMemberValue;
+    if (k !is null)
+      throw new Exception("expected null");
+    verifyCount(0, k);
+
+    // plain by value
+    enforceThrows( (){ m.MemberValue = null; }, "Failed to catch null pointer");
+  }
+
+  ////////////////////////////////// Global variables ////////////////////////////////////////
+  // smart pointer
+  {
+    auto kglobal = GlobalSmartValue;
+    enforce(kglobal is null, "expected null");
+
+    auto k = new Klass("smart global value");
+    GlobalSmartValue = k;
+    verifyCount(2, k);
+
+    kglobal = GlobalSmartValue;
+    string val = kglobal.getValue();
+    verifyValue("smart global value", val);
+    verifyCount(3, kglobal);
+    verifyCount(3, k);
+    verifyValue("smart global value", GlobalSmartValue.getValue());
+    GlobalSmartValue = null;
+  }
+  // plain value
+  {
+    Klass kglobal;
+
+    auto k = new Klass("global value");
+    GlobalValue = k;
+    verifyCount(1, k);
+
+    kglobal = GlobalValue;
+    string val = kglobal.getValue();
+    verifyValue("global value", val);
+    verifyCount(1, kglobal);
+    verifyCount(1, k);
+    verifyValue("global value", GlobalValue.getValue());
+
+    enforceThrows((){ GlobalValue = null; }, "Failed to catch null pointer");
+  }
+  // plain pointer
+  {
+    auto kglobal = GlobalPointer;
+    enforce(kglobal is null, "expected null");
+
+    auto k = new Klass("global pointer");
+    GlobalPointer = k;
+    verifyCount(1, k);
+
+    kglobal = GlobalPointer;
+    string val = kglobal.getValue();
+    verifyValue("global pointer", val);
+    verifyCount(1, kglobal);
+    verifyCount(1, k);
+    GlobalPointer = null;
+  }
+  // plain reference
+  {
+    Klass kglobal;
+
+    auto k = new Klass("global reference");
+    GlobalReference = k;
+    verifyCount(1, k);
+
+    kglobal = GlobalReference;
+    string val = kglobal.getValue();
+    verifyValue("global reference", val);
+    verifyCount(1, kglobal);
+    verifyCount(1, k);
+
+    enforceThrows((){ GlobalReference = null; }, "Failed to catch null pointer");
+  }
+
+  ////////////////////////////////// Templates ////////////////////////////////////////
+  {
+    auto pid = new PairIntDouble(10, 20.2);
+    enforce(pid.baseVal1 == 20 && pid.baseVal2== 40.4, "Base values wrong");
+    enforce(pid.val1 == 10 && pid.val2 == 20.2, "Derived Values wrong");
+  }
+}
+
+private void verifyValue(string expected, string got) {
+  if (expected != got)
+    throw new Exception("verify value failed. Expected: " ~ expected ~ " Got: " ~ got);
+}
+
+private void verifyCount(int expected, Klass k) {
+  // We deliberately call the use_count(Klass) overload also for objects which
+  // are instances of a subclass of Klass (due to static dispatch); things still
+  // have to work.
+  int got = use_count(k);
+  if (expected != got)
+    throw new Exception("verify use_count failed. Expected: " ~ to!string(expected) ~ " Got: " ~ to!string(got));
+}
+
+private void enforceThrows(void delegate() dg, string errorMessage) {
+  bool hasThrown;
+  try {
+    dg();
+  } catch (Exception) {
+    hasThrown = true;
+  } finally {
+    if (!hasThrown) {
+      throw new Exception(errorMessage);
+    }
+  }
+}

Examples/test-suite/d/li_std_except_runme.1.d

@@ -0,0 +1,40 @@
+module li_std_except_runme;
+
+import tango.core.Exception;
+import tango.io.Console;
+import li_std_except.Test;
+
+void main() {
+  with (new Test()) {
+    mixin(test("Exception", "throw_bad_exception"));
+    mixin(test("Exception", "throw_domain_error"));
+    mixin(test("Exception", "throw_exception"));
+    mixin(test("IllegalArgumentException", "throw_invalid_argument"));
+    mixin(test("NoSuchElementException", "throw_length_error"));
+    mixin(test("Exception", "throw_logic_error"));
+    mixin(test("NoSuchElementException", "throw_out_of_range"));
+    mixin(test("Exception", "throw_overflow_error"));
+    mixin(test("Exception", "throw_range_error"));
+    mixin(test("Exception", "throw_runtime_error"));
+    mixin(test("Exception", "throw_underflow_error"));
+  }
+}
+
+char[] test(char[] e, char[] f) {
+  return "if (!works!(" ~ e ~ ")(&" ~ f ~ ")) {\n" ~
+    "throw new Exception(\"" ~ f ~ " failed\");\n" ~
+  "}";
+}
+
+bool works(alias E, F)(F f) {
+  try {
+    try {
+      f();
+    } catch(E) {
+      return true;
+    }
+  } catch(Exception e) {
+    Cerr( "Received wrong exception: " ~ e.classinfo.name ).newline;
+  }
+  return false;
+}

Examples/test-suite/d/li_std_except_runme.2.d

@@ -0,0 +1,34 @@
+module li_std_except_runme;
+
+import std.exception;
+import std.stdio;
+import li_std_except.Test;
+
+void main() {
+  with (new Test()) {
+    enforce(works!(Exception)(&throw_bad_exception));
+    enforce(works!(Exception)(&throw_domain_error));
+    enforce(works!(Exception)(&throw_exception));
+    enforce(works!(Exception)(&throw_invalid_argument));
+    enforce(works!(Exception)(&throw_length_error));
+    enforce(works!(Exception)(&throw_logic_error));
+    enforce(works!(Exception)(&throw_out_of_range));
+    enforce(works!(Exception)(&throw_overflow_error));
+    enforce(works!(Exception)(&throw_range_error));
+    enforce(works!(Exception)(&throw_runtime_error));
+    enforce(works!(Exception)(&throw_underflow_error));
+  }
+}
+
+bool works(alias E, F)(F f) {
+  try {
+    try {
+      f();
+    } catch(E) {
+      return true;
+    }
+  } catch(Exception e) {
+    writefln( "Received wrong exception: %s", e.classinfo.name );
+  }
+  return false;
+}

Examples/test-suite/d/li_std_string_runme.1.d

@@ -0,0 +1,97 @@
+module li_std_string_runme;
+
+import tango.core.Exception;
+import li_std_string.li_std_string;
+import li_std_string.Structure;
+import li_std_string.SWIGTYPE_p_std__string;
+
+
+void main() {
+  // Checking expected use of %typemap(in) std::string {}
+  test_value("Fee");
+
+  // Checking expected result of %typemap(out) std::string {}
+  if (test_value("Fi") != "Fi")
+      throw new Exception("Test 1 failed");
+
+  // Verify type-checking for %typemap(in) std::string {}
+  try {
+      test_value(null);
+      throw new Exception("Test 2 failed");
+  } catch (IllegalArgumentException) {
+  }
+
+  // Checking expected use of %typemap(in) const std::string & {}
+  test_const_reference("Fo");
+
+  // Checking expected result of %typemap(out) const std::string& {}
+  if (test_const_reference("Fum") != "Fum")
+      throw new Exception("Test 3 failed");
+
+  // Verify type-checking for %typemap(in) const std::string & {}
+  try {
+      test_const_reference(null);
+      throw new Exception("Test 4 failed");
+  } catch (IllegalArgumentException) {
+  }
+
+  // Input and output typemaps for pointers and non-const references to
+  // std::string are *not* supported; the following tests confirm
+  // that none of these cases are slipping through.
+
+  SWIGTYPE_p_std__string stringPtr = null;
+
+  stringPtr = test_pointer_out();
+  test_pointer(stringPtr);
+
+  stringPtr = test_const_pointer_out();
+  test_const_pointer(stringPtr);
+
+  stringPtr = test_reference_out();
+  test_reference(stringPtr);
+
+  // Check throw exception specification
+  try {
+      test_throw();
+      throw new Exception("test 5 failed!");
+  } catch (Exception e) {
+    if (e.msg != "test_throw message")
+      throw new Exception("Test 5 string check: " ~ e.msg);
+  }
+  try {
+      test_const_reference_throw();
+      throw new Exception("test 6 failed!");
+  } catch (Exception e) {
+    if (e.msg != "test_const_reference_throw message")
+      throw new Exception("Test 6 string check: " ~ e.msg);
+  }
+
+  // Global variables.
+  const char[] s = "initial string";
+  if (GlobalString2 != "global string 2")
+    throw new Exception("GlobalString2 test 1");
+  GlobalString2 = s;
+  if (GlobalString2 != s)
+    throw new Exception("GlobalString2 test 2");
+  if (ConstGlobalString != "const global string")
+    throw new Exception("ConstGlobalString test");
+
+  // Member variables.
+  auto myStructure = new Structure();
+  if (myStructure.MemberString2 != "member string 2")
+    throw new Exception("MemberString2 test 1");
+  myStructure.MemberString2 = s;
+  if (myStructure.MemberString2 != s)
+    throw new Exception("MemberString2 test 2");
+  if (myStructure.ConstMemberString != "const member string")
+    throw new Exception("ConstMemberString test");
+
+  // Static member variables.
+  if (Structure.StaticMemberString2 != "static member string 2")
+    throw new Exception("StaticMemberString2 test 1");
+  Structure.StaticMemberString2 = s;
+  if (Structure.StaticMemberString2 != s)
+    throw new Exception("StaticMemberString2 test 2");
+  if (Structure.ConstStaticMemberString != "const static member string")
+    throw new Exception("ConstStaticMemberString test");
+}

Examples/test-suite/d/li_std_string_runme.2.d

@@ -0,0 +1,86 @@
+module li_std_string_runme;
+
+import std.exception;
+import li_std_string.li_std_string;
+import li_std_string.Structure;
+import li_std_string.SWIGTYPE_p_std__string;
+
+void main() {
+  // Checking expected use of %typemap(in) std::string {}
+  test_value("Fee");
+
+  // Checking expected result of %typemap(out) std::string {}
+  enforce(test_value("Fi") == "Fi", "Test 1 failed");
+
+  // Verify type-checking for %typemap(in) std::string {}
+  enforceThrows( (){ test_value(null); }, "Test 2 failed.");
+
+  // Checking expected use of %typemap(in) const std::string & {}
+  test_const_reference("Fo");
+
+  // Checking expected result of %typemap(out) const std::string& {}
+  enforce(test_const_reference("Fum") == "Fum", "Test 3 failed");
+
+  // Verify type-checking for %typemap(in) const std::string & {}
+  enforceThrows( (){ test_const_reference(null); }, "Test 4 failed.");
+
+  // Input and output typemaps for pointers and non-const references to
+  // std::string are *not* supported; the following tests confirm
+  // that none of these cases are slipping through.
+
+  SWIGTYPE_p_std__string stringPtr = null;
+
+  stringPtr = test_pointer_out();
+  test_pointer(stringPtr);
+
+  stringPtr = test_const_pointer_out();
+  test_const_pointer(stringPtr);
+
+  stringPtr = test_reference_out();
+  test_reference(stringPtr);
+
+  // Check throw exception specification
+  try {
+    test_throw();
+    throw new Exception("test 5 failed!");
+  } catch (Exception e) {
+    enforce(e.msg == "test_throw message", "Test 5 string check: " ~ e.msg);
+  }
+  try {
+    test_const_reference_throw();
+    throw new Exception("test 6 failed!");
+  } catch (Exception e) {
+    enforce(e.msg == "test_const_reference_throw message", "Test 6 string check: " ~ e.msg);
+  }
+
+  // Global variables.
+  const string s = "initial string";
+  enforce(GlobalString2 == "global string 2", "GlobalString2 test 1");
+  GlobalString2 = s;
+  enforce(GlobalString2 == s, "GlobalString2 test 2");
+  enforce(ConstGlobalString == "const global string", "ConstGlobalString test");
+
+  // Member variables.
+  auto myStructure = new Structure();
+  enforce(myStructure.MemberString2 == "member string 2", "MemberString2 test 1");
+  myStructure.MemberString2 = s;
+  enforce(myStructure.MemberString2 == s, "MemberString2 test 2");
+  enforce(myStructure.ConstMemberString == "const member string", "ConstMemberString test");
+
+  // Static member variables.
+  enforce(Structure.StaticMemberString2 == "static member string 2", "StaticMemberString2 test 1");
+  Structure.StaticMemberString2 = s;
+  enforce(Structure.StaticMemberString2 == s, "StaticMemberString2 test 2");
+  enforce(Structure.ConstStaticMemberString == "const static member string", "ConstStaticMemberString test");
+}
+
+private void enforceThrows(void delegate() dg, string errorMessage) {
+  bool hasThrown;
+  try {
+    dg();
+  } catch (Exception) {
+    hasThrown = true;
+  } finally {
+    enforce(hasThrown, errorMessage);
+  }
+}

Examples/test-suite/d/li_std_vector_runme.1.d

@@ -0,0 +1,219 @@
+module li_std_vector_runme;
+
+import tango.core.Exception;
+import tango.io.Stdout;
+import Integer = tango.text.convert.Integer;
+import li_std_vector.li_std_vector;
+import li_std_vector.DoubleVector;
+import li_std_vector.IntVector;
+import li_std_vector.IntPtrVector;
+import li_std_vector.IntConstPtrVector;
+import li_std_vector.RealVector;
+import li_std_vector.Struct;
+import li_std_vector.StructVector;
+import li_std_vector.StructPtrVector;
+import li_std_vector.StructConstPtrVector;
+
+const size_t SIZE = 20;
+
+void main() {
+  // Basic functionality tests.
+  {
+    auto vector = new IntVector();
+    for (size_t i = 0; i < SIZE; ++i) {
+      vector ~= i * 10;
+    }
+
+    if (vector.length != SIZE) {
+      throw new Exception("length test failed.");
+    }
+
+    vector[0] = 200;
+    if (vector[0] != 200) {
+      throw new Exception("indexing test failed");
+    }
+    vector[0] = 0 * 10;
+
+    try {
+      vector[vector.length] = 777;
+      throw new Exception("out of range test failed");
+    } catch (NoSuchElementException) {
+    }
+
+    foreach (i, value; vector) {
+      if (value != (i * 10)) {
+	throw new Exception("foreach test failed, i: " ~ Integer.toString(i));
+      }
+    }
+
+    vector.clear();
+    if (vector.size != 0) {
+      throw new Exception("clear test failed");
+    }
+  }
+
+  // Slice tests.
+  {
+    auto dVector = new DoubleVector();
+    for (size_t i = 0; i < SIZE; ++i) {
+      dVector ~= i * 10.1f;
+    }
+
+    double[] dArray = dVector[];
+    foreach (i, value; dArray) {
+      if (dVector[i] != value) {
+	throw new Exception("slice test 1 failed, i: " ~ Integer.toString(i));
+      }
+    }
+
+
+    auto sVector = new StructVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      sVector ~= new Struct(i / 10.0);
+    }
+
+    Struct[] array = sVector[];
+
+    for (size_t i = 0; i < SIZE; i++) {
+      // Make sure that a shallow copy has been made.
+      void* aPtr = Struct.swigGetCPtr(array[i]);
+      void* vPtr = Struct.swigGetCPtr(sVector[i]);
+      if (aPtr != vPtr) {
+	throw new Exception("slice test 2 failed, i: " ~
+	  Integer.toString(i));
+      }
+    }
+  }
+
+  // remove() tests.
+  {
+    auto iVector = new IntVector();
+    for (int i = 0; i < SIZE; i++) {
+      iVector ~= i;
+    }
+
+    iVector.remove(iVector.length - 1);
+    iVector.remove(SIZE / 2);
+    iVector.remove(0);
+
+    try {
+      iVector.remove(iVector.size);
+      throw new Exception("remove test failed");
+    } catch (NoSuchElementException) {
+    }
+  }
+
+  // Capacity tests.
+  {
+    auto dv = new DoubleVector(10);
+    if ((dv.capacity != 10) || (dv.length != 0)) {
+      throw new Exception("constructor setting capacity test failed");
+    }
+
+    // TODO: Is this really required (and spec'ed) behavior?
+    dv.capacity = 20;
+    if (dv.capacity != 20) {
+      throw new Exception("capacity test 1 failed");
+    }
+
+    dv ~= 1.11;
+    try {
+      dv.capacity = dv.length - 1;
+      throw new Exception("capacity test 2 failed");
+    } catch (IllegalArgumentException) {
+    }
+  }
+
+  // Test the methods being wrapped.
+  {
+    auto iv = new IntVector();
+    for (int i=0; i<4; i++) {
+      iv ~= i;
+    }
+
+    double x = average(iv);
+    x += average(new IntVector([1, 2, 3, 4]));
+    RealVector rv = half(new RealVector([10.0f, 10.5f, 11.0f, 11.5f]));
+
+    auto dv = new DoubleVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      dv ~= i / 2.0;
+    }
+    halve_in_place(dv);
+
+    RealVector v0 = vecreal(new RealVector());
+    float flo = 123.456f;
+    v0 ~= flo;
+    flo = v0[0];
+
+    IntVector v1 = vecintptr(new IntVector());
+    IntPtrVector v2 = vecintptr(new IntPtrVector());
+    IntConstPtrVector v3 = vecintconstptr(new IntConstPtrVector());
+
+    v1 ~= 123;
+    v2.clear();
+    v3.clear();
+
+    StructVector v4 = vecstruct(new StructVector());
+    StructPtrVector v5 = vecstructptr(new StructPtrVector());
+    StructConstPtrVector v6 = vecstructconstptr(new StructConstPtrVector());
+
+    v4 ~= new Struct(123);
+    v5 ~= new Struct(123);
+    v6 ~= new Struct(123);
+  }
+
+  // Test vectors of pointers.
+  {
+    auto vector = new StructPtrVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      vector ~= new Struct(i / 10.0);
+    }
+
+    Struct[] array = vector[];
+
+    for (size_t i = 0; i < SIZE; i++) {
+      // Make sure that a shallow copy has been made.
+      void* aPtr = Struct.swigGetCPtr(array[i]);
+      void* vPtr = Struct.swigGetCPtr(vector[i]);
+      if (aPtr != vPtr) {
+	throw new Exception("StructPtrVector test 1 failed, i: " ~
+	  Integer.toString(i));
+      }
+    }
+  }
+
+  // Test vectors of const pointers.
+  {
+    auto vector = new StructConstPtrVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      vector ~= new Struct(i / 10.0);
+    }
+
+    Struct[] array = vector[];
+
+    for (size_t i = 0; i < SIZE; i++) {
+      // Make sure that a shallow copy has been made.
+      void* aPtr = Struct.swigGetCPtr(array[i]);
+      void* vPtr = Struct.swigGetCPtr(vector[i]);
+      if (aPtr != vPtr) {
+	throw new Exception("StructConstPtrVector test 1 failed, i: " ~
+	  Integer.toString(i));
+      }
+    }
+  }
+
+  // Test vectors destroyed via dispose().
+  {
+    {
+      scope vector = new StructVector();
+      vector ~= new Struct(0.0);
+      vector ~= new Struct(11.1);
+    }
+    {
+      scope vector = new DoubleVector();
+      vector ~= 0.0;
+      vector ~= 11.1;
+    }
+  }
+}

Examples/test-suite/d/li_std_vector_runme.2.d

@@ -0,0 +1,207 @@
+module li_std_vector_runme;
+
+import std.algorithm;
+import std.array;
+import std.conv;
+import std.exception;
+import std.stdio;
+import li_std_vector.li_std_vector;
+import li_std_vector.DoubleVector;
+import li_std_vector.IntVector;
+import li_std_vector.IntPtrVector;
+import li_std_vector.IntConstPtrVector;
+import li_std_vector.RealVector;
+import li_std_vector.Struct;
+import li_std_vector.StructVector;
+import li_std_vector.StructPtrVector;
+import li_std_vector.StructConstPtrVector;
+
+const size_t SIZE = 20;
+
+void main() {
+  // Basic functionality tests.
+  {
+    auto vector = new IntVector();
+    for (size_t i = 0; i < SIZE; ++i) {
+      vector ~= i * 10;
+    }
+
+    enforce(vector.length == SIZE, "length test failed.");
+
+    vector[0] = 200;
+    enforce(vector[0] == 200, "indexing test failed");
+    vector[0] = 0 * 10;
+
+    enforceThrows((){ vector[vector.length] = 777; }, "out of range test failed" );
+
+    foreach (i, value; vector) {
+      enforce(value == (i * 10), "foreach test failed, i: " ~ to!string(i));
+    }
+
+    enforce(canFind!`a == 0 * 10`(vector[]), "canFind test 1 failed");
+    enforce(canFind!`a == 10 * 10`(vector[]), "canFind test 2 failed");
+    enforce(canFind!`a == 19 * 10`(vector[]), "canFind test 3 failed");
+    enforce(!canFind!`a == 20 * 10`(vector[]), "canFind test 4 failed");
+
+    foreach (i, _; vector) {
+      enforce(indexOf(vector[], i * 10) == i, "indexOf test failed, i: " ~ to!string(i));
+    }
+
+    enforce(indexOf(vector[], 42) == -1, "non-existant item indexOf test failed");
+
+    vector.clear();
+    enforce(vector.length == 0, "clear test failed");
+  }
+
+  // To array conversion tests.
+  {
+    auto dVector = new DoubleVector();
+    for (size_t i = 0; i < SIZE; ++i) {
+      dVector ~= i * 10.1f;
+    }
+
+    double[] dArray = array(dVector[]);
+    foreach (i, value; dArray) {
+      enforce(dVector[i] == value, "slice test 1 failed, i: " ~ to!string(i));
+    }
+
+
+    auto sVector = new StructVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      sVector ~= new Struct(i / 10.0);
+    }
+
+    Struct[] sArray = array(sVector[]);
+
+    for (size_t i = 0; i < SIZE; i++) {
+      // Make sure that a shallow copy has been made.
+      void* aPtr = Struct.swigGetCPtr(sArray[i]);
+      void* vPtr = Struct.swigGetCPtr(sVector[i]);
+      enforce(aPtr == vPtr, "slice test 2 failed, i: " ~ to!string(i));
+    }
+  }
+
+  // remove() tests.
+  {
+    auto iVector = new IntVector();
+    for (int i = 0; i < SIZE; i++) {
+      iVector ~= i;
+    }
+
+    iVector.remove(iVector.length - 1);
+    iVector.remove(SIZE / 2);
+    iVector.remove(0);
+
+    enforceThrows((){ iVector.remove(iVector.length); }, "remove test failed");
+  }
+
+  // Capacity tests.
+  {
+    auto dv = new DoubleVector(10);
+    enforce(dv.capacity == 10, "constructor setting capacity test failed (1)");
+    enforce(dv.length == 0, "constructor setting capacity test failed (1)");
+
+    dv.reserve(20);
+    enforce(dv.capacity == 20, "capacity test failed");
+  }
+
+  // Test the methods being wrapped.
+  {
+    auto iv = new IntVector();
+    for (int i=0; i<4; i++) {
+      iv ~= i;
+    }
+
+    double x = average(iv);
+    x += average(new IntVector([1, 2, 3, 4]));
+    RealVector rv = half(new RealVector([10.0f, 10.5f, 11.0f, 11.5f]));
+
+    auto dv = new DoubleVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      dv ~= i / 2.0;
+    }
+    halve_in_place(dv);
+
+    RealVector v0 = vecreal(new RealVector());
+    float flo = 123.456f;
+    v0 ~= flo;
+    flo = v0[0];
+
+    IntVector v1 = vecintptr(new IntVector());
+    IntPtrVector v2 = vecintptr(new IntPtrVector());
+    IntConstPtrVector v3 = vecintconstptr(new IntConstPtrVector());
+
+    v1 ~= 123;
+    v2.clear();
+    v3.clear();
+
+    StructVector v4 = vecstruct(new StructVector());
+    StructPtrVector v5 = vecstructptr(new StructPtrVector());
+    StructConstPtrVector v6 = vecstructconstptr(new StructConstPtrVector());
+
+    v4 ~= new Struct(123);
+    v5 ~= new Struct(123);
+    v6 ~= new Struct(123);
+  }
+
+  // Test vectors of pointers.
+  {
+    auto vector = new StructPtrVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      vector ~= new Struct(i / 10.0);
+    }
+
+    Struct[] array = array(vector[]);
+
+    for (size_t i = 0; i < SIZE; i++) {
+      // Make sure that a shallow copy has been made.
+      void* aPtr = Struct.swigGetCPtr(array[i]);
+      void* vPtr = Struct.swigGetCPtr(vector[i]);
+      enforce(aPtr == vPtr, "StructConstPtrVector test 1 failed, i: " ~ to!string(i));
+    }
+  }
+
+  // Test vectors of const pointers.
+  {
+    auto vector = new StructConstPtrVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      vector ~= new Struct(i / 10.0);
+    }
+
+    Struct[] array = array(vector[]);
+
+    for (size_t i = 0; i < SIZE; i++) {
+      // Make sure that a shallow copy has been made.
+      void* aPtr = Struct.swigGetCPtr(array[i]);
+      void* vPtr = Struct.swigGetCPtr(vector[i]);
+      enforce(aPtr == vPtr, "StructConstPtrVector test 1 failed, i: " ~ to!string(i));
+    }
+  }
+
+  // Test vectors destroyed via scope.
+  {
+    {
+      scope vector = new StructVector();
+      vector ~= new Struct(0.0);
+      vector ~= new Struct(11.1);
+    }
+    {
+      scope vector = new DoubleVector();
+      vector ~= 0.0;
+      vector ~= 11.1;
+    }
+  }
+}
+
+private void enforceThrows(void delegate() dg, string errorMessage) {
+  bool hasThrown;
+  try {
+    dg();
+  } catch (Exception) {
+    hasThrown = true;
+  } finally {
+    if (!hasThrown) {
+      throw new Exception(errorMessage);
+    }
+  }
+}

Examples/test-suite/d/li_typemaps_runme.1.d

@@ -0,0 +1,94 @@
+/// Tests correct handling of a few INPUT/OUTPUT/INOUT-typemapped functions.
+module li_typemaps_runme;
+
+import li_typemaps.li_typemaps;
+
+void main() {
+  // Check double INPUT typemaps
+  if (in_double(22.22) != 22.22) raiseError("in_double");
+  if (inr_double(22.22) != 22.22) raiseError("inr_double");
+
+  // Check double OUTPUT typemaps
+  {
+    double var = 44.44;
+    out_double(22.22, var);
+    if (var != 22.22) raiseError("out_double");
+  }
+  {
+    double var = 44.44;
+    outr_double(22.22, var);
+    if (var != 22.22) raiseError("outr_double");
+  }
+
+  // Check double INOUT typemaps
+  {
+    double var = 44.44;
+    inout_double(var);
+    if (var != 44.44) raiseError("inout_double");
+  }
+  {
+    double var = 44.44;
+    inoutr_double(var);
+    if (var != 44.44) raiseError("inoutr_double");
+  }
+
+  // Check unsigned long long INPUT typemaps
+  if (in_ulonglong(20) != 20) raiseError("in_ulonglong");
+  if (inr_ulonglong(20) != 20) raiseError("inr_ulonglong");
+
+  // Check unsigned long long OUTPUT typemaps
+  {
+    ulong var = 40;
+    out_ulonglong(20, var);
+    if (var != 20) raiseError("out_ulonglong");
+  }
+  {
+    ulong var = 40;
+    outr_ulonglong(20, var);
+    if (var != 20) raiseError("outr_ulonglong");
+  }
+
+  // Check unsigned long long INOUT typemaps
+  {
+    ulong var = 40;
+    inout_ulonglong(var);
+    if (var != 40) raiseError("inout_ulonglong");
+  }
+  {
+    ulong var = 40;
+    inoutr_ulonglong(var);
+    if (var != 40) raiseError("inoutr_ulonglong");
+  }
+
+  // Check unsigned bool INPUT typemaps
+  if (in_bool(false) != false) raiseError("in_bool");
+  if (inr_bool(false) != false) raiseError("inr_bool");
+
+  // Check unsigned bool OUTPUT typemaps
+  {
+    bool var = false;
+    out_bool(true, var);
+    if (var != true) raiseError("out_bool");
+  }
+  {
+    bool var = false;
+    outr_bool(true, var);
+    if (var != true) raiseError("outr_bool");
+  }
+
+  // Check unsigned bool INOUT typemaps
+  {
+    bool var = false;
+    inout_bool(var);
+    if (var != false) raiseError("inout_bool");
+  }
+  {
+    bool var = false;
+    inoutr_bool(var);
+    if (var != false) raiseError("inoutr_bool");
+  }
+}
+
+void raiseError(char[] funcName) {
+  throw new Exception("Test FAILED for function " ~ funcName);
+}

Examples/test-suite/d/li_typemaps_runme.2.d

@@ -0,0 +1,91 @@
+/// Tests correct handling of a few INPUT/OUTPUT/INOUT-typemapped functions.
+module li_typemaps_runme;
+
+import std.exception;
+import li_typemaps.li_typemaps;
+
+void main() {
+  // Check double INPUT typemaps
+  enforce(in_double(22.22) == 22.22, "in_double");
+  enforce(inr_double(22.22) == 22.22, "inr_double");
+
+  // Check double OUTPUT typemaps
+  {
+    double var = 44.44;
+    out_double(22.22, var);
+    enforce(var == 22.22, "out_double");
+  }
+  {
+    double var = 44.44;
+    outr_double(22.22, var);
+    enforce(var == 22.22, "outr_double");
+  }
+
+  // Check double INOUT typemaps
+  {
+    double var = 44.44;
+    inout_double(var);
+    enforce(var == 44.44, "inout_double");
+  }
+  {
+    double var = 44.44;
+    inoutr_double(var);
+    enforce(var == 44.44, "inoutr_double");
+  }
+
+  // Check unsigned long long INPUT typemaps
+  enforce(in_ulonglong(20) == 20, "in_ulonglong");
+  enforce(inr_ulonglong(20) == 20, "inr_ulonglong");
+
+  // Check unsigned long long OUTPUT typemaps
+  {
+    ulong var = 40;
+    out_ulonglong(20, var);
+    enforce(var == 20, "out_ulonglong");
+  }
+  {
+    ulong var = 40;
+    outr_ulonglong(20, var);
+    enforce(var == 20, "outr_ulonglong");
+  }
+
+  // Check unsigned long long INOUT typemaps
+  {
+    ulong var = 40;
+    inout_ulonglong(var);
+    enforce(var == 40, "inout_ulonglong");
+  }
+  {
+    ulong var = 40;
+    inoutr_ulonglong(var);
+    enforce(var == 40, "inoutr_ulonglong");
+  }
+
+  // Check unsigned bool INPUT typemaps
+  enforce(in_bool(false) == false, "in_bool");
+  enforce(inr_bool(false) == false, "inr_bool");
+
+  // Check unsigned bool OUTPUT typemaps
+  {
+    bool var = false;
+    out_bool(true, var);
+    enforce(var == true, "out_bool");
+  }
+  {
+    bool var = false;
+    outr_bool(true, var);
+    enforce(var == true, "outr_bool");
+  }
+
+  // Check unsigned bool INOUT typemaps
+  {
+    bool var = false;
+    inout_bool(var);
+    enforce(var == false, "inout_bool");
+  }
+  {
+    bool var = false;
+    inoutr_bool(var);
+    enforce(var == false, "inoutr_bool");
+  }
+}

Examples/test-suite/d/long_long_runme.1.d

@@ -0,0 +1,35 @@
+// Checks if the long long and unsigned long long types work.
+module long_long_runme;
+
+import Integer = tango.text.convert.Integer;
+import long_long.long_long;
+
+void main() {
+  check_ll(0L);
+  check_ll(0x7FFFFFFFFFFFFFFFL);
+  check_ll(-10L);
+
+  check_ull(0u);
+  check_ull(127u);
+  check_ull(128u);
+  check_ull(9223372036854775807u); //0x7FFFFFFFFFFFFFFFL
+  check_ull(18446744073709551615u); //0xFFFFFFFFFFFFFFFFL
+}
+
+void check_ll(long value) {
+  ll = value;
+  long value_check = ll;
+  if (value != value_check) {
+    throw new Exception("Runtime test using long long failed: expected: " ~
+      Integer.toString(value) ~ ", got: " ~ Integer.toString(value_check));
+  }
+}
+
+void check_ull(ulong value) {
+  ull = value;
+  ulong value_check = ull;
+  if (value != value_check) {
+    throw new Exception( "Runtime test using unsigned long long failed: expected: " ~
+      Integer.toString(value) ~ ", ll_check=" ~ Integer.toString(value_check));
+  }
+}

Examples/test-suite/d/long_long_runme.2.d

@@ -0,0 +1,32 @@
+// Checks if the long long and unsigned long long types work.
+module long_long_runme;
+
+import std.conv;
+import std.exception;
+import long_long.long_long;
+
+void main() {
+  check_ll(0L);
+  check_ll(0x7FFFFFFFFFFFFFFFL);
+  check_ll(-10L);
+
+  check_ull(0u);
+  check_ull(127u);
+  check_ull(128u);
+  check_ull(9223372036854775807u); //0x7FFFFFFFFFFFFFFFL
+  check_ull(18446744073709551615u); //0xFFFFFFFFFFFFFFFFL
+}
+
+void check_ll(long value) {
+  ll = value;
+  long value_check = ll;
+  enforce(value == value_check, "Runtime test using long long failed: expected: " ~
+    to!string(value) ~ ", got: " ~ to!string(value_check));
+}
+
+void check_ull(ulong value) {
+  ull = value;
+  ulong value_check = ull;
+  enforce(value == value_check, "Runtime test using unsigned long long failed: expected: " ~
+      to!string(value) ~ ", ll_check=" ~ to!string(value_check));
+}

Examples/test-suite/d/member_pointer_runme.1.d

@@ -0,0 +1,43 @@
+module member_pointer_runme;
+
+import Float = tango.text.convert.Float;
+import member_pointer.member_pointer;
+import member_pointer.Square;
+import member_pointer.SWIGTYPE_m_Shape__f_void__double;
+
+void main() {
+  auto s = new Square(10);
+
+  // Do some calculations
+  auto area_pt = areapt();
+  auto perim_pt = perimeterpt();
+  check("Square area ", 100.0, do_op(s, area_pt));
+  check("Square perim", 40.0, do_op(s, perim_pt));
+
+  SWIGTYPE_m_Shape__f_void__double memberPtr = null;
+  memberPtr = areavar;
+  memberPtr = perimetervar;
+
+  // Try the variables
+  check("Square area ", 100.0, do_op(s, areavar));
+  check("Square perim", 40.0, do_op(s, perimetervar));
+
+  // Modify one of the variables
+  areavar = perim_pt;
+  check("Square perimeter", 40.0, do_op(s,areavar));
+
+  // Try the constants
+  memberPtr = AREAPT;
+  memberPtr = PERIMPT;
+  memberPtr = NULLPT;
+
+  check("Square area", 100.0, do_op(s, AREAPT));
+  check("Square perim", 40.0, do_op(s, PERIMPT));
+}
+
+void check(char[] what, double expected, double actual) {
+  if (expected != actual) {
+    throw new Exception("Failed: " ~ what ~ ": expected "
+      ~ Float.toString(expected) ~ ", but got " ~ Float.toString(actual));
+  }
+}

Examples/test-suite/d/member_pointer_runme.2.d

@@ -0,0 +1,42 @@
+module member_pointer_runme;
+
+import std.conv;
+import std.exception;
+import member_pointer.member_pointer;
+import member_pointer.Square;
+import member_pointer.SWIGTYPE_m_Shape__f_void__double;
+
+void main() {
+  auto s = new Square(10);
+
+  // Do some calculations
+  auto area_pt = areapt();
+  auto perim_pt = perimeterpt();
+  check("Square area", 100.0, do_op(s, area_pt));
+  check("Square perim", 40.0, do_op(s, perim_pt));
+
+  SWIGTYPE_m_Shape__f_void__double memberPtr = null;
+  memberPtr = areavar;
+  memberPtr = perimetervar;
+
+  // Try the variables
+  check("Square area", 100.0, do_op(s, areavar));
+  check("Square perim", 40.0, do_op(s, perimetervar));
+
+  // Modify one of the variables
+  areavar = perim_pt;
+  check("Square perimeter", 40.0, do_op(s,areavar));
+
+  // Try the constants
+  memberPtr = AREAPT;
+  memberPtr = PERIMPT;
+  memberPtr = NULLPT;
+
+  check("Square area", 100.0, do_op(s, AREAPT));
+  check("Square perim", 40.0, do_op(s, PERIMPT));
+}
+
+void check(string what, double expected, double actual) {
+  enforce(expected == actual, "Failed: " ~ what ~ ": expected " ~
+    to!string(expected) ~ ", but got " ~ to!string(actual));
+}

Examples/test-suite/d/overload_complicated_runme.1.d

@@ -0,0 +1,50 @@
+module overload_complicated_runme;
+
+import overload_complicated;
+
+void main() {
+  SWIGTYPE_p_int pInt = null;
+
+  // Check the correct constructors are available
+  Pop p = new Pop(pInt);
+
+  p = new Pop(pInt, false);
+
+  // Check overloaded in const only and pointers/references which target languages cannot disambiguate
+  if (p.hip(false) != 701)
+    throw new Exception("Test 1 failed");
+
+  if (p.hip(pInt) != 702)
+    throw new Exception("Test 2 failed");
+
+  // Reverse the order for the above
+  if (p.hop(pInt) != 805)
+    throw new Exception("Test 3 failed");
+
+  if (p.hop(false) != 801)
+    throw new Exception("Test 4 failed");
+
+  // Few more variations and order shuffled
+  if (p.pop(false) != 901)
+    throw new Exception("Test 5 failed");
+
+  if (p.pop(pInt) != 902)
+    throw new Exception("Test 6 failed");
+
+  if (p.pop() != 905)
+    throw new Exception("Test 7 failed");
+
+  // Overload on const only
+  if (p.bop(pInt) != 1001)
+    throw new Exception("Test 8 failed");
+
+  if (p.bip(pInt) != 2001)
+    throw new Exception("Test 9 failed");
+
+  // Globals
+  if (muzak(false) != 3001)
+    throw new Exception("Test 10 failed");
+
+  if (muzak(pInt) != 3002)
+    throw new Exception("Test 11 failed");
+}

Examples/test-suite/d/overload_complicated_runme.2.d

@@ -0,0 +1,34 @@
+module overload_complicated_runme;
+
+import std.exception;
+import overload_complicated.overload_complicated;
+import overload_complicated.Pop;
+
+void main() {
+  int* pInt = new int;
+
+  // Check the correct constructors are available
+  auto p = new Pop(pInt);
+  p = new Pop(pInt, false);
+
+  // Check overloaded in const only and pointers/references which target languages cannot disambiguate
+  enforce(p.hip(false) == 701, "Test 1 failed");
+  enforce(p.hip(pInt) == 702, "Test 2 failed");
+
+  // Reverse the order for the above
+  enforce(p.hop(pInt) == 805, "Test 3 failed");
+  enforce(p.hop(false) == 801, "Test 4 failed");
+
+  // Few more variations and order shuffled
+  enforce(p.pop(false) == 901, "Test 5 failed");
+  enforce(p.pop(pInt) == 902, "Test 6 failed");
+  enforce(p.pop() == 905, "Test 7 failed");
+
+  // Overload on const only
+  enforce(p.bop(pInt) == 1001, "Test 8 failed");
+  enforce(p.bip(pInt) == 2001, "Test 9 failed");
+
+  // Globals
+  enforce(muzak(false) == 3001, "Test 10 failed");
+  enforce(muzak(pInt) == 3002, "Test 11 failed");
+}

Examples/test-suite/d/overload_template_runme.1.d

@@ -0,0 +1,146 @@
+module overload_template_runme;
+
+import overload_template.overload_template;
+import overload_template.Klass;
+
+void main() {
+  int f = foo();
+
+  f += maximum(3,4);
+  double b = maximum(3.4,5.2);
+  b++; // warning suppression
+
+  // mix 1
+  if (mix1("hi") != 101)
+    throw new Exception ("mix1(const char*)");
+
+  if (mix1(1.0, 1.0) != 102)
+    throw new Exception ("mix1(double, const double &)");
+
+  if (mix1(1.0) != 103)
+    throw new Exception ("mix1(double)");
+
+  // mix 2
+  if (mix2("hi") != 101)
+    throw new Exception ("mix2(const char*)");
+
+  if (mix2(1.0, 1.0) != 102)
+    throw new Exception ("mix2(double, const double &)");
+
+  if (mix2(1.0) != 103)
+    throw new Exception ("mix2(double)");
+
+  // mix 3
+  if (mix3("hi") != 101)
+    throw new Exception ("mix3(const char*)");
+
+  if (mix3(1.0, 1.0) != 102)
+    throw new Exception ("mix3(double, const double &)");
+
+  if (mix3(1.0) != 103)
+    throw new Exception ("mix3(double)");
+
+  // Combination 1
+  if (overtparams1(100) != 10)
+    throw new Exception ("overtparams1(int)");
+
+  if (overtparams1(100.0, 100) != 20)
+    throw new Exception ("overtparams1(double, int)");
+
+  // Combination 2
+  if (overtparams2(100.0, 100) != 40)
+    throw new Exception ("overtparams2(double, int)");
+
+  // Combination 3
+  if (overloaded() != 60)
+    throw new Exception ("overloaded()");
+
+  if (overloaded(100.0, 100) != 70)
+    throw new Exception ("overloaded(double, int)");
+
+  // Combination 4
+  if (overloadedagain("hello") != 80)
+    throw new Exception ("overloadedagain(const char *)");
+
+  if (overloadedagain() != 90)
+    throw new Exception ("overloadedagain(double)");
+
+  // specializations
+  if (specialization(10) != 202)
+    throw new Exception ("specialization(int)");
+
+  if (specialization(10.0) != 203)
+    throw new Exception ("specialization(double)");
+
+  if (specialization(10, 10) != 204)
+    throw new Exception ("specialization(int, int)");
+
+  if (specialization(10.0, 10.0) != 205)
+    throw new Exception ("specialization(double, double)");
+
+  if (specialization("hi", "hi") != 201)
+    throw new Exception ("specialization(const char *, const char *)");
+
+  // simple specialization
+  xyz();
+  xyz_int();
+  xyz_double();
+
+  // a bit of everything
+  if (overload("hi") != 0)
+    throw new Exception ("overload()");
+
+  if (overload(1) != 10)
+    throw new Exception ("overload(int t)");
+
+  if (overload(1, 1) != 20)
+    throw new Exception ("overload(int t, const int &)");
+
+  if (overload(1, "hello") != 30)
+    throw new Exception ("overload(int t, const char *)");
+
+  auto k = new Klass();
+  if (overload(k) != 10)
+    throw new Exception ("overload(Klass t)");
+
+  if (overload(k, k) != 20)
+    throw new Exception ("overload(Klass t, const Klass &)");
+
+  if (overload(k, "hello") != 30)
+    throw new Exception ("overload(Klass t, const char *)");
+
+  if (overload(10.0, "hi") != 40)
+    throw new Exception ("overload(double t, const char *)");
+
+  if (overload() != 50)
+    throw new Exception ("overload(const char *)");
+
+
+  // everything put in a namespace
+  if (nsoverload("hi") != 1000)
+    throw new Exception ("nsoverload()");
+
+  if (nsoverload(1) != 1010)
+    throw new Exception ("nsoverload(int t)");
+
+  if (nsoverload(1, 1) != 1020)
+    throw new Exception ("nsoverload(int t, const int &)");
+
+  if (nsoverload(1, "hello") != 1030)
+    throw new Exception ("nsoverload(int t, const char *)");
+
+  if (nsoverload(k) != 1010)
+    throw new Exception ("nsoverload(Klass t)");
+
+  if (nsoverload(k, k) != 1020)
+    throw new Exception ("nsoverload(Klass t, const Klass &)");
+
+  if (nsoverload(k, "hello") != 1030)
+    throw new Exception ("nsoverload(Klass t, const char *)");
+
+  if (nsoverload(10.0, "hi") != 1040)
+    throw new Exception ("nsoverload(double t, const char *)");
+
+  if (nsoverload() != 1050)
+    throw new Exception ("nsoverload(const char *)");
+}

Examples/test-suite/d/overload_template_runme.2.d

@@ -0,0 +1,80 @@
+module overload_template_runme;
+
+import std.exception;
+import overload_template.overload_template;
+import overload_template.Klass;
+
+void main() {
+  int f = foo();
+
+  f += maximum(3,4);
+  double b = maximum(3.4,5.2);
+  b++; // warning suppression
+
+  // mix 1
+  enforce(mix1("hi") == 101, "mix1(const char*)");
+  enforce(mix1(1.0, 1.0) == 102, "mix1(double, const double &)");
+  enforce(mix1(1.0) == 103, "mix1(double)");
+
+  // mix 2
+  enforce(mix2("hi") == 101, "mix2(const char*)");
+  enforce(mix2(1.0, 1.0) == 102, "mix2(double, const double &)");
+  enforce(mix2(1.0) == 103, "mix2(double)");
+
+  // mix 3
+  enforce(mix3("hi") == 101, "mix3(const char*)");
+  enforce(mix3(1.0, 1.0) == 102, "mix3(double, const double &)");
+  enforce(mix3(1.0) == 103, "mix3(double)");
+
+  // Combination 1
+  enforce(overtparams1(100) == 10, "overtparams1(int)");
+  enforce(overtparams1(100.0, 100) == 20, "overtparams1(double, int)");
+
+  // Combination 2
+  enforce(overtparams2(100.0, 100) == 40, "overtparams2(double, int)");
+
+  // Combination 3
+  enforce(overloaded() == 60, "overloaded()");
+  enforce(overloaded(100.0, 100) == 70, "overloaded(double, int)");
+
+  // Combination 4
+  enforce(overloadedagain("hello") == 80, "overloadedagain(const char *)");
+  enforce(overloadedagain() == 90, "overloadedagain(double)");
+
+  // specializations
+  enforce(specialization(10) == 202, "specialization(int)");
+  enforce(specialization(10.0) == 203, "specialization(double)");
+  enforce(specialization(10, 10) == 204, "specialization(int, int)");
+  enforce(specialization(10.0, 10.0) == 205, "specialization(double, double)");
+  enforce(specialization("hi", "hi") == 201, "specialization(const char *, const char *)");
+
+  // simple specialization
+  xyz();
+  xyz_int();
+  xyz_double();
+
+  // a bit of everything
+  enforce(overload("hi") == 0, "overload()");
+  enforce(overload(1) == 10, "overload(int t)");
+  enforce(overload(1, 1) == 20, "overload(int t, const int &)");
+  enforce(overload(1, "hello") == 30, "overload(int t, const char *)");
+
+  auto k = new Klass();
+  enforce(overload(k) == 10, "overload(Klass t)");
+  enforce(overload(k, k) == 20, "overload(Klass t, const Klass &)");
+  enforce(overload(k, "hello") == 30, "overload(Klass t, const char *)");
+  enforce(overload(10.0, "hi") == 40, "overload(double t, const char *)");
+  enforce(overload() == 50, "overload(const char *)");
+
+
+  // everything put in a namespace
+  enforce(nsoverload("hi") == 1000, "nsoverload()");
+  enforce(nsoverload(1) == 1010, "nsoverload(int t)");
+  enforce(nsoverload(1, 1) == 1020, "nsoverload(int t, const int &)");
+  enforce(nsoverload(1, "hello") == 1030, "nsoverload(int t, const char *)");
+  enforce(nsoverload(k) == 1010, "nsoverload(Klass t)");
+  enforce(nsoverload(k, k) == 1020, "nsoverload(Klass t, const Klass &)");
+  enforce(nsoverload(k, "hello") == 1030, "nsoverload(Klass t, const char *)");
+  enforce(nsoverload(10.0, "hi") == 1040, "nsoverload(double t, const char *)");
+  enforce(nsoverload() == 1050, "nsoverload(const char *)");
+}

Examples/test-suite/d/pointer_reference_runme.1.d

@@ -0,0 +1,13 @@
+module pointer_reference_runme;
+
+import pointer_reference.pointer_reference;
+import pointer_reference.Struct;
+
+void main() {
+  Struct s  = get();
+  if (s.value != 10) throw new Exception("get test failed");
+
+  Struct ss = new Struct(20);
+  set(ss);
+  if (Struct.instance.value != 20) throw new Exception("set test failed");
+}

Examples/test-suite/d/pointer_reference_runme.2.d

@@ -0,0 +1,14 @@
+module pointer_reference_runme;
+
+import std.exception;
+import pointer_reference.pointer_reference;
+import pointer_reference.Struct;
+
+void main() {
+  Struct s = get();
+  enforce(s.value == 10, "get test failed");
+
+  auto ss = new Struct(20);
+  set(ss);
+  enforce(Struct.instance.value == 20, "set test failed");
+}

Examples/test-suite/d/preproc_constants_c_runme.1.d

@@ -0,0 +1,63 @@
+module preproc_constants_c_runme;
+
+import preproc_constants_c.preproc_constants_c;
+
+// Same as preproc_constants.i testcase, but bool types are int instead.
+void main() {
+  static assert(is(int == typeof(CONST_INT1())));
+  static assert(is(int == typeof(CONST_INT2())));
+  static assert(is(uint == typeof(CONST_UINT1())));
+  static assert(is(uint == typeof(CONST_UINT2())));
+  static assert(is(uint == typeof(CONST_UINT3())));
+  static assert(is(uint == typeof(CONST_UINT4())));
+  static assert(is(int == typeof(CONST_LONG1())));
+  static assert(is(int == typeof(CONST_LONG2())));
+  static assert(is(int == typeof(CONST_LONG3())));
+  static assert(is(int == typeof(CONST_LONG4())));
+  static assert(is(long == typeof(CONST_LLONG1())));
+  static assert(is(long == typeof(CONST_LLONG2())));
+  static assert(is(long == typeof(CONST_LLONG3())));
+  static assert(is(long == typeof(CONST_LLONG4())));
+  static assert(is(ulong == typeof(CONST_ULLONG1())));
+  static assert(is(ulong == typeof(CONST_ULLONG2())));
+  static assert(is(ulong == typeof(CONST_ULLONG3())));
+  static assert(is(ulong == typeof(CONST_ULLONG4())));
+  static assert(is(double == typeof(CONST_DOUBLE1())));
+  static assert(is(double == typeof(CONST_DOUBLE2())));
+  static assert(is(double == typeof(CONST_DOUBLE3())));
+  static assert(is(double == typeof(CONST_DOUBLE4())));
+  static assert(is(double == typeof(CONST_DOUBLE5())));
+  static assert(is(double == typeof(CONST_DOUBLE6())));
+  static assert(is(int == typeof(CONST_BOOL1())));
+  static assert(is(int == typeof(CONST_BOOL2())));
+  static assert(is(char == typeof(CONST_CHAR())));
+  static assert(is(char[] == typeof(CONST_STRING1())));
+  static assert(is(char[] == typeof(CONST_STRING2())));
+
+  static assert(is(int == typeof(INT_AND_BOOL())));
+//    static assert(is(int == typeof(INT_AND_CHAR())));
+  static assert(is(int == typeof(INT_AND_INT())));
+  static assert(is(uint == typeof(INT_AND_UINT())));
+  static assert(is(int == typeof(INT_AND_LONG())));
+  static assert(is(uint == typeof(INT_AND_ULONG())));
+  static assert(is(long == typeof(INT_AND_LLONG())));
+  static assert(is(ulong == typeof(INT_AND_ULLONG())));
+  static assert(is(int == typeof(BOOL_AND_BOOL())));
+
+  static assert(is(int == typeof(EXPR_MULTIPLY())));
+  static assert(is(int == typeof(EXPR_DIVIDE())));
+  static assert(is(int == typeof(EXPR_PLUS())));
+  static assert(is(int == typeof(EXPR_MINUS())));
+  static assert(is(int == typeof(EXPR_LSHIFT())));
+  static assert(is(int == typeof(EXPR_RSHIFT())));
+  static assert(is(int == typeof(EXPR_LTE())));
+  static assert(is(int == typeof(EXPR_GTE())));
+  static assert(is(int == typeof(EXPR_INEQUALITY())));
+  static assert(is(int == typeof(EXPR_EQUALITY())));
+  static assert(is(int == typeof(EXPR_AND())));
+  static assert(is(int == typeof(EXPR_XOR())));
+  static assert(is(int == typeof(EXPR_OR())));
+  static assert(is(int == typeof(EXPR_LAND())));
+  static assert(is(int == typeof(EXPR_LOR())));
+  static assert(is(double == typeof(EXPR_CONDITIONAL())));
+}

Examples/test-suite/d/preproc_constants_c_runme.2.d

@@ -0,0 +1,63 @@
+module preproc_constants_c_runme;
+
+import preproc_constants_c.preproc_constants_c;
+
+// Same as preproc_constants.i testcase, but bool types are int instead.
+void main() {
+  static assert(is(int == typeof(CONST_INT1())));
+  static assert(is(int == typeof(CONST_INT2())));
+  static assert(is(uint == typeof(CONST_UINT1())));
+  static assert(is(uint == typeof(CONST_UINT2())));
+  static assert(is(uint == typeof(CONST_UINT3())));
+  static assert(is(uint == typeof(CONST_UINT4())));
+  static assert(is(int == typeof(CONST_LONG1())));
+  static assert(is(int == typeof(CONST_LONG2())));
+  static assert(is(int == typeof(CONST_LONG3())));
+  static assert(is(int == typeof(CONST_LONG4())));
+  static assert(is(long == typeof(CONST_LLONG1())));
+  static assert(is(long == typeof(CONST_LLONG2())));
+  static assert(is(long == typeof(CONST_LLONG3())));
+  static assert(is(long == typeof(CONST_LLONG4())));
+  static assert(is(ulong == typeof(CONST_ULLONG1())));
+  static assert(is(ulong == typeof(CONST_ULLONG2())));
+  static assert(is(ulong == typeof(CONST_ULLONG3())));
+  static assert(is(ulong == typeof(CONST_ULLONG4())));
+  static assert(is(double == typeof(CONST_DOUBLE1())));
+  static assert(is(double == typeof(CONST_DOUBLE2())));
+  static assert(is(double == typeof(CONST_DOUBLE3())));
+  static assert(is(double == typeof(CONST_DOUBLE4())));
+  static assert(is(double == typeof(CONST_DOUBLE5())));
+  static assert(is(double == typeof(CONST_DOUBLE6())));
+  static assert(is(int == typeof(CONST_BOOL1())));
+  static assert(is(int == typeof(CONST_BOOL2())));
+  static assert(is(char == typeof(CONST_CHAR())));
+  static assert(is(string == typeof(CONST_STRING1())));
+  static assert(is(string == typeof(CONST_STRING2())));
+
+  static assert(is(int == typeof(INT_AND_BOOL())));
+//    static assert(is(int == typeof(INT_AND_CHAR())));
+  static assert(is(int == typeof(INT_AND_INT())));
+  static assert(is(uint == typeof(INT_AND_UINT())));
+  static assert(is(int == typeof(INT_AND_LONG())));
+  static assert(is(uint == typeof(INT_AND_ULONG())));
+  static assert(is(long == typeof(INT_AND_LLONG())));
+  static assert(is(ulong == typeof(INT_AND_ULLONG())));
+  static assert(is(int == typeof(BOOL_AND_BOOL())));
+
+  static assert(is(int == typeof(EXPR_MULTIPLY())));
+  static assert(is(int == typeof(EXPR_DIVIDE())));
+  static assert(is(int == typeof(EXPR_PLUS())));
+  static assert(is(int == typeof(EXPR_MINUS())));
+  static assert(is(int == typeof(EXPR_LSHIFT())));
+  static assert(is(int == typeof(EXPR_RSHIFT())));
+  static assert(is(int == typeof(EXPR_LTE())));
+  static assert(is(int == typeof(EXPR_GTE())));
+  static assert(is(int == typeof(EXPR_INEQUALITY())));
+  static assert(is(int == typeof(EXPR_EQUALITY())));
+  static assert(is(int == typeof(EXPR_AND())));
+  static assert(is(int == typeof(EXPR_XOR())));
+  static assert(is(int == typeof(EXPR_OR())));
+  static assert(is(int == typeof(EXPR_LAND())));
+  static assert(is(int == typeof(EXPR_LOR())));
+  static assert(is(double == typeof(EXPR_CONDITIONAL())));
+}

Examples/test-suite/d/preproc_constants_runme.1.d

@@ -0,0 +1,62 @@
+module preproc_constants_runme;
+
+import preproc_constants.preproc_constants;
+
+void main() {
+  static assert(is(int == typeof(CONST_INT1())));
+  static assert(is(int == typeof(CONST_INT2())));
+  static assert(is(uint == typeof(CONST_UINT1())));
+  static assert(is(uint == typeof(CONST_UINT2())));
+  static assert(is(uint == typeof(CONST_UINT3())));
+  static assert(is(uint == typeof(CONST_UINT4())));
+  static assert(is(int == typeof(CONST_LONG1())));
+  static assert(is(int == typeof(CONST_LONG2())));
+  static assert(is(int == typeof(CONST_LONG3())));
+  static assert(is(int == typeof(CONST_LONG4())));
+  static assert(is(long == typeof(CONST_LLONG1())));
+  static assert(is(long == typeof(CONST_LLONG2())));
+  static assert(is(long == typeof(CONST_LLONG3())));
+  static assert(is(long == typeof(CONST_LLONG4())));
+  static assert(is(ulong == typeof(CONST_ULLONG1())));
+  static assert(is(ulong == typeof(CONST_ULLONG2())));
+  static assert(is(ulong == typeof(CONST_ULLONG3())));
+  static assert(is(ulong == typeof(CONST_ULLONG4())));
+  static assert(is(double == typeof(CONST_DOUBLE1())));
+  static assert(is(double == typeof(CONST_DOUBLE2())));
+  static assert(is(double == typeof(CONST_DOUBLE3())));
+  static assert(is(double == typeof(CONST_DOUBLE4())));
+  static assert(is(double == typeof(CONST_DOUBLE5())));
+  static assert(is(double == typeof(CONST_DOUBLE6())));
+  static assert(is(bool == typeof(CONST_BOOL1())));
+  static assert(is(bool == typeof(CONST_BOOL2())));
+  static assert(is(char == typeof(CONST_CHAR())));
+  static assert(is(char[] == typeof(CONST_STRING1())));
+  static assert(is(char[] == typeof(CONST_STRING2())));
+
+  static assert(is(int == typeof(INT_AND_BOOL())));
+//    static assert(is(int == typeof(INT_AND_CHAR())));
+  static assert(is(int == typeof(INT_AND_INT())));
+  static assert(is(uint == typeof(INT_AND_UINT())));
+  static assert(is(int == typeof(INT_AND_LONG())));
+  static assert(is(uint == typeof(INT_AND_ULONG())));
+  static assert(is(long == typeof(INT_AND_LLONG())));
+  static assert(is(ulong == typeof(INT_AND_ULLONG())));
+  static assert(is(int == typeof(BOOL_AND_BOOL())));
+
+  static assert(is(int == typeof(EXPR_MULTIPLY())));
+  static assert(is(int == typeof(EXPR_DIVIDE())));
+  static assert(is(int == typeof(EXPR_PLUS())));
+  static assert(is(int == typeof(EXPR_MINUS())));
+  static assert(is(int == typeof(EXPR_LSHIFT())));
+  static assert(is(int == typeof(EXPR_RSHIFT())));
+  static assert(is(bool == typeof(EXPR_LTE())));
+  static assert(is(bool == typeof(EXPR_GTE())));
+  static assert(is(bool == typeof(EXPR_INEQUALITY())));
+  static assert(is(bool == typeof(EXPR_EQUALITY())));
+  static assert(is(int == typeof(EXPR_AND())));
+  static assert(is(int == typeof(EXPR_XOR())));
+  static assert(is(int == typeof(EXPR_OR())));
+  static assert(is(bool == typeof(EXPR_LAND())));
+  static assert(is(bool == typeof(EXPR_LOR())));
+  static assert(is(double == typeof(EXPR_CONDITIONAL())));
+}

Examples/test-suite/d/preproc_constants_runme.2.d

@@ -0,0 +1,62 @@
+module preproc_constants_runme;
+
+import preproc_constants.preproc_constants;
+
+void main() {
+  static assert(is(int == typeof(CONST_INT1())));
+  static assert(is(int == typeof(CONST_INT2())));
+  static assert(is(uint == typeof(CONST_UINT1())));
+  static assert(is(uint == typeof(CONST_UINT2())));
+  static assert(is(uint == typeof(CONST_UINT3())));
+  static assert(is(uint == typeof(CONST_UINT4())));
+  static assert(is(int == typeof(CONST_LONG1())));
+  static assert(is(int == typeof(CONST_LONG2())));
+  static assert(is(int == typeof(CONST_LONG3())));
+  static assert(is(int == typeof(CONST_LONG4())));
+  static assert(is(long == typeof(CONST_LLONG1())));
+  static assert(is(long == typeof(CONST_LLONG2())));
+  static assert(is(long == typeof(CONST_LLONG3())));
+  static assert(is(long == typeof(CONST_LLONG4())));
+  static assert(is(ulong == typeof(CONST_ULLONG1())));
+  static assert(is(ulong == typeof(CONST_ULLONG2())));
+  static assert(is(ulong == typeof(CONST_ULLONG3())));
+  static assert(is(ulong == typeof(CONST_ULLONG4())));
+  static assert(is(double == typeof(CONST_DOUBLE1())));
+  static assert(is(double == typeof(CONST_DOUBLE2())));
+  static assert(is(double == typeof(CONST_DOUBLE3())));
+  static assert(is(double == typeof(CONST_DOUBLE4())));
+  static assert(is(double == typeof(CONST_DOUBLE5())));
+  static assert(is(double == typeof(CONST_DOUBLE6())));
+  static assert(is(bool == typeof(CONST_BOOL1())));
+  static assert(is(bool == typeof(CONST_BOOL2())));
+  static assert(is(char == typeof(CONST_CHAR())));
+  static assert(is(string == typeof(CONST_STRING1())));
+  static assert(is(string == typeof(CONST_STRING2())));
+
+  static assert(is(int == typeof(INT_AND_BOOL())));
+//    static assert(is(int == typeof(INT_AND_CHAR())));
+  static assert(is(int == typeof(INT_AND_INT())));
+  static assert(is(uint == typeof(INT_AND_UINT())));
+  static assert(is(int == typeof(INT_AND_LONG())));
+  static assert(is(uint == typeof(INT_AND_ULONG())));
+  static assert(is(long == typeof(INT_AND_LLONG())));
+  static assert(is(ulong == typeof(INT_AND_ULLONG())));
+  static assert(is(int == typeof(BOOL_AND_BOOL())));
+
+  static assert(is(int == typeof(EXPR_MULTIPLY())));
+  static assert(is(int == typeof(EXPR_DIVIDE())));
+  static assert(is(int == typeof(EXPR_PLUS())));
+  static assert(is(int == typeof(EXPR_MINUS())));
+  static assert(is(int == typeof(EXPR_LSHIFT())));
+  static assert(is(int == typeof(EXPR_RSHIFT())));
+  static assert(is(bool == typeof(EXPR_LTE())));
+  static assert(is(bool == typeof(EXPR_GTE())));
+  static assert(is(bool == typeof(EXPR_INEQUALITY())));
+  static assert(is(bool == typeof(EXPR_EQUALITY())));
+  static assert(is(int == typeof(EXPR_AND())));
+  static assert(is(int == typeof(EXPR_XOR())));
+  static assert(is(int == typeof(EXPR_OR())));
+  static assert(is(bool == typeof(EXPR_LAND())));
+  static assert(is(bool == typeof(EXPR_LOR())));
+  static assert(is(double == typeof(EXPR_CONDITIONAL())));
+}

Examples/test-suite/d/sizet_runme.1.d

@@ -0,0 +1,15 @@
+module sizet_runme;
+
+import sizet.sizet;
+
+void main() {
+  size_t s = 2000;
+  s = test1(s+1);
+  s = test2(s+1);
+  s = test3(s+1);
+  s = test4(s+1);
+
+  if (s != 2004) {
+    throw new Exception("failed");
+  }
+}

Examples/test-suite/d/sizet_runme.2.d

@@ -0,0 +1,14 @@
+module sizet_runme;
+
+import std.exception;
+import sizet.sizet;
+
+void main() {
+  size_t s = 2000;
+  s = test1(s+1);
+  s = test2(s+1);
+  s = test3(s+1);
+  s = test4(s+1);
+
+  enforce(s == 2004, "failed");
+}

Examples/test-suite/d/sneaky1_runme.1.d

@@ -0,0 +1,21 @@
+module sneaky1_runme;
+
+import sneaky1.sneaky1;
+
+void main() {
+  if (add(30, 2) != 32) {
+    throw new Exception("add test failed");
+  }
+
+  if (subtract(20, 2) != 18) {
+    throw new Exception("subtract test failed");
+  }
+
+  if (mul(20, 2) != 40) {
+    throw new Exception("mul test failed");
+  }
+
+  if (divide(20, 2) != 10) {
+    throw new Exception("div test failed");
+  }
+}

Examples/test-suite/d/sneaky1_runme.2.d

@@ -0,0 +1,11 @@
+module sneaky1_runme;
+
+import std.exception;
+import sneaky1.sneaky1;
+
+void main() {
+  enforce(add(30, 2) == 32, "add test failed");
+  enforce(subtract(20, 2) == 18, "subtract test failed");
+  enforce(mul(20, 2) == 40, "mul test failed");
+  enforce(divide(20, 2) == 10, "div test failed");
+}

Examples/test-suite/d/special_variable_macros_runme.1.d

@@ -0,0 +1,39 @@
+module special_variable_macros_runme;
+
+import special_variable_macros.special_variable_macros;
+import special_variable_macros.Name;
+import special_variable_macros.NewName;
+import special_variable_macros.PairIntBool;
+
+void main() {
+  auto name = new Name();
+
+  if (testFred(name) != "none") {
+    throw new Exception("test failed");
+  }
+
+  if (testJack(name) != "$specialname") {
+    throw new Exception("test failed");
+  }
+
+  if (testJill(name) != "jilly") {
+    throw new Exception("test failed");
+  }
+
+  if (testMary(name) != "SWIGTYPE_p_NameWrap") {
+    throw new Exception("test failed");
+  }
+
+  if (testJim(name) != "multiname num") {
+    throw new Exception("test failed");
+  }
+
+  if (testJohn(new PairIntBool(10, false)) != 123) {
+    throw new Exception("test failed");
+  }
+
+  auto newName = NewName.factory("factoryname");
+  if (newName.getStoredName().getName() != "factoryname") {
+    throw new Exception("test failed");
+  }
+}

Examples/test-suite/d/special_variable_macros_runme.2.d

@@ -0,0 +1,21 @@
+module special_variable_macros_runme;
+
+import std.exception;
+import special_variable_macros.special_variable_macros;
+import special_variable_macros.Name;
+import special_variable_macros.NewName;
+import special_variable_macros.PairIntBool;
+
+void main() {
+  auto name = new Name();
+  enforce(testFred(name) == "none");
+  enforce(testJack(name) == "$specialname");
+  enforce(testJill(name) == "jilly");
+  enforce(testMary(name) == "SWIGTYPE_p_NameWrap");
+  enforce(testJim(name) == "multiname num");
+
+  enforce(testJohn(new PairIntBool(10, false)) == 123);
+
+  auto newName = NewName.factory("factoryname");
+  enforce(newName.getStoredName().getName() == "factoryname");
+}

Examples/test-suite/d/threads_runme.1.d

@@ -0,0 +1,70 @@
+module threads_runme;
+
+import tango.core.Thread;
+import tango.io.Console;
+import Integer = tango.text.convert.Integer;
+import threads.Kerfuffle;
+
+// Spawn 8 threads.
+const uint NUM_THREADS = 8;
+
+// Run test for a few seconds on a 1GHz machine.
+const uint WORKER_LOOP_PASSES = 30000;
+
+void main() {
+  auto kerf = new Kerfuffle();
+  TestThread[] threads;
+
+  // Invoke the threads.
+  for (uint i = 0; i < NUM_THREADS; i++) {
+    auto thread = new TestThread(kerf);
+    threads ~= thread;
+    thread.name = Integer.toString(i);
+    thread.start();
+  }
+
+  // Wait for the threads to finish.
+  foreach(thread; threads) {
+    thread.join();
+  }
+
+  // Check if any thread has failed.
+  foreach(thread; threads) {
+    if (thread.failed) throw new Exception("Test failed.");
+  }
+}
+
+class TestThread : Thread {
+public:
+  this(Kerfuffle kerf) {
+    super(&run);
+    m_kerf = kerf;
+  }
+
+  void run() {
+    failed = false;
+    try {
+      for (uint i = 0; i < WORKER_LOOP_PASSES; i++) {
+	char[] given = "This is the test char[] that should come back. A number: " ~ Integer.toString(i);
+	char[] received = m_kerf.StdString(given);
+	if (received != given) {
+	  throw new Exception("StdString char[] does not match. Received: '" ~ received ~ "'. Expected: '" ~ given ~ "'.");
+	}
+      }
+      for (uint i = 0; i < WORKER_LOOP_PASSES; i++) {
+	char[] given = "This is the test char[] that should come back. A number: " ~ Integer.toString(i);
+	char[] received = m_kerf.CharString(given);
+	if (received != given) {
+	  throw new Exception("StdString char[] does not match. Received: '" ~ received ~ "'. Expected: '" ~ given ~ "'.");
+	}
+      }
+    } catch (Exception e) {
+      Cerr("Test failed (thread " ~ name() ~ "): " ~ e.msg).newline;
+      failed = true;
+    }
+  }
+
+  bool failed;
+private:
+  Kerfuffle m_kerf;
+}

Examples/test-suite/d/threads_runme.2.d

@@ -0,0 +1,55 @@
+module threads_runme;
+
+import core.thread;
+import std.conv;
+import std.exception;
+import std.range;
+import std.stdio;
+import threads.Kerfuffle;
+
+// Spawn 8 threads.
+enum THREADS = iota(0, 9);
+
+// Run test for a few seconds on a 1GHz machine.
+enum WORK_RANGE = iota(0, 30000);
+
+void main() {
+  auto kerf = new Kerfuffle();
+  TestThread[] threads;
+
+  // Invoke the threads.
+  foreach (i; THREADS) {
+    auto thread = new TestThread(kerf);
+    threads ~= thread;
+    thread.name = to!string(i);
+    thread.start();
+  }
+
+  // Wait for the threads to finish.
+  foreach (i, thread; threads) {
+    thread.join(true);
+  }
+}
+
+class TestThread : Thread {
+  this(Kerfuffle kerf) {
+    super(&run);
+    m_kerf = kerf;
+  }
+
+  void run() {
+    foreach (i; WORK_RANGE) {
+    	string given = "This is the test string that should come back. A number: " ~ to!string(i);
+    	string received = m_kerf.StdString(given);
+    	enforce(received == given, "StdString string does not match. Received: '" ~ received ~ "'. Expected: '" ~ given ~ "'.");
+    }
+    foreach (i; WORK_RANGE) {
+    	string given = "This is the test string that should come back. A number: " ~ to!string(i);
+    	string received = m_kerf.CharString(given);
+    	enforce(received == given, "CharString string does not match. Received: '" ~ received ~ "'. Expected: '" ~ given ~ "'.");
+    }
+  }
+
+private:
+  Kerfuffle m_kerf;
+}

Examples/test-suite/d/throw_exception_runme.1.d

@@ -0,0 +1,30 @@
+module throw_exception_runme;
+
+import throw_exception.Foo;
+
+void main() {
+  test!("test_int");
+  test!("test_msg");
+  test!("test_cls");
+  test!("test_cls_ptr");
+  test!("test_cls_ref");
+  test!("test_cls_td");
+  test!("test_cls_ptr_td");
+  test!("test_cls_ref_td");
+  test!("test_array");
+  test!("test_enum");
+}
+
+void test(char[] methodName)() {
+  auto foo = new Foo();
+
+  bool didntThrow;
+  try {
+    mixin("foo." ~ methodName ~ "();");
+    didntThrow = true;
+  } catch (Exception) {}
+
+  if (didntThrow) {
+    throw new Exception(methodName ~ " failed");
+  }
+}

Examples/test-suite/d/throw_exception_runme.2.d

@@ -0,0 +1,30 @@
+module throw_exception_runme;
+
+import throw_exception.Foo;
+
+void main() {
+  test!("test_int");
+  test!("test_msg");
+  test!("test_cls");
+  test!("test_cls_ptr");
+  test!("test_cls_ref");
+  test!("test_cls_td");
+  test!("test_cls_ptr_td");
+  test!("test_cls_ref_td");
+  test!("test_array");
+  test!("test_enum");
+}
+
+void test(string methodName)() {
+  auto foo = new Foo();
+
+  bool didntThrow;
+  try {
+    mixin("foo." ~ methodName ~ "();");
+    didntThrow = true;
+  } catch (Exception) {}
+
+  if (didntThrow) {
+    throw new Exception(methodName ~ " failed");
+  }
+}

Examples/test-suite/d/typemap_namespace_runme.1.d

@@ -0,0 +1,13 @@
+module typemap_namespace_runme;
+
+import typemap_namespace.typemap_namespace;
+
+void main() {
+  if (test1("hello") != "hello") {
+    throw new Exception("test1 failed");
+  }
+
+  if (test2("hello") != "hello") {
+    throw new Exception("test2 failed");
+  }
+}

Examples/test-suite/d/typemap_namespace_runme.2.d

@@ -0,0 +1,9 @@
+module typemap_namespace_runme;
+
+import std.exception;
+import typemap_namespace.typemap_namespace;
+
+void main() {
+  enforce(test1("hello") == "hello", "test1 failed");
+  enforce(test2("hello") == "hello", "test2 failed");
+}

Examples/test-suite/d/typemap_out_optimal_runme.1.d

@@ -0,0 +1,9 @@
+module typemap_out_optimal_runme;
+
+import typemap_out_optimal.XX;
+
+void main() {
+  XX x;
+  XX.trace = false;
+  x = XX.create();
+}

Examples/test-suite/d/typemap_out_optimal_runme.2.d

@@ -0,0 +1,9 @@
+module typemap_out_optimal_runme;
+
+import typemap_out_optimal.XX;
+
+void main() {
+  XX x;
+  XX.trace = false;
+  x = XX.create();
+}

Examples/test-suite/d/varargs_runme.1.d

@@ -0,0 +1,20 @@
+module varargs_runme;
+
+import varargs.varargs;
+import varargs.Foo;
+
+void main() {
+  if (test("Hello") != "Hello") {
+    throw new Exception("Test 1 failed");
+  }
+
+  auto f = new Foo("Greetings");
+
+  if (f.str != "Greetings") {
+    throw new Exception("Test 2 failed");
+  }
+
+  if (f.test("Hello") != "Hello") {
+    throw new Exception("Test 3 failed");
+  }
+}

Examples/test-suite/d/varargs_runme.2.d

@@ -0,0 +1,13 @@
+module varargs_runme;
+
+import std.exception;
+import varargs.varargs;
+import varargs.Foo;
+
+void main() {
+  enforce(test("Hello") == "Hello", "Test 1 failed");
+
+  auto f = new Foo("Greetings");
+  enforce(f.str == "Greetings", "Test 2 failed");
+  enforce(f.test("Hello") == "Hello", "Test 3 failed");
+}

Examples/test-suite/d/virtual_poly_runme.1.d

@@ -0,0 +1,27 @@
+module virtual_poly_runme;
+
+import virtual_poly.NDouble;
+import virtual_poly.NInt;
+import virtual_poly.NNumber;
+
+void main() {
+  // D supports covariant (polymorphic) return types, so this should work like
+  // in C++.
+  auto d = new NDouble(3.5);
+  NDouble dc = d.copy();
+  if (d.get() != dc.get()) {
+    throw new Exception("Test 1 failed.");
+  }
+
+  auto i = new NInt(2);
+  NInt ic = i.copy();
+  if (i.get() != ic.get()) {
+    throw new Exception("Test 2 failed.");
+  }
+
+  NNumber n = d;
+  auto nd = cast(NDouble) n.copy();
+  if (nd.get() != d.get()) {
+    throw new Exception("Test 3 failed.");
+  }
+}

Examples/test-suite/d/virtual_poly_runme.2.d

@@ -0,0 +1,22 @@
+module virtual_poly_runme;
+
+import std.exception;
+import virtual_poly.NDouble;
+import virtual_poly.NInt;
+import virtual_poly.NNumber;
+
+void main() {
+  // D supports covariant (polymorphic) return types, so this should work like
+  // in C++.
+  auto d = new NDouble(3.5);
+  NDouble dc = d.copy();
+  enforce(d.get() == dc.get(), "Test 1 failed.");
+
+  auto i = new NInt(2);
+  NInt ic = i.copy();
+  enforce(i.get() == ic.get(), "Test 2 failed.");
+
+  NNumber n = d;
+  auto nd = cast(NDouble) n.copy();
+  enforce(nd.get() == d.get(), "Test 3 failed.");
+}

Examples/test-suite/d_nativepointers.i

@@ -0,0 +1,18 @@
+%module d_nativepointers;
+
+%inline %{
+  class SomeClass {
+  };
+  class OpaqueClass;
+  typedef void (*FuncA)(int **x, char ***y);
+  typedef void (*FuncB)(int **x, SomeClass *y);
+
+  int *a( int *value ){ return value; }
+  float **b( float **value ){ return value; }
+  char ***c( char ***value ){ return value; }
+  SomeClass *d( SomeClass *value ){ return value; }
+  SomeClass **e( SomeClass **value ){ return value; }
+  OpaqueClass *f( OpaqueClass *value ){ return value; }
+  FuncA g( FuncA value ){ return value; }
+  FuncB* h( FuncB* value ){ return value; }
+%}