System.Data.SQLite
Check-in [70020f6f06]
Not logged in

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

Overview
Comment:Update Eagle in externals to the beta 34 release.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: 70020f6f06d38bfe4494f4eb44874f7e483ed41a
User & Date: mistachkin 2015-09-29 05:10:10
Context
2015-09-29
16:58
Changes to support the 'vtab-onepass' functionality in the SQLite core library. check-in: 80d9c54709 user: mistachkin tags: trunk
05:10
Update Eagle in externals to the beta 34 release. check-in: 70020f6f06 user: mistachkin tags: trunk
2015-09-28
17:45
Update the SQLite core library to the latest trunk code. check-in: a0f27df53f 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.

  1438   1438               {automatic false} } {
  1439   1439         #
  1440   1440         # NOTE: Grab the base URI for updates.
  1441   1441         #
  1442   1442         set updateBaseUri [info engine UpdateBaseUri]
  1443   1443   
  1444   1444         #
  1445         -      # NOTE: Append the path and query string used for updates to it.
         1445  +      # NOTE: Grab the update path and query string used for updates.
  1446   1446         #
  1447         -      set updateUri [appendArgs \
  1448         -          $updateBaseUri [info engine UpdatePathAndQuery]]
         1447  +      set updatePathAndQuery [info engine UpdatePathAndQuery]
         1448  +
         1449  +      #
         1450  +      # HACK: Exract the URI type (e.g. "stable" or "latest") from the
         1451  +      #       update path and query.  This code may need to be modified
         1452  +      #       in the future.
         1453  +      #
         1454  +      set updateUriType [lindex [split $updatePathAndQuery .] 0]
         1455  +
         1456  +      #
         1457  +      # NOTE: Combine them to form the complete update URI.
         1458  +      #
         1459  +      set updateUri [appendArgs $updateBaseUri $updatePathAndQuery]
  1449   1460   
  1450   1461         #
  1451   1462         # NOTE: Fetch the master update data from the distribution site
  1452   1463         #       and normalize to Unix-style line-endings.
  1453   1464         #
  1454   1465         set updateData [string map [list \r\n \n] [getUpdateData $updateUri]]
  1455   1466   
................................................................................
  1669   1680                   #
  1670   1681                   if {$checkBuild} then {
  1671   1682                     #
  1672   1683                     # NOTE: Are we supposed to prompt the interactive user,
  1673   1684                     #       if any, to upgrade now?
  1674   1685                     #
  1675   1686                     set text [appendArgs \
  1676         -                      "latest build " $patchLevel ", dated " $dateTime \
  1677         -                      ", is newer than the running build " $enginePatchLevel \
  1678         -                      ", dated " $engineDateTime ", based on data from " \
  1679         -                      $updateBaseUri]
         1687  +                      $updateUriType " build " $patchLevel ", dated " \
         1688  +                      $dateTime ", is newer than the running build " \
         1689  +                      $enginePatchLevel ", dated " $engineDateTime \
         1690  +                      ", based on data from " $updateBaseUri]
  1680   1691   
  1681   1692                     if {$prompt && [isInteractive]} then {
  1682   1693                       #
  1683   1694                       # NOTE: Is the [object] command available?  If not,
  1684   1695                       #       this cannot be done.
  1685   1696                       #
  1686   1697                       if {[llength [info commands object]] > 0} then {
................................................................................
  1916   1927                 } elseif {$checkBuild && $compare < 0} then {
  1917   1928                   #
  1918   1929                   # NOTE: The patch level from the line is less, we are more
  1919   1930                   #       up-to-date than the latest version?
  1920   1931                   #
  1921   1932                   return [list [appendArgs \
  1922   1933                       "running build " $enginePatchLevel ", dated " \
  1923         -                    $engineDateTime ", is newer than the latest build " \
  1924         -                    $patchLevel ", dated " $dateTime ", based on data " \
  1925         -                    "from " $updateBaseUri]]
         1934  +                    $engineDateTime ", is newer than the " $updateUriType \
         1935  +                    " build " $patchLevel ", dated " $dateTime \
         1936  +                    ", based on data " "from " $updateBaseUri]]
  1926   1937                 } elseif {$checkBuild} then {
  1927   1938                   #
  1928   1939                   # NOTE: The patch levels are equal, we are up-to-date.
  1929   1940                   #
  1930   1941                   return [list [appendArgs \
  1931   1942                       "running build " $enginePatchLevel ", dated " \
  1932         -                    $engineDateTime ", is the latest build, based on " \
  1933         -                    "data from " $updateBaseUri]]
         1943  +                    $engineDateTime ", is the " $updateUriType \
         1944  +                    " build, based on " "data from " $updateBaseUri]]
  1934   1945                 }
  1935   1946               }
  1936   1947             }
  1937   1948           }
  1938   1949         }
  1939   1950   
  1940   1951         #

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

   503    503       # TODO: Add more support for standard "tcltest" options here.
   504    504       #
   505    505       set options [list \
   506    506           -breakOnLeak -configuration -constraints -exitOnComplete \
   507    507           -file -logFile -machine -match -no -notFile -platform \
   508    508           -postTest -preTest -postWait -preWait -randomOrder -skip \
   509    509           -startFile -stopFile -stopOnFailure -stopOnLeak -suffix \
   510         -        -suite -tclsh -threshold]
          510  +        -suite -tclsh -threshold -uncountedLeaks -verbose]
   511    511   
   512    512       set length [llength $args]
   513    513   
   514    514       for {set index 0} {$index < $length} {incr index} {
   515    515         #
   516    516         # NOTE: Grab the current list element, which should be the name of
   517    517         #       the test option.
................................................................................
  1190   1190         #
  1191   1191         # NOTE: We are missing the suffix, return nothing.
  1192   1192         #
  1193   1193         return ""
  1194   1194       }
  1195   1195     }
  1196   1196   
         1197  +  proc getTestUncountedLeaks {} {
         1198  +    if {[info exists ::test_uncounted_leaks] && \
         1199  +        [string length $::test_uncounted_leaks] > 0} then {
         1200  +      return $::test_uncounted_leaks
         1201  +    }
         1202  +
         1203  +    return [list]
         1204  +  }
         1205  +
  1197   1206     #
  1198   1207     # NOTE: This procedure should return non-zero if the [exec] command may be
  1199   1208     #       used by the specified test package procedure.
  1200   1209     #
  1201   1210     proc canTestExec { procName } {
  1202   1211       if {[info exists ::no(exec)]} then {
  1203   1212         return false
................................................................................
  1428   1437   
  1429   1438       if {[isEagle]} then {
  1430   1439         if {$code == 0 && [regexp -- {\s==== (.*?) FAILED\s} $result]} then {
  1431   1440           set code 1
  1432   1441         }
  1433   1442   
  1434   1443         #
  1435         -      # NOTE: Display and log the result of the test we just completed.
         1444  +      # NOTE: Display and/or log the results for the test that we just
         1445  +      #       completed.
  1436   1446         #
  1437         -      tresult $code $result
         1447  +      if {[shouldWriteTestData]} then {
         1448  +        tresult $code $result
         1449  +      } else {
         1450  +        tlog $result
         1451  +      }
  1438   1452   
  1439   1453         #
  1440   1454         # NOTE: If the test failed with an actual error (i.e. not just a
  1441   1455         #       test failure), make sure we do not obscure the error
  1442   1456         #       message with test suite output.
  1443   1457         #
  1444   1458         if {$error} then {
................................................................................
  1455   1469           tresult Error "OVERALL RESULT: STOP-ON-FAILURE\n"
  1456   1470   
  1457   1471           unset -nocomplain ::test_suite_running
  1458   1472           error ""; # no message
  1459   1473         }
  1460   1474       } else {
  1461   1475         if {$error} then {
  1462         -        tputs $::test_channel [appendArgs "ERROR (runTest): " $result \n]
         1476  +        #
         1477  +        # HACK: Prevent spurious errors dealing with [test] command options
         1478  +        #       that are missing from native Tcl.
         1479  +        #
         1480  +        set badOptionPattern {^bad option ".*?":\
         1481  +            must be -body, -cleanup, -constraints, -errorOutput,\
         1482  +            -match, -output, -result, -returnCodes, or -setup$}
         1483  +
         1484  +        if {[isEagle] || ![regexp -- $badOptionPattern $result]} then {
         1485  +          tputs $::test_channel [appendArgs "ERROR (runTest): " $result \n]
         1486  +        }
  1463   1487         }
  1464   1488   
  1465   1489         unhookPuts
  1466   1490       }
  1467   1491     }
  1468   1492   
  1469   1493     proc testShim { args } {
................................................................................
  1528   1552       #
  1529   1553       # NOTE: Record counts of all object types that we track.
  1530   1554       #
  1531   1555       upvar 1 $varName array
  1532   1556   
  1533   1557       ###########################################################################
  1534   1558   
  1535         -    set array(uncounted,$index) [list]
         1559  +    if {![info exists array(uncounted,$index)]} then {
         1560  +      set array(uncounted,$index) [getTestUncountedLeaks]
         1561  +    }
         1562  +
         1563  +    ###########################################################################
         1564  +
  1536   1565       set array(time,$index) [clock seconds]
  1537   1566       set array(afters,$index) [llength [after info]]
  1538   1567       set array(variables,$index) [llength [info globals]]
  1539   1568       set array(commands,$index) [llength [info commands]]
  1540   1569       set array(procedures,$index) [llength [info procs]]
  1541   1570       set array(namespaces,$index) [llength [namespace children ::]]
  1542   1571       set array(files,$index) [llength [getFiles $::test_path *]]
................................................................................
  1550   1579       ###########################################################################
  1551   1580   
  1552   1581       #
  1553   1582       # NOTE: These native resource types cannot be positively checked
  1554   1583       #       for leaks (i.e. because the "leak" may be from an external
  1555   1584       #       process).
  1556   1585       #
  1557         -    lappend array(uncounted,$index) temporaryFiles
         1586  +    if {![info exists ::no(uncountedTemporaryFiles)]} then {
         1587  +      lappend array(uncounted,$index) temporaryFiles
         1588  +    }
  1558   1589   
  1559   1590       ###########################################################################
  1560   1591   
  1561   1592       if {[isEagle]} then {
  1562   1593         #
  1563   1594         # NOTE: Support for some of all of these entity types may not be
  1564   1595         #       present in the interpreter, initialize all these counts
................................................................................
  1627   1658         #########################################################################
  1628   1659   
  1629   1660         #
  1630   1661         # NOTE: These managed resource types cannot be positively checked
  1631   1662         #       for leaks (i.e. because the "leak" may be from an external
  1632   1663         #       process).
  1633   1664         #
  1634         -      lappend array(uncounted,$index) assemblies processes
         1665  +      if {![info exists ::no(uncountedAssemblies)]} then {
         1666  +        lappend array(uncounted,$index) assemblies
         1667  +      }
         1668  +
         1669  +      if {![info exists ::no(uncountedProcesses)]} then {
         1670  +        lappend array(uncounted,$index) processes
         1671  +      }
  1635   1672       }
  1636   1673     }
  1637   1674   
  1638   1675     proc reportTestStatistics { channel fileName statsVarName filesVarName } {
  1639   1676       set statistics [list afters variables commands procedures namespaces \
  1640   1677           files temporaryFiles channels aliases interpreters environment \
  1641   1678           loaded]
................................................................................
  2615   2652                 [expr {[info exists ::test_path] ? \
  2616   2653                 $::test_path : "<none>"}] \"\n]
  2617   2654           }
  2618   2655         }
  2619   2656       }
  2620   2657     }
  2621   2658   
  2622         -  proc configureTcltest { match skip constraints imports force } {
         2659  +  proc configureTcltest { verbose match skip constraints imports force } {
  2623   2660       #
  2624   2661       # NOTE: Eagle and native Tcl have different configuration requirements
  2625   2662       #       for the "tcltest" package.  For Eagle, the necessary testing
  2626   2663       #       functionality is built-in.  In native Tcl, the package must be
  2627   2664       #       loaded now and that cannot be done in a "safe" interpreter.
  2628   2665       #
  2629   2666       if {[isEagle]} then {
................................................................................
  2658   2695         #
  2659   2696         package require tcltest
  2660   2697   
  2661   2698         #
  2662   2699         # NOTE: Configure it for our use (only when it was not loaded).
  2663   2700         #
  2664   2701         if {!$loaded} then {
  2665         -        ::tcltest::configure -verbose bpste
         2702  +        if {[string length $verbose] > 0} then {
         2703  +          ::tcltest::configure -verbose $verbose
         2704  +        } else {
         2705  +          ::tcltest::configure -verbose pbste
         2706  +        }
  2666   2707         }
  2667   2708   
  2668   2709         #
  2669   2710         # NOTE: We need to copy the Eagle test names to match over to Tcl.
  2670   2711         #
  2671   2712         if {[llength $match] > 0} then {
  2672   2713           ::tcltest::configure -match $match
................................................................................
  2829   2870           #
  2830   2871           # NOTE: Initialize the list of active test constraints from the
  2831   2872           #       environment variable and/or the test flags.
  2832   2873           #
  2833   2874           set eagle_tests(Constraints) [getEnvironmentVariable testConstraints]
  2834   2875   
  2835   2876           if {[info exists test_flags(-constraints)]} then {
  2836         -            eval lappend eagle_tests(Constraints) $test_flags(-constraints)
         2877  +          eval lappend eagle_tests(Constraints) $test_flags(-constraints)
  2837   2878           }
         2879  +
         2880  +        unset -nocomplain test_verbose; set test_verbose Default
         2881  +
         2882  +        if {[info exists test_flags(-verbose)] && \
         2883  +            [string length $test_flags(-verbose)] > 0} then {
         2884  +          #
         2885  +          # NOTE: Map all test verbosity flags we support for script usage
         2886  +          #       to their abbreviated names (which are all one letter) and
         2887  +          #       then split them into a list.
         2888  +          #
         2889  +          set test_verbose [split [string map [list \
         2890  +              Body B Pass P Skip S Start T Error E Line L \
         2891  +              Fail F Reason R Time I Exit X StdOut O StdErr D] \
         2892  +              $test_flags(-verbose)] ""]
         2893  +        }
         2894  +
         2895  +        set eagle_tests(Verbose) $test_verbose; unset test_verbose
  2838   2896         }
  2839   2897       }
  2840   2898   
  2841   2899       proc setupTestShims { setup {quiet false} } {
  2842   2900         if {$setup} then {
  2843   2901           #
  2844   2902           # HACK: Compatibility shim(s) for use with various tests in the Tcl
................................................................................
  2928   2986             if {!$quiet} then {
  2929   2987               tqputs $::test_channel \
  2930   2988                   "---- removed \"testConstraint\" alias\n"
  2931   2989             }
  2932   2990           }
  2933   2991         }
  2934   2992       }
         2993  +
         2994  +    proc shouldWriteTestData {} {
         2995  +      if {[llength [info commands object]] > 0 && [catch {
         2996  +        object invoke -flags +NonPublic \
         2997  +            Eagle._Components.Private.TestOps ShouldWriteTestData ""
         2998  +      } writeTestData] == 0 && $writeTestData} then {
         2999  +        return false
         3000  +      }
         3001  +
         3002  +      return true
         3003  +    }
  2935   3004   
  2936   3005       proc tresult { code result } {
  2937   3006         host result $code $result; tlog $result
  2938   3007       }
  2939   3008   
  2940   3009       proc getPassPercentage {} {
  2941   3010         if {$::eagle_tests(Total) > 0} then {
................................................................................
  3422   3491       }
  3423   3492   
  3424   3493       #
  3425   3494       # NOTE: Fake loading and configuring the "tcltest" package unless we
  3426   3495       #       are prevented.
  3427   3496       #
  3428   3497       if {![info exists ::no(configureTcltest)]} then {
  3429         -      configureTcltest [list] [list] [list] [list] false
         3498  +      configureTcltest "" [list] [list] [list] [list] false
  3430   3499       }
  3431   3500   
  3432   3501       ###########################################################################
  3433   3502       ############################# END Eagle ONLY ##############################
  3434   3503       ###########################################################################
  3435   3504     } else {
  3436   3505       ###########################################################################
................................................................................
  3466   3535         checkForAndSetTestPath false [expr {![isTestSuiteRunning]}]
  3467   3536       }
  3468   3537   
  3469   3538       #
  3470   3539       # NOTE: Load and configure the "tcltest" package unless we are prevented.
  3471   3540       #
  3472   3541       if {![info exists ::no(configureTcltest)]} then {
  3473         -      configureTcltest [list] [list] [list] [list test testConstraint] false
         3542  +      configureTcltest "" [list] [list] [list] [list test testConstraint] false
  3474   3543       }
  3475   3544   
  3476   3545       #
  3477   3546       # NOTE: We need several of our test related commands in the global
  3478   3547       #       namespace as well.
  3479   3548       #
  3480   3549       exportAndImportPackageCommands [namespace current] [list \
................................................................................
  3481   3550           tputs ttclLog tlog getSoftwareRegistryKey haveConstraint \
  3482   3551           addConstraint haveOrAddConstraint getConstraints removeConstraint \
  3483   3552           fixConstraints calculateBogoCops calculateRelativePerformance \
  3484   3553           formatTimeStamp formatElapsedTime sourceIfValid processTestArguments \
  3485   3554           getTclShellFileName getTemporaryPath getFiles getTestFiles \
  3486   3555           getTestRunId getTestLogId getDefaultTestLog getTestLog getLastTestLog \
  3487   3556           getTestSuite getTestMachine getTestPlatform getTestConfiguration \
  3488         -        getTestSuffix testExec testClrExec execTestShell isRandomOrder \
  3489         -        isBreakOnLeak isStopOnFailure isStopOnLeak isExitOnComplete \
  3490         -        returnInfoScript runTestPrologue runTestEpilogue hookPuts unhookPuts \
  3491         -        runTest testDebugBreak testArrayGet testShim tsource \
  3492         -        recordTestStatistics reportTestStatistics formatList formatListAsDict \
  3493         -        pathToRegexp inverseLsearchGlob removePathFromFileNames formatDecimal \
         3557  +        getTestSuffix getTestUncountedLeaks testExec testClrExec \
         3558  +        execTestShell isRandomOrder isBreakOnLeak isStopOnFailure \
         3559  +        isStopOnLeak isExitOnComplete returnInfoScript runTestPrologue \
         3560  +        runTestEpilogue hookPuts unhookPuts runTest testDebugBreak \
         3561  +        testArrayGet testShim tsource recordTestStatistics \
         3562  +        reportTestStatistics formatList formatListAsDict pathToRegexp \
         3563  +        inverseLsearchGlob removePathFromFileNames formatDecimal \
  3494   3564           clearTestPercent reportTestPercent runAllTests isTestSuiteRunning \
  3495   3565           getTestChannelOrDefault checkForAndSetTestPath configureTcltest \
  3496   3566           machineToPlatform getPassPercentage getSkipPercentage] false false
  3497   3567   
  3498   3568       ###########################################################################
  3499   3569       ############################## END Tcl ONLY ###############################
  3500   3570       ###########################################################################

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

    16     16   
    17     17   #
    18     18   # NOTE: Use our own namespace here because even though we do not directly
    19     19   #       support namespaces ourselves, we do not want to pollute the global
    20     20   #       namespace if this script actually ends up being evaluated in Tcl.
    21     21   #
    22     22   namespace eval ::Eagle {
           23  +  proc getKnownBuildTypes {} {
           24  +    return [list \
           25  +        NetFx20 NetFx35 NetFx40 NetFx45 NetFx451 NetFx452 NetFx46 Bare \
           26  +        LeanAndMean Database MonoOnUnix Development]
           27  +  }
           28  +
    23     29     proc getKnownCompileOptions {} {
    24     30       return [list \
    25     31           APPDOMAINS APPROVED_VERBS ARM ASSEMBLY_RELEASE \
    26     32           ASSEMBLY_STRONG_NAME_TAG ASSEMBLY_TAG ASSEMBLY_TEXT ASSEMBLY_URI \
    27     33           BREAK_ON_EXITING BREAKPOINTS CACHE_ARGUMENT_TOSTRING \
    28     34           CACHE_ARGUMENTLIST_TOSTRING CACHE_DICTIONARY CACHE_RESULT_TOSTRING \
    29     35           CACHE_STATISTICS CACHE_STRINGLIST_TOSTRING CALLBACK_QUEUE CAS_POLICY \
................................................................................
    41     47           NOTIFY_ACTIVE NOTIFY_ARGUMENTS NOTIFY_EXCEPTION NOTIFY_EXECUTE \
    42     48           NOTIFY_EXPRESSION NOTIFY_GLOBAL NOTIFY_OBJECT OBSOLETE OBFUSCATION \
    43     49           OFFICIAL PARSE_CACHE PATCHLEVEL PLUGIN_COMMANDS POLICY_TRACE \
    44     50           PREVIOUS_RESULT RANDOMIZE_ID REMOTING SAMPLE SECURITY SERIALIZATION \
    45     51           SHARED_ID_POOL SHELL SOURCE_ID SOURCE_TIMESTAMP STATIC TCL TCL_KITS \
    46     52           TCL_THREADED TCL_THREADS TCL_UNICODE TCL_WRAPPER TEST THREADING \
    47     53           THROW_ON_DISPOSED TRACE TYPE_CACHE UNIX USE_NAMESPACES VERBOSE WEB \
    48         -        WINDOWS WINFORMS WIX_30 WIX_35 WIX_36 WIX_37 WIX_38 WIX_39 X64 X86 XML]
           54  +        WINDOWS WINFORMS WIX_30 WIX_35 WIX_36 WIX_37 WIX_38 WIX_39 WIX_310 \
           55  +        X64 X86 XML]
    49     56     }
    50     57   
    51     58     proc getKnownMonoVersions {} {
    52     59       #
    53     60       # NOTE: This job of this procedure is to return the list of "known"
    54     61       #       versions of Mono supported by the test suite infrastructure.
    55     62       #
................................................................................
  3693   3700       ###########################################################################
  3694   3701   
  3695   3702       #
  3696   3703       # NOTE: We need several of our test constraint related commands in the
  3697   3704       #       global namespace.
  3698   3705       #
  3699   3706       exportAndImportPackageCommands [namespace current] [list \
  3700         -        getKnownCompileOptions getKnownMonoVersions lpermute \
  3701         -        alwaysFullInterpReady canExecWhoAmI canExecTclShell canExecFossil \
  3702         -        isTestMono isTestAdministrator canPing checkForTestSuiteFiles \
  3703         -        checkForPlatform checkForWindowsVersion checkForScriptLibrary \
  3704         -        checkForVariable checkForTclOptions checkForWindowsCommandProcessor \
  3705         -        checkForFossil checkForEagle checkForSymbols checkForLogFile \
  3706         -        checkForGaruda checkForShell checkForDebug checkForTk checkForVersion \
  3707         -        checkForCommand checkForNamespaces checkForTestExec \
  3708         -        checkForTestMachine checkForTestPlatform checkForTestConfiguration \
  3709         -        checkForTestSuffix checkForFile checkForPathFile checkForNativeCode \
  3710         -        checkForTip127 checkForTip194 checkForTip207 checkForTip241 \
  3711         -        checkForTip285 checkForTip405 checkForTip426 checkForTip429 \
  3712         -        checkForTiming checkForPerformance checkForBigLists \
  3713         -        checkForTimeIntensive checkForFullTest checkForMemoryIntensive \
  3714         -        checkForStackIntensive checkForInteractive checkForInteractiveCommand \
         3707  +        getKnownBuildTypes getKnownCompileOptions getKnownMonoVersions \
         3708  +        lpermute alwaysFullInterpReady canExecWhoAmI canExecTclShell \
         3709  +        canExecFossil isTestMono isTestAdministrator canPing \
         3710  +        checkForTestSuiteFiles checkForPlatform checkForWindowsVersion \
         3711  +        checkForScriptLibrary checkForVariable checkForTclOptions \
         3712  +        checkForWindowsCommandProcessor checkForFossil checkForEagle \
         3713  +        checkForSymbols checkForLogFile checkForGaruda checkForShell \
         3714  +        checkForDebug checkForTk checkForVersion checkForCommand \
         3715  +        checkForNamespaces checkForTestExec checkForTestMachine \
         3716  +        checkForTestPlatform checkForTestConfiguration checkForTestSuffix \
         3717  +        checkForFile checkForPathFile checkForNativeCode checkForTip127 \
         3718  +        checkForTip194 checkForTip207 checkForTip241 checkForTip285 \
         3719  +        checkForTip405 checkForTip426 checkForTip429 checkForTiming \
         3720  +        checkForPerformance checkForBigLists checkForTimeIntensive \
         3721  +        checkForFullTest checkForMemoryIntensive checkForStackIntensive \
         3722  +        checkForInteractive checkForInteractiveCommand \
  3715   3723           checkForUserInteraction checkForNetwork checkForCompileOption \
  3716   3724           checkForKnownCompileOptions] false false
  3717   3725   
  3718   3726       ###########################################################################
  3719   3727       ############################## END Tcl ONLY ###############################
  3720   3728       ###########################################################################
  3721   3729     }

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

   225    225     #
   226    226     if {[catch {package present Eagle.Test.Constraints}]} then {
   227    227       package require Eagle.Test.Constraints
   228    228     }
   229    229   
   230    230     #############################################################################
   231    231   
          232  +  #
          233  +  # NOTE: *SPECIAL* This test constraint must be checked first as it can
          234  +  #       determine if subsequent ones will emit warnings.  This is only
          235  +  #       applicable to Eagle.  This block requires the "Eagle.Test" and
          236  +  #       "Eagle.Test.Constraints" packages.
          237  +  #
          238  +  if {[isEagle]} then {
          239  +    #
          240  +    # NOTE: Has quiet testing support been disabled?
          241  +    #
          242  +    if {![info exists no(preQuiet)]} then {
          243  +      #
          244  +      # NOTE: There are checks for the "quiet" test constraint prior to
          245  +      #       the real test constraints being initialized.  Prepare for
          246  +      #       those checks now.  This will have to be repeated later,
          247  +      #       after the real test constraints are initialized.
          248  +      #
          249  +      checkForQuiet $test_channel true
          250  +    }
          251  +  }
          252  +
          253  +  #############################################################################
          254  +
   232    255     #
   233    256     # NOTE: Verify that the current call frame is correct and that the
   234    257     #       interpreter call stack has not been imbalanced by previous
   235    258     #       tests or other errors.  This check only applies to Eagle.
   236    259     #       This block requires the "Eagle.Library" package.
   237    260     #
   238    261     if {[isEagle] && [llength [info commands object]] > 0} then {
................................................................................
   242    265       #
   243    266       if {[object invoke -flags +NonPublic \
   244    267               Interpreter.GetActive.CurrentFrame Name] ne \
   245    268           [list source [file normalize [info script]]]} then {
   246    269         unset -nocomplain test_suite_running
   247    270         error "cannot run prologue, current frame not for this script"
   248    271       }
          272  +
          273  +    #
          274  +    # NOTE: Attempt to determine if the this script file being run as
          275  +    #       part of the overall test suite script file itself.  If not,
          276  +    #       issue a warning about the inability to detect "leaks" from
          277  +    #       the tests.
          278  +    #
          279  +    if {[lsearch -glob -index 0 -- [object invoke -flags +NonPublic \
          280  +            Interpreter.GetActive ScriptLocations.ToString] \
          281  +            {*[/\]all.eagle}] == -1} then {
          282  +      #
          283  +      # NOTE: Check if the warning should actually be emitted.  If this
          284  +      #       warning has specifically been disabled or we are in quiet
          285  +      #       mode, do nothing.
          286  +      #
          287  +      if {![info exists no(warningForAllEagle)] && \
          288  +          ![haveConstraint quiet]} then {
          289  +        tputs $test_channel [appendArgs \
          290  +            "==== WARNING: tests are not being run via suite script file " \
          291  +            "\"all.eagle\", resource leaks will probably not be reported.\n"]
          292  +      }
          293  +    }
   249    294     }
   250    295   
   251    296     #############################################################################
   252    297   
   253    298     #
   254    299     # NOTE: Set the local root directory of the source checkout (i.e. of Eagle
   255    300     #       or whatever project the Eagle binaries are being used by) using a
................................................................................
   307    352     set test_flags(-file) [list *.eagle]; # default to running all test files.
   308    353     set test_flags(-notFile) [list l.*.eagle]; # COMPAT: Tcl.
   309    354     set test_flags(-startFile) [list]; # start running at these test files.
   310    355     set test_flags(-stopFile) [list]; # stop running after these test files.
   311    356     set test_flags(-match) [list *]; # default to running all tests.
   312    357     set test_flags(-skip) [list]; # default to skipping no tests.
   313    358     set test_flags(-constraints) [list]; # default to no manual constraints.
          359  +  set test_flags(-verbose) ""; # default to pass, body, skip, start, error.
   314    360     set test_flags(-logFile) ""; # default to using standard log file naming.
   315    361     set test_flags(-threshold) ""; # default to requiring all tests to pass.
   316    362     set test_flags(-randomOrder) ""; # default to deterministic order.
          363  +  set test_flags(-uncountedLeaks) ""; # use defaults for uncounted resources.
   317    364     set test_flags(-breakOnLeak) ""; # default to continue on leak.
   318    365     set test_flags(-stopOnFailure) ""; # default to continue on failure.
   319    366     set test_flags(-stopOnLeak) ""; # default to continue on leak.
   320    367     set test_flags(-exitOnComplete) ""; # default to not exit after complete.
   321    368     set test_flags(-preTest) ""; # default to not evaluating anything.
   322    369     set test_flags(-postTest) ""; # default to not evaluating anything.
   323    370     set test_flags(-preWait) ""; # default to not waiting.
................................................................................
   367    414           [string is boolean -strict $test_flags(-randomOrder)]} then {
   368    415         #
   369    416         # NOTE: Set the test random-order flag to the one provided by the
   370    417         #       command line.
   371    418         #
   372    419         set test_random_order $test_flags(-randomOrder)
   373    420       }
          421  +
          422  +    if {[info exists test_flags(-uncountedLeaks)] && \
          423  +        [string length $test_flags(-uncountedLeaks)] > 0} then {
          424  +      #
          425  +      # NOTE: Set the test uncounted leaks "list" to the one provided by
          426  +      #       the command line.  We should probably use [string is list]
          427  +      #       here; however, that is not available until native Tcl 8.5.
          428  +      #
          429  +      set test_uncounted_leaks $test_flags(-uncountedLeaks)
          430  +    }
   374    431   
   375    432       if {[info exists test_flags(-breakOnLeak)] && \
   376    433           [string is boolean -strict $test_flags(-breakOnLeak)]} then {
   377    434         #
   378    435         # NOTE: Set the test break-on-leak flag to the one provided by the
   379    436         #       command line.
   380    437         #
................................................................................
   480    537       if {![info exists test_log]} then {
   481    538         set test_log [getDefaultTestLog]
   482    539       }
   483    540     }
   484    541   
   485    542     #############################################################################
   486    543   
   487         -  #
   488         -  # NOTE: *SPECIAL* This test constraint must be checked first as it can
   489         -  #       determine if subsequent ones will emit warnings.  This is only
   490         -  #       applicable to Eagle.
   491         -  #
   492         -  if {[isEagle]} then {
   493         -    #
   494         -    # NOTE: Has quiet testing support been disabled?
   495         -    #
   496         -    if {![info exists no(preQuiet)]} then {
   497         -      #
   498         -      # NOTE: There are checks for the "quiet" test constraint prior to
   499         -      #       the real test constraints being initialized.  Prepare for
   500         -      #       those checks now.  This will have to be repeated later,
   501         -      #       after the real test constraints are initialized.
   502         -      #
   503         -      checkForQuiet $test_channel true
   504         -    }
   505         -  }
   506         -
   507         -  #############################################################################
   508         -
   509    544     #
   510    545     # NOTE: Has native Tcl shell detection and use been disabled?
   511    546     #
   512    547     if {![info exists no(tclsh)]} then {
   513    548       #
   514    549       # NOTE: Set the Tcl shell executable to use for those specialized
   515    550       #       tests that may require it, if necessary.
................................................................................
   562    597     #
   563    598     # NOTE: When running in Eagle, check for any non-core plugins loaded into
   564    599     #       the interpreter and issue warnings if any are found.  The warning
   565    600     #       may be used to explain subsequent test failures due to the extra
   566    601     #       plugins being loaded (i.e. there are some tests are sensitive to
   567    602     #       having "unexpected" plugins loaded).
   568    603     #
   569         -  if {[isEagle] && ![info exists no(warningForPlugin)] && \
          604  +  if {[isEagle] && \
          605  +      ![info exists no(warningForPlugin)] && \
   570    606         ![haveConstraint quiet]} then {
   571    607       foreach loaded [info loaded] {
   572    608         #
   573    609         # HACK: This code assumes that all plugins in the "Eagle._Plugins"
   574    610         #       namespace belong to the Eagle core library itself.
   575    611         #
   576    612         if {![string match Eagle._Plugins.* [lindex $loaded 1]]} then {
................................................................................
   763    799             [string is integer -strict $test_threshold] ? \
   764    800                 [appendArgs $test_threshold %] : "<none>"}] \n]
   765    801   
   766    802     tputs $test_channel [appendArgs "---- random order: " \
   767    803         [expr {[info exists test_random_order] && \
   768    804             [string is boolean -strict $test_random_order] ? \
   769    805                 $test_random_order : "<none>"}] \n]
          806  +
          807  +  tputs $test_channel [appendArgs "---- uncounted leaks: " \
          808  +      [expr {[info exists test_uncounted_leaks] && \
          809  +          [string length $test_uncounted_leaks] > 0 ? \
          810  +              $test_uncounted_leaks : "<none>"}] \n]
   770    811   
   771    812     tputs $test_channel [appendArgs "---- break on leak: " \
   772    813         [expr {[info exists test_break_on_leak] && \
   773    814             [string is boolean -strict $test_break_on_leak] ? \
   774    815                 $test_break_on_leak : "<none>"}] \n]
   775    816   
   776    817     tputs $test_channel [appendArgs "---- stop on failure: " \
................................................................................
   785    826   
   786    827     tputs $test_channel [appendArgs "---- exit on complete: " \
   787    828         [expr {[info exists test_exit_on_complete] && \
   788    829             [string is boolean -strict $test_exit_on_complete] ? \
   789    830                 $test_exit_on_complete : "<none>"}] \n]
   790    831   
   791    832     #
   792         -  # NOTE: Show the information about which tests and files are being run and/or
   793         -  #       skipped (COMPAT: Tcl).
   794         -  #
   795         -  if {[llength $test_flags(-file)] > 0} then {
   796         -    tputs $test_channel [appendArgs "---- running test files that match: " \
   797         -        $test_flags(-file) \n]
   798         -  }
   799         -
   800         -  if {[llength $test_flags(-notFile)] > 0} then {
   801         -    tputs $test_channel [appendArgs "---- skipping test files that match: " \
   802         -        $test_flags(-notFile) \n]
   803         -  }
   804         -
   805         -  if {[llength $test_flags(-startFile)] > 0} then {
   806         -    tputs $test_channel [appendArgs \
   807         -        "---- starting with test files that match: " \
   808         -        $test_flags(-startFile) \n]
   809         -  }
   810         -
   811         -  if {[llength $test_flags(-stopFile)] > 0} then {
   812         -    tputs $test_channel [appendArgs \
   813         -        "---- stopping after test files that match: " \
   814         -        $test_flags(-stopFile) \n]
   815         -  }
   816         -
   817         -  if {[llength $test_flags(-match)] > 0} then {
   818         -    tputs $test_channel [appendArgs "---- running tests that match: " \
   819         -        $test_flags(-match) \n]
   820         -  }
   821         -
   822         -  if {[llength $test_flags(-skip)] > 0} then {
   823         -    tputs $test_channel [appendArgs "---- skipping tests that match: " \
   824         -        $test_flags(-skip) \n]
   825         -  }
          833  +  # NOTE: Show the information about which tests and files are being run
          834  +  #       and/or skipped (COMPAT: Tcl).
          835  +  #
          836  +  tputs $test_channel [appendArgs "---- running test files that match: " \
          837  +      [expr {[info exists test_flags(-file)] && \
          838  +          [llength $test_flags(-file)] > 0 ? \
          839  +              $test_flags(-file) : "<none>"}] \n]
          840  +
          841  +  tputs $test_channel [appendArgs "---- skipping test files that match: " \
          842  +      [expr {[info exists test_flags(-notFile)] && \
          843  +          [llength $test_flags(-notFile)] > 0 ? \
          844  +              $test_flags(-notFile) : "<none>"}] \n]
          845  +
          846  +  tputs $test_channel [appendArgs \
          847  +      "---- starting with test files that match: " \
          848  +      [expr {[info exists test_flags(-startFile)] && \
          849  +          [llength $test_flags(-startFile)] > 0 ? \
          850  +              $test_flags(-startFile) : "<none>"}] \n]
          851  +
          852  +  tputs $test_channel [appendArgs \
          853  +      "---- stopping after test files that match: " \
          854  +      [expr {[info exists test_flags(-stopFile)] && \
          855  +          [llength $test_flags(-stopFile)] > 0 ? \
          856  +              $test_flags(-stopFile) : "<none>"}] \n]
          857  +
          858  +  tputs $test_channel [appendArgs "---- running tests that match: " \
          859  +      [expr {[info exists test_flags(-match)] && \
          860  +          [llength $test_flags(-match)] > 0 ? \
          861  +              $test_flags(-match) : "<none>"}] \n]
          862  +
          863  +  tputs $test_channel [appendArgs "---- skipping tests that match: " \
          864  +      [expr {[info exists test_flags(-skip)] && \
          865  +          [llength $test_flags(-skip)] > 0 ? \
          866  +              $test_flags(-skip) : "<none>"}] \n]
          867  +
          868  +  tputs $test_channel [appendArgs "---- verbosity level for tests: " \
          869  +      [expr {[info exists test_flags(-verbose)] && \
          870  +          [string length $test_flags(-verbose)] > 0 ? \
          871  +              $test_flags(-verbose) : "<none>"}] \n]
   826    872   
   827    873     tputs $test_channel [appendArgs "---- path: " \
   828    874         [expr {[info exists path] && [string length $path] > 0 ? \
   829    875             [appendArgs \" $path \"] : "<none>"}] \n]
   830    876   
   831    877     tputs $test_channel [appendArgs "---- base path: \"" \
   832    878         $base_path \"\n]
................................................................................
   866    912     # NOTE: Initialize the Eagle test constraints.
   867    913     #
   868    914     if {[isEagle]} then {
   869    915       #
   870    916       # NOTE: *WARNING* This has the effect of removing test constraints
   871    917       #       added prior to this point.
   872    918       #
   873         -    initializeTests; configureTcltest [list] [list] [list] [list] false
          919  +    initializeTests; configureTcltest "" [list] [list] [list] [list] false
   874    920   
   875    921       #
   876    922       # NOTE: If the "no(mono)" variable is set (to anything) then any
   877    923       #       special test suite hacks for Mono will be disabled. This
   878    924       #       does not control or change any hacks for Mono that may
   879    925       #       be present in the library itself.
   880    926       #
................................................................................
  2239   2285       ###########################################################################
  2240   2286       ########################## END Eagle Constraints ##########################
  2241   2287       ###########################################################################
  2242   2288     } else {
  2243   2289       #
  2244   2290       # NOTE: Make sure that Tcl honors the Eagle test constraints.
  2245   2291       #
  2246         -    configureTcltest $test_flags(-match) $test_flags(-skip) \
  2247         -        $test_flags(-constraints) [list] false
         2292  +    configureTcltest \
         2293  +        [expr {[info exists test_flags(-verbose)] ? \
         2294  +            $test_flags(-verbose) : ""}] \
         2295  +        [expr {[info exists test_flags(-match)] ? \
         2296  +            $test_flags(-match) : [list]}] \
         2297  +        [expr {[info exists test_flags(-skip)] ? \
         2298  +            $test_flags(-skip) : [list]}] \
         2299  +        [expr {[info exists test_flags(-constraints)] ? \
         2300  +            $test_flags(-constraints) : [list]}] \
         2301  +        [list] false
  2248   2302   
  2249   2303       #
  2250   2304       # HACK: Reset the test counts for tcltest.
  2251   2305       #
  2252   2306       set ::tcltest::numTests(Total) 0
  2253   2307       set ::tcltest::numTests(Skipped) 0
  2254   2308       set ::tcltest::numTests(Passed) 0
................................................................................
  2383   2437       # NOTE: For test "processIsolation-1.1".
  2384   2438       #
  2385   2439       if {![info exists no(isolated.eagle)]} then {
  2386   2440         checkForFile $test_channel [file join $test_data_path isolated.eagle]
  2387   2441       }
  2388   2442   
  2389   2443       #
  2390         -    # NOTE: This is not currently used by any tests.
         2444  +    # NOTE: For test "basic-1.73".
         2445  +    #
         2446  +    if {![info exists no(callStack.eagle)]} then {
         2447  +      checkForFile $test_channel [file join $test_data_path callStack.eagle]
         2448  +    }
         2449  +
         2450  +    #
         2451  +    # NOTE: This is not currently used by any tests.  However, it is
         2452  +    #       used by the sample targets file "Eagle.Sample.targets".
  2391   2453       #
  2392   2454       if {![info exists no(evaluate.eagle)]} then {
  2393   2455         checkForFile $test_channel [file join $test_data_path evaluate.eagle]
  2394   2456       }
  2395   2457   
  2396   2458       #
  2397         -    # NOTE: This is not currently used by any tests.
         2459  +    # NOTE: This is not currently used by any tests.  However, it is
         2460  +    #       used by the sample targets file "Eagle.Sample.targets".
  2398   2461       #
  2399   2462       if {![info exists no(substitute.eagle)]} then {
  2400   2463         checkForFile $test_channel [file join $test_data_path substitute.eagle]
  2401   2464       }
  2402   2465   
  2403   2466       #
  2404   2467       # NOTE: This is not currently used by any tests.
................................................................................
  2919   2982       } elseif {$test_cops < $test_base_cops} then {
  2920   2983         if {![info exists no(slowerBogoCops)]} then {
  2921   2984           addConstraint sameOrSlowerBogoCops
  2922   2985           addConstraint slowerBogoCops
  2923   2986   
  2924   2987           if {![info exists no(bogoCopsMultipliers)]} then {
  2925   2988             foreach multiplier $test_base_cops_multipliers {
  2926         -            if {$test_cops <= $test_base_cops * (1.0 / $multiplier)} then {
         2989  +            if {$multiplier != 0 && \
         2990  +                $test_cops <= $test_base_cops * (1.0 / $multiplier)} then {
  2927   2991                 addConstraint [appendArgs slowerBogoCopsBy $multiplier X]
  2928   2992               }
  2929   2993             }
  2930   2994   
  2931   2995             unset multiplier
  2932   2996           }
  2933   2997         }