System.Data.SQLite

  #       of Unix).  This procedure must function correctly in both Tcl
  #       and Eagle and must return non-zero only when on Windows.
  #
  proc isWindows {} {
    return [expr {[info exists ::tcl_platform(platform)] && \
        $::tcl_platform(platform) eq "windows"}]
  }

  #
  # NOTE: This procedure should return non-zero if and only if only there
  #       is currently an interactive user that can respond to prompts and
  #       other requests for input.
  #
  proc isInteractive {} {
    #
    # TODO: Is more complex checking required here?
    #
    return [expr {[info exists ::tcl_interactive] && $::tcl_interactive}]
  }

  proc haveGaruda { {varName ""} } {
    #
    # NOTE: Check for a variable name to place the Garuda package Id into.
    #
    if {[string length $varName] > 0} then {
      upvar 1 $varName packageId


    #
    # NOTE: This proc is used to check for new versions -OR- new update
    #       scripts for the runtime when a user executes the interactive
    #       "#check" command.  To disable this functionality, simply
    #       redefine this procedure to do nothing.
    #
    proc checkForUpdate {
            {wantScripts false} {quiet false} {prompt false}
            {automatic false} } {
      #
      # NOTE: This should work properly in Eagle only.
      #
      set updateUri [appendArgs \
          [info engine UpdateBaseUri] [info engine UpdatePathAndQuery]]

      #

                #
                # NOTE: The engine patch level from the line is greater,
                #       we are out-of-date.  Return the result of our
                #       checking now.
                #
                if {$checkBuild} then {
                  #
                  # NOTE: Are we supposed to prompt the interactive user,
                  #       if any, to upgrade now?
                  #
                  set text [appendArgs \
                      "latest build " $patchLevel ", dated " $dateTime \
                      ", is newer than the running build " $enginePatchLevel \
                      ", dated " $engineDateTime]

                  if {$prompt && [isInteractive]} then {
                    set caption [appendArgs \
                        [info engine Name] " " [lindex [info level 0] 0]]

                    if {[object invoke -flags +NonPublic \
                        Eagle._Components.Private.WindowOps YesOrNo \
                        [appendArgs $text \n\n "Run the updater now?"] \
                        $caption false]} then {
                      #
                      # NOTE: Ok, run the updater now and then exit.
                      #
                      runUpdateAndExit $automatic
                    }
                  }

                  return [list $text [list $baseUri $patchLevel] [list $notes]]
                }

                #
                # NOTE: The script patch level from the line matches the
                #       current engine patch level exactly, this script
                #       should be evaluated if it can be authenticated.
                #

    }

    #
    # NOTE: Exports the necessary commands from this package and import them
    #       into the global namespace.
    #
    exportAndImportPackageCommands [namespace current] [list \
        isEagle isWindows isInteractive haveGaruda isTclThread isMono \
        isSameFileName getEnvironmentVariable combineFlags getCompileInfo \
        getPlatformInfo getPluginPath appendArgs lappendArgs \
        getDictionaryValue getColumnValue getRowColumnValue tqputs tqlog \
        readFile readSharedFile writeFile appendFile appendLogFile \
        appendSharedFile appendSharedLogFile readAsciiFile writeAsciiFile \
        readUnicodeFile writeUnicodeFile getDirResultPath addToPath \
        removeFromPath execShell lshuffle ldifference filter map reduce \
        getLengthModifier debug findDirectories findFiles findFilesRecursive \
        exportAndImportPackageCommands] false false

    ###########################################################################
    ############################## END Tcl ONLY ###############################
    ###########################################################################
  }


      set array(transactions,$index) 0
      set array(modules,$index) 0
      set array(delegates,$index) 0
      set array(tcl,$index) 0
      set array(tclInterps,$index) 0
      set array(tclThreads,$index) 0
      set array(tclCommands,$index) 0
      set array(scriptThreads,$index) 0

      catch {set array(connections,$index) [llength [info connections]]}
      catch {set array(transactions,$index) [llength [info transactions]]}
      catch {set array(modules,$index) [llength [info modules]]}
      catch {set array(delegates,$index) [llength [info delegates]]}

      if {[llength [info commands tcl]] > 0} then {
        set array(tcl,$index) [tcl ready]
      }

      catch {set array(tclInterps,$index) [llength [tcl interps]]}
      catch {set array(tclThreads,$index) [llength [tcl threads]]}
      catch {set array(tclCommands,$index) [llength [tcl command list]]}

      #
      # NOTE: Grab the number of active threads that are active because
      #       of ScriptThread object instances.  This only works if Eagle
      #       is Beta 31 or higher.
      #
      catch {
        set array(scriptThreads,$index) [object invoke -flags +NonPublic \
            ScriptThread activeCount]
      }
    }
  }

  proc reportTestStatistics { channel fileName statsVarName filesVarName } {
    set statistics [list afters variables commands procedures namespaces \
        files temporaryFiles channels aliases interpreters environment]

    if {[isEagle]} then {
      #
      # TODO: For now, tracking "leaked" assemblies is meaningless because
      #       the .NET Framework has no way to unload them without tearing
      #       down the entire application domain.
      #
      lappend statistics \
          scopes assemblies processes objects objectCallbacks objectTypes \
          objectInterfaces objectNamespaces connections transactions modules \
          delegates tcl tclInterps tclThreads tclCommands scriptThreads

    }

    #
    # NOTE: Show what leaked, if anything.
    #
    set count 0; upvar 1 $statsVarName array

    #       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 was adapted from the one listed on the Tcl Wiki page
  #       at "http://wiki.tcl.tk/43".  It is only intended to be used on very
  #       small lists because of its heavy use of recursion and complexity on
  #       the order of O(N!).
  #
  proc lpermute { list } {
    set length [llength $list]
    if {$length < 2} {
      return [list $list]
    }
    set index 0
    foreach element1 $list {
      if {$index == 0} then {
        set rest [lrange $list 1 end]
      } elseif {$index == $length - 1} then {
        set rest [lrange $list 0 end-1]
      } else {
        set rest [concat \
            [lrange $list 0 [expr {$index - 1}]] \
            [lrange $list [expr {$index + 1}] end]]
      }
      incr index
      foreach list2 [lpermute $rest] {
        lappend result [concat [list $element1] $list2]
      }
    }
    return $result
  }

  proc alwaysFullInterpReady {} {
    #
    # NOTE: The [interp readylimit] sub-command is only in Eagle.
    #
    if {![isEagle]} then {
      return true

      tputs $channel [appendArgs $::test_suffix \n]
    } else {
      tputs $channel unknown\n
    }
  }

  proc checkForFile { channel name {constraint ""} } {
    tputs $channel [appendArgs "---- checking for file \"" \
        [file normalize $name] "\"... "]

    if {[file exists $name]} then {
      #
      # NOTE: Yes, it appears that it is available.
      #
      if {[string length $constraint] > 0} then {
        addConstraint [appendArgs file_ $constraint]


  proc checkForNetwork { channel host timeout } {
    tputs $channel [appendArgs \
        "---- checking for network connectivity to host \"" $host "\"... "]

    if {[isEagle]} then {
      #
      # NOTE: Running this check on the Mono 3.3.0 (or 3.4.0?) release build
      #       will lock up the process; therefore, skip it in that case.
      #
      if {[info exists ::no(mono)] || ![isMono] || \
          (![haveConstraint mono33] && ![haveConstraint mono34])} then {
        #
        # BUGBUG: Tcl 8.4 does not like this expression (and Tcl tries to
        #         compile it even though it will only actually ever be
        #         evaluated in Eagle).
        #
        set expr {[llength [info commands uri]] > 0 && \
            [catch {uri ping $host $timeout} response] == 0 && \

          addConstraint [appendArgs network_ $host]

          tputs $channel [appendArgs "yes (" $response ")\n"]
        } else {
          tputs $channel no\n
        }
      } else {
        tputs $channel "skipped, may hang on Mono 3.3.0 and 3.4.0\n"
      }
    } else {
      #
      # HACK: Running in Tcl, just assume we have network access.
      #
      addConstraint [appendArgs network_ $host]

        tputs $channel [appendArgs $::eagle_platform(runtimeVersion) \
            " " ( $dotVersion ) \n]
      } else {
        tputs $channel no\n
      }
    }

    proc checkForProcessBits { channel } {
      tputs $channel "---- checking for process bits... "

      if {[info exists ::tcl_platform(processBits)] && \
          [string is integer -strict $::tcl_platform(processBits)]} then {
        addConstraint [appendArgs $::tcl_platform(processBits) bit]

        tputs $channel [appendArgs $::tcl_platform(processBits) -bit\n]
      } else {
        tputs $channel unknown\n
      }
    }

    proc checkForMachine { channel bits machine } {
      tputs $channel [appendArgs "---- checking for machine \"" $bits \
          "-bit " $machine "\"... "]

      #
      # NOTE: What are the machine architecture and the

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

    #
    # NOTE: We need several of our test constraint related commands in the
    #       global namespace.
    #
    exportAndImportPackageCommands [namespace current] [list \
        getKnownCompileOptions getKnownMonoVersions lpermute \
        alwaysFullInterpReady canExecTclShell canExecFossil \
        checkForTestSuiteFiles checkForPlatform 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 checkForTip429 checkForTiming \
        checkForPerformance checkForBigLists checkForMemoryIntensive \
        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"}]
}


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

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