System.Data.SQLite
Check-in [611657ba5b]
Not logged in

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Merge updates from trunk.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | tkt-5cee5409f8
Files: files | file ages | folders
SHA1: 611657ba5be8f8e497ca180fcf14e0f7bbe5d707
User & Date: mistachkin 2018-01-26 01:14:43
Context
2018-01-26
01:28
Merge updates from trunk. check-in: 82138de582 user: mistachkin tags: tkt-5cee5409f8
01:14
Merge updates from trunk. check-in: 611657ba5b user: mistachkin tags: tkt-5cee5409f8
01:13
Replace a call to String.Format with the helper method. check-in: c1719dd9f5 user: mistachkin tags: trunk
00:00
Merge updates from trunk. check-in: e36ed56d66 user: mistachkin tags: tkt-5cee5409f8
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to System.Data.SQLite/SQLiteConnection.cs.

  1437   1437       private ConnectionState _connectionState;
  1438   1438   
  1439   1439       /// <summary>
  1440   1440       /// The connection string
  1441   1441       /// </summary>
  1442   1442       private string _connectionString;
  1443   1443   
         1444  +    /// <summary>
         1445  +    /// This string will contain enough information to identify this connection,
         1446  +    /// e.g. the database file name, original thread, etc.  It is not currently
         1447  +    /// exposed via the public interface as it is intended for use only when
         1448  +    /// debugging this library.
         1449  +    /// </summary>
         1450  +    private string _debugString;
         1451  +
  1444   1452       /// <summary>
  1445   1453       /// Nesting level of the transactions open on the connection
  1446   1454       /// </summary>
  1447   1455       internal int _transactionLevel;
  1448   1456   
  1449   1457       /// <summary>
  1450   1458       /// Transaction counter for the connection.  Currently, this is only used
................................................................................
  2646   2654           if ((_flags & SQLiteConnectionFlags.TraceWarning) == SQLiteConnectionFlags.TraceWarning)
  2647   2655           {
  2648   2656               if (_noDispose)
  2649   2657               {
  2650   2658                   System.Diagnostics.Trace.WriteLine(HelperMethods.StringFormat(
  2651   2659                       CultureInfo.CurrentCulture,
  2652   2660                       "WARNING: Disposing of connection \"{0}\" with the no-dispose flag set.",
  2653         -                    _connectionString));
         2661  +                    _debugString));
  2654   2662               }
  2655   2663           }
  2656   2664   #endif
  2657   2665   
  2658   2666           _disposing = true;
  2659   2667   
  2660   2668           try
................................................................................
  4190   4198   
  4191   4199             StateChangeEventArgs eventArgs = null;
  4192   4200             OnStateChange(ConnectionState.Open, ref eventArgs);
  4193   4201   
  4194   4202             OnChanged(this, new ConnectionEventArgs(
  4195   4203                 SQLiteConnectionEventType.Opened, eventArgs, null, null, null,
  4196   4204                 null, _connectionString, new object[] { opts }));
         4205  +
         4206  +          _debugString = HelperMethods.StringFormat(
         4207  +              CultureInfo.InvariantCulture,
         4208  +              "threadId = {0}, connectionString = {1}",
         4209  +              HelperMethods.GetThreadId(), _connectionString);
  4197   4210           }
  4198   4211           catch
  4199   4212           {
  4200   4213             _connectionState = oldstate;
  4201   4214             throw;
  4202   4215           }
  4203   4216         }

Changes to System.Data.SQLite/UnsafeNativeMethods.cs.

   537    537                 //
   538    538                 lock (staticSyncRoot)
   539    539                 {
   540    540                     debuggerBreak = false;
   541    541                 }
   542    542             }
   543    543         }
          544  +
          545  +      /////////////////////////////////////////////////////////////////////////
          546  +
          547  +      /// <summary>
          548  +      /// Determines the ID of the current thread.  Only used for debugging.
          549  +      /// </summary>
          550  +      /// <returns>
          551  +      /// The ID of the current thread -OR- zero if it cannot be determined.
          552  +      /// </returns>
          553  +      internal static int GetThreadId()
          554  +      {
          555  +#if !PLATFORM_COMPACTFRAMEWORK
          556  +          return AppDomain.GetCurrentThreadId();
          557  +#else
          558  +          return 0;
          559  +#endif
          560  +      }
   544    561   
   545    562         /////////////////////////////////////////////////////////////////////////
   546    563   
   547    564         /// <summary>
   548    565         /// Determines if preparing a query should be logged.
   549    566         /// </summary>
   550    567         /// <param name="flags">

