System.Data.SQLite
Check-in [12a71d6811]
Not logged in

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

Overview
Comment:Update Eagle script library in externals to the latest trunk code.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | nextRelease
Files: files | file ages | folders
SHA1: 12a71d6811f6f3da46f2458f8c9c8e78cdc42f0e
User & Date: mistachkin 2015-03-03 03:15:00
Context
2015-03-04
19:42
Improve coding style in the CountParents method. check-in: 528007e621 user: mistachkin tags: nextRelease
2015-03-03
03:15
Update Eagle script library in externals to the latest trunk code. check-in: 12a71d6811 user: mistachkin tags: nextRelease
02:54
Pickup release archive verification tool changes from upstream. check-in: 8692ce7849 user: mistachkin tags: nextRelease
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

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

   835    835           #
   836    836           # NOTE: Grab the Nth process array element value using the
   837    837           #       accessor method.
   838    838           #
   839    839           set process [$array -alias GetValue $index]
   840    840   
   841    841           #
   842         -        # NOTE: Add the Id of the process to the result list.
          842  +        # NOTE: Add the Id of the process to the result list.  This
          843  +        #       may fail on some versions of Mono.
   843    844           #
   844         -        lappend result [$process Id]
          845  +        if {[catch {$process Id} id] == 0} then {
          846  +          lappend result $id
          847  +        }
   845    848   
   846    849           #
   847    850           # NOTE: Get rid of the process object, we no longer need it.
   848    851           #       Technically, it is not a requirement to explicitly
   849    852           #       unset variables that contain object references;
   850    853           #       however, it is useful in helping to document the
   851    854           #       code.
................................................................................
  1237   1240       proc runUpdateAndExit { {automatic false} } {
  1238   1241         set directory [file dirname [info nameofexecutable]]
  1239   1242   
  1240   1243         set command [list exec -shell -- \
  1241   1244             [file join $directory Hippogriff.exe] -delay 2000]
  1242   1245   
  1243   1246         if {$automatic} then {
  1244         -        eval lappend command -silent true -confirm false
         1247  +        lappend command -silent true -confirm false
         1248  +      }
         1249  +
         1250  +      set baseUri [getUpdateBaseUri]
         1251  +
         1252  +      if {[string length $baseUri] > 0} then {
         1253  +        lappend command -baseUri $baseUri
  1245   1254         }
  1246   1255   
  1247   1256         eval $command &; exit -force
  1248   1257       }
         1258  +
         1259  +    proc getUpdateBaseUri {} {
         1260  +      #
         1261  +      # NOTE: Check the current base URI for updates against the one baked
         1262  +      #       into the assembly.  If they are different, then the base URI
         1263  +      #       must have been overridden.  In that case, we must return the
         1264  +      #       current base URI; otherwise, we must return an empty string.
         1265  +      #
         1266  +      set baseUri(0) [info engine UpdateBaseUri false]; # NOTE: Current.
         1267  +      set baseUri(1) [info engine UpdateBaseUri true];  # NOTE: Default.
         1268  +
         1269  +      if {[string length $baseUri(0)] > 0 && \
         1270  +          [string length $baseUri(1)] > 0} then {
         1271  +        #
         1272  +        # NOTE: Ok, they are both valid.  Are they different?
         1273  +        #
         1274  +        if {$baseUri(0) ne $baseUri(1)} then {
         1275  +          return $baseUri(0)
         1276  +        }
         1277  +      }
         1278  +
         1279  +      return ""
         1280  +    }
  1249   1281   
  1250   1282       proc getUpdateData { uri } {
  1251   1283         #
  1252   1284         # NOTE: Start trusting ONLY our own self-signed SSL certificate.
  1253   1285         #
  1254   1286         set trusted true
  1255   1287   
................................................................................
  1309   1341       #       "#check" command.  To disable this functionality, simply
  1310   1342       #       redefine this procedure to do nothing.
  1311   1343       #
  1312   1344       proc checkForUpdate {
  1313   1345               {wantScripts false} {quiet false} {prompt false}
  1314   1346               {automatic false} } {
  1315   1347         #
  1316         -      # NOTE: This should work properly in Eagle only.
         1348  +      # NOTE: Grab the base URI for updates.
         1349  +      #
         1350  +      set updateBaseUri [info engine UpdateBaseUri]
         1351  +
         1352  +      #
         1353  +      # NOTE: Append the path and query string used for updates to it.
  1317   1354         #
  1318   1355         set updateUri [appendArgs \
  1319         -          [info engine UpdateBaseUri] [info engine UpdatePathAndQuery]]
         1356  +          $updateBaseUri [info engine UpdatePathAndQuery]]
  1320   1357   
  1321   1358         #
  1322   1359         # NOTE: Fetch the master update data from the distribution site
  1323   1360         #       and normalize to Unix-style line-endings.
  1324   1361         #
  1325   1362         set updateData [string map [list \r\n \n] [getUpdateData $updateUri]]
  1326   1363   
................................................................................
  1423   1460                 #
  1424   1461                 set timeStamp [lindex $fields 5]
  1425   1462   
  1426   1463                 if {[string length $timeStamp] == 0} then {
  1427   1464                   set timeStamp 0; #never?
  1428   1465                 }
  1429   1466   
         1467  +              #
         1468  +              # NOTE: What should the DateTime format be for display?  This
         1469  +              #       should be some variation on ISO-8601.
         1470  +              #
         1471  +              set dateTimeFormat yyyy-MM-ddTHH:mm:ss
         1472  +
  1430   1473                 #
  1431   1474                 # NOTE: Does it look like the number of seconds since the epoch
  1432   1475                 #       or some kind of date/time string?
  1433   1476                 #
  1434   1477                 if {[string is integer -strict $timeStamp]} then {
  1435         -                set dateTime [clock format $timeStamp]
         1478  +                set dateTime [clock format \
         1479  +                    $timeStamp -format $dateTimeFormat]
  1436   1480                 } else {
  1437         -                set dateTime [clock format [clock scan $timeStamp]]
         1481  +                set dateTime [clock format \
         1482  +                    [clock scan $timeStamp] -format $dateTimeFormat]
  1438   1483                 }
  1439   1484   
  1440   1485                 #
  1441   1486                 # NOTE: Grab the patch level for the running engine.
  1442   1487                 #
  1443   1488                 set enginePatchLevel [info engine PatchLevel]
  1444   1489   
................................................................................
  1452   1497                 }
  1453   1498   
  1454   1499                 #
  1455   1500                 # NOTE: Does it look like the number of seconds since the epoch
  1456   1501                 #       or some kind of date/time string?
  1457   1502                 #
  1458   1503                 if {[string is integer -strict $engineTimeStamp]} then {
  1459         -                set engineDateTime [clock format $engineTimeStamp]
         1504  +                set engineDateTime [clock format \
         1505  +                    $engineTimeStamp -format $dateTimeFormat]
  1460   1506                 } else {
  1461         -                set engineDateTime [clock format [clock scan $engineTimeStamp]]
         1507  +                set engineDateTime [clock format \
         1508  +                    [clock scan $engineTimeStamp] -format $dateTimeFormat]
  1462   1509                 }
  1463   1510   
  1464   1511                 #
  1465   1512                 # NOTE: For build lines, compare the patch level from the line
  1466   1513                 #       to the one we are currently using using a simple patch
  1467   1514                 #       level comparison.
  1468   1515                 #
