Index: Externals/Eagle/bin/EagleShell.exe.config
==================================================================
--- Externals/Eagle/bin/EagleShell.exe.config
+++ Externals/Eagle/bin/EagleShell.exe.config
@@ -16,10 +16,11 @@
     <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0" />
   </startup>
 
   <runtime>
     <!--
+    <legacyCorruptedStateExceptionsPolicy enabled="true" />
     <NetFx40_LegacySecurityPolicy enabled="true" />
     <generatePublisherEvidence enabled="false" />
     -->
 
     <!--

Index: Externals/Eagle/lib/Eagle1.0/test.eagle
==================================================================
--- Externals/Eagle/lib/Eagle1.0/test.eagle
+++ Externals/Eagle/lib/Eagle1.0/test.eagle
@@ -124,10 +124,29 @@
       }
     }
 
     return $result
   }
+
+  proc removeConstraint { name } {
+    if {[isEagle]} then {
+      if {[info exists ::eagle_tests(constraints)]} then {
+        set index [lsearch -exact $::eagle_tests(constraints) $name]
+
+        if {$index != -1} then {
+          set ::eagle_tests(constraints) [lreplace \
+              $::eagle_tests(constraints) $index $index]
+        }
+      }
+    } else {
+      if {[info exists ::tcltest::testConstraints($name)]} then {
+        unset ::tcltest::testConstraints($name)
+      }
+    }
+
+    return ""
+  }
 
   proc fixConstraints { constraints } {
     set result [string trim $constraints]
 
     if {[string length $result] > 0} then {
@@ -1814,11 +1833,11 @@
         processTestArguments getTemporaryPath getTestLog getTestLogId getFiles \
         getConstraints getTestFiles getTestRunId execTestShell runTestPrologue \
         runTestEpilogue runTest runAllTests fixConstraints sourceIfValid \
         isExitOnComplete getPassPercentage getSkipPercentage testExec tlog \
         returnInfoScript tputs formatDecimal formatList configureTcltest \
-        machineToPlatform tsource testShim] false false
+        removeConstraint machineToPlatform tsource testShim] false false
 
     ###########################################################################
     ############################## END Tcl ONLY ###############################
     ###########################################################################
   }

