From cff68da57b6765d8afc4429c8dffe3515fa17eeb Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Thu, 12 Feb 2004 21:45:11 +0000 Subject: [PATCH] overloading when SWIG cannot disambiguate parameters tests added git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@5711 626c5289-ae23-0410-ae9c-e8d60b6d4f22 --- .../csharp/overload_complicated_runme.cs | 54 ++++++++++++++++ .../java/overload_complicated_runme.java | 63 +++++++++++++++++++ .../test-suite/overload_complicated.i | 55 +++++++++++++++- .../python/overload_complicated_runme.py | 47 ++++++++++++++ 4 files changed, 217 insertions(+), 2 deletions(-) create mode 100755 SWIG/Examples/test-suite/csharp/overload_complicated_runme.cs create mode 100755 SWIG/Examples/test-suite/java/overload_complicated_runme.java create mode 100755 SWIG/Examples/test-suite/python/overload_complicated_runme.py diff --git a/SWIG/Examples/test-suite/csharp/overload_complicated_runme.cs b/SWIG/Examples/test-suite/csharp/overload_complicated_runme.cs new file mode 100755 index 000000000..33b2cf808 --- /dev/null +++ b/SWIG/Examples/test-suite/csharp/overload_complicated_runme.cs @@ -0,0 +1,54 @@ +using System; + +public class runme +{ + static 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 (overload_complicated.muzak(false) != 3001) + throw new Exception("Test 10 failed"); + + if (overload_complicated.muzak(pInt) != 3002) + throw new Exception("Test 11 failed"); + } +} + + diff --git a/SWIG/Examples/test-suite/java/overload_complicated_runme.java b/SWIG/Examples/test-suite/java/overload_complicated_runme.java new file mode 100755 index 000000000..ac8523d75 --- /dev/null +++ b/SWIG/Examples/test-suite/java/overload_complicated_runme.java @@ -0,0 +1,63 @@ + +import overload_complicated.*; + +public class overload_complicated_runme { + + static { + try { + System.loadLibrary("overload_complicated"); + } catch (UnsatisfiedLinkError e) { + System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e); + System.exit(1); + } + } + + public static void main(String argv[]) + { + 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 RuntimeException("Test 1 failed"); + + if (p.hip(pInt) != 702) + throw new RuntimeException("Test 2 failed"); + + // Reverse the order for the above + if (p.hop(pInt) != 805) + throw new RuntimeException("Test 3 failed"); + + if (p.hop(false) != 801) + throw new RuntimeException("Test 4 failed"); + + // Few more variations and order shuffled + if (p.pop(false) != 901) + throw new RuntimeException("Test 5 failed"); + + if (p.pop(pInt) != 902) + throw new RuntimeException("Test 6 failed"); + + if (p.pop() != 905) + throw new RuntimeException("Test 7 failed"); + + // Overload on const only + if (p.bop(pInt) != 1001) + throw new RuntimeException("Test 8 failed"); + + if (p.bip(pInt) != 2001) + throw new RuntimeException("Test 9 failed"); + + // Globals + if (overload_complicated.muzak(false) != 3001) + throw new RuntimeException("Test 10 failed"); + + if (overload_complicated.muzak(pInt) != 3002) + throw new RuntimeException("Test 11 failed"); + } +} + diff --git a/SWIG/Examples/test-suite/overload_complicated.i b/SWIG/Examples/test-suite/overload_complicated.i index 2050e1945..63ed32b3a 100644 --- a/SWIG/Examples/test-suite/overload_complicated.i +++ b/SWIG/Examples/test-suite/overload_complicated.i @@ -3,18 +3,69 @@ #ifndef SWIG_NO_OVERLOAD +// Different warning filters needed for scripting languages (eg Python) and for statically typed languages (eg C#). +%warnfilter(509, 516) Pop::Pop; // Overloaded xxxx is shadowed by xxxx at xxx:y. | Overloaded method xxxx ignored. Method at xxx:y used. +%warnfilter(509, 516) Pop::hip; // Overloaded xxxx is shadowed by xxxx at xxx:y. | Overloaded method xxxx ignored. Method at xxx:y used. +%warnfilter(509, 516) Pop::hop; // Overloaded xxxx is shadowed by xxxx at xxx:y. | Overloaded method xxxx ignored. Method at xxx:y used. +%warnfilter(509, 516) Pop::pop; // Overloaded xxxx is shadowed by xxxx at xxx:y. | Overloaded method xxxx ignored. Method at xxx:y used. +%warnfilter(516) Pop::bop; // Overloaded method xxxx ignored. Method at xxx:y used. +%warnfilter(516) Pop::bip; // Overloaded method xxxx ignored. Method at xxx:y used. +%warnfilter(509, 516) ::muzak; // Overloaded xxxx is shadowed by xxxx at xxx:y. | Overloaded method xxxx ignored. Method at xxx:y used. + %typemap(in, numinputs=0) int l { $1 = 4711; } %inline %{ double foo(int, int, char *, int) { - return 15; + return 15; } double foo(int i, int j, double k = 17.4, int l = 18, char m = 'P') { - return i + j + k + l + (int) m; + return i + j + k + l + (int) m; } +struct Pop { + Pop(int* i) {} + Pop(int& i) {} + Pop(const int* i, bool b) {} + Pop(const int* i) {} + + // Check overloaded in const only and pointers/references which target languages cannot disambiguate + int hip(bool b) { return 701; } + int hip(int* i) { return 702; } + int hip(int& i) { return 703; } + int hip(int* i) const { return 704; } + int hip(const int* i) { return 705; } + + // Reverse the order for the above + int hop(const int* i) { return 805; } + int hop(int* i) const { return 804; } + int hop(int& i) { return 803; } + int hop(int* i) { return 802; } + int hop(bool b) { return 801; } + + // Few more variations and order shuffled + int pop(bool b) { return 901; } + int pop(int* i) const { return 902; } + int pop(int& i) { return 903; } + int pop(int* i) { return 904; } + int pop() { return 905; } + int pop(const int* i) { return 906; } + + // Overload on const only + int bop(int* i) { return 1001; } + int bop(int* i) const { return 1002; } + + int bip(int* i) const { return 2001; } + int bip(int* i) { return 2002; } +}; + +// Globals +int muzak(bool b) { return 3001; } +int muzak(int* i) { return 3002; } +int muzak(int& i) { return 3003; } +int muzak(const int* i) { return 3004; } + %} #endif diff --git a/SWIG/Examples/test-suite/python/overload_complicated_runme.py b/SWIG/Examples/test-suite/python/overload_complicated_runme.py new file mode 100755 index 000000000..2b7467d4d --- /dev/null +++ b/SWIG/Examples/test-suite/python/overload_complicated_runme.py @@ -0,0 +1,47 @@ +from overload_complicated import * + +pInt = None + +# Check the correct constructors are available +p = Pop(pInt) + +p = Pop(pInt, 0) + +# Check overloaded in const only and pointers/references which target languages cannot disambiguate +if p.hip(0) != 701: + raise RuntimeError,"Test 1 failed" + +if p.hip(pInt) != 702: + raise RuntimeError,"Test 2 failed" + +# Reverse the order for the above +if p.hop(pInt) != 805: + raise RuntimeError,"Test 3 failed" + +if p.hop(0) != 801: + raise RuntimeError,"Test 4 failed" + +# Few more variations and order shuffled +if p.pop(0) != 901: + raise RuntimeError,"Test 5 failed" + +if p.pop(pInt) != 902: + raise RuntimeError,"Test 6 failed" + +if p.pop() != 905: + raise RuntimeError,"Test 7 failed" + +# Overload on const only +if p.bop(pInt) != 1001: + raise RuntimeError,"Test 8 failed" + +if p.bip(pInt) != 2001: + raise RuntimeError,"Test 9 failed" + +# Globals +if muzak(0) != 3001: + raise RuntimeError,"Test 10 failed" + +if muzak(pInt) != 3002: + raise RuntimeError,"Test 11 failed" +