System.Data.SQLite
Check-in [17e1e7df74]
Not logged in

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

Overview
Comment:Add support for the new 'testExec' and 'compileCSharp' test constraints. Update the Eagle script library in externals to the latest trunk.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: 17e1e7df74ef6590e4db70f6ded519c413ce0304
User & Date: mistachkin 2013-09-25 02:29:55
Context
2013-10-07
18:22
Fix data table name issue for the GetSchema method reported on the mailing list. check-in: e1c3a2bc9c user: mistachkin tags: trunk
2013-09-25
02:29
Add support for the new 'testExec' and 'compileCSharp' test constraints. Update the Eagle script library in externals to the latest trunk. check-in: 17e1e7df74 user: mistachkin tags: trunk
2013-09-18
09:10
Make the new error messages in the batch build tool more consistent. check-in: aeadebd327 user: mistachkin tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to Externals/Eagle/lib/Eagle1.0/init.eagle.

  1164   1164   
  1165   1165         set command [list exec -- \
  1166   1166             [file join $directory Hippogriff.exe] -delay 2000]
  1167   1167   
  1168   1168         eval $command &; exit -force
  1169   1169       }
  1170   1170   
  1171         -    #
  1172         -    # NOTE: This proc is used to check for new versions of the runtime
  1173         -    #       when the user executes the interactive "#check" command.  To
  1174         -    #       disable that functionality, redefine this proc to do nothing.
  1175         -    #
  1176         -    proc checkForUpdate {} {
         1171  +    proc getUpdateData { uri } {
  1177   1172         #
  1178         -      # NOTE: This should work properly in Eagle only.
  1179         -      #
  1180         -      set uri [appendArgs [info engine Uri] [info engine UpdateFile]]
  1181         -      set fileName [file tempname]; # unique local temp file name.
  1182         -
  1183         -      #
  1184         -      # NOTE: Temporarily start trusting ONLY our self-signed certificate
  1185         -      #       which is used primarily for "software updates".
         1173  +      # NOTE: Temporarily start trusting ONLY our own self-signed
         1174  +      #       certificate which is used primarily for updates.
  1186   1175         #
  1187   1176         uri softwareupdates true
  1188   1177   
  1189   1178         try {
  1190   1179           #
  1191   1180           # NOTE: Download the tag file from the web site.
  1192   1181           #
  1193         -        uri download $uri $fileName; # synchronous.
         1182  +        return [uri download -inline $uri]; # synchronous.
         1183  +      } finally {
         1184  +        #
         1185  +        # NOTE: Stop trusting ONLY our own self-signed certificate
         1186  +        #       which is used primarily for updates.
         1187  +        #
         1188  +        uri softwareupdates false
         1189  +      }
         1190  +    }
         1191  +
         1192  +    proc getUpdateScriptData { uri } {
         1193  +      #
         1194  +      # NOTE: Temporarily start trusting ONLY our own self-signed
         1195  +      #       certificate which is used primarily for updates.
         1196  +      #
         1197  +      uri softwareupdates true
         1198  +
         1199  +      try {
         1200  +        #
         1201  +        # NOTE: Download the script file from the web site.
         1202  +        #
         1203  +        return [interp readorgetscriptfile $uri]; # synchronous.
  1194   1204         } finally {
  1195   1205           #
  1196         -        # NOTE: Stop trusting ONLY our self-signed certificate which is
  1197         -        #       used primarily for "software updates".
         1206  +        # NOTE: Stop trusting ONLY our own self-signed certificate
         1207  +        #       which is used primarily for updates.
  1198   1208           #
  1199   1209           uri softwareupdates false
  1200   1210         }
         1211  +    }
         1212  +
         1213  +    #
         1214  +    # NOTE: This proc is used to check for new versions -OR- new update
         1215  +    #       scripts for the runtime when a user executes the interactive
         1216  +    #       "#check" command.  To disable this functionality, simply
         1217  +    #       redefine this procedure to do nothing.
         1218  +    #
         1219  +    proc checkForUpdate { {wantScripts false} } {
         1220  +      #
         1221  +      # NOTE: This should work properly in Eagle only.
         1222  +      #
         1223  +      set updateUri [appendArgs [info engine Uri] [info engine UpdateFile]]
  1201   1224   
  1202   1225         #
  1203         -      # NOTE: Read all the data out of the downloaded text file.
         1226  +      # NOTE: Fetch the master update data from the distribution site
         1227  +      #       and normalize to Unix-style line-endings.
  1204   1228         #
  1205         -      set data [readFile $fileName]
  1206         -
  1207         -      #
  1208         -      # NOTE: Remove the downloaded temporary file.  We no longer need
  1209         -      #       it because we just read all the data from it.
  1210         -      #
  1211         -      file delete $fileName
  1212         -
  1213         -      #
  1214         -      # NOTE: Normalize to Unix line-endings.
  1215         -      #
  1216         -      set data [string map [list \r\n \n] $data]; # Unix.
         1229  +      set updateData [string map [list \r\n \n] [getUpdateData $updateUri]]
  1217   1230   
  1218   1231         #
  1219   1232         # NOTE: Split the data into lines.
  1220   1233         #
  1221         -      set lines [split $data \n]
         1234  +      set lines [split $updateData \n]
         1235  +
         1236  +      #
         1237  +      # NOTE: Keep track of how many update scripts are processed.
         1238  +      #
         1239  +      set scriptCount 0
  1222   1240   
  1223   1241         #
  1224   1242         # NOTE: Check each line to find the build information...
  1225   1243         #
  1226   1244         foreach line $lines {
  1227   1245           #
  1228   1246           # NOTE: Remove excess whitespace.
................................................................................
  1236   1254             #
  1237   1255             # NOTE: Skip comment lines.
  1238   1256             #
  1239   1257             if {[string index $line 0] ne "#" && \
  1240   1258                 [string index $line 0] ne ";"} then {
  1241   1259               #
  1242   1260               # NOTE: Split the tab-delimited line into fields.  The format
  1243         -            #       of the lines must be as follows:
         1261  +            #       of all lines in the data must be as follows:
  1244   1262               #
  1245         -            # protocolId <tab> publicKeyToken <tab> name <tab> culture
  1246         -            # <tab> patchLevel <tab> timeStamp <tab> uri <tab> md5Hash
  1247         -            # <tab> sha1Hash <tab> sha512Hash <tab> notes <newLine>
         1263  +            #       <startLine> protocolId <tab> publicKeyToken <tab> name
         1264  +            #       <tab> culture <tab> patchLevel <tab> timeStamp <tab>
         1265  +            #       baseUri <tab> md5Hash <tab> sha1Hash <tab> sha512Hash
         1266  +            #       <tab> notes <newLine>
  1248   1267               #
  1249   1268               set fields [split $line \t]
  1250   1269   
  1251   1270               #
  1252   1271               # NOTE: Grab the protocol Id field.
  1253   1272               #
  1254   1273               set protocolId [lindex $fields 0]
................................................................................
  1264   1283               set name [lindex $fields 2]
  1265   1284   
  1266   1285               #
  1267   1286               # NOTE: Grab the culture field.
  1268   1287               #
  1269   1288               set culture [lindex $fields 3]
  1270   1289   
         1290  +            #
         1291  +            # NOTE: Figure out which protocol is in use for this line.
         1292  +            #       The value "1" means this line specifies a build of
         1293  +            #       the script engine.  The value "2" means this line
         1294  +            #       specifies an update script (via a URI) to evaluate.
         1295  +            #       All other values are currently reserved and ignored.
         1296  +            #
         1297  +            set checkBuild [expr {!$wantScripts && $protocolId eq "1"}]
         1298  +            set checkScript [expr {$wantScripts && $protocolId eq "2"}]
         1299  +
  1271   1300               #
  1272   1301               # NOTE: We only want to find the first line that matches our
  1273   1302               #       engine.  The public key token is being used here to
  1274   1303               #       make sure we get the same "flavor" of the engine.
  1275   1304               #       The lines are organized so that the "latest stable
  1276   1305               #       version" is on the first line (for a given public key
  1277   1306               #       token), followed by development builds, experimental
  1278   1307               #       builds, etc.
  1279   1308               #
  1280         -            if {$protocolId eq "1" && \
         1309  +            if {($checkBuild || $checkScript) && \
  1281   1310                   [matchEnginePublicKeyToken $publicKeyToken] && \
  1282   1311                   [matchEngineName $name] && \
  1283   1312                   [matchEngineCulture $culture]} then {
  1284   1313                 #
  1285   1314                 # NOTE: Grab the patch level field.
  1286   1315                 #
  1287   1316                 set patchLevel [lindex $fields 4]
................................................................................
  1297   1326   
  1298   1327                 #
  1299   1328                 # NOTE: Compare the patch level from the line to the one we
  1300   1329                 #       are currently using.
  1301   1330                 #
  1302   1331                 set compare [package vcompare $patchLevel $enginePatchLevel]
  1303   1332   
  1304         -              if {$compare > 0} then {
         1333  +              if {($checkBuild && $compare > 0) || \
         1334  +                  ($checkScript && $compare == 0)} then {
  1305   1335                   #
  1306   1336                   # NOTE: Grab the time-stamp field.
  1307   1337                   #
  1308   1338                   set timeStamp [lindex $fields 5]
  1309   1339   
  1310   1340                   if {[string length $timeStamp] == 0} then {
  1311   1341                     set timeStamp 0; #never?
................................................................................
  1313   1343   
  1314   1344                   #
  1315   1345                   # NOTE: Grab the base URI field (i.e. it may be a mirror
  1316   1346                   #       site).
  1317   1347                   #
  1318   1348                   set baseUri [lindex $fields 6]
  1319   1349   
  1320         -                if {[string length $baseUri] == 0} then {
         1350  +                if {$checkBuild && [string length $baseUri] == 0} then {
  1321   1351                     set baseUri [info engine Uri]; # primary site.
  1322   1352                   }
  1323   1353   
  1324   1354                   #
  1325   1355                   # NOTE: Grab the notes field (which may be empty).
  1326   1356                   #
  1327   1357                   set notes [lindex $fields 10]
................................................................................
  1337   1367                   if {[string is integer -strict $timeStamp]} then {
  1338   1368                     set dateTime [clock format $timeStamp]
  1339   1369                   } else {
  1340   1370                     set dateTime [clock format [clock scan $timeStamp]]
  1341   1371                   }
  1342   1372   
  1343   1373                   #
  1344         -                # NOTE: The patch level from the line is greater, we are
  1345         -                #       out-of-date.
  1346         -                #
  1347         -                return [list [appendArgs "newer build " $patchLevel \
  1348         -                    " is available as of " $dateTime] [list $baseUri \
  1349         -                    $patchLevel] [list $notes]]
  1350         -              } elseif {$compare < 0} then {
         1374  +                # NOTE: The engine patch level from the line is greater,
         1375  +                #       we are out-of-date.  Return the result of our
         1376  +                #       checking now.
         1377  +                #
         1378  +                if {$checkBuild} then {
         1379  +                  return [list [appendArgs "newer build " $patchLevel \
         1380  +                      " is available as of " $dateTime] [list $baseUri \
         1381  +                      $patchLevel] [list $notes]]
         1382  +                }
         1383  +
         1384  +                #
         1385  +                # NOTE: The script patch level from the line matches the
         1386  +                #       current engine patch level exactly, this script
         1387  +                #       should be evaluated if it can be authenticated.
         1388  +                #
         1389  +                if {$checkScript} then {
         1390  +                  #
         1391  +                  # NOTE: First, set the default channel for update script
         1392  +                  #       status messages.  If the test channel has been
         1393  +                  #       set (i.e. by the test suite), it will be used
         1394  +                  #       instead.
         1395  +                  #
         1396  +                  if {![info exists channel]} then {
         1397  +                    set channel [expr {[info exists ::test_channel] ? \
         1398  +                        $::test_channel : "stdout"}]
         1399  +                  }
         1400  +
         1401  +                  #
         1402  +                  # NOTE: Next, verify the script has a valid base URI.
         1403  +                  #       For update scripts, this must be the location
         1404  +                  #       where the update script data can be downloaded.
         1405  +                  #
         1406  +                  if {[string length $baseUri] == 0} then {
         1407  +                    tqputs $channel [appendArgs \
         1408  +                        "---- invalid baseUri value for update script line: " \
         1409  +                        $line \"\n]
         1410  +
         1411  +                    continue
         1412  +                  }
         1413  +
         1414  +                  #
         1415  +                  # NOTE: Next, grab the md5 field and see if it looks valid.
         1416  +                  #       Below, the value of this field will be compared to
         1417  +                  #       that of the actual MD5 hash of the downloaded script
         1418  +                  #       data.
         1419  +                  #
         1420  +                  set lineMd5 [lindex $fields 7]
         1421  +
         1422  +                  if {[string length $lineMd5] == 0} then {
         1423  +                    tqputs $channel [appendArgs \
         1424  +                        "---- invalid md5 value for update script line: " \
         1425  +                        $line \"\n]
         1426  +
         1427  +                    continue
         1428  +                  }
         1429  +
         1430  +                  #
         1431  +                  # NOTE: Next, grab the sha1 field and see if it looks valid.
         1432  +                  #       Below, the value of this field will be compared to
         1433  +                  #       that of the actual SHA1 hash of the downloaded script
         1434  +                  #       data.
         1435  +                  #
         1436  +                  set lineSha1 [lindex $fields 8]
         1437  +
         1438  +                  if {[string length $lineSha1] == 0} then {
         1439  +                    tqputs $channel [appendArgs \
         1440  +                        "---- invalid sha1 value for update script line: " \
         1441  +                        $line \"\n]
         1442  +
         1443  +                    continue
         1444  +                  }
         1445  +
         1446  +                  #
         1447  +                  # NOTE: Next, grab the sha512 field and see if it looks
         1448  +                  #       valid.  Below, the value of this field will be
         1449  +                  #       compared to that of the actual SHA512 hash of the
         1450  +                  #       downloaded script data.
         1451  +                  #
         1452  +                  set lineSha512 [lindex $fields 9]
         1453  +
         1454  +                  if {[string length $lineSha512] == 0} then {
         1455  +                    tqputs $channel [appendArgs \
         1456  +                        "---- invalid sha512 value for update script line: " \
         1457  +                        $line \"\n]
         1458  +
         1459  +                    continue
         1460  +                  }
         1461  +
         1462  +                  #
         1463  +                  # NOTE: Next, show the extra information associated with
         1464  +                  #       this update script, if any.
         1465  +                  #
         1466  +                  tqputs $channel [appendArgs \
         1467  +                      "---- fetching update script from \"" $baseUri "\" (" \
         1468  +                      $dateTime ") with notes:\n"]
         1469  +
         1470  +                  set trimNotes [string trim $notes]
         1471  +
         1472  +                  tqputs $channel [appendArgs \
         1473  +                      [expr {[string length $trimNotes] > 0 ? $trimNotes : \
         1474  +                      "<none>"}] "\n---- end of update script notes\n"]
         1475  +
         1476  +                  #
         1477  +                  # NOTE: Next, attempt to fetch the update script data.
         1478  +                  #
         1479  +                  set code [catch {getUpdateScriptData $baseUri} result]
         1480  +
         1481  +                  if {$code == 0} then {
         1482  +                    #
         1483  +                    # NOTE: Success, set the script data from the result.
         1484  +                    #
         1485  +                    set scriptData $result
         1486  +                  } else {
         1487  +                    #
         1488  +                    # NOTE: Failure, report the error message to the log.
         1489  +                    #
         1490  +                    tqputs $channel [appendArgs \
         1491  +                        "---- failed to fetch update script: " $result \n]
         1492  +
         1493  +                    continue
         1494  +                  }
         1495  +
         1496  +                  #
         1497  +                  # NOTE: Next, verify that the md5, sha1, and sha512
         1498  +                  #       hashes of the raw script data match what was
         1499  +                  #       specified in the md5, sha1, and sha512 fields.
         1500  +                  #
         1501  +                  set scriptMd5 [hash normal md5 $scriptData]
         1502  +
         1503  +                  if {![string equal -nocase $lineMd5 $scriptMd5]} then {
         1504  +                    tqputs $channel [appendArgs \
         1505  +                        "---- wrong md5 value \"" $scriptMd5 \
         1506  +                        "\" for update script line: " $line \"\n]
         1507  +
         1508  +                    continue
         1509  +                  }
         1510  +
         1511  +                  set scriptSha1 [hash normal sha1 $scriptData]
         1512  +
         1513  +                  if {![string equal -nocase $lineSha1 $scriptSha1]} then {
         1514  +                    tqputs $channel [appendArgs \
         1515  +                        "---- wrong sha1 value \"" $scriptSha1 \
         1516  +                        "\" for update script line: " $line \"\n]
         1517  +
         1518  +                    continue
         1519  +                  }
         1520  +
         1521  +                  set scriptSha512 [hash normal sha512 $scriptData]
         1522  +
         1523  +                  if {![string equal -nocase $lineSha512 $scriptSha512]} then {
         1524  +                    tqputs $channel [appendArgs \
         1525  +                        "---- wrong sha512 value \"" $scriptSha512 \
         1526  +                        "\" for update script line: " $line \"\n]
         1527  +
         1528  +                    continue
         1529  +                  }
         1530  +
         1531  +                  #
         1532  +                  # NOTE: Finally, everything looks good.  Therefore, just
         1533  +                  #       evaluate the update script and print the result.
         1534  +                  #
         1535  +                  tqputs $channel [appendArgs \
         1536  +                      "---- evaluating update script from \"" $baseUri \
         1537  +                      \"...\n]
         1538  +
         1539  +                  #
         1540  +                  # NOTE: Reset the variables that will be used to contain
         1541  +                  #       the result of the update script.
         1542  +                  #
         1543  +                  set code 0; set result ""
         1544  +
         1545  +                  #
         1546  +                  # NOTE: Manually override file name to be returned by
         1547  +                  #       [info script] to refer back to the originally
         1548  +                  #       read script base URI.
         1549  +                  #
         1550  +                  object invoke -flags +NonPublic Interpreter.GetActive \
         1551  +                      PushScriptLocation $baseUri true
         1552  +
         1553  +                  try {
         1554  +                    #
         1555  +                    # NOTE: Evaluate the update script in the context of
         1556  +                    #       the caller.
         1557  +                    #
         1558  +                    set code [catch {uplevel 1 $scriptData} result]
         1559  +                  } finally {
         1560  +                    #
         1561  +                    # NOTE: Reset manual override of the script file name
         1562  +                    #       to be returned by [info script].
         1563  +                    #
         1564  +                    object invoke -flags +NonPublic Interpreter.GetActive \
         1565  +                        PopScriptLocation true
         1566  +                  }
         1567  +
         1568  +                  host result $code $result; incr scriptCount
         1569  +                  tqputs $channel "\n---- end of update script results\n"
         1570  +                }
         1571  +              } elseif {$checkBuild && $compare < 0} then {
  1351   1572                   #
  1352   1573                   # NOTE: The patch level from the line is less, we are more
  1353   1574                   #       up-to-date than the latest version?
  1354   1575                   #
  1355   1576                   return [list [appendArgs "running build " $enginePatchLevel \
  1356   1577                       " is newer than the latest build " $patchLevel]]
  1357         -              } else {
         1578  +              } elseif {$checkBuild} then {
  1358   1579                   #
  1359   1580                   # NOTE: The patch levels are equal, we are up-to-date.
  1360   1581                   #
  1361   1582                   return [list "running build is the latest"]
  1362   1583                 }
  1363   1584               }
  1364   1585             }
  1365   1586           }
  1366   1587         }
  1367   1588   
  1368         -      return [list "cannot determine if running build is the latest"]
         1589  +      #
         1590  +      # NOTE: Figure out what the final result should be.  If we get
         1591  +      #       to this point when checking for a new build, something
         1592  +      #       must have gone awry.  Otherwise, report the number of
         1593  +      #       update scripts that were successfully processed.
         1594  +      #
         1595  +      if {$wantScripts} then {
         1596  +        if {$scriptCount > 0} then {
         1597  +          return [list [appendArgs \
         1598  +              "processed " $scriptCount " update scripts"]]
         1599  +        } else {
         1600  +          return [list "no update scripts were processed"]
         1601  +        }
         1602  +      } else {
         1603  +        return [list "cannot determine if running build is the latest"]
         1604  +      }
  1369   1605       }
  1370   1606   
  1371   1607       proc getReturnType { object member } {
  1372   1608         if {[string length $object] == 0 || [string length $member] == 0} then {
  1373   1609           return ""
  1374   1610         }
  1375   1611   

Changes to Externals/Eagle/lib/Eagle1.0/test.eagle.

    76     76         if {[string length $string] > 0} then {
    77     77           appendSharedLogFile $fileName $string
    78     78         }
    79     79       }
    80     80     }
    81     81   
    82     82     proc getSoftwareRegistryKey { wow64 } {
    83         -    if {$wow64 && [info exists ::tcl_platform(machine)] && \
    84         -        $::tcl_platform(machine) eq "amd64"} then {
           83  +    if {$wow64 && [info exists ::tcl_platform(machine)] && [lsearch -exact \
           84  +        [list ia64 amd64] $::tcl_platform(machine)] != -1} then {
    85     85         #
    86     86         # NOTE: Return the WoW64 registry key name because we are running on a
    87     87         #       64-bit operating system and the caller specifically requested
    88     88         #       the WoW64 registry key name.
    89     89         #
    90     90         return Software\\Wow6432Node
    91     91       } else {
................................................................................
   835    835   
   836    836       if {[llength $options] > 0} then {eval lappend command $options}
   837    837   
   838    838       lappend command -- $commandName
   839    839   
   840    840       if {[llength $args] > 0} then {eval lappend command $args}
   841    841   
   842         -    tputs $::test_channel [appendArgs "---- running command: " $command \n]
          842  +    if {[info exists ::no(exec)]} then {
          843  +      tputs $::test_channel [appendArgs "---- skipping command: " $command \n]
   843    844   
   844         -    return [uplevel 1 $command]
          845  +      set procName [lindex [info level [info level]] 0]
          846  +      error "test use of \[$procName\] has been disabled"
          847  +    } else {
          848  +      tputs $::test_channel [appendArgs "---- running command: " $command \n]
          849  +
          850  +      return [uplevel 1 $command]
          851  +    }
   845    852     }
   846    853   
   847    854     proc testClrExec { commandName options args } {
   848    855       set command [list exec]
   849    856   
   850    857       if {[llength $options] > 0} then {eval lappend command $options}
   851    858   
................................................................................
   859    866             [appendArgs \" [file nativename $commandName] \"]
   860    867       } else {
   861    868         lappend command $commandName
   862    869       }
   863    870   
   864    871       if {[llength $args] > 0} then {eval lappend command $args}
   865    872   
   866         -    tputs $::test_channel [appendArgs "---- running command: " $command \n]
          873  +    if {[info exists ::no(exec)]} then {
          874  +      tputs $::test_channel [appendArgs "---- skipping command: " $command \n]
   867    875   
   868         -    return [uplevel 1 $command]
          876  +      set procName [lindex [info level [info level]] 0]
          877  +      error "test use of \[$procName\] has been disabled"
          878  +    } else {
          879  +      tputs $::test_channel [appendArgs "---- running command: " $command \n]
          880  +
          881  +      return [uplevel 1 $command]
          882  +    }
   869    883     }
   870    884   
   871    885     proc execTestShell { options args } {
   872         -    tputs $::test_channel [appendArgs \
   873         -        "---- running nested shell: exec " \
   874         -        [string trim [appendArgs $options " " -- " \"" \
   875         -        [info nameofexecutable] "\" " $args]] \n]
          886  +    if {[info exists ::no(exec)]} then {
          887  +      tputs $::test_channel [appendArgs \
          888  +          "---- skipping nested shell: exec " [string trim [appendArgs \
          889  +          $options " " -- " \"" [info nameofexecutable] "\" " $args]] \n]
   876    890   
   877         -    return [uplevel 1 execShell [list $options] $args]
          891  +      set procName [lindex [info level [info level]] 0]
          892  +      error "test use of \[$procName\] has been disabled"
          893  +    } else {
          894  +      tputs $::test_channel [appendArgs \
          895  +          "---- running nested shell: exec " [string trim [appendArgs \
          896  +          $options " " -- " \"" [info nameofexecutable] "\" " $args]] \n]
          897  +
          898  +      return [uplevel 1 execShell [list $options] $args]
          899  +    }
   878    900     }
   879    901   
   880    902     proc isRandomOrder {} {
   881    903       return [expr {[info exists ::test_random_order] && \
   882    904                     [string is boolean -strict $::test_random_order] && \
   883    905                     $::test_random_order}]
   884    906     }
................................................................................
  2161   2183             # NOTE: Delete the temporary file we used to query the machine
  2162   2184             #       type for the native Tcl shell.
  2163   2185             #
  2164   2186             catch {file delete $fileName}
  2165   2187           }
  2166   2188         }
  2167   2189       }
         2190  +
         2191  +    proc getTclVersionForTclShell {} {
         2192  +      return [testExecTclScript {
         2193  +        puts -nonewline stdout [info tclversion]
         2194  +      }]
         2195  +    }
  2168   2196   
  2169   2197       proc getCommandsForTclShell {} {
  2170   2198         return [testExecTclScript {
  2171   2199           puts -nonewline stdout [info commands]
  2172   2200         }]
  2173   2201       }
  2174   2202   
  2175   2203       proc getMachineForTclShell {} {
  2176   2204         return [testExecTclScript {
  2177   2205           puts -nonewline stdout $tcl_platform(machine)
  2178   2206         }]
  2179   2207       }
  2180   2208   
  2181         -    proc getTkVersion {} {
         2209  +    proc getTkVersionForTclShell {} {
  2182   2210         return [testExecTclScript {
  2183   2211           puts -nonewline stdout [package require Tk]; exit
  2184   2212         }]
  2185   2213       }
  2186   2214   
  2187   2215       proc getGarudaDll {} {
  2188   2216         #
................................................................................
  2261   2289   
  2262   2290         object unimport -importpattern System.Windows.Forms.Design
  2263   2291         object unimport -importpattern System.Windows.Forms.Layout
  2264   2292         object unimport -importpattern System.Windows.Forms.PropertyGridInternal
  2265   2293         object unimport -importpattern System.Windows.Forms.VisualStyles
  2266   2294       }
  2267   2295   
         2296  +    proc getTestLibraryDirectory {} {
         2297  +      #
         2298  +      # NOTE: First, query the location of the script library.
         2299  +      #
         2300  +      set result [info library]
         2301  +
         2302  +      #
         2303  +      # NOTE: Next, If the script library is embedded within the core
         2304  +      #       library itself (i.e. the script library location refers
         2305  +      #       to a file, not a directory), strip off the file name.
         2306  +      #
         2307  +      if {[file exists $result] && [file isfile $result]} then {
         2308  +        set result [file dirname $result]
         2309  +      }
         2310  +
         2311  +      #
         2312  +      # NOTE: Finally, return the resulting script library directory.
         2313  +      #
         2314  +      return $result
         2315  +    }
         2316  +
  2268   2317       #
  2269   2318       # NOTE: Setup the test path relative to the library path.
  2270   2319       #
  2271   2320       if {![interp issafe] && ![info exists ::test_path]} then {
  2272   2321         #
  2273         -      # NOTE: Try the source release directory structure.
         2322  +      # NOTE: Try the source release directory structure.  For this case,
         2323  +      #       the final test path would be:
         2324  +      #
         2325  +      #           $library/../../Library/Tests
  2274   2326         #
  2275   2327         set ::test_path [file join [file normalize [file dirname \
  2276         -          [file dirname [info library]]]] Library Tests]
         2328  +          [file dirname [getTestLibraryDirectory]]]] Library Tests]
  2277   2329   
  2278   2330         if {![file exists $::test_path] || \
  2279   2331             ![file isdirectory $::test_path]} then {
  2280   2332           #
  2281   2333           # NOTE: Try the source release directory structure again; this time,
  2282         -        #       assume only the embedded script library was used.
         2334  +        #       assume only the embedded script library was used.  For this
         2335  +        #       case, the final test path would be:
         2336  +        #
         2337  +        #           $base/Library/Tests
  2283   2338           #
  2284   2339           set ::test_path [file join [info base] Library Tests]
  2285   2340         }
  2286   2341   
  2287   2342         if {![file exists $::test_path] || \
  2288   2343             ![file isdirectory $::test_path]} then {
  2289   2344           #
  2290         -        # NOTE: Try for the test package directory.
         2345  +        # NOTE: Try for the test package directory.  For this case, the final
         2346  +        #       test path would be:
         2347  +        #
         2348  +        #           $script/../Test1.0
  2291   2349           #
  2292   2350           set ::test_path [file join [file normalize [file dirname \
  2293   2351               [file dirname [info script]]]] [appendArgs Test \
  2294   2352               [info engine Version]]]
  2295   2353         }
  2296   2354   
  2297   2355         if {![file exists $::test_path] || \
  2298   2356             ![file isdirectory $::test_path]} then {
  2299   2357           #
  2300   2358           # NOTE: Try for the test package directory again; this time, use the
  2301   2359           #       base path and assume the source release directory structure.
         2360  +        #       For this case, the final test path would be:
         2361  +        #
         2362  +        #           $base/lib/Test1.0
  2302   2363           #
  2303   2364           set ::test_path [file join [info base] lib [appendArgs Test \
  2304   2365               [info engine Version]]]
  2305   2366         }
  2306   2367   
  2307   2368         if {![file exists $::test_path] || \
  2308   2369             ![file isdirectory $::test_path]} then {
  2309   2370           #
  2310   2371           # NOTE: Try for the test package directory again; this time, use the
  2311         -        #       base path.
         2372  +        #       base path.  For this case, the final test path would be:
         2373  +        #
         2374  +        #           $base/Test1.0
  2312   2375           #
  2313   2376           set ::test_path [file join [info base] [appendArgs Test \
  2314   2377               [info engine Version]]]
  2315   2378         }
  2316   2379   
  2317   2380         if {![file exists $::test_path] || \
  2318   2381             ![file isdirectory $::test_path]} then {
  2319   2382           #
  2320   2383           # NOTE: This must be a binary release, no "Library" directory then.
  2321   2384           #       Also, binary releases have an upper-case "Tests" directory
  2322   2385           #       name that originates from the "update.bat" tool.  This must
  2323         -        #       match the casing used in "update.bat".
         2386  +        #       match the casing used in "update.bat".  For this case, the
         2387  +        #       final test path would be:
         2388  +        #
         2389  +        #           $library/../../Tests
  2324   2390           #
  2325   2391           set ::test_path [file join [file normalize [file dirname \
  2326         -            [file dirname [info library]]]] Tests]
         2392  +            [file dirname [getTestLibraryDirectory]]]] Tests]
  2327   2393         }
  2328   2394   
  2329   2395         if {![file exists $::test_path] || \
  2330   2396             ![file isdirectory $::test_path]} then {
  2331   2397           #
  2332   2398           # NOTE: Fallback to using the base directory and checking for a
  2333         -        #       "Tests" directory beneath it.
         2399  +        #       "Tests" directory beneath it.  For this case, the final
         2400  +        #       test path would be:
         2401  +        #
         2402  +        #           $base/Tests
  2334   2403           #
  2335   2404           set ::test_path [file join [info base] Tests]
  2336   2405         }
  2337   2406       }
  2338   2407   
  2339   2408       #
  2340   2409       # NOTE: Fake having the tcltest package unless we are prevented.

Changes to Externals/Eagle/lib/Test1.0/constraints.eagle.

   205    205         }
   206    206       }
   207    207   
   208    208       tputs $channel no\n
   209    209     }
   210    210   
   211    211     proc checkForTclOptions { channel } {
   212         -    tputs $channel "---- checking for Tcl options..."
          212  +    tputs $channel "---- checking for Tcl options... "
   213    213   
   214    214       if {![isEagle]} then {
   215    215         set result [list]
   216    216   
   217    217         #
   218    218         # NOTE: This test constraint is needed by test "benchmark-1.22".
   219    219         #
................................................................................
   649    649         addConstraint [appendArgs command. $name]
   650    650   
   651    651         tputs $channel yes\n
   652    652       } else {
   653    653         tputs $channel no\n
   654    654       }
   655    655     }
          656  +
          657  +  proc checkForTestExec { channel } {
          658  +    tputs $channel "---- checking for test use of \"exec\" command... "
          659  +
          660  +    if {![info exists ::no(testExec)]} then {
          661  +      addConstraint testExec
          662  +
          663  +      tputs $channel yes\n
          664  +    } else {
          665  +      tputs $channel no\n
          666  +    }
          667  +  }
   656    668   
   657    669     proc checkForTestMachine { channel } {
   658    670       tputs $channel "---- checking for test machine... "
   659    671   
   660    672       if {[info exists ::test_machine] && \
   661    673           [string length $::test_machine] > 0} then {
   662    674         addConstraint [appendArgs machine. $::test_machine]
................................................................................
   950    962       } else {
   951    963         tputs $channel no\n
   952    964       }
   953    965     }
   954    966   
   955    967     proc checkForTiming {
   956    968             channel threshold {constraint ""} {tries 1} {delay 1000}
   957         -          {asynchronous false} } {
          969  +          {average false} {asynchronous false} } {
   958    970       tputs $channel [appendArgs \
   959    971           "---- checking for precision timing (threshold of " $threshold \
   960         -        " milliseconds, delay of " $delay " milliseconds)... "]
          972  +        " milliseconds" [expr {$average ? " average" : ""}] ", delay of " \
          973  +        $delay " milliseconds)... "]
   961    974   
   962    975       #
   963    976       # HACK: Sometimes the first try takes quite a bit longer than subsequent
   964    977       #       tries.  We attempt to bypass this problem by retrying a set number
   965    978       #       of times (which can be overridden by the caller) before giving up.
   966    979       #
   967         -    set try 0
          980  +    set total 0
   968    981       set difference unknown
   969    982   
   970         -    for {} {$try < $tries} {incr try} {
          983  +    for {set try 0} {$try < $tries} {incr try} {
   971    984         #
   972    985         # NOTE: Create a script that will set the final clicks value.  This must
   973    986         #       use a global variable due to the nature of [after].
   974    987         #
   975    988         set stopScript {
   976    989           set ::stopClicks [expr {[clock clicks -milliseconds] & 0x7fffffff}]
   977    990         }
................................................................................
   996   1009   
   997   1010         #
   998   1011         # NOTE: Calculate the difference between the actual and expected
   999   1012         #       number of milliseconds.
  1000   1013         #
  1001   1014         set difference [expr {abs($stop - $start - $delay)}]
  1002   1015   
         1016  +      #
         1017  +      # NOTE: Keep track of the total number of milliseconds elapsed for
         1018  +      #       all iterations of this loop.
         1019  +      #
         1020  +      incr total $difference
         1021  +
         1022  +      #
         1023  +      # NOTE: If we are using the average difference, handle that now.
         1024  +      #
         1025  +      if {$average && $tries > 1} then {
         1026  +        set difference [expr {$total / $tries}]
         1027  +      }
         1028  +
  1003   1029         #
  1004   1030         # NOTE: Are we within the threshold specified by the caller?
  1005   1031         #
  1006   1032         if {$difference >= 0 && $difference <= $threshold} then {
  1007   1033           #
  1008   1034           # NOTE: We appear to be capable of fairly precise timing.
  1009   1035           #
  1010         -        if {[string length $constraint] > 0} then {
  1011         -          addConstraint $constraint
  1012         -        } else {
  1013         -          addConstraint timing
         1036  +        if {[string length $constraint] == 0} then {
         1037  +          set constraint timing
  1014   1038           }
  1015   1039   
  1016         -        tputs $channel [appendArgs "yes (0 <= " $difference " <= " \
  1017         -            $threshold " milliseconds, tried " [expr {$try + 1}] \
  1018         -            " " [expr {$try + 1 > 1 ? "times" : "time"}] ")\n"]
         1040  +        addConstraint $constraint
         1041  +
         1042  +        tputs $channel [appendArgs \
         1043  +            "yes (0 <= " $difference " <= " $threshold " milliseconds" \
         1044  +            [expr {$average ? " average" : ""}] ", tried " [expr {$try + 1}] \
         1045  +            " out of " $tries " " [expr {$tries > 1 ? "times" : "time"}] \
         1046  +            ", \"" $constraint "\")\n"]
  1019   1047   
  1020   1048           #
  1021   1049           # NOTE: We are done here, return now.
  1022   1050           #
  1023   1051           return
  1024   1052         }
  1025   1053       }
  1026   1054   
  1027         -    tputs $channel [appendArgs "no (0 <= " $difference " > " \
  1028         -        $threshold " milliseconds, tried " $try " " \
  1029         -        [expr {$try > 1 ? "times" : "time"}] ")\n"]
         1055  +    tputs $channel [appendArgs \
         1056  +        "no (0 <= " $difference " > " $threshold " milliseconds" \
         1057  +        [expr {$average ? " average" : ""}] ", tried " $try " out of " \
         1058  +        $tries " " [expr {$tries > 1 ? "times" : "time"}] ")\n"]
  1030   1059     }
  1031   1060   
  1032   1061     proc checkForPerformance { channel } {
  1033   1062       tputs $channel "---- checking for performance testing... "
  1034   1063   
  1035   1064       #
  1036   1065       # NOTE: Are we allowed to do performance testing?
................................................................................
  1356   1385   
  1357   1386           tputs $channel [appendArgs "yes (" \
  1358   1387               [object invoke $certificate Subject] ")\n"]
  1359   1388         } else {
  1360   1389           tputs $channel no\n
  1361   1390         }
  1362   1391       }
         1392  +
         1393  +    proc checkForCompileCSharp { channel } {
         1394  +      tputs $channel "---- checking for test use of C# compiler... "
         1395  +
         1396  +      if {![info exists ::no(compileCSharp)]} then {
         1397  +        addConstraint compileCSharp
         1398  +
         1399  +        tputs $channel yes\n
         1400  +      } else {
         1401  +        tputs $channel no\n
         1402  +      }
         1403  +    }
  1363   1404   
  1364   1405       proc checkForAdministrator { channel } {
  1365   1406         tputs $channel "---- checking for administrator... "
  1366   1407   
  1367   1408         if {[isAdministrator]} then {
  1368   1409           addConstraint administrator; # running as full admin.
  1369   1410   
................................................................................
  2041   2082         } else {
  2042   2083           tputs $channel no\n
  2043   2084         }
  2044   2085       }
  2045   2086   
  2046   2087       proc checkForTclShell { channel } {
  2047   2088         #
  2048         -      # HACK: We do not care about the machine type returned from this
  2049         -      #       procedure, we only care if it returns "error" because that
  2050         -      #       would indicate an error was caught during [exec] (i.e. the
  2051         -      #       native Tcl shell could not be executed).
         2089  +      # HACK: If this returns "error" that normally indicates an error was
         2090  +      #       caught during [exec] (i.e. the native Tcl shell could not be
         2091  +      #       executed).
  2052   2092         #
  2053         -      if {[catch {getMachineForTclShell} result] == 0 && \
         2093  +      set prefix "---- checking for Tcl shell version... "
         2094  +
         2095  +      if {[catch {getTclVersionForTclShell} result] == 0 && \
  2054   2096             $result ne "error"} then {
  2055   2097           #
  2056   2098           # NOTE: Yes, a native Tcl shell appears to be available.
  2057   2099           #
  2058   2100           addConstraint tclShell
  2059   2101   
  2060         -        tputs $channel [appendArgs "---- checking for Tcl shell... yes (" \
  2061         -            $result ")\n"]
         2102  +        #
         2103  +        # NOTE: Now, add the version specific test constraint.
         2104  +        #
         2105  +        addConstraint [appendArgs tclShell [string map [list . ""] $result]]
         2106  +
         2107  +        tputs $channel [appendArgs $prefix "yes (" $result ")\n"]
  2062   2108         } else {
  2063         -        tputs $channel "---- checking for Tcl shell... no\n"
         2109  +        tputs $channel [appendArgs $prefix no\n]
  2064   2110         }
  2065   2111       }
  2066   2112   
  2067   2113       proc checkForTkPackage { channel } {
  2068   2114         #
  2069   2115         # HACK: We do not care about the Tk version returned from this
  2070   2116         #       procedure, we only care if it returns "error" because that
  2071   2117         #       would indicate an error was caught during [exec] (i.e. the
  2072   2118         #       native Tcl shell could not be executed).
  2073   2119         #
  2074         -      if {[catch {getTkVersion} result] == 0 && \
         2120  +      set prefix "---- checking for Tk package version... "
         2121  +
         2122  +      if {[catch {getTkVersionForTclShell} result] == 0 && \
  2075   2123             $result ne "error"} then {
  2076   2124           #
  2077   2125           # NOTE: Yes, a native Tk package appears to be available.
  2078   2126           #
  2079   2127           addConstraint tkPackage
  2080   2128   
  2081         -        tputs $channel [appendArgs "---- checking for Tk package... yes (" \
  2082         -            $result ")\n"]
         2129  +        tputs $channel [appendArgs $prefix "yes (" $result ")\n"]
  2083   2130         } else {
  2084         -        tputs $channel "---- checking for Tk package... no\n"
         2131  +        tputs $channel [appendArgs $prefix no\n]
  2085   2132         }
  2086   2133       }
  2087   2134   
  2088   2135       proc checkForPowerShell { channel } {
  2089   2136         tputs $channel "---- checking for PowerShell... "
  2090   2137   
  2091   2138         #
................................................................................
  2563   2610       #
  2564   2611       exportAndImportPackageCommands [namespace current] [list \
  2565   2612           getKnownMonoVersions checkForPlatform checkForWindowsVersion \
  2566   2613           checkForScriptLibrary checkForVariable checkForTclOptions \
  2567   2614           checkForWindowsCommandProcessor checkForFossil checkForEagle \
  2568   2615           checkForSymbols checkForLogFile checkForGaruda checkForShell \
  2569   2616           checkForDebug checkForTk checkForVersion checkForCommand \
  2570         -        checkForTestMachine checkForTestPlatform checkForTestConfiguration \
  2571         -        checkForTestSuffix checkForFile checkForPathFile checkForNativeCode \
  2572         -        checkForTip127 checkForTip194 checkForTip241 checkForTip285 \
  2573         -        checkForTip405 checkForTip426 checkForTiming checkForPerformance \
  2574         -        checkForStackIntensive checkForInteractive checkForInteractiveCommand \
         2617  +        checkForTestExec checkForTestMachine checkForTestPlatform \
         2618  +        checkForTestConfiguration checkForTestSuffix checkForFile \
         2619  +        checkForPathFile checkForNativeCode checkForTip127 checkForTip194 \
         2620  +        checkForTip241 checkForTip285 checkForTip405 checkForTip426 \
         2621  +        checkForTiming checkForPerformance checkForStackIntensive \
         2622  +        checkForInteractive checkForInteractiveCommand \
  2575   2623           checkForUserInteraction checkForNetwork checkForCompileOption] false \
  2576   2624           false
  2577   2625   
  2578   2626       ###########################################################################
  2579   2627       ############################## END Tcl ONLY ###############################
  2580   2628       ###########################################################################
  2581   2629     }

Changes to Externals/Eagle/lib/Test1.0/prologue.eagle.

    87     87     #############################################################################
    88     88   
    89     89     #
    90     90     # NOTE: Set the local root directory of the source checkout (i.e. of Eagle
    91     91     #       or whatever project the Eagle binaries are being used by) using a
    92     92     #       Fossil binary in the PATH, if available.
    93     93     #
    94         -  if {![info exists root_path] && ![info exists no(fossil)]} then {
           94  +  if {![info exists root_path] && \
           95  +      ![info exists no(exec)] && ![info exists no(fossil)]} then {
    95     96       set pattern {^local-root:\s+(.*?)\s+$}
    96     97   
    97     98       if {[catch {set exec [exec -- fossil info]}] || \
    98     99           [regexp -line -- $pattern $exec dummy directory] == 0} then {
    99    100         #
   100    101         # NOTE: We could not query local root directory of the source checkout
   101    102         #       from Fossil; therefore, attempt to make an educated guess.  This
................................................................................
   798    799       }
   799    800   
   800    801       #
   801    802       # NOTE: Has machine detection support been disabled?
   802    803       #
   803    804       if {![info exists no(machine)]} then {
   804    805         checkForMachine $test_channel 32 intel; # (i.e. x86)
          806  +      checkForMachine $test_channel 32 arm;   # (i.e. arm)
          807  +      checkForMachine $test_channel 64 ia64;  # (i.e. ia64)
   805    808         checkForMachine $test_channel 64 amd64; # (i.e. x64)
   806    809       }
   807    810   
   808    811       #
   809    812       # NOTE: Has culture detection support been disabled?
   810    813       #
   811    814       if {![info exists no(culture)]} then {
................................................................................
   947    950       if {![info exists no(refCount)]} then {
   948    951         #
   949    952         # NOTE: For tests "excel-*", "object-2.*", "object-7.1", "object-8.*",
   950    953         #       and "object-98.*".
   951    954         #
   952    955         checkForReferenceCountTracking $test_channel
   953    956       }
          957  +
          958  +    #
          959  +    # NOTE: Has testing using the C# compiler been disabled?
          960  +    #
          961  +    if {![info exists no(checkForCompileCSharp)]} then {
          962  +      checkForCompileCSharp $test_channel
          963  +    }
   954    964   
   955    965       #
   956    966       # NOTE: Has compile/runtime option testing support been disabled?
   957    967       #
   958    968       if {![info exists no(compileOptions)]} then {
   959    969         #
   960    970         # NOTE: Has callback queue support been enabled (at compile-time)?
................................................................................
  1606   1616           # NOTE: For test "object-2.8".
  1607   1617           #
  1608   1618           checkForObjectMember $test_channel Eagle._Tests.Default+Disposable \
  1609   1619               *ToString* Eagle._Tests.Default.Disposable.ToString
  1610   1620         }
  1611   1621       }
  1612   1622   
         1623  +    #
         1624  +    # NOTE: Has MSBuild testing support been disabled?
         1625  +    #
         1626  +    if {![info exists no(msBuild)]} then {
         1627  +      #
         1628  +      # NOTE: For test "object-4.13".
         1629  +      #
         1630  +      checkForAssembly $test_channel Microsoft.Build.Framework
         1631  +
         1632  +      #
         1633  +      # NOTE: For test "object-6.1".
         1634  +      #
         1635  +      checkForAssembly $test_channel Microsoft.Build.Engine
         1636  +    }
         1637  +
  1613   1638       #
  1614   1639       # NOTE: Has Excel testing support been disabled?
  1615   1640       #
  1616   1641       if {![info exists no(excel)]} then {
  1617   1642         #
  1618   1643         # NOTE: For tests "excel-*.*".
  1619   1644         #
................................................................................
  1838   1863   
  1839   1864     #############################################################################
  1840   1865     ####################### BEGIN Tcl & Eagle Constraints #######################
  1841   1866     #############################################################################
  1842   1867   
  1843   1868     tputs $test_channel [appendArgs \
  1844   1869         "---- start of common (Tcl & Eagle) test constraints...\n"]
         1870  +
         1871  +  #
         1872  +  # NOTE: Has all use of [exec] for tests been disabled?
         1873  +  #
         1874  +  if {![info exists no(checkForTestExec)]} then {
         1875  +    checkForTestExec $test_channel
         1876  +  }
  1845   1877   
  1846   1878     #
  1847   1879     # NOTE: Has checking for the test machine been disabled?
  1848   1880     #
  1849   1881     if {![info exists no(testMachine)]} then {
  1850   1882       checkForTestMachine $test_channel
  1851   1883     }
................................................................................
  2217   2249     # NOTE: Has performance testing been disabled?
  2218   2250     #
  2219   2251     if {![info exists no(performance)]} then {
  2220   2252       checkForPerformance $test_channel
  2221   2253     }
  2222   2254   
  2223   2255     #
  2224         -  # NOTE: Have precise timing tests been disabled?
         2256  +  # NOTE: Have any timing related constraints been disabled?
         2257  +  #
         2258  +  # BUGBUG: In Eagle, these checks for "precision" timing are not overly
         2259  +  #         reliable.  This may be due to the semi-random nature of the
         2260  +  #         garbage collection.  More research into the precise cause of
         2261  +  #         timing issues is certainly warranted.
         2262  +  #
  2225   2263     #
  2226   2264     if {![info exists no(timing)]} then {
  2227   2265       checkForTiming $test_channel 50; # 1/20th second.
  2228   2266     }
  2229   2267   
  2230         -  #
  2231         -  # NOTE: Have very precise timing tests been disabled?
  2232         -  #
  2233   2268     if {![info exists no(preciseTiming)]} then {
  2234   2269       checkForTiming $test_channel 25 preciseTiming; # 1/40th second.
  2235   2270     }
  2236   2271   
  2237   2272     #
  2238   2273     # NOTE: Has interactive testing been disabled?
  2239   2274     #
................................................................................
  2327   2362     #
  2328   2363     if {[isEagle]} then {
  2329   2364       #
  2330   2365       # NOTE: Get the source checkout and tags (i.e. of Eagle or whatever
  2331   2366       #       project the Eagle binaries are being used by) using a Fossil
  2332   2367       #       binary in the PATH, if available.
  2333   2368       #
  2334         -    if {![info exists no(fossil)]} then {
         2369  +    if {![info exists no(exec)] && ![info exists no(fossil)]} then {
  2335   2370         if {[catch {set exec [exec -- fossil info]}] == 0} then {
  2336   2371           set pattern {^checkout:\s+(.*?)\s+$}
  2337   2372   
  2338   2373           if {[regexp -line -- $pattern $exec dummy checkout] == 0} then {
  2339   2374             #
  2340   2375             # NOTE: We could not query the source checkout from Fossil.
  2341   2376             #

Changes to Tests/backup.eagle.

   218    218       cleanupDb $fileName(2)
   219    219       cleanupDb $fileName(1) memDb
   220    220   
   221    221       freeDbConnection memSource
   222    222   
   223    223       unset -nocomplain result results errors code index memSource dataSource \
   224    224           id memDb db fileName callbackResults
   225         -  } -constraints \
   226         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} \
   227         --match regexp -result [appendArgs \
          225  +  } -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
          226  +System.Data.SQLite compileCSharp} -match regexp -result [appendArgs \
   228    227   "^Ok System#CodeDom#Compiler#CompilerResults#\\d+ \\{\\} " \
   229    228   [lindex $params(results) $i]]}
   230    229   }
   231    230   
   232    231   ###############################################################################
   233    232   
   234    233   unset -nocomplain i params pages callback

Changes to Tests/basic.eagle.

    94     94   
    95     95     list $code [expr {$code == 0 ? "" : $error}]
    96     96   } -cleanup {
    97     97     cleanupFile $fileName
    98     98   
    99     99     unset -nocomplain totalCount failureCount successCount code output \
   100    100         error fileName
   101         -} -constraints {eagle SQLite file_System.Data.SQLite.dll file_test.exe} \
   102         --result {0 {}}}
          101  +} -constraints {eagle SQLite file_System.Data.SQLite.dll file_test.exe\
          102  +testExec} -result {0 {}}}
   103    103   
   104    104   ###############################################################################
   105    105   
   106    106   runTest {test data-1.2 {unit tests from the 'testlinq' project} -setup {
   107    107     #
   108    108     # NOTE: Re-copy the reference database file used for this unit test to the
   109    109     #       build directory in case it has been changed by a previous test run.
................................................................................
   136    136   } -cleanup {
   137    137     catch {object invoke Console OutputEncoding $savedEncoding}
   138    138   
   139    139     unset -nocomplain code output error savedEncoding encoding
   140    140   } -constraints \
   141    141   {eagle monoToDo SQLite file_System.Data.SQLite.dll\
   142    142   file_System.Data.SQLite.Linq.dll file_testlinq.exe file_northwindEF.db\
   143         -file_testlinq.out} -result {0 True {}}}
          143  +file_testlinq.out testExec} -result {0 True {}}}
   144    144   
   145    145   ###############################################################################
   146    146   
   147    147   runTest {test data-1.3 {SELECT scalar/reader, CREATE, INSERT} -setup {
   148    148     setupDb [set fileName data-1.3.db]
   149    149   } -body {
   150    150     set result [list]
................................................................................
   215    215         [expr {$code eq "Ok" ? [catch {
   216    216           object invoke _Dynamic${id}.Test${id} GetReservedWords
   217    217         } result] : [set result ""]}] $result
   218    218   } -cleanup {
   219    219     cleanupDb $fileName
   220    220   
   221    221     unset -nocomplain result results errors code dataSource id db fileName
   222         -} -constraints \
   223         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} \
   224         --match regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0\
   225         -System#Data#DataTable#\d+$}}
          222  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
          223  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
          224  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 System#Data#DataTable#\d+$}}
   226    225   
   227    226   ###############################################################################
   228    227   
   229    228   runTest {test data-1.5 {GetSchema with ForeignKeys} -setup {
   230    229     setupDb [set fileName data-1.5.db]
   231    230   } -body {
   232    231     sql execute $db {
................................................................................
   302    301           set rows
   303    302         } result] : [set result ""]}] $result
   304    303   } -cleanup {
   305    304     cleanupDb $fileName
   306    305   
   307    306     unset -nocomplain result rows foreignKey foreignKeys results errors code \
   308    307         dataSource id db fileName
   309         -} -constraints \
   310         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} \
   311         --match regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0\
   312         -\{\{main FK_t1_0_0 main t1 \{FOREIGN KEY\} False False 0 x main t2 \{\} 0 \{SET\
   313         -DEFAULT\} CASCADE NONE\} \{main FK_t2_0_0 main t2 \{FOREIGN KEY\} False False 0\
   314         -x main t3 \{\} 0 \{NO ACTION\} \{NO ACTION\} NONE\}\}$}}
          308  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
          309  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
          310  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\{main FK_t1_0_0 main t1\
          311  +\{FOREIGN KEY\} False False 0 x main t2 \{\} 0 \{SET DEFAULT\} CASCADE NONE\}\
          312  +\{main FK_t2_0_0 main t2 \{FOREIGN KEY\} False False 0 x main t3 \{\} 0 \{NO\
          313  +ACTION\} \{NO ACTION\} NONE\}\}$}}
   315    314   
   316    315   ###############################################################################
   317    316   
   318    317   runTest {test data-1.6 {SQLITE_FCNTL_WIN32_AV_RETRY} -setup {
   319    318     setupDb [set fileName data-1.6.db]
   320    319   } -body {
   321    320     set id [object invoke Interpreter.GetActive NextId]
................................................................................
   405    404       }
   406    405     }
   407    406   
   408    407     cleanupDb $fileName
   409    408   
   410    409     unset -nocomplain result count interval savedCount savedInterval results \
   411    410         errors code dataSource id db fileName
   412         -} -constraints \
   413         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} \
   414         --match regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0\
   415         -True$}}
          411  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
          412  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
          413  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 True$}}
   416    414   
   417    415   ###############################################################################
   418    416   
   419    417   runTest {test data-1.7 {properly closed database file (non-query)} -setup {
   420    418     set fileName data-1.7.db
   421    419   } -body {
   422    420     set id [object invoke Interpreter.GetActive NextId]
................................................................................
   462    460           object invoke _Dynamic${id}.Test${id} Main
   463    461         } result] : [set result ""]}] $result \
   464    462         [close [open $dataSource RDONLY 0 "" -share None]]
   465    463   } -cleanup {
   466    464     cleanupDb $fileName
   467    465   
   468    466     unset -nocomplain result results errors code sql dataSource id fileName
   469         -} -constraints \
   470         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} \
   471         --match regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0\
   472         -\{\} \{\}$}}
          467  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
          468  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
          469  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\} \{\}$}}
   473    470   
   474    471   ###############################################################################
   475    472   
   476    473   runTest {test data-1.8 {properly closed database file (reader #1)} -setup {
   477    474     set fileName data-1.8.db
   478    475   } -body {
   479    476     set id [object invoke Interpreter.GetActive NextId]
................................................................................
   522    519           object invoke _Dynamic${id}.Test${id} Main
   523    520         } result] : [set result ""]}] $result \
   524    521         [close [open $dataSource RDONLY 0 "" -share None]]
   525    522   } -cleanup {
   526    523     cleanupDb $fileName
   527    524   
   528    525     unset -nocomplain result results errors code sql dataSource id fileName
   529         -} -constraints \
   530         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} \
   531         --match regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0\
   532         -\{\} \{\}$}}
          526  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
          527  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
          528  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\} \{\}$}}
   533    529   
   534    530   ###############################################################################
   535    531   
   536    532   runTest {test data-1.9 {properly closed database file (reader #2)} -setup {
   537    533     set fileName data-1.9.db
   538    534   } -body {
   539    535     set id [object invoke Interpreter.GetActive NextId]
................................................................................
   584    580           object invoke _Dynamic${id}.Test${id} Main
   585    581         } result] : [set result ""]}] $result \
   586    582         [close [open $dataSource RDONLY 0 "" -share None]]
   587    583   } -cleanup {
   588    584     cleanupDb $fileName
   589    585   
   590    586     unset -nocomplain result results errors code sql dataSource id fileName
   591         -} -constraints \
   592         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} \
   593         --match regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0\
   594         -\{\} \{\}$}}
          587  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
          588  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
          589  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\} \{\}$}}
   595    590   
   596    591   ###############################################################################
   597    592   
   598    593   runTest {test data-1.10 {Changes property} -setup {
   599    594     setupDb [set fileName data-1.10.db]
   600    595   } -body {
   601    596     set connection [getDbConnection]
................................................................................
   886    881             string kind,
   887    882             string formatString
   888    883             )
   889    884           {
   890    885             SQLiteConnectionStringBuilder builder =
   891    886                 new SQLiteConnectionStringBuilder();
   892    887   
   893         -          builder.Add("Date Source", "test.db");
          888  +          builder.Add("Data Source", "test.db");
   894    889             builder.Add("DateTimeFormat", format);
   895    890             builder.Add("DateTimeKind", kind);
   896    891             builder.Add("DateTimeFormatString", formatString);
   897    892   
   898    893             return builder.ToString();
   899    894           }
   900    895   
................................................................................
   928    923         } result] : [set result ""]}] $result \
   929    924         [expr {$code eq "Ok" ? [catch {
   930    925           object invoke _Dynamic${id}.Test${id} GetConnectionString \
   931    926               Ticks Local yyyy-MM-dd
   932    927         } result] : [set result ""]}] $result
   933    928   } -cleanup {
   934    929     unset -nocomplain result results errors code id
   935         -} -constraints \
   936         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
   937         -regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{Date\
   938         -Source=test\.db\} 0 \{Date Source=test\.db;DateTimeFormat=(?:Default|ISO8601)\}\
   939         -0 \{Date Source=test\.db;DateTimeKind=Unspecified\} 0 \{Date\
   940         -Source=test\.db;DateTimeFormat=(?:Default|ISO8601);DateTimeKind=Utc\} 0 \{Date\
          930  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
          931  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
          932  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{Data Source=test\.db\} 0\
          933  +\{Data Source=test\.db;DateTimeFormat=(?:Default|ISO8601)\} 0 \{Data\
          934  +Source=test\.db;DateTimeKind=Unspecified\} 0 \{Data\
          935  +Source=test\.db;DateTimeFormat=(?:Default|ISO8601);DateTimeKind=Utc\} 0 \{Data\
   941    936   Source=test\.db;DateTimeFormat=Ticks;DateTimeKind=Local;DateTimeFormatString=yyyy-MM-dd\}$}}
   942    937   
   943    938   ###############################################################################
   944    939   
   945    940   runTest {test data-1.16 {SQLiteConnectionStringBuilder properties} -body {
   946    941     set id [object invoke Interpreter.GetActive NextId]
   947    942   
................................................................................
  1049   1044       }
  1050   1045     }
  1051   1046   
  1052   1047     set results
  1053   1048   } -cleanup {
  1054   1049     unset -nocomplain propertyName propertyNames value key values keys result \
  1055   1050         results errors code id
  1056         -} -constraints \
  1057         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
  1058         -regexp -result {^System#CodeDom#Compiler#CompilerResults#\d+ Ok \{\} 0 \{, \} 0\
  1059         -\{3, Version=3\} 0 \{Normal, Synchronous=Normal\} 0 \{True,\
  1060         -UseUTF16Encoding=True\} 0 \{False, Pooling=False\} 0 \{True, BinaryGUID=True\}\
  1061         -0 \{test\.db, Data Source=test\.db\} 0 \{test\.db, Uri=test\.db\} 0\
  1062         -\{file:test.db, FullUri=file:test\.db\} 0 \{60, Default Timeout=60\} 0 \{False,\
  1063         -Enlist=False\} 0 \{True, FailIfMissing=True\} 0 \{False, Legacy Format=False\}\
  1064         -0 \{True, Read Only=True\} 0 \{secret, Password=secret\} 0 \{4096, Page\
  1065         -Size=4096\} 0 \{1024, Max Page Count=1024\} 0 \{8192, Cache Size=8192\} 0\
  1066         -\{UnixEpoch, DateTimeFormat=UnixEpoch\} 0 \{Utc, DateTimeKind=Utc\} 0\
  1067         -\{yyyy-MM-dd, DateTimeFormatString=yyyy-MM-dd\} 0 \{sqlite_schema,\
         1051  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
         1052  +System.Data.SQLite compileCSharp} -match regexp -result \
         1053  +{^System#CodeDom#Compiler#CompilerResults#\d+ Ok \{\} 0 \{, \} 0 \{3,\
         1054  +Version=3\} 0 \{Normal, Synchronous=Normal\} 0 \{True, UseUTF16Encoding=True\}\
         1055  +0 \{False, Pooling=False\} 0 \{True, BinaryGUID=True\} 0 \{test\.db, Data\
         1056  +Source=test\.db\} 0 \{test\.db, Uri=test\.db\} 0 \{file:test.db,\
         1057  +FullUri=file:test\.db\} 0 \{60, Default Timeout=60\} 0 \{False, Enlist=False\}\
         1058  +0 \{True, FailIfMissing=True\} 0 \{False, Legacy Format=False\} 0 \{True, Read\
         1059  +Only=True\} 0 \{secret, Password=secret\} 0 \{4096, Page Size=4096\} 0 \{1024,\
         1060  +Max Page Count=1024\} 0 \{8192, Cache Size=8192\} 0 \{UnixEpoch,\
         1061  +DateTimeFormat=UnixEpoch\} 0 \{Utc, DateTimeKind=Utc\} 0 \{yyyy-MM-dd,\
         1062  +DateTimeFormatString=yyyy-MM-dd\} 0 \{sqlite_schema,\
  1068   1063   BaseSchemaName=sqlite_schema\} 0 \{Memory, Journal Mode=Memory\} 0\
  1069   1064   \{Serializable, Default IsolationLevel=Serializable\} 0 \{False, Foreign\
  1070   1065   Keys=False\} 0 \{(?:Default|LogCallbackException),\
  1071   1066   Flags=(?:Default|LogCallbackException)\} 0 \{False, SetDefaults=False\} 0\
  1072   1067   \{False, ToFullPath=False\} 0 {736563726574, HexPassword=736563726574}$}}
  1073   1068   
  1074   1069   ###############################################################################