Index: System.Data.SQLite/SQLite3.cs
==================================================================
--- System.Data.SQLite/SQLite3.cs
+++ System.Data.SQLite/SQLite3.cs
@@ -115,11 +115,11 @@
     {
       if (_sql != null)
       {
           if (_usePool)
           {
-              SQLiteBase.ResetConnection(_sql);
+              SQLiteBase.ResetConnection(_sql, _sql);
               SQLiteConnectionPool.Add(_fileName, _sql, _poolVersion);
 
 #if DEBUG && !NET_COMPACT_20
               Trace.WriteLine(String.Format("Close (Pool): {0}", _sql));
 #endif
@@ -286,15 +286,26 @@
 
     internal override void ClearPool()
     {
       SQLiteConnectionPool.ClearPool(_fileName);
     }
+
+    internal override int CountPool()
+    {
+        Dictionary<string, int> counts = null;
+        int totalCount = 0;
+
+        SQLiteConnectionPool.GetCounts(_fileName,
+            ref counts, ref totalCount);
+
+        return totalCount;
+    }
 
     internal override void SetTimeout(int nTimeoutMS)
     {
       int n = UnsafeNativeMethods.sqlite3_busy_timeout(_sql, nTimeoutMS);
-      if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+      if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override bool Step(SQLiteStatement stmt)
     {
       int n;
@@ -317,11 +328,11 @@
           // schema has changed, re-try the step again.  If it errored our because the database
           // is locked, then keep retrying until the command timeout occurs.
           r = Reset(stmt);
 
           if (r == 0)
-            throw new SQLiteException(n, SQLiteLastError());
+            throw new SQLiteException(n, GetLastError());
 
           else if ((r == 6 || r == 5) && stmt._command != null) // SQLITE_LOCKED || SQLITE_BUSY
           {
             // Keep trying
             if (rnd == null) // First time we've encountered the lock
@@ -328,11 +339,11 @@
               rnd = new Random();
 
             // If we've exceeded the command's timeout, give up and throw an error
             if ((uint)Environment.TickCount - starttick > timeout)
             {
-              throw new SQLiteException(r, SQLiteLastError());
+              throw new SQLiteException(r, GetLastError());
             }
             else
             {
               // Otherwise sleep for a random amount of time up to 150ms
               System.Threading.Thread.Sleep(rnd.Next(1, 150));
@@ -372,18 +383,18 @@
       }
       else if (n == 6 || n == 5) // SQLITE_LOCKED || SQLITE_BUSY
         return n;
 
       if (n > 0)
-        throw new SQLiteException(n, SQLiteLastError());
+        throw new SQLiteException(n, GetLastError());
 
       return 0; // We reset OK, no schema changes
     }
 
-    internal override string SQLiteLastError()
+    internal override string GetLastError()
     {
-      return SQLiteBase.SQLiteLastError(_sql);
+      return SQLiteBase.GetLastError(_sql, _sql);
     }
 
     internal override SQLiteStatement Prepare(SQLiteConnection cnn, string strSql, SQLiteStatement previous, uint timeoutMS, out string strRemain)
     {
       if (!String.IsNullOrEmpty(strSql))
@@ -449,11 +460,11 @@
 
           if (n == 17)
             retries++;
           else if (n == 1)
           {
-            if (String.Compare(SQLiteLastError(), "near \"TYPES\": syntax error", StringComparison.OrdinalIgnoreCase) == 0)
+            if (String.Compare(GetLastError(), "near \"TYPES\": syntax error", StringComparison.OrdinalIgnoreCase) == 0)
             {
               int pos = strSql.IndexOf(';');
               if (pos == -1) pos = strSql.Length - 1;
 
               typedefs = strSql.Substring(0, pos + 1);
@@ -471,11 +482,11 @@
                 cmd.SetTypes(typedefs);
 
               return cmd;
             }
 #if !PLATFORM_COMPACTFRAMEWORK
-            else if (_buildingSchema == false && String.Compare(SQLiteLastError(), 0, "no such table: TEMP.SCHEMA", 0, 26, StringComparison.OrdinalIgnoreCase) == 0)
+            else if (_buildingSchema == false && String.Compare(GetLastError(), 0, "no such table: TEMP.SCHEMA", 0, 26, StringComparison.OrdinalIgnoreCase) == 0)
             {
               strRemain = "";
               _buildingSchema = true;
               try
               {
@@ -506,21 +517,21 @@
               rnd = new Random();
 
             // If we've exceeded the command's timeout, give up and throw an error
             if ((uint)Environment.TickCount - starttick > timeoutMS)
             {
-              throw new SQLiteException(n, SQLiteLastError());
+              throw new SQLiteException(n, GetLastError());
             }
             else
             {
               // Otherwise sleep for a random amount of time up to 150ms
               System.Threading.Thread.Sleep(rnd.Next(1, 150));
             }
           }
         }
 
-        if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+        if (n > 0) throw new SQLiteException(n, GetLastError());
 
         strRemain = UTF8ToString(ptr, len);
 
         if (stmt != IntPtr.Zero) cmd = new SQLiteStatement(this, flags, stmt, strSql.Substring(0, strSql.Length - strRemain.Length), previous);
 
@@ -621,11 +632,11 @@
 
         int n = UnsafeNativeMethods.sqlite3_bind_double(handle, index, value);
 #else
         int n = UnsafeNativeMethods.sqlite3_bind_double_interop(handle, index, ref value);
 #endif
-        if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+        if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override void Bind_Int32(SQLiteStatement stmt, SQLiteConnectionFlags flags, int index, int value)
     {
         SQLiteStatementHandle handle = stmt._sqlite_stmt;
@@ -636,11 +647,11 @@
             LogBind(handle, index, value);
         }
 #endif
 
         int n = UnsafeNativeMethods.sqlite3_bind_int(handle, index, value);
-        if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+        if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override void Bind_UInt32(SQLiteStatement stmt, SQLiteConnectionFlags flags, int index, uint value)
     {
         SQLiteStatementHandle handle = stmt._sqlite_stmt;
@@ -651,11 +662,11 @@
             LogBind(handle, index, value);
         }
 #endif
 
         int n = UnsafeNativeMethods.sqlite3_bind_uint(handle, index, value);
-        if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+        if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override void Bind_Int64(SQLiteStatement stmt, SQLiteConnectionFlags flags, int index, long value)
     {
         SQLiteStatementHandle handle = stmt._sqlite_stmt;
@@ -668,11 +679,11 @@
 
         int n = UnsafeNativeMethods.sqlite3_bind_int64(handle, index, value);
 #else
         int n = UnsafeNativeMethods.sqlite3_bind_int64_interop(handle, index, ref value);
 #endif
-        if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+        if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override void Bind_UInt64(SQLiteStatement stmt, SQLiteConnectionFlags flags, int index, ulong value)
     {
         SQLiteStatementHandle handle = stmt._sqlite_stmt;
@@ -685,11 +696,11 @@
 
         int n = UnsafeNativeMethods.sqlite3_bind_uint64(handle, index, value);
 #else
         int n = UnsafeNativeMethods.sqlite3_bind_uint64_interop(handle, index, ref value);
 #endif
-        if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+        if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override void Bind_Text(SQLiteStatement stmt, SQLiteConnectionFlags flags, int index, string value)
     {
         SQLiteStatementHandle handle = stmt._sqlite_stmt;
@@ -709,11 +720,11 @@
             LogBind(handle, index, b);
         }
 #endif
 
         int n = UnsafeNativeMethods.sqlite3_bind_text(handle, index, b, b.Length - 1, (IntPtr)(-1));
-        if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+        if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override void Bind_DateTime(SQLiteStatement stmt, SQLiteConnectionFlags flags, int index, DateTime dt)
     {
         SQLiteStatementHandle handle = stmt._sqlite_stmt;
@@ -739,11 +750,11 @@
 
                     int n = UnsafeNativeMethods.sqlite3_bind_int64(handle, index, value);
 #else
                     int n = UnsafeNativeMethods.sqlite3_bind_int64_interop(handle, index, ref value);
 #endif
-                    if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+                    if (n > 0) throw new SQLiteException(n, GetLastError());
                     break;
                 }
             case SQLiteDateFormats.JulianDay:
                 {
                     double value = ToJulianDay(dt);
@@ -756,11 +767,11 @@
 
                     int n = UnsafeNativeMethods.sqlite3_bind_double(handle, index, value);
 #else
                     int n = UnsafeNativeMethods.sqlite3_bind_double_interop(handle, index, ref value);
 #endif
-                    if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+                    if (n > 0) throw new SQLiteException(n, GetLastError());
                     break;
                 }
             case SQLiteDateFormats.UnixEpoch:
                 {
                     long value = Convert.ToInt64(dt.Subtract(UnixEpoch).TotalSeconds);
@@ -773,11 +784,11 @@
 
                     int n = UnsafeNativeMethods.sqlite3_bind_int64(handle, index, value);
 #else
                     int n = UnsafeNativeMethods.sqlite3_bind_int64_interop(handle, index, ref value);
 #endif
-                    if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+                    if (n > 0) throw new SQLiteException(n, GetLastError());
                     break;
                 }
             default:
                 {
                     byte[] b = ToUTF8(dt);
@@ -788,11 +799,11 @@
                         LogBind(handle, index, b);
                     }
 #endif
 
                     int n = UnsafeNativeMethods.sqlite3_bind_text(handle, index, b, b.Length - 1, (IntPtr)(-1));
-                    if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+                    if (n > 0) throw new SQLiteException(n, GetLastError());
                     break;
                 }
         }
     }
 
@@ -806,11 +817,11 @@
             LogBind(handle, index, blobData);
         }
 #endif
 
         int n = UnsafeNativeMethods.sqlite3_bind_blob(handle, index, blobData, blobData.Length, (IntPtr)(-1));
-        if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+        if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override void Bind_Null(SQLiteStatement stmt, SQLiteConnectionFlags flags, int index)
     {
         SQLiteStatementHandle handle = stmt._sqlite_stmt;
@@ -821,11 +832,11 @@
             LogBind(handle, index);
         }
 #endif
 
         int n = UnsafeNativeMethods.sqlite3_bind_null(handle, index);
-        if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+        if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override int Bind_ParamCount(SQLiteStatement stmt, SQLiteConnectionFlags flags)
     {
         SQLiteStatementHandle handle = stmt._sqlite_stmt;
@@ -1005,11 +1016,11 @@
       dtLen = -1;
       csLen = -1;
 
       n = UnsafeNativeMethods.sqlite3_table_column_metadata(_sql, ToUTF8(dataBase), ToUTF8(table), ToUTF8(column), out dataTypePtr, out collSeqPtr, out nnotNull, out nprimaryKey, out nautoInc);
 #endif
-      if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+      if (n > 0) throw new SQLiteException(n, GetLastError());
 
       dataType = UTF8ToString(dataTypePtr, dtLen);
       collateSequence = UTF8ToString(collSeqPtr, csLen);
 
       notNull = (nnotNull == 1);
@@ -1129,18 +1140,18 @@
       if (n == 0) n = UnsafeNativeMethods.sqlite3_create_function_interop(_sql, ToUTF8(strFunction), nArgs, 1, IntPtr.Zero, func, funcstep, funcfinal, (needCollSeq == true) ? 1 : 0);
 #else
       n = UnsafeNativeMethods.sqlite3_create_function(_sql, ToUTF8(strFunction), nArgs, 4, IntPtr.Zero, func, funcstep, funcfinal);
       if (n == 0) n = UnsafeNativeMethods.sqlite3_create_function(_sql, ToUTF8(strFunction), nArgs, 1, IntPtr.Zero, func, funcstep, funcfinal);
 #endif
-      if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+      if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override void CreateCollation(string strCollation, SQLiteCollation func, SQLiteCollation func16)
     {
       int n = UnsafeNativeMethods.sqlite3_create_collation(_sql, ToUTF8(strCollation), 2, IntPtr.Zero, func16);
       if (n == 0) n = UnsafeNativeMethods.sqlite3_create_collation(_sql, ToUTF8(strCollation), 1, IntPtr.Zero, func);
-      if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+      if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override int ContextCollateCompare(CollationEncodingEnum enc, IntPtr context, string s1, string s2)
     {
 #if !SQLITE_STANDARD
@@ -1360,17 +1371,17 @@
 
 #if INTEROP_CODEC
     internal override void SetPassword(byte[] passwordBytes)
     {
       int n = UnsafeNativeMethods.sqlite3_key(_sql, passwordBytes, passwordBytes.Length);
-      if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+      if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override void ChangePassword(byte[] newPasswordBytes)
     {
       int n = UnsafeNativeMethods.sqlite3_rekey(_sql, newPasswordBytes, (newPasswordBytes == null) ? 0 : newPasswordBytes.Length);
-      if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+      if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 #endif
 
     internal override void SetUpdateHook(SQLiteUpdateCallback func)
     {
@@ -1459,11 +1470,11 @@
 
         IntPtr backup = UnsafeNativeMethods.sqlite3_backup_init(
             destHandle, zDestName, sourceHandle, zSourceName);
 
         if (backup == IntPtr.Zero)
-            throw new SQLiteException(ResultCode(), SQLiteLastError());
+            throw new SQLiteException(ResultCode(), GetLastError());
 
         return new SQLiteBackup(
             this, backup, destHandle, zDestName, sourceHandle, zSourceName);
     }
 
@@ -1520,11 +1531,11 @@
         {
             return false;
         }
         else
         {
-            throw new SQLiteException(n, SQLiteLastError());
+            throw new SQLiteException(n, GetLastError());
         }
     }
 
     /// <summary>
     /// Returns the number of pages remaining to be copied from the source
@@ -1591,11 +1602,11 @@
 
         int n = UnsafeNativeMethods.sqlite3_backup_finish(handle);
         handle.SetHandleAsInvalid();
 
         if ((n > 0) && (n != backup._stepResult))
-            throw new SQLiteException(n, SQLiteLastError());
+            throw new SQLiteException(n, GetLastError());
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
 
     /// <summary>

Index: System.Data.SQLite/SQLite3_UTF16.cs
==================================================================
--- System.Data.SQLite/SQLite3_UTF16.cs
+++ System.Data.SQLite/SQLite3_UTF16.cs
@@ -167,11 +167,11 @@
             LogBind(handle, index, value);
         }
 #endif
 
         int n = UnsafeNativeMethods.sqlite3_bind_text16(handle, index, value, value.Length * 2, (IntPtr)(-1));
-        if (n > 0) throw new SQLiteException(n, SQLiteLastError());
+        if (n > 0) throw new SQLiteException(n, GetLastError());
     }
 
     internal override DateTime GetDateTime(SQLiteStatement stmt, int index)
     {
       return ToDateTime(GetText(stmt, index));

Index: System.Data.SQLite/SQLiteBase.cs
==================================================================
--- System.Data.SQLite/SQLiteBase.cs
+++ System.Data.SQLite/SQLiteBase.cs
@@ -16,12 +16,10 @@
   internal abstract class SQLiteBase : SQLiteConvert, IDisposable
   {
     internal SQLiteBase(SQLiteDateFormats fmt, DateTimeKind kind)
       : base(fmt, kind) { }
 
-    static internal object _lock = new object();
-
     /// <summary>
     /// Returns a string representing the active version of SQLite
     /// </summary>
     internal abstract string Version { get; }
     /// <summary>
@@ -78,17 +76,23 @@
     internal abstract void SetTimeout(int nTimeoutMS);
     /// <summary>
     /// Returns the text of the last error issued by SQLite
     /// </summary>
     /// <returns></returns>
-    internal abstract string SQLiteLastError();
+    internal abstract string GetLastError();
 
     /// <summary>
     /// When pooling is enabled, force this connection to be disposed rather than returned to the pool
     /// </summary>
     internal abstract void ClearPool();
 
+    /// <summary>
+    /// When pooling is enabled, returns the number of pool entries matching the current file name.
+    /// </summary>
+    /// <returns>The number of pool entries matching the current file name.</returns>
+    internal abstract int CountPool();
+
     /// <summary>
     /// Prepares a SQL statement for execution.
     /// </summary>
     /// <param name="cnn">The source connection preparing the command.  Can be null for any caller except LINQ</param>
     /// <param name="strSql">The SQL command text to prepare</param>
@@ -338,87 +342,91 @@
     // These statics are here for lack of a better place to put them.
     // They exist here because they are called during the finalization of
     // a SQLiteStatementHandle, SQLiteConnectionHandle, and SQLiteFunctionCookieHandle.
     // Therefore these functions have to be static, and have to be low-level.
 
-    internal static string SQLiteLastError(SQLiteConnectionHandle db)
-    {
-#if !SQLITE_STANDARD
-      int len;
-      return UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg_interop(db, out len), len);
-#else
-      return UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg(db), -1);
-#endif
-    }
-
-    internal static void FinishBackup(SQLiteBackupHandle backup)
-    {
-        lock (_lock)
-        {
-            int n = UnsafeNativeMethods.sqlite3_backup_finish(backup);
-            backup.SetHandleAsInvalid();
-            if (n > 0) throw new SQLiteException(n, null);
-        }
-    }
-
-    internal static void FinalizeStatement(SQLiteStatementHandle stmt)
-    {
-      lock (_lock)
-      {
+    internal static string GetLastError(SQLiteConnectionHandle hdl, IntPtr db)
+    {
+        if ((hdl == null) || (db == IntPtr.Zero))
+            return "invalid connection or database handle";
+
+        lock (hdl)
+        {
+#if !SQLITE_STANDARD
+            int len;
+            return UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg_interop(db, out len), len);
+#else
+            return UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg(db), -1);
+#endif
+        }
+    }
+
+    internal static void FinishBackup(IntPtr backup)
+    {
+        if (backup == IntPtr.Zero) return;
+        int n = UnsafeNativeMethods.sqlite3_backup_finish(backup);
+        if (n > 0) throw new SQLiteException(n, null);
+    }
+
+    internal static void FinalizeStatement(IntPtr stmt)
+    {
+        if (stmt == IntPtr.Zero) return;
 #if !SQLITE_STANDARD
         int n = UnsafeNativeMethods.sqlite3_finalize_interop(stmt);
 #else
-      int n = UnsafeNativeMethods.sqlite3_finalize(stmt);
-#endif
-        if (n > 0) throw new SQLiteException(n, null);
-      }
-    }
-
-    internal static void CloseConnection(SQLiteConnectionHandle db)
-    {
-      lock (_lock)
-      {
-#if !SQLITE_STANDARD
-        int n = UnsafeNativeMethods.sqlite3_close_interop(db);
-#else
-      ResetConnection(db);
-      int n = UnsafeNativeMethods.sqlite3_close(db);
-#endif
-        if (n > 0) throw new SQLiteException(n, SQLiteLastError(db));
-      }
-    }
-
-    internal static void ResetConnection(SQLiteConnectionHandle db)
-    {
-      lock (_lock)
-      {
-        IntPtr stmt = IntPtr.Zero;
-        int n;
-        do
-        {
-          stmt = UnsafeNativeMethods.sqlite3_next_stmt(db, stmt);
-          if (stmt != IntPtr.Zero)
-          {
-#if !SQLITE_STANDARD
-            n = UnsafeNativeMethods.sqlite3_reset_interop(stmt);
-#else
-            n = UnsafeNativeMethods.sqlite3_reset(stmt);
-#endif
-          }
-        } while (stmt != IntPtr.Zero);
-
-        if (IsAutocommit(db) == false) // a transaction is pending on the connection
-        {
-          n = UnsafeNativeMethods.sqlite3_exec(db, ToUTF8("ROLLBACK"), IntPtr.Zero, IntPtr.Zero, out stmt);
-          if (n > 0) throw new SQLiteException(n, SQLiteLastError(db));
-        }
-      }
-    }
-
-    internal static bool IsAutocommit(SQLiteConnectionHandle hdl)
-    {
-      return (UnsafeNativeMethods.sqlite3_get_autocommit(hdl) == 1);
+        int n = UnsafeNativeMethods.sqlite3_finalize(stmt);
+#endif
+        if (n > 0) throw new SQLiteException(n, null);
+    }
+
+    internal static void CloseConnection(SQLiteConnectionHandle hdl, IntPtr db)
+    {
+        if ((hdl == null) || (db == IntPtr.Zero)) return;
+        lock (hdl)
+        {
+#if !SQLITE_STANDARD
+            int n = UnsafeNativeMethods.sqlite3_close_interop(db);
+#else
+            ResetConnection(hdl, db);
+            int n = UnsafeNativeMethods.sqlite3_close(db);
+#endif
+            if (n > 0) throw new SQLiteException(n, GetLastError(hdl, db));
+        }
+    }
+
+    internal static void ResetConnection(SQLiteConnectionHandle hdl, IntPtr db)
+    {
+        if ((hdl == null) || (db == IntPtr.Zero)) return;
+        lock (hdl)
+        {
+            IntPtr stmt = IntPtr.Zero;
+            int n;
+            do
+            {
+                stmt = UnsafeNativeMethods.sqlite3_next_stmt(db, stmt);
+                if (stmt != IntPtr.Zero)
+                {
+#if !SQLITE_STANDARD
+                    n = UnsafeNativeMethods.sqlite3_reset_interop(stmt);
+#else
+                    n = UnsafeNativeMethods.sqlite3_reset(stmt);
+#endif
+                }
+            } while (stmt != IntPtr.Zero);
+
+            if (IsAutocommit(db) == false) // a transaction is pending on the connection
+            {
+                n = UnsafeNativeMethods.sqlite3_exec(db, ToUTF8("ROLLBACK"), IntPtr.Zero, IntPtr.Zero, out stmt);
+                if (n > 0) throw new SQLiteException(n, GetLastError(hdl, db));
+            }
+        }
+    }
+
+    internal static bool IsAutocommit(IntPtr db)
+    {
+      if (db == IntPtr.Zero) return false;
+      return (UnsafeNativeMethods.sqlite3_get_autocommit(db) == 1);
     }
 
   }
 
   internal interface ISQLiteSchemaExtensions

Index: System.Data.SQLite/SQLiteConnection.cs
==================================================================
--- System.Data.SQLite/SQLiteConnection.cs
+++ System.Data.SQLite/SQLiteConnection.cs
@@ -670,10 +670,22 @@
         }
         _transactionLevel = 0;
       }
       OnStateChange(ConnectionState.Closed);
     }
+
+    /// <summary>
+    /// Returns the number of pool entries for the file name associated with this connection.
+    /// </summary>
+    public int PoolCount
+    {
+        get
+        {
+            if (_sql == null) return 0;
+            return _sql.CountPool();
+        }
+    }
 
     /// <summary>
     /// Clears the connection pool associated with the connection.  Any other active connections using the same database file
     /// will be discarded instead of returned to the pool when they are closed.
     /// </summary>

Index: System.Data.SQLite/SQLiteConnectionPool.cs
==================================================================
--- System.Data.SQLite/SQLiteConnectionPool.cs
+++ System.Data.SQLite/SQLiteConnectionPool.cs
@@ -36,10 +36,60 @@
 
     /// <summary>
     /// The default version number new pools will get
     /// </summary>
     private static int _poolVersion = 1;
+
+    /// <summary>
+    /// Counts the number of pool entries matching the specified file name.
+    /// </summary>
+    /// <param name="fileName">The file name to match or null to match all files.</param>
+    /// <param name="counts">The pool entry counts for each matching file.</param>
+    /// <param name="totalCount">The total number of pool entries for all matching files.</param>
+    internal static void GetCounts(
+        string fileName,
+        ref Dictionary<string, int> counts,
+        ref int totalCount
+        )
+    {
+        lock (_connections)
+        {
+            if (counts == null)
+            {
+                counts = new Dictionary<string, int>(
+                    StringComparer.OrdinalIgnoreCase);
+            }
+
+            if (fileName != null)
+            {
+                Pool queue;
+
+                if (_connections.TryGetValue(fileName, out queue))
+                {
+                    Queue<WeakReference> poolQueue = queue.Queue;
+                    int count = (poolQueue != null) ? poolQueue.Count : 0;
+
+                    counts.Add(fileName, count);
+                    totalCount += count;
+                }
+            }
+            else
+            {
+                foreach (KeyValuePair<string, Pool> pair in _connections)
+                {
+                    if (pair.Value == null)
+                        continue;
+
+                    Queue<WeakReference> poolQueue = pair.Value.Queue;
+                    int count = (poolQueue != null) ? poolQueue.Count : 0;
+
+                    counts.Add(pair.Key, count);
+                    totalCount += count;
+                }
+            }
+        }
+    }
 
     /// <summary>
     /// Attempt to pull a pooled connection out of the queue for active duty
     /// </summary>
     /// <param name="fileName">The filename for a desired connection</param>
@@ -70,19 +120,23 @@
         version = queue.PoolVersion;
         queue.MaxPoolSize = maxPoolSize;
 
         ResizePool(queue, false);
 
-        // Try and get a pooled connection from the queue
-        while (queue.Queue.Count > 0)
-        {
-          WeakReference cnn = queue.Queue.Dequeue();
+        // Try and get a pooled connection from the queue
+        Queue<WeakReference> poolQueue = queue.Queue;
+        if (poolQueue == null) return null;
+
+        while (poolQueue.Count > 0)
+        {
+          WeakReference cnn = poolQueue.Dequeue();
           SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle;
-          if (hdl != null)
+          if ((hdl != null) && !hdl.IsClosed && !hdl.IsInvalid)
           {
             return hdl;
-          }
+          }
+          GC.KeepAlive(hdl);
         }
         return null;
       }
     }
 
