System.Data.SQLite

        return [appendArgs "downloaded URI " [lindex $args 0] \
            " to directory \"" $directory \"]
      } else {
        return "cannot fetch update, the URI is invalid"
      }
    }

    proc runUpdateAndExit { {automatic false} } {
      set directory [file dirname [info nameofexecutable]]

      set command [list exec -shell -- \
          [file join $directory Hippogriff.exe] -delay 2000]

      if {$automatic} then {
        eval lappend command -silent true -confirm false
      }

      eval $command &; exit -force
    }

    proc getUpdateData { uri } {
      #
      # NOTE: Temporarily start trusting ONLY our own self-signed

    #       "#check" command.  To disable this functionality, simply
    #       redefine this procedure to do nothing.
    #
    proc checkForUpdate { {wantScripts false} {quiet false} } {
      #
      # NOTE: This should work properly in Eagle only.
      #
      set updateUri [appendArgs \
          [info engine UpdateBaseUri] [info engine UpdatePathAndQuery]]

      #
      # NOTE: Fetch the master update data from the distribution site
      #       and normalize to Unix-style line-endings.
      #
      set updateData [string map [list \r\n \n] [getUpdateData $updateUri]]

    #
    # HACK: Prevent the Eagle core test suite infrastructure from checking
    #       test constraints that are time-consuming and/or most likely to
    #       be superfluous to third-party test suites (i.e. those that are
    #       not testing the Eagle core library itself).
    #
    set no(core) 1








  }
}

###############################################################################
############################### END VENDOR CODE ###############################
###############################################################################

        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 OFFICIAL \
        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.
    #

    }
  }

  proc checkForNamespaces { channel } {
    tputs $channel "---- checking for namespace support... "

    if {[isEagle]} then {
      #
      # NOTE: Check if namespace support was compiled into the core library
      #       (i.e. this is beta 30 or later).
      #
      set available false

      if {[catch {string length [object invoke \
              Type GetType Eagle._Commands.Namespace2]} length] == 0 && \
          [set available [expr {$length > 0}]]} then {
        addConstraint namespaces.available
      } else {
        addConstraint namespaces.unavailable
      }

      if {[catch {object invoke -flags +NonPublic Interpreter.GetActive \
              AreNamespacesEnabled} enabled] == 0} then {
        #
        # NOTE: We were able to query for namespace support (i.e. this
        #       must be beta 29 or later); however, we still need to
        #       check if it has been enabled at runtime.
        #
        if {$enabled} then {
          #
          # NOTE: Yes, it appears that it is available and enabled.
          #
          addConstraint namespaces

          tputs $channel enabled\n
        } else {
          tputs $channel disabled\n

          #
          # NOTE: Check if namespace support was compiled into the core
          #       library (i.e. is this beta 30 or later).
          #
          if {$available} then {
            #
            # NOTE: The tests seem to be running with namespace support
            #       available, but disabled.  Emit a warning into the
            #       test log file.
            #
            tputs $channel \
                "==== WARNING: running with namespaces available and disabled\n"
          }
        }
      } else {
        tputs $channel error\n
      }
    } else {
      #
      # NOTE: All supported versions of native Tcl have namespaces enabled
      #       and available.
      #
      addConstraint namespaces.available
      addConstraint namespaces

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

    set procName [lindex [info level [info level]] 0]

    if {![info exists ::no(testExec)] && [canTestExec $procName]} then {
      addConstraint testExec

      tputs $channel yes\n

      if {[info exists ::no(exec)]} then {
        tputs $channel \
            "==== WARNING: running with the \"testExec\" procedure disabled\n"

    #
    # NOTE: Is the interpreter TIP #194 ready?
    #
    catch {apply} error

    if {$error ne {invalid command name "apply"}} then {
      addConstraint tip194

      tputs $channel yes\n
    } else {
      tputs $channel no\n
    }
  }

  proc checkForTip207 { channel } {
    tputs $channel "---- checking for TIP #207... "

    #
    # NOTE: Is the interpreter TIP #207 ready?
    #
    catch {interp invokehidden {} -namespace -- info} error

    if {![string match {bad option "-namespace": *} $error]} then {
      addConstraint tip207

      tputs $channel yes\n
    } else {
      tputs $channel no\n
    }
  }


        checkForWindowsVersion checkForScriptLibrary checkForVariable \
        checkForTclOptions checkForWindowsCommandProcessor checkForFossil \
        checkForEagle checkForSymbols checkForLogFile checkForGaruda \
        checkForShell checkForDebug checkForTk checkForVersion \
        checkForCommand checkForNamespaces checkForTestExec \
        checkForTestMachine checkForTestPlatform checkForTestConfiguration \
        checkForTestSuffix checkForFile checkForPathFile checkForNativeCode \
        checkForTip127 checkForTip194 checkForTip207 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"}]
}


    #   set no(mono) true
    # }

    ###########################################################################
    ######################### BEGIN Eagle Constraints #########################
    ###########################################################################

    tputs $test_channel \
        "---- start of Eagle specific test constraints...\n"

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

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

    ###########################################################################
  }

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

  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

    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 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 {
      addConstraint sameOrFasterBogoCops
      addConstraint fasterBogoCops

      tputs $test_channel faster\n
    } elseif {$test_cops < $test_base_cops} then {
      addConstraint sameOrSlowerBogoCops
      addConstraint slowerBogoCops

      tputs $test_channel slower\n
    } else {
      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"}] \