................................................................................
  1207   1202         [expr {$code eq "Ok" ? [catch {
  1208   1203           object invoke _Dynamic${id}.Test${id} Main
  1209   1204         } result] : [set result ""]}] $result
  1210   1205   } -cleanup {
  1211   1206     cleanupDb $fileName
  1212   1207   
  1213   1208     unset -nocomplain result results errors code sql dataSource id db fileName
  1214         -} -constraints \
  1215         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
  1216         -regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
         1209  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
         1210  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
         1211  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
  1217   1212   
  1218   1213   ###############################################################################
  1219   1214   
  1220   1215   runTest {test data-1.22 {SQLiteFunction collation exception} -setup {
  1221   1216     setupDb [set fileName data-1.22.db]
  1222   1217   } -body {
  1223   1218     sql execute $db "CREATE TABLE t1(x TEXT);"
................................................................................
  1291   1286         [expr {$code eq "Ok" ? [catch {
  1292   1287           object invoke _Dynamic${id}.Test${id} Main
  1293   1288         } result] : [set result ""]}] $result
  1294   1289   } -cleanup {
  1295   1290     cleanupDb $fileName
  1296   1291   
  1297   1292     unset -nocomplain result results errors code sql dataSource id db fileName
  1298         -} -constraints \
  1299         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
  1300         -regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 1\
         1293  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
         1294  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
         1295  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 1\
  1301   1296   \{System\.Reflection\.TargetInvocationException: Exception has been thrown by\
  1302   1297   the target of an invocation\. ---> System\.Data\.SQLite\.SQLiteException:\
  1303   1298   interrupted.*$}}
  1304   1299   
  1305   1300   ###############################################################################
  1306   1301   
  1307   1302   runTest {test data-1.23 {LINQ SQL_CONSTRAINTCOLUMNS resource} -body {
................................................................................
  2474   2469         [expr {$code eq "Ok" ? [catch {
  2475   2470           object invoke _Dynamic${id}.Test${id} DoTest false
  2476   2471         } result] : [set result ""]}] $result
  2477   2472   } -cleanup {
  2478   2473     cleanupDb $fileName
  2479   2474   
  2480   2475     unset -nocomplain result code results errors sql dataSource id fileName
  2481         -} -constraints \
  2482         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
  2483         -regexp -result [string map [list \n \r\n] {^Ok\
  2484         -System#CodeDom#Compiler#CompilerResults#\d+ \{\} 1\
  2485         -\{System\.Reflection\.TargetInvocationException: Exception has been thrown by\
  2486         -the target of an invocation\. ---> System\.Data\.SQLite\.SQLiteException: SQL\
  2487         -logic error or missing database
         2476  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
         2477  +System.Data.SQLite compileCSharp} -match regexp -result \
         2478  +[string map [list \n \r\n] {^Ok System#CodeDom#Compiler#CompilerResults#\d+\
         2479  +\{\} 1 \{System\.Reflection\.TargetInvocationException: Exception has been\
         2480  +thrown by the target of an invocation\. --->\
         2481  +System\.Data\.SQLite\.SQLiteException: SQL logic error or missing database
  2488   2482   no such function: MyRandom.*\} 0 (?:-)?\d+ 1\
  2489   2483   \{System\.Reflection\.TargetInvocationException: Exception has been thrown by\
  2490   2484   the target of an invocation\. ---> System\.Data\.SQLite\.SQLiteException: SQL\
  2491   2485   logic error or missing database
  2492   2486   no such function: MyRandom.*\}$}]}
  2493   2487   
  2494   2488   ###############################################################################

Changes to Tests/installer.eagle.

   150    150     list $code [expr {$code == 0 ? [string equal [readFile $fileName] \
   151    151         [subst -nobackslashes [readFile $testInstallVs2005LogFile]]] : $error}]
   152    152   } -cleanup {
   153    153     cleanupFile $fileName
   154    154   
   155    155     unset -nocomplain wow64 is64 code output error fileName
   156    156   } -constraints {eagle administrator buildYear.2005 visualStudio2005\
   157         -System.Data.SQLite.dll_v2.0.50727 file_Installer.exe\
          157  +System.Data.SQLite.dll_v2.0.50727 file_Installer.exe testExec\
   158    158   file_System.Data.SQLite.dll file_Installer_Test_Vs2005.log} -result {0 True}}
   159    159   
   160    160   ###############################################################################
   161    161   
   162    162   runTest {test installer-1.2 {uninstaller tool / Visual Studio 2005} -setup {
   163    163     set fileName [file join [getTemporaryPath] [file tail [string map [list \
   164    164         .log [appendArgs _ [pid] .log]] $testUninstallVs2005LogFile]]]
................................................................................
   187    187     list $code [expr {$code == 0 ? [string equal [readFile $fileName] \
   188    188         [subst -nobackslashes [readFile $testUninstallVs2005LogFile]]] : $error}]
   189    189   } -cleanup {
   190    190     cleanupFile $fileName
   191    191   
   192    192     unset -nocomplain wow64 is64 code output error fileName
   193    193   } -constraints {eagle administrator buildYear.2005 visualStudio2005\
   194         -System.Data.SQLite.dll_v2.0.50727 file_Installer.exe\
          194  +System.Data.SQLite.dll_v2.0.50727 file_Installer.exe testExec\
   195    195   file_System.Data.SQLite.dll file_Uninstaller_Test_Vs2005.log} -result {0 True}}
   196    196   
   197    197   ###############################################################################
   198    198   
   199    199   runTest {test installer-1.3 {installer tool / Visual Studio 2008} -setup {
   200    200     set fileName [file join [getTemporaryPath] [file tail [string map [list \
   201    201         .log [appendArgs _ [pid] .log]] $testInstallVs2008LogFile]]]
................................................................................
   224    224     list $code [expr {$code == 0 ? [string equal [readFile $fileName] \
   225    225         [subst -nobackslashes [readFile $testInstallVs2008LogFile]]] : $error}]
   226    226   } -cleanup {
   227    227     cleanupFile $fileName
   228    228   
   229    229     unset -nocomplain wow64 is64 code output error fileName
   230    230   } -constraints {eagle administrator buildYear.2008 visualStudio2008\
   231         -System.Data.SQLite.dll_v2.0.50727 file_Installer.exe\
          231  +System.Data.SQLite.dll_v2.0.50727 file_Installer.exe testExec\
   232    232   file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
   233    233   file_Installer_Test_Vs2008.log} -result {0 True}}
   234    234   
   235    235   ###############################################################################
   236    236   
   237    237   runTest {test installer-1.4 {uninstaller tool / Visual Studio 2008} -setup {
   238    238     set fileName [file join [getTemporaryPath] [file tail [string map [list \
................................................................................
   262    262     list $code [expr {$code == 0 ? [string equal [readFile $fileName] \
   263    263         [subst -nobackslashes [readFile $testUninstallVs2008LogFile]]] : $error}]
   264    264   } -cleanup {
   265    265     cleanupFile $fileName
   266    266   
   267    267     unset -nocomplain wow64 is64 code output error fileName
   268    268   } -constraints {eagle administrator buildYear.2008 visualStudio2008\
   269         -System.Data.SQLite.dll_v2.0.50727 file_Installer.exe\
          269  +System.Data.SQLite.dll_v2.0.50727 file_Installer.exe testExec\
   270    270   file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
   271    271   file_Uninstaller_Test_Vs2008.log} -result {0 True}}
   272    272   
   273    273   ###############################################################################
   274    274   
   275    275   runTest {test installer-1.5 {installer tool / Visual Studio 2010} -setup {
   276    276     set fileName [file join [getTemporaryPath] [file tail [string map [list \
................................................................................
   300    300     list $code [expr {$code == 0 ? [string equal [readFile $fileName] \
   301    301         [subst -nobackslashes [readFile $testInstallVs2010LogFile]]] : $error}]
   302    302   } -cleanup {
   303    303     cleanupFile $fileName
   304    304   
   305    305     unset -nocomplain wow64 is64 code output error fileName
   306    306   } -constraints {eagle administrator buildYear.2010 visualStudio2010\
   307         -System.Data.SQLite.dll_v4.0.30319 file_Installer.exe\
          307  +System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
   308    308   file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
   309    309   file_Installer_Test_Vs2010.log} -result {0 True}}
   310    310   
   311    311   ###############################################################################
   312    312   
   313    313   runTest {test installer-1.6 {uninstaller tool / Visual Studio 2010} -setup {
   314    314     set fileName [file join [getTemporaryPath] [file tail [string map [list \
................................................................................
   338    338     list $code [expr {$code == 0 ? [string equal [readFile $fileName] \
   339    339         [subst -nobackslashes [readFile $testUninstallVs2010LogFile]]] : $error}]
   340    340   } -cleanup {
   341    341     cleanupFile $fileName
   342    342   
   343    343     unset -nocomplain wow64 is64 code output error fileName
   344    344   } -constraints {eagle administrator buildYear.2010 visualStudio2010\
   345         -System.Data.SQLite.dll_v4.0.30319 file_Installer.exe\
          345  +System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
   346    346   file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
   347    347   file_Uninstaller_Test_Vs2010.log} -result {0 True}}
   348    348   
   349    349   ###############################################################################
   350    350   
   351    351   runTest {test installer-1.7 {installer tool / Visual Studio 2012} -setup {
   352    352     set fileName [file join [getTemporaryPath] [file tail [string map [list \
................................................................................
   376    376     list $code [expr {$code == 0 ? [string equal [readFile $fileName] \
   377    377         [subst -nobackslashes [readFile $testInstallVs2012LogFile]]] : $error}]
   378    378   } -cleanup {
   379    379     cleanupFile $fileName
   380    380   
   381    381     unset -nocomplain wow64 is64 code output error fileName
   382    382   } -constraints {eagle administrator buildYear.2012 visualStudio2012\
   383         -System.Data.SQLite.dll_v4.0.30319 file_Installer.exe\
          383  +System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
   384    384   file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
   385    385   file_Installer_Test_Vs2012.log} -result {0 True}}
   386    386   
   387    387   ###############################################################################
   388    388   
   389    389   runTest {test installer-1.8 {uninstaller tool / Visual Studio 2012} -setup {
   390    390     set fileName [file join [getTemporaryPath] [file tail [string map [list \
................................................................................
   414    414     list $code [expr {$code == 0 ? [string equal [readFile $fileName] \
   415    415         [subst -nobackslashes [readFile $testUninstallVs2012LogFile]]] : $error}]
   416    416   } -cleanup {
   417    417     cleanupFile $fileName
   418    418   
   419    419     unset -nocomplain wow64 is64 code output error fileName
   420    420   } -constraints {eagle administrator buildYear.2012 visualStudio2012\
   421         -System.Data.SQLite.dll_v4.0.30319 file_Installer.exe\
          421  +System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
   422    422   file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
   423    423   file_Uninstaller_Test_Vs2012.log} -result {0 True}}
   424    424   
   425    425   ###############################################################################
   426    426   
   427    427   unset -nocomplain testUninstallVs2012LogFile testUninstallVs2010LogFile \
   428    428       testUninstallVs2008LogFile testUninstallVs2005LogFile \

Changes to Tests/stress.eagle.

  1424   1424     rename setupLogging ""
  1425   1425   
  1426   1426     unset -nocomplain result thread index workload priority noWorkload \
  1427   1427         priorities srcDb db fileName compiled options count times logFileName \
  1428   1428         logListener event timeout connection indicators iterations exitOnFail \
  1429   1429         coTaskMem noTrace failures status
  1430   1430   } -time true -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
  1431         -System.Data.SQLite} -result {0}}
         1431  +System.Data.SQLite compileCSharp} -result {0}}
  1432   1432   
  1433   1433   ###############################################################################
  1434   1434   
  1435   1435   #
  1436   1436   # NOTE: Report after test.
  1437   1437   #
  1438   1438   checkForSQLiteDirectories $test_channel

Changes to Tests/thread.eagle.

   454    454         [getSQLiteHandleCounts $test_channel] \
   455    455         [reportSQLiteResources $test_channel]
   456    456   } -cleanup {
   457    457     cleanupDb $fileName
   458    458   
   459    459     unset -nocomplain result results errors code sql dataSource id db fileName
   460    460   } -time true -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
   461         -System.Data.SQLite} -match regexp -result [appendArgs "^Ok\
          461  +System.Data.SQLite compileCSharp} -match regexp -result [appendArgs "^Ok\
   462    462   System#CodeDom#Compiler#CompilerResults#\\d+ \\{\\} 0 \\{\\d+ \\d+ " $count(1) \
   463    463   "\\} \\{\\} \\{" $handle_counts "\\} " $memory_used \$]}
   464    464   
   465    465   ###############################################################################
   466    466   
   467    467   unset -nocomplain count
   468    468   

Changes to Tests/tkt-00f86f9739.eagle.

    79     79     }
    80     80   
    81     81     set result
    82     82   } -cleanup {
    83     83     unset -nocomplain code output error result value
    84     84   } -constraints \
    85     85   {eagle monoToDo defineConstant.System.Data.SQLite.USE_INTEROP_DLL\
    86         -defineConstant.System.Data.SQLite.INTEROP_EXTENSION_FUNCTIONS SQLite\
           86  +defineConstant.System.Data.SQLite.INTEROP_EXTENSION_FUNCTIONS SQLite testExec\
    87     87   file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll file_testlinq.exe\
    88     88   file_northwindEF.db} -result {0 {} 0 {DRACD OLDWO RATTC} 0 {ALFKI CACTU CHOPS\
    89     89   FOLKO GALED KOENE LILAS MAGAA MAISD OCEAN RANCH SAVEA THECR} 0 {} 0 {} 0 {} 0\
    90     90   {}}}
    91     91   
    92     92   ###############################################################################
    93     93   

Changes to Tests/tkt-201128cc88.eagle.

    90     90         [sql execute -execute scalar $db "SELECT Base64(CAST(NULL AS BLOB));"] \
    91     91         [sql execute -execute scalar $db "SELECT Base64(CAST('' AS BLOB));"] \
    92     92         [sql execute -execute scalar $db "SELECT Base64(CAST('foo' AS BLOB));"]
    93     93   } -cleanup {
    94     94     cleanupDb $fileName
    95     95   
    96     96     unset -nocomplain result code results errors id db fileName
    97         -} -constraints \
    98         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
    99         -regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}\
           97  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
           98  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
           99  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}\
   100    100   System#Data#SQLite#SQLiteConnection#\d+ \{\} \{\} Zm9v$}}
   101    101   
   102    102   ###############################################################################
   103    103   
   104    104   runSQLiteTestEpilogue
   105    105   runTestEpilogue

Changes to Tests/tkt-343d392b51.eagle.

   186    186         } result] : [set result ""]}] $result
   187    187   } -cleanup {
   188    188     cleanupDb $fileName; unset -nocomplain db fileName
   189    189     cleanupDb $otherFileName
   190    190   
   191    191     unset -nocomplain result code results errors i sql otherTable otherDbName \
   192    192         otherDataSource dataSource id otherFileName
   193         -} -constraints \
   194         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
   195         -glob -result {* System.Data.DBConcurrencyException: *}}
          193  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
          194  +System.Data.SQLite compileCSharp} -match glob -result {*\
          195  +System.Data.DBConcurrencyException: *}}
   196    196   
   197    197   ###############################################################################
   198    198   
   199    199   runTest {test tkt-343d392b51-2.2 {SQLiteDataAdapter update success} -setup {
   200    200     setupDb [set fileName tkt-343d392b51-2.2.db] "" JulianDay
   201    201     set otherFileName tkt-343d392b51-2.2-otherDb.db
   202    202   } -body {
................................................................................
   292    292         } result] : [set result ""]}] $result
   293    293   } -cleanup {
   294    294     cleanupDb $fileName; unset -nocomplain db fileName
   295    295     cleanupDb $otherFileName
   296    296   
   297    297     unset -nocomplain result code results errors i sql otherTable otherDbName \
   298    298         otherDataSource dataSource id otherFileName
   299         -} -constraints \
   300         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
   301         -regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
          299  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
          300  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
          301  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
   302    302   
   303    303   ###############################################################################
   304    304   
   305    305   runTest {test tkt-343d392b51-3.1 {attached database, same table name} -setup {
   306    306     setupDb [set fileName tkt-343d392b51-3.1.db]
   307    307     set otherFileName tkt-343d392b51-3.1-otherDb.db
   308    308   } -body {
................................................................................
   428    428         } result] : [set result ""]}] $result
   429    429   } -cleanup {
   430    430     cleanupDb $fileName; unset -nocomplain db fileName
   431    431     cleanupDb $otherFileName
   432    432   
   433    433     unset -nocomplain result code results errors i sql otherTable otherDbName \
   434    434         otherDataSource dataSource id otherFileName
   435         -} -constraints \
   436         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
   437         -regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
          435  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
          436  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
          437  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
   438    438   
   439    439   ###############################################################################
   440    440   
   441    441   runSQLiteTestEpilogue
   442    442   runTestEpilogue

