System.Data.SQLite

Check-in [d25440f7b5]
Login

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Make it possible for the test suite infrastructure to find native binaries when testing the managed binaries for the .NET Core.
Downloads: Tarball | ZIP archive
Timelines: family | ancestors | descendants | both | netStandard20
Files: files | file ages | folders
SHA1: d25440f7b5c07a8d10d992a8064e18d5bba30b3e
User & Date: mistachkin 2018-04-06 14:23:04.050
Context
2018-04-06
14:24
Fix typo in the previous check-in. check-in: c98cb01b99 user: mistachkin tags: netStandard20
14:23
Make it possible for the test suite infrastructure to find native binaries when testing the managed binaries for the .NET Core. check-in: d25440f7b5 user: mistachkin tags: netStandard20
11:11
Fix another portability issue in the stress test. check-in: 08e474ef9c user: mistachkin tags: netStandard20
Changes
Unified Diff Ignore Whitespace Patch
Changes to Externals/Eagle/lib/Eagle1.0/vendor.eagle.
354
355
356
357
358
359
360
361

362
363
364
365

366
367
368
369
370
371
372
373
    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 test_configurations \

        test_constraints test_machine 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"
    }







|
>
|
|
|
|
>
|







354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
    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"
    }
Changes to lib/System.Data.SQLite/common.eagle.
144
145
146
147
148
149
150

















151
152
153
154
155
156
157
            #
            return 2008; # TODO: Good "fallback" default?
          }
        }
      }
    }


















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







>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>







144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
            #
            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
392
393
394
395
396
397
398















































399
400
401
402
403
404
405
      } else {
        #
        # NOTE: Use the default list of test configurations.
        #
        return [list Debug Release]
      }
    }















































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







>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>







409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
      } 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").
      #
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
      #       we have everything we need.
      #
      if {$native} then {
        return true
      }

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

      #







|







699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
      #       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
      }

      #
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
      if {[string length $varName] > 0} then {
        upvar 1 $varName $varName
      }

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

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







|




<
<
<
<
<
<







787
788
789
790
791
792
793
794
795
796
797
798






799
800
801
802
803
804
805
      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]
      }
    }

810
811
812
813
814
815
816

817

818
819
820
821
822
823
824
        #       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] \

            [getBuildYear] [getBuildPlatform $native] [getBuildConfiguration]]

      }
    }

    proc getReleaseVersion {} {
      #
      # NOTE: Figure out the release version for use with the build directory
      #       when checking for available releases.







>
|
>







868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
        #       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.
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
      #       [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 nothign else we
      #       can do.
      #
      if {![info exists ::tcl_platform(machine)]} then {
        return false
      }

      #







|







1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
      #       [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
      }

      #
1715
1716
1717
1718
1719
1720
1721

1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741

1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774


1775
1776
1777
1778
1779
1780
1781

1782
1783
1784
1785
1786
1787
1788
      # 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] {

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


            #
            # 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 ")\n"]



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

            }
          }
        }
      }

      return false
    }







>
|
|
|
|
|
|
|

|
|
|
|
|

|
|
|
|
|
|
>

|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|

|
|

|
|
|

|
|
|
|
>
>

|
|
|
|
|
|
>







1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
      # 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
    }
5030
5031
5032
5033
5034
5035
5036







5037
5038
5039
5040
5041
5042
5043
        tputs $::test_channel \
            "---- checking for System.Data.SQLite build year... "

        set year [getBuildYear]
        addConstraint [appendArgs buildYear. $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... "







>
>
>
>
>
>
>







5095
5096
5097
5098
5099
5100
5101
5102
5103
5104
5105
5106
5107
5108
5109
5110
5111
5112
5113
5114
5115
        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... "
5052
5053
5054
5055
5056
5057
5058

















5059
5060
5061
5062
5063
5064
5065
        #
        tputs $::test_channel \
            "---- checking for System.Data.SQLite build configuration... "

        set configuration [getBuildConfiguration]
        addConstraint [appendArgs buildConfiguration. $configuration]
        tputs $::test_channel [appendArgs \" $configuration \"\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 {







>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>







5124
5125
5126
5127
5128
5129
5130
5131
5132
5133
5134
5135
5136
5137
5138
5139
5140
5141
5142
5143
5144
5145
5146
5147
5148
5149
5150
5151
5152
5153
5154
        #
        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 {