................................................................................
  1532   1579                     #
  1533   1580                     # NOTE: Are we supposed to prompt the interactive user,
  1534   1581                     #       if any, to upgrade now?
  1535   1582                     #
  1536   1583                     set text [appendArgs \
  1537   1584                         "latest build " $patchLevel ", dated " $dateTime \
  1538   1585                         ", is newer than the running build " $enginePatchLevel \
  1539         -                      ", dated " $engineDateTime]
         1586  +                      ", dated " $engineDateTime ", based on data from " \
         1587  +                      $updateBaseUri]
  1540   1588   
  1541   1589                     if {$prompt && [isInteractive]} then {
  1542   1590                       set caption [appendArgs \
  1543   1591                           [info engine Name] " " [lindex [info level 0] 0]]
  1544   1592   
  1545   1593                       if {[object invoke -flags +NonPublic \
  1546   1594                           Eagle._Components.Private.WindowOps YesOrNo \
................................................................................
  1771   1819                   #
  1772   1820                   # NOTE: The patch level from the line is less, we are more
  1773   1821                   #       up-to-date than the latest version?
  1774   1822                   #
  1775   1823                   return [list [appendArgs \
  1776   1824                       "running build " $enginePatchLevel ", dated " \
  1777   1825                       $engineDateTime ", is newer than the latest build " \
  1778         -                    $patchLevel ", dated " $dateTime]]
         1826  +                    $patchLevel ", dated " $dateTime ", based on data " \
         1827  +                    "from " $updateBaseUri]]
  1779   1828                 } elseif {$checkBuild} then {
  1780   1829                   #
  1781   1830                   # NOTE: The patch levels are equal, we are up-to-date.
  1782   1831                   #
  1783   1832                   return [list [appendArgs \
  1784   1833                       "running build " $enginePatchLevel ", dated " \
  1785         -                    $engineDateTime ", is the latest build"]]
         1834  +                    $engineDateTime ", is the latest build, based on " \
         1835  +                    "data from " $updateBaseUri]]
  1786   1836                 }
  1787   1837               }
  1788   1838             }
  1789   1839           }
  1790   1840         }
  1791   1841   
  1792   1842         #

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 -stopOnLeak \
   491         -        -suffix -suite -tclsh -threshold]
          490  +        -postWait -preWait -randomOrder -skip -startFile -stopFile \
          491  +        -stopOnFailure -stopOnLeak -suffix -suite -tclsh -threshold]
   492    492   
   493    493       set length [llength $args]
   494    494   
   495    495       for {set index 0} {$index < $length} {incr index} {
   496    496         #
   497    497         # NOTE: Grab the current list element, which should be the name of
   498    498         #       the test option.
................................................................................
  1970   1970             if {[isEagle]} then {
  1971   1971               set before $::eagle_tests(Failed)
  1972   1972             } else {
  1973   1973               set before $::tcltest::numTests(Failed)
  1974   1974             }
  1975   1975   
  1976   1976             #
  1977         -          # NOTE: Evaluate the file in the context of the caller,
  1978         -          #       catching any errors.  If an error is raised and the
  1979         -          #       stop-on-failure flag is set, assume it was a test
  1980         -          #       failure and that we need to stop any and all further
  1981         -          #       processing of test files.
         1977  +          # NOTE: Evaluate the test file, optionally waiting for a certain
         1978  +          #       number of milliseconds before and/or after doing so.
  1982   1979             #
  1983         -          if {[catch {uplevel 1 [list source $fileName]} error]} then {
         1980  +          if {[catch {
         1981  +            #
         1982  +            # NOTE: Are we being prevented from waiting before the file?
         1983  +            #
         1984  +            if {![info exists ::no(preWait)]} then {
         1985  +              if {[info exists ::test_wait(pre)] && \
         1986  +                  [string is integer -strict $::test_wait(pre)]} then {
         1987  +                tputs $channel [appendArgs \
         1988  +                    "---- waiting for " $::test_wait(pre) \
         1989  +                    " milliseconds before test file...\n"]
         1990  +
         1991  +                after $::test_wait(pre); # NOTE: Sleep.
         1992  +              }
         1993  +            }
         1994  +
         1995  +            #
         1996  +            # NOTE: Evaluate the file in the context of the caller,
         1997  +            #       catching any errors.  If an error is raised and the
         1998  +            #       stop-on-failure flag is set, assume it was a test
         1999  +            #       failure and that we need to stop any and all further
         2000  +            #       processing of test files.
         2001  +            #
         2002  +            uplevel 1 [list source $fileName]
         2003  +
         2004  +            #
         2005  +            # NOTE: Are we being prevented from waiting after the file?
         2006  +            #
         2007  +            if {![info exists ::no(postWait)]} then {
         2008  +              if {[info exists ::test_wait(post)] && \
         2009  +                  [string is integer -strict $::test_wait(post)]} then {
         2010  +                tputs $channel [appendArgs \
         2011  +                    "---- waiting for " $::test_wait(post) \
         2012  +                    " milliseconds after test file...\n"]
         2013  +
         2014  +                after $::test_wait(post); # NOTE: Sleep.
         2015  +              }
         2016  +            }
         2017  +          } error]} then {
  1984   2018               #
  1985   2019               # NOTE: Most likely, this error was caused by malformed or
  1986   2020               #       incorrect code in-between the tests themselves.  We
  1987   2021               #       need to report this.
  1988   2022               #
  1989   2023               tputs $channel [appendArgs "==== \"" $fileName "\" ERROR \"" \
  1990   2024                   $error \"\n]
................................................................................
  2563   2597           }
  2564   2598         } else {
  2565   2599           return true; # already dead?
  2566   2600         }
  2567   2601   
  2568   2602         return false; # still alive (or error).
  2569   2603       }
         2604  +
         2605  +    proc reportTestConstraintCounts { channel skippedNames } {
         2606  +      #
         2607  +      # NOTE: Process the list of skipped tests, which is really a dictionary
         2608  +      #       of test names to the list of constraints that caused them to be
         2609  +      #       skipped.  We need to "roll them up", on a per-constraint basis,
         2610  +      #       and produce counts for each constraint.  At the same time, we
         2611  +      #       need to keep track of the maximum count seen, to help align the
         2612  +      #       final output.
         2613  +      #
         2614  +      set maximum 0
         2615  +
         2616  +      foreach {testName constraintNames} $skippedNames {
         2617  +        foreach constraintName $constraintNames {
         2618  +          if {[info exists skippedCounts($constraintName)]} then {
         2619  +            incr skippedCounts($constraintName)
         2620  +          } else {
         2621  +            set skippedCounts($constraintName) 1
         2622  +          }
         2623  +
         2624  +          if {$skippedCounts($constraintName) > $maximum} then {
         2625  +            set maximum $skippedCounts($constraintName)
         2626  +          }
         2627  +        }
         2628  +      }
         2629  +
         2630  +      #
         2631  +      # NOTE: Produce the final output, which includes a single line header
         2632  +      #       followed by one line per test constraint seen.
         2633  +      #
         2634  +      if {$maximum > 0 && [array size skippedCounts] > 0} then {
         2635  +        set places [expr {int(log10($maximum)) + 1}]
         2636  +
         2637  +        tputs $channel "Number of tests skipped for each constraint:\n"
         2638  +
         2639  +        foreach {name value} [array get skippedCounts] {
         2640  +          tputs $channel [appendArgs \
         2641  +              \t [format [appendArgs % $places s] $value] \t $name \n]
         2642  +        }
         2643  +
         2644  +        tputs $channel \n
         2645  +      }
         2646  +    }
  2570   2647   
  2571   2648       proc purgeAndCleanup { channel name } {
  2572   2649         catch {uplevel 1 [list debug purge]} result
  2573   2650   
  2574   2651         tputs $channel [appendArgs \
  2575   2652             "---- purge \"" $name "\" results: " $result \n]
  2576   2653   

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

    39     39           NET_20_SP1 NET_20_SP2 NET_30 NET_35 NET_40 NET_45 NET_451 NET_452 \
    40     40           NON_WORKING_CODE NOTIFY NOTIFY_ACTIVE NOTIFY_ARGUMENTS \
    41     41           NOTIFY_EXCEPTION NOTIFY_EXECUTE NOTIFY_EXPRESSION NOTIFY_GLOBAL \
    42     42           NOTIFY_OBJECT OBSOLETE OFFICIAL PARSE_CACHE PATCHLEVEL POLICY_TRACE \
    43     43           PREVIOUS_RESULT RANDOMIZE_ID REMOTING SAMPLE SERIALIZATION \
    44     44           SHARED_ID_POOL SHELL SOURCE_ID SOURCE_TIMESTAMP STATIC TCL TCL_KITS \
    45     45           TCL_THREADED TCL_THREADS TCL_UNICODE TCL_WRAPPER TEST THREADING \
    46         -        THROW_ON_DISPOSED TRACE TYPE_CACHE UNIX VERBOSE WEB WINDOWS WINFORMS \
    47         -        WIX_30 WIX_35 WIX_36 WIX_37 WIX_38 X64 X86 XML]
           46  +        THROW_ON_DISPOSED TRACE TYPE_CACHE UNIX USE_NAMESPACES VERBOSE WEB \
           47  +        WINDOWS WINFORMS WIX_30 WIX_35 WIX_36 WIX_37 WIX_38 WIX_39 X64 X86 XML]
    48     48     }
    49     49   
    50     50     proc getKnownMonoVersions {} {
    51     51       #
    52     52       # NOTE: This job of this procedure is to return the list of "known"
    53     53       #       versions of Mono supported by the test suite infrastructure.
    54     54       #
    55     55       return [list \
    56     56           [list 2 0] [list 2 2] [list 2 4] [list 2 6] [list 2 8] [list 2 10] \
    57     57           [list 2 11] [list 2 12] [list 3 0] [list 3 1] [list 3 2] [list 3 3] \
    58         -        [list 3 4] [list 3 5] [list 3 6]]
           58  +        [list 3 4] [list 3 5] [list 3 6] [list 3 8] [list 3 10] [list 3 12]]
    59     59     }
    60     60   
    61     61     #
    62     62     # NOTE: This procedure was adapted from the one listed on the Tcl Wiki page
    63     63     #       at "http://wiki.tcl.tk/43".  It is only intended to be used on very
    64     64     #       small lists because of its heavy use of recursion and complexity on
    65     65     #       the order of O(N!).