Changes to Tests/backup.eagle.

   143    143   
   144    144             public static string BackupAndGetData(
   145    145               Interpreter interpreter,
   146    146               SQLiteConnection source
   147    147               )
   148    148             {
   149    149               using (SQLiteConnection destination = new SQLiteConnection(
   150         -                "Data Source=${dataSource};[getFlagsProperty]"))
          150  +                "Data Source=${dataSource};[getTestProperties]"))
   151    151               {
   152    152                 destination.Open();
   153    153   
   154    154                 int pages = ${pages};
   155    155   
   156    156                 source.BackupDatabase(destination, "main", "main", pages,
   157    157                   ${callback}, 0);

Changes to Tests/basic.eagle.

   177    177       namespace _Dynamic${id}
   178    178       {
   179    179         public static class Test${id}
   180    180         {
   181    181           public static DataTable GetReservedWords()
   182    182           {
   183    183             using (SQLiteConnection connection = new SQLiteConnection(
   184         -              "Data Source=${dataSource};[getFlagsProperty]"))
          184  +              "Data Source=${dataSource};[getTestProperties]"))
   185    185             {
   186    186               connection.Open();
   187    187   
   188    188               return connection.GetSchema("ReservedWords");
   189    189             }
   190    190           }
   191    191   
................................................................................
   239    239       namespace _Dynamic${id}
   240    240       {
   241    241         public static class Test${id}
   242    242         {
   243    243           public static DataRowCollection GetForeignKeys()
   244    244           {
   245    245             using (SQLiteConnection connection = new SQLiteConnection(
   246         -              "Data Source=${dataSource};[getFlagsProperty]"))
          246  +              "Data Source=${dataSource};[getTestProperties]"))
   247    247             {
   248    248               connection.Open();
   249    249   
   250    250               return connection.GetSchema("ForeignKeys").Rows;
   251    251             }
   252    252           }
   253    253   
................................................................................
   320    320         {
   321    321           public static bool TestSetAvRetry(
   322    322             ref int count,
   323    323             ref int interval
   324    324             )
   325    325           {
   326    326             using (SQLiteConnection connection = new SQLiteConnection(
   327         -              "Data Source=${dataSource};[getFlagsProperty]"))
          327  +              "Data Source=${dataSource};[getTestProperties]"))
   328    328             {
   329    329               connection.Open();
   330    330   
   331    331               //
   332    332               // NOTE: Set the requested retry parameter values.
   333    333               //
   334    334               if (connection.SetAvRetry(ref count, ref interval) != 0)
................................................................................
   424    424       namespace _Dynamic${id}
   425    425       {
   426    426         public static class Test${id}
   427    427         {
   428    428           public static void Main()
   429    429           {
   430    430             using (SQLiteConnection connection = new SQLiteConnection(
   431         -              "Data Source=${dataSource};[getFlagsProperty]"))
          431  +              "Data Source=${dataSource};[getTestProperties]"))
   432    432             {
   433    433               connection.Open();
   434    434   
   435    435               using (SQLiteCommand command = new SQLiteCommand("${sql}",
   436    436                   connection))
   437    437               {
   438    438                 command.ExecuteNonQuery();
................................................................................
   480    480       namespace _Dynamic${id}
   481    481       {
   482    482         public static class Test${id}
   483    483         {
   484    484           public static void Main()
   485    485           {
   486    486             using (SQLiteConnection connection = new SQLiteConnection(
   487         -              "Data Source=${dataSource};[getFlagsProperty]"))
          487  +              "Data Source=${dataSource};[getTestProperties]"))
   488    488             {
   489    489               connection.Open();
   490    490   
   491    491               using (SQLiteCommand command = new SQLiteCommand("${sql}",
   492    492                   connection))
   493    493               {
   494    494                 using (SQLiteDataReader dataReader = command.ExecuteReader())
................................................................................
   540    540       namespace _Dynamic${id}
   541    541       {
   542    542         public static class Test${id}
   543    543         {
   544    544           public static void Main()
   545    545           {
   546    546             using (SQLiteConnection connection = new SQLiteConnection(
   547         -              "Data Source=${dataSource};[getFlagsProperty]"))
          547  +              "Data Source=${dataSource};[getTestProperties]"))
   548    548             {
   549    549               connection.Open();
   550    550   
   551    551               using (SQLiteCommand command = new SQLiteCommand("${sql}",
   552    552                   connection))
   553    553               {
   554    554                 using (SQLiteDataReader dataReader = command.ExecuteReader(
................................................................................
  1174   1174           ///////////////////////////////////////////////////////////////////////
  1175   1175   
  1176   1176           public static void Main()
  1177   1177           {
  1178   1178             SQLiteFunction.RegisterFunction(typeof(Test${id}));
  1179   1179   
  1180   1180             using (SQLiteConnection connection = new SQLiteConnection(
  1181         -              "Data Source=${dataSource};[getFlagsProperty]"))
         1181  +              "Data Source=${dataSource};[getTestProperties]"))
  1182   1182             {
  1183   1183               connection.Open();
  1184   1184   
  1185   1185               using (SQLiteTransaction transaction =
  1186   1186                   connection.BeginTransaction())
  1187   1187               {
  1188   1188                 try
................................................................................
  1256   1256           ///////////////////////////////////////////////////////////////////////
  1257   1257   
  1258   1258           public static int Main()
  1259   1259           {
  1260   1260             SQLiteFunction.RegisterFunction(typeof(Test${id}));
  1261   1261   
  1262   1262             using (SQLiteConnection connection = new SQLiteConnection(
  1263         -              "Data Source=${dataSource};[getFlagsProperty]"))
         1263  +              "Data Source=${dataSource};[getTestProperties]"))
  1264   1264             {
  1265   1265               connection.Open();
  1266   1266   
  1267   1267               using (SQLiteTransaction transaction =
  1268   1268                   connection.BeginTransaction())
  1269   1269               {
  1270   1270                 SQLiteCommand command = connection.CreateCommand();
................................................................................
  2547   2547           }
  2548   2548   
  2549   2549           ///////////////////////////////////////////////////////////////////////
  2550   2550   
  2551   2551           public static object DoTest(bool bindFunction)
  2552   2552           {
  2553   2553             using (SQLiteConnection connection = new SQLiteConnection(
  2554         -              "Data Source=${dataSource};[getFlagsProperty]"))
         2554  +              "Data Source=${dataSource};[getTestProperties]"))
  2555   2555             {
  2556   2556               connection.Open();
  2557   2557   
  2558   2558               if (bindFunction)
  2559   2559               {
  2560   2560                 connection.BindFunction(new SQLiteFunctionAttribute(
  2561   2561                   "MyRandom", 0, FunctionType.Scalar), new Test${id}());
................................................................................
  3309   3309               functionAttribute = new SQLiteFunctionAttribute(
  3310   3310                   "MyRandom", 0, FunctionType.Scalar);
  3311   3311             }
  3312   3312   
  3313   3313             if (connection == null)
  3314   3314             {
  3315   3315               connection = new SQLiteConnection(
  3316         -                "Data Source=${dataSource};[getFlagsProperty]");
         3316  +                "Data Source=${dataSource};[getTestProperties]");
  3317   3317   
  3318   3318               connection.Open();
  3319   3319             }
  3320   3320           }
  3321   3321   
  3322   3322           ///////////////////////////////////////////////////////////////////////
  3323   3323   
................................................................................
  3466   3466                   "MyRandom", 0, FunctionType.Scalar);
  3467   3467             }
  3468   3468   
  3469   3469             if (connection == null)
  3470   3470             {
  3471   3471               connection = new SQLiteConnection(
  3472   3472                   "Data Source=${dataSource};Pooling=True;" +
  3473         -                "[getFlagsProperty UnbindFunctionsOnClose]");
         3473  +                "[getTestProperties UnbindFunctionsOnClose]");
  3474   3474   
  3475   3475               connection.Open();
  3476   3476             }
  3477   3477           }
  3478   3478   
  3479   3479           ///////////////////////////////////////////////////////////////////////
  3480   3480   
................................................................................
  4289   4289               functionAttribute = new SQLiteFunctionAttribute(
  4290   4290                   "regexp", 2, FunctionType.Scalar);
  4291   4291             }
  4292   4292   
  4293   4293             if (connection == null)
  4294   4294             {
  4295   4295               connection = new SQLiteConnection(
  4296         -                "Data Source=${dataSource};[getFlagsProperty]");
         4296  +                "Data Source=${dataSource};[getTestProperties]");
  4297   4297   
  4298   4298               connection.Open();
  4299   4299             }
  4300   4300           }
  4301   4301   
  4302   4302           ///////////////////////////////////////////////////////////////////////
  4303   4303   

Changes to Tests/progress.eagle.

    57     57           }
    58     58   
    59     59           ///////////////////////////////////////////////////////////////////////
    60     60   
    61     61           public static int Main()
    62     62           {
    63     63             using (SQLiteConnection connection = new SQLiteConnection(
    64         -              "Data Source=${dataSource};[getFlagsProperty]"))
           64  +              "Data Source=${dataSource};[getTestProperties]"))
    65     65             {
    66     66               connection.Progress += MyProgressHandler;
    67     67               connection.Open();
    68     68   
    69     69               using (SQLiteCommand command = new SQLiteCommand("${sql}",
    70     70                   connection))
    71     71               {
................................................................................
   132    132           }
   133    133   
   134    134           ///////////////////////////////////////////////////////////////////////
   135    135   
   136    136           public static int Main()
   137    137           {
   138    138             using (SQLiteConnection connection = new SQLiteConnection(
   139         -              "Data Source=${dataSource};ProgressOps=1;[getFlagsProperty]"))
          139  +              "Data Source=${dataSource};ProgressOps=1;[getTestProperties]"))
   140    140             {
   141    141               connection.Progress += MyProgressHandler;
   142    142               connection.Open();
   143    143   
   144    144               using (SQLiteCommand command = new SQLiteCommand("${sql}",
   145    145                   connection))
   146    146               {
................................................................................
   208    208           }
   209    209   
   210    210           ///////////////////////////////////////////////////////////////////////
   211    211   
   212    212           public static int Main()
   213    213           {
   214    214             using (SQLiteConnection connection = new SQLiteConnection(
   215         -              "Data Source=${dataSource};ProgressOps=1;[getFlagsProperty]"))
          215  +              "Data Source=${dataSource};ProgressOps=1;[getTestProperties]"))
   216    216             {
   217    217               connection.Progress += MyProgressHandler;
   218    218               connection.Open();
   219    219   
   220    220               using (SQLiteCommand command = new SQLiteCommand("${sql}",
   221    221                   connection))
   222    222               {
................................................................................
   285    285           }
   286    286   
   287    287           ///////////////////////////////////////////////////////////////////////
   288    288   
   289    289           public static int Main()
   290    290           {
   291    291             using (SQLiteConnection connection = new SQLiteConnection(
   292         -              "Data Source=${dataSource};ProgressOps=1;[getFlagsProperty]"))
          292  +              "Data Source=${dataSource};ProgressOps=1;[getTestProperties]"))
   293    293             {
   294    294               connection.Progress += MyProgressHandler;
   295    295               connection.Open();
   296    296   
   297    297               using (SQLiteCommand command = new SQLiteCommand("${sql}",
   298    298                   connection))
   299    299               {

Changes to Tests/stress.eagle.

  1087   1087               namespace _Dynamic${id}
  1088   1088               {
  1089   1089                 public static class Test${id}
  1090   1090                 {
  1091   1091                   public static void BackupAndGetData()
  1092   1092                   {
  1093   1093                     using (SQLiteConnection source = new SQLiteConnection(
  1094         -                      "FullUri=${dstFileName};[getFlagsProperty {} true]"))
         1094  +                      "FullUri=${dstFileName};[getTestProperties {} true]"))
  1095   1095                     {
  1096   1096                       source.Open();
  1097   1097   
  1098   1098                       using (SQLiteConnection destination = new SQLiteConnection(
  1099         -                        "FullUri=${srcFileName};[getFlagsProperty {} true]"))
         1099  +                        "FullUri=${srcFileName};[getTestProperties {} true]"))
  1100   1100                       {
  1101   1101                         destination.Open();
  1102   1102   
  1103   1103                         source.BackupDatabase(
  1104   1104                             destination, "main", "main", -1, null, 0);
  1105   1105                       }
  1106   1106                     }
................................................................................
  1170   1170               namespace _Dynamic${id}
  1171   1171               {
  1172   1172                 public static class Test${id}
  1173   1173                 {
  1174   1174                   public static void BackupAndGetData()
  1175   1175                   {
  1176   1176                     using (SQLiteConnection source = new SQLiteConnection(
  1177         -                      "FullUri=${srcFileName};[getFlagsProperty {} true]"))
         1177  +                      "FullUri=${srcFileName};[getTestProperties {} true]"))
  1178   1178                     {
  1179   1179                       source.Open();
  1180   1180   
  1181   1181                       using (SQLiteConnection destination = new SQLiteConnection(
  1182         -                        "FullUri=${dstFileName};[getFlagsProperty {} true]"))
         1182  +                        "FullUri=${dstFileName};[getTestProperties {} true]"))
  1183   1183                       {
  1184   1184                         destination.Open();
  1185   1185   
  1186   1186                         source.BackupDatabase(
  1187   1187                             destination, "main", "main", -1, null, 0);
  1188   1188                       }
  1189   1189                     }

Changes to Tests/thread.eagle.

   203    203   
   204    204                   //
   205    205                   // NOTE: Create a new connection object.  We purposely avoid
   206    206                   //       putting this inside a "using" block to help test our
   207    207                   //       cleanup via the garbage collector.
   208    208                   //
   209    209                   SQLiteConnection connection = new SQLiteConnection(
   210         -                    "Data Source=${dataSource};[getFlagsProperty]");
          210  +                    "Data Source=${dataSource};[getTestProperties]");
   211    211   
   212    212                   //
   213    213                   // NOTE: Open the connection.  After this point, native memory
   214    214                   //       and resources have been allocated by this thread.
   215    215                   //
   216    216                   connection.Open();
   217    217   

Changes to Tests/tkt-0e48e80333.eagle.

   190    190   
   191    191             /////////////////////////////////////////////////////////////////////
   192    192   
   193    193             public static SQLiteConnection MakeConnection()
   194    194             {
   195    195               SQLiteConnection connection = new SQLiteConnection(
   196    196                   "Data Source=${dataSource};Journal Mode=Wal;Pooling=true;" +
   197         -                "[getFlagsProperty AllowNestedTransactions]");
          197  +                "[getTestProperties AllowNestedTransactions]");
   198    198   
   199    199               connection.Open();
   200    200               connection.Trace += handler;
   201    201   
   202    202               return connection;
   203    203             }
   204    204   

Changes to Tests/tkt-1f7bfff467.eagle.

   167    167       namespace _Dynamic${id}
   168    168       {
   169    169         public static class Test${id}
   170    170         {
   171    171           public static void Main()
   172    172           {
   173    173             using (SQLiteConnection connection = new SQLiteConnection(
   174         -              "Data Source=${dataSource};[getFlagsProperty ${flags}]"))
          174  +              "Data Source=${dataSource};[getTestProperties ${flags}]"))
   175    175             {
   176    176               connection.Open();
   177    177   
   178    178               using (SQLiteTransaction transaction1 =
   179    179                   connection.BeginTransaction())
   180    180               {
   181    181                 using (SQLiteCommand command1 = new SQLiteCommand(
................................................................................
   250    250       namespace _Dynamic${id}
   251    251       {
   252    252         public static class Test${id}
   253    253         {
   254    254           public static void Main()
   255    255           {
   256    256             using (SQLiteConnection connection = new SQLiteConnection(
   257         -              "Data Source=${dataSource};[getFlagsProperty ${flags}]"))
          257  +              "Data Source=${dataSource};[getTestProperties ${flags}]"))
   258    258             {
   259    259               connection.Open();
   260    260   
   261    261               using (SQLiteTransaction transaction1 =
   262    262                   connection.BeginTransaction())
   263    263               {
   264    264                 using (SQLiteCommand command1 = new SQLiteCommand(
................................................................................
   337    337       namespace _Dynamic${id}
   338    338       {
   339    339         public static class Test${id}
   340    340         {
   341    341           public static void Main()
   342    342           {
   343    343             using (SQLiteConnection connection = new SQLiteConnection(
   344         -              "Data Source=${dataSource};[getFlagsProperty ${flags}]"))
          344  +              "Data Source=${dataSource};[getTestProperties ${flags}]"))
   345    345             {
   346    346               connection.Open();
   347    347   
   348    348               using (SQLiteTransaction transaction1 =
   349    349                   connection.BeginTransaction())
   350    350               {
   351    351                 using (SQLiteCommand command1 = new SQLiteCommand(
................................................................................
   437    437       namespace _Dynamic${id}
   438    438       {
   439    439         public static class Test${id}
   440    440         {
   441    441           public static void Main()
   442    442           {
   443    443             using (SQLiteConnection connection = new SQLiteConnection(
   444         -              "Data Source=${dataSource};[getFlagsProperty ${flags}]"))
          444  +              "Data Source=${dataSource};[getTestProperties ${flags}]"))
   445    445             {
   446    446               connection.Open();
   447    447   
   448    448               using (SQLiteTransaction transaction1 =
   449    449                   connection.BeginTransaction())
   450    450               {
   451    451                 using (SQLiteCommand command1 = new SQLiteCommand(

Changes to Tests/tkt-343d392b51.eagle.

   125    125       namespace _Dynamic${id}
   126    126       {
   127    127         public static class Test${id}
   128    128         {
   129    129           public static void Main()
   130    130           {
   131    131             using (SQLiteConnection connection = new SQLiteConnection(
   132         -              "Data Source=${dataSource};[getFlagsProperty]"))
          132  +              "Data Source=${dataSource};[getTestProperties]"))
   133    133             {
   134    134               connection.Open();
   135    135   
   136    136               using (SQLiteCommand command = connection.CreateCommand())
   137    137               {
   138    138                 command.CommandText = "${sql(1)}";
   139    139                 command.ExecuteNonQuery();
................................................................................
   232    232       {
   233    233         public static class Test${id}
   234    234         {
   235    235           public static void Main()
   236    236           {
   237    237             using (SQLiteConnection connection = new SQLiteConnection(
   238    238                 "Data Source=${dataSource};DateTimeFormat=JulianDay;" +
   239         -              "[getFlagsProperty]"))
          239  +              "[getTestProperties]"))
   240    240             {
   241    241               connection.Open();
   242    242   
   243    243               using (SQLiteCommand command = connection.CreateCommand())
   244    244               {
   245    245                 command.CommandText = "${sql(1)}";
   246    246                 command.ExecuteNonQuery();
................................................................................
   377    377       namespace _Dynamic${id}
   378    378       {
   379    379         public static class Test${id}
   380    380         {
   381    381           public static void Main()
   382    382           {
   383    383             using (SQLiteConnection connection = new SQLiteConnection(
   384         -              "Data Source=${dataSource};[getFlagsProperty]"))
          384  +              "Data Source=${dataSource};[getTestProperties]"))
   385    385             {
   386    386               connection.Open();
   387    387   
   388    388               using (SQLiteCommand command = connection.CreateCommand())
   389    389               {
   390    390                 command.CommandText = "${sql(1)}";
   391    391                 command.ExecuteNonQuery();

Changes to Tests/tkt-3aa50d8413.eagle.

    45     45       namespace _Dynamic${id}
    46     46       {
    47     47         public static class Test${id}
    48     48         {
    49     49           public static void Main()
    50     50           {
    51     51             using (SQLiteConnection connection = new SQLiteConnection(
    52         -              "Data Source=${dataSource};[getFlagsProperty]"))
           52  +              "Data Source=${dataSource};[getTestProperties]"))
    53     53             {
    54     54               connection.Open();
    55     55   
    56     56               using (SQLiteDataAdapter dataAdapter = new SQLiteDataAdapter(
    57     57                   "${sql}", connection))
    58     58               {
    59     59                 using (DataSet dataSet = new DataSet())

Changes to Tests/tkt-47c6fa04d3.eagle.

    76     76         public static class Test${id}
    77     77         {
    78     78           public static DataTable GetDataTable()
    79     79           {
    80     80             DataTable dataTable;
    81     81   
    82     82             using (SQLiteConnection connection = new SQLiteConnection(
    83         -              "Data Source=${dataSource};[getFlagsProperty]"))
           83  +              "Data Source=${dataSource};[getTestProperties]"))
    84     84             {
    85     85               connection.Open();
    86     86   
    87     87               using (SQLiteCommand command = new SQLiteCommand(@"${sql}",
    88     88                   connection))
    89     89               {
    90     90                 using (SQLiteDataReader dataReader = command.ExecuteReader())

Changes to Tests/tkt-48a6b8e4ca.eagle.

    43     43       namespace _Dynamic${id}
    44     44       {
    45     45         public static class Test${id}
    46     46         {
    47     47           public static void Main()
    48     48           {
    49     49             using (SQLiteConnection connection = new SQLiteConnection(
    50         -              "Data Source=${dataSource};[getFlagsProperty]"))
           50  +              "Data Source=${dataSource};[getTestProperties]"))
    51     51             {
    52     52               connection.Open();
    53     53   
    54     54               using (SQLiteCommand command = new SQLiteCommand("${sql}",
    55     55                   connection))
    56     56               {
    57     57                 using (SQLiteDataAdapter dataAdapter = new SQLiteDataAdapter(

Changes to Tests/tkt-4a791e70ab.eagle.

    36     36       namespace _Dynamic${id}
    37     37       {
    38     38         public static class Test${id}
    39     39         {
    40     40           public static void Main()
    41     41           {
    42     42             using (SQLiteConnection connection = new SQLiteConnection(
    43         -              "Data Source=${dataSource};[getFlagsProperty]"))
           43  +              "Data Source=${dataSource};[getTestProperties]"))
    44     44             {
    45     45               connection.Open();
    46     46   
    47     47               using (SQLiteCommand command = connection.CreateCommand())
    48     48               {
    49     49                 command.CommandText = "SELECT x FROM t1 ORDER BY x;";
    50     50   

Changes to Tests/tkt-56b42d99c1.eagle.

    42     42             TransactionOptions transactionOptions = new TransactionOptions();
    43     43             transactionOptions.IsolationLevel = IsolationLevel.ReadCommitted;
    44     44   
    45     45             using (TransactionScope transactionScope = new TransactionScope(
    46     46                 TransactionScopeOption.Required, transactionOptions))
    47     47             {
    48     48               using (SQLiteConnection connection1 = new SQLiteConnection(
    49         -                "Data Source=${dataSource};[getFlagsProperty]"))
           49  +                "Data Source=${dataSource};[getTestProperties]"))
    50     50               {
    51     51                 connection1.Open();
    52     52   
    53     53                 using (SQLiteConnection connection2 = new SQLiteConnection(
    54         -                  "Data Source=${dataSource};[getFlagsProperty]"))
           54  +                  "Data Source=${dataSource};[getTestProperties]"))
    55     55                 {
    56     56                   connection2.Open();
    57     57   
    58     58                   BindingFlags bindingFlags = BindingFlags.Instance |
    59     59                     BindingFlags.NonPublic | BindingFlags.GetField;
    60     60   
    61     61                   FieldInfo fieldInfo1 = connection1.GetType().GetField(
................................................................................
   135    135             TransactionOptions transactionOptions = new TransactionOptions();
   136    136             transactionOptions.IsolationLevel = IsolationLevel.ReadCommitted;
   137    137   
   138    138             using (TransactionScope transactionScope = new TransactionScope(
   139    139                 TransactionScopeOption.Required, transactionOptions))
   140    140             {
   141    141               using (SQLiteConnection connection1 = new SQLiteConnection(
   142         -                "Data Source=${dataSource};[getFlagsProperty]"))
          142  +                "Data Source=${dataSource};[getTestProperties]"))
   143    143               {
   144    144                 connection1.Open();
   145    145   
   146    146                 using (SQLiteConnection connection2 = new SQLiteConnection(
   147         -                  "Data Source=${dataSource};[getFlagsProperty]"))
          147  +                  "Data Source=${dataSource};[getTestProperties]"))
   148    148                 {
   149    149                   connection2.Open();
   150    150   
   151    151                   using (SQLiteCommand command1 = connection1.CreateCommand())
   152    152                   {
   153    153                     command1.CommandText = "${sql(1)}";
   154    154                     command1.ExecuteNonQuery();
................................................................................
   212    212             TransactionOptions transactionOptions = new TransactionOptions();
   213    213             transactionOptions.IsolationLevel = IsolationLevel.ReadCommitted;
   214    214   
   215    215             using (TransactionScope transactionScope = new TransactionScope(
   216    216                 TransactionScopeOption.Required, transactionOptions))
   217    217             {
   218    218               using (SQLiteConnection connection1 = new SQLiteConnection(
   219         -                "Data Source=${dataSource};Enlist=False;[getFlagsProperty]"))
          219  +                "Data Source=${dataSource};Enlist=False;[getTestProperties]"))
   220    220               {
   221    221                 connection1.Open();
   222    222   
   223    223                 using (SQLiteConnection connection2 = new SQLiteConnection(
   224         -                  "Data Source=${dataSource};Enlist=False;[getFlagsProperty]"))
          224  +                  "Data Source=${dataSource};Enlist=False;[getTestProperties]"))
   225    225                 {
   226    226                   connection2.Open();
   227    227   
   228    228                   using (SQLiteCommand command1 = connection1.CreateCommand())
   229    229                   {
   230    230                     command1.CommandText = "${sql(1)}";
   231    231                     command1.ExecuteNonQuery();
................................................................................
   289    289             TransactionOptions transactionOptions = new TransactionOptions();
   290    290             transactionOptions.IsolationLevel = IsolationLevel.ReadCommitted;
   291    291   
   292    292             using (TransactionScope transactionScope = new TransactionScope(
   293    293                 TransactionScopeOption.Required, transactionOptions))
   294    294             {
   295    295               using (SQLiteConnection connection1 = new SQLiteConnection(
   296         -                "Data Source=${dataSource};[getFlagsProperty]"))
          296  +                "Data Source=${dataSource};[getTestProperties]"))
   297    297               {
   298    298                 connection1.Open();
   299    299   
   300    300                 using (SQLiteConnection connection2 = new SQLiteConnection(
   301         -                  "Data Source=${dataSource};Enlist=False;[getFlagsProperty]"))
          301  +                  "Data Source=${dataSource};Enlist=False;[getTestProperties]"))
   302    302                 {
   303    303                   connection2.Open();
   304    304   
   305    305                   using (SQLiteCommand command1 = connection1.CreateCommand())
   306    306                   {
   307    307                     command1.CommandText = "${sql(1)}";
   308    308                     command1.ExecuteNonQuery();
................................................................................
   366    366             TransactionOptions transactionOptions = new TransactionOptions();
   367    367             transactionOptions.IsolationLevel = IsolationLevel.ReadCommitted;
   368    368   
   369    369             using (TransactionScope transactionScope = new TransactionScope(
   370    370                 TransactionScopeOption.Required, transactionOptions))
   371    371             {
   372    372               using (SQLiteConnection connection1 = new SQLiteConnection(
   373         -                "Data Source=${dataSource};Enlist=False;[getFlagsProperty]"))
          373  +                "Data Source=${dataSource};Enlist=False;[getTestProperties]"))
   374    374               {
   375    375                 connection1.Open();
   376    376   
   377    377                 using (SQLiteConnection connection2 = new SQLiteConnection(
   378         -                  "Data Source=${dataSource};[getFlagsProperty]"))
          378  +                  "Data Source=${dataSource};[getTestProperties]"))
   379    379                 {
   380    380                   connection2.Open();
   381    381   
   382    382                   using (SQLiteCommand command1 = connection1.CreateCommand())
   383    383                   {
   384    384                     command1.CommandText = "${sql(1)}";
   385    385                     command1.ExecuteNonQuery();
................................................................................
   439    439             TransactionOptions transactionOptions = new TransactionOptions();
   440    440             transactionOptions.IsolationLevel = IsolationLevel.ReadUncommitted;
   441    441   
   442    442             using (TransactionScope transactionScope = new TransactionScope(
   443    443                 TransactionScopeOption.Required, transactionOptions))
   444    444             {
   445    445               using (SQLiteConnection connection1 = new SQLiteConnection(
   446         -                "Data Source=${dataSource};[getFlagsProperty $flags]"))
          446  +                "Data Source=${dataSource};[getTestProperties $flags]"))
   447    447               {
   448    448                 connection1.Open();
   449    449   
   450    450                 using (SQLiteConnection connection2 = new SQLiteConnection(
   451         -                  "Data Source=${dataSource};[getFlagsProperty $flags]"))
          451  +                  "Data Source=${dataSource};[getTestProperties $flags]"))
   452    452                 {
   453    453                   connection2.Open();
   454    454   
   455    455                   BindingFlags bindingFlags = BindingFlags.Instance |
   456    456                     BindingFlags.NonPublic | BindingFlags.GetField;
   457    457   
   458    458                   FieldInfo fieldInfo1 = connection1.GetType().GetField(
................................................................................
   532    532             TransactionOptions transactionOptions = new TransactionOptions();
   533    533             transactionOptions.IsolationLevel = IsolationLevel.ReadUncommitted;
   534    534   
   535    535             using (TransactionScope transactionScope = new TransactionScope(
   536    536                 TransactionScopeOption.Required, transactionOptions))
   537    537             {
   538    538               using (SQLiteConnection connection1 = new SQLiteConnection(
   539         -                "Data Source=${dataSource};[getFlagsProperty $flags]"))
          539  +                "Data Source=${dataSource};[getTestProperties $flags]"))
   540    540               {
   541    541                 connection1.Open();
   542    542   
   543    543                 using (SQLiteConnection connection2 = new SQLiteConnection(
   544         -                  "Data Source=${dataSource};[getFlagsProperty $flags]"))
          544  +                  "Data Source=${dataSource};[getTestProperties $flags]"))
   545    545                 {
   546    546                   connection2.Open();
   547    547   
   548    548                   using (SQLiteCommand command1 = connection1.CreateCommand())
   549    549                   {
   550    550                     command1.CommandText = "${sql(1)}";
   551    551                     command1.ExecuteNonQuery();
................................................................................
   609    609             TransactionOptions transactionOptions = new TransactionOptions();
   610    610             transactionOptions.IsolationLevel = IsolationLevel.ReadUncommitted;
   611    611   
   612    612             using (TransactionScope transactionScope = new TransactionScope(
   613    613                 TransactionScopeOption.Required, transactionOptions))
   614    614             {
   615    615               using (SQLiteConnection connection1 = new SQLiteConnection(
   616         -                "Data Source=${dataSource};Enlist=False;[getFlagsProperty $flags]"))
          616  +                "Data Source=${dataSource};Enlist=False;[getTestProperties $flags]"))
   617    617               {
   618    618                 connection1.Open();
   619    619   
   620    620                 using (SQLiteConnection connection2 = new SQLiteConnection(
   621         -                  "Data Source=${dataSource};Enlist=False;[getFlagsProperty $flags]"))
          621  +                  "Data Source=${dataSource};Enlist=False;[getTestProperties $flags]"))
   622    622                 {
   623    623                   connection2.Open();
   624    624   
   625    625                   using (SQLiteCommand command1 = connection1.CreateCommand())
   626    626                   {
   627    627                     command1.CommandText = "${sql(1)}";
   628    628                     command1.ExecuteNonQuery();
................................................................................
   686    686             TransactionOptions transactionOptions = new TransactionOptions();
   687    687             transactionOptions.IsolationLevel = IsolationLevel.ReadUncommitted;
   688    688   
   689    689             using (TransactionScope transactionScope = new TransactionScope(
   690    690                 TransactionScopeOption.Required, transactionOptions))
   691    691             {
   692    692               using (SQLiteConnection connection1 = new SQLiteConnection(
   693         -                "Data Source=${dataSource};[getFlagsProperty $flags]"))
          693  +                "Data Source=${dataSource};[getTestProperties $flags]"))
   694    694               {
   695    695                 connection1.Open();
   696    696   
   697    697                 using (SQLiteConnection connection2 = new SQLiteConnection(
   698         -                  "Data Source=${dataSource};Enlist=False;[getFlagsProperty $flags]"))
          698  +                  "Data Source=${dataSource};Enlist=False;[getTestProperties $flags]"))
   699    699                 {
   700    700                   connection2.Open();
   701    701   
   702    702                   using (SQLiteCommand command1 = connection1.CreateCommand())
   703    703                   {
   704    704                     command1.CommandText = "${sql(1)}";
   705    705                     command1.ExecuteNonQuery();
................................................................................
   763    763             TransactionOptions transactionOptions = new TransactionOptions();
   764    764             transactionOptions.IsolationLevel = IsolationLevel.ReadUncommitted;
   765    765   
   766    766             using (TransactionScope transactionScope = new TransactionScope(
   767    767                 TransactionScopeOption.Required, transactionOptions))
   768    768             {
   769    769               using (SQLiteConnection connection1 = new SQLiteConnection(
   770         -                "Data Source=${dataSource};Enlist=False;[getFlagsProperty $flags]"))
          770  +                "Data Source=${dataSource};Enlist=False;[getTestProperties $flags]"))
   771    771               {
   772    772                 connection1.Open();
   773    773   
   774    774                 using (SQLiteConnection connection2 = new SQLiteConnection(
   775         -                  "Data Source=${dataSource};[getFlagsProperty $flags]"))
          775  +                  "Data Source=${dataSource};[getTestProperties $flags]"))
   776    776                 {
   777    777                   connection2.Open();
   778    778   
   779    779                   using (SQLiteCommand command1 = connection1.CreateCommand())
   780    780                   {
   781    781                     command1.CommandText = "${sql(1)}";
   782    782                     command1.ExecuteNonQuery();

Changes to Tests/tkt-6434e23a0f.eagle.

    46     46       namespace _Dynamic${id}
    47     47       {
    48     48         public static class Test${id}
    49     49         {
    50     50           public static void Main()
    51     51           {
    52     52             using (SQLiteConnection connection = new SQLiteConnection(
    53         -              "Data Source=${dataSource};[getFlagsProperty]"))
           53  +              "Data Source=${dataSource};[getTestProperties]"))
    54     54             {
    55     55               connection.Open();
    56     56   
    57     57               using (SQLiteDataAdapter dataAdapter = new SQLiteDataAdapter(
    58     58                   "${sql}", connection))
    59     59               {
    60     60                 dataAdapter.Fill(new DataSet());

Changes to Tests/tkt-6c6ecccc5f.eagle.

    42     42       namespace _Dynamic${id}
    43     43       {
    44     44         public static class Test${id}
    45     45         {
    46     46           public static void Main()
    47     47           {
    48     48             using (SQLiteConnection connection = new SQLiteConnection(
    49         -              "Data Source=${dataSource};[getFlagsProperty]"))
           49  +              "Data Source=${dataSource};[getTestProperties]"))
    50     50             {
    51     51               connection.Open();
    52     52   
    53     53               using (SQLiteCommand command = new SQLiteCommand("${sql}",
    54     54                   connection))
    55     55               {
    56     56                 /* IGNORED */

Changes to Tests/tkt-72905c9a77.eagle.

   167    167   
   168    168                     //
   169    169                     // NOTE: Create and open a connection and use it to log a
   170    170                     //       test message just to make sure that the logging
   171    171                     //       system is initialized and in working order.
   172    172                     //
   173    173                     using (SQLiteConnection connection = new SQLiteConnection(
   174         -                      "Data Source=${dataSource};[getFlagsProperty]"))
          174  +                      "Data Source=${dataSource};[getTestProperties]"))
   175    175                     {
   176    176                       connection.Open();
   177    177                       connection.LogMessage(0, "TEST ${id}");
   178    178                     }
   179    179                   }
   180    180                   catch (Exception e)
   181    181                   {

Changes to Tests/tkt-7e3fa93744.eagle.

    93     93       namespace _Dynamic${id}
    94     94       {
    95     95         public static class Test${id}
    96     96         {
    97     97           public static int Main()
    98     98           {
    99     99             using (SQLiteConnection connection = new SQLiteConnection(
   100         -              "Data Source=${dataSource};[getFlagsProperty]"))
          100  +              "Data Source=${dataSource};[getTestProperties]"))
   101    101             {
   102    102               connection.Open();
   103    103   
   104    104               using (SQLiteCommand command = connection.CreateCommand())
   105    105               {
   106    106                 command.CommandText = "${sql}";
   107    107   

Changes to Tests/tkt-85b824b736.eagle.

    79     79         public static class Test${id}
    80     80         {
    81     81           public static StringList GetList(params string\[\] strings)
    82     82           {
    83     83             StringList result = new StringList();
    84     84   
    85     85             using (SQLiteConnection connection = new SQLiteConnection(
    86         -              "Data Source=${dataSource};[getFlagsProperty]"))
           86  +              "Data Source=${dataSource};[getTestProperties]"))
    87     87             {
    88     88               connection.Open();
    89     89   
    90     90               SQLiteModuleTest${id} module = new SQLiteModuleTest${id}(
    91     91                   "mod${id}", strings);
    92     92   
    93     93               connection.CreateModule(module);
................................................................................
   198    198         public static class Test${id}
   199    199         {
   200    200           public static ByteList GetList(params string\[\] strings)
   201    201           {
   202    202             ByteList result = new ByteList();
   203    203   
   204    204             using (SQLiteConnection connection = new SQLiteConnection(
   205         -              "Data Source=${dataSource};[getFlagsProperty]"))
          205  +              "Data Source=${dataSource};[getTestProperties]"))
   206    206             {
   207    207               connection.Open();
   208    208   
   209    209               SQLiteModuleTest${id} module = new SQLiteModuleTest${id}(
   210    210                   "mod${id}", strings);
   211    211   
   212    212               connection.CreateModule(module);

Changes to Tests/tkt-996d13cd87.eagle.

   146    146                     //       and then wait a random number of milliseconds before
   147    147                     //       doing it again.
   148    148                     //
   149    149                     Thread.Sleep(random.Next(0, 500));
   150    150   
   151    151                     SQLiteConnection connection = new SQLiteConnection(
   152    152                         "Data Source=${dataSource};Pooling=${pooling};" +
   153         -                      "[getFlagsProperty]");
          153  +                      "[getTestProperties]");
   154    154   
   155    155                     connection.Open();
   156    156   
   157    157                     using (SQLiteCommand command = new SQLiteCommand("${sql}",
   158    158                         connection))
   159    159                     {
   160    160                       command.ExecuteNonQuery();

Changes to Tests/tkt-ae5267b863.eagle.

    67     67       namespace _Dynamic${id}
    68     68       {
    69     69         public static class Test${id}
    70     70         {
    71     71           public static void Main()
    72     72           {
    73     73             using (SQLiteConnection connection = new SQLiteConnection(
    74         -              "Data Source=${dataSource};[getFlagsProperty]"))
           74  +              "Data Source=${dataSource};[getTestProperties]"))
    75     75             {
    76     76               connection.Open();
    77     77   
    78     78               using (SQLiteCommand command = connection.CreateCommand())
    79     79               {
    80     80                 command.CommandText = "${sql(1)}";
    81     81                 command.ExecuteNonQuery();

Changes to Tests/tkt-e1b2e0f769.eagle.

    95     95             }
    96     96   
    97     97             /////////////////////////////////////////////////////////////////////
    98     98   
    99     99             public static int Main()
   100    100             {
   101    101               using (SQLiteConnection connection = new SQLiteConnection(
   102         -                "Data Source=${dataSource};[getFlagsProperty]"))
          102  +                "Data Source=${dataSource};[getTestProperties]"))
   103    103               {
   104    104                 connection.Open();
   105    105   
   106    106                 return Tkt_e1b2e0f769(connection).Count;
   107    107               }
   108    108             }
   109    109           }

Changes to Tests/tkt-e30b820248.eagle.

    58     58                 new FileStream("${test_log}", FileMode.Append,
    59     59                     FileAccess.Write, FileShare.ReadWrite), "${name}"))
    60     60             {
    61     61               Trace.Listeners.Add(listener);
    62     62               Trace.WriteLine("---- START TRACE \\"${name}\\"");
    63     63   
    64     64               using (SQLiteConnection connection = new SQLiteConnection(
    65         -                "Data Source=${dataSource};[getFlagsProperty]"))
           65  +                "Data Source=${dataSource};[getTestProperties]"))
    66     66               {
    67     67                 connection.Open();
    68     68                 connection.LogMessage(0, "Connection opened.");
    69     69   
    70     70                 using (SQLiteTransaction transaction =
    71     71                     connection.BeginTransaction())
    72     72                 {
................................................................................
   154    154   
   155    155             /////////////////////////////////////////////////////////////////////
   156    156   
   157    157             #region Public Static Methods
   158    158             public static void OpenConnection()
   159    159             {
   160    160               connection = new SQLiteConnection(
   161         -                "Data Source=${dataSource};[getFlagsProperty]");
          161  +                "Data Source=${dataSource};[getTestProperties]");
   162    162   
   163    163               connection.Open();
   164    164               connection.LogMessage(0, "Connection opened.");
   165    165             }
   166    166   
   167    167             /////////////////////////////////////////////////////////////////////
   168    168   

Changes to Tests/tkt-ef2216192d.eagle.

    40     40       namespace _Dynamic${id}
    41     41       {
    42     42         public static class Test${id}
    43     43         {
    44     44           public static void Main()
    45     45           {
    46     46             using (SQLiteConnection connection = new SQLiteConnection(
    47         -              "Data Source=${dataSource};[getFlagsProperty]"))
           47  +              "Data Source=${dataSource};[getTestProperties]"))
    48     48             {
    49     49               connection.Open();
    50     50   
    51     51               using (SQLiteDataAdapter dataAdapter = new SQLiteDataAdapter(
    52     52                   "${sql}", connection))
    53     53               {
    54     54                 using (SQLiteCommandBuilder commandBuilder =

Changes to Tests/vtab.eagle.

    82     82         /////////////////////////////////////////////////////////////////////////
    83     83   
    84     84         public static class Test${id}
    85     85         {
    86     86           public static void Main()
    87     87           {
    88     88             using (SQLiteConnection connection = new SQLiteConnection(
    89         -              "Data Source=${dataSource};[getFlagsProperty]"))
           89  +              "Data Source=${dataSource};[getTestProperties]"))
    90     90             {
    91     91               connection.Open();
    92     92               connection.CreateModule(new SQLiteModuleTest${id}("mod${id}"));
    93     93   
    94     94               using (SQLiteCommand command = connection.CreateCommand())
    95     95               {
    96     96                 command.CommandText = "[subst ${sql}]";
................................................................................
   151    151         public static class Test${id}
   152    152         {
   153    153           public static StringList GetList(params string\[\] strings)
   154    154           {
   155    155             StringList result = new StringList();
   156    156   
   157    157             using (SQLiteConnection connection = new SQLiteConnection(
   158         -              "Data Source=${dataSource};[getFlagsProperty]"))
          158  +              "Data Source=${dataSource};[getTestProperties]"))
   159    159             {
   160    160               connection.Open();
   161    161   
   162    162               connection.CreateModule(new SQLiteModuleEnumerable(
   163    163                 "mod${id}", strings));
   164    164   
   165    165               using (SQLiteCommand command = connection.CreateCommand())
................................................................................
   259    259         public static class Test${id}
   260    260         {
   261    261           public static StringList GetList(params string\[\] strings)
   262    262           {
   263    263             StringList result = new StringList();
   264    264   
   265    265             using (SQLiteConnection connection = new SQLiteConnection(
   266         -              "Data Source=${dataSource};[getFlagsProperty]"))
          266  +              "Data Source=${dataSource};[getTestProperties]"))
   267    267             {
   268    268               connection.Open();
   269    269   
   270    270               SQLiteModule module = new SQLiteModuleEnumerable(
   271    271                   "mod${id}", strings);
   272    272   
   273    273               connection.CreateModule(module);
................................................................................
   371    371         public static class Test${id}
   372    372         {
   373    373           public static StringList GetList(params int\[\] integers)
   374    374           {
   375    375             StringList result = new StringList();
   376    376   
   377    377             using (SQLiteConnection connection = new SQLiteConnection(
   378         -              "Data Source=${dataSource};[getFlagsProperty]"))
          378  +              "Data Source=${dataSource};[getTestProperties]"))
   379    379             {
   380    380               connection.Open();
   381    381   
   382    382               connection.CreateModule(new SQLiteModuleEnumerable<int>(
   383    383                 "mod${id}", integers));
   384    384   
   385    385               using (SQLiteCommand command = connection.CreateCommand())
................................................................................
   479    479         public static class Test${id}
   480    480         {
   481    481           public static StringList GetList(params int\[\] integers)
   482    482           {
   483    483             StringList result = new StringList();
   484    484   
   485    485             using (SQLiteConnection connection = new SQLiteConnection(
   486         -              "Data Source=${dataSource};[getFlagsProperty]"))
          486  +              "Data Source=${dataSource};[getTestProperties]"))
   487    487             {
   488    488               connection.Open();
   489    489   
   490    490               SQLiteModule module = new SQLiteModuleEnumerable<int>(
   491    491                   "mod${id}", integers);
   492    492   
   493    493               connection.CreateModule(module);
................................................................................
   715    715         public static class Test${id}
   716    716         {
   717    717           public static StringList GetList()
   718    718           {
   719    719             StringList result = new StringList();
   720    720   
   721    721             using (SQLiteConnection connection = new SQLiteConnection(
   722         -              "Data Source=${dataSource};[getFlagsProperty NoBindFunctions]"))
          722  +              "Data Source=${dataSource};[getTestProperties NoBindFunctions]"))
   723    723             {
   724    724               connection.Open();
   725    725               connection.CreateModule(new SQLiteModuleTest${id}("mod${id}"));
   726    726   
   727    727               try
   728    728               {
   729    729                 using (SQLiteCommand command = connection.CreateCommand())
................................................................................
   968    968         public static class Test${id}
   969    969         {
   970    970           public static StringList GetList()
   971    971           {
   972    972             StringList result = new StringList();
   973    973   
   974    974             using (SQLiteConnection connection = new SQLiteConnection(
   975         -              "Data Source=${dataSource};[getFlagsProperty]"))
          975  +              "Data Source=${dataSource};[getTestProperties]"))
   976    976             {
   977    977               connection.Open();
   978    978               connection.CreateModule(new SQLiteModuleTest${id}("mod${id}"));
   979    979   
   980    980               try
   981    981               {
   982    982                 using (SQLiteCommand command = connection.CreateCommand())
................................................................................
  1137   1137         public static class Test${id}
  1138   1138         {
  1139   1139           public static StringList GetList()
  1140   1140           {
  1141   1141             StringList result = new StringList();
  1142   1142   
  1143   1143             using (SQLiteConnection connection = new SQLiteConnection(
  1144         -              "Data Source=${dataSource};[getFlagsProperty]"))
         1144  +              "Data Source=${dataSource};[getTestProperties]"))
  1145   1145             {
  1146   1146               connection.Open();
  1147   1147               connection.CreateModule(new SQLiteModuleTest${id}("mod${id}"));
  1148   1148   
  1149   1149               try
  1150   1150               {
  1151   1151                 using (SQLiteCommand command = connection.CreateCommand())
................................................................................
  1314   1314         public static class Test${id}
  1315   1315         {
  1316   1316           public static StringList GetList(params string\[\] strings)
  1317   1317           {
  1318   1318             StringList result = new StringList();
  1319   1319   
  1320   1320             using (SQLiteConnection connection = new SQLiteConnection(
  1321         -              "Data Source=${dataSource};[getFlagsProperty]"))
         1321  +              "Data Source=${dataSource};[getTestProperties]"))
  1322   1322             {
  1323   1323               connection.Open();
  1324   1324   
  1325   1325               SQLiteModuleTest${id} module = new SQLiteModuleTest${id}(
  1326   1326                   "mod${id}", strings);
  1327   1327   
  1328   1328               connection.CreateModule(module);
................................................................................
  1459   1459         public static class Test${id}
  1460   1460         {
  1461   1461           public static StringList GetList(params string\[\] strings)
  1462   1462           {
  1463   1463             StringList result = new StringList();
  1464   1464   
  1465   1465             using (SQLiteConnection connection = new SQLiteConnection(
  1466         -              "Data Source=${dataSource};[getFlagsProperty]"))
         1466  +              "Data Source=${dataSource};[getTestProperties]"))
  1467   1467             {
  1468   1468               connection.Open();
  1469   1469   
  1470   1470               SQLiteModuleTest${id} module = new SQLiteModuleTest${id}(
  1471   1471                   "mod${id}", strings);
  1472   1472   
  1473   1473               connection.CreateModule(module);
................................................................................
  1553   1553       namespace _Dynamic${id}
  1554   1554       {
  1555   1555         public static class Test${id}
  1556   1556         {
  1557   1557           public static object GetSum()
  1558   1558           {
  1559   1559             using (SQLiteConnection connection = new SQLiteConnection(
  1560         -              "Data Source=${dataSource};[getFlagsProperty]"))
         1560  +              "Data Source=${dataSource};[getTestProperties]"))
  1561   1561             {
  1562   1562               connection.Open();
  1563   1563   
  1564   1564               byte\[\] bytes = new byte\[1048576\];
  1565   1565               new Random().NextBytes(bytes);
  1566   1566   
  1567   1567               connection.CreateModule(new SQLiteModuleEnumerable(
................................................................................
  1635   1635         public static class Test${id}
  1636   1636         {
  1637   1637           public static StringList GetList(params string\[\] strings)
  1638   1638           {
  1639   1639             StringList result = new StringList();
  1640   1640   
  1641   1641             using (SQLiteConnection connection = new SQLiteConnection(
  1642         -              "Data Source=${dataSource};[getFlagsProperty]"))
         1642  +              "Data Source=${dataSource};[getTestProperties]"))
  1643   1643             {
  1644   1644               connection.Open();
  1645   1645   
  1646   1646               connection.CreateModule(new SQLiteModuleEnumerable(
  1647   1647                 "mod${id}", strings));
  1648   1648   
  1649   1649               using (SQLiteCommand command = connection.CreateCommand())
................................................................................
  1733   1733         public static class Test${id}
  1734   1734         {
  1735   1735           public static StringList GetList(params string\[\] strings)
  1736   1736           {
  1737   1737             StringList result = new StringList();
  1738   1738   
  1739   1739             using (SQLiteConnection connection = new SQLiteConnection(
  1740         -              "Data Source=${dataSource};[getFlagsProperty]"))
         1740  +              "Data Source=${dataSource};[getTestProperties]"))
  1741   1741             {
  1742   1742               connection.Open();
  1743   1743   
  1744   1744               connection.CreateModule(new SQLiteModuleEnumerable(
  1745   1745                 "mod${id}", strings, true));
  1746   1746   
  1747   1747               using (SQLiteCommand command = connection.CreateCommand())

Changes to lib/System.Data.SQLite/common.eagle.

  2525   2525           #          ["magical"] meta-flags).
  2526   2526           #
  2527   2527           return [appendArgs "Flags=" $flags \;]
  2528   2528         }
  2529   2529   
  2530   2530         return ""
  2531   2531       }
         2532  +
         2533  +    proc getTestProperties { {flags ""} {quiet false} } {
         2534  +      #
         2535  +      # NOTE: Start with "Flags" property for the new connection, if any.
         2536  +      #
         2537  +      set result [getFlagsProperty $flags $quiet]
         2538  +
         2539  +      #
         2540  +      # NOTE: Add the name of the current test file, if available.  This is
         2541  +      #       only used for debugging.
         2542  +      #
         2543  +      if {[info exists ::test_file]} then {
         2544  +        append result {TestFile=${::test_file};}
         2545  +      }
         2546  +
         2547  +      #
         2548  +      # NOTE: Add the name of the current test, if available.  This is only
         2549  +      #       used for debugging.
         2550  +      #
         2551  +      if {[info exists ::eagle_tests(CurrentName)]} then {
         2552  +        append result {TestName=${::eagle_tests(CurrentName)};}
         2553  +      }
         2554  +
         2555  +      return $result
         2556  +    }
  2532   2557   
  2533   2558       proc enableSharedCache { channel enable {quiet false} } {
  2534   2559         if {[catch {
  2535   2560           object invoke -flags +NonPublic \
  2536   2561               System.Data.SQLite.UnsafeNativeMethods \
  2537   2562               sqlite3_enable_shared_cache [expr int($enable)]
  2538   2563         } result] == 0} then {
................................................................................
  2656   2681         #
  2657   2682         # NOTE: If our caller specified an extra payload to the connection
  2658   2683         #       string, append it now.
  2659   2684         #
  2660   2685         if {[string length $extra] > 0} then {
  2661   2686           append connection \; $extra
  2662   2687         }
         2688  +
         2689  +      #
         2690  +      # NOTE: Add the name of the current test file, if available.  This is
         2691  +      #       only used for debugging.
         2692  +      #
         2693  +      if {[info exists ::test_file]} then {
         2694  +        append connection {;TestFile=${::test_file}}
         2695  +      }
         2696  +
         2697  +      #
         2698  +      # NOTE: Add the name of the current test, if available.  This is only
         2699  +      #       used for debugging.
         2700  +      #
         2701  +      if {[info exists ::eagle_tests(CurrentName)]} then {
         2702  +        append connection {;TestName=${::eagle_tests(CurrentName)}}
         2703  +      }
  2663   2704   
  2664   2705         #
  2665   2706         # NOTE: For clarity, append a final semicolon to the connection string.
  2666   2707         #
  2667   2708         append connection \;
  2668   2709   
  2669   2710         #
................................................................................
  4951   4992   
  4952   4993           #
  4953   4994           # NOTE: Save the test constraints for use by threads created in this
  4954   4995           #       application domain.  This is necessary because all the Eagle
  4955   4996           #       "test context" information is per-thread.
  4956   4997           #
  4957   4998           if {![info exists ::test_constraints]} then {
  4958         -          set ::test_constraints $::eagle_tests(constraints)
         4999  +          set ::test_constraints $::eagle_tests(Constraints)
  4959   5000           }
  4960   5001   
  4961   5002           #
  4962   5003           # NOTE: Load the "after-constraints" custom per-user and/or per-host
  4963   5004           #       test settings now.
  4964   5005           #
  4965   5006           uplevel 1 [list loadSQLiteTestSettings $::test_channel .after]