System.Data.SQLite

    checkForTestOverrides stdout [expr {[info exists test_overrides] ? \
        $test_overrides : [list binary_directory build_base_directory \
        build_directory common_directory compile_option_prefix \
        connection_flags core_library_version database_directory \
        datetime_format define_constant_prefix execute_on_setup \
        interop_assembly_file_names native_library_file_names \
        release_version scratch_directory temporary_directory test_clr \
        test_clr_v2 test_clr_v4 test_configuration _configurations \
        test_constraints test_extra test_extras test_machine \
        test_native_year test_net_fx test_net_fx_2005 test_net_fx_2008 \
        test_net_fx_2010 test_net_fx_2012 test_net_fx_2013 \
        test_net_fx_2015 test_overrides test_platform test_suite \
        test_year test_years test_year_clr_v2 test_year_clr_v4 \
        vendor_directory vendor_test_directory]}] \
        [checkForVendorQuiet checkForTestOverrides]

    #
    # NOTE: Set the name of the running test suite, if necessary.
    #
    if {![info exists test_suite]} then {
      set test_suite "System.Data.SQLite Test Suite for Eagle"
    }

            #
            return 2008; # TODO: Good "fallback" default?
          }
        }
      }
    }

    proc getBuildNativeYear {} {
      if {[info exists ::test_native_year] && \
          [string length $::test_native_year] > 0} then {
        #
        # NOTE: Use the specified test year for native binaries.  If this
        #       variable is not set, the value returned by [getBuildYear]
        #       will be used.
        #
        return $::test_native_year
      } else {
        #
        # NOTE: Fallback on the (normal) build year for managed binaries.
        #
        return [getBuildYear]
      }
    }

    #
    # NOTE: This procedure is only used when adding shimmed test constraints.
    #
    proc getBuildClrVersion {} {
      if {[info exists ::test_clr] && [string length $::test_clr] > 0} then {
        #
        # NOTE: Use the specified test version for the CLR.  If this variable

      } else {
        #
        # NOTE: Use the default list of test configurations.
        #
        return [list Debug Release]
      }
    }

    proc getBuildExtra {} {
      if {[info exists ::test_extra] && \
          [string length $::test_extra] > 0} then {
        #
        # NOTE: Use the specified extra output directory.
        #
        return $::test_extra
      } elseif {[isDotNetCore]} then {
        #
        # NOTE: Running on .NET Core, use the extra output directory for
        #       library files.
        #
        return netstandard2.0
      } else {
        #
        # NOTE: No extra output directory is required.
        #
        return ""
      }
    }

    proc getBuildExtras {} {
      #
      # NOTE: See if the list of extra output directories has been overridden
      #       by the user (e.g. on the command line).
      #
      if {[info exists ::test_extras] && \
          [llength $::test_extras] > 0} then {
        #
        # NOTE: Use the specified list of extra output directories.
        #
        return $::test_extras
      } elseif {[isDotNetCore]} then {
        #
        # NOTE: Running on .NET Core, prioritize its extra output directory
        #       for library files.
        #
        return [list netstandard2.0 ""]
      } else {
        #
        # NOTE: Use default list of extra output directories, which is one
        #       empty string (no-op).
        #
        return [list ""]
      }
    }

    proc getBuildBaseDirectory {} {
      #
      # NOTE: Figure out the base directory where all the builds should be
      #       located.  This will be the directory that contains the actual
      #       build output directory (e.g. parent of "bin").
      #

      #       we have everything we need.
      #
      if {$native} then {
        return true
      }

      #
      # NOTE: If the machine name is unavailable, there is nothing else we
      #       can do.
      #
      if {![info exists ::tcl_platform(machine)]} then {
        return false
      }

      #

      if {[string length $varName] > 0} then {
        upvar 1 $varName $varName
      }

      return [isBuildAvailable "" $directory $varName]
    }

    proc joinBuildDirectory { native path year platform configuration extra } {
      #
      # NOTE: Figure out and then return the fully qualified path to the build
      #       directory based on all the arguments provided by our caller.
      #






      if {$native} then {
        return [file join $path bin $year $platform $configuration $extra]
      } else {
        return [file join $path bin $year $configuration bin $extra]
      }
    }


        #       need to be adjusted accordingly to actually run the test suite.
        #       Refer to the comments in [getBuildYear] for more information on
        #       how to set this variable.
        #
        set native [expr {!$managedOnly && [hasRuntimeOption native]}]

        return [joinBuildDirectory $native [getBuildBaseDirectory] \
            [expr {$managedOnly ? [getBuildYear] : [getBuildNativeYear]}] \
            [getBuildPlatform $native] [getBuildConfiguration] \
            [expr {$managedOnly ? [getBuildExtra] : ""}]]
      }
    }

    proc getReleaseVersion {} {
      #
      # NOTE: Figure out the release version for use with the build directory
      #       when checking for available releases.

      #       [primarily] a native build; therefore, it always matches.
      #
      if {[string length $platform] == 0} then {
        return true
      }

      #
      # NOTE: If the machine name is unavailable, there is nothing else we
      #       can do.
      #
      if {![info exists ::tcl_platform(machine)]} then {
        return 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.
      #
      foreach native [list false true] {
        foreach year [getBuildYears] {
          foreach configuration [getBuildConfigurations] {
            foreach extra [getBuildExtras] {
              #
              # NOTE: Figure out the effective build platform.  This is
              #       based on whether or not a [primarily] native build
              #       is being used.  For [primarily] non-native builds,
              #       this will be an empty string.
              #
              set platform [getBuildPlatform $native]

              tputs $channel [appendArgs \
                  "---- checking for System.Data.SQLite build \"" [expr \
                  {$native ? "native/" : ""}] [expr {[string length \
                  $platform] > 0 ? [appendArgs $platform /] : ""}] $year \
                  / $configuration "\"... "]

              #
              # NOTE: Build the fully qualified directory where the necessary
              #       components for System.Data.SQLite should be found.
              #
              set directory [joinBuildDirectory $native \
                  [getBuildBaseDirectory] $year $platform $configuration \
                  $extra]

              #
              # NOTE: Do the necessary files exist?  Currently, no other steps
              #       are taken to verify this build is actually viable.
              #
              if {[isBuildAvailable $native $directory]} then {
                #
                # NOTE: When in "select" mode, automatically select the first
                #       available build of System.Data.SQLite and then return
                #       immediately.
                #
                if {$select && [matchPlatform $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

                  tputs $channel [appendArgs \
                      "yes, selected (" [expr {$native ? "native/" : ""}] \
                      [expr {[string length $platform] > 0 ? [appendArgs \
                      $platform /] : ""}] $year / $configuration \
                      [expr {[string length $extra] > 0 ? [appendArgs / \
                      $extra] : ""}] ")\n"]

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

      return false
    }

        tputs $::test_channel \
            "---- checking for System.Data.SQLite build year... "

        set year [getBuildYear]
        addConstraint [appendArgs buildYear. $year]
        tputs $::test_channel [appendArgs \" $year \"\n]

        tputs $::test_channel \
            "---- checking for System.Data.SQLite build native year... "

        set year [getBuildNativeYear]
        addConstraint [appendArgs buildNativeYear. $year]
        tputs $::test_channel [appendArgs \" $year \"\n]

        #
        # NOTE: Check the current build .NET Framework.  Basically, this
        #       indicates which version of the .NET Framework is being
        #       used by the assembly binaries under test.
        #
        tputs $::test_channel \
            "---- checking for System.Data.SQLite build .NET Framework... "

        #
        tputs $::test_channel \
            "---- checking for System.Data.SQLite build configuration... "

        set configuration [getBuildConfiguration]
        addConstraint [appendArgs buildConfiguration. $configuration]
        tputs $::test_channel [appendArgs \" $configuration \"\n]

        tputs $::test_channel \
            "---- checking for System.Data.SQLite build extra... "

        #
        # NOTE: Check the current build extra directory.  This will normally
        #       be either "netstandard2.0" or an empty string.
        #
        set extra [getBuildExtra]

        if {[string length $extra] > 0} then {
          addConstraint [appendArgs buildExtra. $extra]
          tputs $::test_channel [appendArgs \" $extra \"\n]
        } else {
          addConstraint buildExtra.none
          tputs $::test_channel <none>\n
        }

        #
        # NOTE: Try to setup an interrupt callback using the script debugger
        #       that will cancel all SQL queries in progress for all database
        #       connections known to this interpreter.
        #
        if {![info exists ::no(sqliteInterruptCallback)]} then {