System.Data.SQLite

        $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 test_configurations \
        test_configuration_suffix test_configuration_suffixes \
        test_constraints test_extra test_extras test_machine test_native \
        test_native_configuration_suffix 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_net_fx_2017 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"
    }

          [appendArgs [getSQLiteDefineConstantPrefix] $name]]
    }

    proc haveSQLiteCompileOption { name } {
      return [haveConstraint \
          [appendArgs [getSQLiteCompileOptionPrefix] $name]]
    }

    proc getBuildNative {} {
      #
      # NOTE: Check if we are being forced to treat this as a native build.
      #       This is normally done (automatically) only when the mixed-mode
      #       assembly is in use; however, in some circumstances it is useful
      #       to force this behavior.
      #
      if {[info exists ::test_native] && \
          [string is boolean -strict $::test_native]} then {
        return $::test_native
      } else {
        return false
      }
    }

    proc getBuildYear {} {
      #
      # NOTE: See if the "year" setting has been overridden by the user (e.g.
      #       on the command line).  This helps control exactly which set of
      #       binaries we are testing, those produced using the Visual Studio
      #       2005, 2008, 2010, 2012, 2013, 2015, or 2017 build systems.  To

        #
        # NOTE: Fallback on the (normal) build year for managed binaries.
        #
        return [getBuildYear]
      }
    }

    proc getBuildNativeYearForDotNetCore { year } {
      if {[isDotNetCore] && [isWindows]} then {
        return 2015; # HACK: Special case, use 2015 native binaries.
      } elseif {[string length $year] > 0} then {
        return $year
      } else {
        return [getBuildNativeYear]
      }
    }

    proc getBuildYears {} {
      #
      # NOTE: See if the list of test years has been overridden by the user
      #       (e.g. on the command line).
      #
      if {[info exists ::test_years] && [llength $::test_years] > 0} then {
        #
        # NOTE: Use the specified list of test years.
        #
        return $::test_years
      } elseif {[isDotNetCore]} then {
        #
        # NOTE: Running on .NET Core, prioritize its list of test years.
        #
        return [list NetStandard20]
      } else {
        #
        # NOTE: Use the default list of test years (i.e. all).
        #
        return [list 2005 2008 2010 2012 2013 2015 2017 NetStandard20]
      }
    }

    #
    # 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

            #
            return 2.0.50727; # TODO: Good "fallback" default?
          }
        }
      }
    }



















    proc getBuildNetFx {} {
      #
      # NOTE: See if the test .NET Framework setting has been overridden by
      #       the user (e.g. on the command line).
      #
      if {[info exists ::test_net_fx] && \
          [string length $::test_net_fx] > 0} then {

      return true
    }

    proc getBuildPlatform { native } {
      if {[info exists ::test_platform] && \
          [string length $::test_platform] > 0} then {
        #
        # NOTE: Possibly use the specified test platform.  If this variable
        #       is not set, the default value will be based on the machine
        #       architecture.  Normally, this is done for builds that involve
        #       the mixed-mode assembly.
        #
        return [expr {$native ? $::test_platform : ""}]
      } elseif {[info exists ::test_machine] && \
          [string length $::test_machine] > 0} then {
        #
        # NOTE: For native builds, return the platform name corresponding to
        #       the test machine architecture; otherwise, return an empty
        #       string.  Normally, this is done for builds that involve the
        #       mixed-mode assembly.
        #
        return [expr {
          $native ? [machineToPlatform $::test_machine] : ""
        }]
      } elseif {[info exists ::tcl_platform(machine)]} then {
        #
        # NOTE: For native builds, return the platform name corresponding to
        #       the machine architecture; otherwise, return an empty string.
        #       Normally, this is done for builds that involve the mixed-mode
        #       assembly.
        #
        return [expr {
          $native ? [machineToPlatform $::tcl_platform(machine)] : ""
        }]
      } else {
        #
        # NOTE: No machine architecture is available, return an empty string.

        #       test configuration variable is always set by the test suite
        #       itself; however, it can be overridden using the unset command
        #       from the -preTest option to the test suite.
        #
        return $::eagle_platform(configuration)
      }
    }

    proc getBuildConfigurations {} {
      #
      # NOTE: See if the list of test configurations has been overridden by
      #       the user (e.g. on the command line).
      #
      if {[info exists ::test_configurations] && \
          [llength $::test_configurations] > 0} then {
        #
        # NOTE: Use the specified list of test configurations.
        #
        return $::test_configurations
      } else {
        #
        # NOTE: Use the default list of test configurations.
        #
        return [list Debug Release]
      }
    }

    proc getBuildConfigurationSuffix {} {
      #
      # NOTE: See if the test configuration suffix has been overridden by
      #       the user (e.g. on the command line).
      #
      if {[info exists ::test_configuration_suffix] && \

        # NOTE: Use the default test configuration suffix, which should be
        #       an empty string.
        #
        return ""
      }
    }




















    proc getBuildNativeConfigurationSuffix {} {
      #
      # NOTE: See if the test native configuration suffix has been
      #       overridden by the user (e.g. on the command line).
      #
      if {[info exists ::test_native_configuration_suffix] && \
          [string length $::test_native_configuration_suffix] > 0} then {
        #
        # NOTE: Use the specified test native configuration suffix.
        #
        return $::test_native_configuration_suffix
      } else {
        #
        # NOTE: Use the default test native configuration suffix, which
        #       should be an empty string.
        #
        return ""
      }
    }

    proc getBuildNativeConfigurationSuffixForDotNetCore { suffix } {
      if {[isDotNetCore] && [isWindows]} then {
        return NativeOnly; # HACK: Special case, use 2015 native binaries.
      } elseif {[string length $suffix] > 0} then {
        return $suffix
      } else {
        return [getBuildNativeConfigurationSuffix]
      }
    }

    proc getBuildConfigurationSuffixes {} {
      #
      # NOTE: See if the list of test configuration suffixes has been
      #       overridden by the user (e.g. on the command line).
      #
      if {[info exists ::test_configuration_suffixes] && \
          [llength $::test_configuration_suffixes] > 0} then {
        #
        # NOTE: Use the specified list of test configurations suffixes.
        #
        return $::test_configuration_suffixes
      } elseif {[isDotNetCore]} then {
        #
        # NOTE: Running on .NET Core, prioritize its test configuration
        #       suffixes for library files.
        #
        return [list NetStandard20 ""]
      } else {
        #
        # NOTE: Use the default list of test configurations suffixes.
        #
        return [list ""]
      }
    }

    proc getBuildExtra {} {
      if {[info exists ::test_extra] && \
          [string length $::test_extra] > 0} then {
        #
        # NOTE: Use the specified extra output directory.
        #

      if {[file exists $fileName]} then {
        return $fileName
      }

      return $default
    }

    proc isBuildAvailable { native skipNative directory {varName ""} } {
      #
      # NOTE: Build the fully qualified file name for the primary assembly
      #       containing the System.Data.SQLite managed components.  It
      #       should be noted that this assembly file may also contain the
      #       native components, if a native build is in use.
      #
      set fileName [file nativename [file join $directory \
          System.Data.SQLite.dll]]

      if {![file exists $fileName]} then {
        return false
      }

      #
      # NOTE: If we are skipping looking for the native components, stop
      #       now.
      #
      if {$skipNative} then {
        return true
      }

      #
      # NOTE: Attempt to automatically detect if the primary assembly
      #       contains any native components, if necessary.
      #
      if {[string length $native] == 0} then {
        if {[string length $varName] > 0} then {

    }

    proc isReleaseAvailable { directory {varName ""} } {
      if {[string length $varName] > 0} then {
        upvar 1 $varName $varName
      }

      return [isBuildAvailable "" false $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.
      #

        #
        #       Note that all of the build commands above will default to using
        #       the latest version of MSBuild available and the "test_year" may
        #       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 && ([getBuildNative] || [hasRuntimeOption native])
        }]

        return [joinBuildDirectory $native [getBuildBaseDirectory] \
            [expr {$managedOnly ? [getBuildYear] : [getBuildNativeYear]}] \
            [getBuildPlatform $native] [appendArgs [getBuildConfiguration] \
            [expr {$managedOnly ? [getBuildConfigurationSuffix] : \
            [getBuildNativeConfigurationSuffix]}]] [expr {$managedOnly ? \
            [getBuildExtra] : ""}]]

      # 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 suffix [getBuildConfigurationSuffixes] {
              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]






                #

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

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

                #
                # NOTE: Do the necessary files exist?  Currently, no other
                #       steps are taken to verify this build is actually
                #       viable.
                #
                set skipNative [expr {[isDotNetCore] && [isWindows]}]

                if {[isBuildAvailable $native $skipNative $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_native $skipNative
                    set ::test_year $year

                    set ::test_native_year \
                        [getBuildNativeYearForDotNetCore $year]

                    set ::test_platform $platform
                    set ::test_configuration $configuration
                    set ::test_configuration_suffix $suffix

                    set ::test_native_configuration_suffix \
                        [getBuildNativeConfigurationSuffixForDotNetCore \
                        $suffix]

                    set ::test_extra $extra

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

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

      return false

        #
        # NOTE: Show the platform and architecture used to help locate the
        #       native build files.
        #
        tputs $::test_channel [appendArgs \
            "---- platform for locating native build files is \"" \
            [expr {[string length $platform] > 0 ? $platform : "<none>"}] \
            \"\n]

        tputs $::test_channel [appendArgs \
            "---- architecture for locating native build files is \"" \
            [expr {[string length $architecture] > 0 ? $architecture : \
            "<none>"}] \"\n]

        #
        # NOTE: Build a list of configuration files that we handle.
        #
        set configFileNames [list \
            System.Data.SQLite.dll.config]

        #
        # NOTE: Show the various lists of file names that are handled by this
        #       procedure.
        #
        tputs $::test_channel [appendArgs \
            "---- list of \"configuration\" file names is: " \
            [expr {[llength $configFileNames] > 0 ? $configFileNames : \
            "<none>"}] \n]

        tputs $::test_channel [appendArgs \
            "---- list of \"MDA configuration\" file names is: " \
            [expr {[llength $mdaConfigFileNames] > 0 ? $mdaConfigFileNames : \
            "<none>"}] \n]

        tputs $::test_channel [appendArgs \
            "---- list of \"external\" file names is: " \
            [expr {[llength $externalFileNames] > 0 ? $externalFileNames : \
            "<none>"}] \n]

        tputs $::test_channel [appendArgs \
            "---- list of \"native\" file names is: " \
            [expr {[llength $nativeFileNames] > 0 ? $nativeFileNames : \
            "<none>"}] \n]

        tputs $::test_channel [appendArgs \
            "---- list of \"mixed\" file names is: " \
            [expr {[llength $mixedFileNames] > 0 ? $mixedFileNames : \
            "<none>"}] \n]

        tputs $::test_channel [appendArgs \
            "---- list of \"managed\" file names is: " \
            [expr {[llength $managedFileNames] > 0 ? $managedFileNames : \
            "<none>"}] \n]

        #
        # NOTE: Remove any test constraints that refer to the native and/or
        #       managed assembly files that we handle unless forbidden from
        #       doing so.
        #
        if {![info exists ::no(sqliteRemoveConstraints)]} then {

            removeConstraint [appendArgs file_ $fileName]
          }

          foreach fileName $managedFileNames {
            removeConstraint [appendArgs file_ $fileName]
          }
        }

        #
        # NOTE: Check for the "autoSelect" runtime option.  If present,
        #       attempt to automatically select the first available
        #       build (or "release") of SQLite and System.Data.SQLite
        #       for use with the test suite.
        #
        if {[hasRuntimeOption autoSelect]} then {
          if {![checkForSQLiteBuilds $::test_channel true]} then {
            checkForSQLiteReleases $::test_channel true
          }
        }

        #
        # NOTE: Skip all System.Data.SQLite related file handling (deleting,
        #       copying, and loading) if instructed.
        #
        if {![info exists ::no(sqliteFiles)]} then {
          #

            if {![info exists ::no(deleteSqliteManagedFiles)]} then {
              foreach fileName $managedFileNames {
                tryDeleteAssembly $fileName
              }
            }
          }













          #
          # NOTE: Skip trying to verify the build directory if instructed;
          #       otherwise, make sure it actually exists or halt the entire
          #       testing process if it does not exist.
          #
          if {![info exists ::no(verifyBuildDirectory)]} then {
            #

                      "---- copying \"native\" files for architecture \"" \
                      $architecture \"...\n]

                  foreach fileName $nativeFileNames {
                    tryCopyAssembly $fileName false $architecture
                  }
                }

                if {![info exists ::no(copySqliteForcedNativeFiles)] && \
                    [getBuildNative]} then {
                  tputs $::test_channel \
                      "---- copying forced \"native\" files...\n"

                  foreach fileName $nativeFileNames {
                    tryCopyAssembly $fileName false
                  }
                }
              }
            }

            if {![info exists ::no(copySqliteMixedFiles)]} then {
              #
              # NOTE: If the "native" runtime option is set, copy implicit
              #       mixed-mode assembly files as well.  The runtime option

                      "---- copying \"mixed\" files for architecture \"" \
                      $architecture \"...\n]

                  foreach fileName $mixedFileNames {
                    tryCopyAssembly $fileName false $architecture
                  }
                }

                if {![info exists ::no(copySqliteForcedMixedFiles)] && \
                    [getBuildNative]} then {
                  tputs $::test_channel \
                      "---- copying forced \"mixed\" files...\n"

                  foreach fileName $mixedFileNames {
                    tryCopyAssembly $fileName false
                  }
                }
              }
            }

            if {![info exists ::no(copySqliteManagedFiles)]} then {
              tputs $::test_channel "---- copying \"managed\" files...\n"

              foreach fileName $managedFileNames {

              # NOTE: Yes, add constraint for use by the test suite.
              #
              addConstraint System.Data.SQLite.Encryption
            }
          }
        }

        #
        # NOTE: Check if the native build flag has been forcibly set.
        #
        tputs $::test_channel \
            "---- checking for System.Data.SQLite build native flag... "

        set native [getBuildNative]

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

        #
        # NOTE: Check the current build year.  Basically, this indicates
        #       which version of MSBuild and/or Visual Studio was used to
        #       compile the assembly binaries under test.
        #
        tputs $::test_channel \
            "---- checking for System.Data.SQLite build year... "

        set year [getBuildYear]

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

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

        set year [getBuildNativeYear]

        if {[string length $year] > 0} then {
          addConstraint [appendArgs buildNativeYear. $year]
          tputs $::test_channel [appendArgs \" $year \"\n]
        } else {
          addConstraint buildNativeYear.none
          tputs $::test_channel <none>\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... "

        set netFx [getBuildNetFx]

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

        #
        # NOTE: Check the current build configuration.  This should normally
        #       be either "Debug" or "Release".
        #
        tputs $::test_channel \
            "---- checking for System.Data.SQLite build configuration... "

        set configuration [getBuildConfiguration]

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

        #
        # NOTE: Check the current build configuration suffix.  This will
        #       normally be either "NetStandard20" or an empty string.
        #
        tputs $::test_channel \
            "---- checking for System.Data.SQLite build configuration suffix... "

        set suffix [getBuildConfigurationSuffix]

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

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

        set suffix [getBuildNativeConfigurationSuffix]

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

        #
        # NOTE: Check the current build extra directory.  This will normally
        #       be either "netstandard2.0" or an empty string.
        #
        tputs $::test_channel \
            "---- checking for System.Data.SQLite build extra... "

        set extra [getBuildExtra]

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