@@ -101,11 +155,12 @@
             WeakReference cnn = pair.Value.Queue.Dequeue();
             SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle;
             if (hdl != null)
             {
               hdl.Dispose();
-            }
+            }
+            GC.KeepAlive(hdl);
           }
           
           // Keep track of the highest revision so we can go one higher when we're finished
           if (_poolVersion <= pair.Value.PoolVersion)
             _poolVersion = pair.Value.PoolVersion + 1;
@@ -128,19 +183,24 @@
       lock (_connections)
       {
         Pool queue;
         if (_connections.TryGetValue(fileName, out queue) == true)
         {
-          queue.PoolVersion++;
-          while (queue.Queue.Count > 0)
-          {
-            WeakReference cnn = queue.Queue.Dequeue();
+          queue.PoolVersion++;
+
+          Queue<WeakReference> poolQueue = queue.Queue;
+          if (poolQueue == null) return;
+
+          while (poolQueue.Count > 0)
+          {
+            WeakReference cnn = poolQueue.Dequeue();
             SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle;
             if (hdl != null)
             {
               hdl.Dispose();
-            }
+            }
+            GC.KeepAlive(hdl);
           }
         }
       }
     }
 
@@ -159,12 +219,16 @@
       {
         // If the queue doesn't exist in the pool, then it must've been cleared sometime after the connection was created.
         Pool queue;
         if (_connections.TryGetValue(fileName, out queue) == true && version == queue.PoolVersion)
         {
-          ResizePool(queue, true);
-          queue.Queue.Enqueue(new WeakReference(hdl, false));
+          ResizePool(queue, true);
+
+          Queue<WeakReference> poolQueue = queue.Queue;
+          if (poolQueue == null) return;
+
+          poolQueue.Enqueue(new WeakReference(hdl, false));
           GC.KeepAlive(hdl);
         }
         else
         {
           hdl.Close();
@@ -181,19 +245,23 @@
     /// to take one more than it needs from the pool</param>
     private static void ResizePool(Pool queue, bool forAdding)
     {
       int target = queue.MaxPoolSize;
 
-      if (forAdding && target > 0) target--;
-
-      while (queue.Queue.Count > target)
-      {
-        WeakReference cnn = queue.Queue.Dequeue();
+      if (forAdding && target > 0) target--;
+
+      Queue<WeakReference> poolQueue = queue.Queue;
+      if (poolQueue == null) return;
+
+      while (poolQueue.Count > target)
+      {
+        WeakReference cnn = poolQueue.Dequeue();
         SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle;
         if (hdl != null)
         {
           hdl.Dispose();
-        }
+        }
+        GC.KeepAlive(hdl);
       }
     }
   }
 }

