diff --git a/Examples/test-suite/csharp/lib_std_string_runme.cs b/Examples/test-suite/csharp/lib_std_string_runme.cs
index b2e4ccfca..226e3751d 100644
--- a/Examples/test-suite/csharp/lib_std_string_runme.cs
+++ b/Examples/test-suite/csharp/lib_std_string_runme.cs
@@ -1,34 +1,34 @@
 using System;
-using lib_std_stringNamespace;
+using li_std_stringNamespace;
 
 public class runme
 {
     static void Main() 
     {
         // Checking expected use of %typemap(in) std::string {}
-        lib_std_string.test_value("Fee");
+        li_std_string.test_value("Fee");
 
         // Checking expected result of %typemap(out) std::string {}
-        if (lib_std_string.test_value("Fi") != "Fi")
+        if (li_std_string.test_value("Fi") != "Fi")
             throw new Exception("Test 1 failed");
 
         // Verify type-checking for %typemap(in) std::string {}
         try {
-            lib_std_string.test_value(null);
+            li_std_string.test_value(null);
             throw new Exception("Test 2 failed");
         } catch (NullReferenceException) {
         }
 
         // Checking expected use of %typemap(in) const std::string & {}
-        lib_std_string.test_const_reference("Fo");
+        li_std_string.test_const_reference("Fo");
 
         // Checking expected result of %typemap(out) const std::string& {}
-        if (lib_std_string.test_const_reference("Fum") != "Fum")
+        if (li_std_string.test_const_reference("Fum") != "Fum")
             throw new Exception("Test 3 failed");
 
         // Verify type-checking for %typemap(in) const std::string & {}
         try {
-            lib_std_string.test_const_reference(null);
+            li_std_string.test_const_reference(null);
             throw new Exception("Test 4 failed");
         } catch (NullReferenceException) {
         }
@@ -41,17 +41,17 @@ public class runme
         
         SWIGTYPE_p_std__string stringPtr = null;
         
-        stringPtr = lib_std_string.test_pointer_out();
+        stringPtr = li_std_string.test_pointer_out();
 
-        lib_std_string.test_pointer(stringPtr);
+        li_std_string.test_pointer(stringPtr);
 
-        stringPtr = lib_std_string.test_const_pointer_out();
+        stringPtr = li_std_string.test_const_pointer_out();
 
-        lib_std_string.test_const_pointer(stringPtr);
+        li_std_string.test_const_pointer(stringPtr);
 
-        stringPtr = lib_std_string.test_reference_out();
+        stringPtr = li_std_string.test_reference_out();
 
-        lib_std_string.test_reference(stringPtr);
+        li_std_string.test_reference(stringPtr);
 
     }
 }
diff --git a/Examples/test-suite/csharp/lib_typemaps_runme.cs b/Examples/test-suite/csharp/lib_typemaps_runme.cs
index b6a5090ea..fde6e8b9f 100644
--- a/Examples/test-suite/csharp/lib_typemaps_runme.cs
+++ b/Examples/test-suite/csharp/lib_typemaps_runme.cs
@@ -2,93 +2,93 @@
 // Check a few of the INPUT, OUTPUT and INOUT typemaps.
 
 using System;
