System.Data.SQLite
Check-in [cafe9568f1]
Not logged in

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

Overview
Comment:Update Eagle in externals to the latest trunk code.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: cafe9568f1c3b381ba35caf4564e94bb964b111a
User & Date: mistachkin 2014-09-04 02:41:58
Context
2014-09-04
02:43
Updates to the test suite infrastructure to handle Eagle integration changes. Cherrypick of [e68410521b]. check-in: 320319609f user: mistachkin tags: trunk
02:41
Update Eagle in externals to the latest trunk code. check-in: cafe9568f1 user: mistachkin tags: trunk
2014-08-19
17:58
Add per-connection caching of the 'Use_SQLiteConvert_DefaultDbType' and 'Use_SQLiteConvert_DefaultTypeName' settings. Pursuant to [58ed318f2f]. check-in: 948fd5b3a3 user: mistachkin tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to Externals/Eagle/bin/Eagle.dll.

cannot compute difference between binary files

Changes to Externals/Eagle/bin/EagleShell.exe.

cannot compute difference between binary files

Changes to Externals/Eagle/bin/EagleShell32.exe.

cannot compute difference between binary files

Changes to Externals/Eagle/bin/x64/Spilornis.dll.

cannot compute difference between binary files

Changes to Externals/Eagle/bin/x86/Spilornis.dll.

cannot compute difference between binary files

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

    99     99     #       in both Tcl and Eagle and must return non-zero only when
   100    100     #       running in Eagle on Mono.
   101    101     #
   102    102     proc isMono {} {
   103    103       return [expr {[info exists ::eagle_platform(runtime)] && \
   104    104           [string compare -nocase mono $::eagle_platform(runtime)] == 0}]
   105    105     }
          106  +
          107  +  #
          108  +  # NOTE: This procedure returns non-zero if the specified file names refer
          109  +  #       to the same file, using the most robust method available for the
          110  +  #       script engine and platform.
          111  +  #
          112  +  proc isSameFileName { fileName1 fileName2 } {
          113  +    if {[isEagle]} then {
          114  +      return [file same $fileName1 $fileName2]
          115  +    } else {
          116  +      if {[isWindows]} then {
          117  +        return [string equal -nocase $fileName1 $fileName2]
          118  +      } else {
          119  +        return [string equal $fileName1 $fileName2]
          120  +      }
          121  +    }
          122  +  }
   106    123   
   107    124     proc getEnvironmentVariable { name } {
   108    125       #
   109    126       # NOTE: This should work properly in both Tcl and Eagle.
   110    127       #
   111    128       return [expr {[info exists ::env($name)] ? $::env($name) : ""}]
   112    129     }