Index: System.Data.SQLite/UnsafeNativeMethods.cs
==================================================================
--- System.Data.SQLite/UnsafeNativeMethods.cs
+++ System.Data.SQLite/UnsafeNativeMethods.cs
@@ -21,10 +21,14 @@
 #if !PLATFORM_COMPACTFRAMEWORK && !DEBUG
   using System.Security;
 #endif
 
   using System.Runtime.InteropServices;
+
+#if !PLATFORM_COMPACTFRAMEWORK
+  using System.Threading;
+#endif
 
 #if !PLATFORM_COMPACTFRAMEWORK && !DEBUG
   [SuppressUnmanagedCodeSecurity]
 #endif
   internal static class UnsafeNativeMethods
@@ -1382,22 +1386,34 @@
 
     protected override bool ReleaseHandle()
     {
       try
       {
-        SQLiteBase.CloseConnection(this);
+#if !PLATFORM_COMPACTFRAMEWORK
+        IntPtr localHandle = Interlocked.Exchange(
+          ref handle, IntPtr.Zero);
+
+        if (localHandle != IntPtr.Zero)
+          SQLiteBase.CloseConnection(this, localHandle);
 
 #if DEBUG && !NET_COMPACT_20
         try
         {
           Trace.WriteLine(String.Format(
-              "CloseConnection: {0}", handle));
+              "CloseConnection: {0}", localHandle));
         }
         catch
         {
         }
 #endif
