############################################################################### # # prologue.eagle -- # # Extensible Adaptable Generalized Logic Engine (Eagle) # Test Prologue File # # Copyright (c) 2007-2012 by Joe Mistachkin. All rights reserved. # # See the file "license.terms" for information on usage and redistribution of # this file, and for a DISCLAIMER OF ALL WARRANTIES. # # RCS: @(#) $Id: $ # ############################################################################### if {![info exists no([file tail [info script]])]} then { if {[info level] > 0} then { error "cannot run, current level is not global" } # # NOTE: Make sure all the variables used by this prologue are unset. # unset -nocomplain pkg_dir pattern exec dummy directory name value expr \ publicKeyToken encoding memory stack drive server database timeout \ user password percent checkout timeStamp loaded # # NOTE: Indicate that the test suite is currently running. # if {![info exists test_suite_running] || !$test_suite_running} then { set test_suite_running true } # # NOTE: Set the location of the test suite, if necessary. # if {![info exists test_path]} then { set test_path [file normalize [file dirname [info script]]] } # # NOTE: Set the location of the test suite data, if necessary. # if {![info exists test_data_path]} then { set test_data_path [file join $test_path data] } # # NOTE: Set the location of the base Eagle directory, if # necessary. # if {![info exists base_path]} then { # # NOTE: Start out going up one level and check for a "lib" # sub-directory. If not found, go up another level # because we will always be two levels down from the # base directory when running inside the source tree. # set base_path [file normalize [file dirname $test_path]] # # HACK: We must verify that the "init.eagle" file can eventually # be found under the "lib" directory since Visual Studio # insists on creating a superfluous (and empty) "lib\Eagle1.0" # sub-directory inside of the "Library" project directory # simply due to the links contained in the project file that # actually point to the "lib\Eagle1.0" sub-directory under the # solution directory. # # WARNING: The Eagle package name and version are hard-coded here. # set pkg_dir Eagle1.0; # TODO: Change me. if {![file exists [file join $base_path lib]] || \ ![file isdirectory [file join $base_path lib]] || \ ![file exists [file join $base_path lib $pkg_dir]] || \ ![file isdirectory [file join $base_path lib $pkg_dir]] || \ ![file exists [file join $base_path lib $pkg_dir init.eagle]] || \ ![file isfile [file join $base_path lib $pkg_dir init.eagle]]} then { # # NOTE: We do not bother to check if the "lib" sub-directory actually # exists as a child of this one. This is the previous (legacy) # behavior (i.e. where we always went up two levels to the base # directory). # set base_path [file dirname $base_path] } unset pkg_dir } ############################################################################# # # NOTE: Set the location of the Eagle main strong name keys directory, # if necessary. # if {![info exists key_path]} then { # # NOTE: Normally, there should be a "Keys" sub-directory just within # the base directory. # set key_path [file join $base_path Keys] } ############################################################################# # # NOTE: Set the executable file name for the process, if # necessary. # if {![info exists bin_file]} then { set bin_file [info nameofexecutable] } # # NOTE: Set the location of the directory containing the # executable file for the process, if necessary. # if {![info exists bin_path]} then { set bin_path [file normalize [file dirname $bin_file]] } # # NOTE: Set the location of the [non-script] library directory # (i.e. the directory where the plugins are located), if # necessary. # if {![info exists lib_path]} then { # # NOTE: This should go one directory up from the directory # containing the executable file for the process (e.g. # the shell) and then into the "lib" directory just # beneath that. # set lib_path [file normalize [file join [file dirname $bin_path] lib]] } # # NOTE: Set the web host to test against, if necessary. # if {![info exists test_host]} then { set test_host eagle.to } # # NOTE: Set the port to use for server sockets, if necessary. # if {![info exists test_port]} then { set test_port 12346; # IANA, 12346-12752 Unassigned } # # NOTE: Set the network timeout, if necessary. # if {![info exists test_timeout]} then { set test_timeout 2000; # in milliseconds. } # # NOTE: Set the channel to use for test output, if necessary. # if {![info exists test_channel]} then { set test_channel stdout } # # NOTE: Set the primary package path, if necessary. # if {![info exists test_package_path]} then { set test_package_path [file join $base_path lib] } # # NOTE: Make sure our primary package path is part of the auto-path. # if {[lsearch -exact $auto_path $test_package_path] == -1} then { lappend auto_path $test_package_path } # # NOTE: Make sure our test package path is part of the auto-path. # if {[lsearch -exact $auto_path $test_path] == -1} then { lappend auto_path $test_path } ############################################################################# # # NOTE: Check for and load the Eagle library package, if necessary. # if {[catch {package present Eagle.Library}]} then { package require Eagle.Library } # # NOTE: Check for and load the Eagle test package, if necessary. # if {[catch {package present Eagle.Test}]} then { package require Eagle.Test } # # NOTE: Check for and load the Eagle test constraints package, if # necessary. # if {[catch {package present Eagle.Test.Constraints}]} then { package require Eagle.Test.Constraints } ############################################################################# # # NOTE: Verify that the current call frame is correct and that the # interpreter call stack has not been imbalanced by previous # tests or other errors. This check only applies to Eagle. # This block requires the "Eagle.Library" package. # if {[isEagle]} then { # # NOTE: Check the name of the current call frame against the one # that should be used for evaluating this script file. # if {[object invoke -flags +NonPublic \ Interpreter.GetActive.CurrentFrame Name] ne \ [list source [file normalize [info script]]]} then { unset -nocomplain test_suite_running error "cannot run, current frame is not for this script" } } ############################################################################# # # NOTE: Set the local root directory of the source checkout (i.e. of Eagle # or whatever project the Eagle binaries are being used by) using a # Fossil binary in the PATH, if available. This block now requires # the "Eagle.Test.Constraints" package. # if {![info exists root_path]} then { # # NOTE: Is the use of Fossil by the test suite allowed? # if {[canExecFossil]} then { set pattern {^local-root:\s+(.*?)\s+$} if {[catch {exec -- fossil info} exec] || \ ![regexp -line -- $pattern $exec dummy directory]} then { # # NOTE: We could not query local root directory of the source # checkout from Fossil; therefore, attempt to make an # educated guess. This value will probably be wrong for # any project(s) other than Eagle. In that case, this # value should be overridden by that project to reflect # the actual local root directory of the source checkout # for that project. # set root_path $base_path } else { # # NOTE: We extracted the local root directory of the source # checkout from Fossil. Now, make sure it is fully # normalized and has no trailing slashes. # set root_path [file normalize $directory] } unset -nocomplain directory dummy exec pattern } else { # # NOTE: Use of Fossil by the test suite is forbidden. Fallback # to using the base path. # set root_path $base_path } } ############################################################################# # # NOTE: If command line arguments were supplied, process them now. # set test_flags(-suite) ""; # test suite name, default to empty. set test_flags(-machine) ""; # machine architecture, default to empty. set test_flags(-platform) ""; # build platform, default to empty. set test_flags(-configuration) ""; # build configuration, default to empty. set test_flags(-suffix) ""; # build suffix, default to empty. set test_flags(-file) [list *.eagle]; # default to running all test files. set test_flags(-notFile) [list l.*.eagle]; # COMPAT: Tcl. set test_flags(-startFile) [list]; # start running at these test files. set test_flags(-stopFile) [list]; # stop running after these test files. set test_flags(-match) [list *]; # default to running all tests. set test_flags(-skip) [list]; # default to skipping no tests. set test_flags(-constraints) [list]; # default to no manual constraints. set test_flags(-logFile) ""; # default to using standard log file naming. set test_flags(-threshold) ""; # default to requiring all tests to pass. set test_flags(-randomOrder) ""; # default to deterministic order. set test_flags(-breakOnLeak) ""; # default to continue on leak. set test_flags(-stopOnFailure) ""; # default to continue on failure. set test_flags(-stopOnLeak) ""; # default to continue on leak. set test_flags(-exitOnComplete) ""; # default to not exit after complete. set test_flags(-preTest) ""; # default to not evaluating anything. set test_flags(-postTest) ""; # default to not evaluating anything. set test_flags(-tclsh) ""; # Tcl shell, default to empty. # # NOTE: Check for and process any command line arguments. # if {[info exists argv]} then { eval processTestArguments test_flags $argv if {[info exists test_flags(-no)] && \ [string length $test_flags(-no)] > 0} then { # # NOTE: Set the test run restrictions based on the provided command line # argument value (which is assumed to be a "dictionary-style" list # containing name/value pairs to add to the global "no" array). # foreach {name value} $test_flags(-no) { set no($name) $value } unset -nocomplain name value } if {[info exists test_flags(-logFile)] && \ [string length $test_flags(-logFile)] > 0} then { # # NOTE: Set the log file name to the one provided by the command line. # set test_log $test_flags(-logFile) } if {[info exists test_flags(-threshold)] && \ [string is integer -strict $test_flags(-threshold)]} then { # # NOTE: Set the test pass threshold to the one provided by the command # line. # set test_threshold $test_flags(-threshold) } if {[info exists test_flags(-randomOrder)] && \ [string is boolean -strict $test_flags(-randomOrder)]} then { # # NOTE: Set the test random-order flag to the one provided by the # command line. # set test_random_order $test_flags(-randomOrder) } if {[info exists test_flags(-breakOnLeak)] && \ [string is boolean -strict $test_flags(-breakOnLeak)]} then { # # NOTE: Set the test break-on-leak flag to the one provided by the # command line. # set test_break_on_leak $test_flags(-breakOnLeak) } if {[info exists test_flags(-stopOnFailure)] && \ [string is boolean -strict $test_flags(-stopOnFailure)]} then { # # NOTE: Set the test stop-on-failure flag to the one provided by the # command line. # set test_stop_on_failure $test_flags(-stopOnFailure) } if {[info exists test_flags(-stopOnLeak)] && \ [string is boolean -strict $test_flags(-stopOnLeak)]} then { # # NOTE: Set the test stop-on-leak flag to the one provided by the # command line. # set test_stop_on_leak $test_flags(-stopOnLeak) } if {[info exists test_flags(-exitOnComplete)] && \ [string is boolean -strict $test_flags(-exitOnComplete)]} then { # # NOTE: Set the test exit-on-complete flag to the one provided by the # command line. # set test_exit_on_complete $test_flags(-exitOnComplete) } if {[info exists test_flags(-preTest)] && \ [string length $test_flags(-preTest)] > 0} then { # # NOTE: Set the pre-test script to the one provided by the command line. # set test_script(pre) $test_flags(-preTest) } if {[info exists test_flags(-postTest)] && \ [string length $test_flags(-postTest)] > 0} then { # # NOTE: Set the pre-test script to the one provided by the command line. # set test_script(post) $test_flags(-postTest) } } # # NOTE: Set the default test suite name, if necessary. # if {![info exists test_suite]} then { set test_suite [getTestSuite] } # # NOTE: Set the default test machine (e.g. amd64, intel, etc), if necessary. # if {![info exists test_machine]} then { set test_machine [getTestMachine] } # # NOTE: Set the default test platform (e.g. x86, x64, etc), if necessary. # if {![info exists test_platform]} then { set test_platform [getTestPlatform] } # # NOTE: Set the default test configuration (i.e. Debug or Release), if # necessary. # if {![info exists test_configuration]} then { set test_configuration [getPlatformInfo configuration Release] } # # NOTE: Has automatic log file naming been disabled? # if {![info exists no(logFileName)]} then { # # NOTE: Set the log to use for test output, if necessary. # if {![info exists test_log]} then { set test_log [getDefaultTestLog] } } ############################################################################# # # NOTE: *SPECIAL* This test constraint must be checked first as it can # determine if subsequent ones will emit warnings. This is only # applicable to Eagle. # if {[isEagle]} then { # # NOTE: Has quiet testing support been disabled? # if {![info exists no(preQuiet)]} then { # # NOTE: There are checks for the "quiet" test constraint prior to # the real test constraints being initialized. Prepare for # those checks now. This will have to be repeated later, # after the real test constraints are initialized. # checkForQuiet $test_channel true } } ############################################################################# # # NOTE: Has native Tcl shell detection and use been disabled? # if {![info exists no(tclsh)]} then { # # NOTE: Set the Tcl shell executable to use for those specialized # tests that may require it, if necessary. # if {![info exists test_tclsh]} then { # # NOTE: When running in Eagle, more complex logic is required to # determine the native Tcl shell to use for the various tests # that require it. Also, this same logic is used with Tcl # when it is not running from an instance of the Tcl shell # executable. # if {[isEagle] || ![string match tclsh* $bin_file]} then { if {[info exists test_flags(-tclsh)] && \ [string length $test_flags(-tclsh)] > 0} then { # # NOTE: Use the native Tcl shell specified via the command line. # set test_tclsh $test_flags(-tclsh) } else { if {[canExecTclShell] && \ ![info exists no(getTclShellFileName)]} then { # # NOTE: Attempt to automatically select the native Tcl shell # to use. # if {![info exists no(warningForTclShell)] && \ ![haveConstraint quiet]} then { tputs $test_channel \ "==== WARNING: attempting automatic Tcl shell selection...\n" } set test_tclsh [getTclShellFileName true] } else { # # NOTE: Skip detection and use the fallback default. # set test_tclsh tclsh } } } else { set test_tclsh $bin_file } } } # # NOTE: When running in Eagle, check for any non-core plugins loaded into # the interpreter and issue warnings if any are found. The warning # may be used to explain subsequent test failures due to the extra # plugins being loaded (i.e. there are some tests are sensitive to # having "unexpected" plugins loaded). # if {[isEagle] && ![info exists no(warningForPlugin)] && \ ![haveConstraint quiet]} then { foreach loaded [info loaded] { # # HACK: This code assumes that all plugins in the "Eagle._Plugins" # namespace belong to the Eagle core library itself. # if {![string match Eagle._Plugins.* [lindex $loaded 1]]} then { tputs $test_channel [appendArgs \ "==== WARNING: extra plugin found: " $loaded \n] } } unset -nocomplain loaded } # # NOTE: Show both the pre-test and post-test scripts now, prior to actually # evaluating either of them (even if their use has been disabled). # tputs $test_channel [appendArgs "---- pre-test script: " \ [expr {[info exists test_script(pre)] && \ [string length $test_script(pre)] > 0 ? \ [appendArgs \" $test_script(pre) \"] : ""}] \n] tputs $test_channel [appendArgs "---- post-test script: " \ [expr {[info exists test_script(post)] && \ [string length $test_script(post)] > 0 ? \ [appendArgs \" $test_script(post) \"] : ""}] \n] # # NOTE: Are we being prevented from evaluating the "pre-test" script? # if {![info exists no(preTest)]} then { # # NOTE: Evaluate the specified pre-test script now, if any. # if {[info exists test_script(pre)] && \ [string length $test_script(pre)] > 0} then { # # TODO: Perhaps use [uplevel] here instead of [eval]. For now, it does # not matter since we enforce this file being evaluated at the # top-level. # if {[catch $test_script(pre) test_script(pre,result)]} then { # # NOTE: Make 100% sure, even in "quiet" mode, that this script error # gets into the test log file. # tputs $test_channel [appendArgs "---- pre-test script error: " \ $test_script(pre,result) \n] # # NOTE: The pre-test script failed in some way. This is considered # to be an overall failure of the test suite; therefore, raise # the error now that we are sure it has been recorded in the # test log file. # unset -nocomplain test_suite_running error $test_script(pre,result) } } } # # NOTE: Check for and process any custom test prologue script that may be set # in the environment. This must be done after the Eagle test package # has been made available and after the log file has been setup. # sourceIfValid prologue [getEnvironmentVariable testPrologue] # # NOTE: Show the name of the executable and the command line arguments, if # any. This must be done after the log file has been setup; otherwise, # this information will not be visible in the log file. # tputs $test_channel [appendArgs "---- testRunId: " \ [getTestRunId] \n] tputs $test_channel [appendArgs "---- processId: " \ [pid] \n] tputs $test_channel [appendArgs "---- test suite: " \ [expr {[info exists test_suite] ? \ $test_suite : ""}] \n] tputs $test_channel [appendArgs "---- test channel: " \ $test_channel \n] tputs $test_channel [appendArgs "---- test machine: " \ [expr {[info exists test_machine] ? \ $test_machine : ""}] \n] tputs $test_channel [appendArgs "---- test platform: " \ [expr {[info exists test_platform] ? \ $test_platform : ""}] \n] tputs $test_channel [appendArgs "---- test configuration: " \ [expr {[info exists test_configuration] ? \ $test_configuration : ""}] \n] tputs $test_channel [appendArgs "---- test suffix: " \ [expr {[info exists test_suffix] ? \ $test_suffix : ""}] \n] if {[isEagle]} then { tputs $test_channel [appendArgs "---- original command line: " \ [info cmdline] \n] tputs $test_channel [appendArgs "---- threadId: " \ [info tid] \n] tputs $test_channel [appendArgs "---- processors: " \ [info processors] \n] catch {object invoke Console.InputEncoding WebName} encoding tputs $test_channel [appendArgs "---- input encoding: " \ $encoding \n] catch {object invoke Console.OutputEncoding WebName} encoding tputs $test_channel [appendArgs "---- output encoding: " \ $encoding \n] unset encoding catch {host query} host tputs $test_channel [appendArgs "---- host query: " \ [formatListAsDict $host ] \n] unset host catch {debug memory} memory tputs $test_channel [appendArgs "---- starting memory: " \ [formatListAsDict $memory ] \n] unset memory catch {debug stack true} stack tputs $test_channel [appendArgs "---- starting stack: " \ [formatListAsDict $stack ] \n] unset stack catch {file drive} drive tputs $test_channel [appendArgs "---- system drive: " \ [formatListAsDict $drive ] \n] unset drive } tputs $test_channel [appendArgs "---- executable: \"" \ $bin_file \"\n] tputs $test_channel [appendArgs "---- command line: " \ [expr {[info exists argv] && [string length $argv] > 0 ? \ $argv : ""}] \n] tputs $test_channel [appendArgs "---- logging to: " \ [expr {[info exists test_log] && [string length $test_log] > 0 ? \ [appendArgs \" $test_log \"] : ""}] \n] tputs $test_channel [appendArgs "---- pass threshold: " \ [expr {[info exists test_threshold] && \ [string is integer -strict $test_threshold] ? \ [appendArgs $test_threshold %] : ""}] \n] tputs $test_channel [appendArgs "---- random order: " \ [expr {[info exists test_random_order] && \ [string is boolean -strict $test_random_order] ? \ $test_random_order : ""}] \n] tputs $test_channel [appendArgs "---- break on leak: " \ [expr {[info exists test_break_on_leak] && \ [string is boolean -strict $test_break_on_leak] ? \ $test_break_on_leak : ""}] \n] tputs $test_channel [appendArgs "---- stop on failure: " \ [expr {[info exists test_stop_on_failure] && \ [string is boolean -strict $test_stop_on_failure] ? \ $test_stop_on_failure : ""}] \n] tputs $test_channel [appendArgs "---- stop on leak: " \ [expr {[info exists test_stop_on_leak] && \ [string is boolean -strict $test_stop_on_leak] ? \ $test_stop_on_leak : ""}] \n] tputs $test_channel [appendArgs "---- exit on complete: " \ [expr {[info exists test_exit_on_complete] && \ [string is boolean -strict $test_exit_on_complete] ? \ $test_exit_on_complete : ""}] \n] # # NOTE: Show the information about which tests and files are being run and/or # skipped (COMPAT: Tcl). # if {[llength $test_flags(-file)] > 0} then { tputs $test_channel [appendArgs "---- running test files that match: " \ $test_flags(-file) \n] } if {[llength $test_flags(-notFile)] > 0} then { tputs $test_channel [appendArgs "---- skipping test files that match: " \ $test_flags(-notFile) \n] } if {[llength $test_flags(-startFile)] > 0} then { tputs $test_channel [appendArgs \ "---- starting with test files that match: " \ $test_flags(-startFile) \n] } if {[llength $test_flags(-stopFile)] > 0} then { tputs $test_channel [appendArgs \ "---- stopping after test files that match: " \ $test_flags(-stopFile) \n] } if {[llength $test_flags(-match)] > 0} then { tputs $test_channel [appendArgs "---- running tests that match: " \ $test_flags(-match) \n] } if {[llength $test_flags(-skip)] > 0} then { tputs $test_channel [appendArgs "---- skipping tests that match: " \ $test_flags(-skip) \n] } tputs $test_channel [appendArgs "---- path: " \ [expr {[info exists path] && [string length $path] > 0 ? \ [appendArgs \" $path \"] : ""}] \n] tputs $test_channel [appendArgs "---- base path: \"" \ $base_path \"\n] tputs $test_channel [appendArgs "---- key path: \"" \ $key_path \"\n] tputs $test_channel [appendArgs "---- root path: \"" \ $root_path \"\n] tputs $test_channel [appendArgs "---- binary path: \"" \ $bin_path \"\n] tputs $test_channel [appendArgs "---- library path: \"" \ $lib_path \"\n] tputs $test_channel [appendArgs "---- test script files located in: \"" \ $test_path \"\n] tputs $test_channel [appendArgs "---- test data files located in: \"" \ $test_data_path \"\n] tputs $test_channel [appendArgs "---- running in: \"" \ [pwd] \"\n] tputs $test_channel [appendArgs "---- temporary files stored in: \"" \ [getTemporaryPath] \"\n] tputs $test_channel [appendArgs "---- native Tcl shell: " \ [expr {[info exists test_tclsh] && [string length $test_tclsh] > 0 ? \ [appendArgs \" $test_tclsh \"] : ""}] \n] tputs $test_channel [appendArgs "---- disabled options: " \ [formatList [lsort [array names no]] ] \n] # # NOTE: Initialize the Eagle test constraints. # if {[isEagle]} then { # # NOTE: *WARNING* This has the effect of removing test constraints # added prior to this point. # initializeTests; configureTcltest [list] [list] [list] [list] false # # NOTE: If the "no(mono)" variable is set (to anything) then any # special test suite hacks for Mono will be disabled. This # does not control or change any hacks for Mono that may # be present in the library itself. # # if {![info exists no(mono)] && [isMono]} then { # set no(mono) true # } ########################################################################### ######################### BEGIN Eagle Constraints ######################### ########################################################################### tputs $test_channel \ "---- start of Eagle specific test constraints...\n" # # NOTE: *WARNING* Has quiet testing support been disabled? # Please do not move this "quietness" test constraint # check as subsequent test constraints may rely on it # when determining if a warning should be emitted. # if {![info exists no(quiet)]} then { # # NOTE: For tests "basic-1.36", "benchmark-1.*", "debug-1.3", # "debug-1.4", "glob-99.*", "object-10.*", "perf-2.2", # and various other places within the test suite code # itself. # checkForQuiet $test_channel false } # # NOTE: Has strong name key detection been disabled? # if {![info exists no(strongNameKey)]} then { catch {info engine PublicKeyToken} publicKeyToken if {[string length $publicKeyToken] == 0} then { # # NOTE: The Eagle core library is not signed with a strong name key. # This is not an error, per se; however, it may cause selected # tests to fail and it should be reported to the user and noted # in the test suite log file. # addConstraint strongName.none if {![info exists no(warningForStrongNameKey)] && \ ![haveConstraint quiet]} then { tputs $test_channel \ "==== WARNING: no Eagle strong name signature detected...\n" } } else { # # NOTE: Add a test constraint for this specific strong name key. # addConstraint [appendArgs strongName. $publicKeyToken] # # BUGBUG: Tcl 8.4 does not seem to like this expression because it # contains the "ni" operator added in Tcl 8.5 (and Tcl 8.4 # tries to compile it even though it will only be evaluated # in Eagle). # set expr {$publicKeyToken ni \ "29c6297630be05eb 1e22ec67879739a2 358030063a832bc3"} if {[expr $expr]} then { # # NOTE: The Eagle core library is strong name signed with a key that # is not official. This is also not an error, per se; however, # it may cause some tests to fail and it should be reported to # the user and noted in the test suite log file. # addConstraint strongName.unofficial if {![info exists no(warningForStrongNameKey)] && \ ![haveConstraint quiet]} then { tputs $test_channel [appendArgs \ "==== WARNING: unofficial Eagle strong name signature " \ "detected: " $publicKeyToken \n] } } else { # # NOTE: Several tests require one of the official strong name keys to # be used in order for them to pass. # addConstraint strongName.official tputs $test_channel [appendArgs \ "---- official Eagle strong name signature detected: " \ $publicKeyToken \n] } unset expr } unset publicKeyToken } # # NOTE: Has administrator detection support been disabled? We do # this check [nearly] first as it may [eventually] be used # to help determine if other constraints should be skipped. # if {![info exists no(administrator)]} then { checkForAdministrator $test_channel } # # NOTE: Has host detection support been disabled? # if {![info exists no(host)]} then { checkForHost $test_channel } # # NOTE: Has host type detection support been disabled? # if {![info exists no(hostType)]} then { checkForHostType $test_channel } # # NOTE: Has primary thread detection support been disabled? We do # this check [nearly] first as it may [eventually] be used # to help determine if other constraints should be skipped. # if {![info exists no(primaryThread)]} then { checkForPrimaryThread $test_channel } # # NOTE: Has default application domain detection support been # disabled? We do this check [nearly] first as it may # [eventually] be used to help determine if other # constraints should be skipped. # if {![info exists no(defaultAppDomain)]} then { checkForDefaultAppDomain $test_channel } # # NOTE: Has runtime detection support been disabled? We do this # checking [nearly] first as it may skip other constraints. # if {![info exists no(runtime)]} then { checkForRuntime $test_channel } # # NOTE: Check the variant and/or version of the CLR that we are # currently running on. # if {![info exists no(checkForRuntimeVersion)]} then { checkForRuntimeVersion $test_channel } # # NOTE: Check the framework version (i.e. regardless of runtime) that # we are currently running on. # if {![info exists no(frameworkVersion)]} then { checkForFrameworkVersion $test_channel } # # NOTE: Check the image runtime version (i.e. the runtime version that # this assembly compiled against). # if {![info exists no(imageRuntimeVersion)]} then { checkForImageRuntimeVersion $test_channel } # # NOTE: Has process bits detection support been disabled? # if {![info exists no(processBits)]} then { checkForProcessBits $test_channel } # # NOTE: Has machine detection support been disabled? # if {![info exists no(machine)]} then { checkForMachine $test_channel 32 intel; # (i.e. x86) checkForMachine $test_channel 32 arm; # (i.e. arm) checkForMachine $test_channel 64 ia64; # (i.e. itanium) checkForMachine $test_channel 64 amd64; # (i.e. x64) } # # NOTE: Has culture detection support been disabled? # if {![info exists no(culture)]} then { checkForCulture $test_channel } # # NOTE: Has thread culture detection support been disabled? # if {![info exists no(threadCulture)]} then { checkForThreadCulture $test_channel } # # NOTE: Has software update trust detection support been disabled? # if {![info exists no(softwareUpdate)]} then { checkForSoftwareUpdateTrust $test_channel } # # NOTE: Has strong name detection support been disabled? # if {![info exists no(strongName)]} then { checkForStrongName $test_channel } # # NOTE: Has certificate detection support been disabled? # if {![info exists no(certificate)]} then { checkForCertificate $test_channel } # # NOTE: Has database testing support been disabled? # if {![info exists no(core)] && ![info exists no(database)]} then { # # NOTE: Set the server name, if necessary. # if {![info exists server]} then { set server . } # # NOTE: Set the database name, if necessary. # if {![info exists database]} then { set database master } # # NOTE: Set the connection timeout, if necessary. # if {![info exists timeout]} then { set timeout [expr {$test_timeout / 1000}]; # milliseconds to seconds. } # # NOTE: Set the test user name, if necessary. # if {![info exists user]} then { set user [getEnvironmentVariable user] } # # NOTE: Set the test password, if necessary. # if {![info exists password]} then { set password [getEnvironmentVariable password] } # # NOTE: Set the test database connection type, if necessary. # if {![info exists test_database_type]} then { # # NOTE: Use the default database connection type. # set test_database_type Sql; # TODO: Good test default? } # # NOTE: Set the test database connection string, if necessary. # if {![info exists test_database]} then { # # NOTE: Mono does not have support for "trusted connections"; # therefore, we must emit a different connection string # when running there. # set test_database [subst \ {Data Source=${server};Initial Catalog=${database};Connect\ Timeout=${timeout};[expr {[isMono] ? [subst \ {User Id=${user};Password=${password};}] : {Integrated\ Security=SSPI;}}]}]; # NOTE: Microsoft SQL Server specific. } elseif {[info exists test_database_subst]} then { # # NOTE: The test database connection string must be dynamically # post-processed using [subst], per request. This allows # the [custom] test database connection string to contain # references to the other test database variables setup # by this test prologue. # set test_database [subst $test_database] } # # NOTE: Set the test database table, if necessary. # if {![info exists test_database_table]} then { # # NOTE: Use the default database table. # set test_database_table eagle_sql_test_ok_to_delete } # # NOTE: Can we access the configured test database? # checkForDatabase $test_channel $test_database_type $test_database unset password user timeout database server } # # NOTE: Has symbol testing support been disabled? # if {![info exists no(assemblySymbols)]} then { checkForSymbols $test_channel [lindex [info assembly] end] } # # NOTE: Has object handle reference count tracking support been disabled # (at compile-time)? # if {![info exists no(refCount)]} then { # # NOTE: For tests "excel-*", "object-2.*", "object-7.1", "object-8.*", # and "object-98.*". # checkForReferenceCountTracking $test_channel } # # NOTE: Has testing using the C# compiler been disabled? # if {![info exists no(checkForCompileCSharp)]} then { checkForCompileCSharp $test_channel } # # NOTE: Has compile/runtime option testing support been disabled? # if {![info exists no(compileOptions)]} then { # # NOTE: Has "known" compile option testing support been disabled? # if {![info exists no(knownCompileOptions)]} then { # # NOTE: Check for all "known" compile options. # checkForKnownCompileOptions $test_channel } else { # # NOTE: Has callback queue support been enabled (at compile-time)? # if {![info exists no(compileCallbackQueue)]} then { # # NOTE: For tests "basic-1.54" and "commands-1.4". # checkForCompileOption $test_channel CALLBACK_QUEUE } # # NOTE: Has legacy CAS policy support been enabled (at compile-time)? # if {![info exists no(compileCasPolicy)]} then { # # NOTE: For tests "load-1.6" and "load-1.7". # checkForCompileOption $test_channel CAS_POLICY } # # NOTE: Has console support been enabled (at compile-time)? # if {![info exists no(compileConsole)]} then { # # NOTE: For test "host-1.2". # checkForCompileOption $test_channel CONSOLE } # # NOTE: Has database support been enabled (at compile-time)? # if {![info exists no(compileData)]} then { # # NOTE: For tests "sql-1.1" and "upvar-99.1". # checkForCompileOption $test_channel DATA } # # NOTE: Has script debugger support been enabled (at compile-time)? # if {![info exists no(compileDebugger)]} then { # # NOTE: For tests "debug-1.1", "debug-2.1", "debug-3.1" and # "debug-4.1". # checkForCompileOption $test_channel DEBUGGER } # # NOTE: Has application domain management support been enabled (at # compile-time)? # if {![info exists no(compileAppDomains)]} then { # # NOTE: For test "interp-1.27". # checkForCompileOption $test_channel APPDOMAINS } # # NOTE: Has isolated interpreter support been enabled (at compile-time)? # if {![info exists no(compileIsolatedInterpreters)]} then { # # NOTE: For test "xaml-1.2". # checkForCompileOption $test_channel ISOLATED_INTERPRETERS } # # NOTE: Has expression flags support been enabled (at compile-time)? # if {![info exists no(compileExpressionFlags)]} then { # # NOTE: For test "function-2.16". # checkForCompileOption $test_channel EXPRESSION_FLAGS } # # NOTE: Has isolated plugin support been enabled (at compile-time)? # if {![info exists no(compileIsolatedPlugins)]} then { # # NOTE: For test "load-1.1.1". # checkForCompileOption $test_channel ISOLATED_PLUGINS } # # NOTE: Has PowerShell approved-verbs support been enabled (at # compile-time)? # if {![info exists no(compileApprovedVerbs)]} then { # # NOTE: For test "object-4.8". # checkForCompileOption $test_channel APPROVED_VERBS } # # NOTE: Has Mono support been enabled (at compile-time)? # if {![info exists no(compileMono)]} then { # # NOTE: For test "object-4.13". # checkForCompileOption $test_channel MONO } # # NOTE: Has Windows support been enabled (at compile-time)? # if {![info exists no(compileWindows)]} then { # # NOTE: For tests "garuda-1.1" and "garuda-1.2". # checkForCompileOption $test_channel WINDOWS } # # NOTE: Has Windows Forms support been enabled (at compile-time)? # if {![info exists no(compileWinForms)]} then { # # NOTE: For tests "object-10.21", "tclLoad-1.2", "winForms-*.*". # checkForCompileOption $test_channel WINFORMS } # # NOTE: Has native code support been enabled (at compile-time)? # if {![info exists no(compileNative)]} then { # # NOTE: For tests "debug-3.2", "expr-3.2", and "host-1.1". # checkForCompileOption $test_channel NATIVE } # # NOTE: Has native package support been enabled (at compile-time)? # if {![info exists no(compileNativePackage)]} then { # # NOTE: For tests "garuda-1.1" and "garuda-1.2". # checkForCompileOption $test_channel NATIVE_PACKAGE } # # NOTE: Has network support been enabled (at compile-time)? # if {![info exists no(compileNetwork)]} then { # # NOTE: For tests "commands-1.4", "socket-1.*", "socket-2.1", and # "socket-3.1". # checkForCompileOption $test_channel NETWORK } # # NOTE: Has native Tcl support been enabled (at compile-time)? # if {![info exists no(compileTcl)]} then { # # NOTE: For tests "commands-1.1.*", "excel-2.2", "tclCancel-1.1", # "tclEncoding-1.*", "tclErrorInfo-1.*", "tclLoad-1.*", # "tclResetCancel-1.1", "tclResetCancel-2.1", # "tclResetCancel-2.2", "tclResetCancel-3.1", # "tclResetCancel-4.1", "tclSet-1.1", and "tclSubst-1.1". # checkForCompileOption $test_channel TCL } # # NOTE: Has XML support been enabled (at compile-time)? # if {![info exists no(compileXml)]} then { # # NOTE: For tests "commands-1.4", "object-7.3" and "xml-1.1.*". # checkForCompileOption $test_channel XML } # # NOTE: Has serialization support been enabled (at compile-time)? # if {![info exists no(compileSerialization)]} then { # # NOTE: For test "interp-1.10". # checkForCompileOption $test_channel SERIALIZATION } # # NOTE: Has dedicated test support been enabled (at compile-time)? # if {![info exists no(compileTest)]} then { # # NOTE: For tests "basic-1.20", "basic-1.21", "function-1.1", # "object-2.1", "object-3.1", "object-4.1", "object-7.1", # "object-7.2", "object-7.4", "object-14.4", "object-14.5", # "object-14.6", "remotingServer-1.*", and "debug-5.*". # checkForCompileOption $test_channel TEST } # # NOTE: Has threading support been enabled (at compile-time)? # if {![info exists no(compileThreading)]} then { # # NOTE: For tests "object-10.2" and "object-10.3". # checkForCompileOption $test_channel THREADING } # # NOTE: Has Tcl threading support been enabled (at compile-time)? # if {![info exists no(compileTclThreaded)]} then { # # NOTE: For tests "tclLoad-1.5" and "tclLoad-1.6". # checkForCompileOption $test_channel TCL_THREADED } # # NOTE: Has Tcl isolated interpreter thread support been enabled (at # compile-time)? # if {![info exists no(compileTclThreads)]} then { # # NOTE: For tests "tclLoad-1.5" and "tclLoad-1.6". # checkForCompileOption $test_channel TCL_THREADS } # # NOTE: Has GDI+ drawing support been enabled (at compile-time)? # if {![info exists no(compileDrawing)]} then { checkForCompileOption $test_channel DRAWING } # # NOTE: Has WinForms support been enabled (at compile-time)? # if {![info exists no(compileWinForms)]} then { checkForCompileOption $test_channel WINFORMS } # # NOTE: Has runtime license checking support been disabled (at # compile-time). This only applies to third-party plugins # and applications. # if {![info exists no(compileLicensing)]} then { # # NOTE: This is not currently used by any tests. # checkForCompileOption $test_channel LICENSING } } } # # NOTE: Has dynamic loading testing support been disabled? # if {![info exists no(dynamic)]} then { # # NOTE: For tests "commands-1.1.*", "library-3.*", and "tcl*-*.*". # checkForDynamicLoading $test_channel } # # NOTE: Has Tcl testing support been disabled? # if {![info exists no(tcl)]} then { if {![info exists no(tclInstalls)]} then { # # NOTE: For tests "commands-1.1.*", "library-3.*", and "tcl*-*.*". # checkForTclInstalls $test_channel } if {![info exists no(tclReady)]} then { checkForTclReady $test_channel } if {![info exists no(tclShell)]} then { # # NOTE: For test "garuda-1.1". # checkForTclShell $test_channel } if {![info exists no(tkPackage)]} then { # # NOTE: For test "tclLoad-1.1". # checkForTkPackage $test_channel } } # # NOTE: Has custom test method support been disabled? # if {![info exists no(core)] && ![info exists no(test)]} then { # # NOTE: Has script stream testing support been disabled? # if {![info exists no(testScriptStream)]} then { # # NOTE: For tests "basic-1.46" and "basic-1.47". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestScriptStream* } if {![info exists no(testLoad)]} then { # # NOTE: For tests "load-1.6" and "load-1.7". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestLoadPluginViaBytes* } # # NOTE: Has DateTime testing support been disabled? # if {![info exists no(testDateTime)]} then { # # NOTE: For test "vwait-1.11". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestSetDateTimeNowCallback* } # # NOTE: Has remoting testing support been disabled? # if {![info exists no(testRemoting)]} then { # # NOTE: For tests "remotingServer-1.*". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestRemoting* } # # NOTE: Has asynchronous testing support been disabled? # if {![info exists no(testAsynchronous)]} then { # # NOTE: For tests "basic-1.20" and "basic-1.21". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestEvaluateAsync* } # # NOTE: Has custom function testing support been disabled? # if {![info exists no(testFunction)]} then { # # NOTE: For test "function-1.1". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestAddFunction* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestRemoveFunction* # # NOTE: For tests "function-5.*". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestAddNamedFunction* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestRemoveNamedFunction* # # NOTE: For test "interp-1.19". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestAddNamedFunction2* # # NOTE: For tests "function-5.*". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestAddNamedFunction3* } # # NOTE: Has write-box testing support been disabled? # if {![info exists no(testWriteBox)]} then { # # NOTE: For tests "debug-5.*". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestWriteBox* } # # NOTE: Has shell testing support been disabled? # if {![info exists no(testShell)]} then { # # NOTE: For test "debug-1.3". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestShellMainCore* } # # NOTE: Has quiet property testing support been disabled? # if {![info exists no(testSetQuiet)]} then { # # NOTE: For tests "basic-1.36" and "debug-1.3". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestSetQuiet* } # # NOTE: Has complaint testing support been disabled? # if {![info exists no(testSetComplain)]} then { # # NOTE: This is not currently used by any tests. # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestSetComplain* } # # NOTE: Has linked variable testing support been disabled? # if {![info exists no(testLinkedVariables)]} then { # # NOTE: For tests "basic-1.39", "basic-1.40", "basic-1.41", # "basic-1.42", and "basic-1.43". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestSetVariableLinks* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestUnsetVariableLinks* } # # NOTE: Has system array variable testing support been disabled? # if {![info exists no(testSystemArrayVariables)]} then { # # NOTE: For tests "basic-1.62", "basic-1.63", "basic-1.64", # and "basic-1.65". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestIntPtrChangeTypeCallback* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestSetVariableSystemArray* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestUnsetVariableSystemArray* } # # NOTE: Has field testing support been disabled? # if {![info exists no(testFields)]} then { # # NOTE: For tests "basic-1.39", "basic-1.40", "basic-1.41", # "basic-1.42", and "basic-1.43". # checkForObjectMember $test_channel Eagle._Tests.Default \ *privateField* checkForObjectMember $test_channel Eagle._Tests.Default \ *objectField* checkForObjectMember $test_channel Eagle._Tests.Default \ *intField* } # # NOTE: Has property testing support been disabled? # if {![info exists no(testProperties)]} then { # # NOTE: For tests "basic-1.39", "basic-1.40", "basic-1.41", # "basic-1.42", and "basic-1.43". # checkForObjectMember $test_channel Eagle._Tests.Default \ *get_SimpleIntProperty* # # NOTE: For test "object-3.1". # checkForObjectMember $test_channel Eagle._Tests.Default \ *get_Item* checkForObjectMember $test_channel Eagle._Tests.Default \ *set_Item* } # # NOTE: Has core marshaller testing support been disabled? # if {![info exists no(testMarshaller)]} then { # # NOTE: These are not currently used by any tests. # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestSaveObjects* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestRestoreObjects* # # NOTE: For test "basic-1.29". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestExecuteStaticDelegates* # # NOTE: For tests "basic-1.30" and "basic-1.31". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestExecuteDelegateCommands* # # NOTE: For test "namespace-97.10". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestRenameNamespace* # # NOTE: For test "object-2.1". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestComplexMethod* # # NOTE: For test "object-2.12". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestMoreComplexMethod* # # NOTE: For test "object-2.3". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestToHexadecimalString* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestMulti2Array* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestMulti3Array* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestNestedArray* # # NOTE: For test "object-2.11". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestObjectAsArray* # # NOTE: For tests "object-3.6" and "object-3.7". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestStringIListReturnValue* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestStringIListIListIListReturnValue* # # NOTE: For test "object-3.8". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestByteList* # # NOTE: For test "object-3.9". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestIntList* # # NOTE: For test "object-3.10". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestLongList* # # NOTE: For test "object-3.11". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestDerivedList* # # NOTE: For tests "object-3.12" and "object-3.13". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestStringIDictionaryReturnValue* # # NOTE: For test "object-4.1". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestExpr* # # NOTE: For test "array-4.1". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestTwoByteArrays* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestReturnByteArray* # # NOTE: For test "object-7.1". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestByRefValueTypeMethod* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestNullableValueTypeMethod* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestByRefNullableValueTypeMethod* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestIntArrayReturnValue* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestStringArrayReturnValue* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestStringListReturnValue* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestStringListArrayReturnValue* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestByRefStringListArray* # # NOTE: For tests "object-7.2" and "object-7.4". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestNullArray* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestOutArray* # # NOTE: For test "object-7.5". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TestEnum* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestByRefEnum* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestNullableEnum* checkForObjectMember $test_channel Eagle._Tests.Default \ *TestByRefNullableEnum* # # NOTE: For tests "object-14.4" and "object-14.5". # checkForObjectMember $test_channel Eagle._Tests.Default \ *StaticObjectProperty* # # NOTE: For test "object-14.6". # checkForObjectMember $test_channel Eagle._Tests.Default \ *TypeProperty* } # # NOTE: Has IDisposable testing support been disabled? # if {![info exists no(testDisposable)]} then { # # NOTE: For test "object-2.8". # checkForObjectMember $test_channel Eagle._Tests.Default+Disposable \ *ToString* Eagle._Tests.Default.Disposable.ToString } } # # NOTE: Has MSBuild testing support been disabled? # if {![info exists no(msBuild)]} then { # # NOTE: For test "object-4.13". # checkForAssembly $test_channel Microsoft.Build.Framework # # NOTE: For test "object-6.1". # checkForAssembly $test_channel Microsoft.Build.Engine } # # NOTE: Has Excel testing support been disabled? # if {![info exists no(excel)]} then { # # NOTE: For tests "excel-*.*". # checkForAssembly $test_channel Microsoft.Office.Interop.Excel } # # NOTE: Has speech testing support been disabled? # if {![info exists no(speech)]} then { # # NOTE: Set the audio volume, if necessary. # if {![info exists test_volume]} then { set test_volume 0; # in percent, 0 is silent. } # # NOTE: For test "object-4.5". # checkForAssembly $test_channel System.Speech } # # NOTE: Has WinForms testing support been disabled? # if {![info exists no(winForms)]} then { # # NOTE: For tests "object-13.1.*", "object-13.2.*", and # "winForms-*.*". # checkForWindowsForms $test_channel } # # NOTE: Are we running in a WoW64 process? # if {![info exists no(wow64)]} then { # # NOTE: This is not currently used by any tests. # checkForWoW64 $test_channel } # # NOTE: Are we running in an STA thread? # if {![info exists no(staThread)]} then { # # NOTE: For tests "xaml-1.*". # checkForStaThread $test_channel } # # NOTE: Has WPF testing support been disabled? # if {![info exists no(wpf)]} then { # # NOTE: For tests "xaml-1.*". # checkForWindowsPresentationFoundation $test_channel } # # NOTE: Has PowerShell testing support been disabled? # if {![info exists no(powerShell)]} then { # # NOTE: For tests "object-4.7", "object-4.8", and "object-4.9". # checkForPowerShell $test_channel } # # NOTE: Has .NET Framework 4.5 testing support been disabled? # if {![info exists no(netFx45)]} then { # # NOTE: For test "object-12.1.*". # checkForNetFx45 $test_channel } # # NOTE: Has target framework testing support been disabled? # if {![info exists no(targetFramework)]} then { checkForTargetFramework $test_channel } # # NOTE: Has native utility testing support been disabled? # if {![info exists no(nativeUtility)]} then { checkForNativeUtility $test_channel } # # NOTE: Has Visual Studio testing support been disabled? # if {![info exists no(visualStudio)]} then { checkForVisualStudio $test_channel } # # NOTE: Has WiX testing support been disabled? # if {![info exists no(wix)]} then { # # NOTE: For test "object-4.10". # checkForWix $test_channel } # # NOTE: Has native debugger testing support been disabled? # if {![info exists no(nativeDebugger)]} then { checkForNativeDebugger $test_channel } # # NOTE: Has managed debugger testing support been disabled? # if {![info exists no(managedDebugger)]} then { checkForManagedDebugger $test_channel } # # NOTE: Has managed debugging assistants testing support been # disabled? # if {![info exists no(managedDebuggingAssistants)]} then { checkForManagedDebuggingAssistants $test_channel } # # NOTE: Has script debugger testing support been disabled? # if {![info exists no(scriptDebugger)]} then { # # NOTE: For tests "debug-1.1", "debug-2.1", "debug-3.1", and # "debug-4.1". # checkForScriptDebugger $test_channel } # # NOTE: Has script debugger interpreter testing support been # disabled? # if {![info exists no(scriptDebuggerInterpreter)]} then { # # NOTE: For test "debug-2.1". # checkForScriptDebuggerInterpreter $test_channel } # # NOTE: Are we running under the Mono debugger? If so, several # tests will have to be disabled because they do not appear # to work there. # if {![info exists no(monoDebugger)]} then { tputs $test_channel "---- checking for Mono debugger... " if {[haveConstraint mono] && [haveConstraint managedDebugger]} then { # # NOTE: Add a special test constraint to simplify the Mono debugger # test constraint checking for the tests that need it. # addConstraint monoDebugger tputs $test_channel yes\n } else { tputs $test_channel no\n } } # # NOTE: Has Garuda testing support been disabled? # if {![info exists no(garudaDll)]} then { # # NOTE: For tests "garuda-1.1" and "garuda-1.2". # checkForGarudaDll $test_channel } ########################################################################### ########################## END Eagle Constraints ########################## ########################################################################### } else { # # NOTE: Make sure that Tcl honors the Eagle test constraints. # configureTcltest $test_flags(-match) $test_flags(-skip) \ $test_flags(-constraints) [list] false # # HACK: Reset the test counts for tcltest. # set ::tcltest::numTests(Total) 0 set ::tcltest::numTests(Skipped) 0 set ::tcltest::numTests(Passed) 0 set ::tcltest::numTests(Failed) 0 # # HACK: Reset the list of failed files. # set ::tcltest::failFiles [list] ########################################################################### ########################## BEGIN Tcl Constraints ########################## ########################################################################### tputs $test_channel \ "---- start of Tcl specific test constraints...\n" # # NOTE: Has compile/runtime option testing support been disabled? # if {![info exists no(compileOptions)]} then { # # NOTE: Has "known" compile option testing support been disabled? # if {![info exists no(knownCompileOptions)]} then { # # NOTE: Check for all "known" compile options. # checkForKnownCompileOptions $test_channel } else { # # NOTE: Has dedicated test support been enabled (at compile-time)? # if {![info exists no(compileTest)]} then { # # NOTE: For tests "tclLoad-1.17.1" and "tclLoad-1.17.2". # checkForCompileOption $test_channel TEST } } } ########################################################################### ########################### END Tcl Constraints ########################### ########################################################################### } ############################################################################# ####################### BEGIN Tcl & Eagle Constraints ####################### ############################################################################# tputs $test_channel \ "---- start of common (Tcl & Eagle) test constraints...\n" # # NOTE: Check for the test suite infrastructure files... # if {![info exists no(testSuiteFiles)]} then { checkForTestSuiteFiles $test_channel } # # NOTE: Has all use of [exec] for tests been disabled? # if {![info exists no(checkForTestExec)]} then { checkForTestExec $test_channel [haveConstraint quiet] } # # NOTE: Has checking for the test machine been disabled? # if {![info exists no(testMachine)]} then { checkForTestMachine $test_channel } # # NOTE: Has checking for the test platform been disabled? # if {![info exists no(testPlatform)]} then { checkForTestPlatform $test_channel } # # NOTE: Has checking for the test configuration been disabled? # if {![info exists no(testConfiguration)]} then { checkForTestConfiguration $test_channel } # # NOTE: Has checking for the test suffix been disabled? # if {![info exists no(testSuffix)]} then { checkForTestSuffix $test_channel } # # NOTE: Has checking for the extra files needed by various tests in the # Eagle core test suite been disabled? # if {![info exists no(core)] && ![info exists no(checkForFile)]} then { # # NOTE: For tests "benchmark-1.3[89]" and "benchmark-1.40". # if {![info exists no(benchmark.txt)]} then { checkForFile $test_channel [file join $test_data_path benchmark.txt] } # # NOTE: For test "garuda-1.1". # if {![info exists no(pkgAll.tcl)]} then { checkForFile $test_channel [file join $base_path Native Package \ Tests all.tcl] pkgAll.tcl } # # NOTE: For tests "subst-1.*". # if {![info exists no(bad_subst.txt)]} then { checkForFile $test_channel [file join $test_data_path bad_subst.txt] } # # NOTE: This is not currently used by any tests. # if {![info exists no(evaluate.eagle)]} then { checkForFile $test_channel [file join $test_data_path evaluate.eagle] } # # NOTE: This is not currently used by any tests. # if {![info exists no(substitute.eagle)]} then { checkForFile $test_channel [file join $test_data_path substitute.eagle] } # # NOTE: This is not currently used by any tests. # if {![info exists no(unicode_bom.txt)]} then { checkForFile $test_channel [file join $test_data_path unicode_bom.txt] } # # NOTE: This is not currently used by any tests. # if {![info exists no(unicode_no_bom.txt)]} then { checkForFile $test_channel [file join $test_data_path unicode_no_bom.txt] } # # NOTE: This is not currently used by any tests. # if {![info exists no(utf8.txt)]} then { checkForFile $test_channel [file join $test_data_path utf8.txt] } # # NOTE: For tests "fileIO-1.*". # if {![info exists no(file.dat)]} then { checkForFile $test_channel [file join $test_data_path file.dat] } # # NOTE: For test "garbage-1.1". # if {![info exists no(garbage.txt)]} then { checkForFile $test_channel [file join $test_data_path garbage.txt] } # # NOTE: For tests "xaml-1.*". # if {![info exists no(test.png)]} then { checkForFile $test_channel [file join $test_data_path test.png] } # # NOTE: For test "socket-1.2". # if {![info exists no(client.tcl)]} then { checkForFile $test_channel [file join $test_data_path client.tcl] } # # NOTE: For test "tclLoad-1.2". # if {![info exists no(tcl_unload.tcl)]} then { checkForFile $test_channel [file join $test_data_path tcl_unload.tcl] } # # NOTE: For test "basic-1.4". # if {![info exists no(read.eagle)]} then { checkForFile $test_channel [file join $test_data_path read.eagle] } # # NOTE: For test "basic-1.5". # if {![info exists no(read2.eagle)]} then { checkForFile $test_channel [file join $test_data_path read2.eagle] } # # NOTE: For test "basic-1.6". # if {![info exists no(read3.eagle)]} then { checkForFile $test_channel [file join $test_data_path read3.eagle] } # # NOTE: For test "basic-1.7". # if {![info exists no(read4.eagle)]} then { checkForFile $test_channel [file join $test_data_path read4.eagle] } # # NOTE: For test "infoScript-1.1". # if {![info exists no(script.eagle)]} then { checkForFile $test_channel [file join $test_data_path script.eagle] } # # NOTE: For test "basic-1.1". # if {![info exists no(source.eagle)]} then { checkForFile $test_channel [file join $test_data_path source.eagle] } # # NOTE: For test "basic-1.2". # if {![info exists no(unbalanced_brace.eagle)]} then { checkForFile $test_channel [file join \ $test_data_path unbalanced_brace.eagle] } # # NOTE: For test "basic-1.3". # if {![info exists no(unbalanced_brace2.eagle)]} then { checkForFile $test_channel [file join \ $test_data_path unbalanced_brace2.eagle] } # # NOTE: For tests "excel-2.*". # if {![info exists no(test.xls)]} then { checkForFile $test_channel [file join $test_data_path test.xls] } # # NOTE: For test "proc-1.9". # if {![info exists no(testProcs.tcl)]} then { checkForFile $test_channel [file join $test_data_path testProcs.tcl] } # # NOTE: For test "interp-1.10". # if {![info exists no(settings.xml)]} then { checkForFile $test_channel [file join $test_data_path settings.xml] } # # NOTE: For tests "load-1.1.*". # if {![info exists no(Plugin.dll)]} then { checkForFile $test_channel [file join $lib_path Plugin1.0 Plugin.dll] } # # NOTE: For test "object-6.1". # if {![info exists no(Sample.exe)]} then { checkForFile $test_channel [file join $bin_path Sample.exe] } # # NOTE: For test "object-4.8". # if {![info exists no(EagleCmdlets.dll)]} then { checkForFile $test_channel [file join $bin_path EagleCmdlets.dll] } # # NOTE: For test "object-4.10". # if {![info exists no(EagleExtensions.dll)]} then { checkForFile $test_channel [file join $bin_path EagleExtensions.dll] } # # NOTE: For test "object-4.10". # if {![info exists no(test.wxs)]} then { checkForFile $test_channel [file join $base_path Installer Tests test.wxs] } # # NOTE: For tests "sql-1.2", "sql-1.4", "sql-1.5", "sql-1.6", "sql-1.7", # "sql-1.8", and "sql-1.9". # if {![info exists no(sqlite3.dll)]} then { checkForFile $test_channel [file join $bin_path sqlite3.dll] # # NOTE: Did we manage to find the native SQLite library? If not, do we # at least know the machine type? # if {![haveConstraint file_sqlite3.dll]} then { # # NOTE: Ok, now try to check for the machine specific native SQLite # library. # checkForFile $test_channel [file join $bin_path [machineToPlatform \ $test_machine true] sqlite3.dll] # # NOTE: Did we manage to find the native SQLite library yet? # if {![haveConstraint file_sqlite3.dll]} then { # # NOTE: Ok, now try to check for the platform specific native SQLite # library. # checkForFile $test_channel [file join $bin_path [machineToPlatform \ $test_machine false] sqlite3.dll] } } } if {![info exists no(System.Data.SQLite.dll)]} then { checkForFile $test_channel [file join $bin_path System.Data.SQLite.dll] } if {![info exists no(test.sqlite3)]} then { checkForFile $test_channel [file join $test_data_path test.sqlite3] } } # # NOTE: Check the core test constraints unless they have been # explicitly disabled. # if {![info exists no(platform)]} then { checkForPlatform $test_channel } if {![info exists no(windowsVersion)]} then { checkForWindowsVersion $test_channel } if {![info exists no(scriptLibrary)]} then { checkForScriptLibrary $test_channel } if {![info exists no(tclOptions)]} then { checkForTclOptions $test_channel } if {![info exists no(checkForBigLists)]} then { checkForBigLists $test_channel } if {![info exists no(checkForMemoryIntensive)]} then { checkForMemoryIntensive $test_channel } if {![info exists no(checkForStackIntensive)]} then { checkForStackIntensive $test_channel } if {![info exists no(windowsCommandProcessor)]} then { checkForWindowsCommandProcessor $test_channel cmd.exe } if {![info exists no(fossil)]} then { checkForFossil $test_channel } if {![info exists no(testRepository)]} then { checkForVariable $test_channel test_repository } if {![info exists no(version)]} then { checkForVersion $test_channel } if {![info exists no(eagle)]} then { checkForEagle $test_channel } if {![info exists no(noLogFile)]} then { checkForLogFile $test_channel } if {![info exists no(symbols)]} then { checkForSymbols $test_channel [info nameofexecutable] } if {![info exists no(garuda)]} then { checkForGaruda $test_channel } if {![info exists no(shell)]} then { checkForShell $test_channel } if {![info exists no(debug)]} then { checkForDebug $test_channel } # # NOTE: Has Tk testing support been disabled? # if {![info exists no(tk)]} then { checkForTk $test_channel } # # NOTE: Has native code detection support been disabled? # if {![info exists no(native)]} then { checkForNativeCode $test_channel } # # NOTE: Check for various extra commands that may be present. # if {![info exists no(callbackCommand)]} then { checkForCommand $test_channel callback } if {![info exists no(libraryCommand)]} then { checkForCommand $test_channel library } if {![info exists no(socketCommand)]} then { checkForCommand $test_channel socket } if {![info exists no(sqlCommand)]} then { checkForCommand $test_channel sql } if {![info exists no(tclCommand)]} then { checkForCommand $test_channel tcl } if {![info exists no(xmlCommand)]} then { checkForCommand $test_channel xml } # # NOTE: Has namespace detection support been disabled? # if {![info exists no(namespaces)]} then { checkForNamespaces $test_channel [haveConstraint quiet] } # # NOTE: Check for various features that were added through # the TIP process. # if {![info exists no(tip127)]} then { checkForTip127 $test_channel } if {![info exists no(tip194)]} then { checkForTip194 $test_channel } if {![info exists no(tip207)]} then { checkForTip207 $test_channel } if {![info exists no(tip241)]} then { checkForTip241 $test_channel } if {![info exists no(tip285)]} then { checkForTip285 $test_channel } if {![info exists no(tip405)]} then { checkForTip405 $test_channel } if {![info exists no(tip426)]} then { checkForTip426 $test_channel } if {![info exists no(tip429)]} then { checkForTip429 $test_channel } # # NOTE: Has performance testing been disabled? # if {![info exists no(core)] && \ ![info exists no(checkForPerformance)]} then { checkForPerformance $test_channel } # # NOTE: Have any timing related constraints been disabled? # # BUGBUG: In Eagle, these checks for "precision" timing are not overly # reliable. This may be due to the semi-random nature of the # garbage collection. More research into the precise cause of # timing issues is certainly warranted. # # if {![info exists no(core)] && \ ![info exists no(timing)]} then { checkForTiming $test_channel 50; # 1/20th second. } if {![info exists no(core)] && \ ![info exists no(preciseTiming)]} then { # # NOTE: Normally, the "preciseTiming" constraint implicitly requires that # the "timing" constraint be present as well; however, that can be # overridden. # if {[info exists no(requireTiming)] || \ [haveConstraint timing]} then { checkForTiming $test_channel 25 preciseTiming; # 1/40th second. } } # # NOTE: Has interactive testing been disabled? # if {![info exists no(interactive)]} then { checkForInteractive $test_channel } # # NOTE: Has interactive command testing been disabled? # if {![info exists no(core)] && \ ![info exists no(interactiveCommand)]} then { # # NOTE: For test "debug-1.8". # checkForInteractiveCommand $test_channel go # # NOTE: For test "debug-1.9". # checkForInteractiveCommand $test_channel done # # NOTE: For test "object-15.9". # checkForInteractiveCommand $test_channel args } if {![info exists no(userInteraction)]} then { checkForUserInteraction $test_channel } # # NOTE: Check for network connectivity to our test host (i.e. # the Eagle distribution site). # if {![info exists no(core)] && ![info exists no(network)]} then { checkForNetwork $test_channel $test_host $test_timeout } # # NOTE: Figure out the approximate relative performance of this machine. # if {![info exists no(bogoCops)] && [haveConstraint performance]} then { tputs $test_channel \ "---- checking for baseline BogoCops (commands-per-second)... " if {![info exists test_base_cops]} then { # # NOTE: The expected performance numbers for all the # performance tests will be calibrated based on # this number (which is based on the measured # performance of the actual machine that was # used to determine those expected performance # numbers). # if {[isEagle]} then { set test_base_cops 36000.0; # NOTE: Eagle 1.0 Win32 } else { set test_base_cops 1570000.0; # NOTE: Tcl 8.4.19 Win32 } } tputs $test_channel [appendArgs $test_base_cops \n] tputs $test_channel \ "---- checking for baseline BogoCops multipliers... " if {![info exists test_base_cops_multipliers]} then { set test_base_cops_multipliers [list \ 2 4 8 10 16 20 32 50 64 100 1000 10000 100000 1000000] } tputs $test_channel [appendArgs $test_base_cops_multipliers \n] tputs $test_channel \ "---- checking for current BogoCops (commands-per-second)... " if {![info exists test_cops]} then { set test_cops [calculateBogoCops] } tputs $test_channel [appendArgs [formatDecimal $test_cops] \n] tputs $test_channel \ "---- checking for current BogoCops against baseline BogoCops... " if {$test_cops > $test_base_cops} then { if {![info exists no(fasterBogoCops)]} then { addConstraint sameOrFasterBogoCops addConstraint fasterBogoCops if {![info exists no(bogoCopsMultipliers)]} then { foreach multiplier $test_base_cops_multipliers { if {$test_cops >= $test_base_cops * $multiplier} then { addConstraint [appendArgs fasterBogoCopsBy $multiplier X] } } unset multiplier } } tputs $test_channel faster\n } elseif {$test_cops < $test_base_cops} then { if {![info exists no(slowerBogoCops)]} then { addConstraint sameOrSlowerBogoCops addConstraint slowerBogoCops if {![info exists no(bogoCopsMultipliers)]} then { foreach multiplier $test_base_cops_multipliers { if {$test_cops <= $test_base_cops * (1.0 / $multiplier)} then { addConstraint [appendArgs slowerBogoCopsBy $multiplier X] } } unset multiplier } } tputs $test_channel slower\n } else { if {![info exists no(sameBogoCops)]} then { addConstraint sameOrFasterBogoCops addConstraint sameOrSlowerBogoCops addConstraint sameBogoCops } tputs $test_channel same\n } set percent [expr {[calculateRelativePerformance iterations 1] * 100}] tputs $test_channel [appendArgs \ "---- current BogoCops (commands-per-second) is " [formatDecimal \ [expr {$percent > 100 ? $percent - 100 : $percent}] 2] "% " \ [expr {$percent > 100 ? "faster than" : "as fast as"}] \ " the baseline\n"] unset percent } ############################################################################# ######################## END Eagle & Tcl Constraints ######################## ############################################################################# # # NOTE: For Eagle, dump the platform information, including # the compile options. # if {[isEagle]} then { # # NOTE: Is the use of Fossil by the test suite allowed? # if {[canExecFossil]} then { # # NOTE: Get the source checkout and tags (i.e. of Eagle or whatever # project the Eagle binaries are being used by) using a Fossil # binary in the PATH, if available. # if {[catch {exec -- fossil info} exec] == 0} then { set pattern {^checkout:\s+(.*?)\s+$} if {![regexp -line -- $pattern $exec dummy checkout]} then { # # NOTE: We could not query the source checkout from Fossil. # set checkout } set pattern {^tags:\s+(.*?)\s+$} if {![regexp -line -- $pattern $exec dummy tags]} then { # # NOTE: We could not query the tags from Fossil. # set tags } } else { # # NOTE: We could not query information from Fossil. # set checkout set tags } unset -nocomplain dummy exec pattern } else { # # NOTE: Use of Fossil by the test suite is forbidden. # set checkout set tags } tputs $test_channel [appendArgs "---- checkout: " \ $checkout \n] tputs $test_channel [appendArgs "---- tags: " \ $tags \n] unset tags checkout ########################################################################### set timeStamp [getPlatformInfo timeStamp ""] if {[string length $timeStamp] > 0} then { ######################################################################### # MONO: Bug, see: https://bugzilla.novell.com/show_bug.cgi?id=479061 ######################################################################### if {[isMono]} then { # # HACK: We need something to go into the log file. # set timeStamp [lindex $timeStamp 0] } else { set timeStamp [formatTimeStamp [clock scan $timeStamp]] } } else { set timeStamp } tputs $test_channel [appendArgs "---- build: " \ [list [getPlatformInfo engine ]] " " \ [list [getPlatformInfo patchLevel ]] " " \ [list [getPlatformInfo tag ]] " " \ [list [getPlatformInfo release ]] " " \ [list [getPlatformInfo text ]] " " \ [list [getPlatformInfo configuration ]] " " \ [list [getPlatformInfo suffix ]] " " \ [list $timeStamp] " " \ [list [getPlatformInfo sourceId ]] " " \ [list [getPlatformInfo sourceTimeStamp ]] \n] unset timeStamp tputs $test_channel [appendArgs "---- os: " \ [getPlatformInfo os ] \n] tputs $test_channel [appendArgs "---- globalAssemblyCache: " \ [getPlatformInfo globalAssemblyCache ] \n] tputs $test_channel [appendArgs "---- moduleVersionId: " \ [getPlatformInfo moduleVersionId ] \n] tputs $test_channel [appendArgs "---- compileOptions: " \ [formatList [getPlatformInfo compileOptions ]] \n] tputs $test_channel [appendArgs "---- strongName: " \ [getPlatformInfo strongName ] \n] tputs $test_channel [appendArgs "---- certificate: " \ [getPlatformInfo certificate ] \n] tputs $test_channel [appendArgs "---- targetFramework: " \ [getPlatformInfo targetFramework ] \n] } # # NOTE: Show the current test file name, if any. # tputs $test_channel [appendArgs "---- test file: " \ [expr {[info exists test_file] && [string length $test_file] > 0 ? \ $test_file : ""}] \n] # # NOTE: Show the active test constraints. # tputs $test_channel [appendArgs "---- constraints: " \ [formatList [lsort [getConstraints]] ] \n] # # NOTE: Show the starting command count (for both Tcl and Eagle). # tputs $test_channel [appendArgs "---- starting command count: " \ [info cmdcount] \n] if {[isEagle]} then { # # NOTE: Show the starting operation count (for Eagle only). # tputs $test_channel [appendArgs "---- starting operation count: " \ [object invoke -flags +NonPublic Interpreter.GetActive \ OperationCount] \n] # # NOTE: Record the raw starting performance count, for later use in # calculating the approximate number of microseconds elapsed. # catch {set test_timestamp(startCount) [clock start]} } # # NOTE: Show when the tests actually began (now). # tputs $test_channel [appendArgs "---- tests started at " \ [formatTimeStamp [set test_timestamp(startSeconds) \ [clock seconds]]] \n] }