System.Data.SQLite

          if {[string length $newString] > 0} then {
            appendSharedLogFile $fileName $newString
          }

          unset ::test_log_queue($entry)
        }

        #
        # NOTE: If all entries in the test log queue were just processed,
        #       unset the entire array now.
        #
        if {[array size test_log_queue] == 0} then {
          unset ::test_log_queue
        }
      }

      #
      # NOTE: If an empty string is supplied by the caller, do nothing.
      #
      if {[string length $string] > 0} then {
        appendSharedLogFile $fileName $string

      # TODO: Possibly add a check if the file actually exists
      #       here.
      #
      if {[string length $value] > 0} then {
        #
        # NOTE: *EXTERNAL* Use verbatim, no normalization.
        #
        if {$automatic && [isEagle]} then {
          #
          # NOTE: In automatic mode, the environment variable
          #       value simply represents another candidate
          #       Tcl shell (i.e. it does not halt the search
          #       for other candidate Tcl shells).
          #
          lappend shells $value

    } else {
      #
      # NOTE: We are missing the suffix, return nothing.
      #
      return ""
    }
  }

  #
  # NOTE: This procedure should return non-zero if the [exec] command may be
  #       used by the specified test package procedure.
  #
  proc canTestExec { procName } {
    if {[info exists ::no(exec)]} then {
      return false
    }

    if {[info exists ::no(canTestExec)]} then {
      return false
    }

    if {[string length $procName] > 0 && \
        [info exists [appendArgs ::no(canTestExec. $procName )]]} then {
      return false
    }

    return true
  }

  proc testExec { commandName options args } {
    set command [list exec]

    if {[llength $options] > 0} then {eval lappend command $options}

    lappend command -- $commandName

    if {[llength $args] > 0} then {eval lappend command $args}
    set procName [lindex [info level [info level]] 0]

    if {![canTestExec $procName]} then {
      tputs $::test_channel [appendArgs "---- skipping command: " $command \n]


      error "test use of \[$procName\] has been disabled"
    } else {
      tputs $::test_channel [appendArgs "---- running command: " $command \n]

      return [uplevel 1 $command]
    }
  }

      lappend command mono \
          [appendArgs \" [file nativename $commandName] \"]
    } else {
      lappend command $commandName
    }

    if {[llength $args] > 0} then {eval lappend command $args}
    set procName [lindex [info level [info level]] 0]

    if {![canTestExec $procName]} then {
      tputs $::test_channel [appendArgs "---- skipping command: " $command \n]


      error "test use of \[$procName\] has been disabled"
    } else {
      tputs $::test_channel [appendArgs "---- running command: " $command \n]

      return [uplevel 1 $command]
    }
  }

  proc execTestShell { options args } {
    set procName [lindex [info level [info level]] 0]

    if {![canTestExec $procName]} then {
      tputs $::test_channel [appendArgs \
          "---- skipping nested shell: exec " [string trim [appendArgs \
          $options " " -- " \"" [info nameofexecutable] "\" " $args]] \n]


      error "test use of \[$procName\] has been disabled"
    } else {
      tputs $::test_channel [appendArgs \
          "---- running nested shell: exec " [string trim [appendArgs \
          $options " " -- " \"" [info nameofexecutable] "\" " $args]] \n]

      return [uplevel 1 execShell [list $options] $args]

  }

  proc reportTestPercent {
          channel percent totalFiles failedFiles leakedFiles } {
    if {[isEagle]} then {
      set totalTests $::eagle_tests(Total)
      set failedTests $::eagle_tests(Failed)
      set skippedTests $::eagle_tests(Skipped)
    } else {
      set totalTests $::tcltest::numTests(Total)
      set failedTests $::tcltest::numTests(Failed)
      set skippedTests $::tcltest::numTests(Skipped)
    }

    set status [appendArgs \
        "---- test suite running, about " $percent "% complete (" \
        $totalTests " tests total, " $failedTests " tests failed, " \
        $skippedTests " tests skipped, " $totalFiles " files total, " \
        $failedFiles " files failed, " $leakedFiles " files leaked)..."]

    tputs $channel [appendArgs $status \n]

    if {[isEagle]} then {
      host title $status
    }
  }


    proc getTkVersionForTclShell { {shell ""} } {
      return [testExecTclScript {
        puts -nonewline stdout [package require Tk]; exit
      } $shell]
    }

    proc getGarudaDll { {machine ""} } {
      #
      # NOTE: Get the Garuda DLL of the same platform (i.e. machine type)
      #       as the native Tcl shell.
      #
      if {[info exists ::base_path]} then {
        #
        # NOTE: Get the effective test configuration.

        #
        # NOTE: Get the effective test suffix.  This is allowed to be an
        #       empty string.
        #
        set suffix [getTestSuffix]

        #
        # NOTE: If necessary, automatically detect the machine for the Tcl
        #       shell that we plan on using.
        #
        if {[string length $machine] == 0} then {
          set machine [getMachineForTclShell]
        }

        #
        # NOTE: Build the full path and file name of the Garuda DLL, using
        #       the Eagle base path.  Currently, this will only work
        #       correctly if the test suite is being run from inside the
        #       source tree.
        #
        return [file join $::base_path bin \
            [machineToPlatform $machine] [appendArgs $configuration Dll \
            $suffix] [appendArgs Garuda [info sharedlibextension]]]

      } else {
        #
        # NOTE: We are missing the base path, return nothing.
        #
        return ""
      }
    }

#
# NOTE: Use our own namespace here because even though we do not directly
#       support namespaces ourselves, we do not want to pollute the global
#       namespace if this script actually ends up being evaluated in Tcl.
#
namespace eval ::Eagle {
  proc getKnownCompileOptions {} {
    return [list \
        APPDOMAINS APPROVED_VERBS ARM ASSEMBLY_RELEASE \
        ASSEMBLY_STRONG_NAME_TAG ASSEMBLY_TAG ASSEMBLY_TEXT ASSEMBLY_URI \
        BREAK_ON_EXITING BREAKPOINTS CACHE_ARGUMENT_TOSTRING \
        CACHE_ARGUMENTLIST_TOSTRING CACHE_DICTIONARY CACHE_RESULT_TOSTRING \
        CACHE_STATISTICS CACHE_STRINGLIST_TOSTRING CALLBACK_QUEUE CAS_POLICY \
        CODE_ANALYSIS COM_TYPE_CACHE CONSOLE DAEMON DATA DEAD_CODE DEBUG \
        DEBUGGER DEBUGGER_ARGUMENTS DEBUG_TRACE DEBUG_WRITE DRAWING DYNAMIC \
        EAGLE EMBEDDED_LIBRARY EXECUTE_CACHE EXPRESSION_FLAGS FAST_ERRORCODE \
        FAST_ERRORINFO HAVE_SIZEOF HISTORY IA64 INTERACTIVE_COMMANDS \
        INTERNALS_VISIBLE_TO ISOLATED_INTERPRETERS ISOLATED_PLUGINS LIBRARY \
        LICENSING LIST_CACHE MONO MONO_BUILD MONO_HACKS MONO_LEGACY \
        NATIVE NATIVE_PACKAGE NATIVE_UTILITY NATIVE_UTILITY_BSTR NETWORK \
        NET_20 NET_20_FAST_ENUM NET_20_ONLY NET_20_SP1 NET_20_SP2 NET_30 \
        NET_35 NET_40 NET_45 NET_451 NON_WORKING_CODE NOTIFY NOTIFY_ACTIVE \
        NOTIFY_ARGUMENTS NOTIFY_GLOBAL NOTIFY_OBJECT OBSOLETE PARSE_CACHE \
        PATCHLEVEL POLICY_TRACE PREVIOUS_RESULT RANDOMIZE_ID REMOTING SAMPLE \
        SERIALIZATION SHARED_ID_POOL SHELL SOURCE_ID SOURCE_TIMESTAMP STATIC \
        TCL TCL_KITS TCL_THREADED TCL_THREADS TCL_UNICODE TCL_WRAPPER TEST \
        THREADING THROW_ON_DISPOSED TRACE TYPE_CACHE UNIX VERBOSE WEB \
        WINDOWS WINFORMS WIX_30 WIX_35 WIX_36 WIX_37 WIX_38 X64 X86 XML]
  }

  proc getKnownMonoVersions {} {
    #
    # NOTE: This job of this procedure is to return the list of "known"
    #       versions of Mono supported by the test suite infrastructure.
    #
    return [list \
        [list 2 0] [list 2 2] [list 2 4] [list 2 6] [list 2 8] [list 2 10] \
        [list 2 11] [list 2 12] [list 3 0] [list 3 1] [list 3 2] [list 3 3] \
        [list 3 4] [list 3 5] [list 3 6]]
  }

  #
  # NOTE: This procedure should return non-zero if the native Tcl shell may
  #       be executed by the test suite infrastructure outside the context
  #       of any specific tests.  The specific tests themselves must make
  #       use of their own constraints to prevent execution of the native
  #       Tcl shell.
  #
  proc canExecTclShell {} {
    if {[info exists ::no(exec)]} then {
      return false
    }

    if {[info exists ::no(tcl)]} then {
      return false
    }

    if {[info exists ::no(canExecTclShell)]} then {
      return false
    }

    return true
  }

  #
  # NOTE: This procedure should return non-zero if Fossil may be executed by
  #       the test suite infrastructure outside the context of any specific
  #       tests.  The specific tests themselves must make use of their own
  #       constraints to prevent execution of Fossil.
  #
  proc canExecFossil {} {
    if {[info exists ::no(exec)]} then {
      return false
    }

    if {[info exists ::no(fossil)]} then {
      return false
    }

    if {[info exists ::no(canExecFossil)]} then {
      return false
    }

    return true
  }

  proc checkForTestSuiteFiles { channel } {
    tputs $channel "---- checking for test suite files... "

    #
    # NOTE: Start out with no test suite files to check.
    #

    tputs $channel no\n
  }

  proc checkForFossil { channel } {
    tputs $channel "---- checking for Fossil... "

    if {[canExecFossil] && \
        [catch {exec -- fossil version} version] == 0} then {
      set version [string trim $version]
      set pattern {^This is fossil version (.*) \[([0-9a-f]+)\]\
          \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} UTC$}

      if {[regexp -- $pattern $version dummy version sourceId]} then {
        #
        # NOTE: Add a constraint to show that the Fossil executable
        #       itself is available.
        #
        addConstraint fossil_version

        #
        # NOTE: Append the version of Fossil currently in use.
        #
        append result version " " $version " \[" $sourceId \]

        if {[canExecFossil] && \
            [catch {exec -- fossil remote} remote] == 0} then {
          set remote [string trim $remote]; set valid false

          if {[isEagle]} then {
            #
            # NOTE: With Eagle, we can actually validate the URI.
            #
            if {[uri isvalid $remote]} then {

  proc checkForTestExec { channel } {
    tputs $channel "---- checking for test use of \"exec\" command... "

    if {![info exists ::no(testExec)]} then {
      addConstraint testExec

      tputs $channel yes\n

      if {[info exists ::no(exec)]} then {
        tputs $channel \
            "==== WARNING: running with the \"testExec\" procedure disabled\n"
      }
    } else {
      tputs $channel no\n
    }
  }

  proc checkForTestMachine { channel } {
    tputs $channel "---- checking for test machine... "

          return
        }
      }

      tputs $channel no\n
    }
  }

  proc checkForKnownCompileOptions { channel } {
    #
    # NOTE: Check for all "known" compile options.
    #
    tputs $channel "---- checking for known compile options... "

    set options [getKnownCompileOptions]

    if {[llength $options] > 0} then {
      tputs $channel [appendArgs "yes (" [llength $options] ")\n"]

      foreach option $options {
        if {![info exists [appendArgs ::no(compile. $option )]]} then {
          checkForCompileOption $channel $option
        }
      }
    } else {
      tputs $channel no\n
    }
  }

  if {[isEagle]} then {
    ###########################################################################
    ############################ BEGIN Eagle ONLY #############################
    ###########################################################################

    proc checkForSoftwareUpdateTrust { channel } {

            -bit " " $::tcl_platform(machine) \n]
      } else {
        tputs $channel "no, unknown\n"
      }
    }

    proc checkForGarudaDll { channel } {
      #
      # NOTE: Skip automatic Tcl shell machine detection if we are not
      #       allowed to execute external commands.
      #
      if {[canExecTclShell]} then {
        #
        # NOTE: Have the [getGarudaDll] procedure automatically detect the
        #       machine.
        #
        set machine ""
      } else {
        #
        # NOTE: Use the machine for this test run.
        #
        set machine [getTestMachine]

        #
        # NOTE: Since an empty string means "automatically detect" to the
        #       [getGarudaDll] procedure, we must make sure the value is
        #       something else.
        #
        if {[string length $machine] == 0} then {
          set machine unknown
        }
      }

      #
      # NOTE: Check for the Garuda DLL of the same platform (i.e. machine
      #       type) as the native Tcl shell.
      #
      return [checkForFile $channel [getGarudaDll $machine]]
    }

    proc checkForCulture { channel } {
      tputs $channel "---- checking for culture... "

      #
      # NOTE: Grab the current culture.

      #
      # HACK: If this returns "error" that normally indicates an error was
      #       caught during [exec] (i.e. the native Tcl shell could not be
      #       executed).
      #
      set prefix "---- checking for Tcl shell version... "

      if {[canExecTclShell] && \
          [catch {getTclVersionForTclShell} version] == 0 && \
          $version ne "error"} then {
        #
        # NOTE: Yes, a native Tcl shell appears to be available.
        #
        addConstraint tclShell

        #

      # HACK: We do not care about the Tk version returned from this
      #       procedure, we only care if it returns "error" because that
      #       would indicate an error was caught during [exec] (i.e. the
      #       native Tcl shell could not be executed).
      #
      set prefix "---- checking for Tk package version... "

      if {[canExecTclShell] && \
          [catch {getTkVersionForTclShell} version] == 0 && \
          $version ne "error"} then {
        #
        # NOTE: Yes, a native Tk package appears to be available.
        #
        addConstraint tkPackage

        tputs $channel [appendArgs $prefix "yes (" $version ")\n"]

    ###########################################################################

    #
    # NOTE: We need several of our test constraint related commands in the
    #       global namespace.
    #
    exportAndImportPackageCommands [namespace current] [list \
        getKnownCompileOptions getKnownMonoVersions canExecTclShell \
        canExecFossil checkForTestSuiteFiles checkForPlatform \
        checkForWindowsVersion checkForScriptLibrary checkForVariable \
        checkForTclOptions checkForWindowsCommandProcessor checkForFossil \
        checkForEagle checkForSymbols checkForLogFile checkForGaruda \
        checkForShell checkForDebug checkForTk checkForVersion \
        checkForCommand checkForTestExec checkForTestMachine \
        checkForTestPlatform checkForTestConfiguration checkForTestSuffix \
        checkForFile checkForPathFile checkForNativeCode checkForTip127 \
        checkForTip194 checkForTip241 checkForTip285 checkForTip405 \
        checkForTip426 checkForTiming checkForPerformance checkForBigLists \
        checkForStackIntensive checkForInteractive checkForInteractiveCommand \
        checkForUserInteraction checkForNetwork checkForCompileOption \
        checkForKnownCompileOptions] false false

    ###########################################################################
    ############################## END Tcl ONLY ###############################
    ###########################################################################
  }

  #
  # NOTE: Provide the Eagle test constraints package to the interpreter.
  #
  package provide Eagle.Test.Constraints \
    [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
}


    }

    unset pkg_dir
  }

  #############################################################################



































  #
  # NOTE: Set the executable file name for the process, if
  #       necessary.
  #
  if {![info exists bin_file]} then {
    set bin_file [info nameofexecutable]
  }

  #############################################################################

  #
  # 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 \
        [appendArgs 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.

        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)]} then {
              tputs $test_channel \
                  "==== WARNING: attempting automatic Tcl shell selection...\n"

    #
    # 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 {

    }

    #
    # 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 {

        "---- 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 ###########################
    ###########################################################################
  }

  #
  # 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 <none>
        set tags <none>
      }

      unset -nocomplain dummy exec pattern
    } else {
      #
      # NOTE: Use of Fossil by the test suite is forbidden.
      #
      set checkout <none>
      set tags <none>
    }

    tputs $test_channel [appendArgs "---- checkout: " \
        $checkout \n]