................................................................................
   102    102       #       return true.
   103    103       #
   104    104       return [expr {
   105    105         [catch {interp readylimit {}} readylimit] != 0 || $readylimit == 0
   106    106       }]
   107    107     }
   108    108   
          109  +  #
          110  +  # NOTE: This procedure should return non-zero if the "whoami" command may
          111  +  #       be executed by the test suite infrastructure outside the context
          112  +  #       of any specific tests.
          113  +  #
          114  +  proc canExecWhoAmI {} {
          115  +    if {[info exists ::no(exec)]} then {
          116  +      return false
          117  +    }
          118  +
          119  +    if {[info exists ::no(whoami)]} then {
          120  +      return false
          121  +    }
          122  +
          123  +    if {[info exists ::no(canExecWhoAmI)]} then {
          124  +      return false
          125  +    }
          126  +
          127  +    return true
          128  +  }
          129  +
   109    130     #
   110    131     # NOTE: This procedure should return non-zero if the native Tcl shell may
   111    132     #       be executed by the test suite infrastructure outside the context
   112    133     #       of any specific tests.  The specific tests themselves must make
   113    134     #       use of their own constraints to prevent execution of the native
   114    135     #       Tcl shell.
   115    136     #
................................................................................
   146    167   
   147    168       if {[info exists ::no(canExecFossil)]} then {
   148    169         return false
   149    170       }
   150    171   
   151    172       return true
   152    173     }
          174  +
          175  +  #
          176  +  # NOTE: This procedure should return non-zero if the test suite should be
          177  +  #       considered to be running on Mono.
          178  +  #
          179  +  proc isTestMono {} {
          180  +    return [expr {![info exists ::no(mono)] && [isMono]}]
          181  +  }
          182  +
          183  +  proc isTestAdministrator { {force false} } {
          184  +    #
          185  +    # NOTE: This is a workaround for the [isAdministrator] procedure being
          186  +    #       inaccurate for Mono on Windows, primarily due to the inability
          187  +    #       of Mono to call a P/Invoke method by ordinal.  Also, this can
          188  +    #       be used for native Tcl on Windows.  This only works on Windows.
          189  +    #
          190  +    if {[isWindows]} then {
          191  +      #
          192  +      # NOTE: Normally, this is only used for native Tcl or Eagle on Mono;
          193  +      #       however, it can be used for Eagle on the .NET Framework if
          194  +      #       forced.
          195  +      #
          196  +      if {$force || ![isEagle] || [isTestMono]} then {
          197  +        if {[canExecWhoAmI] && \
          198  +            [catch {exec -- whoami /groups} groups] == 0} then {
          199  +          set groups [string map [list \r\n \n] $groups]
          200  +
          201  +          foreach group [split $groups \n] {
          202  +            #
          203  +            # NOTE: Match this group line against the "well-known" SID for
          204  +            #       the "Administrators" group on Windows.
          205  +            #
          206  +            if {[regexp -- {\sS-1-5-32-544\s} $group]} then {
          207  +              #
          208  +              # NOTE: Match this group line against the attributes column
          209  +              #       sub-value that should be present when running with
          210  +              #       elevated administrator credentials.
          211  +              #
          212  +              if {[regexp -- {\sEnabled group(?:,|\s)} $group]} then {
          213  +                return true
          214  +              }
          215  +            }
          216  +          }
          217  +        }
          218  +      }
          219  +    }
          220  +
          221  +    #
          222  +    # NOTE: We must be running in native Tcl, running on Unix, running in
          223  +    #       Eagle on the .NET Framework, or unable to execute the "whoami"
          224  +    #       command.  If running in Eagle, we can just fallback to using
          225  +    #       the [isAdministrator] procedure; otherwise, just return false.
          226  +    #
          227  +    return [expr {[isEagle] ? [isAdministrator] : false}]
          228  +  }
          229  +
          230  +  proc canPing { {varName ""} } {
          231  +    #
          232  +    # NOTE: If requested by the caller, provide a reason whenever false is
          233  +    #       returned from this procedure.
          234  +    #
          235  +    if {[string length $varName] > 0} then {
          236  +      upvar 1 $varName reason
          237  +    }
          238  +
          239  +    #
          240  +    # NOTE: Native Tcl (without extra packages) does not provide support for
          241  +    #       pinging a network host.
          242  +    #
          243  +    if {[isEagle]} then {
          244  +      if {[isTestMono]} then {
          245  +        #
          246  +        # NOTE: Using [uri ping] on the Mono 3.3.0 (or 3.4.0?) release will
          247  +        #       lock up the process; therefore, skip it in that case.
          248  +        #
          249  +        if {[haveConstraint mono33] || [haveConstraint mono34]} then {
          250  +          set reason "skipped, may hang on Mono 3.3.0 and 3.4.0"
          251  +          return false
          252  +        }
          253  +
          254  +        #
          255  +        # NOTE: Other versions of Mono, e.g. 3.12, appear to require elevated
          256  +        #       privileges (i.e. full administrator) in order to successfully
          257  +        #       execute [uri ping].  This has been verified on Windows.
          258  +        #
          259  +        if {![isTestAdministrator]} then {
          260  +          set reason "skipped, need administrator privileges"
          261  +          return false
          262  +        }
          263  +      }
          264  +
          265  +      #
          266  +      # NOTE: Eagle, when running on the Microsoft .NET Framework, supports
          267  +      #       pinging a network host as long as it was compiled with network
          268  +      #       support (which this procedure purposely does not check).  That
          269  +      #       is done using [checkForCompileOption], by the test prologue.
          270  +      #
          271  +      return true
          272  +    }
          273  +
          274  +    set reason "skipped, need Eagle"
          275  +    return false
          276  +  }
   153    277   
   154    278     proc checkForTestSuiteFiles { channel } {
   155    279       tputs $channel "---- checking for test suite files... "
   156    280   
   157    281       #
   158    282       # NOTE: Start out with no test suite files to check.
   159    283       #
................................................................................
  1427   1551       if {![info exists ::no(bigLists)]} then {
  1428   1552         if {[isEagle]} then {
  1429   1553           #
  1430   1554           # MONO: Using the native utility library when running on Mono to
  1431   1555           #       join big lists seems to cause StackOverflowException to
  1432   1556           #       be thrown.
  1433   1557           #
  1434         -        if {[info exists ::no(mono)] || ![isMono] || \
  1435         -            ![haveConstraint nativeUtility]} then {
         1558  +        if {![isTestMono] || ![haveConstraint nativeUtility]} then {
  1436   1559             #
  1437   1560             # NOTE: Yes, it appears that it is available.
  1438   1561             #
  1439   1562             addConstraint bigLists
  1440   1563   
  1441   1564             tputs $channel yes\n
  1442   1565           } else {
................................................................................
  1447   1570   
  1448   1571           tputs $channel yes\n
  1449   1572         }
  1450   1573       } else {
  1451   1574         tputs $channel no\n
  1452   1575       }
  1453   1576     }
         1577  +
         1578  +  proc checkForTimeIntensive { channel } {
         1579  +    tputs $channel "---- checking for time intensive testing... "
         1580  +
         1581  +    #
         1582  +    # NOTE: Are we allowed to do time intensive testing?
         1583  +    #
         1584  +    if {![info exists ::no(timeIntensive)]} then {
         1585  +      addConstraint timeIntensive
         1586  +
         1587  +      tputs $channel yes\n
         1588  +    } else {
         1589  +      tputs $channel no\n
         1590  +    }
         1591  +  }
  1454   1592   
  1455   1593     proc checkForMemoryIntensive { channel } {
  1456   1594       tputs $channel "---- checking for memory intensive testing... "
  1457   1595   
  1458   1596       #
  1459   1597       # NOTE: Are we allowed to do memory intensive testing?
  1460   1598       #
................................................................................
  1569   1707           "---- checking for network connectivity to host \"" $host "\"... "]
  1570   1708   
  1571   1709       if {[isEagle]} then {
  1572   1710         #
  1573   1711         # NOTE: Running this check on the Mono 3.3.0 (or 3.4.0?) release build
  1574   1712         #       will lock up the process; therefore, skip it in that case.
  1575   1713         #
  1576         -      if {[info exists ::no(mono)] || ![isMono] || \
  1577         -          (![haveConstraint mono33] && ![haveConstraint mono34])} then {
         1714  +      set reason unknown
         1715  +
         1716  +      if {[canPing reason]} then {
  1578   1717           #
  1579   1718           # BUGBUG: Tcl 8.4 does not like this expression (and Tcl tries to
  1580   1719           #         compile it even though it will only actually ever be
  1581   1720           #         evaluated in Eagle).
  1582   1721           #
  1583   1722           set expr {[llength [info commands uri]] > 0 && \
  1584   1723               [catch {uri ping $host $timeout} response] == 0 && \
................................................................................
  1596   1735             addConstraint [appendArgs network_ $host]
  1597   1736   
  1598   1737             tputs $channel [appendArgs "yes (" $response ")\n"]
  1599   1738           } else {
  1600   1739             tputs $channel no\n
  1601   1740           }
  1602   1741         } else {
  1603         -        tputs $channel "skipped, may hang on Mono 3.3.0 and 3.4.0\n"
         1742  +        tputs $channel [appendArgs $reason \n]
  1604   1743         }
  1605   1744       } else {
  1606   1745         #
  1607   1746         # HACK: Running in Tcl, just assume we have network access.
  1608   1747         #
  1609   1748         addConstraint [appendArgs network_ $host]
  1610   1749   
................................................................................
  1813   1952           tputs $channel no\n
  1814   1953         }
  1815   1954       }
  1816   1955   
  1817   1956       proc checkForCertificate { channel } {
  1818   1957         tputs $channel "---- checking for certificate... "
  1819   1958   
  1820         -      if {[catch {object invoke Interpreter.GetActive GetCertificate} \
  1821         -              certificate] == 0 && \
  1822         -          [string length $certificate] > 0} then {
         1959  +      if {[catch {
         1960  +        object invoke Interpreter.GetActive GetCertificate
         1961  +      } certificate] == 0 && [string length $certificate] > 0} then {
  1823   1962           #
  1824   1963           # NOTE: Yes, it appears that the core library was signed with a
  1825   1964           #       code-signing certificate.
  1826   1965           #
  1827   1966           addConstraint certificate
  1828   1967   
  1829         -        tputs $channel [appendArgs "yes (" \
  1830         -            [object invoke $certificate Subject] ")\n"]
         1968  +        #
         1969  +        # NOTE: Attempt to query the subject from the certificate.
         1970  +        #
         1971  +        if {[catch {
         1972  +          object invoke $certificate Subject
         1973  +        } subject] != 0 || [string length $subject] == 0} then {
         1974  +          #
         1975  +          # TODO: No certificate subject, better handling here?
         1976  +          #
         1977  +          set subject unknown
         1978  +        }
         1979  +
         1980  +        tputs $channel [appendArgs "yes (" $subject ")\n"]
  1831   1981         } else {
  1832   1982           tputs $channel no\n
  1833   1983         }
  1834   1984       }
  1835   1985   
  1836   1986       proc checkForCompileCSharp { channel } {
  1837   1987         tputs $channel "---- checking for test use of C# compiler... "
................................................................................
  1844   1994           tputs $channel no\n
  1845   1995         }
  1846   1996       }
  1847   1997   
  1848   1998       proc checkForAdministrator { channel } {
  1849   1999         tputs $channel "---- checking for administrator... "
  1850   2000   
  1851         -      if {[isAdministrator]} then {
         2001  +      if {[isTestAdministrator]} then {
  1852   2002           addConstraint administrator; # running as full admin.
  1853   2003   
  1854   2004           tputs $channel yes\n
  1855   2005         } else {
  1856   2006           tputs $channel no\n
  1857   2007         }
  1858   2008       }
................................................................................
  1915   2065           tputs $channel [appendArgs "no (" $threadId ")\n"]
  1916   2066         }
  1917   2067       }
  1918   2068   
  1919   2069       proc checkForDefaultAppDomain { channel } {
  1920   2070         tputs $channel "---- checking for default application domain... "
  1921   2071   
  1922         -      if {[catch {object invoke AppDomain CurrentDomain} appDomain] == 0 && \
  1923         -          [string length $appDomain] > 0} then {
  1924         -        if {[object invoke $appDomain IsDefaultAppDomain]} then {
         2072  +      if {[catch {
         2073  +        object invoke AppDomain CurrentDomain
         2074  +      } appDomain] == 0 && [string length $appDomain] > 0} then {
         2075  +        if {[catch {
         2076  +          object invoke $appDomain IsDefaultAppDomain
         2077  +        } default] != 0 || [string length $default] == 0} then {
         2078  +          set default false
         2079  +        }
         2080  +
         2081  +        if {[catch {
         2082  +          object invoke $appDomain Id
         2083  +        } id] != 0 || [string length $id] == 0} then {
         2084  +          set id unknown
         2085  +        }
         2086  +
         2087  +        if {$default} then {
  1925   2088             addConstraint defaultAppDomain
  1926   2089   
  1927         -          tputs $channel [appendArgs "yes (" [object invoke $appDomain Id] \
  1928         -              ")\n"]
         2090  +          tputs $channel [appendArgs "yes (" $id ")\n"]
  1929   2091           } else {
  1930         -          tputs $channel [appendArgs "no (" [object invoke $appDomain Id] \
  1931         -              ")\n"]
         2092  +          tputs $channel [appendArgs "no (" $id ")\n"]
  1932   2093           }
  1933   2094         } else {
  1934   2095           tputs $channel [appendArgs "no (null)\n"]
  1935   2096         }
  1936   2097       }
  1937   2098   
  1938   2099       proc checkForRuntime { channel } {
  1939   2100         tputs $channel "---- checking for runtime... "
  1940   2101   
  1941   2102         #
  1942   2103         # NOTE: Are we running inside Mono (regardless of operating system)?
  1943   2104         #
  1944         -      if {![info exists ::no(mono)] && [isMono]} then {
         2105  +      if {[isTestMono]} then {
  1945   2106           #
  1946   2107           # NOTE: Yes, it appears that we are running inside Mono.
  1947   2108           #
  1948   2109           addConstraint mono; # running on Mono.
  1949   2110   
  1950   2111           tputs $channel [appendArgs [expr {[info exists \
  1951   2112               ::eagle_platform(runtime)] ? \
................................................................................
  2044   2205   
  2045   2206           #
  2046   2207           # NOTE: Now create a version string for use in the constraint name
  2047   2208           #       (remove the periods).
  2048   2209           #
  2049   2210           set version [string map [list . ""] $dotVersion]
  2050   2211   
  2051         -        if {![info exists ::no(mono)] && [isMono]} then {
         2212  +        if {[isTestMono]} then {
  2052   2213             #
  2053   2214             # NOTE: If the runtime version was found, add a test constraint
  2054   2215             #       for it now.
  2055   2216             #
  2056   2217             if {[string length $version] > 0} then {
  2057   2218                 #
  2058   2219                 # NOTE: We are running on Mono.  Keep track of the specific
................................................................................
  2471   2632         tputs $channel "---- checking for database... "
  2472   2633   
  2473   2634         #
  2474   2635         # HACK: Disable database connectivity testing on Mono because
  2475   2636         #       it fails to timeout (unless special test suite hacks
  2476   2637         #       for Mono have been disabled by the user).
  2477   2638         #
  2478         -      if {[info exists ::no(mono)] || ![isMono]} then {
         2639  +      if {![isTestMono]} then {
  2479   2640           #
  2480   2641           # NOTE: Can we access the local database?
  2481   2642           #
  2482   2643           if {[catch {sql open -type $type $string} connection] == 0} then {
  2483   2644             #
  2484   2645             # NOTE: Yes, it appears that we can connect to the local database.
  2485   2646             #
................................................................................
  2965   3126           } else {
  2966   3127             tputs $channel unknown\n
  2967   3128           }
  2968   3129         } else {
  2969   3130           tputs $channel no\n
  2970   3131         }
  2971   3132       }
         3133  +
         3134  +    proc checkForNetFx20ServicePack { channel } {
         3135  +      tputs $channel "---- checking for .NET Framework 2.0 Service Pack... "
         3136  +
         3137  +      #
         3138  +      # NOTE: Platform must be Windows for this constraint to even be
         3139  +      #       checked (i.e. we require the registry).
         3140  +      #
         3141  +      if {[isWindows]} then {
         3142  +        #
         3143  +        # NOTE: Registry hive where the .NET Framework 2.0 setup and
         3144  +        #       servicing information is stored.  No need to look in
         3145  +        #       the WoW64 registry because the .NET Framework should
         3146  +        #       be installed natively as well.
         3147  +        #
         3148  +        set key [appendArgs HKEY_LOCAL_MACHINE\\ \
         3149  +            {Software\Microsoft\NET Framework Setup\NDP\v2.0.50727}]
         3150  +
         3151  +        #
         3152  +        # NOTE: Attempt to fetch the .NET Framework 2.0 "SP" value from the
         3153  +        #       servicing registry hive.  If this value does not exist -OR-
         3154  +        #       is less than 1, then no .NET Framework 2.0 service pack is
         3155  +        #       installed.  If this raises a script error, that will almost
         3156  +        #       certainly cause the result to be a non-integer, this failing
         3157  +        #       the check below.
         3158  +        #
         3159  +        catch {
         3160  +          object invoke Microsoft.Win32.Registry GetValue $key SP null
         3161  +        } servicePack
         3162  +
         3163  +        if {[string is integer -strict $servicePack]} then {
         3164  +          #
         3165  +          # NOTE: Service packs are always cumulative; therefore, add test
         3166  +          #       constraints for all service pack levels up to the one that
         3167  +          #       is actually installed.
         3168  +          #
         3169  +          for {set level 0} {$level <= $servicePack} {incr level} {
         3170  +            addConstraint [appendArgs dotNet20Sp $level OrHigher]
         3171  +          }
         3172  +
         3173  +          #
         3174  +          # NOTE: Also add the "exact" service pack test constraint even
         3175  +          #       though it should almost never be used.
         3176  +          #
         3177  +          addConstraint [appendArgs dotNet20Sp $servicePack]
         3178  +
         3179  +          #
         3180  +          # NOTE: Show the "servicePack" value we found in the registry.
         3181  +          #
         3182  +          tputs $channel [appendArgs "yes (" $servicePack ")\n"]
         3183  +
         3184  +          #
         3185  +          # NOTE: We are done here, return now.
         3186  +          #
         3187  +          return
         3188  +        }
         3189  +      }
         3190  +
         3191  +      tputs $channel no\n
         3192  +    }
  2972   3193   
  2973   3194       proc checkForNetFx45 { channel } {
  2974   3195         tputs $channel "---- checking for .NET Framework 4.5... "
  2975   3196   
  2976   3197         #
  2977   3198         # NOTE: Platform must be Windows for this constraint to even be
  2978   3199         #       checked (i.e. we require the registry).
................................................................................
  2987   3208           set key [appendArgs HKEY_LOCAL_MACHINE\\ \
  2988   3209               {Software\Microsoft\NET Framework Setup\NDP\v4\Full}]
  2989   3210   
  2990   3211           #
  2991   3212           # NOTE: Attempt to fetch the .NET Framework 4.0 "release" value from
  2992   3213           #       the servicing registry hive.  If this value does not exist
  2993   3214           #       -OR- is less than 378389, then the .NET Framework 4.5 is not
  2994         -        #       installed.
         3215  +        #       installed.  If this raises a script error, that will almost
         3216  +        #       certainly cause the result to be a non-integer, this failing
         3217  +        #       the check below.
  2995   3218           #
  2996         -        set release [object invoke Microsoft.Win32.Registry GetValue $key \
  2997         -            Release null]
         3219  +        catch {
         3220  +          object invoke Microsoft.Win32.Registry GetValue $key Release null
         3221  +        } release
  2998   3222   
  2999   3223           if {[string is integer -strict $release] && $release >= 378389} then {
  3000   3224             #
  3001   3225             # NOTE: Yes, it appears that it is available.
  3002   3226             #
  3003   3227             addConstraint dotNet45OrHigher
  3004   3228   
  3005   3229             #
  3006         -          # NOTE: If the "release" value is greater than or equal to 378758,
  3007         -          #       then the .NET Framework 4.5.1 is installed.
         3230  +          # NOTE: If the "release" value is greater than or equal to 378758
         3231  +          #       (or 378675 for Windows 8.1), then the .NET Framework 4.5.1
         3232  +          #       is installed.  However, if the "release" value is also
         3233  +          #       greater than or equal to 379893, then the .NET Framework
         3234  +          #       4.5.2 is installed, which is an in-place upgrade to 4.5.1
         3235  +          #       (and 4.5).
  3008   3236             #
  3009         -          if {$release >= 378758} then {
         3237  +          if {$release >= 379893} then {
         3238  +            addConstraint dotNet452
         3239  +            addConstraint dotNet452OrHigher
         3240  +
         3241  +            set version 4.5.2
         3242  +          } elseif {$release >= 378675} then {
  3010   3243               addConstraint dotNet451
  3011   3244               addConstraint dotNet451OrHigher
  3012   3245   
  3013   3246               set version 4.5.1
  3014   3247             } else {
  3015   3248               addConstraint dotNet45
  3016   3249   
................................................................................
  3228   3461   
  3229   3462       #
  3230   3463       # NOTE: We need several of our test constraint related commands in the
  3231   3464       #       global namespace.
  3232   3465       #
  3233   3466       exportAndImportPackageCommands [namespace current] [list \
  3234   3467           getKnownCompileOptions getKnownMonoVersions lpermute \
  3235         -        alwaysFullInterpReady canExecTclShell canExecFossil \
  3236         -        checkForTestSuiteFiles checkForPlatform checkForWindowsVersion \
  3237         -        checkForScriptLibrary checkForVariable checkForTclOptions \
  3238         -        checkForWindowsCommandProcessor checkForFossil checkForEagle \
  3239         -        checkForSymbols checkForLogFile checkForGaruda checkForShell \
  3240         -        checkForDebug checkForTk checkForVersion checkForCommand \
  3241         -        checkForNamespaces checkForTestExec checkForTestMachine \
  3242         -        checkForTestPlatform checkForTestConfiguration checkForTestSuffix \
  3243         -        checkForFile checkForPathFile checkForNativeCode checkForTip127 \
  3244         -        checkForTip194 checkForTip207 checkForTip241 checkForTip285 \
  3245         -        checkForTip405 checkForTip426 checkForTip429 checkForTiming \
  3246         -        checkForPerformance checkForBigLists checkForMemoryIntensive \
  3247         -        checkForStackIntensive checkForInteractive checkForInteractiveCommand \
  3248         -        checkForUserInteraction checkForNetwork checkForCompileOption \
  3249         -        checkForKnownCompileOptions] false false
         3468  +        alwaysFullInterpReady canExecWhoAmI canExecTclShell canExecFossil \
         3469  +        isTestMono isTestAdministrator canPing checkForTestSuiteFiles \
         3470  +        checkForPlatform checkForWindowsVersion checkForScriptLibrary \
         3471  +        checkForVariable checkForTclOptions checkForWindowsCommandProcessor \
         3472  +        checkForFossil checkForEagle checkForSymbols checkForLogFile \
         3473  +        checkForGaruda checkForShell checkForDebug checkForTk checkForVersion \
         3474  +        checkForCommand checkForNamespaces checkForTestExec \
         3475  +        checkForTestMachine checkForTestPlatform checkForTestConfiguration \
         3476  +        checkForTestSuffix checkForFile checkForPathFile checkForNativeCode \
         3477  +        checkForTip127 checkForTip194 checkForTip207 checkForTip241 \
         3478  +        checkForTip285 checkForTip405 checkForTip426 checkForTip429 \
         3479  +        checkForTiming checkForPerformance checkForBigLists \
         3480  +        checkForTimeIntensive checkForMemoryIntensive checkForStackIntensive \
         3481  +        checkForInteractive checkForInteractiveCommand checkForUserInteraction \
         3482  +        checkForNetwork checkForCompileOption checkForKnownCompileOptions] false false
  3250   3483   
  3251   3484       ###########################################################################
  3252   3485       ############################## END Tcl ONLY ###############################
  3253   3486       ###########################################################################
  3254   3487     }
  3255   3488   
  3256   3489     #
  3257   3490     # NOTE: Provide the Eagle test constraints package to the interpreter.
  3258   3491     #
  3259   3492     package provide Eagle.Test.Constraints \
  3260   3493       [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
  3261   3494   }
  3262   3495   

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

   151    151               "==== test name \"" $name "\" BAD COUNT (" $count ")\n"]
   152    152         }
   153    153       }
   154    154   
   155    155       unset -nocomplain name count
   156    156   
   157    157       tputs $test_channel \n; # NOTE: Blank line.
          158  +    reportTestConstraintCounts $test_channel $eagle_tests(SkippedNames)
   158    159   
   159    160       if {$eagle_tests(Passed) > 0} then {
   160    161         tresult Ok [appendArgs "PASSED: " $eagle_tests(Passed) \n]
   161    162       }
   162    163   
   163    164       if {$eagle_tests(Failed) > 0} then {
   164    165         tresult Error [appendArgs "FAILED: " $eagle_tests(Failed) \n]

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

    18     18     if {[info level] > 0} then {
    19     19       error "cannot run, current level is not global"
    20     20     }
    21     21   
    22     22     #
    23     23     # NOTE: Make sure all the variables used by this prologue are unset.
    24     24     #
    25         -  unset -nocomplain pkg_dir pattern exec dummy directory name value expr \
    26         -      publicKeyToken encoding memory stack drive server database timeout \
           25  +  unset -nocomplain pkg_dir pattern dummy directory name value exec encoding \
           26  +      host memory stack drive publicKeyToken expr server database timeout \
    27     27         user password percent checkout timeStamp loaded
    28     28   
    29     29     #
    30     30     # NOTE: Indicate that the test suite is currently running.
    31     31     #
    32     32     if {![info exists test_suite_running] || !$test_suite_running} then {
    33     33       set test_suite_running true
................................................................................
   300    300     set test_flags(-randomOrder) ""; # default to deterministic order.
   301    301     set test_flags(-breakOnLeak) ""; # default to continue on leak.
   302    302     set test_flags(-stopOnFailure) ""; # default to continue on failure.
   303    303     set test_flags(-stopOnLeak) ""; # default to continue on leak.
   304    304     set test_flags(-exitOnComplete) ""; # default to not exit after complete.
   305    305     set test_flags(-preTest) ""; # default to not evaluating anything.
   306    306     set test_flags(-postTest) ""; # default to not evaluating anything.
          307  +  set test_flags(-preWait) ""; # default to not waiting.
          308  +  set test_flags(-postWait) ""; # default to not waiting.
   307    309     set test_flags(-tclsh) ""; # Tcl shell, default to empty.
   308    310   
   309    311     #
   310    312     # NOTE: Check for and process any command line arguments.
   311    313     #
   312    314     if {[info exists argv]} then {
   313    315       eval processTestArguments test_flags $argv
................................................................................
   399    401       if {[info exists test_flags(-postTest)] && \
   400    402           [string length $test_flags(-postTest)] > 0} then {
   401    403         #
   402    404         # NOTE: Set the pre-test script to the one provided by the command line.
   403    405         #
   404    406         set test_script(post) $test_flags(-postTest)
   405    407       }
          408  +
          409  +    if {[info exists test_flags(-preWait)] && \
          410  +        [string is integer -strict $test_flags(-preWait)]} then {
          411  +      #
          412  +      # NOTE: Set the specified wait (in milliseconds) before each file.
          413  +      #
          414  +      set test_wait(pre) $test_flags(-preWait)
          415  +    }
          416  +
          417  +    if {[info exists test_flags(-postWait)] && \
          418  +        [string is integer -strict $test_flags(-postWait)]} then {
          419  +      #
          420  +      # NOTE: Set the specified wait (in milliseconds) after each file.
          421  +      #
          422  +      set test_wait(post) $test_flags(-postWait)
          423  +    }
   406    424     }
   407    425   
   408    426     #
   409    427     # NOTE: Set the default test suite name, if necessary.
   410    428     #
   411    429     if {![info exists test_suite]} then {
   412    430       set test_suite [getTestSuite]
................................................................................
   553    571         [appendArgs \" $test_script(pre) \"] : "<none>"}] \n]
   554    572   
   555    573     tputs $test_channel [appendArgs "---- post-test script: " \
   556    574         [expr {[info exists test_script(post)] && \
   557    575         [string length $test_script(post)] > 0 ? \
   558    576         [appendArgs \" $test_script(post) \"] : "<none>"}] \n]
   559    577   
          578  +  #
          579  +  # NOTE: Show both the pre-test and post-test waits now, prior to actually
          580  +  #       using either of them (even if their use has been disabled).
          581  +  #
          582  +  tputs $test_channel [appendArgs "---- pre-test wait: " \
          583  +      [expr {[info exists test_wait(pre)] && \
          584  +      [string is integer -strict $test_wait(pre)] ? \
          585  +      [appendArgs $test_wait(pre) " milliseconds"] : \
          586  +      "<none>"}] \n]
          587  +
          588  +  tputs $test_channel [appendArgs "---- post-test wait: " \
          589  +      [expr {[info exists test_wait(post)] && \
          590  +      [string is integer -strict $test_wait(post)] ? \
          591  +      [appendArgs $test_wait(post) " milliseconds"] : \
          592  +      "<none>"}] \n]
          593  +
   560    594     #
   561    595     # NOTE: Are we being prevented from evaluating the "pre-test" script?
   562    596     #
   563    597     if {![info exists no(preTest)]} then {
   564    598       #
   565    599       # NOTE: Evaluate the specified pre-test script now, if any.
   566    600       #
................................................................................
   806    840   
   807    841       #
   808    842       # NOTE: If the "no(mono)" variable is set (to anything) then any
   809    843       #       special test suite hacks for Mono will be disabled. This
   810    844       #       does not control or change any hacks for Mono that may
   811    845       #       be present in the library itself.
   812    846       #
   813         -    # if {![info exists no(mono)] && [isMono]} then {
          847  +    # if {[isTestMono]} then {
   814    848       #   set no(mono) true
   815    849       # }
   816    850   
   817    851       ###########################################################################
   818    852       ######################### BEGIN Eagle Constraints #########################
   819    853       ###########################################################################
   820    854   
................................................................................
  1472   1506         }
  1473   1507       }
  1474   1508   
  1475   1509       #
  1476   1510       # NOTE: Has custom test method support been disabled?
  1477   1511       #
  1478   1512       if {![info exists no(core)] && ![info exists no(test)]} then {
         1513  +      #
         1514  +      # NOTE: Has plugin policy testing support been disabled?
         1515  +      #
         1516  +      if {![info exists no(testPluginPolicy)]} then {
         1517  +        #
         1518  +        # NOTE: For tests "load-2.0" and "load-2.1".
         1519  +        #
         1520  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1521  +            *TestAddLoadPluginPolicy*
         1522  +
         1523  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1524  +            *TestLoadPluginPolicy*
         1525  +      }
         1526  +
  1479   1527         #
  1480   1528         # NOTE: Has script stream testing support been disabled?
  1481   1529         #
  1482   1530         if {![info exists no(testScriptStream)]} then {
  1483   1531           #
  1484   1532           # NOTE: For tests "basic-1.46" and "basic-1.47".
  1485   1533           #
  1486   1534           checkForObjectMember $test_channel Eagle._Tests.Default \
  1487   1535               *TestScriptStream*
  1488   1536         }
         1537  +
         1538  +      #
         1539  +      # NOTE: Has complaint testing support been disabled?
         1540  +      #
         1541  +      if {![info exists no(testComplain)]} then {
         1542  +        #
         1543  +        # NOTE: For tests "debug-1.98" and "debug-1.99".
         1544  +        #
         1545  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1546  +            *TestSetComplainCallback*
         1547  +
         1548  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1549  +            *TestComplainCallbackThrow*
         1550  +
         1551  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1552  +            *TestComplainCallbackNoThrow*
         1553  +      }
  1489   1554   
  1490   1555         if {![info exists no(testLoad)]} then {
  1491   1556           #
  1492   1557           # NOTE: For tests "load-1.6" and "load-1.7".
  1493   1558           #
  1494   1559           checkForObjectMember $test_channel Eagle._Tests.Default \
  1495   1560               *TestLoadPluginViaBytes*
  1496   1561         }
         1562  +
         1563  +      if {![info exists no(testPermute)]} then {
         1564  +        #
         1565  +        # NOTE: For test "lpermute-1.3".
         1566  +        #
         1567  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1568  +            *TestPermute*
         1569  +      }
  1497   1570   
  1498   1571         #
  1499   1572         # NOTE: Has DateTime testing support been disabled?
  1500   1573         #
  1501   1574         if {![info exists no(testDateTime)]} then {
  1502   1575           #
  1503   1576           # NOTE: For test "vwait-1.11".
................................................................................
  1784   1857   
  1785   1858           #
  1786   1859           # NOTE: For test "object-4.1".
  1787   1860           #
  1788   1861           checkForObjectMember $test_channel Eagle._Tests.Default \
  1789   1862               *TestExpr*
  1790   1863   
         1864  +        #
         1865  +        # NOTE: For tests "basic-1.66", "basic-1.67", "basic-1.68",
         1866  +        #       and "basic-1.69".
         1867  +        #
         1868  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1869  +            *TestTakeEventHandler*
         1870  +
         1871  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1872  +            *TestTakeGenericEventHandler*
         1873  +
         1874  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         1875  +            *TestTakeResolveEventHandler*
         1876  +
  1791   1877           #
  1792   1878           # NOTE: For test "array-4.1".
  1793   1879           #
  1794   1880           checkForObjectMember $test_channel Eagle._Tests.Default \
  1795   1881               *TestTwoByteArrays*
  1796   1882   
  1797   1883           checkForObjectMember $test_channel Eagle._Tests.Default \
................................................................................
  1961   2047       #
  1962   2048       if {![info exists no(powerShell)]} then {
  1963   2049         #
  1964   2050         # NOTE: For tests "object-4.7", "object-4.8", and "object-4.9".
  1965   2051         #
  1966   2052         checkForPowerShell $test_channel
  1967   2053       }
         2054  +
         2055  +    #
         2056  +    # NOTE: Has .NET Framework 2.0 Service Pack testing support been
         2057  +    #       disabled?
         2058  +    #
         2059  +    if {![info exists no(netFx20Sp)]} then {
         2060  +      #
         2061  +      # NOTE: For test "hash-1.1".
         2062  +      #
         2063  +      checkForNetFx20ServicePack $test_channel
         2064  +    }
  1968   2065   
  1969   2066       #
  1970   2067       # NOTE: Has .NET Framework 4.5 testing support been disabled?
  1971   2068       #
  1972   2069       if {![info exists no(netFx45)]} then {
  1973   2070         #
  1974   2071         # NOTE: For test "object-12.1.*".
................................................................................
  2463   2560     if {![info exists no(tclOptions)]} then {
  2464   2561       checkForTclOptions $test_channel
  2465   2562     }
  2466   2563   
  2467   2564     if {![info exists no(checkForBigLists)]} then {
  2468   2565       checkForBigLists $test_channel
  2469   2566     }
         2567  +
         2568  +  if {![info exists no(checkForTimeIntensive)]} then {
         2569  +    checkForTimeIntensive $test_channel
         2570  +  }
  2470   2571   
  2471   2572     if {![info exists no(checkForMemoryIntensive)]} then {
  2472   2573       checkForMemoryIntensive $test_channel
  2473   2574     }
  2474   2575   
  2475   2576     if {![info exists no(checkForStackIntensive)]} then {
  2476   2577       checkForStackIntensive $test_channel