Changes to Tests/tkt-3aa50d8413.eagle.

    72     72         [expr {$code eq "Ok" ? [catch {
    73     73           object invoke _Dynamic${id}.Test${id} Main
    74     74         } result] : [set result ""]}] $result
    75     75   } -cleanup {
    76     76     cleanupDb $fileName
    77     77   
    78     78     unset -nocomplain result code results errors sql dataSource id db fileName
    79         -} -constraints \
    80         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
    81         -regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
           79  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
           80  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
           81  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
    82     82   
    83     83   ###############################################################################
    84     84   
    85     85   runSQLiteTestEpilogue
    86     86   runTestEpilogue

Changes to Tests/tkt-48a6b8e4ca.eagle.

    74     74         [expr {$code eq "Ok" ? [catch {
    75     75           object invoke _Dynamic${id}.Test${id} Main
    76     76         } result] : [set result ""]}] $result
    77     77   } -cleanup {
    78     78     cleanupDb $fileName
    79     79   
    80     80     unset -nocomplain result code results errors sql dataSource id db fileName
    81         -} -constraints \
    82         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
    83         -regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
           81  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
           82  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
           83  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
    84     84   
    85     85   ###############################################################################
    86     86   
    87     87   runSQLiteTestEpilogue
    88     88   runTestEpilogue

