System.Data.SQLite

      # NOTE: Returns non-zero if the logged on user has full administrator
      #       rights on this machine.
      #
      return [expr {[info exists ::eagle_platform(administrator)] && \
          $::eagle_platform(administrator)}]
    }

    proc hasRuntimeOption { name {default false} } {
      #
      # NOTE: Returns non-zero if the specified runtime option is set.
      #
      if {[llength [info commands debug]] > 0} then {
        if {[llength [info subcommands debug runtimeoption]] > 0} then {
          if {[catch {debug runtimeoption has $name} result] == 0} then {
            return $result
          }
        }
      }

      if {[llength [info commands object]] > 0} then {
        if {[catch {
          object invoke Interpreter.GetActive HasRuntimeOption $name
        } result] == 0} then {
          return $result
        }
      }

      return $default

    }

    proc getPluginFlags { pattern } {
      foreach loaded [info loaded] {
        set plugin [lindex $loaded end]

        if {[regexp -- $pattern $plugin]} then {

        uplevel 1 [list set test_overrides $varNames]
      }

      return $result
    }

    proc refreshAutoPath {} {
      if {[llength [info commands debug]] > 0 && \
          [llength [info subcommands debug refreshautopath]] > 0 && \
          [catch {debug refreshautopath true}] == 0} then {
        return debug
      }

      if {[llength [info commands object]] > 0 && \
          [catch {object invoke Utility RefreshAutoPathList true}] == 0} then {
        return object

      #
      # NOTE: Directory not found, return failure.
      #
      return false
    }

    proc setupInterpreterTestPath { channel dir quiet } {
      if {[llength [info commands debug]] > 0 && \
          [llength [info subcommands debug testpath]] > 0 && \
          [catch {debug testpath} testPath] == 0} then {
        if {$dir ne $testPath} then {
          debug testpath $dir

          if {!$quiet} then {
            catch {
              tqputs $channel [appendArgs \

      #       infrastructure directory and add it to the auto-path for the
      #       current interpreter.  Normally, this will also set the variable
      #       created above to point to the directory added to the auto-path;
      #       however, this will not be done if the variable was not created
      #       by us.
      #
      addTestSuiteToAutoPath stdout [expr {$have_vendor_directory ? "" : \
          "vendor_directory"}] [info exists ::env(quietAddTestSuiteToAutoPath)]

      unset have_vendor_directory

      #
      # NOTE: If we actually found a vendor-specific testing infrastructure
      #       directory then modify the TestPath property of the current
      #       interpreter to point directly to it.
      #
      if {[string length $vendor_directory] > 0} then {
        setupInterpreterTestPath stdout $vendor_directory [info exists \
            ::env(quietSetupInterpreterTestPath)]
      }
    }

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

    # NOTE: Are we allowed to do stack intensive testing?
    #
    if {![info exists ::no(stackIntensive)]} then {
      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 && $canQueryThread} then {

          #
          # NOTE: Yes, it appears that it is available.
          #
          addConstraint stackIntensive

          tputs $channel yes\n
        } else {

    #
    # NOTE: Currently, only Eagle has "interactive commands".
    #
    if {[isEagle]} then {
      #
      # NOTE: Attempt to query the interactive command names from Eagle.
      #
      if {[catch {
        object invoke Utility GetInteractiveCommandNames $name false

      } names] == 0 && [llength $names] > 0} then {
        #
        # NOTE: Yes, it appears that it is available.
        #
        addConstraint [appendArgs interactiveCommand. $name]

        tputs $channel yes\n

      tputs $channel no\n
    }

    proc checkForStrongName { channel } {
      tputs $channel "---- checking for strong name... "

      if {[catch {
        object invoke Interpreter.GetActive GetStrongName

      } strongName] == 0 && [string length $strongName] > 0} then {
        #
        # NOTE: Yes, it appears that the core library was signed with a
        #       strong name key.
        #
        addConstraint strongName

        tputs $channel yes\n

        tlog $open; tputs $channel error\n
      }
    }

    proc checkForHostType { channel } {
      tputs $channel "---- checking for host type... "

      if {[set code [catch {
        object invoke Interpreter.GetActive.Host.GetType ToString
      } hostType]] == 0 && [string length $hostType] > 0} then {
        addConstraint [appendArgs hostType. [string map \
            [list , _ + _ & _ * _ \[ _ \] _ . _ \\ _] $hostType]]

        tputs $channel [appendArgs $hostType \n]
      } elseif {$code == 0} then {
        tputs $channel unknown\n
      } else {

      } appDomain] == 0 && [string length $appDomain] > 0} then {
        if {[catch {
          object invoke $appDomain IsDefaultAppDomain
        } default] != 0 || [string length $default] == 0} then {
          set default false
        }


        if {[catch {object invoke $appDomain Id} id] != 0 || \
            [string length $id] == 0} then {
          set id unknown
        }

        if {$default} then {
          addConstraint defaultAppDomain

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


    proc checkForThreadCulture { channel } {
      tputs $channel "---- checking for thread culture... "

      #
      # NOTE: Grab the current thread culture.
      #
      if {[catch {
        object invoke System.Threading.Thread.CurrentThread CurrentCulture
      } culture] == 0 && [catch {
        object invoke Eagle._Components.Private.FormatOps CultureName \
            $culture false
      } culture] == 0 && [string length $culture] > 0} then {
        #
        # NOTE: The culture information is present, use it and show it.
        #
        addConstraint [appendArgs threadCulture. [string map [list - _] \
            $culture]]

        tputs $channel [appendArgs $culture \n]

      #       Windows Form when the X server is unavailable (e.g. on
      #       OpenBSD).
      #
      if {[isWindows] || [info exists ::env(DISPLAY)]} then {
        #
        # NOTE: Is the Windows Forms assembly available?
        #
        if {[catch {
          object resolve System.Windows.Forms
        } assembly] == 0} then {
          #
          # NOTE: Yes, it appears that it is available.
          #
          addConstraint winForms

          tputs $channel yes\n

        tputs $channel no\n
      }
    }

    proc checkForStaThread { channel } {
      tputs $channel "---- checking for STA thread... "

      if {[catch {
        object invoke System.Threading.Thread.CurrentThread GetApartmentState

      } apartmentState] == 0 && $apartmentState eq "STA"} then {
        #
        # NOTE: Yes, we are running in an STA thread.
        #
        addConstraint staThread

        tputs $channel yes\n
      } else {
        tputs $channel no\n
      }
    }

    proc checkForWindowsPresentationFoundation { channel } {
      tputs $channel "---- checking for Windows Presentation Foundation... "

      #
      # NOTE: Is the Windows Presentation Foundation available?
      #
      if {[catch {
        object resolve PresentationFramework
      } assembly] == 0} then {
        #
        # NOTE: Yes, it appears that it is available.
        #
        addConstraint wpf

        tputs $channel yes\n
      } else {


    proc checkForPowerShell { channel } {
      tputs $channel "---- checking for PowerShell... "

      #
      # NOTE: Can the PowerShell assembly be loaded?
      #
      if {[catch {
        object resolve System.Management.Automation
      } assembly] == 0} then {
        #
        # NOTE: Yes, it appears that it is available.
        #
        addConstraint powerShell

        tputs $channel yes\n
      } else {


    proc checkForNativeDebugger { channel } {
      tputs $channel "---- checking for native debugger... "

      #
      # NOTE: Is the native debugger present?
      #
      if {[catch {
        object invoke -flags +NonPublic \
            Eagle._Components.Private.NativeOps+SafeNativeMethods \
            IsDebuggerPresent
      } present] == 0 && $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 && $attached} then {
        #
        # NOTE: Yes, it appears that it is attached.
        #
        addConstraint managedDebugger

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

      #
      # NOTE: Is the script debugger available?
      #
      if {[catch {
        object invoke -flags +NonPublic Interpreter.GetActive Debugger
      } debugger] == 0} then {
        #
        # NOTE: We do not own this, do not dispose it.
        #
        if {[string length $debugger] > 0} then {
          catch {object flags $debugger +NoDispose}
        }


    proc checkForScriptDebuggerInterpreter { channel } {
      tputs $channel "---- checking for script debugger interpreter... "

      #
      # NOTE: Is the script debugger interpreter available?
      #
      if {[catch {
        object invoke -flags +NonPublic Interpreter.GetActive Debugger
      } debugger] == 0} then {
        #
        # NOTE: We do not own this, do not dispose it.
        #
        if {[string length $debugger] > 0} then {
          catch {object flags $debugger +NoDispose}
        }

        checkForTestMachine checkForTestPlatform checkForTestConfiguration \
        checkForTestSuffix checkForFile checkForPathFile checkForNativeCode \
        checkForTip127 checkForTip194 checkForTip207 checkForTip241 \
        checkForTip285 checkForTip405 checkForTip426 checkForTip429 \
        checkForTiming checkForPerformance checkForBigLists \
        checkForTimeIntensive 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: 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.
  #
  if {[isEagle] && [llength [info commands object]] > 0} then {
    catch {
      #
      # 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 \

            " microseconds\n"]
      }
    }

    #
    # NOTE: Show the ending operation count (for Eagle only).
    #
    if {[llength [info commands object]] > 0} then {
      catch {
        object invoke -flags +NonPublic Interpreter.GetActive OperationCount
      } operationCount
    } else {
      set operationCount unavailable
    }

    tputs $test_channel [appendArgs "---- ending operation count: " \
        $operationCount \n]

    unset operationCount

    #

  #
  # 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] && [llength [info commands object]] > 0} then {
    catch {
      #
      # 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 \

    tputs $test_channel [appendArgs "---- threadId: " \
        [info tid] \n]

    tputs $test_channel [appendArgs "---- processors: " \
        [info processors] \n]

    if {[llength [info commands object]] > 0} then {
      catch {object invoke Console.InputEncoding WebName} encoding
    } else {
      set encoding unavailable
    }

    tputs $test_channel [appendArgs "---- input encoding: " \
        $encoding \n]

    if {[llength [info commands object]] > 0} then {
      catch {object invoke Console.OutputEncoding WebName} encoding
    } else {
      set encoding unavailable
    }

    tputs $test_channel [appendArgs "---- output encoding: " \
        $encoding \n]

    unset encoding
    catch {host query} host

  tputs $test_channel [appendArgs "---- starting command count: " \
      [info cmdcount] \n]

  if {[isEagle]} then {
    #
    # NOTE: Show the starting operation count (for Eagle only).
    #
    if {[llength [info commands object]] > 0} then {
      catch {
        object invoke -flags +NonPublic Interpreter.GetActive OperationCount
      } operationCount
    } else {
      set operationCount unavailable
    }

    tputs $test_channel [appendArgs "---- starting operation count: " \
        $operationCount \n]

    unset operationCount

    #

        if {![info exists ::no(shimSQLiteVisualStudioConstraints)]} then {
          addConstraint [appendArgs visualStudio [getBuildYear]]
        }

        tputs $channel no\n
      }
    }

    proc changeNativeRuntimeOption { native } {
      if {[llength [info commands debug]] > 0 && \
          [llength [info subcommands debug runtimeoption]] > 0 && [catch {
        debug runtimeoption [expr {$native ? "add" : "remove"}] native
      }] == 0} then {
        return true
      }

      if {[haveSQLiteObjectCommand] && [catch {
        object invoke Interpreter.GetActive [expr {$native ? \
            "AddRuntimeOption" : "RemoveRuntimeOption"}] native
      }] == 0} then {
        return true
      }

      return false
    }

    proc checkForSQLiteBuilds { channel {select false} } {
      #
      # NOTE: Check for every possible valid combination of values used when
      #       locating out the build output directory, showing each available
      #       build variation along the way.
      #

              #
              if {$select && [matchMachine $platform]} then {
                #
                # NOTE: Manually override all the build directory selection
                #       related test settings in order to force this build
                #       of System.Data.SQLite to be used.
                #


                if {![changeNativeRuntimeOption $native]} then {

                  tputs $channel [appendArgs \
                      "no, failed to " [expr {$native ? "add" : "remove"}] \
                      " the \"native\" runtime option\n"]

                  return false
                }

                set ::test_year $year
                set ::test_platform $platform
                set ::test_configuration $configuration

      return $code
    }

    proc setupDbInterruptCallback { channel log } {
      tputs $channel "---- setting up debugger interrupt callback... "

      if {[catch {
        set ::env(quietSetupInterpreterTestPath) 1

        try {
          #
          # NOTE: Make sure the script debugger and the isolated interpreter
          #       are setup and ready for use.
          #
          debug setup true true

          #
          # NOTE: Load the necessary packages into the isolated interpreter.
          #
          debug eval {
            package require Eagle
            package require Eagle.Library
            package require Eagle.Test
          }

          #
          # NOTE: Copy the necessary variables into the isolated interpreter.
          #
          debug invoke 0 set ::test_channel $channel; # NOTE: For [tputs].
          debug invoke 0 set ::test_log $log; # NOTE: For [tlog].

          #
          # NOTE: Install the callback script to be evaluated in the isolated
          #       interpreter when this interpreter is interrupted by script
          #       cancellation, etc.
          #
          debug callback apply {{sender e} {
            #
            # NOTE: Check if this callback is one that we care about.
            #
            if {"Canceled" in [split [$e InterruptType] ", "]} then {
              #
              # NOTE: Make sure the [object] command is available.  Since
              #       this is an isolated interpreter, check for it the hard
              #       way.
              #
              if {[llength [info commands object]] > 0} then {
                #
                # NOTE: Iterate through all database connections known to the
                #       parent interpreter.
                #
                object foreach -alias pair [object invoke -flags +NonPublic \
                    $e Interpreter.connections] {
                  #
                  # NOTE: Attempt to cancel any SQL queries in progress on
                  #       this database connection.
                  #
                  if {[catch {$pair Value.Cancel} error]} then {
                    tputs $::test_channel [appendArgs \n \
                        "==== WARNING: failed to cancel query for " \
                        "connection \"" [$pair Key] "\", error: " \n\t \
                        $error \n]
                  }
                }
              } else {
                tputs $::test_channel [appendArgs \n \
                    "==== WARNING: cannot cancel any queries: " \
                    "the \"object\" command is not available\n"]
              }
            }
          }}
        } finally {
          catch {unset ::env(quietSetupInterpreterTestPath)}
        }
      } error] == 0} then {
        addConstraint interruptCallback.sqlite3

        tputs $channel yes\n
      } else {
        tputs $channel [appendArgs "no, error: " \n\t $error \n]
      }

###############################################################################
#
# settings.before.mistachkin.eagle --
#
# Written by Joe Mistachkin.
# Released to the public domain, use at your own risk!
#
###############################################################################

if {[info exists ::env(TEST_ALL)]} then {
  if {[haveSQLiteObjectCommand]} then {
    catch {
      object invoke Interpreter.GetActive AddRuntimeOption noPoolCounts
    }
  }
}