System.Data.SQLite

{
  "runtimeOptions": {
    "tfm": "netcoreapp2.0",
    "framework": {
      "name": "Microsoft.NETCore.App",
      "version": "2.0.0"
    }
  }
}


  #
  # NOTE: This procedure is used to determine whether the C# compiler appears
  #       to work when invoked via the interfaces defined in this script file.
  #       Non-zero is returned to indicate success.  This procedure should not
  #       raise script errors.
  #
  proc doesCompileCSharpWork { {name ""} {errorsVarName ""} } {
    if {[string length $errorsVarName] > 0} then {
      upvar 1 $errorsVarName errors
    }

    if {[catch {getCSharpTestProgram $name} program]} then {
      set errors [list [appendArgs \
          "caught error while getting \"" $name "\" test program: " \
          $program]]

      return false
    }

    if {[llength $program] < 2} then {
      set errors [list [appendArgs \
          "command \[getCSharpTestProgram\] returned malformed \"" \
          $name "\" test program: " $program]]

      return false
    }

    unset -nocomplain results local_errors

    if {[catch {
      compileCSharp [lindex $program 1] true true true results local_errors
    } code]} then {
      set errors [list [appendArgs \
          "caught error while compiling \"" $name "\" test program: " \
          $code]]

      return false
    }

    if {$code ne "Ok"} then {
      set errors [list [appendArgs \
          "errors from compilation of \"" $name "\" test program: " \
          $local_errors]]

      return false
    }

    if {[catch {
      object invoke [lindex $program 0] Main null
    } exitCode]} then {
      set errors [list [appendArgs \
          "caught error while executing \"" $name "\" test program: " \
          $exitCode]]

      return false
    }

    if {$exitCode ne "0"} then {
      set errors [list [appendArgs \
          "bad exit code from \"" $name "\" test program: " \
          $exitCode]]

      return false
    }

    return true
  }

  #

    #
    if {$library} then {
      set libraryOptions [expr { \
          [info exists ::eagle_platform(compileOptions)] ? \
          $::eagle_platform(compileOptions) : [list] \
      }]
    } else {
      set libraryOptions [list]
    }

    #
    # NOTE: Permit extra C# compiler options to be passed via the global
    #       array element "csharpOptions", if it exists.  This caller may
    #       disable this handling.
    #
    if {$csharp} then {
      set csharpOptions [expr { \
          [info exists ::eagle_platform(csharpOptions)] ? \
          $::eagle_platform(csharpOptions) : [list] \
      }]
    } else {
      set csharpOptions [list]
    }

    #
    # NOTE: Start out with no compiler options.
    #
    set result ""

    # NOTE: Do we not want to persist the generated assembly to disk?
    #
    set outputFileName ""

    if {$memory} then {
      $parameters GenerateInMemory true
    } else {
      $parameters OutputAssembly [set outputFileName [appendArgs [set \
          tempName(1) [file tempname]] .dll]]
    }

    #
    # NOTE: Use a try/finally block to cleanup temporary files.
    #
    try {
      #
      # NOTE: Do we want symbols to be generated for the generated assembly?
      #
      if {$symbols} then {
        $parameters IncludeDebugInformation true
      }

      #
      # NOTE: Start out the compiler options with the pre-existing defaults
      #       for the compiler followed by those necessary for the platform.
      #
      $parameters CompilerOptions \
          [getCSharpCompilerOptions $parameters true true /]

      #
      # NOTE: Process extra compiler settings the caller may have provided.
      #
      foreach {name value} $args {
        $parameters -nocase $name $value
      }

      #
      # NOTE: Prepare to transfer the object reference to the caller.  We
      #       must use [upvar] here because otherwise the object is lost
      #       when the procedure call frame is cleaned up.
      #
      if {[string length $resultsVarName] > 0} then {
        upvar 1 $resultsVarName results
      }

      #
      # NOTE: Attempt to compile the specified string as C# and capture the
      #       results into the variable provided by the caller.
      #
      set results [$provider -alias CompileAssemblyFromSource $parameters \
          $string]

      #
      # NOTE: We no longer need the C# code provider object (i.e. the
      #       compiler); therefore, dispose it now.
      #
      unset provider; # dispose

      #
      # NOTE: Fetch the collection of compiler errors (which may be empty).
      #
      set errors [$results -alias Errors]

      #
      # NOTE: It is assumed that no assembly was generated if there were
      #       any compiler errors.  Ignore all compiler warnings unless
      #       we are in strict mode.
      #
      if {[$errors HasErrors] || \
          ($strict && [$errors HasWarnings])} then {
        #
        # NOTE: Compilation of the assembly failed.
        #
        set code Error

        #
        # NOTE: Prepare to transfer error messages to the caller.
        #
        if {[string length $errorsVarName] > 0} then {
          upvar 1 $errorsVarName local_errors
        }

        #
        # NOTE: Grab each error object and append the string itself to
        #       the overall list of errors.
        #
        for {set index 0} {$index < [$errors Count]} {incr index} {
          #
          # NOTE: Get the compiler error object at this index.
          #
          set error [$errors -alias Item $index]

          #
          # NOTE: Convert it to a string and append it to the list of
          #       errors.
          #
          lappend local_errors [$error ToString]

          #
          # NOTE: Since the error itself is actually an object, we must
          #       dispose it.
          #
          unset error; # dispose
        }
      } else {
        #
        # NOTE: Compilation of the assembly succeeded.
        #
        set code Ok
      }

      #
      # NOTE: We no longer need the compiler errors collection; therefore,
      #       dispose it now.
      #
      unset errors; # dispose

      #
      # HACK: *BREAKING CHANGE* If there is an output file name, return it
      #       as well; otherwise, just return success.
      #
      if {[string length $outputFileName] > 0} then {
        #
        # NOTE: Return a two element list: the first element is the overall
        #       result and the second element is the output file name.
        #
        return [list $code $outputFileName]
      } else {
        #
        # NOTE: Return the overall result to the caller.
        #
        return $code
      }
    } finally {
      #
      # NOTE: Make sure the dummy temporary files are cleaned up.
      #
      if {[array exists tempName]} then {
        foreach tempFileName [array values tempName] {
          if {[file exists $tempFileName]} then {
            catch {file delete $tempFileName}
          }
        }
      }
    }
  }

  #
  # NOTE: This procedure is used to dynamically compile arbitrary C# code
  #       from within a script using the command line C# compiler provided
  #       by the .NET Core SDK.  This procedure was originally designed to

    #
    append command " " [getCSharpCompilerOptions "" true true -]

    #
    # NOTE: Allocate a couple temporary file names, one to hold the source
    #       code to compile and one to hold the generated assembly.
    #
    set sourceFileName [appendArgs [set tempName(1) [file tempname]] .cs]
    set outputFileName [appendArgs [set tempName(2) [file tempname]] .dll]

    #
    # NOTE: Use a try/finally block to cleanup temporary files.
    #
    try {
      #
      # NOTE: Process extra compiler settings the caller may have provided.
      #
      foreach {name value} $args {
        set nameValueArguments \
            [compilerParameterToArguments $name $value outputFileName]

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


      #
      # NOTE: Make the compiler output a little quieter.  This is needed
      #       to maintain compatibility with the results generated by the
      #       [compileViaCSharpCodeProvider] procedure.
      #
      lappend command -nologo

      #
      # NOTE: Delete the temporary file name used to hold the source code.
      #
      if {[string length $sourceFileName] > 0 && \
          [file exists $sourceFileName]} then {
        catch {file delete $sourceFileName}
      }

      #
      # NOTE: Make sure the dummy temporary files are cleaned up.
      #
      if {[array exists tempName]} then {
        foreach tempFileName [array values tempName] {
          if {[file exists $tempFileName]} then {
            catch {file delete $tempFileName}
          }
        }
      }
    }

    #
    # HACK: *BREAKING CHANGE* If there is an output file name, return it
    #       as well; otherwise, just return success.
    #
    if {!$memory && [string length $outputFileName] > 0} then {

    #
    # NOTE: Finally, execute the resulting [exec] command in the context
    #       of the caller, returning its result.
    #
    return [uplevel 1 $command]
  }

  #
  # NOTE: This procedure is designed to extract the exit code for a child
  #       process run via [exec] using the value of $::errorCode.  It will
  #       always return either a valid integer -OR- the specified default
  #       value, which may be an empty string.
  #
  proc maybeGetExitCode { value {default ""} } {
    if {[lindex $value 0] eq "CHILDSTATUS"} then {
      set status [lindex $value 2]

      if {[string is integer -strict $status]} then {
        return $status
      }
    }

    return $default
  }

  #
  # NOTE: Provide the Eagle "execute" package to the interpreter.
  #
  package provide Eagle.Execute \
    [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
}

          }
        }
      }

      return $result
    }
  }

  #
  # NOTE: This procedure attempts to copy all files matching the specified
  #       source directory and patterns to the destination directory.  This
  #       procedure may raise script errors.
  #
  proc copyFilesRecursive {
          sourceDirectory targetDirectory {patterns ""} {options ""} } {
    #
    # NOTE: Block non-Windows platforms since this is Windows specific.
    #
    if {![isWindows]} then {
      error "not supported on this operating system"
    }

    #
    # NOTE: Start out with the [exec] command and the necessary options
    #       to the command.
    #
    if {[isEagle]} then {
      set command [list exec -exitcode exitCode -- robocopy]
    } else {
      set command [list exec -- robocopy]
    }

    #
    # NOTE: Add the source and target directory names.  These are always
    #       required.
    #
    if {[isEagle]} then {
      lappend command [appendArgs \" [file nativename $sourceDirectory] \"]
      lappend command [appendArgs \" [file nativename $targetDirectory] \"]
    } else {
      lappend command [file nativename $sourceDirectory]
      lappend command [file nativename $targetDirectory]
    }

    #
    # NOTE: If there are patterns specified, add them now.  By default,
    #       all files are copied (i.e. "*.*").
    #
    if {[llength $patterns] > 0} then {
      eval lappend command $patterns
    }

    #
    # NOTE: Should the default Robocopy options be excluded?  Generally,
    #       these options should not be excluded.  All matching files
    #       are copied, using restartable mode, and using extra options
    #       when running as administrator to enable copying more files
    #       and metadata, e.g. using backup mode and copying the extra
    #       file security information.
    #
    if {[lsearch -exact $options -nocopyopts] == -1} then {
      lappend command /E

      if {[isEagle] && [isAdministrator]} then {
        lappend command /ZB /COPYALL
      } else {
        lappend command /Z
      }

      lappend command /DCOPY:T
    }

    #
    # NOTE: Should we override the default number of retries per file?
    #       If no retry related option is found, the Robocopy default
    #       behavior will be used (i.e. 1 million retries per file).
    #
    if {[set index [lsearch -glob $options -retries:*]] != -1} then {
      #
      # NOTE: Grab the retry option name/value from the list of options
      #       and attempt to extract the integer number of retries from
      #       it.
      #
      set value [lindex $options $index]

      if {[regexp -- {^-retries:(\d+)$} $value dummy retries] && \
          [string is integer -strict $retries] && $retries >= 0} then {
        #
        # NOTE: Use the specified number of retries.  This value will
        #       be greater than or equal to zero and within the range
        #       of a 32-bit integer.
        #
        lappend command [appendArgs /R: $retries]
      } else {
        #
        # NOTE: The specified number of retries is somehow invalid.
        #
        error "number of retries must be a positive integer"
      }
    } elseif {[lsearch -exact $options -retry] == -1} then {
      #
      # NOTE: Fallback to setting retry count to zero, which is used
      #       to disable per-file retries.
      #
      lappend command /R:0
    }

    #
    # NOTE: By default, do not process file system junctions.  This
    #       is used to avoid the possibility of infinite loops when
    #       traversing the file system (i.e. because it is trivial
    #       to utilize file system junctions in order to construct
    #       directory trees that loop back upon themselves).
    #
    if {[lsearch -exact $options -junctions] == -1} then {
      lappend command /XJ
    }

    #
    # NOTE: By default, do not purge any files that happen to be in
    #       the target directory.
    #
    if {[lsearch -exact $options -purge] != -1} then {
      lappend command /PURGE
    }

    #
    # NOTE: By default, do not produce a verbose log files in the
    #       temporary directory.
    #
    if {[lsearch -exact $options -logging] != -1} then {
      lappend command /X /V /FP /NP

      package require Eagle.Test
      set logFileName [getTemporaryFileName]

      if {[isEagle]} then {
        lappend command [appendArgs \
            \"/LOG: [file nativename $logFileName] \"]
      } else {
        lappend command [appendArgs \
            /LOG: [file nativename $logFileName]]
      }
    }

    #
    # NOTE: Upon success, the exit code from Robocopy will be between
    #       zero and seven.  If the exit code is eight or greater, it
    #       has somehow failed and that error must be reported to the
    #       caller via raising a script error.
    #
    if {[isEagle]} then {
      #
      # NOTE: Execute the resulting [exec] command in our context and
      #       capture the results.
      #
      set result [eval $command]

      if {[info exists exitCode] && $exitCode in \
          [list Success Failure Exception 0 1 2 3 4 5 6 7]} then {
        #
        # NOTE: Return the captured output from the Robocopy command,
        #       whatever it was.  Generally, this will either be the
        #       summary and details of the files copied -OR- the log
        #       file name.
        #
        return $result
      } else {
        #
        # NOTE: Raise a script error, using the captured errors from
        #       the Robocopy command, whatever it was.
        #
        error [appendArgs \
            "command \"" $command "\" error: " $result]
      }
    } else {
      #
      # NOTE: Execute the resulting [exec] command in our context and
      #       capture the results.
      #
      if {[catch $command result] == 0 || ([info exists ::errorCode] && \
          [maybeGetExitCode $::errorCode 8] < 8)} then {
        #
        # NOTE: Return the captured output from the Robocopy command,
        #       whatever it was.  Generally, this will either be the
        #       summary and details of the files copied -OR- the log
        #       file name.
        #
        return $result
      } else {
        #
        # NOTE: Raise a script error, using the captured errors from
        #       the Robocopy command, whatever it was.
        #
        error [appendArgs \
            "command \"" $command "\" error: " $result]
      }
    }
  }

  #
  # NOTE: Provide the Eagle "file finder" package to the interpreter.
  #
  package provide Eagle.File.Finder \
    [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
}

          getPluginName getPluginPath getPackageInstallPath appendArgs \
          lappendArgs getDictionaryValue getColumnValue getRowColumnValue \
          tqputs tqlog makeBinaryChannel makeAsciiChannel makeUnicodeChannel \
          makeLogChannel readFile readSharedFile writeFile appendFile \
          appendLogFile appendSharedFile appendSharedLogFile \
          readAsciiFile writeAsciiFile readUnicodeFile \
          writeUnicodeFile getDirResultPath addToPath removeFromPath \
          execShell maybeGetExitCode lshuffle ldifference filter map reduce \
          getLengthModifier debug findDirectories \
          findDirectoriesRecursive findFiles findFilesRecursive \
          copyFilesRecursive exportAndImportPackageCommands setupUnzipVars \
          unzipMustBeInstalled extractZipArchive] false false
    }

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

    }

    #
    # TODO: Add more support for standard "tcltest" options here.
    #
    set options [list \
        -breakOnLeak -configuration -constraints -exitOnComplete \
        -file -logFile -machine -match -namePrefix -no -notFile \
        -platform -postTest -preTest -postWait -preWait -randomOrder \
        -skip -startFile -stopFile -stopOnFailure -stopOnLeak -suffix \
        -suite -tclsh -threshold -uncountedLeaks -verbose]

    set length [llength $args]

    for {set index 0} {$index < $length} {incr index} {
      #
      # NOTE: Grab the current list element, which should be the name of

      }

      #
      # NOTE: Check each candidate Tcl shell and query its fully
      #       qualified path from it.  If it cannot be executed,
      #       we know that candidate Tcl shell is not available.
      #
      if {![info exists ::no(getTclExecutableForTclShell)]} then {
        foreach shell $shells {
          if {[catch {
            getTclExecutableForTclShell $shell
          } executable] == 0 && $executable ne "error"} then {
            #
            # NOTE: It looks like this Tcl shell is available.
            #       Return the fully qualified path to it now.
            #
            return $executable
          }
        }
      }
    }

    #
    # NOTE: Return the fallback default.
    #


  proc getDefaultTestLog {} {
    set executable [info nameofexecutable]

    if {![info exists ::no(temporaryTestLog)]} then {
      set path [getTemporaryPath]
    } else {
      #
      # HACK: It seems that .NET Core considers itself to be the
      #       executable-of-record for the process; in that case,
      #       relocate the log file to be nearer the assemblies.
      #
      if {[isEagle] && [isDotNetCore]} then {
        set path [info binary]
      } else {
        set path [file dirname $executable]
      }
    }

    return [file normalize [file join $path [appendArgs \
        [file tail $executable] [getTestLogId] .test. [pid] .log]]]
  }

  proc getTestLog {} {
    return [expr {[info exists ::test_log] ? $::test_log : ""}]
  }

  proc getLastTestLog {} {

    } else {
      #
      # NOTE: We are missing the configuration, return nothing.
      #
      return ""
    }
  }

  proc getTestNamePrefix {} {
    #
    # NOTE: Determine the effective test name prefix and return it.  If
    #       the test name prefix cannot be determined, return an empty
    #       string.
    #
    if {[info exists ::test_flags(-namePrefix)] && \
        [string length $::test_flags(-namePrefix)] > 0} then {
      #
      # NOTE: The test name prefix has been manually overridden via the
      #       test flags; therefore, use it.
      #
      return $::test_flags(-namePrefix)
    } elseif {[info exists ::test_name_prefix] && \
        [string length $::test_name_prefix] > 0} then {
      #
      # NOTE: Use the default test name prefix.
      #
      return $::test_name_prefix
    } else {
      #
      # NOTE: We are missing the test name prefix, return nothing.
      #
      return ""
    }
  }

  proc getTestSuffix {} {
    #
    # NOTE: Determine the effective test suffix and return it.  If
    #       the test suffix cannot be determined, return an empty
    #       string.
    #

      # NOTE: Use the build suffix of Eagle itself.  This value
      #       will typically be "NetFx20", "NetFx40", etc.  The
      #       default value of this element is an empty string.
      #
      return $::eagle_platform(suffix)
    } else {
      #
      # NOTE: We are missing the test suffix, return nothing.
      #
      return ""
    }
  }

  proc getTestUncountedLeaks {} {
    if {[info exists ::test_uncounted_leaks] && \

        #
        # NOTE: Does the file name contain directory information?
        #
        if {[string length [file dirname $fileName]] <= 1} then {
          #
          # NOTE: If not, assume it is under the supplied test path.
          #
          set fileName [file normalize [file join $path $fileName]]
        }

        #
        # NOTE: The "magic" pattern we are looking for to determine if
        #       a given file is part of the formal test suite.
        #
        set pattern {^(\s)*runTest .*$}

        #
        set suffix [getTestSuffix]

        #
        # NOTE: If necessary, automatically detect the machine for the Tcl
        #       shell that we plan on using.
        #
        if {[string length $machine] == 0 && \
            ![info exists ::no(getMachineForTclShell)]} 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

        haveOrAddConstraint getConstraints getCachedConstraints \
        useCachedConstraints removeConstraint fixConstraints \
        fixTimingConstraints calculateBogoCops calculateRelativePerformance \
        formatTimeStamp formatElapsedTime sourceIfValid \
        processTestArguments getTclShellFileName getTemporaryPath \
        getFiles getTestFiles getTestRunId getNewTestRunId getTestLogId \
        getDefaultTestLog getTestLog getLastTestLog getTestSuite \
        getTestMachine getTestPlatform getTestConfiguration getTestNamePrefix \
        getTestSuffix getTestUncountedLeaks getRuntimeAssemblyName \
        getTestAssemblyName canTestExec testExec testClrExec execTestShell \
        isRandomOrder isBreakOnDemand isBreakOnLeak isStopOnFailure \
        isStopOnLeak isExitOnComplete returnInfoScript runTestPrologue \
        runTestEpilogue hookPuts unhookPuts runTest testDebugBreak \
        testArrayGet testShim tsource recordTestStatistics \
        reportTestStatistics formatList formatListAsDict pathToRegexp \
        assemblyNameToRegexp inverseLsearchGlob removePathFromFileNames \
        formatDecimal clearTestPercent reportTestPercent runAllTests \
        isTestSuiteRunning getTestChannelOrDefault tryVerifyTestPath \
        checkForAndSetTestPath configureTcltest machineToPlatform \
        getPassPercentage getSkipPercentage] false false

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

    #
    # NOTE: The command to use when attempting to unzip an archive.
    #
    variable unzipExtractCommand; # DEFAULT: unzip ...

    if {$force || ![info exists unzipExtractCommand]} then {
      set unzipExtractCommand {unzip -n {${fileName}} -d {${directory}}}
    }
  }

  #
  # NOTE: This procedure attempts to verify that an implementation of the
  #       unzip command line tool is installed locally.  There are no
  #       arguments.  Script errors are raised if any problems are found.

    #
    if {$force || ![info exists ::no(monoVersions)]} then {
      return [list \
          [list 2 0] [list 2 2] [list 2 4] [list 2 6] [list 2 8] [list 2 10] \
          [list 2 11] [list 3 0] [list 3 1] [list 3 2] [list 3 4] [list 3 6] \
          [list 3 8] [list 3 10] [list 3 12] [list 4 0] [list 4 2] [list 4 4] \
          [list 4 6] [list 4 8] [list 5 0] [list 5 2] [list 5 4] [list 5 8] \
          [list 5 10] [list 5 12] [list 5 14]]
    } else {
      return [list]
    }
  }

  proc addKnownMonoConstraints { generic } {
    #

          }
        }
      }
    }

    tputs $channel no\n
  }

  proc checkForEFormat { channel } {
    tputs $channel "---- checking for \"eformat\" support... "

    if {[catch {
      #
      # HACK: This test was stolen directly from the native Tcl source
      #       file "library/tcltest/tcltest.tcl", which is part of the
      #       "tcltest" package.
      #
      if {[isEagle]} then {
        expr {
          [string equal [format %.0e 5e-5] 5e-05] && \
              [string equal [format %#.5g 0] 0.0000]
        }
      } else {
        expr {
          [string equal [format %g 5e-5] 5e-05] && \
              [string equal [format %#.5g 0] 0.0000]
        }
      }
    } eformat] == 0 && [string is true -strict $eformat]} then {
      addConstraint eformat

      tputs $channel yes\n
    } else {
      tputs $channel no\n
    }
  }

  proc checkForNamespaces { channel quiet } {
    tputs $channel "---- checking for namespace support... "

    if {[isEagle]} then {
      #
      # NOTE: Check if namespace support was compiled into the core

      }

      #
      # 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 {[string is true -strict $enabled]} then {
        #
        # NOTE: Yes, it appears that it is available and enabled.
        #
        addConstraint namespaces

        tputs $channel enabled\n
      } else {

      addConstraint [appendArgs configuration. $::test_configuration]

      tputs $channel [appendArgs $::test_configuration \n]
    } else {
      tputs $channel unknown\n
    }
  }

  proc checkForTestNamePrefix { channel } {
    tputs $channel "---- checking for test name prefix... "

    if {[info exists ::test_name_prefix] && \
        [string length $::test_name_prefix] > 0} then {
      addConstraint [appendArgs namePrefix. $::test_name_prefix]

      tputs $channel [appendArgs $::test_name_prefix \n]
    } else {
      tputs $channel unknown\n
    }
  }

  proc checkForTestSuffix { channel } {
    tputs $channel "---- checking for test suffix... "

    if {[info exists ::test_suffix] && \
        [string length $::test_suffix] > 0} then {
      addConstraint [appendArgs suffix. $::test_suffix]

      if {[isEagle]} then {
        #
        # NOTE: Attempt to query for native stack checking in Eagle.
        #
        if {[catch {
          object invoke -flags +NonPublic \
              Eagle._Components.Private.NativeStack CanQueryThread
        } canQueryThread] == 0 && \
            [string is true -strict $canQueryThread]} then {
          #
          # NOTE: Yes, it appears that it is available.
          #
          addConstraint stackIntensive

          tputs $channel yes\n
        } else {

          object invoke -flags +NonPublic \
              Eagle._Components.Private.FileOps \
              GetPeFileStackReserveAndCommit \
              [info nameofexecutable] reserve commit

          set reserve; # primitive, already numeric.
        } stackSize] == 0 && \
            [string is integer -strict $stackSize] && $stackSize > 0} then {
          addConstraint [appendArgs stackSize.0x [format %x $stackSize]]

          tputs $channel [appendArgs "yes (" $stackSize ")\n"]
        } else {
          tputs $channel no\n
        }
      } else {

    proc checkForSecurity { channel } {
      tputs $channel "---- checking for security... "

      if {[catch {
        object invoke -flags +NonPublic Interpreter.GetActive HasSecurity
      } security] == 0} then {
        if {[string is true -strict $security]} then {
          addConstraint security.enabled

          tputs $channel yes\n
        } else {
          addConstraint security.disabled

          tputs $channel no\n

      }
    }

    proc checkForHost { channel } {
      tputs $channel "---- checking for host... "

      if {[catch {host isopen} open] == 0} then {
        if {[string is true -strict $open]} then {
          addConstraint hostIsOpen

          tputs $channel open\n
        } else {
          if {[catch {host redirected Input} redirected] == 0} then {
            if {[string is true -strict $redirected]} then {
              addConstraint hostInputRedirected

              tputs $channel redirected\n
            } else {
              addConstraint hostIsClosed

              tputs $channel closed\n

    proc checkForQuiet { channel quiet } {
      if {!$quiet} then {
        tputs $channel "---- checking for quiet... "
      }

      if {[catch {
        object invoke Interpreter.GetActive Quiet
      } isQuiet] == 0 && [string is true -strict $isQuiet]} then {
        #
        # NOTE: Yes, quiet mode is enabled.
        #
        addConstraint quiet

        if {!$quiet} then {
          tputs $channel yes\n

      } else {
        tputs $channel no\n
      }
    }

    proc testForDynamicLoading { {fileName ""} } {
      if {[catch {
        if {[string length $fileName] == 0} then {
          if {[isWindows]} then {
            set fileName kernel32; # HACK: Always pre-loaded?
          } elseif {[info exists ::tcl_platform(os)] && \
              $::tcl_platform(os) eq "Darwin"} then {
            set fileName libdl.dylib; # TODO: Good default?
          } else {
            set fileName libdl.so; # TODO: Good default?
          }
        }

        set error null

        object invoke -flags +NonPublic \
            Eagle._Components.Private.NativeOps TestLoadLibrary \
            $fileName error

          #       interpreter and AppDomain tidy.  It also requires access
          #       to native Windows support in order to use the [info hwnd]
          #       sub-command.
          #
          if {[haveConstraint compile.ISOLATED_INTERPRETERS] && \
              [haveConstraint compile.NATIVE] && \
              [haveConstraint compile.WINDOWS]} then {
            #
            # NOTE: Allocate a temporary file name that can be used to save
            #       the Excel spreadsheet.  This name will be provided to a
            #       child interpreter for its use -AND- cleaned up by this
            #       interpreter before exiting this procedure.
            #
            set tempName(1) [getTemporaryFileName]

            #
            # NOTE: Use a try/finally block to cleanup temporary files.
            #
            try {
              if {[catch {
                #
                # NOTE: In an attempt to limit the assemblies loaded into the
                #       primary AppDomain, create an isolated interpreter.
                #
                set interp [interp create -isolated]

                #
                # NOTE: Give the newly created (isolated) interpreter a means
                #       to set variables in the parent (this) interpreter.
                #
                interp alias $interp pset {} set; # parent set

                #
                # NOTE: Give the newly created (isolated) interpreter a base
                #       name for a temporary file.
                #
                interp set $interp tempName(1) $tempName(1)

                #
                # NOTE: Evaluate all the Excel interop assembly related code
                #       in the other AppDomain.
                #
                interp eval $interp {
                  #
                  # NOTE: First, attempt to load the Excel interop assembly.

                  #
                  # NOTE: Next, attempt to add a new workbook.  If this fails,
                  #       Excel is not considered usable.
                  #
                  set workbook [object invoke -alias \
                      $application.Workbooks Add $enumValue]







                  #
                  # NOTE: Setup a temporary file name that can be used to save
                  #       the Excel spreadsheet.
                  #
                  pset fileName [set fileName [file nativename [appendArgs \
                      $tempName(1) .xls]]]

                  #
                  # NOTE: Next, attempt to save a new workbook.  If this fails,
                  #       Excel is not considered usable.
                  #
                  $workbook SaveAs $fileName

              #
              # NOTE: Make sure the temporary spreadsheet file is deleted if
              #       it was actually created.
              #
              if {[info exists fileName] && [file exists $fileName]} then {
                catch {file delete $fileName}
              }

              #
              # NOTE: Make sure the dummy temporary files are cleaned up.
              #
              if {[array exists tempName]} then {
                foreach tempFileName [array values tempName] {
                  if {[file exists $tempFileName]} then {
                    catch {file delete $tempFileName}
                  }
                }
              }
            }
          } else {
            tputs $channel "unknown, missing optional feature\n"
          }
        } else {
          tputs $channel "unknown, no Excel interop assembly\n"
        }

      tputs $channel no\n
    }

    proc checkForTclReady { channel } {
      tputs $channel "---- checking for Tcl readiness... "

      if {[catch {tcl ready} ready] == 0 && \
          [string is true -strict $ready]} then {
        #
        # NOTE: Yes, native Tcl is loaded and ready.
        #
        addConstraint tclReady

        #
        # NOTE: Yes, native Tcl is ready -OR- available.

      # 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] && \
          ![info exists ::no(getTclVersionForTclShell)] && \
          [catch {getTclVersionForTclShell} version] == 0 && \
          $version ne "error"} then {
        #
        # NOTE: Yes, a native Tcl shell appears to be available.
        #
        addConstraint tclShell

      #       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] && \
          ![info exists ::no(getTkVersionForTclShell)] && \
          [catch {getTkVersionForTclShell} version] == 0 && \
          $version ne "error"} then {
        #
        # NOTE: Yes, a native Tk package appears to be available.
        #
        addConstraint tkPackage

            {Software\Microsoft\NET Framework Setup\NDP\v2.0.50727}]

        #
        # NOTE: Attempt to fetch the .NET Framework 2.0 "SP" value from the
        #       servicing registry hive.  If this value does not exist -OR-
        #       is less than 1, then no .NET Framework 2.0 service pack is
        #       installed.  If this raises a script error, that will almost
        #       certainly cause the result to be a non-integer, thus failing
        #       the check below.
        #
        catch {
          object invoke Microsoft.Win32.Registry GetValue $key SP null
        } servicePack

        if {[string is integer -strict $servicePack]} then {

            {Software\Microsoft\NET Framework Setup\NDP\v4\Full}]

        #
        # NOTE: Attempt to fetch the .NET Framework 4.0 "release" value from
        #       the servicing registry hive.  If this value does not exist
        #       -OR- is less than 378389, then the .NET Framework 4.5 is not
        #       installed.  If this raises a script error, that will almost
        #       certainly cause the result to be a non-integer, thus failing
        #       the check below.
        #
        catch {
          object invoke Microsoft.Win32.Registry GetValue $key Release null
        } release

        if {[string is integer -strict $release] && $release >= 378389} then {

      #
      # NOTE: Is the native debugger present?
      #
      if {[catch {
        object invoke -flags +NonPublic \
            Eagle._Components.Private.NativeOps+SafeNativeMethods \
            IsDebuggerPresent
      } present] == 0 && [string is true -strict $present]} then {
        #
        # NOTE: Yes, it appears that it is present.
        #
        addConstraint nativeDebugger

        tputs $channel yes\n
      } else {
        tputs $channel no\n
      }
    }

    proc checkForManagedDebugger { channel } {
      tputs $channel "---- checking for managed debugger... "

      #
      # NOTE: Is the managed debugger attached?
      #
      if {[catch {
        object invoke System.Diagnostics.Debugger IsAttached
      } attached] == 0 && [string is true -strict $attached]} then {
        #
        # NOTE: Yes, it appears that it is attached.
        #
        addConstraint managedDebugger

        tputs $channel yes\n
      } else {

        cleanPackageName haveTclPlatformOsExtraUpdateName \
        checkForTestSuiteFiles checkForPlatform checkForWindowsVersion \
        checkForOperatingSystemUpdate checkForScriptLibrary checkForVariable \
        checkForTclOptions checkForWindowsCommandProcessor checkForPackage \
        checkForFossil checkForVisualStudioViaVsWhere checkForEagle \
        checkForSymbols checkForLogFile checkForGaruda checkForShell \
        checkForOfficialStableReleaseInProgress checkForDebug checkForTk \
        checkForVersion checkForCommand checkForSubCommand checkForEFormat \
        checkForNamespaces checkForTestExec checkForTestMachine \
        checkForTestPlatform checkForTestConfiguration checkForTestNamePrefix \
        checkForTestSuffix checkForFile checkForPathFile checkForNativeCode \
        checkForTip127 checkForTip194 checkForTip207 checkForTip241 \
        checkForTip285 checkForTip405 checkForTip421 checkForTip426 \
        checkForTip429 checkForTip440 checkForTip461 checkForTip463 \
        checkForTip471 checkForTiming checkForPerformance checkForBigLists \
        checkForProcessorIntensive checkForTimeIntensive checkForFullTest \
        checkForMemoryIntensive checkForStackIntensive checkForStackSize \
        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: 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(-namePrefix) ""; # test name prefix, 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.

  #
  # 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: Set the name prefix used for some tests, if necessary.
  #
  if {![info exists test_name_prefix]} then {
    set test_name_prefix ""
  }

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

  tputs $test_channel [appendArgs "---- test platform: " \
      [expr {[info exists test_platform] ? \
          $test_platform : "<none>"}] \n]

  tputs $test_channel [appendArgs "---- test configuration: " \
      [expr {[info exists test_configuration] ? \
          $test_configuration : "<none>"}] \n]

  tputs $test_channel [appendArgs "---- test name prefix: " \
      [expr {[info exists test_name_prefix] ? \
          $test_name_prefix : "<none>"}] \n]

  tputs $test_channel [appendArgs "---- test suffix: " \
      [expr {[info exists test_suffix] ? \
          $test_suffix : "<none>"}] \n]

  if {[isEagle]} then {
    tputs $test_channel [appendArgs "---- original command line: " \

  #
  # NOTE: Has checking for the test configuration been disabled?
  #
  if {![info exists no(testConfiguration)]} then {
    checkForTestConfiguration $test_channel
  }

  #
  # NOTE: Has checking for the test name prefix been disabled?
  #
  if {![info exists no(testNamePrefix)]} then {
    checkForTestNamePrefix $test_channel
  }

  #
  # NOTE: Has checking for the test suffix been disabled?
  #
  if {![info exists no(testSuffix)]} then {
    checkForTestSuffix $test_channel
  }

    # 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 $core_bin_path sqlite3.dll]

      #
      # NOTE: Did we manage to find the native SQLite library yet?  If not,
      #       try to check using the machine type as a sub-directory.
      #
      if {![haveConstraint file_sqlite3.dll]} then {
        #
        # NOTE: Ok, now try to check for the machine specific native
        #       SQLite library.
        #
        checkForFile $test_channel [file join $core_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 $core_bin_path \
              [machineToPlatform $test_machine false] sqlite3.dll]
        }
      }

      if {[isEagle] && ![isWindows]} then {
        #
        # NOTE: Did we manage to find the native SQLite library yet?  If not,
        #       try to check using the machine type as a sub-directory -AND-
        #       using the Unix file name.
        #
        if {![haveConstraint file_sqlite3.dll]} then {
          #
          # NOTE: Ok, now try to check for the machine specific native
          #       SQLite library, near the binary, using the Unix name.
          #
          checkForFile $test_channel [file join $core_bin_path \
              [machineToPlatform $test_machine true] [appendArgs \
              libsqlite3 [info sharedlibextension]]] 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, near the binary, using the Unix name.
            #
            checkForFile $test_channel [file join $core_bin_path \
                [machineToPlatform $test_machine false] [appendArgs \
                libsqlite3 [info sharedlibextension]]] sqlite3.dll
          }
        }

        #
        # NOTE: Did we manage to find the native SQLite library yet?  If not,
        #       try to check using the Unix library directories -AND- using
        #       the Unix file name.
        #
        if {![haveConstraint file_sqlite3.dll]} then {
          #
          # NOTE: Attempt to obtain the path information for the Unix
          #       local library directory.  This will not work for
          #       native Tcl.
          #
          if {[catch {
            info path "=NativeLibrary +Local"
          } lib_dir] == 0} then {
            #
            # NOTE: Ok, now try to check for the machine specific native
            #       SQLite library, in the Unix local library directory,
            #       and the Unix file name.
            #
            checkForFile $test_channel [file join $lib_dir [appendArgs \
                libsqlite3 [info sharedlibextension]]] sqlite3.dll
          }

          #
          # NOTE: Did we manage to find the native SQLite library yet?
          #
          if {![haveConstraint file_sqlite3.dll]} then {
            #
            # NOTE: Attempt to obtain the path information for the Unix
            #       global library directory.  This will not work for
            #       native Tcl.
            #
            if {[catch {
              info path "=NativeLibrary -Local"
            } lib_dir] == 0} then {
              #
              # NOTE: Ok, now try to check for the machine specific native
              #       SQLite library, in the Unix global library directory,
              #       and the Unix file name.
              #
              checkForFile $test_channel [file join $lib_dir [appendArgs \
                  libsqlite3 [info sharedlibextension]]] sqlite3.dll
            }
          }

          unset lib_dir
        }

        #
        # NOTE: Did we manage to find the native SQLite library yet?  If not,
        #       try to check using the Unix library directories -AND- using
        #       the Unix file name, without using the processor name.
        #
        if {![haveConstraint file_sqlite3.dll]} then {
          #
          # NOTE: Attempt to obtain the path information for the Unix
          #       local library directory without the processor name.
          #       This will not work for native Tcl.
          #
          if {[catch {
            info path "=NativeLibrary +Local +NoProcessor"
          } lib_dir] == 0} then {
            #
            # NOTE: Ok, now try to check for the machine specific native
            #       SQLite library, in the Unix local library directory,
            #       and the Unix file name.
            #
            checkForFile $test_channel [file join $lib_dir [appendArgs \
                libsqlite3 [info sharedlibextension]]] sqlite3.dll
          }

          #
          # NOTE: Did we manage to find the native SQLite library yet?
          #
          if {![haveConstraint file_sqlite3.dll]} then {
            #
            # NOTE: Attempt to obtain the path information for the Unix
            #       global library directory without the processor name.
            #       This will not work for native Tcl.
            #
            if {[catch {
              info path "=NativeLibrary -Local +NoProcessor"
            } lib_dir] == 0} then {
              #
              # NOTE: Ok, now try to check for the machine specific native
              #       SQLite library, in the Unix global library directory,
              #       and the Unix file name.
              #
              checkForFile $test_channel [file join $lib_dir [appendArgs \
                  libsqlite3 [info sharedlibextension]]] sqlite3.dll
            }
          }

          unset lib_dir
        }
      }
    }

    if {![info exists no(System.Data.SQLite.dll)]} then {
      checkForFile $test_channel [file join $core_bin_path \
          System.Data.SQLite.dll]
    }

  if {![info exists no(versionCommand)]} then {
    checkForCommand $test_channel version
  }

  if {![info exists no(xmlCommand)]} then {
    checkForCommand $test_channel xml
  }

  #
  # NOTE: Has "eformat" detection support been disabled?
  #
  if {![info exists no(eformat)]} then {
    checkForEFormat $test_channel
  }

  #
  # NOTE: Has namespace detection support been disabled?
  #
  if {![info exists no(namespaces)]} then {
    checkForNamespaces $test_channel [haveConstraint quiet]
  }