Changes to Tests/tkt-4a791e70ab.eagle.

    67     67         [expr {$code eq "Ok" ? [catch {
    68     68           object invoke _Dynamic${id}.Test${id} Main
    69     69         } result] : [set result ""]}] $result
    70     70   } -cleanup {
    71     71     cleanupDb $fileName
    72     72   
    73     73     unset -nocomplain result results errors code dataSource id db fileName
    74         -} -constraints \
    75         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
    76         -regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
           74  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
           75  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
           76  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
    77     77   
    78     78   ###############################################################################
    79     79   
    80     80   runSQLiteTestEpilogue
    81     81   runTestEpilogue

Changes to Tests/tkt-59edc1018b.eagle.

    79     79     }
    80     80   
    81     81     set result
    82     82   } -cleanup {
    83     83     unset -nocomplain code output error result value
    84     84   } -constraints \
    85     85   {eagle monoToDo defineConstant.System.Data.SQLite.USE_INTEROP_DLL\
    86         -defineConstant.System.Data.SQLite.INTEROP_EXTENSION_FUNCTIONS SQLite\
           86  +defineConstant.System.Data.SQLite.INTEROP_EXTENSION_FUNCTIONS SQLite testExec\
    87     87   file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll file_testlinq.exe\
    88     88   file_northwindEF.db} -result {0 {} 0 {FURIB GALED GODOS LAZYK LINOD PRINI REGGC\
    89     89   WOLZA} 0 {} 0 ERNSH 0 {} 0 {AROUT BSBEV CONSH EASTC NORTS SEVES} 0 {}}}
    90     90   
    91     91   ###############################################################################
    92     92   
    93     93   unset -nocomplain systemDataSQLiteDllFile systemDataSQLiteLinqDllFile \
    94     94       testLinqExeFile northwindEfDbFile
    95     95   
    96     96   ###############################################################################
    97     97   
    98     98   runSQLiteTestEpilogue
    99     99   runTestEpilogue