-using lib_typemapsNamespace;
+using li_typemapsNamespace;
 
 public class runme
 {
   static void Main() 
   {
     // Check double INPUT typemaps
-    if (lib_typemaps.in_double(22.22) != 22.22) exit_test("in_double");
-    if (lib_typemaps.inr_double(22.22) != 22.22) exit_test("inr_double");
+    if (li_typemaps.in_double(22.22) != 22.22) exit_test("in_double");
+    if (li_typemaps.inr_double(22.22) != 22.22) exit_test("inr_double");
 
     // Check double OUTPUT typemaps
     {
       double var = 44.44;
-      lib_typemaps.out_double(22.22, out var);
+      li_typemaps.out_double(22.22, out var);
       if (var != 22.22) exit_test("out_double");
     }
     {
       double var = 44.44;
-      lib_typemaps.outr_double(22.22, out var);
+      li_typemaps.outr_double(22.22, out var);
       if (var != 22.22) exit_test("outr_double");
     }
 
     // Check double INOUT typemaps
     {
       double var = 44.44;
-      lib_typemaps.inout_double(ref var);
+      li_typemaps.inout_double(ref var);
       if (var != 44.44) exit_test("inout_double");
     }
     {
       double var = 44.44;
-      lib_typemaps.inoutr_double(ref var);
+      li_typemaps.inoutr_double(ref var);
       if (var != 44.44) exit_test("inoutr_double");
     }
 
     // Check unsigned long long INPUT typemaps
-    if (lib_typemaps.in_ulonglong(20) != 20) exit_test("in_ulonglong");
-    if (lib_typemaps.inr_ulonglong(20) != 20) exit_test("inr_ulonglong");
+    if (li_typemaps.in_ulonglong(20) != 20) exit_test("in_ulonglong");
+    if (li_typemaps.inr_ulonglong(20) != 20) exit_test("inr_ulonglong");
 
     // Check unsigned long long OUTPUT typemaps
     {
       ulong var = 40;
-      lib_typemaps.out_ulonglong(20, out var);
+      li_typemaps.out_ulonglong(20, out var);
       if (var != 20) exit_test("out_ulonglong");
     }
     {
       ulong var = 40;
-      lib_typemaps.outr_ulonglong(20, out var);
+      li_typemaps.outr_ulonglong(20, out var);
       if (var != 20) exit_test("outr_ulonglong");
     }
 
     // Check unsigned long long INOUT typemaps
     {
       ulong var = 40;
-      lib_typemaps.inout_ulonglong(ref var);
+      li_typemaps.inout_ulonglong(ref var);
       if (var != 40) exit_test("inout_ulonglong");
     }
     {
       ulong var = 40;
-      lib_typemaps.inoutr_ulonglong(ref var);
+      li_typemaps.inoutr_ulonglong(ref var);
       if (var != 40) exit_test("inoutr_ulonglong");
     }
 
     // Check unsigned bool INPUT typemaps
-    if (lib_typemaps.in_bool(false) != false) exit_test("in_bool");
-    if (lib_typemaps.inr_bool(false) != false) exit_test("inr_bool");
+    if (li_typemaps.in_bool(false) != false) exit_test("in_bool");
+    if (li_typemaps.inr_bool(false) != false) exit_test("inr_bool");
 
     // Check unsigned bool OUTPUT typemaps
     {
       bool var = false;
-      lib_typemaps.out_bool(true, out var);
+      li_typemaps.out_bool(true, out var);
       if (var != true) exit_test("out_bool");
     }
     {
       bool var = false;
-      lib_typemaps.outr_bool(true, out var);
+      li_typemaps.outr_bool(true, out var);
       if (var != true) exit_test("outr_bool");
     }
 
     // Check unsigned bool INOUT typemaps
     {
       bool var = false;
-      lib_typemaps.inout_bool(ref var);
+      li_typemaps.inout_bool(ref var);
       if (var != false) exit_test("inout_bool");
     }
     {
       bool var = false;
-      lib_typemaps.inoutr_bool(ref var);
+      li_typemaps.inoutr_bool(ref var);
       if (var != false) exit_test("inoutr_bool");
     }
   }
diff --git a/Examples/test-suite/java/lib_std_string_runme.java b/Examples/test-suite/java/lib_std_string_runme.java
index 3f222a61a..eb6a896bb 100644
--- a/Examples/test-suite/java/lib_std_string_runme.java
+++ b/Examples/test-suite/java/lib_std_string_runme.java
@@ -1,10 +1,10 @@
-import lib_std_string.*;
+import li_std_string.*;
 
-public class lib_std_string_runme {
+public class li_std_string_runme {
 
   static {
     try {
-        System.loadLibrary("lib_std_string");
+        System.loadLibrary("li_std_string");
     } 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);
@@ -14,29 +14,29 @@ public class lib_std_string_runme {
   public static void main(String argv[]) throws Throwable
   {
       // Checking expected use of %typemap(in) std::string {}
-      lib_std_string.test_value("Fee");
+      li_std_string.test_value("Fee");
 
       // Checking expected result of %typemap(out) std::string {}
-      if (!lib_std_string.test_value("Fi").equals("Fi"))
+      if (!li_std_string.test_value("Fi").equals("Fi"))
           throw new RuntimeException("Test 1 failed");
 
       // Verify type-checking for %typemap(in) std::string {}
       try {
-          lib_std_string.test_value(null);
+          li_std_string.test_value(null);
           throw new RuntimeException("Test 2 failed");
       } catch (NullPointerException e) {
       }
 
       // Checking expected use of %typemap(in) const std::string & {}
-      lib_std_string.test_const_reference("Fo");
+      li_std_string.test_const_reference("Fo");
 
       // Checking expected result of %typemap(out) const std::string& {}
-      if (!lib_std_string.test_const_reference("Fum").equals("Fum"))
+      if (!li_std_string.test_const_reference("Fum").equals("Fum"))
           throw new RuntimeException("Test 3 failed");
 
       // Verify type-checking for %typemap(in) const std::string & {}
       try {
-          lib_std_string.test_const_reference(null);
+          li_std_string.test_const_reference(null);
           throw new RuntimeException("Test 4 failed");
       } catch (NullPointerException e) {
       }
@@ -49,26 +49,26 @@ public class lib_std_string_runme {
 
       SWIGTYPE_p_std__string stringPtr = null;
 
-      stringPtr = lib_std_string.test_pointer_out();
+      stringPtr = li_std_string.test_pointer_out();
 
-      lib_std_string.test_pointer(stringPtr);
+      li_std_string.test_pointer(stringPtr);
 
-      stringPtr = lib_std_string.test_const_pointer_out();
+      stringPtr = li_std_string.test_const_pointer_out();
 
-      lib_std_string.test_const_pointer(stringPtr);
+      li_std_string.test_const_pointer(stringPtr);
 
-      stringPtr = lib_std_string.test_reference_out();
+      stringPtr = li_std_string.test_reference_out();
 
-      lib_std_string.test_reference(stringPtr);
+      li_std_string.test_reference(stringPtr);
 
       // Check throw exception specification
       try {
-          lib_std_string.test_throw();
+          li_std_string.test_throw();
           throw new Throwable("Test 5 failed");
       } catch (RuntimeException e) {
       }
       try {
-          lib_std_string.test_const_reference_throw();
+          li_std_string.test_const_reference_throw();
           throw new Throwable("Test 6 failed");
       } catch (RuntimeException e) {
       }
diff --git a/Examples/test-suite/java/lib_typemaps_runme.java b/Examples/test-suite/java/lib_typemaps_runme.java
index 2caf57b61..327b188c2 100644
--- a/Examples/test-suite/java/lib_typemaps_runme.java
+++ b/Examples/test-suite/java/lib_typemaps_runme.java
@@ -1,14 +1,14 @@
 
 // Check a few of the INPUT, OUTPUT and INOUT typemaps.
 
-import lib_typemaps.*;
+import li_typemaps.*;
 import java.math.*;
 
-public class lib_typemaps_runme {
+public class li_typemaps_runme {
 
   static {
     try {
-	System.loadLibrary("lib_typemaps");
+	System.loadLibrary("li_typemaps");
     } 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);
@@ -18,23 +18,23 @@ public class lib_typemaps_runme {
   public static void main(String argv[]) {
 
     // Check double INPUT typemaps
-    if (lib_typemaps.in_double(22.22) != 22.22) exit_test("in_double");
-    if (lib_typemaps.inr_double(22.22) != 22.22) exit_test("inr_double");
+    if (li_typemaps.in_double(22.22) != 22.22) exit_test("in_double");
+    if (li_typemaps.inr_double(22.22) != 22.22) exit_test("inr_double");
 
     // Check double OUTPUT typemaps
     {
         double[] var = {44.44};
-        lib_typemaps.out_double(22.22, var);
+        li_typemaps.out_double(22.22, var);
         if (var[0] != 22.22) exit_test("out_double");
     }
     {
         double[] var = {44.44};
-        lib_typemaps.outr_double(22.22, var);
+        li_typemaps.outr_double(22.22, var);
         if (var[0] != 22.22) exit_test("outr_double");
     }
     try {
         double[] var = null;
-        lib_typemaps.out_double(22.22, var);
+        li_typemaps.out_double(22.22, var);
         exit_test("null out_double");
     } catch (NullPointerException e) {
     }
@@ -42,17 +42,17 @@ public class lib_typemaps_runme {
     // Check double INOUT typemaps
     {
         double[] var = {44.44};
-        lib_typemaps.inout_double(var);
+        li_typemaps.inout_double(var);
         if (var[0] != 44.44) exit_test("inout_double");
     }
     {
         double[] var = {44.44};
-        lib_typemaps.inoutr_double(var);
+        li_typemaps.inoutr_double(var);
         if (var[0] != 44.44) exit_test("inoutr_double");
     }
     try {
         double[] var = null;
-        lib_typemaps.inout_double(var);
+        li_typemaps.inout_double(var);
         exit_test("null inout_double");
     } catch (NullPointerException e) {
     }
@@ -60,11 +60,11 @@ public class lib_typemaps_runme {
     // Check unsigned long long INPUT typemaps
     BigInteger forty = new BigInteger("40");
     BigInteger twenty = new BigInteger("20");
-    if (!lib_typemaps.in_ulonglong(twenty).equals(twenty)) exit_test("in_ulonglong");
-    if (!lib_typemaps.inr_ulonglong(twenty).equals(twenty)) exit_test("inr_ulonglong");
+    if (!li_typemaps.in_ulonglong(twenty).equals(twenty)) exit_test("in_ulonglong");
+    if (!li_typemaps.inr_ulonglong(twenty).equals(twenty)) exit_test("inr_ulonglong");
 
     try {
-        lib_typemaps.in_ulonglong(null);
+        li_typemaps.in_ulonglong(null);
         exit_test("null in_ulonglong");
     } catch (NullPointerException e) {
     }
@@ -72,46 +72,46 @@ public class lib_typemaps_runme {
     // Check unsigned long long OUTPUT typemaps
     {
         BigInteger[] var = {new BigInteger("40")};
-        lib_typemaps.out_ulonglong(twenty, var);
+        li_typemaps.out_ulonglong(twenty, var);
         if (!var[0].equals(twenty)) exit_test("out_ulonglong");
     }
     {
         BigInteger[] var = {new BigInteger("40")};
-        lib_typemaps.outr_ulonglong(twenty, var);
+        li_typemaps.outr_ulonglong(twenty, var);
         if (!var[0].equals(twenty)) exit_test("outr_ulonglong");
     }
     try {
         BigInteger[] var = null;
-        lib_typemaps.out_ulonglong(twenty, var);
+        li_typemaps.out_ulonglong(twenty, var);
         exit_test("null out_ulonglong");
     } catch (NullPointerException e) {
     }
     {
         BigInteger[] var = { null };
-        lib_typemaps.out_ulonglong(twenty, var);
+        li_typemaps.out_ulonglong(twenty, var);
         if (!var[0].equals(twenty)) exit_test("null element out_ulonglong");
     }
 
     // Check unsigned long long INOUT typemaps
     {
         BigInteger[] var = {new BigInteger("40")};
-        lib_typemaps.inout_ulonglong(var);
+        li_typemaps.inout_ulonglong(var);
         if (!var[0].equals(forty)) exit_test("inout_ulonglong");
     }
     {
         BigInteger[] var = {new BigInteger("40")};
-        lib_typemaps.inoutr_ulonglong(var);
+        li_typemaps.inoutr_ulonglong(var);
         if (!var[0].equals(forty)) exit_test("inoutr_ulonglong");
     }
     try {
         BigInteger[] var = null;
-        lib_typemaps.inout_ulonglong(var);
+        li_typemaps.inout_ulonglong(var);
         exit_test("null inout_ulonglong");
     } catch (NullPointerException e) {
     }
     try {
         BigInteger[] var = { null };
-        lib_typemaps.inout_ulonglong(var);
+        li_typemaps.inout_ulonglong(var);
         exit_test("null element inout_ulonglong");
     } catch (NullPointerException e) {
     }
diff --git a/Examples/test-suite/perl5/lib_std_string_runme.pl b/Examples/test-suite/perl5/lib_std_string_runme.pl
index 0372273a5..662182848 100644
--- a/Examples/test-suite/perl5/lib_std_string_runme.pl
+++ b/Examples/test-suite/perl5/lib_std_string_runme.pl
@@ -1,32 +1,32 @@
-use lib_std_string;
+use li_std_string;
 
 
 # Checking expected use of %typemap(in) std::string {}
-lib_std_string::test_value("Fee");
+li_std_string::test_value("Fee");
 
 # Checking expected result of %typemap(out) std::string {}
-if (lib_std_string::test_value("Fi") != "Fi") {
+if (li_std_string::test_value("Fi") != "Fi") {
   die "Test 1 failed";
 }
 
 ###### passing undef seems to work - surely it should fail ????
 # Verify type-checking for %typemap(in) std::string {}
-#eval { lib_std_string::test_value(undef) };
+#eval { li_std_string::test_value(undef) };
 #if (!$@) {
 #  die "Test 2 failed";
 #}
 
 # Checking expected use of %typemap(in) const std::string & {}
-lib_std_string::test_const_reference("Fo");
+li_std_string::test_const_reference("Fo");
 
 # Checking expected result of %typemap(out) const std::string& {}
-if (lib_std_string::test_const_reference("Fum") != "Fum") {
+if (li_std_string::test_const_reference("Fum") != "Fum") {
   die "Test 3 failed";
 }
 
 ###### passing undef seems to work - surely it should fail ????
 # Verify type-checking for %typemap(in) const std::string & {}
-#eval { lib_std_string::test_const_reference(undef) };
+#eval { li_std_string::test_const_reference(undef) };
 #if (!$@) {
 #  die "Test 4 failed";
 #}
@@ -39,24 +39,24 @@ if (lib_std_string::test_const_reference("Fum") != "Fum") {
 
 my $stringPtr = undef;
 
-$stringPtr = lib_std_string::test_pointer_out();
+$stringPtr = li_std_string::test_pointer_out();
 
-lib_std_string::test_pointer($stringPtr);
+li_std_string::test_pointer($stringPtr);
 
-$stringPtr = lib_std_string::test_const_pointer_out();
+$stringPtr = li_std_string::test_const_pointer_out();
 
-lib_std_string::test_const_pointer($stringPtr);
+li_std_string::test_const_pointer($stringPtr);
 
-$stringPtr = lib_std_string::test_reference_out();
+$stringPtr = li_std_string::test_reference_out();
 
-lib_std_string::test_reference($stringPtr);
+li_std_string::test_reference($stringPtr);
 
 # Check throw exception specification
-eval { lib_std_string::test_throw() };
+eval { li_std_string::test_throw() };
 if (!$@) {
   die "Test 5 failed";
 }
-eval { lib_std_string::test_const_reference_throw() };
+eval { li_std_string::test_const_reference_throw() };
 if (!$@) {
   die "Test 6 failed";
 }
diff --git a/Examples/test-suite/php4/lib_carrays_runme.php4 b/Examples/test-suite/php4/lib_carrays_runme.php4
index 134dbc251..26fd06e88 100644
--- a/Examples/test-suite/php4/lib_carrays_runme.php4
+++ b/Examples/test-suite/php4/lib_carrays_runme.php4
@@ -2,7 +2,7 @@
 // Sample test file
 
 require "tests.php4";
-require "lib_carrays.php";
+require "li_carrays.php";
 
 // No new functions
 check::functions(array(new_intarray,delete_intarray,intarray_getitem,intarray_setitem));
diff --git a/Examples/test-suite/python/lib_std_map_runme.py b/Examples/test-suite/python/lib_std_map_runme.py
index 00fe41a89..be190f101 100644
--- a/Examples/test-suite/python/lib_std_map_runme.py
+++ b/Examples/test-suite/python/lib_std_map_runme.py
@@ -1,17 +1,17 @@
-import lib_std_map
+import li_std_map
 
-a1 = lib_std_map.A(3)
-a2 = lib_std_map.A(7)
+a1 = li_std_map.A(3)
+a2 = li_std_map.A(7)
 
 
 if 1:
-  p0 = lib_std_map.pairii(1,2)
-  p1 = lib_std_map.pairA(1,a1.this)
+  p0 = li_std_map.pairii(1,2)
+  p1 = li_std_map.pairA(1,a1.this)
   m = {}
   m[1] = a1
   m[2] = a2
   
-  lib_std_map.p_identa(p1)
-  lib_std_map.m_identa(m)
+  li_std_map.p_identa(p1)
+  li_std_map.m_identa(m)
   
 
diff --git a/Examples/test-suite/python/lib_std_pair_runme.py b/Examples/test-suite/python/lib_std_pair_runme.py
index 398e2b1d4..27e291d08 100644
--- a/Examples/test-suite/python/lib_std_pair_runme.py
+++ b/Examples/test-suite/python/lib_std_pair_runme.py
@@ -1,33 +1,33 @@
-import lib_std_pair
+import li_std_pair
 
 p = (1,2)
-p1 = lib_std_pair.p_inout(p)
-p2 = lib_std_pair.p_inoutd(p1)
+p1 = li_std_pair.p_inout(p)
+p2 = li_std_pair.p_inoutd(p1)
 
-d1 = lib_std_pair.d_inout(2)
+d1 = li_std_pair.d_inout(2)
 
-i,d2 = lib_std_pair.d_inout2(2)
+i,d2 = li_std_pair.d_inout2(2)
 
-i,p = lib_std_pair.p_inout2(p)
-p3,p4 = lib_std_pair.p_inout3(p1,p1)
+i,p = li_std_pair.p_inout2(p)
+p3,p4 = li_std_pair.p_inout3(p1,p1)
 
-psi = lib_std_pair.SIPair("hello",1)
-pci = lib_std_pair.CIPair(1,1)
+psi = li_std_pair.SIPair("hello",1)
+pci = li_std_pair.CIPair(1,1)
 
 
 #psi.first = "hi"
 
 
-psi = lib_std_pair.SIPair("hi",1)
+psi = li_std_pair.SIPair("hi",1)
 if psi != ("hi",1):
   raise RuntimeError
 
-psii = lib_std_pair.SIIPair(psi,1)
+psii = li_std_pair.SIIPair(psi,1)
 
-a = lib_std_pair.A()
-b = lib_std_pair.B()
+a = li_std_pair.A()
+b = li_std_pair.B()
 
-pab = lib_std_pair.ABPair(a,b);
+pab = li_std_pair.ABPair(a,b);
 
 pab.first = a
 pab.first.val = 2
@@ -36,14 +36,14 @@ if pab.first.val != 2:
   raise RuntimeError
   
 
-pci = lib_std_pair.CIntPair(1,0)
+pci = li_std_pair.CIntPair(1,0)
 
-a = lib_std_pair.A(5)
-p1 = lib_std_pair.pairP1(1,a.this)
-p2 = lib_std_pair.pairP2(a,1)
-p3 = lib_std_pair.pairP3(a,a)
+a = li_std_pair.A(5)
+p1 = li_std_pair.pairP1(1,a.this)
+p2 = li_std_pair.pairP2(a,1)
+p3 = li_std_pair.pairP3(a,a)
 
 
-if a.val != lib_std_pair.p_identa(p1.this)[1].val:
+if a.val != li_std_pair.p_identa(p1.this)[1].val:
   raise RuntimeError
   
diff --git a/Examples/test-suite/python/lib_std_string_runme.py b/Examples/test-suite/python/lib_std_string_runme.py
index 51f7b46d1..1564da560 100644
--- a/Examples/test-suite/python/lib_std_string_runme.py
+++ b/Examples/test-suite/python/lib_std_string_runme.py
@@ -1,23 +1,23 @@
-import lib_std_string
+import li_std_string
 
 x="hello"
 
 
 
-if lib_std_string.test_ccvalue(x) != x:
+if li_std_string.test_ccvalue(x) != x:
   raise RuntimeError, "bad string mapping"
 
-if lib_std_string.test_cvalue(x) != x:
+if li_std_string.test_cvalue(x) != x:
   raise RuntimeError, "bad string mapping"
 
-if lib_std_string.test_value(x) != x:
+if li_std_string.test_value(x) != x:
   raise RuntimeError, "bad string mapping"
 
-if lib_std_string.test_const_reference(x) != x:
+if li_std_string.test_const_reference(x) != x:
   raise RuntimeError, "bad string mapping"
 
 
-s = lib_std_string.string("he")
+s = li_std_string.string("he")
 #s += "ll"
 #s.append('o')
 s += "llo"
@@ -29,21 +29,21 @@ if s != x:
 if s[1:4] != x[1:4]:
   raise RuntimeError, "bad string mapping"
 
-if lib_std_string.test_value(s) != x:
+if li_std_string.test_value(s) != x:
   raise RuntimeError, "bad string mapping"
 
-if lib_std_string.test_const_reference(s) != x:
+if li_std_string.test_const_reference(s) != x:
   raise RuntimeError, "bad string mapping"
 
-a = lib_std_string.A(s)
+a = li_std_string.A(s)
 
-if lib_std_string.test_value(a) != x:
+if li_std_string.test_value(a) != x:
   raise RuntimeError, "bad string mapping"
 
-if lib_std_string.test_const_reference(a) != x:
+if li_std_string.test_const_reference(a) != x:
   raise RuntimeError, "bad string mapping"
 
-b = lib_std_string.string(" world")
+b = li_std_string.string(" world")
 
 if a + b != "hello world":
   raise RuntimeError, "bad string mapping"
@@ -60,14 +60,14 @@ if c.find_last_of("l") != 9:
   
 s = "hello world"
 
-b = lib_std_string.B("hi")
+b = li_std_string.B("hi")
 
-b.name = lib_std_string.string("hello")
+b.name = li_std_string.string("hello")
 if b.name != "hello":
   raise RuntimeError, "bad string mapping"
 
 
-b.a = lib_std_string.A("hello")
+b.a = li_std_string.A("hello")
 if b.a != "hello":
   raise RuntimeError, "bad string mapping"
 
diff --git a/Examples/test-suite/python/lib_std_vector_runme.py b/Examples/test-suite/python/lib_std_vector_runme.py
index bf3e4891b..89e5f3968 100644
--- a/Examples/test-suite/python/lib_std_vector_runme.py
+++ b/Examples/test-suite/python/lib_std_vector_runme.py
@@ -1,4 +1,4 @@
-from lib_std_vector import *
+from li_std_vector import *
 
 iv = IntVector(4)
 for i in range(0,4):
diff --git a/Examples/test-suite/python/lib_std_wstring_runme.py b/Examples/test-suite/python/lib_std_wstring_runme.py
index 6d088373a..3e49033fd 100644
--- a/Examples/test-suite/python/lib_std_wstring_runme.py
+++ b/Examples/test-suite/python/lib_std_wstring_runme.py
@@ -1,26 +1,26 @@
-import lib_std_wstring
+import li_std_wstring
 
 x=u"h"
 
-if lib_std_wstring.test_wcvalue(x) != x:
+if li_std_wstring.test_wcvalue(x) != x:
   raise RuntimeError, "bad string mapping"
 
 x=u"hello"
-if lib_std_wstring.test_ccvalue(x) != x:
+if li_std_wstring.test_ccvalue(x) != x:
   raise RuntimeError, "bad string mapping"
 
-if lib_std_wstring.test_cvalue(x) != x:
+if li_std_wstring.test_cvalue(x) != x:
   raise RuntimeError, "bad string mapping"
 
-if lib_std_wstring.test_value(x) != x:
-  print x, lib_std_wstring.test_value(x)
+if li_std_wstring.test_value(x) != x:
+  print x, li_std_wstring.test_value(x)
   raise RuntimeError, "bad string mapping"
 
-if lib_std_wstring.test_const_reference(x) != x:
+if li_std_wstring.test_const_reference(x) != x:
   raise RuntimeError, "bad string mapping"
 
 
-s = lib_std_wstring.wstring(u"he")
+s = li_std_wstring.wstring(u"he")
 s += u"llo"
 
 if s != x:
@@ -30,21 +30,21 @@ if s != x:
 if s[1:4] != x[1:4]:
   raise RuntimeError, "bad string mapping"
 
-if lib_std_wstring.test_value(s) != x:
+if li_std_wstring.test_value(s) != x:
   raise RuntimeError, "bad string mapping"
 
-if lib_std_wstring.test_const_reference(s) != x:
+if li_std_wstring.test_const_reference(s) != x:
   raise RuntimeError, "bad string mapping"
 
-a = lib_std_wstring.A(s)
+a = li_std_wstring.A(s)
 
-if lib_std_wstring.test_value(a) != x:
+if li_std_wstring.test_value(a) != x:
   raise RuntimeError, "bad string mapping"
 
-if lib_std_wstring.test_const_reference(a) != x:
+if li_std_wstring.test_const_reference(a) != x:
   raise RuntimeError, "bad string mapping"
 
-b = lib_std_wstring.wstring(" world")
+b = li_std_wstring.wstring(" world")
 
 if a + b != "hello world":
   raise RuntimeError, "bad string mapping"
@@ -61,14 +61,14 @@ if c.find_last_of("l") != 9:
   
 s = "hello world"
 
-b = lib_std_wstring.B("hi")
+b = li_std_wstring.B("hi")
 
-b.name = lib_std_wstring.wstring(u"hello")
+b.name = li_std_wstring.wstring(u"hello")
 if b.name != "hello":
   raise RuntimeError, "bad string mapping"
 
 
-b.a = lib_std_wstring.A("hello")
+b.a = li_std_wstring.A("hello")
 if b.a != u"hello":
   raise RuntimeError, "bad string mapping"
 
diff --git a/Examples/test-suite/ruby/lib_carrays_runme.rb b/Examples/test-suite/ruby/lib_carrays_runme.rb
index dd8a2c6c3..d133526f9 100644
--- a/Examples/test-suite/ruby/lib_carrays_runme.rb
+++ b/Examples/test-suite/ruby/lib_carrays_runme.rb
@@ -1,4 +1,4 @@
-require 'lib_carrays'
+require 'li_carrays'
 
 include Lib_carrays
 
diff --git a/Examples/test-suite/ruby/lib_std_deque_runme.rb b/Examples/test-suite/ruby/lib_std_deque_runme.rb
index fc3940341..24a84b78d 100644
--- a/Examples/test-suite/ruby/lib_std_deque_runme.rb
+++ b/Examples/test-suite/ruby/lib_std_deque_runme.rb
@@ -1,4 +1,4 @@
-require 'lib_std_deque'
+require 'li_std_deque'
 
 include Lib_std_deque
 
diff --git a/Examples/test-suite/ruby/lib_std_pair_runme.rb b/Examples/test-suite/ruby/lib_std_pair_runme.rb
index 3a3427577..dbb36529e 100755
--- a/Examples/test-suite/ruby/lib_std_pair_runme.rb
+++ b/Examples/test-suite/ruby/lib_std_pair_runme.rb
@@ -1,4 +1,4 @@
-require 'lib_std_pair'
+require 'li_std_pair'
 
 include Lib_std_pair
 
@@ -30,7 +30,7 @@ raise RuntimeError unless (intPairConstRef.first == 7 && intPairConstRef.second
 #
 # Now test various input typemaps. Each of the wrapped C++ functions
 # (product1, product2 and product3) is expecting an argument of a
-# different type (see lib_std_pair.i). Typemaps should be in place to
+# different type (see li_std_pair.i). Typemaps should be in place to
 # convert this Array into the expected argument type.
 #
 raise RuntimeError unless product1(intPair) == 42
diff --git a/Examples/test-suite/ruby/lib_std_string_runme.rb b/Examples/test-suite/ruby/lib_std_string_runme.rb
index dbf96810c..8836a05a0 100644
--- a/Examples/test-suite/ruby/lib_std_string_runme.rb
+++ b/Examples/test-suite/ruby/lib_std_string_runme.rb
@@ -1,4 +1,4 @@
-require 'lib_std_string'
+require 'li_std_string'
 
 include Lib_std_string
 
diff --git a/Examples/test-suite/ruby/lib_std_vector_runme.rb b/Examples/test-suite/ruby/lib_std_vector_runme.rb
index 587495f8d..4340377ea 100755
--- a/Examples/test-suite/ruby/lib_std_vector_runme.rb
+++ b/Examples/test-suite/ruby/lib_std_vector_runme.rb
@@ -1,4 +1,4 @@
-require 'lib_std_vector'
+require 'li_std_vector'
 
 include Lib_std_vector