+#else
+        if (handle != IntPtr.Zero)
+        {
+          SQLiteBase.CloseConnection(this, handle);
+          SetHandle(IntPtr.Zero);
+        }
+#endif
 
 #if DEBUG
         return true;
 #endif
       }
@@ -1417,10 +1433,14 @@
         catch
         {
         }
 #endif
       }
+      finally
+      {
+        SetHandleAsInvalid();
+      }
 #if DEBUG
       return false;
 #else
       return true;
 #endif
@@ -1465,22 +1485,34 @@
 
     protected override bool ReleaseHandle()
     {
       try
       {
-        SQLiteBase.FinalizeStatement(this);
+#if !PLATFORM_COMPACTFRAMEWORK
+        IntPtr localHandle = Interlocked.Exchange(
+          ref handle, IntPtr.Zero);
+
+        if (localHandle != IntPtr.Zero)
+          SQLiteBase.FinalizeStatement(localHandle);
 
 #if DEBUG && !NET_COMPACT_20
         try
         {
           Trace.WriteLine(String.Format(
-              "FinalizeStatement: {0}", handle));
+              "FinalizeStatement: {0}", localHandle));
         }
         catch
         {
         }
 #endif
+#else
+        if (handle != IntPtr.Zero)
+        {
+          SQLiteBase.FinalizeStatement(handle);
+          SetHandle(IntPtr.Zero);
+        }
+#endif
 
 #if DEBUG
         return true;
 #endif
       }
@@ -1500,10 +1532,14 @@
         catch
         {
         }
 #endif
       }
+      finally
+      {
+        SetHandleAsInvalid();
+      }
 #if DEBUG
       return false;
 #else
       return true;
 #endif
@@ -1548,22 +1584,34 @@
 
       protected override bool ReleaseHandle()
       {
           try
           {
-              SQLiteBase.FinishBackup(this);
+#if !PLATFORM_COMPACTFRAMEWORK
+              IntPtr localHandle = Interlocked.Exchange(
+                  ref handle, IntPtr.Zero);
+
+              if (localHandle != IntPtr.Zero)
+                  SQLiteBase.FinishBackup(localHandle);
 
 #if DEBUG && !NET_COMPACT_20
               try
               {
                   Trace.WriteLine(String.Format(
-                      "FinishBackup: {0}", handle));
+                      "FinishBackup: {0}", localHandle));
               }
               catch
               {
               }
 #endif
+#else
+              if (handle != IntPtr.Zero)
+              {
+                SQLiteBase.FinishBackup(handle);
+                SetHandle(IntPtr.Zero);
+              }
+#endif
 
 #if DEBUG
               return true;
 #endif
           }
@@ -1583,10 +1631,14 @@
               catch
               {
               }
 #endif
           }
+          finally
+          {
+              SetHandleAsInvalid();
+          }
 #if DEBUG
           return false;
 #else
           return true;
 #endif

Index: Tests/basic.eagle
==================================================================
--- Tests/basic.eagle
+++ Tests/basic.eagle
@@ -22,19 +22,31 @@
 
 #
 # NOTE: Setup the variables that refer to the various files required by the
 #       tests in this file.
 #
+set systemDataSQLiteDllFile [getBuildFileName System.Data.SQLite.dll]
+set systemDataSQLiteLinqDllFile [getBuildFileName System.Data.SQLite.Linq.dll]
 set testExeFile [getBuildFileName test.exe]
 set testLinqExeFile [getBuildFileName testlinq.exe]
 set testLinqOutFile [file nativename [file join $path testlinq.out]]
 set northwindEfDbFile [file nativename [file join [file dirname $path] \
     testlinq northwindEF.db]]
 
 #
 # NOTE: Setup the test constraints specific to the tests in this file.
 #