Changes to Tests/tkt-6434e23a0f.eagle.

    72     72         [expr {$code eq "Ok" ? [catch {
    73     73           object invoke _Dynamic${id}.Test${id} Main
    74     74         } result] : [set result ""]}] $result
    75     75   } -cleanup {
    76     76     cleanupDb $fileName
    77     77   
    78     78     unset -nocomplain result results errors code sql dataSource id db fileName
    79         -} -constraints \
    80         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
    81         -regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
           79  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
           80  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
           81  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
    82     82   
    83     83   ###############################################################################
    84     84   
    85     85   runSQLiteTestEpilogue
    86     86   runTestEpilogue

Changes to Tests/tkt-6c6ecccc5f.eagle.

    67     67         [expr {$code eq "Ok" ? [catch {
    68     68           object invoke _Dynamic${id}.Test${id} Main
    69     69         } result] : [set result ""]}] $result
    70     70   } -cleanup {
    71     71     cleanupDb $fileName
    72     72   
    73     73     unset -nocomplain result results errors code sql dataSource id db fileName
    74         -} -constraints \
    75         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} \
    76         --match regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0\
    77         -\{\}$}}
           74  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
           75  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
           76  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
    78     77   
    79     78   ###############################################################################
    80     79   
    81     80   runSQLiteTestEpilogue
    82     81   runTestEpilogue

