diff options
Diffstat (limited to 'Examples/test-suite/d')
90 files changed, 6919 insertions, 0 deletions
diff --git a/Examples/test-suite/d/Makefile.in b/Examples/test-suite/d/Makefile.in new file mode 100644 index 000000000..0f5bf8cbb --- /dev/null +++ b/Examples/test-suite/d/Makefile.in @@ -0,0 +1,81 @@ +####################################################################### +# 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_exception_name \ + 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 $*$(VERSIONSUFFIX) ]; then \ + rm -rf $*$(VERSIONSUFFIX); \ + fi diff --git a/Examples/test-suite/d/README b/Examples/test-suite/d/README new file mode 100644 index 000000000..bb5372882 --- /dev/null +++ b/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. diff --git a/Examples/test-suite/d/aggregate_runme.1.d b/Examples/test-suite/d/aggregate_runme.1.d new file mode 100644 index 000000000..a00d34c25 --- /dev/null +++ b/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) {} +} diff --git a/Examples/test-suite/d/aggregate_runme.2.d b/Examples/test-suite/d/aggregate_runme.2.d new file mode 100644 index 000000000..a00d34c25 --- /dev/null +++ b/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) {} +} diff --git a/Examples/test-suite/d/allprotected_runme.1.d b/Examples/test-suite/d/allprotected_runme.1.d new file mode 100644 index 000000000..82a180e66 --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/allprotected_runme.2.d b/Examples/test-suite/d/allprotected_runme.2.d new file mode 100644 index 000000000..799230291 --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/apply_strings_runme.1.d b/Examples/test-suite/d/apply_strings_runme.1.d new file mode 100644 index 000000000..960caa4ca --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/apply_strings_runme.2.d b/Examples/test-suite/d/apply_strings_runme.2.d new file mode 100644 index 000000000..86183f8a3 --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/bools_runme.1.d b/Examples/test-suite/d/bools_runme.1.d new file mode 100644 index 000000000..f501b0762 --- /dev/null +++ b/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."); + } + } +} diff --git a/Examples/test-suite/d/bools_runme.2.d b/Examples/test-suite/d/bools_runme.2.d new file mode 100644 index 000000000..f501b0762 --- /dev/null +++ b/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."); + } + } +} diff --git a/Examples/test-suite/d/catches_runme.1.d b/Examples/test-suite/d/catches_runme.1.d new file mode 100644 index 000000000..55b18132d --- /dev/null +++ b/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."); + } +} diff --git a/Examples/test-suite/d/catches_runme.2.d b/Examples/test-suite/d/catches_runme.2.d new file mode 100644 index 000000000..508558485 --- /dev/null +++ b/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."); + } +} diff --git a/Examples/test-suite/d/char_strings_runme.1.d b/Examples/test-suite/d/char_strings_runme.1.d new file mode 100644 index 000000000..cde6fe0f7 --- /dev/null +++ b/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)); + } +} diff --git a/Examples/test-suite/d/char_strings_runme.2.d b/Examples/test-suite/d/char_strings_runme.2.d new file mode 100644 index 000000000..5fe28e995 --- /dev/null +++ b/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)); + } +} diff --git a/Examples/test-suite/d/constover_runme.1.d b/Examples/test-suite/d/constover_runme.1.d new file mode 100644 index 000000000..ead67319e --- /dev/null +++ b/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!"); +} diff --git a/Examples/test-suite/d/constover_runme.2.d b/Examples/test-suite/d/constover_runme.2.d new file mode 100644 index 000000000..68f7f207a --- /dev/null +++ b/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!"); +} diff --git a/Examples/test-suite/d/d_nativepointers_runme.1.d b/Examples/test-suite/d/d_nativepointers_runme.1.d new file mode 100644 index 000000000..797c057d3 --- /dev/null +++ b/Examples/test-suite/d/d_nativepointers_runme.1.d @@ -0,0 +1,36 @@ +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); + + { + static assert(is(int* function(int*) == typeof(&refA))); + int v = 2; + assert(*refA(&v) == 2); + } + + { + static assert(is(float** function(float**) == typeof(&refB))); + float v = 1.0; + float* p = &v; + assert(**refB(&p) == 1.0); + } +} + +void check(alias F, T)() { + static assert(is(T function(T) == typeof(&F))); + assert(F(null) is null); +} diff --git a/Examples/test-suite/d/d_nativepointers_runme.2.d b/Examples/test-suite/d/d_nativepointers_runme.2.d new file mode 100644 index 000000000..797c057d3 --- /dev/null +++ b/Examples/test-suite/d/d_nativepointers_runme.2.d @@ -0,0 +1,36 @@ +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); + + { + static assert(is(int* function(int*) == typeof(&refA))); + int v = 2; + assert(*refA(&v) == 2); + } + + { + static assert(is(float** function(float**) == typeof(&refB))); + float v = 1.0; + float* p = &v; + assert(**refB(&p) == 1.0); + } +} + +void check(alias F, T)() { + static assert(is(T function(T) == typeof(&F))); + assert(F(null) is null); +} diff --git a/Examples/test-suite/d/default_args_runme.1.d b/Examples/test-suite/d/default_args_runme.1.d new file mode 100644 index 000000000..0ad63b7c2 --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/default_args_runme.2.d b/Examples/test-suite/d/default_args_runme.2.d new file mode 100644 index 000000000..15688aec8 --- /dev/null +++ b/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); + } + } +} diff --git a/Examples/test-suite/d/default_constructor_runme.1.d b/Examples/test-suite/d/default_constructor_runme.1.d new file mode 100644 index 000000000..3640218ae --- /dev/null +++ b/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; + } + } +} diff --git a/Examples/test-suite/d/default_constructor_runme.2.d b/Examples/test-suite/d/default_constructor_runme.2.d new file mode 100644 index 000000000..22f5bffd2 --- /dev/null +++ b/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); + } + } +} diff --git a/Examples/test-suite/d/director_alternating_runme.1.d b/Examples/test-suite/d/director_alternating_runme.1.d new file mode 100644 index 000000000..27bd262fd --- /dev/null +++ b/Examples/test-suite/d/director_alternating_runme.1.d @@ -0,0 +1,7 @@ +module director_alternating_runme; + +import director_alternating.director_alternating; + +void main() { + assert(getBar().id() == idFromGetBar()); +} diff --git a/Examples/test-suite/d/director_alternating_runme.2.d b/Examples/test-suite/d/director_alternating_runme.2.d new file mode 100644 index 000000000..27bd262fd --- /dev/null +++ b/Examples/test-suite/d/director_alternating_runme.2.d @@ -0,0 +1,7 @@ +module director_alternating_runme; + +import director_alternating.director_alternating; + +void main() { + assert(getBar().id() == idFromGetBar()); +} diff --git a/Examples/test-suite/d/director_basic_runme.1.d b/Examples/test-suite/d/director_basic_runme.1.d new file mode 100644 index 000000000..58a54835e --- /dev/null +++ b/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; + } +} diff --git a/Examples/test-suite/d/director_basic_runme.2.d b/Examples/test-suite/d/director_basic_runme.2.d new file mode 100644 index 000000000..877fcbc47 --- /dev/null +++ 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; + } +} diff --git a/Examples/test-suite/d/director_classes_runme.1.d b/Examples/test-suite/d/director_classes_runme.1.d new file mode 100644 index 000000000..9c34db82a --- /dev/null +++ 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*/); + } +} diff --git a/Examples/test-suite/d/director_classes_runme.2.d b/Examples/test-suite/d/director_classes_runme.2.d new file mode 100644 index 000000000..98e27b3cd --- /dev/null +++ b/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*/); + } +} diff --git a/Examples/test-suite/d/director_classic_runme.1.d b/Examples/test-suite/d/director_classic_runme.1.d new file mode 100644 index 000000000..33be80618 --- /dev/null +++ b/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(); + } +} diff --git a/Examples/test-suite/d/director_classic_runme.2.d b/Examples/test-suite/d/director_classic_runme.2.d new file mode 100644 index 000000000..c50781b07 --- /dev/null +++ b/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(); + } +} diff --git a/Examples/test-suite/d/director_ignore_runme.1.d b/Examples/test-suite/d/director_ignore_runme.1.d new file mode 100644 index 000000000..797d2fddf --- /dev/null +++ b/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; } +} diff --git a/Examples/test-suite/d/director_ignore_runme.2.d b/Examples/test-suite/d/director_ignore_runme.2.d new file mode 100644 index 000000000..b3e29b48d --- /dev/null +++ b/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; } +} diff --git a/Examples/test-suite/d/director_primitives_runme.1.d b/Examples/test-suite/d/director_primitives_runme.1.d new file mode 100644 index 000000000..f19e86f59 --- /dev/null +++ b/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); + } +} diff --git a/Examples/test-suite/d/director_primitives_runme.2.d b/Examples/test-suite/d/director_primitives_runme.2.d new file mode 100644 index 000000000..e0e307330 --- /dev/null +++ b/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); + } +} diff --git a/Examples/test-suite/d/director_protected_runme.1.d b/Examples/test-suite/d/director_protected_runme.1.d new file mode 100644 index 000000000..81447b73b --- /dev/null +++ b/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();"; + } +} diff --git a/Examples/test-suite/d/director_protected_runme.2.d b/Examples/test-suite/d/director_protected_runme.2.d new file mode 100644 index 000000000..9beeecd23 --- /dev/null +++ b/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();"; + } +} diff --git a/Examples/test-suite/d/director_string_runme.1.d b/Examples/test-suite/d/director_string_runme.1.d new file mode 100644 index 000000000..4e750791a --- /dev/null +++ b/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); + } +} diff --git a/Examples/test-suite/d/director_string_runme.2.d b/Examples/test-suite/d/director_string_runme.2.d new file mode 100644 index 000000000..950a34072 --- /dev/null +++ b/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); + } +} diff --git a/Examples/test-suite/d/enum_thorough_runme.1.d b/Examples/test-suite/d/enum_thorough_runme.1.d new file mode 100644 index 000000000..b76bfdd93 --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/enum_thorough_runme.2.d b/Examples/test-suite/d/enum_thorough_runme.2.d new file mode 100644 index 000000000..d8b2a2ad9 --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/inherit_target_language_runme.1.d b/Examples/test-suite/d/inherit_target_language_runme.1.d new file mode 100644 index 000000000..8a13caca4 --- /dev/null +++ b/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(); +} diff --git a/Examples/test-suite/d/inherit_target_language_runme.2.d b/Examples/test-suite/d/inherit_target_language_runme.2.d new file mode 100644 index 000000000..8a13caca4 --- /dev/null +++ b/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(); +} diff --git a/Examples/test-suite/d/li_attribute_runme.1.d b/Examples/test-suite/d/li_attribute_runme.1.d new file mode 100644 index 000000000..ada3ed8d8 --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/li_attribute_runme.2.d b/Examples/test-suite/d/li_attribute_runme.2.d new file mode 100644 index 000000000..4e0ea58ff --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/li_boost_shared_ptr_bits_runme.1.d b/Examples/test-suite/d/li_boost_shared_ptr_bits_runme.1.d new file mode 100644 index 000000000..098570b95 --- /dev/null +++ b/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(); + } +} diff --git a/Examples/test-suite/d/li_boost_shared_ptr_bits_runme.2.d b/Examples/test-suite/d/li_boost_shared_ptr_bits_runme.2.d new file mode 100644 index 000000000..4891b7673 --- /dev/null +++ b/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(); + } +} diff --git a/Examples/test-suite/d/li_boost_shared_ptr_runme.1.d b/Examples/test-suite/d/li_boost_shared_ptr_runme.1.d new file mode 100644 index 000000000..ed55cd302 --- /dev/null +++ b/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)); +} diff --git a/Examples/test-suite/d/li_boost_shared_ptr_runme.2.d b/Examples/test-suite/d/li_boost_shared_ptr_runme.2.d new file mode 100644 index 000000000..773ae74d5 --- /dev/null +++ b/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); + } + } +} diff --git a/Examples/test-suite/d/li_std_except_runme.1.d b/Examples/test-suite/d/li_std_except_runme.1.d new file mode 100644 index 000000000..39f3bb202 --- /dev/null +++ b/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; +} diff --git a/Examples/test-suite/d/li_std_except_runme.2.d b/Examples/test-suite/d/li_std_except_runme.2.d new file mode 100644 index 000000000..f2b4b672c --- /dev/null +++ b/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; +} diff --git a/Examples/test-suite/d/li_std_string_runme.1.d b/Examples/test-suite/d/li_std_string_runme.1.d new file mode 100644 index 000000000..b5bbb51c0 --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/li_std_string_runme.2.d b/Examples/test-suite/d/li_std_string_runme.2.d new file mode 100644 index 000000000..395c2f7ff --- /dev/null +++ b/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); + } +} diff --git a/Examples/test-suite/d/li_std_vector_runme.1.d b/Examples/test-suite/d/li_std_vector_runme.1.d new file mode 100644 index 000000000..895fb450f --- /dev/null +++ b/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; + } + } +} diff --git a/Examples/test-suite/d/li_std_vector_runme.2.d b/Examples/test-suite/d/li_std_vector_runme.2.d new file mode 100644 index 000000000..7860ad6fc --- /dev/null +++ b/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); + } + } +} diff --git a/Examples/test-suite/d/li_typemaps_runme.1.d b/Examples/test-suite/d/li_typemaps_runme.1.d new file mode 100644 index 000000000..e37b12bc2 --- /dev/null +++ b/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); +} diff --git a/Examples/test-suite/d/li_typemaps_runme.2.d b/Examples/test-suite/d/li_typemaps_runme.2.d new file mode 100644 index 000000000..de515b0ff --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/long_long_runme.1.d b/Examples/test-suite/d/long_long_runme.1.d new file mode 100644 index 000000000..a6d5448bc --- /dev/null +++ b/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)); + } +} diff --git a/Examples/test-suite/d/long_long_runme.2.d b/Examples/test-suite/d/long_long_runme.2.d new file mode 100644 index 000000000..a082171b4 --- /dev/null +++ b/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)); +} diff --git a/Examples/test-suite/d/member_pointer_runme.1.d b/Examples/test-suite/d/member_pointer_runme.1.d new file mode 100644 index 000000000..c1f8d33b8 --- /dev/null +++ b/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)); + } +} diff --git a/Examples/test-suite/d/member_pointer_runme.2.d b/Examples/test-suite/d/member_pointer_runme.2.d new file mode 100644 index 000000000..a5c293cd0 --- /dev/null +++ b/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)); +} diff --git a/Examples/test-suite/d/operator_overload_runme.1.d b/Examples/test-suite/d/operator_overload_runme.1.d new file mode 100644 index 000000000..18a24b91f --- /dev/null +++ b/Examples/test-suite/d/operator_overload_runme.1.d @@ -0,0 +1,89 @@ +module operator_overload_runme; + +import operator_overload.Op; + +void main() { + // Invoke the C++ sanity check first. + Op.sanity_check(); + + auto a = new Op(); + auto b = new Op(5); + auto c = b; + auto d = new Op(2); + auto dd = d; + + // test equality + assert(a != b); + assert(b == c); + assert(a != d); + assert(d == dd); + + // test < + assert(a < b); + assert(a <= b); + assert(b <= c); + assert(b >= c); + assert(b > d); + assert(b >= d); + + // test += + auto e = new Op(3); + e += d; + assert(e == b); + e -= c; + assert(e == a); + e = new Op(1); + e *= b; + assert(e == c); + e /= d; + assert(e == d); + e %= c; + assert(e == d); + + // test + + auto f = new Op(1); + auto g = new Op(1); + assert(f + g == new Op(2)); + assert(f - g == new Op(0)); + assert(f * g == new Op(1)); + assert(f / g == new Op(1)); + assert(f % g == new Op(0)); + + // test unary operators + assert(-a == a); + assert(-b == new Op(-5)); + // The unary ! operator is not overloadable in D1. + + // test [] + auto h = new Op(3); + assert(h[0]==3); + assert(h[1]==0); + // Generation of opIndexAssign is not supported yet. + + // test () + auto i = new Op(3); + assert(i()==3); + assert(i(1)==4); + assert(i(1,2)==6); + + // test ++ and -- + auto j = new Op(100); + int original = j.i; + { + Op newOp = j++; + int newInt = original++; + assert(j.i == original); + assert(newOp.i == newInt); + } + { + Op newOp = j--; + int newInt = original--; + assert(j.i == original); + assert(newOp.i == newInt); + } + // Prefix increment/decrement operators are lowered to (foo +=/-= 1) in D1, + // but the test case does not define an integer overload for operator += + // respectively -=. + + // Implicit casting is not overloadable in D1. +}
\ No newline at end of file diff --git a/Examples/test-suite/d/operator_overload_runme.2.d b/Examples/test-suite/d/operator_overload_runme.2.d new file mode 100644 index 000000000..2ff61cd56 --- /dev/null +++ b/Examples/test-suite/d/operator_overload_runme.2.d @@ -0,0 +1,91 @@ +module operator_overload_runme; + +import operator_overload.Op; + +void main() { + // Invoke the C++ sanity check first. + Op.sanity_check(); + + auto a = new Op(); + auto b = new Op(5); + auto c = b; + auto d = new Op(2); + auto dd = d; + + // test equality + assert(a != b); + assert(b == c); + assert(a != d); + assert(d == dd); + + // test < + assert(a < b); + assert(a <= b); + assert(b <= c); + assert(b >= c); + assert(b > d); + assert(b >= d); + + // test += + auto e = new Op(3); + e += d; + assert(e == b); + e -= c; + assert(e == a); + e = new Op(1); + e *= b; + assert(e == c); + e /= d; + assert(e == d); + e %= c; + assert(e == d); + + // test + + auto f = new Op(1); + auto g = new Op(1); + assert(f + g == new Op(2)); + assert(f - g == new Op(0)); + assert(f * g == new Op(1)); + assert(f / g == new Op(1)); + assert(f % g == new Op(0)); + + // test unary operators + assert(-a == a); + assert(-b == new Op(-5)); + + // Unfortunaly, there is no way to override conversion to boolean for + // classes in D, opCast!("bool") is only used for structs. + + // test [] + auto h = new Op(3); + assert(h[0]==3); + assert(h[1]==0); + // Generation of opIndexAssign is not supported yet. + + // test () + auto i = new Op(3); + assert(i()==3); + assert(i(1)==4); + assert(i(1,2)==6); + + // test ++ and -- + auto j = new Op(100); + int original = j.i; + // The prefix increment/decrement operators are not directly overloadable in + // D2, and because the proxy classes are reference types, the lowering + // yields the same value as the postfix operators. + { + Op newOp = ++j; + int newInt = ++original; + assert(j.i == original); + assert(newOp.i == newInt); + } + { + Op newOp = --j; + int newInt = --original; + assert(j.i == original); + assert(newOp.i == newInt); + } + + // Implicit casting via alias this is not supported yet. +}
\ No newline at end of file diff --git a/Examples/test-suite/d/overload_complicated_runme.1.d b/Examples/test-suite/d/overload_complicated_runme.1.d new file mode 100644 index 000000000..03d1bf1e6 --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/overload_complicated_runme.2.d b/Examples/test-suite/d/overload_complicated_runme.2.d new file mode 100644 index 000000000..9d03ec5e6 --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/overload_template_runme.1.d b/Examples/test-suite/d/overload_template_runme.1.d new file mode 100644 index 000000000..a1fe8012f --- /dev/null +++ b/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 *)"); +} diff --git a/Examples/test-suite/d/overload_template_runme.2.d b/Examples/test-suite/d/overload_template_runme.2.d new file mode 100644 index 000000000..9fe6eb2cf --- /dev/null +++ b/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 *)"); +} diff --git a/Examples/test-suite/d/pointer_reference_runme.1.d b/Examples/test-suite/d/pointer_reference_runme.1.d new file mode 100644 index 000000000..c593b939c --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/pointer_reference_runme.2.d b/Examples/test-suite/d/pointer_reference_runme.2.d new file mode 100644 index 000000000..8f287dfbd --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/preproc_constants_c_runme.1.d b/Examples/test-suite/d/preproc_constants_c_runme.1.d new file mode 100644 index 000000000..f25bbfdee --- /dev/null +++ b/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()))); +} diff --git a/Examples/test-suite/d/preproc_constants_c_runme.2.d b/Examples/test-suite/d/preproc_constants_c_runme.2.d new file mode 100644 index 000000000..07d6ac53d --- /dev/null +++ b/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()))); +} diff --git a/Examples/test-suite/d/preproc_constants_runme.1.d b/Examples/test-suite/d/preproc_constants_runme.1.d new file mode 100644 index 000000000..a2aaa8fcd --- /dev/null +++ b/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()))); +} diff --git a/Examples/test-suite/d/preproc_constants_runme.2.d b/Examples/test-suite/d/preproc_constants_runme.2.d new file mode 100644 index 000000000..e2eab2c46 --- /dev/null +++ b/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()))); +} diff --git a/Examples/test-suite/d/sizet_runme.1.d b/Examples/test-suite/d/sizet_runme.1.d new file mode 100644 index 000000000..ae42e20e5 --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/sizet_runme.2.d b/Examples/test-suite/d/sizet_runme.2.d new file mode 100644 index 000000000..63eb03b21 --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/sneaky1_runme.1.d b/Examples/test-suite/d/sneaky1_runme.1.d new file mode 100644 index 000000000..b293b4972 --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/sneaky1_runme.2.d b/Examples/test-suite/d/sneaky1_runme.2.d new file mode 100644 index 000000000..84e51e74d --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/special_variable_macros_runme.1.d b/Examples/test-suite/d/special_variable_macros_runme.1.d new file mode 100644 index 000000000..12491eef5 --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/special_variable_macros_runme.2.d b/Examples/test-suite/d/special_variable_macros_runme.2.d new file mode 100644 index 000000000..128e5870f --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/threads_runme.1.d b/Examples/test-suite/d/threads_runme.1.d new file mode 100644 index 000000000..206875824 --- /dev/null +++ b/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; +} diff --git a/Examples/test-suite/d/threads_runme.2.d b/Examples/test-suite/d/threads_runme.2.d new file mode 100644 index 000000000..3ac27a5a8 --- /dev/null +++ b/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; +} diff --git a/Examples/test-suite/d/throw_exception_runme.1.d b/Examples/test-suite/d/throw_exception_runme.1.d new file mode 100644 index 000000000..f2397a202 --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/throw_exception_runme.2.d b/Examples/test-suite/d/throw_exception_runme.2.d new file mode 100644 index 000000000..6fc82a93d --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/typemap_namespace_runme.1.d b/Examples/test-suite/d/typemap_namespace_runme.1.d new file mode 100644 index 000000000..3a5ca1a9f --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/typemap_namespace_runme.2.d b/Examples/test-suite/d/typemap_namespace_runme.2.d new file mode 100644 index 000000000..2281e403b --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/typemap_out_optimal_runme.1.d b/Examples/test-suite/d/typemap_out_optimal_runme.1.d new file mode 100644 index 000000000..16aab3cff --- /dev/null +++ b/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(); +} diff --git a/Examples/test-suite/d/typemap_out_optimal_runme.2.d b/Examples/test-suite/d/typemap_out_optimal_runme.2.d new file mode 100644 index 000000000..16aab3cff --- /dev/null +++ b/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(); +} diff --git a/Examples/test-suite/d/varargs_runme.1.d b/Examples/test-suite/d/varargs_runme.1.d new file mode 100644 index 000000000..53f76d075 --- /dev/null +++ b/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"); + } +} diff --git a/Examples/test-suite/d/varargs_runme.2.d b/Examples/test-suite/d/varargs_runme.2.d new file mode 100644 index 000000000..b2b5ceddc --- /dev/null +++ b/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"); +} diff --git a/Examples/test-suite/d/virtual_poly_runme.1.d b/Examples/test-suite/d/virtual_poly_runme.1.d new file mode 100644 index 000000000..fb2e7814d --- /dev/null +++ b/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."); + } +} diff --git a/Examples/test-suite/d/virtual_poly_runme.2.d b/Examples/test-suite/d/virtual_poly_runme.2.d new file mode 100644 index 000000000..f749ee236 --- /dev/null +++ b/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."); +} |