+if {![haveConstraint [appendArgs file_ \
+    [file tail $systemDataSQLiteDllFile]]]} then {
+  checkForFile $test_channel $systemDataSQLiteDllFile
+}
+
+if {![haveConstraint [appendArgs file_ \
+    [file tail $systemDataSQLiteLinqDllFile]]]} then {
+  checkForFile $test_channel $systemDataSQLiteLinqDllFile
+}
+
 if {![haveConstraint [appendArgs file_ [file tail $testExeFile]]]} then {
   checkForFile $test_channel $testExeFile
 }
 
 if {![haveConstraint [appendArgs file_ [file tail $testLinqExeFile]]]} then {
@@ -76,11 +88,11 @@
   list $code [expr {$code == 0 ? "" : $error}]
 } -cleanup {
   cleanupDb $fileName
 
   unset -nocomplain code output error fileName
-} -constraints {eagle file_test.exe} -result {0 {}}}
+} -constraints {eagle file_System.Data.SQLite.dll file_test.exe} -result {0 {}}}
 
 ###############################################################################
 
 runTest {test data-1.2 {unit tests from the 'testlinq' project} -setup {
   #
@@ -115,12 +127,12 @@
 } -cleanup {
   catch {object invoke Console OutputEncoding $savedEncoding}
 
   unset -nocomplain code output error savedEncoding encoding
 } -constraints \
-{eagle monoToDo file_testlinq.exe file_northwindEF.db file_testlinq.out} \
--result {0 True {}}}
+{eagle monoToDo file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
+file_testlinq.exe file_northwindEF.db file_testlinq.out} -result {0 True {}}}
 
 ###############################################################################
 
 runTest {test data-1.3 {SELECT scalar/reader, CREATE, INSERT} -setup {
   setupDb [set fileName data-1.3.db]
@@ -1380,11 +1392,12 @@
 {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -result \
 {{26 26} {zebra zebra}}}
 
 ###############################################################################
 
-unset -nocomplain testExeFile testLinqExeFile northwindEfDbFile testLinqOutFile
+unset -nocomplain systemDataSQLiteDllFile systemDataSQLiteLinqDllFile \
+    testExeFile testLinqExeFile northwindEfDbFile testLinqOutFile
 
 ###############################################################################
 
 runSQLiteTestEpilogue
 runTestEpilogue

Index: Tests/common.eagle
==================================================================
--- Tests/common.eagle
+++ Tests/common.eagle
@@ -805,13 +805,20 @@
           #
           # NOTE: Skip trying to delete any files if we are so instructed.
           #
           if {![info exists ::no(deleteSqliteFiles)]} then {
             tryDeleteAssembly sqlite3.dll
+            removeConstraint file_sqlite3.dll
+
             tryDeleteAssembly SQLite.Interop.dll
+            removeConstraint file_SQLite.Interop.dll
+
             tryDeleteAssembly System.Data.SQLite.dll
+            removeConstraint file_System.Data.SQLite.dll
+
             tryDeleteAssembly System.Data.SQLite.Linq.dll
+            removeConstraint file_System.Data.SQLite.Linq.dll
           }
 
           #
           # NOTE: Skip trying to copy any files if we are so instructed.
           #
@@ -896,18 +903,32 @@
         #
         # NOTE: Show the active test constraints.
         #
         tputs $::test_channel [appendArgs "---- constraints: " \
             [formatList [lsort [getConstraints]]] \n]
+
+        #
+        # NOTE: Show when our tests actually began (now).
+        #
+        tputs $::test_channel [appendArgs \
+            "---- System.Data.SQLite tests began at " \
+            [clock format [clock seconds]] \n]
       }
     }
 
     proc runSQLiteTestEpilogue {} {
       #
       # NOTE: Skip running our custom epilogue if the main one has been skipped.
       #
       if {![info exists ::no(epilogue.eagle)]} then {
+        #
+        # NOTE: Show when our tests actually ended (now).
+        #
+        tputs $::test_channel [appendArgs \
+            "---- System.Data.SQLite tests ended at " \
+            [clock format [clock seconds]] \n]
+
         #
         # NOTE: Also report the resource usage after running the tests.
         #
         reportSQLiteResources $::test_channel
       }

Index: Tests/tkt-00f86f9739.eagle
==================================================================
--- Tests/tkt-00f86f9739.eagle
+++ Tests/tkt-00f86f9739.eagle
@@ -22,17 +22,29 @@
 
 #
 # NOTE: Setup the variables that refer to the various files required by the
 #       tests in this file.
 #
+set systemDataSQLiteDllFile [getBuildFileName System.Data.SQLite.dll]
+set systemDataSQLiteLinqDllFile [getBuildFileName System.Data.SQLite.Linq.dll]
 set testLinqExeFile [getBuildFileName testlinq.exe]
 set northwindEfDbFile [file nativename [file join [file dirname $path] \
     testlinq northwindEF.db]]
 
 #
 # NOTE: Setup the test constraints specific to the tests in this file.
 #
+if {![haveConstraint [appendArgs file_ \
+    [file tail $systemDataSQLiteDllFile]]]} then {
+  checkForFile $test_channel $systemDataSQLiteDllFile
+}
+
+if {![haveConstraint [appendArgs file_ \
+    [file tail $systemDataSQLiteLinqDllFile]]]} then {
+  checkForFile $test_channel $systemDataSQLiteLinqDllFile
+}
+
 if {![haveConstraint [appendArgs file_ [file tail $testLinqExeFile]]]} then {
   checkForFile $test_channel $testLinqExeFile
 }
 
 if {![haveConstraint [appendArgs file_ [file tail $northwindEfDbFile]]]} then {
@@ -69,17 +81,19 @@
   set result
 } -cleanup {
   unset -nocomplain code output error result value
 } -constraints \
 {eagle monoToDo defineConstant.System.Data.SQLite.INTEROP_EXTENSION_FUNCTIONS\
-file_testlinq.exe file_northwindEF.db} -result {0 {} 0 {DRACD OLDWO RATTC} 0\
-{ALFKI CACTU CHOPS FOLKO GALED KOENE LILAS MAGAA MAISD OCEAN RANCH SAVEA THECR}\
-0 {} 0 {} 0 {} 0 {}}}
+file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll file_testlinq.exe\
+file_northwindEF.db} -result {0 {} 0 {DRACD OLDWO RATTC} 0 {ALFKI CACTU CHOPS\
+FOLKO GALED KOENE LILAS MAGAA MAISD OCEAN RANCH SAVEA THECR} 0 {} 0 {} 0 {} 0\
+{}}}
 
 ###############################################################################
 
-unset -nocomplain testLinqExeFile northwindEfDbFile
+unset -nocomplain systemDataSQLiteDllFile systemDataSQLiteLinqDllFile \
+    testLinqExeFile northwindEfDbFile
 
 ###############################################################################
 
 runSQLiteTestEpilogue
 runTestEpilogue

Index: Tests/tkt-59edc1018b.eagle
==================================================================
--- Tests/tkt-59edc1018b.eagle
+++ Tests/tkt-59edc1018b.eagle
@@ -22,17 +22,29 @@
 
 #
 # NOTE: Setup the variables that refer to the various files required by the
 #       tests in this file.
 #
+set systemDataSQLiteDllFile [getBuildFileName System.Data.SQLite.dll]
+set systemDataSQLiteLinqDllFile [getBuildFileName System.Data.SQLite.Linq.dll]
 set testLinqExeFile [getBuildFileName testlinq.exe]
 set northwindEfDbFile [file nativename [file join [file dirname $path] \
     testlinq northwindEF.db]]
 
 #
 # NOTE: Setup the test constraints specific to the tests in this file.
 #
+if {![haveConstraint [appendArgs file_ \
+    [file tail $systemDataSQLiteDllFile]]]} then {
+  checkForFile $test_channel $systemDataSQLiteDllFile
+}
+
+if {![haveConstraint [appendArgs file_ \
+    [file tail $systemDataSQLiteLinqDllFile]]]} then {
+  checkForFile $test_channel $systemDataSQLiteLinqDllFile
+}
+
 if {![haveConstraint [appendArgs file_ [file tail $testLinqExeFile]]]} then {
   checkForFile $test_channel $testLinqExeFile
 }
 
 if {![haveConstraint [appendArgs file_ [file tail $northwindEfDbFile]]]} then {
@@ -69,17 +81,18 @@
   set result
 } -cleanup {
   unset -nocomplain code output error result value
 } -constraints \
 {eagle monoToDo defineConstant.System.Data.SQLite.INTEROP_EXTENSION_FUNCTIONS\
-file_testlinq.exe file_northwindEF.db} -result {0 {} 0 {FURIB GALED GODOS LAZYK\
-LINOD PRINI REGGC WOLZA} 0 {} 0 ERNSH 0 {} 0 {AROUT BSBEV CONSH EASTC NORTS\
-SEVES} 0 {}}}
+file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll file_testlinq.exe\
+file_northwindEF.db} -result {0 {} 0 {FURIB GALED GODOS LAZYK LINOD PRINI REGGC\
+WOLZA} 0 {} 0 ERNSH 0 {} 0 {AROUT BSBEV CONSH EASTC NORTS SEVES} 0 {}}}
 
 ###############################################################################
 