Changes to Tests/tkt-72905c9a77.eagle.

   270    270         } result] : [set result ""]}] [string map [list \r\n \n] $result]
   271    271   } -cleanup {
   272    272     cleanupDb $fileName
   273    273   
   274    274     unset -nocomplain result code results errors dataSource fileName
   275    275   } -constraints [fixConstraints {eagle monoBug28 configuration.Release\
   276    276   !defineConstant.System.Data.SQLite.INTEROP_LOG command.sql compile.DATA\
   277         -SQLite System.Data.SQLite}] -match regexp -result [appendArgs "^Ok\
   278         -System#CodeDom#Compiler#CompilerResults#\\d+ \\{\\} 0 \\{" [string repeat \
          277  +SQLite System.Data.SQLite compileCSharp}] -match regexp -result [appendArgs \
          278  +"^Ok System#CodeDom#Compiler#CompilerResults#\\d+ \\{\\} 0 \\{" [string repeat \
   279    279   "SQLite message \\(0\\): TEST $id
   280    280   " [expr {4 * [info processors]}]] "\\}\$"]}
   281    281   
   282    282   ###############################################################################
   283    283   
   284    284   unset -nocomplain id
   285    285   
   286    286   ###############################################################################
   287    287   
   288    288   runSQLiteTestEpilogue
   289    289   runTestEpilogue

Changes to Tests/tkt-7e3fa93744.eagle.

   124    124         [expr {$code eq "Ok" ? [catch {
   125    125           object invoke _Dynamic${id}.Test${id} Main
   126    126         } result] : [set result ""]}] $result
   127    127   } -cleanup {
   128    128     cleanupDb $fileName
   129    129   
   130    130     unset -nocomplain result code results errors sql dataSource id db fileName
   131         -} -constraints \
   132         -{eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} -match \
   133         -regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 8$}}
          131  +} -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
          132  +System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
          133  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 8$}}
   134    134   
   135    135   ###############################################################################
   136    136   
   137    137   runSQLiteTestEpilogue
   138    138   runTestEpilogue

