Conflicts:

.gitignore
	.project
	.travis.yml
	Examples/Makefile.in
	Examples/test-suite/director_nspace.i

Examples/test-suite/javascript/Makefile.in

@@ -0,0 +1,181 @@
+#######################################################################
+# Makefile for javascript test-suite
+#######################################################################
+
+LANGUAGE     = javascript
+SCRIPTSUFFIX = _runme.js
+srcdir       = @srcdir@
+top_srcdir   = @top_srcdir@
+top_builddir = @top_builddir@
+SWIG  = $(top_builddir)/preinst_swig
+
+ifneq (, $(ENGINE))
+	JSENGINE=$(ENGINE)
+else
+	JSENGINE=node
+endif
+
+# Note: the javascript generator is not ready yet for the real game.
+# To be able keep the behavior continously tested that is expected to work already
+# we have a 'light' version of the test-suite
+# This will be removed and replaced by a list of 'BROKEN_TEST_CASES' when
+# the number gets smaller (currently we have about 65 broken tests for JSC, and 85 for V8)
+
+ifneq (,$(SMOKE))
+
+C_TEST_CASES = \
+  preproc \
+  preproc_include
+
+CPP_TEST_CASES = \
+  abstract_access \
+  abstract_typedef \
+  abstract_typedef2 \
+  abstract_virtual \
+  arrays_global \
+  array_member \
+  char_binary \
+  class_ignore \
+  class_scope_weird \
+  complextest \
+  constover \
+  constructor_copy \
+  cpp_enum \
+  cpp_namespace \
+  cpp_static \
+  enum_template \
+  namespace_virtual_method \
+  nspace \
+  nspace_extend \
+  overload_copy \
+  rename_simple \
+  rename_scope \
+  ret_by_value \
+  struct_value \
+  template_static \
+  typedef_class \
+  typedef_inherit \
+  typedef_scope \
+  typemap_arrays \
+  typemap_delete \
+  typemap_namespace \
+  typemap_ns_using \
+  using1 \
+  using2 \
+  javascript_unicode
+
+SKIP_CPP_CASES = @SKIP_CPP_CASES@
+SKIP_C_CASES = @SKIP_C_CASES@
+SKIP_CPP_STD_CASES = @SKIP_CPP_STD_CASES@
+SKIP_MULTI_CPP_CASES = @SKIP_MULTI_CPP_CASES@
+
+endif
+
+include $(srcdir)/../common.mk
+
+_setup = \
+	if [ -f $(srcdir)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then	  \
+	  echo "$(ACTION)ing testcase $* (with run test) under javascript ($(JSENGINE))" ; \
+	else								  \
+	  echo "$(ACTION)ing testcase $* under javascript ($(JSENGINE))" ;		  \
+	fi;
+
+ifneq (jsc,$(ENGINE))
+
+  # This test can not be run with v8 as it uses v8 API incompatible output typemaps
+  typemap_variables.cpptest:
+		echo "skipping testcase typemap_variables under javascript ($(JSENGINE))."
+
+  # with v8 we have to generate C++ wrappers only
+  # these tests did raise warnings which are ignored
+  nested.ctest: SWIGOPT += -w312,-325
+  nested_structs.ctest: SWIGOPT += -w312,-325
+  unions.ctest: SWIGOPT += -w312,-325
+
+endif
+
+ifeq (node,$(JSENGINE))
+
+  SWIGOPT += -v8 -DBUILDING_NODE_EXTENSION=1
+
+  # shut up some warnings
+  # contract macro has an empty 'else' at the end...
+  aggregate.cpptest: GYP_CFLAGS = \"-Wno-empty-body\"
+  contract.cpptest: GYP_CFLAGS = \"-Wno-empty-body\"
+
+  # dunno... ignoring generously
+  apply_signed_char.cpptest: GYP_CFLAGS = \"-Wno-ignored-qualifiers\"
+  constant_pointers.cpptest: GYP_CFLAGS = \"-Wno-ignored-qualifiers\"
+  enum_thorough.cpptest: GYP_CFLAGS = \"-Wno-ignored-qualifiers\"
+
+	__setup = \
+		sh ./setup_test.sh $* $(GYP_CFLAGS); \
+		$(SWIG) -c++ -javascript $(SWIGOPT) ../$*.i;
+
+	nodejs_swig_and_compile = \
+		node-gyp --loglevel=silent --directory $* configure build 1>>/dev/null
+
+	run_testcase = \
+		if [ -f $(srcdir)/$*$(SCRIPTSUFFIX) ]; then \
+			node $(srcdir)/$*$(SCRIPTSUFFIX); \
+		fi
+
+  %.cpptest:
+		$(_setup)
+		$(__setup)
+		$(nodejs_swig_and_compile)
+		$(run_testcase)
+
+  %.ctest:
+		$(_setup)
+		$(__setup)
+		$(nodejs_swig_and_compile)
+		$(run_testcase)
+
+  %.multicpptest:
+		$(_setup)
+
+else
+
+  SWIGOPT += -$(JSENGINE)
+
+	run_testcase = \
+		if [ -f $(srcdir)/$*$(SCRIPTSUFFIX) ]; then \
+			$(top_srcdir)/Tools/javascript/javascript -$(JSENGINE) $(srcdir)/$*$(SCRIPTSUFFIX); \
+		fi
+
+  %.cpptest:
+		$(_setup)
+		+$(swig_and_compile_cpp)
+		$(run_testcase)
+
+  %.multicpptest:
+		$(_setup)
+		+$(swig_and_compile_multi_cpp)
+		$(run_testcase)
+
+endif
+
+ifeq (v8,$(ENGINE))
+  %.ctest:
+		$(_setup)
+		+$(swig_and_compile_cpp)
+		$(run_testcase)
+
+endif
+
+ifeq (jsc,$(ENGINE))
+  %.ctest:
+		$(_setup)
+		+$(swig_and_compile_c)
+		$(run_testcase)
+endif
+
+%.clean:
+	rm -rf $*
+
+clean:
+	rm -f *_wrap.cxx
+	rm -f *_wrap.c
+	rm -f *.so
+	rm -f *.o

Examples/test-suite/javascript/abstract_access_runme.js

@@ -0,0 +1,6 @@
+var abstract_access = require("./abstract_access");
+
+var d = new abstract_access.D()
+if (d.do_x() != 1) {
+   throw "Error";
+}

Examples/test-suite/javascript/abstract_inherit_runme.js

@@ -0,0 +1,40 @@
+var abstract_inherit = require("./abstract_inherit");
+
+// Shouldn't be able to instantiate any of these classes
+// since none of them implements the pure virtual function
+// declared in the base class (Foo).
+var Foo = abstract_inherit.Foo;
+var Bar = abstract_inherit.Bar;
+var Spam = abstract_inherit.Spam;
+
+var caughtException = false;
+try {
+  new Foo();
+} catch (err) {
+  caughtException = true;
+}
+if (!caughtException) {
+  throw new Error("Foo should be instantiated as it is abstract");
+}
+
+caughtException = false;
+try {
+  new Bar();
+} catch (err) {
+  caughtException = true;
+}
+
+if (!caughtException) {
+  throw new Error("Bar should be instantiated as it is abstract");
+}
+
+caughtException = false;
+try {
+  new Spam();  
+} catch (err) {
+  caughtException = true;
+}
+
+if (!caughtException) {
+  throw new Error("Spam should be instantiated as it is abstract");
+}

Examples/test-suite/javascript/abstract_typedef2_runme.js

@@ -0,0 +1,6 @@
+var abstract_typedef2 = require("./abstract_typedef2");
+
+var a = new abstract_typedef2.A_UF();
+
+if (a == undefined)
+  throw "Error";

Examples/test-suite/javascript/abstract_typedef_runme.js

@@ -0,0 +1,8 @@
+var abstract_typedef = require("./abstract_typedef");
+
+var e = new abstract_typedef.Engine();
+var a = new abstract_typedef.A()
+
+if (a.write(e) != 1) {
+  throw "Error";
+}

Examples/test-suite/javascript/abstract_virtual_runme.js

@@ -0,0 +1,11 @@
+var abstract_virtual = require("./abstract_virtual");
+
+d = new abstract_virtual.D()
+
+if (d == undefined)
+  throw "Error";
+
+e = new abstract_virtual.E()
+
+if (e == undefined)
+  throw "Error";

Examples/test-suite/javascript/array_member_runme.js

@@ -0,0 +1,22 @@
+var array_member = require("./array_member");
+
+var f = new array_member.Foo();
+f.data = array_member.global_data;
+
+for (var i=0; i<8; i++) {
+  if (array_member.get_value(f.data,i) != array_member.get_value(array_member.global_data,i)) {
+    throw "Bad array assignment (1)";
+  }
+}
+
+for (var i=0; i<8; i++) {
+  array_member.set_value(f.data,i,-i);
+}
+
+array_member.global_data = f.data;
+
+for (var i=0; i<8; i++){
+  if (array_member.get_value(f.data,i) != array_member.get_value(array_member.global_data,i)) {
+    throw "Bad array assignment (2)";
+  }
+}

Examples/test-suite/javascript/arrays_global_runme.js

@@ -0,0 +1,18 @@
+var arrays_global = require("./arrays_global");
+
+arrays_global.array_i = arrays_global.array_const_i;
+
+arrays_global.BeginString_FIX44a;
+arrays_global.BeginString_FIX44b;
+arrays_global.BeginString_FIX44c;
+arrays_global.BeginString_FIX44d;
+arrays_global.BeginString_FIX44d;
+arrays_global.BeginString_FIX44b = "12"+'\0'+"45";
+arrays_global.BeginString_FIX44b;
+arrays_global.BeginString_FIX44d;
+arrays_global.BeginString_FIX44e;
+arrays_global.BeginString_FIX44f;
+
+arrays_global.test_a("hello","hi","chello","chi");
+
+arrays_global.test_b("1234567","hi");

Examples/test-suite/javascript/callback_runme.js

@@ -0,0 +1,30 @@
+var callback = require("./callback");
+
+if (callback.foo(2) !== 2) {
+  throw new Error("Failed.");
+}
+if (callback.A_bar(2) !== 4) {
+  throw new Error("Failed.");
+}
+if (callback.foobar(3, callback.foo) != callback.foo(3)) {
+  throw new Error("Failed.");
+}
+if (callback.foobar(3, foo) != callback.foo(3)) {
+  throw new Error("Failed.");
+}
+if (callback.foobar(3, callback.A_bar) != callback.A_bar(3)) {
+  throw new Error("Failed.");
+}
+if (callback.foobar(3, callback.foof) != callback.foof(3)) {
+  throw new Error("Failed.");
+}
+if (callback.foobar_i(3, callback.foo_i) != callback.foo_i(3)) {
+  throw new Error("Failed.");
+}
+if (callback.foobar_d(3.5, callback.foo_d) != callback.foo_d(3.5)) {
+  throw new Error("Failed.");
+}
+var a = new callback.A();
+if (callback.foobarm(3, a, callback.A.foom_cb_ptr) != a.foom(3)) {
+  throw new Error("Failed.");
+}

Examples/test-suite/javascript/char_binary_runme.js

@@ -0,0 +1,38 @@
+var char_binary = require("./char_binary");
+
+var t = new char_binary.Test();
+if (t.strlen('hile') != 4) {
+  print(t.strlen('hile'));
+  throw("bad multi-arg typemap 1");
+}
+
+if (t.strlen('hil\0') != 4) {
+  throw("bad multi-arg typemap 2");
+}
+
+/*
+ *  creating a raw char*
+ */
+var pc = char_binary.new_pchar(5);
+char_binary.pchar_setitem(pc, 0, 'h');
+char_binary.pchar_setitem(pc, 1, 'o');
+char_binary.pchar_setitem(pc, 2, 'l');
+char_binary.pchar_setitem(pc, 3, 'a');
+char_binary.pchar_setitem(pc, 4, 0);
+
+
+if (t.strlen(pc) != 4) {
+  throw("bad multi-arg typemap (3)");
+}
+
+char_binary.var_pchar = pc;
+if (char_binary.var_pchar != "hola") {
+  print(char_binary.var_pchar);
+  throw("bad pointer case (1)");
+}
+
+char_binary.var_namet = pc;
+if (char_binary.var_namet != "hola") {
+  throw("bad pointer case (2)");
+}
+char_binary.delete_pchar(pc);

Examples/test-suite/javascript/char_strings_runme.js

@@ -0,0 +1,11 @@
+var char_strings = require("./char_strings");
+
+var assertIsEqual = function(expected, actual) {
+  if (expected !== actual) {
+    throw new Error("Expected "+expected+", was "+actual);
+  }
+};
+
+assertIsEqual("hi there", char_strings.CharPingPong("hi there"));
+assertIsEqual("hi there", char_strings.CharArrayPingPong("hi there"));
+assertIsEqual("hi there", char_strings.CharArrayDimsPingPong("hi there"));

Examples/test-suite/javascript/class_ignore_runme.js

@@ -0,0 +1,6 @@
+var class_ignore = require("./class_ignore");
+
+a = new class_ignore.Bar();
+
+if (class_ignore.do_blah(a) != "Bar::blah")
+    throw "Error";

Examples/test-suite/javascript/class_scope_weird_runme.js

@@ -0,0 +1,6 @@
+var class_scope_weird = require("./class_scope_weird");
+
+f = new class_scope_weird.Foo();
+g = new class_scope_weird.Foo(3);
+if (f.bar(3) != 3)
+    throw RuntimeError;

Examples/test-suite/javascript/complextest_runme.js

@@ -0,0 +1,22 @@
+var complextest = require("./complextest");
+
+a = [-1,2];
+
+expected = [-1, -2];
+
+a_c = complextest.Conj(a);
+if (a_c.toString() != expected.toString())
+  throw "Error in Conj(a)";
+
+a_c_f = complextest.Conjf(a);
+if (a_c_f.toString() != expected.toString())
+    throw "Error in Conjf(a)";
+
+v = new complextest.VectorStdCplx();
+v.add([1,2]);
+v.add([2,3]);
+v.add([4,3]);
+v.add(1);
+
+// TODO: how to check validity?
+complextest.Copy_h(v);

Examples/test-suite/javascript/constover_runme.js

@@ -0,0 +1,33 @@
+var constover = require("./constover");
+
+p = constover.test("test");
+if (p != "test") {
+    throw "test failed!";
+}
+
+p = constover.test_pconst("test");
+if (p != "test_pconst") {
+    throw "test_pconst failed!";
+}
+
+f = new constover.Foo();
+
+p = f.test("test");
+if (p != "test") {
+    throw "member-test failed!";
+}
+
+p = f.test_pconst("test");
+if (p != "test_pconst") {
+    throw "member-test_pconst failed!";
+}
+
+p = f.test_constm("test");
+if (p != "test_constmethod") {
+    throw "member-test_constm failed!";
+}
+
+p = f.test_pconstm("test");
+if (p != "test_pconstmethod") {
+    throw "member-test_pconstm failed!";
+}

Examples/test-suite/javascript/constructor_copy_runme.js

@@ -0,0 +1,42 @@
+var constructor_copy = require("./constructor_copy");
+
+f1 = new constructor_copy.Foo1(3);
+f11 = new constructor_copy.Foo1(f1);
+
+if (f1.x != f11.x) {
+  throw "error in ctor copy for Foo1";
+}
+
+var good = 0;
+
+f8 = new constructor_copy.Foo8()
+try {
+  f81 = new constructor_copy.Foo8(f8);
+  good = 0;
+} catch (err) {
+  good = 1;
+}
+
+if (good == 0) {
+  throw "Error: should not allow calling copy ctor for Foo8";
+}
+
+
+bi = new constructor_copy.Bari(5);
+bc = new constructor_copy.Bari(bi);
+
+if (bi.x != bc.x) {
+  throw "Error in copy ctor of Bari";
+}
+
+bd = new constructor_copy.Bard(5);
+try {
+  bc = new constructor_copy.Bard(bd);
+  good = 0;
+} catch (err) {
+  good = 1;
+}
+
+if (good == 0) {
+  throw "Error: should not allow calling copy ctor for Bard";
+}

Examples/test-suite/javascript/cpp_enum_runme.js

@@ -0,0 +1,28 @@
+var cpp_enum = require("./cpp_enum");
+
+var f = new cpp_enum.Foo()
+
+if(f.hola != cpp_enum.Hello){
+  print(f.hola);
+  throw "Error";
+}
+
+f.hola = cpp_enum.Foo.Hi
+if(f.hola != cpp_enum.Foo.Hi){
+  print(f.hola);
+  throw "Error";
+}
+
+f.hola = cpp_enum.Hello
+
+if(f.hola != cpp_enum.Hello){
+  print(f.hola);
+  throw "Error";
+}
+
+cpp_enum.Foo.hi = cpp_enum.Hello
+if(cpp_enum.Foo.hi != cpp_enum.Hello){
+  print(cpp_enum.Foo.hi);
+  throw "Error";
+}
+

Examples/test-suite/javascript/cpp_namespace_runme.js

@@ -0,0 +1,47 @@
+var cpp_namespace = require("./cpp_namespace");
+
+var n = cpp_namespace.fact(4);
+if (n != 24){
+    throw ("Bad return value error!");
+}
+if (cpp_namespace.Foo != 42){
+    throw ("Bad variable value error!");
+}
+
+t = new cpp_namespace.Test();
+if (t.method() != "Test::method"){
+    throw ("Bad method return value error!");
+}
+if (cpp_namespace.do_method(t) != "Test::method"){
+    throw ("Bad return value error!");
+}
+
+if (cpp_namespace.do_method2(t) != "Test::method"){
+    throw ("Bad return value error!");
+}
+cpp_namespace.weird("hello", 4);
+delete t;
+
+t2 = new cpp_namespace.Test2();
+t3 = new cpp_namespace.Test3();
+t4 = new cpp_namespace.Test4();
+t5 = new cpp_namespace.Test5();
+if (cpp_namespace.foo3(42) != 42){
+    throw ("Bad return value error!");
+}
+
+if (cpp_namespace.do_method3(t2,40) != "Test2::method"){
+    throw ("Bad return value error!");
+}
+
+if (cpp_namespace.do_method3(t3,40) != "Test3::method"){
+    throw ("Bad return value error!");
+}
+
+if (cpp_namespace.do_method3(t4,40) != "Test4::method"){
+    throw ("Bad return value error!");
+}
+
+if (cpp_namespace.do_method3(t5,40) != "Test5::method"){
+    throw ("Bad return value error!");
+}

Examples/test-suite/javascript/cpp_static_runme.js

@@ -0,0 +1,9 @@
+var cpp_static = require("./cpp_static");
+
+cpp_static.StaticFunctionTest.static_func();
+cpp_static.StaticFunctionTest.static_func_2(1);
+cpp_static.StaticFunctionTest.static_func_3(1,2);
+cpp_static.StaticMemberTest.static_int = 10;
+if (cpp_static.StaticMemberTest.static_int != 10)
+throw "error";
+

Examples/test-suite/javascript/director_alternating_runme.js

@@ -0,0 +1,5 @@
+var director_alternating = require("./director_alternating");
+
+id = director_alternating.getBar().id();
+if (id != director_alternating.idFromGetBar())
+  throw ("Error, Got wrong id: " + str(id));

Examples/test-suite/javascript/disown_runme.js

@@ -0,0 +1,22 @@
+var disown = require("./disown");
+
+var a = new disown.A();
+var tmp = a.thisown;
+a.thisown = 0
+if (a.thisown) {
+  throw new Error("Failed.");
+}
+a.thisown = 1
+if (!a.thisown) {
+  throw new Error("Failed.");
+}
+a.thisown = tmp
+if (a.thisown != tmp) {
+  throw new Error("Failed.");
+}
+
+var b = new disown.B();
+b.acquire(a);
+if (a.thisown) {
+  throw new Error("Failed.");
+}

Examples/test-suite/javascript/dynamic_cast_runme.js

@@ -0,0 +1,12 @@
+var dynamic_cast = require("./dynamic_cast");
+
+var f = new dynamic_cast.Foo();
+var b = new dynamic_cast.Bar();
+
+var x = f.blah();
+var y = b.blah();
+
+var a = dynamic_cast.do_test(y);
+if (a != "Bar::test") {
+  throw new Error("Failed.");
+}

Examples/test-suite/javascript/empty_runme.js

@@ -0,0 +1 @@
+var empty = require("./empty");

Examples/test-suite/javascript/enum_template_runme.js

@@ -0,0 +1,8 @@
+var enum_template = require("./enum_template");
+
+if (enum_template.MakeETest() != 1)
+  throw "RuntimeError";
+
+if (enum_template.TakeETest(0) != null)
+  throw "RuntimeError";
+

Examples/test-suite/javascript/infinity_runme.js

@@ -0,0 +1,4 @@
+var infinity = require("./infinity");
+
+var my_infinity = infinity.INFINTY;
+var ret_val = infinity.use_infinity(my_infinity);

Examples/test-suite/javascript/javascript_unicode_runme.js

@@ -0,0 +1,9 @@
+var javascript_unicode = require("./javascript_unicode");
+
+var str = "olé";
+
+var copy = javascript_unicode.copy_string(str);
+
+if (str !== copy) {
+	print("Error: copy is not equal: original="+str+", copy="+copy);
+}

Examples/test-suite/javascript/namespace_virtual_method_runme.js

@@ -0,0 +1,3 @@
+var namespace_virtual_method = require("./namespace_virtual_method");
+
+x = new namespace_virtual_method.Spam();

Examples/test-suite/javascript/node_template/binding.gyp.in

@@ -0,0 +1,30 @@
+{
+  "targets": [
+    {
+      "target_name": "$testcase",
+      "sources":[ "../$testcase_wrap.cxx" ],
+      "include_dirs": ["../.."],
+      'defines': [
+        'BUILDING_NODE_EXTENSION=1',
+      ],
+      'conditions': [
+        ['OS=="mac"',
+          {
+            'xcode_settings': {
+              'GCC_ENABLE_CPP_RTTI': 'YES',
+              'GCC_ENABLE_CPP_EXCEPTIONS' : 'YES'
+            }
+          }
+        ],
+        ['OS=="linux" or OS=="freebsd" or OS=="openbsd" or OS=="solaris"',
+          {
+            'cflags': [ "-Wno-unused-variable", "-Wno-unused-but-set-variable", "-Wno-unused-but-set-parameter", $cflags],
+            'cflags_cc': [ "-Wno-unused-variable", "-Wno-unused-but-set-variable", "-Wno-unused-but-set-parameter", $cflags],
+            'cflags!': [ '-fno-exceptions' ],
+            'cflags_cc!': [ '-fno-exceptions', '-fno-rtti' ]
+          }
+        ]
+      ],
+    }
+  ],
+}

Examples/test-suite/javascript/node_template/index.js.in

@@ -0,0 +1 @@
+module.exports = require('./build/Release/$testcase');

Examples/test-suite/javascript/nspace_extend_runme.js

@@ -0,0 +1,27 @@
+var nspace_extend = require("./nspace_extend");
+
+// constructors and destructors
+var color1 = new nspace_extend.Outer.Inner1.Color();
+var color = new nspace_extend.Outer.Inner1.Color(color1);
+delete color1;
+
+// class methods
+color.colorInstanceMethod(20.0);
+nspace_extend.Outer.Inner1.Color.colorStaticMethod(20.0);
+var created = nspace_extend.Outer.Inner1.Color.create();
+
+
+// constructors and destructors
+var color2 = new nspace_extend.Outer.Inner2.Color();
+color = new nspace_extend.Outer.Inner2.Color(color2);
+delete color2;
+
+// class methods
+color.colorInstanceMethod(20.0);
+nspace_extend.Outer.Inner2.Color.colorStaticMethod(20.0);
+created = nspace_extend.Outer.Inner2.Color.create();
+
+// Same class different namespaces
+var col1 = new nspace_extend.Outer.Inner1.Color();
+var col2 = nspace_extend.Outer.Inner2.Color.create();
+col2.colors(col1, col1, col2, col2, col2);

Examples/test-suite/javascript/nspace_runme.js

@@ -0,0 +1,77 @@
+var nspace = require("./nspace");
+
+var color1 = new nspace.Outer.Inner1.Color();
+var color = new nspace.Outer.Inner1.Color(color1);
+delete color1;
+
+// class methods
+color.colorInstanceMethod(20.0);
+nspace.Outer.Inner1.Color.colorStaticMethod(20.0);
+var created = nspace.Outer.Inner1.Color.create();
+
+// class enums
+var someClass = new nspace.Outer.SomeClass();
+var channel = someClass.GetInner1ColorChannel();
+if (channel != nspace.Outer.Inner1.Color.Transmission) {
+  throw new Error("Failed.");
+}
+
+// class anonymous enums
+var val1 = nspace.Outer.Inner1.Color.ColorEnumVal1;
+var val2 = nspace.Outer.Inner1.Color.ColorEnumVal2;
+if (val1 !== 0 || val2 !== 0x22) {
+  throw new Error("Failed.");
+}
+
+// instance member variables
+color.instanceMemberVariable = 123;
+if (color.instanceMemberVariable !== 123) {
+  throw new Error("Failed.");
+}
+
+// static member variables
+nspace.Outer.Inner1.Color.staticMemberVariable = 789;
+if (nspace.Outer.Inner1.Color.staticMemberVariable !== 789) {
+  throw new Error("Failed.");
+}
+
+if (nspace.Outer.Inner1.Color.staticConstMemberVariable !== 222) {
+  throw new Error("Failed.");
+}
+
+if (nspace.Outer.Inner1.Color.staticConstEnumMemberVariable !== nspace.Outer.Inner1.Color.Transmission) {
+  throw new Error("Failed.");
+}
+
+// Same class different namespaces
+var col1 = new nspace.Outer.Inner1.Color();
+var col2 = nspace.Outer.Inner2.Color.create();
+col2.colors(col1, col1, col2, col2, col2);
+
+// TODO: why isn't it scoped in the namespace???
+nspace.namespaceFunction(color);
+nspace.Outer.Inner1.namespaceVar = 111;
+if (nspace.Outer.Inner1.namespaceVar !== 111) {
+  throw new Error("Failed.");
+}
+
+// global enums
+var outerChannel1 = someClass.GetInner1Channel();
+if (outerChannel1 != nspace.Outer.Inner1.Transmission1) {
+  throw new Error("Failed.");
+}
+
+var outerChannel2 = someClass.GetInner2Channel();
+if (outerChannel2 !== nspace.Outer.Inner2.Transmission2) {
+  throw new Error("Failed.");
+}
+
+// turn feature off / ignoring
+var ns = new nspace.Outer.namespce();
+var nons = new nspace.NoNSpacePlease();
+
+// Derived class
+var blue3 = new nspace.Outer.Inner3.Blue();
+blue3.blueInstanceMethod();
+var blue4 = new nspace.Outer.Inner4.Blue();
+blue4.blueInstanceMethod();

Examples/test-suite/javascript/overload_copy_runme.js

@@ -0,0 +1,4 @@
+var overload_copy = require("./overload_copy");
+
+f = new overload_copy.Foo();
+g = new overload_copy.Foo(f);

Examples/test-suite/javascript/preproc_include_runme.js

@@ -0,0 +1,23 @@
+var preproc_include = require("./preproc_include");
+
+if (preproc_include.multiply10(10) != 100)
+  throw "RuntimeError";
+
+if (preproc_include.multiply20(10) != 200)
+  throw "RuntimeError";
+
+if (preproc_include.multiply30(10) != 300)
+  throw "RuntimeError";
+
+if (preproc_include.multiply40(10) != 400)
+  throw "RuntimeError";
+
+if (preproc_include.multiply50(10) != 500)
+  throw "RuntimeError";
+
+if (preproc_include.multiply60(10) != 600)
+  throw "RuntimeError";
+
+if (preproc_include.multiply70(10) != 700)
+  throw "RuntimeError";
+

Examples/test-suite/javascript/preproc_runme.js

@@ -0,0 +1,14 @@
+var preproc = require("./preproc");
+
+if (preproc.endif != 1)
+  throw "RuntimeError";
+
+if (preproc.define != 1)
+  throw "RuntimeError";
+
+if (preproc.defined != 1)
+  throw "RuntimeError";
+
+if (2*preproc.one != preproc.two)
+  throw "RuntimeError";
+

Examples/test-suite/javascript/rename1_runme.js

@@ -0,0 +1,68 @@
+var rename = require("./rename1");
+
+function part1() {
+  var xyz = new rename.XYZInt();
+  notxyz = new rename.NotXYZInt();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother2();
+  xyz.opT2();
+  xyz.tMethod2(0);
+  xyz.tMethodNotXYZ2(notxyz);
+  xyz.opNotXYZ2();
+  xyz.opXYZ2();
+}
+
+function part2() {
+  var xyz = new rename.XYZDouble();
+  var notxyz = new rename.NotXYZDouble();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother1();
+  xyz.opT1();
+  xyz.tMethod1(0);
+  xyz.tMethodNotXYZ1(notxyz);
+  xyz.opNotXYZ1();
+  xyz.opXYZ1();
+}
+
+function part3(){
+  var xyz = new rename.XYZKlass();
+  var notxyz = new rename.NotXYZKlass();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother3();
+  xyz.opT3();
+  xyz.tMethod3(new rename.Klass());
+  xyz.tMethodNotXYZ3(notxyz);
+  xyz.opNotXYZ3();
+  xyz.opXYZ3();
+}
+
+function part4() {
+  var xyz = new rename.XYZEnu();
+  var notxyz = new rename.NotXYZEnu();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother4();
+  xyz.opT4();
+  xyz.tMethod4(rename.En1);
+  xyz.tMethodNotXYZ4(notxyz);
+  xyz.opNotXYZ4();
+  xyz.opXYZ4();
+}
+
+function part5() {
+  var abc = new rename.ABC();
+  abc.methodABC(abc);
+  var k = new rename.Klass();
+  abc.methodKlass(k);
+  var a = abc.opABC();
+  k = abc.opKlass();
+}
+
+part1();
+part2();
+part3();
+part4();
+part5();

Examples/test-suite/javascript/rename2_runme.js

@@ -0,0 +1,68 @@
+var rename = require("./rename2");
+
+function part1() {
+  var xyz = new rename.XYZInt();
+  notxyz = new rename.NotXYZInt();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother2();
+  xyz.opT2();
+  xyz.tMethod2(0);
+  xyz.tMethodNotXYZ2(notxyz);
+  xyz.opNotXYZ2();
+  xyz.opXYZ2();
+}
+
+function part2() {
+  var xyz = new rename.XYZDouble();
+  var notxyz = new rename.NotXYZDouble();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother1();
+  xyz.opT1();
+  xyz.tMethod1(0);
+  xyz.tMethodNotXYZ1(notxyz);
+  xyz.opNotXYZ1();
+  xyz.opXYZ1();
+}
+
+function part3(){
+  var xyz = new rename.XYZKlass();
+  var notxyz = new rename.NotXYZKlass();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother3();
+  xyz.opT3();
+  xyz.tMethod3(new rename.Klass());
+  xyz.tMethodNotXYZ3(notxyz);
+  xyz.opNotXYZ3();
+  xyz.opXYZ3();
+}
+
+function part4() {
+  var xyz = new rename.XYZEnu();
+  var notxyz = new rename.NotXYZEnu();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother4();
+  xyz.opT4();
+  xyz.tMethod4(rename.En1);
+  xyz.tMethodNotXYZ4(notxyz);
+  xyz.opNotXYZ4();
+  xyz.opXYZ4();
+}
+
+function part5() {
+  var abc = new rename.ABC();
+  abc.methodABC(abc);
+  var k = new rename.Klass();
+  abc.methodKlass(k);
+  var a = abc.opABC();
+  k = abc.opKlass();
+}
+
+part1();
+part2();
+part3();
+part4();
+part5();

Examples/test-suite/javascript/rename3_runme.js

@@ -0,0 +1,68 @@
+var rename = require("./rename3");
+
+function part1() {
+  var xyz = new rename.XYZInt();
+  notxyz = new rename.NotXYZInt();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother2();
+  xyz.opT2();
+  xyz.tMethod2(0);
+  xyz.tMethodNotXYZ2(notxyz);
+  xyz.opNotXYZ2();
+  xyz.opXYZ2();
+}
+
+function part2() {
+  var xyz = new rename.XYZDouble();
+  var notxyz = new rename.NotXYZDouble();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother1();
+  xyz.opT1();
+  xyz.tMethod1(0);
+  xyz.tMethodNotXYZ1(notxyz);
+  xyz.opNotXYZ1();
+  xyz.opXYZ1();
+}
+
+function part3(){
+  var xyz = new rename.XYZKlass();
+  var notxyz = new rename.NotXYZKlass();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother3();
+  xyz.opT3();
+  xyz.tMethod3(new rename.Klass());
+  xyz.tMethodNotXYZ3(notxyz);
+  xyz.opNotXYZ3();
+  xyz.opXYZ3();
+}
+
+function part4() {
+  var xyz = new rename.XYZEnu();
+  var notxyz = new rename.NotXYZEnu();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother4();
+  xyz.opT4();
+  xyz.tMethod4(rename.En1);
+  xyz.tMethodNotXYZ4(notxyz);
+  xyz.opNotXYZ4();
+  xyz.opXYZ4();
+}
+
+function part5() {
+  var abc = new rename.ABC();
+  abc.methodABC(abc);
+  var k = new rename.Klass();
+  abc.methodKlass(k);
+  var a = abc.opABC();
+  k = abc.opKlass();
+}
+
+part1();
+part2();
+part3();
+part4();
+part5();

Examples/test-suite/javascript/rename4_runme.js

@@ -0,0 +1,68 @@
+var rename = require("./rename4");
+
+function part1() {
+  var xyz = new rename.XYZInt();
+  notxyz = new rename.NotXYZInt();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother2();
+  xyz.opT2();
+  xyz.tMethod2(0);
+  xyz.tMethodNotXYZ2(notxyz);
+  xyz.opNotXYZ2();
+  xyz.opXYZ2();
+}
+
+function part2() {
+  var xyz = new rename.XYZDouble();
+  var notxyz = new rename.NotXYZDouble();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother1();
+  xyz.opT1();
+  xyz.tMethod1(0);
+  xyz.tMethodNotXYZ1(notxyz);
+  xyz.opNotXYZ1();
+  xyz.opXYZ1();
+}
+
+function part3(){
+  var xyz = new rename.XYZKlass();
+  var notxyz = new rename.NotXYZKlass();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother3();
+  xyz.opT3();
+  xyz.tMethod3(new rename.Klass());
+  xyz.tMethodNotXYZ3(notxyz);
+  xyz.opNotXYZ3();
+  xyz.opXYZ3();
+}
+
+function part4() {
+  var xyz = new rename.XYZEnu();
+  var notxyz = new rename.NotXYZEnu();
+  xyz.opIntPtrA();
+  xyz.opIntPtrB();
+  xyz.opAnother4();
+  xyz.opT4();
+  xyz.tMethod4(rename.En1);
+  xyz.tMethodNotXYZ4(notxyz);
+  xyz.opNotXYZ4();
+  xyz.opXYZ4();
+}
+
+function part5() {
+  var abc = new rename.ABC();
+  abc.methodABC(abc);
+  var k = new rename.Klass();
+  abc.methodKlass(k);
+  var a = abc.opABC();
+  k = abc.opKlass();
+}
+
+part1();
+part2();
+part3();
+part4();
+part5();

Examples/test-suite/javascript/rename_scope_runme.js

@@ -0,0 +1,17 @@
+var rename_scope = require("./rename_scope");
+
+var a = new rename_scope.Natural_UP();
+var b = new rename_scope.Natural_BP();
+
+if (a.rtest() !== 1) {
+  throw new Error("a.rtest(): Expected 1, was " + a.rtest());
+}
+
+if (b.rtest() !== 1) {
+  throw new Error("b.rtest(): Expected 1, was " + b.rtest());
+}
+
+var f = rename_scope.equals;
+if (f === undefined) {
+  throw new Error("Equality operator has not been renamed.");
+}

Examples/test-suite/javascript/rename_simple_runme.js

@@ -0,0 +1,50 @@
+var rename_simple = require("./rename_simple");
+var NewStruct = rename_simple.NewStruct;
+
+var s = new NewStruct();
+
+// renamed instance variable
+if (s.NewInstanceVariable !== 111) {
+  throw new Error("NewInstanceVariable: Expected 111, was " + s.NewInstanceVariable);
+}
+
+// renamed instance method
+if (s.NewInstanceMethod() !== 222) {
+  throw new Error("NewInstanceMethod(): Expected 222, was " + s.NewInstanceMethod());
+}
+
+// renamed static method
+if (NewStruct.NewStaticMethod() !== 333) {
+  throw new Error("NewInstanceMethod(): Expected 333, was " + NewStruct.NewStaticMethod());
+}
+
+// renamed static variable
+if (NewStruct.NewStaticVariable !== 444) {
+  throw new Error("NewInstanceMethod(): Expected 444, was " + NewStruct.NewStaticVariable);
+}
+
+// renamed global function
+if (rename_simple.NewFunction() !== 555) {
+  throw new Error("rename_simple.NewFunction(): Expected 555, was " + rename_simple.NewFunction());
+}
+
+// renamed global variable
+if (rename_simple.NewGlobalVariable !== 666) {
+  throw new Error("rename_simple.NewGlobalVariable: Expected 666, was " + rename_simple.NewGlobalVariable);
+}
+
+// setting renamed variables
+s.NewInstanceVariable = 1111;
+if (s.NewInstanceVariable !== 1111) {
+  throw new Error("NewInstanceVariable: Expected 1111, was " + s.NewInstanceVariable);
+}
+
+NewStruct.NewStaticVariable = 4444;
+if (NewStruct.NewStaticVariable !== 4444) {
+  throw new Error("NewInstanceMethod(): Expected 4444, was " + NewStruct.NewStaticVariable);
+}
+
+rename_simple.NewGlobalVariable = 6666;
+if (rename_simple.NewGlobalVariable !== 6666) {
+  throw new Error("rename_simple.NewGlobalVariable: Expected 6666, was " + rename_simple.NewGlobalVariable);
+}

Examples/test-suite/javascript/ret_by_value_runme.js

@@ -0,0 +1,8 @@
+var ret_by_value = require("./ret_by_value");
+
+a = ret_by_value.get_test();
+if (a.myInt != 100)
+    throw "RuntimeError";
+
+if (a.myShort != 200)
+    throw "RuntimeError";

Examples/test-suite/javascript/setup_test.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+if [ ! -d $1 ]; then
+  mkdir $1;
+fi
+sed -e "s/\$testcase/$1/" -e "s/\$cflags/$2/" < node_template/binding.gyp.in > $1/binding.gyp
+sed s/\$testcase/$1/ node_template/index.js.in > $1/index.js

Examples/test-suite/javascript/struct_value_runme.js

@@ -0,0 +1,11 @@
+var struct_value = require("./struct_value");
+
+b = new struct_value.Bar();
+
+b.a.x = 3;
+if (b.a.x != 3)
+throw "RuntimeError";
+
+b.b.x = 3;
+if (b.b.x != 3)
+throw "RuntimeError"

Examples/test-suite/javascript/template_static_runme.js

@@ -0,0 +1,3 @@
+var template_static = require("./template_static");
+
+template_static.Foo.bar_double(1);

Examples/test-suite/javascript/typedef_class_runme.js

@@ -0,0 +1,7 @@
+var typedef_class = require("./typedef_class");
+
+a = new typedef_class.RealA();
+a.a = 3;
+
+b = new typedef_class.B();
+b.testA(a);

Examples/test-suite/javascript/typedef_inherit_runme.js

@@ -0,0 +1,23 @@
+var typedef_inherit = require("./typedef_inherit");
+
+a = new typedef_inherit.Foo();
+b = new typedef_inherit.Bar();
+
+x = typedef_inherit.do_blah(a);
+if (x != "Foo::blah")
+    print("Whoa! Bad return" + x);
+
+x = typedef_inherit.do_blah(b);
+if (x != "Bar::blah")
+    print("Whoa! Bad return" + x);
+
+c = new typedef_inherit.Spam();
+d = new typedef_inherit.Grok();
+
+x = typedef_inherit.do_blah2(c);
+if (x != "Spam::blah")
+    print("Whoa! Bad return" + x);
+
+x = typedef_inherit.do_blah2(d);
+if (x != "Grok::blah")
+    print ("Whoa! Bad return" + x);

Examples/test-suite/javascript/typedef_scope_runme.js

@@ -0,0 +1,12 @@
+var typedef_scope = require("./typedef_scope");
+
+b = new typedef_scope.Bar();
+x = b.test1(42,"hello");
+if (x != 42)
+    print("Failed!!");
+
+x = b.test2(42,"hello");
+if (x != "hello")
+    print("Failed!!");
+
+

Examples/test-suite/javascript/typemap_arrays_runme.js

@@ -0,0 +1,5 @@
+var typemap_arrays = require("./typemap_arrays");
+
+if (typemap_arrays.sumA(null) != 60)
+    throw "RuntimeError, Sum is wrong";
+

Examples/test-suite/javascript/typemap_delete_runme.js

@@ -0,0 +1,5 @@
+var typemap_delete = require("./typemap_delete");
+
+r = new typemap_delete.Rect(123);
+if (r.val != 123)
+    throw "RuntimeError";

Examples/test-suite/javascript/typemap_namespace_runme.js

@@ -0,0 +1,7 @@
+var typemap_namespace = require("./typemap_namespace");
+
+if (typemap_namespace.test1("hello") != "hello")
+    throw "RuntimeError";
+
+if (typemap_namespace.test2("hello") != "hello")
+    throw "RuntimeError";

Examples/test-suite/javascript/typemap_ns_using_runme.js

@@ -0,0 +1,4 @@
+var typemap_ns_using = require("./typemap_ns_using");
+
+if (typemap_ns_using.spam(37) != 37)
+    throw "RuntimeError";

Examples/test-suite/javascript/using1_runme.js

@@ -0,0 +1,4 @@
+var using1 = require("./using1");
+
+if (using1.spam(37) != 37)
+    throw "RuntimeError";

Examples/test-suite/javascript/using2_runme.js

@@ -0,0 +1,4 @@
+var using2 = require("./using2");
+
+if (using2.spam(37) != 37)
+    throw "RuntimeError";

Examples/test-suite/javascript/varargs_runme.js

@@ -0,0 +1,44 @@
+var varargs = require("./varargs");
+
+if (varargs.test("Hello") != "Hello") {
+  throw new Error("Failed");
+}
+
+var f = new varargs.Foo("Greetings")
+if (f.str != "Greetings") {
+  throw new Error("Failed");
+}
+
+if (f.test("Hello") != "Hello") {
+  throw new Error("Failed");
+}
+
+if (varargs.test_def("Hello",1) != "Hello") {
+  throw new Error("Failed");
+}
+
+if (varargs.test_def("Hello") != "Hello") {
+  throw new Error("Failed");
+}
+
+if (varargs.test_plenty("Hello") != "Hello") {
+  throw new Error("Failed");
+}
+
+if (varargs.test_plenty("Hello", 1) != "Hello") {
+  throw new Error("Failed");
+}
+
+if (varargs.test_plenty("Hello", 1, 2) != "Hello") {
+  throw new Error("Failed");
+}
+
+var thrown = false;
+try {
+  varargs.test_plenty("Hello", 1, 2, 3);
+} catch (err) {
+  thrown = true;
+}
+if (!thrown) {
+  throw new Error("Failed");
+}