................................................................................
   914    931         #       for the platform (i.e. the ones used to compile the Eagle core
   915    932         #       library assembly).
   916    933         #
   917    934         set platformOptions [expr { \
   918    935             [info exists ::eagle_platform(compileOptions)] ? \
   919    936             $::eagle_platform(compileOptions) : [list]}]
   920    937   
   921         -      if {[llength $platformOptions] > 0} then {
          938  +      #
          939  +      # NOTE: Permit extra C# compiler options to be passed via the global
          940  +      #       array element "csharpOptions", if it exists.
          941  +      #
          942  +      set csharpOptions [expr { \
          943  +          [info exists ::eagle_platform(csharpOptions)] ? \
          944  +          $::eagle_platform(csharpOptions) : [list]}]
          945  +
          946  +      if {[llength $platformOptions] > 0 || \
          947  +          [llength $csharpOptions] > 0} then {
   922    948           #
   923    949           # NOTE: Grab the existing compiler options, if any.
   924    950           #
   925    951           set compilerOptions [$parameters CompilerOptions]
   926    952   
   927    953           if {"DEBUG" in $platformOptions} then {
   928         -          append compilerOptions " /define:DEBUG"
          954  +          if {[string length $compilerOptions] > 0} then {
          955  +            append compilerOptions " "
          956  +          }
          957  +
          958  +          append compilerOptions /define:DEBUG
   929    959           }
   930    960   
   931    961           if {"TRACE" in $platformOptions} then {
   932         -          append compilerOptions " /define:TRACE"
          962  +          if {[string length $compilerOptions] > 0} then {
          963  +            append compilerOptions " "
          964  +          }
          965  +
          966  +          append compilerOptions /define:TRACE
          967  +        }
          968  +
          969  +        #
          970  +        # NOTE: Append the configured extra C# compiler options configured
          971  +        #       via the global array element "csharpOptions", if any.
          972  +        #
          973  +        foreach csharpOption $csharpOptions {
          974  +          if {[string length $compilerOptions] > 0} then {
          975  +            append compilerOptions " "
          976  +          }
          977  +
          978  +          append compilerOptions $csharpOption
   933    979           }
   934    980   
   935    981           #
   936    982           # NOTE: Reset the compiler options to the pre-existing ones plus the
   937    983           #       extra defines we may have added (above).
   938    984           #
   939    985           $parameters CompilerOptions $compilerOptions
................................................................................
  1810   1856           set length [string length $name]
  1811   1857   
  1812   1858           if {$length > $maxLength} {
  1813   1859             set maxLength $length
  1814   1860           }
  1815   1861         }
  1816   1862   
         1863  +      set stringMap [list \b " " \t " " \r \xB6 \n \xB6]
  1817   1864         set maxLength [expr {$maxLength + [string length $a] + 2}]
  1818   1865         set hostLength [lindex [getHostSize] 0]
  1819   1866         set valueLength [expr {$hostLength - $maxLength - 5}]; # " ... "
  1820   1867   
  1821   1868         foreach name $names {
  1822   1869           #
  1823   1870           # NOTE: Format the array element name for display.
  1824   1871           #
  1825         -        set nameString [appendArgs $a ( $name )]
         1872  +        set nameString [string map $stringMap [appendArgs $a ( $name )]]
  1826   1873   
  1827   1874           #
  1828   1875           # NOTE: If the value by itself is too long to fit on one host line,
  1829   1876           #       just truncate and ellipsis it.
  1830   1877           #
  1831         -        set valueString $array($name)
         1878  +        set valueString [string map $stringMap $array($name)]
  1832   1879   
  1833   1880           if {[string length $valueString] > $valueLength} then {
  1834   1881             set valueString [appendArgs [string range $valueString 0 \
  1835   1882                 [expr {$valueLength - 4}]] " ..."]
  1836   1883           }
  1837   1884   
  1838   1885           #
................................................................................
  1964   2011         }
  1965   2012       }
  1966   2013   
  1967   2014       proc findDirectories { pattern } {
  1968   2015         #
  1969   2016         # NOTE: Block non-Windows platforms since this is Windows specific.
  1970   2017         #
  1971         -      if {$::tcl_platform(platform) ne "windows"} then {
         2018  +      if {![isWindows]} then {
  1972   2019           error "not supported on this operating system"
  1973   2020         }
  1974   2021   
  1975   2022         #
  1976   2023         # NOTE: This should work properly in Eagle only.
  1977   2024         #
  1978   2025         set dir ""; set result [list]
................................................................................
  2012   2059         return $result
  2013   2060       }
  2014   2061   
  2015   2062       proc findFiles { pattern } {
  2016   2063         #
  2017   2064         # NOTE: Block non-Windows platforms since this is Windows specific.
  2018   2065         #
  2019         -      if {$::tcl_platform(platform) ne "windows"} then {
         2066  +      if {![isWindows]} then {
  2020   2067           error "not supported on this operating system"
  2021   2068         }
  2022   2069   
  2023   2070         #
  2024   2071         # NOTE: This should work properly in Eagle only.
  2025   2072         #
  2026   2073         set fileName ""; set result [list]
................................................................................
  2060   2107         return $result
  2061   2108       }
  2062   2109   
  2063   2110       proc findFilesRecursive { pattern } {
  2064   2111         #
  2065   2112         # NOTE: Block non-Windows platforms since this is Windows specific.
  2066   2113         #
  2067         -      if {$::tcl_platform(platform) ne "windows"} then {
         2114  +      if {![isWindows]} then {
  2068   2115           error "not supported on this operating system"
  2069   2116         }
  2070   2117   
  2071   2118         #
  2072   2119         # NOTE: This should work properly in Eagle only.
  2073   2120         #
  2074   2121         set fileName ""; set result [list]
................................................................................
  2167   2214         return $result
  2168   2215       }
  2169   2216   
  2170   2217       proc findFilesRecursive { pattern } {
  2171   2218         #
  2172   2219         # NOTE: Block non-Windows platforms since this is Windows specific.
  2173   2220         #
  2174         -      if {$::tcl_platform(platform) ne "windows"} then {
         2221  +      if {![isWindows]} then {
  2175   2222           error "not supported on this operating system"
  2176   2223         }
  2177   2224   
  2178   2225         #
  2179   2226         # NOTE: This should work properly in Tcl only.
  2180   2227         #
  2181   2228         set result [list]
................................................................................
  2258   2305       }
  2259   2306   
  2260   2307       #
  2261   2308       # NOTE: Exports the necessary commands from this package and import them
  2262   2309       #       into the global namespace.
  2263   2310       #
  2264   2311       exportAndImportPackageCommands [namespace current] [list \
  2265         -        isEagle isWindows haveGaruda isTclThread isMono \
         2312  +        isEagle isWindows haveGaruda isTclThread isMono isSameFileName \
  2266   2313           getEnvironmentVariable combineFlags getCompileInfo getPlatformInfo \
  2267   2314           getPluginPath appendArgs lappendArgs getDictionaryValue \
  2268   2315           getColumnValue getRowColumnValue tqputs tqlog readFile \
  2269   2316           readSharedFile writeFile appendFile appendLogFile appendSharedFile \
  2270   2317           appendSharedLogFile readAsciiFile writeAsciiFile readUnicodeFile \
  2271   2318           writeUnicodeFile getDirResultPath addToPath removeFromPath execShell \
  2272   2319           lshuffle ldifference filter map reduce getLengthModifier debug \

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

   483    483   
   484    484       #
   485    485       # TODO: Add more support for standard tcltest options here.
   486    486       #
   487    487       set options [list \
   488    488           -breakOnLeak -configuration -constraints -exitOnComplete -file \
   489    489           -logFile -machine -match -no -notFile -platform -postTest -preTest \
   490         -        -randomOrder -skip -startFile -stopFile -stopOnFailure -suffix \
   491         -        -suite -tclsh -threshold]
          490  +        -randomOrder -skip -startFile -stopFile -stopOnFailure -stopOnLeak \
          491  +        -suffix -suite -tclsh -threshold]
   492    492   
   493         -    foreach {name value} $args {
          493  +    set length [llength $args]
          494  +
          495  +    for {set index 0} {$index < $length} {incr index} {
          496  +      #
          497  +      # NOTE: Grab the current list element, which should be the name of
          498  +      #       the test option.
          499  +      #
          500  +      set name [lindex $args $index]
          501  +
   494    502         #
   495    503         # NOTE: Use the [tqputs] command here just in case the test log file
   496    504         #       has not been setup yet (i.e. by default, this procedure is
   497    505         #       almost always called by the test prologue file prior to the
   498    506         #       test log file having been setup and we do not want to just
   499    507         #       lose this output).
   500    508         #
   501    509         if {[lsearch -exact $options $name] != -1} then {
   502         -        set array($name) $value
          510  +        #
          511  +        # NOTE: Is there another list element available for the value?  If
          512  +        #       not, this is not a valid test option.
          513  +        #
          514  +        if {$index + 1 < $length} then {
          515  +          incr index; set value [lindex $args $index]
   503    516   
   504         -        tqputs $::test_channel [appendArgs \
   505         -            "---- overrode test option \"" $name "\" with value \"" \
   506         -            $value \"\n]
          517  +          set array($name) $value
          518  +
          519  +          tqputs $::test_channel [appendArgs \
          520  +              "---- overrode test option \"" $name "\" with value \"" \
          521  +              $value \"\n]
          522  +        } else {
          523  +          tqputs $::test_channel [appendArgs \
          524  +              "---- no value for test option \"" $name "\", ignored\n"]
          525  +        }
          526  +      } elseif {[string index $name 0] eq "-"} then {
          527  +        #
          528  +        # NOTE: Is there another list element available for the value?  If
          529  +        #       not, it does not conform to the standard command line name
          530  +        #       and value pattern.
          531  +        #
          532  +        if {$index + 1 < $length} then {
          533  +          incr index; set value [lindex $args $index]
          534  +
          535  +          tqputs $::test_channel [appendArgs \
          536  +              "---- unknown test option \"" $name "\" with value \"" \
          537  +              $value "\" ignored\n"]
          538  +        } else {
          539  +          tqputs $::test_channel [appendArgs \
          540  +              "---- no value for unknown test option \"" $name \
          541  +              "\" ignored\n"]
          542  +        }
   507    543         } else {
          544  +        #
          545  +        # NOTE: This is not an option of *any* kind that we know about.
          546  +        #       Ignore it and issue a warning.
          547  +        #
   508    548           tqputs $::test_channel [appendArgs \
   509         -            "---- unknown test option \"" $name "\" with value \"" \
   510         -            $value "\" ignored\n"]
          549  +            "---- unknown argument \"" $name "\" ignored\n"]
   511    550         }
   512    551       }
   513    552   
   514    553       #
   515    554       # NOTE: Now, attempt to flush the test log queue, if available.
   516    555       #
   517    556       tlog ""
................................................................................
   799    838       }
   800    839     }
   801    840   
   802    841     proc getTestLogId {} {
   803    842       return [expr {[info exists ::test_log_id] ? \
   804    843           [append result . $::test_log_id] : ""}]
   805    844     }
          845  +
          846  +  proc getDefaultTestLog {} {
          847  +    return [file join [getTemporaryPath] [appendArgs \
          848  +        [file tail [info nameofexecutable]] [getTestLogId] \
          849  +        .test. [pid] .log]]
          850  +  }
   806    851   
   807    852     proc getTestLog {} {
   808    853       return [expr {[info exists ::test_log] ? $::test_log : ""}]
   809    854     }
          855  +
          856  +  proc getLastTestLog {} {
          857  +    #
          858  +    # NOTE: Use the configured log file name -OR- what the configured
          859  +    #       log file name would be, by default, if it actually existed.
          860  +    #
          861  +    if {[info exists ::test_log]} then {
          862  +      set logFileName $::test_log
          863  +    } else {
          864  +      set logFileName [getDefaultTestLog]
          865  +    }
          866  +
          867  +    set logFileName [file normalize $logFileName]
          868  +    set logTime [expr {[file exists $logFileName] ? \
          869  +        [file mtime $logFileName] : 0}]
          870  +
          871  +    #
          872  +    # NOTE: Make the log file name into a pattern we can use to find
          873  +    #       the related log files.
          874  +    #
          875  +    if {[regsub -- {\.\d+\.} $logFileName {.*.} pattern]} then {
          876  +      set lastLogFile [list]
          877  +
          878  +      foreach fileName [findFiles $pattern] {
          879  +        #
          880  +        # NOTE: Skip the current test log file, if found.
          881  +        #
          882  +        if {[isSameFileName $fileName $logFileName]} then {
          883  +          continue
          884  +        }
          885  +
          886  +        #
          887  +        # NOTE: When was this log file last modified?
          888  +        #
          889  +        set time [file mtime $fileName]
          890  +
          891  +        #
          892  +        # NOTE: Check if there has been no log file seen -OR- this
          893  +        #       log file has the latest modified time seen.
          894  +        #
          895  +        if {[llength $lastLogFile] == 0 || \
          896  +            $time > [lindex $lastLogFile 0]} then {
          897  +          #
          898  +          # NOTE: This is now the latest log file seen.
          899  +          #
          900  +          set lastLogFile [list $time $fileName]
          901  +        }
          902  +      }
          903  +
          904  +      #
          905  +      # NOTE: Either return the last log file seen, if any -OR- the
          906  +      #       configured log file, if it actually exists.
          907  +      #
          908  +      if {[llength $lastLogFile] > 0} then {
          909  +        return [lindex $lastLogFile 1]
          910  +      } elseif {$logTime != 0} then {
          911  +        return $logFileName
          912  +      }
          913  +    }
          914  +
          915  +    return ""
          916  +  }
   810    917   
   811    918     proc getTestSuite {} {
   812    919       #
   813    920       # NOTE: Determine the effective test suite name and return it.  If the
   814    921       #       test suite name cannot be determined, return the default based
   815    922       #       on whether we are running in Eagle or native Tcl.
   816    923       #
................................................................................
  1078   1185     }
  1079   1186   
  1080   1187     proc isStopOnFailure {} {
  1081   1188       return [expr {[info exists ::test_stop_on_failure] && \
  1082   1189                     [string is boolean -strict $::test_stop_on_failure] && \
  1083   1190                     $::test_stop_on_failure}]
  1084   1191     }
         1192  +
         1193  +  proc isStopOnLeak {} {
         1194  +    return [expr {[info exists ::test_stop_on_leak] && \
         1195  +                  [string is boolean -strict $::test_stop_on_leak] && \
         1196  +                  $::test_stop_on_leak}]
         1197  +  }
  1085   1198   
  1086   1199     proc isExitOnComplete {} {
  1087   1200       return [expr {[info exists ::test_exit_on_complete] && \
  1088   1201                     [string is boolean -strict $::test_exit_on_complete] && \
  1089   1202                     $::test_exit_on_complete}]
  1090   1203     }
  1091   1204   
................................................................................
  1300   1413   
  1301   1414     proc recordTestStatistics { varName index } {
  1302   1415       #
  1303   1416       # NOTE: Record counts of all object types that we track.
  1304   1417       #
  1305   1418       upvar 1 $varName array
  1306   1419   
         1420  +    set array(uncounted,$index) [list]
  1307   1421       set array(time,$index) [clock seconds]
  1308   1422       set array(afters,$index) [llength [after info]]
  1309   1423       set array(variables,$index) [llength [info globals]]
  1310   1424       set array(commands,$index) [llength [info commands]]
  1311   1425       set array(procedures,$index) [llength [info procs]]
  1312   1426       set array(namespaces,$index) [llength [namespace children ::]]
  1313   1427       set array(files,$index) [llength [getFiles $::test_path *]]
  1314   1428       set array(temporaryFiles,$index) [llength [getFiles [getTemporaryPath] *]]
  1315   1429       set array(channels,$index) [llength [file channels]]
  1316   1430       set array(aliases,$index) [llength [interp aliases]]
  1317   1431       set array(interpreters,$index) [llength [interp slaves]]
  1318   1432       set array(environment,$index) [llength [array names env]]
  1319   1433   
         1434  +    #
         1435  +    # NOTE: These native resource types cannot be positively checked
         1436  +    #       for leaks (i.e. because the "leak" may be from an external
         1437  +    #       process).
         1438  +    #
         1439  +    lappend array(uncounted,$index) temporaryFiles
         1440  +
  1320   1441       if {[isEagle]} then {
  1321   1442         set array(scopes,$index) [llength [scope list]]
  1322   1443         set array(assemblies,$index) [llength [object assemblies]]
  1323   1444         set array(processes,$index) [llength [getProcesses ""]]
  1324   1445         set array(objects,$index) [llength [info objects]]
  1325   1446         set array(objectCallbacks,$index) [llength [info callbacks]]
  1326   1447         set array(objectTypes,$index) [llength [object types]]
  1327   1448         set array(objectInterfaces,$index) [llength [object interfaces]]
  1328   1449         set array(objectNamespaces,$index) [llength [object namespaces]]
  1329   1450   
         1451  +      #
         1452  +      # NOTE: These managed resource types cannot be positively checked
         1453  +      #       for leaks (i.e. because the "leak" may be from an external
         1454  +      #       process).
         1455  +      #
         1456  +      lappend array(uncounted,$index) assemblies processes
         1457  +
  1330   1458         #
  1331   1459         # NOTE: Support for some of all of these entity types may not be
  1332   1460         #       present in the interpreter, initialize all these counts
  1333   1461         #       to zero and then try to query each one individually below
  1334   1462         #       wrapped in a catch.
  1335   1463         #
  1336   1464         set array(connections,$index) 0
................................................................................
  1376   1504       #
  1377   1505       # NOTE: Show what leaked, if anything.
  1378   1506       #
  1379   1507       set count 0; upvar 1 $statsVarName array
  1380   1508   
  1381   1509       foreach statistic $statistics {
  1382   1510         if {$array($statistic,after) > $array($statistic,before)} then {
  1383         -        incr count; lappend array(statistics,leaked) $statistic
         1511  +        lappend array(statistics,leaked) $statistic
  1384   1512   
  1385   1513           tputs $channel [appendArgs "==== \"" $fileName "\" LEAKED " \
  1386   1514               $statistic \n]
  1387   1515   
  1388   1516           if {[info exists array($statistic,before,list)]} then {
  1389   1517             tputs $channel [appendArgs "---- " $statistic " BEFORE: " \
  1390   1518                 [formatList $array($statistic,before,list)] \n]
  1391   1519           }
  1392   1520   
  1393   1521           if {[info exists array($statistic,after,list)]} then {
  1394   1522             tputs $channel [appendArgs "---- " $statistic " AFTER: " \
  1395   1523                 [formatList $array($statistic,after,list)] \n]
  1396   1524           }
         1525  +
         1526  +        if {[info exists array(uncounted,before)] && \
         1527  +            [lsearch -exact $array(uncounted,before) $statistic] != -1} then {
         1528  +          continue
         1529  +        }
         1530  +
         1531  +        if {[info exists array(uncounted,after)] && \
         1532  +            [lsearch -exact $array(uncounted,after) $statistic] != -1} then {
         1533  +          continue
         1534  +        }
         1535  +
         1536  +        incr count
  1397   1537         }
  1398   1538       }
  1399   1539   
  1400   1540       #
  1401   1541       # NOTE: Make sure this file name is recorded in the list of file names with
  1402   1542       #       leaking tests.
  1403   1543       #
................................................................................
  1405   1545   
  1406   1546       if {$count > 0 && \
  1407   1547           [lsearch -exact $fileNames [file tail $fileName]] == -1} then {
  1408   1548         lappend fileNames [file tail $fileName]
  1409   1549       }
  1410   1550   
  1411   1551       #
  1412         -    # NOTE: If we are supposed to break into the debugger whenever a leak is
  1413         -    #       detected, do it now.
         1552  +    # NOTE: If we are supposed to stop or break into the debugger whenever
         1553  +    #       a leak is detected, do it now.
  1414   1554       #
  1415         -    if {$count > 0 && [isBreakOnLeak]} then {
  1416         -      testDebugBreak
         1555  +    if {$count > 0} then {
         1556  +      if {[isStopOnLeak]} then {
         1557  +        tresult Error "OVERALL RESULT: STOP-ON-LEAK\n"
         1558  +
         1559  +        unset -nocomplain ::test_suite_running
         1560  +        error ""; # no message
         1561  +      } elseif {[isBreakOnLeak]} then {
         1562  +        testDebugBreak
         1563  +      }
  1417   1564       }
  1418   1565     }
  1419   1566   
  1420   1567     proc formatList { list {default ""} {columns 1} } {
  1421   1568       if {[catch {
  1422   1569         set result ""
  1423   1570         set count 1
................................................................................
  1494   1641       #
  1495   1642       # NOTE: Perform the inverse of [lsearch -glob], attempt
  1496   1643       #       to match an element against a list of patterns.
  1497   1644       #
  1498   1645       set command [list string match]
  1499   1646       if {$noCase} then {lappend command -nocase}
  1500   1647   
  1501         -    for {set index 0} {$index < [llength $patterns]} {incr index} {
         1648  +    set length [llength $patterns]
         1649  +
         1650  +    for {set index 0} {$index < $length} {incr index} {
  1502   1651         set pattern [lindex $patterns $index]
  1503         -      if {[eval $command [list $pattern] [list $element]]} then {return $index}
         1652  +
         1653  +      if {[eval $command [list $pattern] [list $element]]} then {
         1654  +        return $index
         1655  +      }
  1504   1656       }
  1505   1657   
  1506   1658       return -1
  1507   1659     }
  1508   1660   
  1509   1661     proc removePathFromFileNames { path fileNames } {
  1510   1662       set result [list]
................................................................................
  2477   2629             after flags =$flags
  2478   2630           }
  2479   2631         } finally {
  2480   2632           interp bgerror {} $bgerror
  2481   2633         }
  2482   2634       }
  2483   2635   
  2484         -    proc testExecTclScript { script {shell ""} } {
         2636  +    proc testExecTclScript { script {shell ""} {verbose false} } {
  2485   2637         try {
  2486   2638           #
  2487   2639           # NOTE: Get a temporary file name for the script we are going to
  2488   2640           #       use to query the machine type for the native Tcl shell.
  2489   2641           #
  2490   2642           set fileName [file tempname]
  2491   2643   
................................................................................
  2509   2661                 [string length $::test_tclsh] > 0} then {
  2510   2662               set shell $::test_tclsh
  2511   2663             } else {
  2512   2664               #
  2513   2665               # NOTE: We cannot execute the native Tcl shell because one
  2514   2666               #       has not been specified, nor configured.
  2515   2667               #
  2516         -            return error
         2668  +            return [expr {$verbose ? "::test_tclsh missing" : "error"}]
  2517   2669             }
  2518   2670           }
  2519   2671   
  2520   2672           #
  2521   2673           # NOTE: Evaluate the script using the native Tcl shell, trim the
  2522   2674           #       excess whitespace from the output, and return it to the
  2523   2675           #       caller.
................................................................................
  2530   2682             #
  2531   2683             return $result
  2532   2684           } else {
  2533   2685             #
  2534   2686             # NOTE: We could not execute the native Tcl shell (perhaps one
  2535   2687             #       is not available?).
  2536   2688             #
  2537         -          return error
         2689  +          return [expr {$verbose ? [appendArgs "error: " $result] : "error"}]
  2538   2690           }
  2539   2691         } finally {
  2540   2692           #
  2541   2693           # NOTE: Did we create a temporary file?
  2542   2694           #
  2543   2695           if {[info exists fileName] && \
  2544   2696               [string length $fileName] > 0 && \
................................................................................
  2577   2729       }
  2578   2730   
  2579   2731       proc getTkVersionForTclShell { {shell ""} } {
  2580   2732         return [testExecTclScript {
  2581   2733           puts -nonewline stdout [package require Tk]; exit
  2582   2734         } $shell]
  2583   2735       }
         2736  +
         2737  +    proc evalWithTclShell { script {raw false} {shell ""} {verbose false} } {
         2738  +      return [testExecTclScript [string map \
         2739  +          [list %script% $script %raw% $raw] {
         2740  +        if {%raw%} then {
         2741  +          set code [catch {%script%} result]
         2742  +          puts -nonewline stdout [list $code $result]
         2743  +        } else {
         2744  +          puts -nonewline stdout [eval {%script%}]
         2745  +        }
         2746  +      }] $shell $verbose]
         2747  +    }
  2584   2748   
  2585   2749       proc getGarudaDll { {machine ""} } {
  2586   2750         #
  2587   2751         # NOTE: Get the Garuda DLL of the same platform (i.e. machine type)
  2588   2752         #       as the native Tcl shell.
  2589   2753         #
  2590   2754         if {[info exists ::base_path]} then {
................................................................................
  2863   3027       #
  2864   3028       exportAndImportPackageCommands [namespace current] [list \
  2865   3029           tputs tlog getSoftwareRegistryKey haveConstraint addConstraint \
  2866   3030           haveOrAddConstraint getConstraints removeConstraint fixConstraints \
  2867   3031           calculateBogoCops calculateRelativePerformance formatTimeStamp \
  2868   3032           formatElapsedTime sourceIfValid processTestArguments \
  2869   3033           getTclShellFileName getTemporaryPath getFiles getTestFiles \
  2870         -        getTestRunId getTestLogId getTestLog getTestSuite getTestMachine \
  2871         -        getTestPlatform getTestConfiguration getTestSuffix testExec \
  2872         -        testClrExec execTestShell isRandomOrder isBreakOnLeak isStopOnFailure \
  2873         -        isExitOnComplete returnInfoScript runTestPrologue runTestEpilogue \
  2874         -        hookPuts unhookPuts runTest testDebugBreak testArrayGet testShim \
  2875         -        tsource recordTestStatistics reportTestStatistics formatList \
  2876         -        formatListAsDict pathToRegexp inverseLsearchGlob \
  2877         -        removePathFromFileNames formatDecimal clearTestPercent \
  2878         -        reportTestPercent runAllTests isTestSuiteRunning configureTcltest \
  2879         -        machineToPlatform getPassPercentage getSkipPercentage] false false
         3034  +        getTestRunId getTestLogId getDefaultTestLog getTestLog getLastTestLog \
         3035  +        getTestSuite getTestMachine getTestPlatform getTestConfiguration \
         3036  +        getTestSuffix testExec testClrExec execTestShell isRandomOrder \
         3037  +        isBreakOnLeak isStopOnFailure isStopOnLeak isExitOnComplete \
         3038  +        returnInfoScript runTestPrologue runTestEpilogue hookPuts unhookPuts \
         3039  +        runTest testDebugBreak testArrayGet testShim tsource \
         3040  +        recordTestStatistics reportTestStatistics formatList formatListAsDict \
         3041  +        pathToRegexp inverseLsearchGlob removePathFromFileNames formatDecimal \
         3042  +        clearTestPercent reportTestPercent runAllTests isTestSuiteRunning \
         3043  +        configureTcltest machineToPlatform getPassPercentage \
         3044  +        getSkipPercentage] false false
  2880   3045   
  2881   3046       ###########################################################################
  2882   3047       ############################## END Tcl ONLY ###############################
  2883   3048       ###########################################################################
  2884   3049     }
  2885   3050   
  2886   3051     #
  2887   3052     # NOTE: Provide the Eagle test package to the interpreter.
  2888   3053     #
  2889   3054     package provide Eagle.Test \
  2890   3055       [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
  2891   3056   }
  2892   3057   

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

   244    244       ###########################################################################
   245    245   
   246    246       if {![isEagle]} then {
   247    247         #
   248    248         # BUGFIX: We do not normally want to skip any Mono bugs in native Tcl.
   249    249         #
   250    250         if {![info exists ::no(runtimeVersion)]} then {
   251         -        set constraints [list monoToDo monoBug monoCrash]
   252         -
   253    251           #
   254    252           # NOTE: Add the necessary constraints for each version of Mono that
   255    253           #       we know about.
   256    254           #
   257    255           foreach monoVersion [getKnownMonoVersions] {
   258    256             set constraintVersion [join $monoVersion ""]
   259    257   
   260    258             addConstraint [appendArgs monoToDo $constraintVersion]
          259  +          addConstraint [appendArgs monoToDo $constraintVersion Only]
   261    260             addConstraint [appendArgs monoBug $constraintVersion]
          261  +          addConstraint [appendArgs monoBug $constraintVersion Only]
   262    262             addConstraint [appendArgs monoCrash $constraintVersion]
          263  +          addConstraint [appendArgs monoCrash $constraintVersion Only]
   263    264           }
   264    265   
   265    266           #
   266    267           # NOTE: Also add just the generic Mono constraints that do not have
   267    268           #       a trailing version.
   268    269           #
          270  +        set constraints [list monoToDo monoBug monoCrash]
          271  +
   269    272           foreach constraint $constraints {
   270    273             addConstraint $constraint
   271    274           }
   272    275         }
   273    276       }
   274    277     }
   275    278   
................................................................................
   767    770         #
   768    771         if {$::tcl_version eq "8.4"} then {
   769    772           #
   770    773           # NOTE: Baseline reported language and feature
   771    774           #       version.
   772    775           #
   773    776           addConstraint tcl84
   774         -        addConstraint tcl84OrHigher
   775    777           addConstraint tcl84Feature
          778  +        addConstraint tcl84OrLower
          779  +        addConstraint tcl84OrHigher
          780  +        addConstraint tcl85OrLower
   776    781   
   777    782           if {[isEagle]} then {
   778    783             #
   779    784             # NOTE: *EAGLE* We do want to include any
   780    785             #       tests that target "Tcl 8.5 or higher"
   781    786             #       features and/or "Tcl 8.6 or higher"
   782    787             #       features because they would not be in
................................................................................
   789    794           }
   790    795         } elseif {$::tcl_version eq "8.5"} then {
   791    796           #
   792    797           # NOTE: Baseline reported language and feature
   793    798           #       version.  Tcl 8.5 includes all the
   794    799           #       features from itself and Tcl 8.4.
   795    800           #
   796         -        addConstraint tcl85
          801  +        addConstraint tcl84Feature
   797    802           addConstraint tcl84OrHigher
   798         -        addConstraint tcl85OrHigher
   799         -        addConstraint tcl84Feature
          803  +        addConstraint tcl85
   800    804           addConstraint tcl85Feature
          805  +        addConstraint tcl85OrLower
          806  +        addConstraint tcl85OrHigher
   801    807   
   802    808           if {[isEagle]} then {
   803    809             #
   804    810             # NOTE: *EAGLE* We do want to include any
   805    811             #       tests that target "Tcl 8.5 or higher"
   806    812             #       features and/or "Tcl 8.6 or higher"
   807    813             #       features because they would not be in
................................................................................
   814    820         } elseif {$::tcl_version eq "8.6"} then {
   815    821           #
   816    822           # NOTE: Baseline reported language and feature
   817    823           #       version.  Tcl 8.6 includes all the
   818    824           #       features from itself Tcl 8.4, and Tcl
   819    825           #       8.5.
   820    826           #
   821         -        addConstraint tcl86
          827  +        addConstraint tcl84Feature
   822    828           addConstraint tcl84OrHigher
          829  +        addConstraint tcl85Feature
   823    830           addConstraint tcl85OrHigher
   824         -        addConstraint tcl86OrHigher
   825         -        addConstraint tcl84Feature
   826         -        addConstraint tcl85Feature
          831  +        addConstraint tcl86
   827    832           addConstraint tcl86Feature
          833  +        addConstraint tcl86OrLower
          834  +        addConstraint tcl86OrHigher
   828    835         }
   829    836   
   830    837         tputs $channel [appendArgs $::tcl_version \n]
   831    838       } else {
   832    839         tputs $channel no\n
   833    840       }
   834    841     }
................................................................................
   848    855   
   849    856         tputs $channel yes\n
   850    857       } else {
   851    858         tputs $channel no\n
   852    859       }
   853    860     }
   854    861   
   855         -  proc checkForNamespaces { channel } {
          862  +  proc checkForNamespaces { channel quiet } {
   856    863       tputs $channel "---- checking for namespace support... "
   857    864   
   858    865       if {[isEagle]} then {
   859    866         #
   860    867         # NOTE: Check if namespace support was compiled into the core library
   861    868         #       (i.e. this is beta 30 or later).
   862    869         #
................................................................................
   887    894           } else {
   888    895             tputs $channel disabled\n
   889    896   
   890    897             #
   891    898             # NOTE: Check if namespace support was compiled into the core
   892    899             #       library (i.e. is this beta 30 or later).
   893    900             #
   894         -          if {$available} then {
          901  +          if {!$quiet && $available} then {
   895    902               #
   896    903               # NOTE: The tests seem to be running with namespace support
   897    904               #       available, but disabled.  Emit a warning into the
   898    905               #       test log file.
   899    906               #
   900    907               tputs $channel \
   901    908                   "==== WARNING: running with namespaces available and disabled\n"
................................................................................
   912    919         addConstraint namespaces.available
   913    920         addConstraint namespaces
   914    921   
   915    922         tputs $channel enabled\n
   916    923       }
   917    924     }
   918    925   
   919         -  proc checkForTestExec { channel } {
          926  +  proc checkForTestExec { channel quiet } {
   920    927       tputs $channel "---- checking for test use of \"exec\" command... "
   921    928   
   922    929       set procName [lindex [info level [info level]] 0]
   923    930   
   924    931       if {![info exists ::no(testExec)] && [canTestExec $procName]} then {
   925    932         addConstraint testExec
   926    933   
   927    934         tputs $channel yes\n
   928    935   
   929         -      if {[info exists ::no(exec)]} then {
          936  +      if {!$quiet && [info exists ::no(exec)]} then {
   930    937           tputs $channel \
   931    938               "==== WARNING: running with the \"testExec\" procedure disabled\n"
   932    939         }
   933    940       } else {
   934    941         tputs $channel no\n
   935    942       }
   936    943     }
................................................................................
  1250   1257         addConstraint tip426
  1251   1258   
  1252   1259         tputs $channel yes\n
  1253   1260       } else {
  1254   1261         tputs $channel no\n
  1255   1262       }
  1256   1263     }
         1264  +
         1265  +  proc checkForTip429 { channel } {
         1266  +    tputs $channel "---- checking for TIP #429... "
         1267  +
         1268  +    #
         1269  +    # NOTE: Is the interpreter TIP #429 ready?
         1270  +    #
         1271  +    if {[catch {string cat}] == 0} then {
         1272  +      addConstraint tip429
         1273  +
         1274  +      tputs $channel yes\n
         1275  +    } else {
         1276  +      tputs $channel no\n
         1277  +    }
         1278  +  }
  1257   1279   
  1258   1280     proc checkForTiming {
  1259   1281             channel threshold {constraint ""} {tries 1} {delay 1000}
  1260   1282             {average false} {asynchronous false} } {
  1261   1283       tputs $channel [appendArgs \
  1262   1284           "---- checking for precision timing (threshold of " $threshold \
  1263   1285           " milliseconds" [expr {$average ? " average" : ""}] ", delay of " \
................................................................................
  1393   1415   
  1394   1416           tputs $channel yes\n
  1395   1417         }
  1396   1418       } else {
  1397   1419         tputs $channel no\n
  1398   1420       }
  1399   1421     }
         1422  +
         1423  +  proc checkForMemoryIntensive { channel } {
         1424  +    tputs $channel "---- checking for memory intensive testing... "
         1425  +
         1426  +    #
         1427  +    # NOTE: Are we allowed to do memory intensive testing?
         1428  +    #
         1429  +    if {![info exists ::no(memoryIntensive)]} then {
         1430  +      addConstraint memoryIntensive
         1431  +
         1432  +      tputs $channel yes\n
         1433  +    } else {
         1434  +      tputs $channel no\n
         1435  +    }
         1436  +  }
  1400   1437   
  1401   1438     proc checkForStackIntensive { channel } {
  1402   1439       tputs $channel "---- checking for stack intensive testing... "
  1403   1440   
  1404   1441       #
  1405   1442       # NOTE: Are we allowed to do stack intensive testing?
  1406   1443       #
................................................................................
  2035   2072                 set constraintVersion [join $monoVersion ""]
  2036   2073   
  2037   2074                 addConstraint [appendArgs mono $constraintVersion OrHigher]
  2038   2075                 addConstraint [appendArgs monoToDo $constraintVersion]
  2039   2076                 addConstraint [appendArgs monoBug $constraintVersion]
  2040   2077                 addConstraint [appendArgs monoCrash $constraintVersion]
  2041   2078               }
         2079  +
         2080  +            #
         2081  +            # NOTE: Check all known versions of Mono for an exact match with
         2082  +            #       the currently running one.
         2083  +            #
         2084  +            foreach monoVersion [getKnownMonoVersions] {
         2085  +              #
         2086  +              # NOTE: Check if Mono major/minor version is exactly the one
         2087  +              #       we are currently processing.
         2088  +              #
         2089  +              set constraintVersion [join $monoVersion ""]
         2090  +
         2091  +              if {[lindex $monoVersion 0] == $majorVersion && \
         2092  +                  [lindex $monoVersion 1] == $minorVersion} then {
         2093  +                #
         2094  +                # NOTE: Add test constraints that only apply to this exact
         2095  +                #       version of Mono.
         2096  +                #
         2097  +                addConstraint [appendArgs mono $constraintVersion Only]
         2098  +              } else {
         2099  +                #
         2100  +                # NOTE: Add test constraints that apply to all versions of
         2101  +                #       Mono except this exact version.
         2102  +                #
         2103  +                addConstraint [appendArgs monoToDo $constraintVersion Only]
         2104  +                addConstraint [appendArgs monoBug $constraintVersion Only]
         2105  +                addConstraint [appendArgs monoCrash $constraintVersion Only]
         2106  +              }
         2107  +            }
  2042   2108             }
  2043   2109           } else {
  2044   2110             #
  2045   2111             # NOTE: If the runtime version was found, add a test constraint
  2046   2112             #       for it now.
  2047   2113             #
  2048   2114             if {[string length $version] > 0} then {
................................................................................
  2059   2125             #       necessary constraints for each version of Mono we know
  2060   2126             #       about.
  2061   2127             #
  2062   2128             foreach monoVersion [getKnownMonoVersions] {
  2063   2129               set constraintVersion [join $monoVersion ""]
  2064   2130   
  2065   2131               addConstraint [appendArgs monoToDo $constraintVersion]
         2132  +            addConstraint [appendArgs monoToDo $constraintVersion Only]
  2066   2133               addConstraint [appendArgs monoBug $constraintVersion]
         2134  +            addConstraint [appendArgs monoBug $constraintVersion Only]
  2067   2135               addConstraint [appendArgs monoCrash $constraintVersion]
         2136  +            addConstraint [appendArgs monoCrash $constraintVersion Only]
  2068   2137             }
  2069   2138           }
  2070   2139   
  2071   2140           tputs $channel [appendArgs $::eagle_platform(runtimeVersion) \
  2072   2141               " " ( $dotVersion ) \n]
  2073   2142         } else {
  2074   2143           tputs $channel no\n
................................................................................
  2181   2250   
  2182   2251           tputs $channel [appendArgs $culture \n]
  2183   2252         } else {
  2184   2253           tputs $channel unknown\n
  2185   2254         }
  2186   2255       }
  2187   2256   
  2188         -    proc checkForQuiet { channel } {
  2189         -      tputs $channel "---- checking for quiet... "
         2257  +    proc checkForQuiet { channel quiet } {
         2258  +      if {!$quiet} then {
         2259  +        tputs $channel "---- checking for quiet... "
         2260  +      }
  2190   2261   
  2191         -      if {[catch {object invoke Interpreter.GetActive Quiet} quiet] == 0 && \
  2192         -          $quiet} then {
         2262  +      if {[catch {
         2263  +        object invoke Interpreter.GetActive Quiet
         2264  +      } isQuiet] == 0 && $isQuiet} then {
  2193   2265           #
  2194   2266           # NOTE: Yes, quiet mode is enabled.
  2195   2267           #
  2196   2268           addConstraint quiet
  2197   2269   
  2198         -        tputs $channel yes\n
         2270  +        if {!$quiet} then {
         2271  +          tputs $channel yes\n
         2272  +        }
  2199   2273         } else {
  2200         -        tputs $channel no\n
         2274  +        if {!$quiet} then {
         2275  +          tputs $channel no\n
         2276  +        }
  2201   2277         }
  2202   2278       }
  2203   2279   
  2204   2280       proc checkForReferenceCountTracking { channel } {
  2205   2281         tputs $channel "---- checking for object reference count tracking... "
  2206   2282   
  2207   2283         if {[info exists ::eagle_platform(compileOptions)] && \
................................................................................
  3116   3192           checkForTclOptions checkForWindowsCommandProcessor checkForFossil \
  3117   3193           checkForEagle checkForSymbols checkForLogFile checkForGaruda \
  3118   3194           checkForShell checkForDebug checkForTk checkForVersion \
  3119   3195           checkForCommand checkForNamespaces checkForTestExec \
  3120   3196           checkForTestMachine checkForTestPlatform checkForTestConfiguration \
  3121   3197           checkForTestSuffix checkForFile checkForPathFile checkForNativeCode \
  3122   3198           checkForTip127 checkForTip194 checkForTip207 checkForTip241 \
  3123         -        checkForTip285 checkForTip405 checkForTip426 checkForTiming \
  3124         -        checkForPerformance checkForBigLists checkForStackIntensive \
  3125         -        checkForInteractive checkForInteractiveCommand \
  3126         -        checkForUserInteraction checkForNetwork checkForCompileOption \
  3127         -        checkForKnownCompileOptions] false false
         3199  +        checkForTip285 checkForTip405 checkForTip426 checkForTip429 \
         3200  +        checkForTiming checkForPerformance checkForBigLists \
         3201  +        checkForMemoryIntensive checkForStackIntensive checkForInteractive \
         3202  +        checkForInteractiveCommand checkForUserInteraction checkForNetwork \
         3203  +        checkForCompileOption checkForKnownCompileOptions] false false
  3128   3204   
  3129   3205       ###########################################################################
  3130   3206       ############################## END Tcl ONLY ###############################
  3131   3207       ###########################################################################
  3132   3208     }
  3133   3209   
  3134   3210     #
  3135   3211     # NOTE: Provide the Eagle test constraints package to the interpreter.
  3136   3212     #
  3137   3213     package provide Eagle.Test.Constraints \
  3138   3214       [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
  3139   3215   }
  3140   3216   

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

    89     89       }
    90     90   
    91     91       unset pkg_dir
    92     92     }
    93     93   
    94     94     #############################################################################
    95     95   
           96  +  #
           97  +  # NOTE: Set the location of the Eagle main strong name keys directory,
           98  +  #       if necessary.
           99  +  #
          100  +  if {![info exists key_path]} then {
          101  +    #
          102  +    # NOTE: Normally, there should be a "Keys" sub-directory just within
          103  +    #       the base directory.
          104  +    #
          105  +    set key_path [file join $base_path Keys]
          106  +  }
          107  +
          108  +  #############################################################################
          109  +
    96    110     #
    97    111     # NOTE: Set the executable file name for the process, if
    98    112     #       necessary.
    99    113     #
   100    114     if {![info exists bin_file]} then {
   101    115       set bin_file [info nameofexecutable]
   102    116     }
................................................................................
   282    296     set test_flags(-skip) [list]; # default to skipping no tests.
   283    297     set test_flags(-constraints) [list]; # default to no manual constraints.
   284    298     set test_flags(-logFile) ""; # default to using standard log file naming.
   285    299     set test_flags(-threshold) ""; # default to requiring all tests to pass.
   286    300     set test_flags(-randomOrder) ""; # default to deterministic order.
   287    301     set test_flags(-breakOnLeak) ""; # default to continue on leak.
   288    302     set test_flags(-stopOnFailure) ""; # default to continue on failure.
          303  +  set test_flags(-stopOnLeak) ""; # default to continue on leak.
   289    304     set test_flags(-exitOnComplete) ""; # default to not exit after complete.
   290    305     set test_flags(-preTest) ""; # default to not evaluating anything.
   291    306     set test_flags(-postTest) ""; # default to not evaluating anything.
   292    307     set test_flags(-tclsh) ""; # Tcl shell, default to empty.
   293    308   
   294    309     #
   295    310     # NOTE: Check for and process any command line arguments.
................................................................................
   350    365           [string is boolean -strict $test_flags(-stopOnFailure)]} then {
   351    366         #
   352    367         # NOTE: Set the test stop-on-failure flag to the one provided by the
   353    368         #       command line.
   354    369         #
   355    370         set test_stop_on_failure $test_flags(-stopOnFailure)
   356    371       }
          372  +
          373  +    if {[info exists test_flags(-stopOnLeak)] && \
          374  +        [string is boolean -strict $test_flags(-stopOnLeak)]} then {
          375  +      #
          376  +      # NOTE: Set the test stop-on-leak flag to the one provided by the
          377  +      #       command line.
          378  +      #
          379  +      set test_stop_on_leak $test_flags(-stopOnLeak)
          380  +    }
   357    381   
   358    382       if {[info exists test_flags(-exitOnComplete)] && \
   359    383           [string is boolean -strict $test_flags(-exitOnComplete)]} then {
   360    384         #
   361    385         # NOTE: Set the test exit-on-complete flag to the one provided by the
   362    386         #       command line.
   363    387         #
................................................................................
   414    438     # NOTE: Has automatic log file naming been disabled?
   415    439     #
   416    440     if {![info exists no(logFileName)]} then {
   417    441       #
   418    442       # NOTE: Set the log to use for test output, if necessary.
   419    443       #
   420    444       if {![info exists test_log]} then {
   421         -      set test_log [file join [getTemporaryPath] [appendArgs [file tail [info \
   422         -          nameofexecutable]] [getTestLogId] .test. [pid] .log]]
          445  +      set test_log [getDefaultTestLog]
   423    446       }
   424    447     }
          448  +
          449  +  #############################################################################
          450  +
          451  +  #
          452  +  # NOTE: *SPECIAL* This test constraint must be checked first as it can
          453  +  #       determine if subsequent ones will emit warnings.  This is only
          454  +  #       applicable to Eagle.
          455  +  #
          456  +  if {[isEagle]} then {
          457  +    #
          458  +    # NOTE: Has quiet testing support been disabled?
          459  +    #
          460  +    if {![info exists no(preQuiet)]} then {
          461  +      #
          462  +      # NOTE: There are checks for the "quiet" test constraint prior to
          463  +      #       the real test constraints being initialized.  Prepare for
          464  +      #       those checks now.  This will have to be repeated later,
          465  +      #       after the real test constraints are initialized.
          466  +      #
          467  +      checkForQuiet $test_channel true
          468  +    }
          469  +  }
          470  +
          471  +  #############################################################################
   425    472   
   426    473     #
   427    474     # NOTE: Has native Tcl shell detection and use been disabled?
   428    475     #
   429    476     if {![info exists no(tclsh)]} then {
   430    477       #
   431    478       # NOTE: Set the Tcl shell executable to use for those specialized
................................................................................
   449    496           } else {
   450    497             if {[canExecTclShell] && \
   451    498                 ![info exists no(getTclShellFileName)]} then {
   452    499               #
   453    500               # NOTE: Attempt to automatically select the native Tcl shell
   454    501               #       to use.
   455    502               #
   456         -            if {![info exists no(warningForTclShell)]} then {
          503  +            if {![info exists no(warningForTclShell)] && \
          504  +                ![haveConstraint quiet]} then {
   457    505                 tputs $test_channel \
   458    506                     "==== WARNING: attempting automatic Tcl shell selection...\n"
   459    507               }
   460    508   
   461    509               set test_tclsh [getTclShellFileName true]
   462    510             } else {
   463    511               #
................................................................................
   475    523     #
   476    524     # NOTE: When running in Eagle, check for any non-core plugins loaded into
   477    525     #       the interpreter and issue warnings if any are found.  The warning
   478    526     #       may be used to explain subsequent test failures due to the extra
   479    527     #       plugins being loaded (i.e. there are some tests are sensitive to
   480    528     #       having "unexpected" plugins loaded).
   481    529     #
   482         -  if {[isEagle] && ![info exists no(warningForPlugin)]} then {
          530  +  if {[isEagle] && ![info exists no(warningForPlugin)] && \
          531  +      ![haveConstraint quiet]} then {
   483    532       foreach loaded [info loaded] {
   484    533         #
   485    534         # HACK: This code assumes that all plugins in the "Eagle._Plugins"
   486    535         #       namespace belong to the Eagle core library itself.
   487    536         #
   488    537         if {![string match Eagle._Plugins.* [lindex $loaded 1]]} then {
   489    538           tputs $test_channel [appendArgs \
................................................................................
   579    628         [expr {[info exists test_configuration] ? \
   580    629             $test_configuration : "<none>"}] \n]
   581    630   
   582    631     tputs $test_channel [appendArgs "---- test suffix: " \
   583    632         [expr {[info exists test_suffix] ? \
   584    633             $test_suffix : "<none>"}] \n]
   585    634   
   586         -  if {[isEagle] && ![info exists no(warningForStrongName)]} then {
   587         -    catch {info engine PublicKeyToken} publicKeyToken
   588         -
   589         -    if {[string length $publicKeyToken] == 0} then {
   590         -      #
   591         -      # NOTE: The Eagle core library is not strong name signed.  This is not an
   592         -      #       error, per se; however, it may cause some tests to fail and it
   593         -      #       should be reported to the user and noted in the test suite log
   594         -      #       file.
   595         -      #
   596         -      tputs $test_channel \
   597         -          "==== WARNING: running without any strong name signature...\n"
   598         -    } else {
   599         -      #
   600         -      # BUGBUG: Tcl 8.4 does not like this expression because it contains the
   601         -      #         "ni" operator (and Tcl tries to compile it even though it will
   602         -      #         only actually ever be evaluated in Eagle).
   603         -      #
   604         -      set expr {$publicKeyToken ni \
   605         -          "29c6297630be05eb 1e22ec67879739a2 358030063a832bc3"}
   606         -
   607         -      if {[expr $expr]} then {
   608         -        #
   609         -        # NOTE: The Eagle core library is strong name signed with a key that is
   610         -        #       not official.  This is also not an error, per se; however, it
   611         -        #       may cause some tests to fail and it should be reported to the
   612         -        #       user and noted in the test suite log file.
   613         -        #
   614         -        tputs $test_channel [appendArgs \
   615         -            "==== WARNING: running without official strong name signature: " \
   616         -            $publicKeyToken \n]
   617         -      }
   618         -
   619         -      unset expr
   620         -    }
   621         -
   622         -    unset publicKeyToken
   623         -
          635  +  if {[isEagle]} then {
   624    636       tputs $test_channel [appendArgs "---- original command line: " \
   625    637           [info cmdline] \n]
   626    638   
   627    639       tputs $test_channel [appendArgs "---- threadId: " \
   628    640           [info tid] \n]
   629    641   
   630    642       tputs $test_channel [appendArgs "---- processors: " \
................................................................................
   693    705             [string is boolean -strict $test_break_on_leak] ? \
   694    706                 $test_break_on_leak : "<none>"}] \n]
   695    707   
   696    708     tputs $test_channel [appendArgs "---- stop on failure: " \
   697    709         [expr {[info exists test_stop_on_failure] && \
   698    710             [string is boolean -strict $test_stop_on_failure] ? \
   699    711                 $test_stop_on_failure : "<none>"}] \n]
          712  +
          713  +  tputs $test_channel [appendArgs "---- stop on leak: " \
          714  +      [expr {[info exists test_stop_on_leak] && \
          715  +          [string is boolean -strict $test_stop_on_leak] ? \
          716  +              $test_stop_on_leak : "<none>"}] \n]
   700    717   
   701    718     tputs $test_channel [appendArgs "---- exit on complete: " \
   702    719         [expr {[info exists test_exit_on_complete] && \
   703    720             [string is boolean -strict $test_exit_on_complete] ? \
   704    721                 $test_exit_on_complete : "<none>"}] \n]
   705    722   
   706    723     #
................................................................................
   741    758   
   742    759     tputs $test_channel [appendArgs "---- path: " \
   743    760         [expr {[info exists path] && [string length $path] > 0 ? \
   744    761             [appendArgs \" $path \"] : "<none>"}] \n]
   745    762   
   746    763     tputs $test_channel [appendArgs "---- base path: \"" \
   747    764         $base_path \"\n]
          765  +
          766  +  tputs $test_channel [appendArgs "---- key path: \"" \
          767  +      $key_path \"\n]
   748    768   
   749    769     tputs $test_channel [appendArgs "---- root path: \"" \
   750    770         $root_path \"\n]
   751    771   
   752    772     tputs $test_channel [appendArgs "---- binary path: \"" \
   753    773         $bin_path \"\n]
   754    774   
................................................................................
   774    794     tputs $test_channel [appendArgs "---- disabled options: " \
   775    795         [formatList [lsort [array names no]] <none>] \n]
   776    796   
   777    797     #
   778    798     # NOTE: Initialize the Eagle test constraints.
   779    799     #
   780    800     if {[isEagle]} then {
          801  +    #
          802  +    # NOTE: *WARNING* This has the effect of removing test constraints
          803  +    #       added prior to this point.
          804  +    #
   781    805       initializeTests; configureTcltest [list] [list] [list] [list] false
   782    806   
   783    807       #
   784    808       # NOTE: If the "no(mono)" variable is set (to anything) then any
   785    809       #       special test suite hacks for Mono will be disabled. This
   786    810       #       does not control or change any hacks for Mono that may
   787    811       #       be present in the library itself.
................................................................................
   792    816   
   793    817       ###########################################################################
   794    818       ######################### BEGIN Eagle Constraints #########################
   795    819       ###########################################################################
   796    820   
   797    821       tputs $test_channel \
   798    822           "---- start of Eagle specific test constraints...\n"
          823  +
          824  +    #
          825  +    # NOTE: *WARNING* Has quiet testing support been disabled?
          826  +    #       Please do not move this "quietness" test constraint
          827  +    #       check as subsequent test constraints may rely on it
          828  +    #       when determining if a warning should be emitted.
          829  +    #
          830  +    if {![info exists no(quiet)]} then {
          831  +      #
          832  +      # NOTE: For tests "basic-1.36", "benchmark-1.*", "debug-1.3",
          833  +      #       "debug-1.4", "glob-99.*", "object-10.*", "perf-2.2",
          834  +      #       and various other places within the test suite code
          835  +      #       itself.
          836  +      #
          837  +      checkForQuiet $test_channel false
          838  +    }
          839  +
          840  +    #
          841  +    # NOTE: Has strong name key detection been disabled?
          842  +    #
          843  +    if {![info exists no(strongNameKey)]} then {
          844  +      catch {info engine PublicKeyToken} publicKeyToken
          845  +
          846  +      if {[string length $publicKeyToken] == 0} then {
          847  +        #
          848  +        # NOTE: The Eagle core library is not signed with a strong name key.
          849  +        #       This is not an error, per se; however, it may cause selected
          850  +        #       tests to fail and it should be reported to the user and noted
          851  +        #       in the test suite log file.
          852  +        #
          853  +        addConstraint strongName.none
          854  +
          855  +        if {![info exists no(warningForStrongNameKey)] && \
          856  +            ![haveConstraint quiet]} then {
          857  +          tputs $test_channel \
          858  +              "==== WARNING: no Eagle strong name signature detected...\n"
          859  +        }
          860  +      } else {
          861  +        #
          862  +        # NOTE: Add a test constraint for this specific strong name key.
          863  +        #
          864  +        addConstraint [appendArgs strongName. $publicKeyToken]
          865  +
          866  +        #
          867  +        # BUGBUG: Tcl 8.4 does not seem to like this expression because it
          868  +        #         contains the "ni" operator added in Tcl 8.5 (and Tcl 8.4
          869  +        #         tries to compile it even though it will only be evaluated
          870  +        #         in Eagle).
          871  +        #
          872  +        set expr {$publicKeyToken ni \
          873  +            "29c6297630be05eb 1e22ec67879739a2 358030063a832bc3"}
          874  +
          875  +        if {[expr $expr]} then {
          876  +          #
          877  +          # NOTE: The Eagle core library is strong name signed with a key that
          878  +          #       is not official.  This is also not an error, per se; however,
          879  +          #       it may cause some tests to fail and it should be reported to
          880  +          #       the user and noted in the test suite log file.
          881  +          #
          882  +          addConstraint strongName.unofficial
          883  +
          884  +          if {![info exists no(warningForStrongNameKey)] && \
          885  +              ![haveConstraint quiet]} then {
          886  +            tputs $test_channel [appendArgs \
          887  +                "==== WARNING: unofficial Eagle strong name signature " \
          888  +                "detected: " $publicKeyToken \n]
          889  +          }
          890  +        } else {
          891  +          #
          892  +          # NOTE: Several tests require one of the official strong name keys to
          893  +          #       be used in order for them to pass.
          894  +          #
          895  +          addConstraint strongName.official
          896  +
          897  +          tputs $test_channel [appendArgs \
          898  +              "---- official Eagle strong name signature detected: " \
          899  +              $publicKeyToken \n]
          900  +        }
          901  +
          902  +        unset expr
          903  +      }
          904  +
          905  +      unset publicKeyToken
          906  +    }
   799    907   
   800    908       #
   801    909       # NOTE: Has administrator detection support been disabled?  We do
   802    910       #       this check [nearly] first as it may [eventually] be used
   803    911       #       to help determine if other constraints should be skipped.
   804    912       #
   805    913       if {![info exists no(administrator)]} then {
................................................................................
  1011   1119       #
  1012   1120       # NOTE: Has symbol testing support been disabled?
  1013   1121       #
  1014   1122       if {![info exists no(assemblySymbols)]} then {
  1015   1123         checkForSymbols $test_channel [lindex [info assembly] end]
  1016   1124       }
  1017   1125   
  1018         -    #
  1019         -    # NOTE: Has quiet testing support been disabled?
  1020         -    #
  1021         -    if {![info exists no(quiet)]} then {
  1022         -      #
  1023         -      # NOTE: For tests "basic-1.36", "debug-1.3", "debug-1.4", "object-10.*",
  1024         -      #       and "perf-2.2".
  1025         -      #
  1026         -      checkForQuiet $test_channel
  1027         -    }
  1028         -
  1029   1126       #
  1030   1127       # NOTE: Has object handle reference count tracking support been disabled
  1031   1128       #       (at compile-time)?
  1032   1129       #
  1033   1130       if {![info exists no(refCount)]} then {
  1034   1131         #
  1035   1132         # NOTE: For tests "excel-*", "object-2.*", "object-7.1", "object-8.*",
................................................................................
  1514   1611           checkForObjectMember $test_channel Eagle._Tests.Default \
  1515   1612               *TestSetVariableLinks*
  1516   1613   
  1517   1614           checkForObjectMember $test_channel Eagle._Tests.Default \
  1518   1615               *TestUnsetVariableLinks*
  1519   1616         }
  1520   1617   
         1618  +      #
         1619  +      # NOTE: Has system array variable testing support been disabled?
         1620  +      #
         1621  +      if {![info exists no(testSystemArrayVariables)]} then {
         1622  +        #
         1623  +        # NOTE: For tests "basic-1.62", "basic-1.63", "basic-1.64",
         1624  +        #       and "basic-1.65".
         1625  +        #
         1626  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1627  +            *TestIntPtrChangeTypeCallback*
         1628  +
         1629  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1630  +            *TestSetVariableSystemArray*
         1631  +
         1632  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1633  +            *TestUnsetVariableSystemArray*
         1634  +      }
         1635  +
  1521   1636         #
  1522   1637         # NOTE: Has field testing support been disabled?
  1523   1638         #
  1524   1639         if {![info exists no(testFields)]} then {
  1525   1640           #
  1526   1641           # NOTE: For tests "basic-1.39", "basic-1.40", "basic-1.41",
  1527   1642           #       "basic-1.42", and "basic-1.43".
................................................................................
  1584   1699   
  1585   1700           #
  1586   1701           # NOTE: For test "object-2.1".
  1587   1702           #
  1588   1703           checkForObjectMember $test_channel Eagle._Tests.Default \
  1589   1704               *TestComplexMethod*
  1590   1705   
         1706  +        #
         1707  +        # NOTE: For test "object-2.12".
         1708  +        #
         1709  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1710  +            *TestMoreComplexMethod*
         1711  +
  1591   1712           #
  1592   1713           # NOTE: For test "object-2.3".
  1593   1714           #
  1594   1715           checkForObjectMember $test_channel Eagle._Tests.Default \
  1595   1716               *TestToHexadecimalString*
  1596   1717   
  1597   1718           checkForObjectMember $test_channel Eagle._Tests.Default \
................................................................................
  2022   2143       checkForTestSuiteFiles $test_channel
  2023   2144     }
  2024   2145   
  2025   2146     #
  2026   2147     # NOTE: Has all use of [exec] for tests been disabled?
  2027   2148     #
  2028   2149     if {![info exists no(checkForTestExec)]} then {
  2029         -    checkForTestExec $test_channel
         2150  +    checkForTestExec $test_channel [haveConstraint quiet]
  2030   2151     }
  2031   2152   
  2032   2153     #
  2033   2154     # NOTE: Has checking for the test machine been disabled?
  2034   2155     #
  2035   2156     if {![info exists no(testMachine)]} then {
  2036   2157       checkForTestMachine $test_channel
................................................................................
  2329   2450     if {![info exists no(tclOptions)]} then {
  2330   2451       checkForTclOptions $test_channel
  2331   2452     }
  2332   2453   
  2333   2454     if {![info exists no(checkForBigLists)]} then {
  2334   2455       checkForBigLists $test_channel
  2335   2456     }
         2457  +
         2458  +  if {![info exists no(checkForMemoryIntensive)]} then {
         2459  +    checkForMemoryIntensive $test_channel
         2460  +  }
  2336   2461   
  2337   2462     if {![info exists no(checkForStackIntensive)]} then {
  2338   2463       checkForStackIntensive $test_channel
  2339   2464     }
  2340   2465   
  2341   2466     if {![info exists no(windowsCommandProcessor)]} then {
  2342   2467       checkForWindowsCommandProcessor $test_channel cmd.exe
................................................................................
  2419   2544       checkForCommand $test_channel xml
  2420   2545     }
  2421   2546   
  2422   2547     #
  2423   2548     # NOTE: Has namespace detection support been disabled?
  2424   2549     #
  2425   2550     if {![info exists no(namespaces)]} then {
  2426         -    checkForNamespaces $test_channel
         2551  +    checkForNamespaces $test_channel [haveConstraint quiet]
  2427   2552     }
  2428   2553   
  2429   2554     #
  2430   2555     # NOTE: Check for various features that were added through
  2431   2556     #       the TIP process.
  2432   2557     #
  2433   2558     if {![info exists no(tip127)]} then {
................................................................................
  2454   2579       checkForTip405 $test_channel
  2455   2580     }
  2456   2581   
  2457   2582     if {![info exists no(tip426)]} then {
  2458   2583       checkForTip426 $test_channel
  2459   2584     }
  2460   2585   
         2586  +  if {![info exists no(tip429)]} then {
         2587  +    checkForTip429 $test_channel
         2588  +  }
         2589  +
  2461   2590     #
  2462   2591     # NOTE: Has performance testing been disabled?
  2463   2592     #
  2464   2593     if {![info exists no(core)] && \
  2465   2594         ![info exists no(checkForPerformance)]} then {
  2466   2595       checkForPerformance $test_channel
  2467   2596     }
................................................................................
  2478   2607     if {![info exists no(core)] && \
  2479   2608         ![info exists no(timing)]} then {
  2480   2609       checkForTiming $test_channel 50; # 1/20th second.
  2481   2610     }
  2482   2611   
  2483   2612     if {![info exists no(core)] && \
  2484   2613         ![info exists no(preciseTiming)]} then {
  2485         -    checkForTiming $test_channel 25 preciseTiming; # 1/40th second.
         2614  +    #
         2615  +    # NOTE: Normally, the "preciseTiming" constraint implicitly requires that
         2616  +    #       the "timing" constraint be present as well; however, that can be
         2617  +    #       overridden.
         2618  +    #
         2619  +    if {[info exists no(requireTiming)] || \
         2620  +        [haveConstraint timing]} then {
         2621  +      checkForTiming $test_channel 25 preciseTiming; # 1/40th second.
         2622  +    }
  2486   2623     }
  2487   2624   
  2488   2625     #
  2489   2626     # NOTE: Has interactive testing been disabled?
  2490   2627     #
  2491   2628     if {![info exists no(interactive)]} then {
  2492   2629       checkForInteractive $test_channel