Changes to Tests/tkt-8b7d179c3c.eagle.

    77     77         lappend result [string trim $error]
    78     78       }
    79     79     }
    80     80   
    81     81     set result
    82     82   } -cleanup {
    83     83     unset -nocomplain code output error result pageSize
    84         -} -constraints {eagle monoToDo SQLite file_System.Data.SQLite.dll\
           84  +} -constraints {eagle monoToDo SQLite file_System.Data.SQLite.dll testExec\
    85     85   file_System.Data.SQLite.Linq.dll file_testlinq.exe file_northwindEF.db} \
    86     86   -result {0 {} 0 {DRACD RATTC OLDWO GALED LILAS MAGAA ALFKI CHOPS SAVEA KOENE\
    87     87   MAISD FOLKO CACTU OCEAN RANCH THECR GOURL GROSR SUPRD HUNGO ISLAT QUICK HUNGC\
    88     88   GREAL LEHMS RICSU ERNSH WILMK LINOD TRAIH SIMOB OTTIK SPLIR MORGK FOLIG FURIB\
    89     89   PRINI AROUT BSBEV CONSH EASTC NORTS SEVES BERGS VICTE BOLID FISSA ROMEY BLAUS\
    90     90   BONAP MEREP ANATR ANTON CENTC PERIC TORTU FRANK TOMSP DUMON FRANR WARTH PARIS\
    91     91   SPECD LONEP THEBI REGGC VINET WELLI HANAR QUEDE RICAR PICCO HILAA LETSS COMMI\

Changes to Tests/tkt-996d13cd87.eagle.

   283    283       cleanupDb $fileName
   284    284   
   285    285       unset -nocomplain result results errors code sql dataSource id \
   286    286           poolCounts havePoolCounts fileName
   287    287   
   288    288       rename getPoolCounts ""
   289    289     } -constraints {eagle monoBug28 command.sql compile.DATA\
   290         -SQLite System.Data.SQLite} -match regexp -result {^Ok\
          290  +SQLite System.Data.SQLite compileCSharp} -match regexp -result {^Ok\
   291    291   System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \d+ \{\} True True$}}
   292    292   }
   293    293   
   294    294   ###############################################################################
   295    295   
   296    296   unset -nocomplain count pooling i
   297    297   
   298    298   ###############################################################################
   299    299   
   300    300   runSQLiteTestEpilogue
   301    301   runTestEpilogue

Changes to Tests/tkt-ae5267b863.eagle.

   143    143           object invoke _Dynamic${id}.Test${id} Main
   144    144         } result] : [set result ""]}] $result
   145    145   } -cleanup {
   146    146     cleanupDb $fileName
   147    147   
   148    148     unset -nocomplain result code results errors sql dataSource id db fileName
   149    149   } -constraints [fixConstraints {eagle monoBug28 command.sql compile.DATA\
   150         -SQLite System.Data.SQLite !mda\
          150  +SQLite System.Data.SQLite !mda compileCSharp\
   151    151   !defineConstant.System.Data.SQLite.INTEROP_LEGACY_CLOSE}] -match regexp \
   152    152   -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
   153    153   
   154    154   ###############################################################################
   155    155   
   156    156   runSQLiteTestEpilogue
   157    157   runTestEpilogue

Changes to Tests/tkt-ccfa69fc32.eagle.

    77     77         lappend result [string trim $error]
    78     78       }
    79     79     }
    80     80   
    81     81     set result
    82     82   } -cleanup {
    83     83     unset -nocomplain code output error result add
    84         -} -constraints {eagle monoToDo SQLite file_System.Data.SQLite.dll\
           84  +} -constraints {eagle monoToDo SQLite file_System.Data.SQLite.dll testExec\
    85     85   file_System.Data.SQLite.Linq.dll file_testlinq.exe file_northwindEF.db} -match \
    86     86   glob -result {0 {1581 1730 1833 2116 2139} 0 {System.Data.UpdateException: *\
    87     87   ---> System.Data.SQLite.SQLiteException: constraint failed
    88     88   PRIMARY KEY must be unique
    89     89   *} 0 {1 2 3 4 5 6 7 8 9 10 1576 1577 1578 1579 1580 1581 1730 1833 2116 2139}}}
    90     90   
    91     91   ###############################################################################

Changes to Tests/tkt-e1b2e0f769.eagle.

   119    119   
   120    120     set result1
   121    121   } -cleanup {
   122    122     cleanupDb $fileName
   123    123   
   124    124     unset -nocomplain result2 result1 code results errors sql table dataSource \
   125    125         id x db fileName
   126         -} -constraints \
   127         -[fixConstraints {eagle monoBug28 command.sql compile.DATA SQLite\
   128         -!defineConstant.System.Data.SQLite.CHECK_STATE System.Data.SQLite}] -match \
   129         -regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 3 Ok\
          126  +} -constraints [fixConstraints {eagle monoBug28 command.sql compile.DATA SQLite\
          127  +!defineConstant.System.Data.SQLite.CHECK_STATE System.Data.SQLite\
          128  +compileCSharp}] -match regexp -result {^Ok\
          129  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 3 Ok\
   130    130   System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 0$}}
   131    131   
   132    132   ###############################################################################
   133    133   
   134    134   runSQLiteTestEpilogue
   135    135   runTestEpilogue