-unset -nocomplain testLinqExeFile northwindEfDbFile
+unset -nocomplain systemDataSQLiteDllFile systemDataSQLiteLinqDllFile \
+    testLinqExeFile northwindEfDbFile
 
 ###############################################################################
 
 runSQLiteTestEpilogue
 runTestEpilogue

Index: Tests/tkt-8b7d179c3c.eagle
==================================================================
--- Tests/tkt-8b7d179c3c.eagle
+++ Tests/tkt-8b7d179c3c.eagle
@@ -22,17 +22,29 @@
 
 #
 # NOTE: Setup the variables that refer to the various files required by the
 #       tests in this file.
 #
+set systemDataSQLiteDllFile [getBuildFileName System.Data.SQLite.dll]
+set systemDataSQLiteLinqDllFile [getBuildFileName System.Data.SQLite.Linq.dll]
 set testLinqExeFile [getBuildFileName testlinq.exe]
 set northwindEfDbFile [file nativename [file join [file dirname $path] \
     testlinq northwindEF.db]]
 
 #
 # NOTE: Setup the test constraints specific to the tests in this file.
 #
+if {![haveConstraint [appendArgs file_ \
+    [file tail $systemDataSQLiteDllFile]]]} then {
+  checkForFile $test_channel $systemDataSQLiteDllFile
+}
+
+if {![haveConstraint [appendArgs file_ \
+    [file tail $systemDataSQLiteLinqDllFile]]]} then {
+  checkForFile $test_channel $systemDataSQLiteLinqDllFile
+}
+
 if {![haveConstraint [appendArgs file_ [file tail $testLinqExeFile]]]} then {
   checkForFile $test_channel $testLinqExeFile
 }
 
 if {![haveConstraint [appendArgs file_ [file tail $northwindEfDbFile]]]} then {
@@ -67,30 +79,32 @@
   }
 
   set result
 } -cleanup {
   unset -nocomplain code output error result pageSize
-} -constraints {eagle monoToDo file_testlinq.exe file_northwindEF.db} -result \
-{0 {} 0 {DRACD RATTC OLDWO GALED LILAS MAGAA ALFKI CHOPS SAVEA KOENE MAISD\
-FOLKO CACTU OCEAN RANCH THECR GOURL GROSR SUPRD HUNGO ISLAT QUICK HUNGC GREAL\
-LEHMS RICSU ERNSH WILMK LINOD TRAIH SIMOB OTTIK SPLIR MORGK FOLIG FURIB PRINI\
-AROUT BSBEV CONSH EASTC NORTS SEVES BERGS VICTE BOLID FISSA ROMEY BLAUS BONAP\
-MEREP ANATR ANTON CENTC PERIC TORTU FRANK TOMSP DUMON FRANR WARTH PARIS SPECD\
-LONEP THEBI REGGC VINET WELLI HANAR QUEDE RICAR PICCO HILAA LETSS COMMI FAMIA\
-QUEEN TRADH WHITC GODOS SANTG BLONP WANDK FRANS LAMAI BOTTM LAUGB LACOR LAZYK\
-WOLZA VAFFE} 0 {DRACD RATTC OLDWO GALED LILAS MAGAA ALFKI CHOPS SAVEA KOENE\
+} -constraints {eagle monoToDo file_System.Data.SQLite.dll\
+file_System.Data.SQLite.Linq.dll file_testlinq.exe file_northwindEF.db} \
+-result {0 {} 0 {DRACD RATTC OLDWO GALED LILAS MAGAA ALFKI CHOPS SAVEA KOENE\
 MAISD FOLKO CACTU OCEAN RANCH THECR GOURL GROSR SUPRD HUNGO ISLAT QUICK HUNGC\
 GREAL LEHMS RICSU ERNSH WILMK LINOD TRAIH SIMOB OTTIK SPLIR MORGK FOLIG FURIB\
 PRINI AROUT BSBEV CONSH EASTC NORTS SEVES BERGS VICTE BOLID FISSA ROMEY BLAUS\
 BONAP MEREP ANATR ANTON CENTC PERIC TORTU FRANK TOMSP DUMON FRANR WARTH PARIS\
 SPECD LONEP THEBI REGGC VINET WELLI HANAR QUEDE RICAR PICCO HILAA LETSS COMMI\
 FAMIA QUEEN TRADH WHITC GODOS SANTG BLONP WANDK FRANS LAMAI BOTTM LAUGB LACOR\
-LAZYK WOLZA VAFFE}}}
+LAZYK WOLZA VAFFE} 0 {DRACD RATTC OLDWO GALED LILAS MAGAA ALFKI CHOPS SAVEA\
+KOENE MAISD FOLKO CACTU OCEAN RANCH THECR GOURL GROSR SUPRD HUNGO ISLAT QUICK\
+HUNGC GREAL LEHMS RICSU ERNSH WILMK LINOD TRAIH SIMOB OTTIK SPLIR MORGK FOLIG\
+FURIB PRINI AROUT BSBEV CONSH EASTC NORTS SEVES BERGS VICTE BOLID FISSA ROMEY\
+BLAUS BONAP MEREP ANATR ANTON CENTC PERIC TORTU FRANK TOMSP DUMON FRANR WARTH\
+PARIS SPECD LONEP THEBI REGGC VINET WELLI HANAR QUEDE RICAR PICCO HILAA LETSS\
+COMMI FAMIA QUEEN TRADH WHITC GODOS SANTG BLONP WANDK FRANS LAMAI BOTTM LAUGB\
+LACOR LAZYK WOLZA VAFFE}}}
 
 ###############################################################################
 
-unset -nocomplain testLinqExeFile northwindEfDbFile
+unset -nocomplain systemDataSQLiteDllFile systemDataSQLiteLinqDllFile \
+    testLinqExeFile northwindEfDbFile
 
 ###############################################################################
 
 runSQLiteTestEpilogue
 runTestEpilogue

