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: |
611657ba5be8f8e497ca180fcf14e0f7 |
| 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
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]