Changes to Tests/tkt-e30b820248.eagle.

   104    104           object invoke _Dynamic${id}.Test${id} Main
   105    105         } result] : [set result ""]}] $result \
   106    106         [reportSQLiteResources $test_channel true]
   107    107   } -cleanup {
   108    108     cleanupDb $fileName
   109    109   
   110    110     unset -nocomplain result code results errors sql name dataSource id fileName
   111         -} -constraints \
   112         -{eagle logFile monoBug28 command.sql compile.DATA SQLite System.Data.SQLite} \
   113         --match regexp -result [appendArgs "^Ok\
          111  +} -constraints {eagle logFile monoBug28 command.sql compile.DATA SQLite\
          112  +System.Data.SQLite compileCSharp} -match regexp -result [appendArgs "^Ok\
   114    113   System#CodeDom#Compiler#CompilerResults#\\d+ \\{\\} 0 \\{\\} " $memory_used \$]}
   115    114   
   116    115   ###############################################################################
   117    116   
   118    117   for {set i 2} {$i < 5} {incr i} {
   119    118     set memory_used [reportSQLiteResources $test_channel true]
   120    119   
................................................................................
   259    258           [reportSQLiteResources $test_channel true]
   260    259     } -cleanup {
   261    260       cleanupDb $fileName
   262    261   
   263    262       unset -nocomplain result code results errors sql name dataSource id \
   264    263           fileName
   265    264     } -constraints {eagle logFile monoBug28 command.sql compile.DATA SQLite\
   266         -System.Data.SQLite} -match regexp -result [appendArgs "^Ok\
          265  +System.Data.SQLite compileCSharp} -match regexp -result [appendArgs "^Ok\
   267    266   System#CodeDom#Compiler#CompilerResults#\\d+ \\{\\} 0 \\{\\} " $memory_used \$]}
   268    267   }
   269    268   
   270    269   ###############################################################################
   271    270   
   272    271   unset -nocomplain i
   273    272   

Changes to Tests/vtab.eagle.

    99     99         } result] : [set result ""]}] $result
   100    100   } -cleanup {
   101    101     cleanupDb $fileName
   102    102   
   103    103     unset -nocomplain result code results errors sql dataSource id fileName
   104    104   } -constraints \
   105    105   {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
   106         -defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE} -match regexp -result \
   107         -{^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
          106  +defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE compileCSharp} -match \
          107  +regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\}$}}
   108    108   
   109    109   ###############################################################################
   110    110   
   111    111   runTest {test vtab-1.2.1 {IEnumerable virtual table} -setup {
   112    112     set fileName vtab-1.2.1.db
   113    113   } -body {
   114    114     set id [object invoke Interpreter.GetActive NextId]
................................................................................
   204    204         } result] : [set result ""]}] $result
   205    205   } -cleanup {
   206    206     cleanupDb $fileName
   207    207   
   208    208     unset -nocomplain result code results errors sql dataSource id fileName
   209    209   } -constraints \
   210    210   {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
   211         -defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE} -match regexp -result \
   212         -[string map [list \n \r\n] {^Ok System#CodeDom#Compiler#CompilerResults#\d+\
   213         -\{\} 0 \{one two three 4 5\.0 Error \{SQL logic error or missing database
          211  +defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE compileCSharp} -match \
          212  +regexp -result [string map [list \n \r\n] {^Ok\
          213  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{one two three 4 5\.0 Error\
          214  +\{SQL logic error or missing database
   214    215   virtual table "t\d+" is read-only\}\}$}]}
   215    216   
   216    217   ###############################################################################
   217    218   
   218    219   runTest {test vtab-1.2.2 {IEnumerable virtual table} -setup {
   219    220     set fileName vtab-1.2.2.db
   220    221   } -body {
................................................................................
   314    315         } result] : [set result ""]}] $result
   315    316   } -cleanup {
   316    317     cleanupDb $fileName
   317    318   
   318    319     unset -nocomplain result code results errors sql dataSource id fileName
   319    320   } -constraints \
   320    321   {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
   321         -defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE} -match regexp -result \
   322         -[string map [list \n \r\n] {^Ok System#CodeDom#Compiler#CompilerResults#\d+\
   323         -\{\} 0 \{one two three 4 5\.0 Error \{SQL logic error or missing database
          322  +defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE compileCSharp} -match \
          323  +regexp -result [string map [list \n \r\n] {^Ok\
          324  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{one two three 4 5\.0 Error\
          325  +\{SQL logic error or missing database
   324    326   virtual table "t\d+" is read-only\}\}$}]}
   325    327   
   326    328   ###############################################################################
   327    329   
   328    330   runTest {test vtab-1.3.1 {IEnumerable<T> virtual table} -setup {
   329    331     set fileName vtab-1.3.1.db
   330    332   } -body {
................................................................................
   422    424         } result] : [set result ""]}] $result
   423    425   } -cleanup {
   424    426     cleanupDb $fileName
   425    427   
   426    428     unset -nocomplain result code results errors sql dataSource id fileName
   427    429   } -constraints \
   428    430   {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
   429         -defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE} -match regexp -result \
   430         -[string map [list \n \r\n] {^Ok System#CodeDom#Compiler#CompilerResults#\d+\
   431         -\{\} 0 \{1 2 3 4 5 Error \{SQL logic error or missing database
          431  +defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE compileCSharp} -match \
          432  +regexp -result [string map [list \n \r\n] {^Ok\
          433  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{1 2 3 4 5 Error \{SQL\
          434  +logic error or missing database
   432    435   virtual table "t\d+" is read-only\}\}$}]}
   433    436   
   434    437   ###############################################################################
   435    438   
   436    439   runTest {test vtab-1.3.2 {IEnumerable<T> virtual table} -setup {
   437    440     set fileName vtab-1.3.2.db
   438    441   } -body {
................................................................................
   533    536         } result] : [set result ""]}] $result
   534    537   } -cleanup {
   535    538     cleanupDb $fileName
   536    539   
   537    540     unset -nocomplain result code results errors sql dataSource id fileName
   538    541   } -constraints \
   539    542   {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
   540         -defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE} -match regexp -result \
   541         -[string map [list \n \r\n] {^Ok System#CodeDom#Compiler#CompilerResults#\d+\
   542         -\{\} 0 \{1 2 3 4 5 Error \{SQL logic error or missing database
          543  +defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE compileCSharp} -match \
          544  +regexp -result [string map [list \n \r\n] {^Ok\
          545  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{1 2 3 4 5 Error \{SQL\
          546  +logic error or missing database
   543    547   virtual table "t\d+" is read-only\}\}$}]}
   544    548   
   545    549   ###############################################################################
   546    550   
   547    551   runTest {test vtab-1.4 {virtual table function support} -setup {
   548    552     set fileName vtab-1.4.db
   549    553   } -body {
................................................................................
   784    788         } result] : [set result ""]}] $result
   785    789   } -cleanup {
   786    790     cleanupDb $fileName
   787    791   
   788    792     unset -nocomplain result code results errors sql dataSource id fileName
   789    793   } -constraints \
   790    794   {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
   791         -defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE} -match regexp -result \
   792         -[string map [list \n \r\n] {^Ok System#CodeDom#Compiler#CompilerResults#\d+\
   793         -\{\} 0 \{\{\} b25l \{SQL logic error or missing database
          795  +defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE compileCSharp} -match \
          796  +regexp -result [string map [list \n \r\n] {^Ok\
          797  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\{\} b25l \{SQL logic\
          798  +error or missing database
   794    799   unable to use function Base64 in the requested context\} \{SQL logic error or\
   795    800   missing database
   796    801   no such function: Base65\}\}$}]}
   797    802   
   798    803   ###############################################################################
   799    804   
   800    805   runTest {test vtab-1.5 {virtual table function support} -setup {
................................................................................
  1037   1042         } result] : [set result ""]}] $result
  1038   1043   } -cleanup {
  1039   1044     cleanupDb $fileName
  1040   1045   
  1041   1046     unset -nocomplain result code results errors sql dataSource id fileName
  1042   1047   } -constraints \
  1043   1048   {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
  1044         -defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE} -match regexp -result \
  1045         -[string map [list \n \r\n] {^Ok System#CodeDom#Compiler#CompilerResults#\d+\
  1046         -\{\} 0 \{\{\} b25l \{SQL logic error or missing database
         1049  +defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE compileCSharp} -match \
         1050  +regexp -result [string map [list \n \r\n] {^Ok\
         1051  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\{\} b25l \{SQL logic\
         1052  +error or missing database
  1047   1053   (?:unable to use function Base64 in the requested context|need exactly one\
  1048   1054   argument, got 3)\} \{SQL logic error or missing database
  1049   1055   no such function: Base65\}\}$}]}
  1050   1056   
  1051   1057   ###############################################################################
  1052   1058   
  1053   1059   runTest {test vtab-1.6 {virtual table rename support} -setup {
................................................................................
  1216   1222         } result] : [set result ""]}] $result
  1217   1223   } -cleanup {
  1218   1224     cleanupDb $fileName
  1219   1225   
  1220   1226     unset -nocomplain result code results errors sql dataSource id fileName
  1221   1227   } -constraints \
  1222   1228   {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
  1223         -defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE} -match regexp -result \
  1224         -[string map [list \n \r\n] {^Ok System#CodeDom#Compiler#CompilerResults#\d+\
  1225         -\{\} 0 \{\{\} t\d+ \{\} x\d+\}$}]}
         1229  +defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE compileCSharp} -match \
         1230  +regexp -result [string map [list \n \r\n] {^Ok\
         1231  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\{\} t\d+ \{\} x\d+\}$}]}
  1226   1232   
  1227   1233   ###############################################################################
  1228   1234   
  1229   1235   runTest {test vtab-1.7 {virtual table xBestIndex marshalling (1)} -setup {
  1230   1236     set fileName vtab-1.7.db
  1231   1237   } -body {
  1232   1238     set id [object invoke Interpreter.GetActive NextId]
................................................................................
  1316   1322         } result] : [set result ""]}] $result
  1317   1323   } -cleanup {
  1318   1324     cleanupDb $fileName
  1319   1325   
  1320   1326     unset -nocomplain result code results errors sql dataSource id fileName
  1321   1327   } -constraints \
  1322   1328   {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
  1323         -defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE} -match regexp -result \
  1324         -[string map [list \n \r\n] {^Ok System#CodeDom#Compiler#CompilerResults#\d+\
  1325         -\{\} 0 \{0 5 two three one 5\.0 4\}$}]}
         1329  +defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE compileCSharp} -match \
         1330  +regexp -result [string map [list \n \r\n] {^Ok\
         1331  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{0 5 two three one 5\.0\
         1332  +4\}$}]}
  1326   1333   
  1327   1334   ###############################################################################
  1328   1335   
  1329   1336   runTest {test vtab-1.8 {virtual table xBestIndex marshalling (2)} -setup {
  1330   1337     set fileName vtab-1.8.db
  1331   1338   } -body {
  1332   1339     set id [object invoke Interpreter.GetActive NextId]
................................................................................
  1417   1424         } result] : [set result ""]}] $result
  1418   1425   } -cleanup {
  1419   1426     cleanupDb $fileName
  1420   1427   
  1421   1428     unset -nocomplain result code results errors sql dataSource id fileName
  1422   1429   } -constraints \
  1423   1430   {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
  1424         -defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE} -match regexp -result \
  1425         -[string map [list \n \r\n] {^Ok System#CodeDom#Compiler#CompilerResults#\d+\
  1426         -\{\} 0 \{0 5 one three\}$}]}
         1431  +defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE compileCSharp} -match \
         1432  +regexp -result [string map [list \n \r\n] {^Ok\
         1433  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{0 5 one three\}$}]}
  1427   1434   
  1428   1435   ###############################################################################
  1429   1436   
  1430   1437   runTest {test vtab-1.9 {IEnumerable virtual table w/large byte array} -setup {
  1431   1438     set fileName vtab-1.9.db
  1432   1439   } -body {
  1433   1440     set id [object invoke Interpreter.GetActive NextId]
................................................................................
  1495   1502         } result] : [set result ""]}] $result
  1496   1503   } -cleanup {
  1497   1504     cleanupDb $fileName
  1498   1505   
  1499   1506     unset -nocomplain result code results errors sql dataSource id fileName
  1500   1507   } -time true -constraints \
  1501   1508   {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
  1502         -defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE} -match regexp -result \
  1503         -[string map [list \n \r\n] {^Ok System#CodeDom#Compiler#CompilerResults#\d+\
  1504         -\{\} 0 (?:-)?\d+$}]}
         1509  +defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE compileCSharp} -match \
         1510  +regexp -result [string map [list \n \r\n] {^Ok\
         1511  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 (?:-)?\d+$}]}
  1505   1512   
  1506   1513   ###############################################################################
  1507   1514   
  1508   1515   runTest {test vtab-1.10 {virtual table xRowId uniqueness} -setup {
  1509   1516     set fileName vtab-1.10.db
  1510   1517   } -body {
  1511   1518     set id [object invoke Interpreter.GetActive NextId]
................................................................................
  1592   1599         } result] : [set result ""]}] $result
  1593   1600   } -cleanup {
  1594   1601     cleanupDb $fileName
  1595   1602   
  1596   1603     unset -nocomplain result code results errors sql dataSource id fileName
  1597   1604   } -constraints \
  1598   1605   {eagle monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
  1599         -defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE} -match regexp -result \
  1600         -[string map [list \n \r\n] {^Ok System#CodeDom#Compiler#CompilerResults#\d+\
  1601         -\{\} 0 \{0 4294967296 4294967296 8589934592 8589934592 12884901888 12884901888\
  1602         -17179869184 17179869184 21474836480 21474836480 25769803776 25769803776\}$}]}
         1606  +defineConstant.System.Data.SQLite.INTEROP_VIRTUAL_TABLE compileCSharp} -match \
         1607  +regexp -result [string map [list \n \r\n] {^Ok\
         1608  +System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{0 4294967296 4294967296\
         1609  +8589934592 8589934592 12884901888 12884901888 17179869184 17179869184\
         1610  +21474836480 21474836480 25769803776 25769803776\}$}]}
  1603   1611   
  1604   1612   ###############################################################################
  1605   1613   
  1606   1614   runSQLiteTestEpilogue
  1607   1615   runTestEpilogue