Add testcase for using declarations and templates

Examples/test-suite/common.mk

@@ -496,6 +496,7 @@ CPP_TEST_CASES += \
 	template_specialization \
 	template_specialization_defarg \
 	template_specialization_enum \
+	template_specialization_using_declaration \
 	template_static \
 	template_tbase_template \
 	template_template_parameters \

Examples/test-suite/java/template_specialization_using_declaration_runme.java

@@ -0,0 +1,45 @@
+import template_specialization_using_declaration.*;
+
+public class template_specialization_using_declaration_runme {
+
+  static {
+    try {
+	System.loadLibrary("template_specialization_using_declaration");
+    } 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[]) {
+
+    ConcreteClass cc = new ConcreteClass(11);
+
+    // Base template tests
+    BaseTemplateString bs = new BaseTemplateString();
+    bs.method_primary("hi");
+
+    BaseTemplateConcreteClass cs = new BaseTemplateConcreteClass();
+    cs.method_specialization(cc);
+
+    BaseTemplateInt bi = new BaseTemplateInt();
+    bi.method_partial_specialization(22);
+
+
+    // Derived template tests
+    DerivedTemplateString ds = new DerivedTemplateString();
+    ds.method_primary("hi");
+    ds.method_primary_derived("hi");
+    ds.method_primary_hidden("hi");
+
+    DerivedTemplateConcreteClass dc = new DerivedTemplateConcreteClass();
+    dc.method_specialization(cc);
+    dc.method_specialization_derived(cc);
+    dc.method_specialization_hidden(cc);
+
+    DerivedTemplateInt di = new DerivedTemplateInt();
+    di.method_partial_specialization(22);
+    di.method_partial_specialization_derived(22);
+    di.method_partial_specialization_hidden(22);
+  }
+}

Examples/test-suite/template_specialization_using_declaration.i

@@ -0,0 +1,73 @@
+%module template_specialization_using_declaration
+
+%include <std_string.i>
+
+%inline %{
+class ConcreteClass {
+  int val;
+public:
+  ConcreteClass(int i = 0) : val(i) {}
+  int concrete_value() { return val; }
+};
+
+namespace Space {
+// primary template class
+template<typename T>
+struct BaseTemplate {
+  void method_primary(T t) {}
+  virtual ~BaseTemplate() {}
+protected:
+  void method_primary_hidden(T t) {}
+};
+// specialized template class
+template<typename T>
+struct BaseTemplate<T *> {
+  void method_specialization(T t) {}
+  virtual ~BaseTemplate() {}
+protected:
+  void method_specialization_hidden(T t) {}
+};
+// partially specialized template class
+template<>
+struct BaseTemplate<int> {
+  void method_partial_specialization(int i) {}
+  virtual ~BaseTemplate() {}
+protected:
+  void method_partial_specialization_hidden(int t) {}
+};
+}
+%}
+
+%template(BaseTemplateString) Space::BaseTemplate<std::string>;
+%template(BaseTemplateConcreteClass) Space::BaseTemplate<ConcreteClass *>;
+%template(BaseTemplateInt) Space::BaseTemplate<int>;
+
+%inline %{
+namespace Space {
+// primary template class
+template<typename T>
+struct DerivedTemplate : BaseTemplate<T> {
+  void method_primary_derived(T t) {}
+  virtual ~DerivedTemplate() {}
+  using BaseTemplate<T>::method_primary_hidden;
+};
+// specialized template class
+template<typename T>
+struct DerivedTemplate<T *> : BaseTemplate<T *> {
+  void method_specialization_derived(T t) {}
+  virtual ~DerivedTemplate() {}
+  using BaseTemplate<T *>::method_specialization_hidden;
+};
+// partially specialized template class
+template<>
+struct DerivedTemplate<int> : BaseTemplate<int> {
+  void method_partial_specialization_derived(int i) {}
+  virtual ~DerivedTemplate() {}
+  using BaseTemplate<int>::method_partial_specialization_hidden;
+};
+}
+%}
+
+%template(DerivedTemplateString) Space::DerivedTemplate<std::string>;
+%template(DerivedTemplateConcreteClass) Space::DerivedTemplate<ConcreteClass *>;
+%template(DerivedTemplateInt) Space::DerivedTemplate<int>;