ADDED   Tests/tkt-996d13cd87.eagle
Index: Tests/tkt-996d13cd87.eagle
==================================================================
--- /dev/null
+++ Tests/tkt-996d13cd87.eagle
@@ -0,0 +1,230 @@
+###############################################################################
+#
+# tkt-996d13cd87.eagle --
+#
+# Written by Joe Mistachkin.
+# Released to the public domain, use at your own risk!
+#
+###############################################################################
+
+package require Eagle
+package require Eagle.Library
+package require Eagle.Test
+
+runTestPrologue
+
+###############################################################################
+
+package require System.Data.SQLite.Test
+runSQLiteTestPrologue
+
+###############################################################################
+
+runTest {test tkt-996d13cd87-1.1 {SQLiteConnectionPool stress} -setup {
+  set fileName tkt-996d13cd87-1.1.db
+} -body {
+  set id [object invoke Interpreter.GetActive NextId]
+  set dataSource [file join [getDatabaseDirectory] $fileName]
+
+  set sql { \
+    CREATE TABLE t1(x TEXT); \
+    INSERT INTO t1 (x) VALUES(HEX(RANDOMBLOB(1000))); \
+  }
+
+  unset -nocomplain results errors
+
+  set code [compileCSharpWith [subst {
+    using System;
+    using System.Data.SQLite;
+    using System.Diagnostics;
+    using System.Threading;
+
+    namespace _Dynamic${id}
+    {
+      public static class Test${id}
+      {
+        public static int Main()
+        {
+          //
+          // NOTE: This is the total number of exceptions caught by all the
+          //       test threads.
+          //
+          int errors = 0;
+
+          //
+          // NOTE: This is the total number of test threads to create.
+          //
+          int count = 100;
+
+          //
+          // NOTE: Create a random number generator suitable for waiting a
+          //       random number of milliseconds between each attempt to
+          //       cause the race condition on a given thread.
+          //
+          Random random = new Random();
+
+          //
+          // NOTE: Create the event that will be used to synchronize all the
+          //       created threads so that they start doing their actual test
+          //       "work" at approximately the same time.
+          //
+          using (ManualResetEvent goEvent = new ManualResetEvent(false))
+          {
+            //
+            // NOTE: Create a (reusable) delegate that will contain the code
+            //       that half the created threads are to execute.  This code
+            //       will repeatedly create, open, and close a single database
+            //       connection with pool enabled.
+            //
+            ThreadStart threadStart1 = delegate()
+            {
+              try
+              {
+                //
+                // NOTE: Wait forever for the "GO" signal so that all threads
+                //       can start working at approximately the same time.
+                //
+                goEvent.WaitOne();
+
+                //
+                // NOTE: Repeatedly try to create, open, and close a pooled
+                //       database connection and then wait a random number of
+                //       milliseconds before doing it again.
+                //
+                Thread.Sleep(random.Next(0, 500));
+
+                SQLiteConnection connection = new SQLiteConnection(
+                    "Data Source=${dataSource};Pooling=True;");
+
+                connection.Open();
+
+                using (SQLiteCommand command = new SQLiteCommand("${sql}",
+                    connection))
+                {
+                  command.ExecuteNonQuery();
+                }
+
+                connection.Close();
+                connection = null;
+              }
+              catch (Exception e)
+              {
+                Interlocked.Increment(ref errors);
+                Trace.WriteLine(e);
+              }
+            };
+
+            //
+            // NOTE: Create a (reusable) delegate that will contain the code
+            //       that half the created threads are to execute.  This code
+            //       will repeatedly force a full garbage collection.
+            //
+            ThreadStart threadStart2 = delegate()
+            {
+              try
+              {
+                //
+                // NOTE: Wait forever for the "GO" signal so that all threads
+                //       can start working at approximately the same time.
+                //
+                goEvent.WaitOne();
+
+                //
+                // NOTE: Wait a random number of milliseconds before forcing a
+                //       full garbage collection.
+                //
+                Thread.Sleep(random.Next(0, 1000));
+                GC.GetTotalMemory(true);
+              }
+              catch (Exception e)
+              {
+                Interlocked.Increment(ref errors);
+                Trace.WriteLine(e);
+              }
+            };
+
+            //
+            // NOTE: Create the array of thread objects.
+            //
+            Thread\[\] thread = new Thread\[count\];
+
+            //
+            // NOTE: Create each of the test threads with a suitable stack
+            //       size.  We must specify a stack size here because the
+            //       default one for the process would be the same as the
+            //       parent executable (the Eagle shell), which is 16MB,
+            //       too large to be useful.
+            //
+            for (int index = 0; index < count; index++)
+            {
+              //
+              // NOTE: Figure out what kind of thread to create (i.e. one
+              //       that uses a connection or one that calls the GC).
+              //
+              ThreadStart threadStart;
+
+              if (index == 0)
+                threadStart = threadStart2;
+              else
+                threadStart = threadStart1;
+
+              thread\[index\] = new Thread(threadStart, 1048576);
+
+              //
+              // NOTE: Name each thread for a better debugging experience.
+              //
+              thread\[index\].Name = String.Format(
+                  "[file rootname ${fileName}] #{0}", index);
+            }
+
+            //
+            // NOTE: Start all the threads now.  They should not actually do
+            //       any of the test "work" until we signal the event.
+            //
+            for (int index = 0; index < count; index++)
+              thread\[index\].Start();
+
+            //
+            // NOTE: Send the signal that all threads should start doing
+            //       their test "work" now.
+            //
+            goEvent.Set(); /* GO */
+
+            //
+            // NOTE: Wait forever for each thread to finish its test "work"
+            //       and then die.
+            //
+            for (int index = 0; index < count; index++)
+              thread\[index\].Join();
+          }
+
+          //
+          // NOTE: Return the total number of exceptions caught by the test
+          //       threads.  For this test to pass, this number must be zero.
+          //
+          return errors;
+        }
+      }
+    }
+  }] true true true results errors System.Data.SQLite.dll]
+
+  list $code $results \
+      [expr {[info exists errors] ? $errors : ""}] \
+      [expr {$code eq "Ok" ? [catch {
+        object invoke _Dynamic${id}.Test${id} Main
+      } result] : [set result ""]}] $result
+} -cleanup {
+  object invoke System.Data.SQLite.SQLiteConnection ClearAllPools
+  object invoke GC GetTotalMemory true
+
+  cleanupDb $fileName
+
+  unset -nocomplain result results errors code sql dataSource id db fileName
+} -constraints \
+{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
+regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 0$}}
+
+###############################################################################
+
+runSQLiteTestEpilogue
+runTestEpilogue

Index: Tests/tkt-ccfa69fc32.eagle
==================================================================
--- Tests/tkt-ccfa69fc32.eagle
+++ Tests/tkt-ccfa69fc32.eagle
@@ -22,17 +22,29 @@
 
 #
 # NOTE: Setup the variables that refer to the various files required by the
 #       tests in this file.
 #
+set systemDataSQLiteDllFile [getBuildFileName System.Data.SQLite.dll]
+set systemDataSQLiteLinqDllFile [getBuildFileName System.Data.SQLite.Linq.dll]
 set testLinqExeFile [getBuildFileName testlinq.exe]
 set northwindEfDbFile [file nativename [file join [file dirname $path] \
     testlinq northwindEF.db]]
 
 #
 # NOTE: Setup the test constraints specific to the tests in this file.
 #
+if {![haveConstraint [appendArgs file_ \
+    [file tail $systemDataSQLiteDllFile]]]} then {
+  checkForFile $test_channel $systemDataSQLiteDllFile
+}
+
+if {![haveConstraint [appendArgs file_ \
+    [file tail $systemDataSQLiteLinqDllFile]]]} then {
+  checkForFile $test_channel $systemDataSQLiteLinqDllFile
+}
+
 if {![haveConstraint [appendArgs file_ [file tail $testLinqExeFile]]]} then {
   checkForFile $test_channel $testLinqExeFile
 }
 
 if {![haveConstraint [appendArgs file_ [file tail $northwindEfDbFile]]]} then {
@@ -67,19 +79,21 @@
   }
 
   set result
 } -cleanup {
   unset -nocomplain code output error result add
-} -constraints {eagle monoToDo file_testlinq.exe file_northwindEF.db} -match \
+} -constraints {eagle monoToDo file_System.Data.SQLite.dll\
+file_System.Data.SQLite.Linq.dll file_testlinq.exe file_northwindEF.db} -match \
 glob -result {0 {1581 1730 1833 2116 2139} 0 {System.Data.UpdateException: *\
 ---> System.Data.SQLite.SQLiteException: Abort due to constraint violation
 PRIMARY KEY must be unique
 *} 0 {1 2 3 4 5 6 7 8 9 10 1576 1577 1578 1579 1580 1581 1730 1833 2116 2139}}}
 
 ###############################################################################
 
-unset -nocomplain testLinqExeFile northwindEfDbFile
+unset -nocomplain systemDataSQLiteDllFile systemDataSQLiteLinqDllFile \
+    testLinqExeFile northwindEfDbFile
 
 ###############################################################################
 
 runSQLiteTestEpilogue
 runTestEpilogue