System.Data.SQLite
Check-in [250dac131a]
Not logged in

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

Overview
Comment:Merge updates from trunk.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | tkt-343d392b51
Files: files | file ages | folders
SHA1: 250dac131abdd3c292c0cf6aee8cbed18377e201
User & Date: mistachkin 2011-10-11 03:50:15
Context
2011-10-11
07:21
Merge all fixes, enhancements, and tests related to ticket [343d392b51] into trunk. check-in: fc49363310 user: mistachkin tags: trunk
03:50
Merge updates from trunk. Closed-Leaf check-in: 250dac131a user: mistachkin tags: tkt-343d392b51
03:48
Fix leaked variable 'version' in test. Cleanup comments. check-in: b55caba05c user: mistachkin tags: trunk
2011-10-09
04:13
Add comments to the getDateTimeFormat unit testing infrastructure procedure to clarify how the default format was chosen. check-in: 1b25ba72a3 user: mistachkin tags: tkt-343d392b51
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to Externals/Eagle/lib/Eagle1.0/init.eagle.

  1570   1570       # NOTE: Exports the necessary commands from this package and import
  1571   1571       #       them into the global namespace.
  1572   1572       #
  1573   1573       exportAndImportPackageCommands [namespace current] [list \
  1574   1574           exportAndImportPackageCommands isEagle isMono getEnvironmentVariable \
  1575   1575           getPluginPath getDictionaryValue getColumnValue getRowColumnValue \
  1576   1576           appendArgs haveGaruda lappendArgs readFile filter map reduce \
  1577         -        getPlatformInfo] false false
         1577  +        getPlatformInfo execShell] false false
  1578   1578   
  1579   1579       ###########################################################################
  1580   1580       ############################## END Tcl ONLY ###############################
  1581   1581       ###########################################################################
  1582   1582     }
  1583   1583   
  1584   1584     #
  1585   1585     # NOTE: Provide the Eagle library package to the interpreter.
  1586   1586     #
  1587   1587     package provide EagleLibrary \
  1588   1588       [expr {[isEagle] ? [info engine PatchLevel] : 1.0}]
  1589   1589   }
  1590   1590   

Changes to Externals/Eagle/lib/Eagle1.0/test.eagle.

   196    196       #       the caller.
   197    197       #
   198    198       upvar 1 $varName array
   199    199   
   200    200       #
   201    201       # TODO: Add more support for standard tcltest options here.
   202    202       #
   203         -    set options [list -configuration -suffix -file -notFile -match -skip \
   204         -        -constraints -logFile -preTest -postTest -threshold -stopOnFailure \
   205         -        -exitOnComplete]
          203  +    set options [list -configuration -constraints -exitOnComplete -file \
          204  +        -logFile -match -no -notFile -postTest -preTest -skip -stopOnFailure \
          205  +        -suffix -threshold]
   206    206   
   207    207       foreach {name value} $args {
   208    208         if {[lsearch -exact $options $name] != -1} then {
   209    209           set array($name) $value
   210    210   
   211    211           tputs $::test_channel [appendArgs \
   212    212               "---- overrode test option \"" $name "\" with value \"" $value \
................................................................................
   675    675         #
   676    676         set array(connections,$index) 0
   677    677         set array(transactions,$index) 0
   678    678         set array(modules,$index) 0
   679    679         set array(delegates,$index) 0
   680    680         set array(tcl,$index) 0
   681    681         set array(tclinterps,$index) 0
          682  +      set array(tclthreads,$index) 0
   682    683         set array(tclcommands,$index) 0
   683    684   
   684    685         catch {set array(connections,$index) [llength [info connections]]}
   685    686         catch {set array(transactions,$index) [llength [info transactions]]}
   686    687         catch {set array(modules,$index) [llength [info modules]]}
   687    688         catch {set array(delegates,$index) [llength [info delegates]]}
   688    689   
   689    690         if {[llength [info commands tcl]] > 0} then {
   690    691           set array(tcl,$index) [tcl ready]
   691    692         }
   692    693   
   693    694         catch {set array(tclinterps,$index) [llength [tcl interps]]}
          695  +      catch {set array(tclthreads,$index) [llength [tcl threads]]}
   694    696         catch {set array(tclcommands,$index) [llength [tcl command list]]}
   695    697       }
   696    698     }
   697    699   
   698    700     proc reportTestStatistics { channel fileName varName } {
   699    701       set statistics [list afters variables commands procedures files \
   700    702           temporaryFiles channels aliases interpreters environment]
................................................................................
   703    705         #
   704    706         # TODO: For now, tracking "leaked" assemblies is meaningless because
   705    707         #       the .NET Framework has no way to unload them without tearing
   706    708         #       down the entire application domain.
   707    709         #
   708    710         lappend statistics scopes objects callbacks types interfaces \
   709    711             namespaces processes connections transactions modules \
   710         -          delegates tcl tclinterps tclcommands; # assemblies
          712  +          delegates tcl tclinterps tclthreads tclcommands; # assemblies
   711    713       }
   712    714   
   713    715       #
   714    716       # NOTE: Show what leaked, if anything.
   715    717       #
   716    718       upvar 1 $varName array
   717    719   
................................................................................
  1132   1134         #
  1133   1135         interp alias {} testConstraint {} haveOrAddConstraint
  1134   1136         interp alias {} ::tcltest::testConstraint {} haveOrAddConstraint
  1135   1137   
  1136   1138         #
  1137   1139         # NOTE: This is needed by most tests in the Tcl test suite.
  1138   1140         #
  1139         -      proc ::tcltest::cleanupTests {} {}
         1141  +      proc ::tcltest::cleanupTests { args } {}
  1140   1142       } else {
  1141   1143         #
  1142   1144         # NOTE: Load the tcltest package.
  1143   1145         #
  1144   1146         package require tcltest
  1145   1147   
  1146   1148         #
................................................................................
  1300   1302             if {[isMono]} then {
  1301   1303               return [expr \
  1302   1304                   {double(($after - $before) / ($milliseconds / 1000.0))}]
  1303   1305             } else {
  1304   1306               return [expr {($after - $before) / ($milliseconds / 1000.0)}]
  1305   1307             }
  1306   1308           } finally {
  1307         -          catch {after cancel $event}
         1309  +          if {[info exists event]} then {
         1310  +            catch {after cancel $event}
         1311  +          }
         1312  +
  1308   1313             after flags =$flags
  1309   1314           }
  1310   1315         } finally {
  1311   1316           interp bgerror {} $bgerror
  1312   1317         }
  1313   1318       }
  1314   1319   

Changes to Externals/Eagle/lib/Test1.0/constraints.eagle.

   111    111         # NOTE: We do not want to skip bugs or crashing
   112    112         #       issues for Eagle since we are not running
   113    113         #       in Eagle.
   114    114         #
   115    115         addConstraint eagleBug
   116    116         addConstraint eagleCrash
   117    117   
          118  +      #
          119  +      # HACK: Needed by tests "socket-*.*".
          120  +      #
          121  +      if {![info exists ::no(compileNetwork)]} then {
          122  +        addConstraint compile.NETWORK
          123  +      }
          124  +
          125  +      tputs $channel no\n
          126  +    }
          127  +  }
          128  +
          129  +  proc checkForLogFile { channel } {
          130  +    tputs $channel "---- checking for log file... "
          131  +
          132  +    if {[info exists ::test_log] && \
          133  +        [string length $::test_log] > 0 && \
          134  +        [file exists $::test_log]} then {
          135  +      #
          136  +      # NOTE: The log file appears to be available.
          137  +      #
          138  +      addConstraint logFile
          139  +
          140  +      tputs $channel yes\n
          141  +    } else {
   118    142         tputs $channel no\n
   119    143       }
   120    144     }
   121    145   
   122    146     proc checkForGaruda { channel } {
   123    147       tputs $channel "---- checking for Garuda... "
   124    148   
................................................................................
   435    459         # NOTE: Tcl is always native code and can always execute native code.
   436    460         #
   437    461         addConstraint native
   438    462   
   439    463         #
   440    464         # HACK: Needed by test "benchmark-1.22".
   441    465         #
   442         -      addConstraint compile.NATIVE
          466  +      if {![info exists ::no(compileNative)]} then {
          467  +        addConstraint compile.NATIVE
          468  +      }
   443    469   
   444    470         tputs $channel yes\n
   445    471       }
   446    472     }
   447    473   
   448    474     proc checkForTip127 { channel } {
   449    475       tputs $channel "---- checking for TIP #127... "
................................................................................
  1615   1641       # NOTE: We need several of our test constraint related commands in the
  1616   1642       #       global namespace.
  1617   1643       #
  1618   1644       exportAndImportPackageCommands [namespace current] [list checkForPlatform \
  1619   1645           checkForEagle checkForGaruda checkForShell checkForDebug checkForTk \
  1620   1646           checkForVersion checkForCommand checkForFile checkForNativeCode \
  1621   1647           checkForTip127 checkForTip194 checkForTip241 checkForTip285 \
  1622         -        checkForPerformance checkForTiming checkForInteractive \
         1648  +        checkForPerformance checkForTiming checkForInteractive checkForLogFile \
  1623   1649           checkForNetwork checkForCompileOption checkForUserInteraction] false \
  1624   1650           false
  1625   1651   
  1626   1652       ###########################################################################
  1627   1653       ############################## END Tcl ONLY ###############################
  1628   1654       ###########################################################################
  1629   1655     }

Changes to Externals/Eagle/lib/Test1.0/epilogue.eagle.

   257    257               $percent "% < " $test_threshold %)\n]
   258    258         }
   259    259       }
   260    260   
   261    261       unset percent
   262    262   
   263    263       tputs $test_channel \n; # NOTE: Blank line.
          264  +
          265  +    #
          266  +    # NOTE: Call the Tcl test cleanup procedure now to give it a chance to do
          267  +    #       any custom cleanup that has been registered.
          268  +    #
          269  +    ::tcltest::cleanupTests
   264    270     }
   265    271   
   266    272     #
   267    273     # NOTE: Check for and process any custom test epilogue script that may
   268    274     #       be set in the environment.
   269    275     #
   270    276     sourceIfValid epilogue [getEnvironmentVariable testEpilogue]
   271    277   
   272    278     #
   273         -  # NOTE: Evaluate the specified post-test script now, if any.
          279  +  # NOTE: Are we being prevented from evaluating the "post-test" script?
   274    280     #
   275         -  if {[info exists test_flags(-postTest)] && \
   276         -      [string length $test_flags(-postTest)] > 0} then {
          281  +  if {![info exists no(postTest)]} then {
          282  +    #
          283  +    # NOTE: Evaluate the specified post-test script now, if any.
   277    284       #
   278         -    # TODO: Perhaps use [uplevel] here instead of [eval].  For now, it does not
   279         -    #       matter since we enforce this file being evaluated at the top-level.
   280         -    #
   281         -    eval $test_flags(-postTest)
          285  +    if {[info exists test_flags(-postTest)] && \
          286  +        [string length $test_flags(-postTest)] > 0} then {
          287  +      #
          288  +      # TODO: Perhaps use [uplevel] here instead of [eval].  For now, it does
          289  +      #       not matter since we enforce this file being evaluated at the
          290  +      #       top-level.
          291  +      #
          292  +      eval $test_flags(-postTest)
          293  +    }
   282    294     }
   283    295   
   284    296     #
   285    297     # NOTE: Do we need to exit now?
   286    298     #
   287    299     if {[isExitOnComplete]} then {
   288    300       #

Changes to Externals/Eagle/lib/Test1.0/prologue.eagle.

    62     62         #       previous (legacy) behavior (i.e. where we always went
    63     63         #       up two levels to the base directory).
    64     64         #
    65     65         set base_path [file dirname $base_path]
    66     66       }
    67     67     }
    68     68   
           69  +  #
           70  +  # NOTE: Set the local root directory of the source checkout (i.e. of
           71  +  #       Eagle or whatever project the Eagle binaries are being used by).
           72  +  #
           73  +  if {![info exists root_path]} then {
           74  +    set pattern {^local-root:\s+(.*)\s+$}
           75  +
           76  +    if {[catch {set exec [exec -- fossil info]}] || \
           77  +        [regexp -line -- $pattern $exec dummy directory] == 0} then {
           78  +      #
           79  +      # NOTE: We could not query local root directory of the source checkout
           80  +      #       from Fossil; therefore, attempt to make an educated guess.  This
           81  +      #       value will probably be wrong for any project(s) other than Eagle.
           82  +      #       In that case, this value should be overridden by that project to
           83  +      #       relfect the actual local root directory of the source checkout
           84  +      #       for that project.
           85  +      #
           86  +      set root_path $base_path
           87  +    } else {
           88  +      #
           89  +      # NOTE: We extracted the local root directory of the source checkout
           90  +      #       from Fossil.  Now, make sure it is fully normalized and has no
           91  +      #       trailing slashes.
           92  +      #
           93  +      set root_path [file normalize $directory]
           94  +    }
           95  +
           96  +    unset -nocomplain directory exec pattern
           97  +  }
           98  +
    69     99     #
    70    100     # NOTE: Set the executable file name for the process, if
    71    101     #       necessary.
    72    102     #
    73    103     if {![info exists bin_file]} then {
    74    104       set bin_file [info nameofexecutable]
    75    105     }
................................................................................
   190    220     set test_flags(-postTest) ""; # default to not evaluating anything.
   191    221   
   192    222     #
   193    223     # NOTE: Check for and process any command line arguments.
   194    224     #
   195    225     if {[info exists argv]} then {
   196    226       eval processTestArguments test_flags $argv
          227  +
          228  +    if {[info exists test_flags(-no)] && \
          229  +        [string length $test_flags(-no)] > 0} then {
          230  +      #
          231  +      # NOTE: Set the test run restrictions based on the provided command line
          232  +      #       argument value (which is assumed to be a "dictionary-style" list
          233  +      #       containing name/value pairs to add to the global "no" array).
          234  +      #
          235  +      foreach {name value} $test_flags(-no) {
          236  +        set no($name) $value
          237  +      }
          238  +
          239  +      unset name value
          240  +    }
   197    241   
   198    242       if {[info exists test_flags(-logFile)] && \
   199    243           [string length $test_flags(-logFile)] > 0} then {
   200    244         #
   201    245         # NOTE: Set the log file name to the one provided by the command line.
   202    246         #
   203    247         set test_log $test_flags(-logFile)
................................................................................
   248    292         set test_tclsh tclsh
   249    293       } else {
   250    294         set test_tclsh $bin_file
   251    295       }
   252    296     }
   253    297   
   254    298     #
   255         -  # NOTE: Has logging been disabled?
          299  +  # NOTE: Has automatic log file naming been disabled?
   256    300     #
   257         -  if {![info exists no(log)]} then {
          301  +  if {![info exists no(logFileName)]} then {
   258    302       #
   259    303       # NOTE: Set the log to use for test output, if necessary.
   260    304       #
   261    305       if {![info exists test_log]} then {
   262    306         set test_log [file join [getTemporaryPath] [appendArgs [file tail [info \
   263    307             nameofexecutable]] [getTestLogId] .test. [pid] .log]]
   264    308       }
   265    309     }
   266    310   
   267    311     #
   268         -  # NOTE: Evaluate the specified pre-test script now, if any.
          312  +  # NOTE: Are we being prevented from evaluating the "pre-test" script?
   269    313     #
   270         -  if {[info exists test_flags(-preTest)] && \
   271         -      [string length $test_flags(-preTest)] > 0} then {
          314  +  if {![info exists no(preTest)]} then {
   272    315       #
   273         -    # TODO: Perhaps use [uplevel] here instead of [eval].  For now, it does not
   274         -    #       matter since we enforce this file being evaluated at the top-level.
          316  +    # NOTE: Evaluate the specified pre-test script now, if any.
   275    317       #
   276         -    eval $test_flags(-preTest)
          318  +    if {[info exists test_flags(-preTest)] && \
          319  +        [string length $test_flags(-preTest)] > 0} then {
          320  +      #
          321  +      # TODO: Perhaps use [uplevel] here instead of [eval].  For now, it does
          322  +      #       not matter since we enforce this file being evaluated at the
          323  +      #       top-level.
          324  +      #
          325  +      eval $test_flags(-preTest)
          326  +    }
   277    327     }
   278    328   
   279    329     #
   280    330     # NOTE: Check for and process any custom test prologue script that may be set
   281    331     #       in the environment.  This must be done after the Eagle test package
   282    332     #       has been made available and after the log file has been setup.
   283    333     #
................................................................................
   424    474     }
   425    475   
   426    476     if {[llength $test_flags(-skip)] > 0} then {
   427    477       tputs $test_channel [appendArgs "---- skipping tests that match: " \
   428    478           $test_flags(-skip) \n]
   429    479     }
   430    480   
   431         -  tputs $test_channel [appendArgs "---- path: \"" \
          481  +  tputs $test_channel [appendArgs "---- path: " \
   432    482         [expr {[info exists path] && [string length $path] > 0 ? \
   433         -          $path : "<none>"}] \"\n]
          483  +          [appendArgs \" $path \"] : "<none>"}] \n]
   434    484   
   435    485     tputs $test_channel [appendArgs "---- base path: \"" \
   436    486         $base_path \"\n]
          487  +
          488  +  tputs $test_channel [appendArgs "---- root path: \"" \
          489  +      $root_path \"\n]
   437    490   
   438    491     tputs $test_channel [appendArgs "---- binary path: \"" \
   439    492         $bin_path \"\n]
   440    493   
   441    494     tputs $test_channel [appendArgs "---- library path: \"" \
   442    495         $lib_path \"\n]
   443    496   
................................................................................
  1340   1393     #
  1341   1394     # NOTE: For test "excel-2.*".
  1342   1395     #
  1343   1396     if {![info exists no(test.xls)]} then {
  1344   1397       checkForFile $test_channel [file join $test_path test.xls]
  1345   1398     }
  1346   1399   
         1400  +  #
         1401  +  # NOTE: For test "interp-1.10".
         1402  +  #
         1403  +  if {![info exists no(settings.xml)]} then {
         1404  +    checkForFile $test_channel [file join $test_path settings.xml]
         1405  +  }
         1406  +
  1347   1407     #
  1348   1408     # NOTE: For test "load-1.1.*".
  1349   1409     #
  1350   1410     if {![info exists no(Plugin.dll)]} then {
  1351   1411       checkForFile $test_channel [file join $lib_path Plugin1.0 Plugin.dll]
  1352   1412     }
  1353   1413   
................................................................................
  1405   1465     if {![info exists no(version)]} then {
  1406   1466       checkForVersion $test_channel
  1407   1467     }
  1408   1468   
  1409   1469     if {![info exists no(eagle)]} then {
  1410   1470       checkForEagle $test_channel
  1411   1471     }
         1472  +
         1473  +  if {![info exists no(noLogFile)]} then {
         1474  +    checkForLogFile $test_channel
         1475  +  }
  1412   1476   
  1413   1477     if {![info exists no(garuda)]} then {
  1414   1478       checkForGaruda $test_channel
  1415   1479     }
  1416   1480   
  1417   1481     if {![info exists no(shell)]} then {
  1418   1482       checkForShell $test_channel
................................................................................
  1546   1610             "---- checking for current BogoCops (commands-per-second)... "]
  1547   1611   
  1548   1612         if {![info exists test_cops]} then {
  1549   1613           set test_cops [calculateBogoCops]
  1550   1614         }
  1551   1615   
  1552   1616         tputs $test_channel [appendArgs $test_cops \n]
         1617  +
         1618  +      set percent [expr {[calculateRelativePerformance iterations 1] * 100}]
         1619  +
         1620  +      tputs $test_channel [appendArgs \
         1621  +          "---- current BogoCops (commands-per-second) is " [formatDecimal \
         1622  +          [expr {$percent > 100 ? $percent - 100 : $percent}] 2] "% " \
         1623  +          [expr {$percent > 100 ? "faster than" : "as fast as"}] \
         1624  +          " the baseline\n"]
         1625  +
         1626  +      unset percent
  1553   1627       }
  1554   1628   
  1555   1629       ###########################################################################
  1556   1630   
  1557   1631       set timeStamp [getPlatformInfo timeStamp ""]
  1558   1632   
  1559   1633       if {[string length $timeStamp] > 0} then {

Changes to SQLite.Interop/props/SQLite.Interop.vsprops.

    15     15   	<UserMacro
    16     16   		Name="ConfigurationYear"
    17     17   		Value="2008"
    18     18   		PerformEnvironmentSet="true"
    19     19   	/>
    20     20   	<UserMacro
    21     21   		Name="INTEROP_BUILD_NUMBER"
    22         -		Value="075"
           22  +		Value="076"
    23     23   		PerformEnvironmentSet="true"
    24     24   	/>
    25     25   	<UserMacro
    26     26   		Name="INTEROP_MANIFEST_VERSION"
    27     27   		Value="1.0.76.0"
    28     28   		PerformEnvironmentSet="true"
    29     29   	/>

Added SQLite.MSIL.nuspec.

            1  +<?xml version="1.0" encoding="utf-8"?>
            2  +<package>
            3  +  <metadata>
            4  +    <id>System.Data.SQLite.MSIL</id>
            5  +    <version>1.0.76.0</version>
            6  +    <authors>SQLite Development Team</authors>
            7  +    <description>An ADO.NET provider for SQLite (managed-only).</description>
            8  +    <language>en-US</language>
            9  +    <projectUrl>http://system.data.sqlite.org/</projectUrl>
           10  +    <iconUrl>http://system.data.sqlite.org/images/sqlite32.png</iconUrl>
           11  +    <licenseUrl>http://www.sqlite.org/copyright.html</licenseUrl>
           12  +    <tags>sqlite database ado.net provider interop</tags>
           13  +    <copyright>Public Domain</copyright>
           14  +  </metadata>
           15  +  <files>
           16  +    <file src="bin\2008\Release\bin\System.Data.SQLite.dll" target="lib\net20" />
           17  +    <file src="bin\2010\Release\bin\System.Data.SQLite.dll" target="lib\net40" />
           18  +    <file src="bin\2008\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net20" />
           19  +    <file src="bin\2010\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net40" />
           20  +  </files>
           21  +</package>

Changes to Tests/basic.eagle.

    29     29   set testLinqOutFile [file nativename [file join $path testlinq.out]]
    30     30   set northwindEfDbFile [file nativename [file join [file dirname $path] \
    31     31       testlinq northwindEF.db]]
    32     32   
    33     33   #
    34     34   # NOTE: Setup the test constraints specific to the tests in this file.
    35     35   #
    36         -if {![haveConstraint file_[file tail $testExeFile]]} then {
           36  +if {![haveConstraint [appendArgs file_ [file tail $testExeFile]]]} then {
    37     37     checkForFile $test_channel $testExeFile
    38     38   }
    39     39   
    40         -if {![haveConstraint file_[file tail $testLinqExeFile]]} then {
           40  +if {![haveConstraint [appendArgs file_ [file tail $testLinqExeFile]]]} then {
    41     41     checkForFile $test_channel $testLinqExeFile
    42     42   }
    43     43   
    44         -if {![haveConstraint file_[file tail $northwindEfDbFile]]} then {
           44  +if {![haveConstraint [appendArgs file_ [file tail $northwindEfDbFile]]]} then {
    45     45     checkForFile $test_channel $northwindEfDbFile
    46     46   }
    47     47   
    48         -if {![haveConstraint file_[file tail $testLinqOutFile]]} then {
           48  +if {![haveConstraint [appendArgs file_ [file tail $testLinqOutFile]]]} then {
    49     49     checkForFile $test_channel $testLinqOutFile
    50     50   }
    51     51   
    52     52   ###############################################################################
    53     53   
    54     54   runTest {test basic-1.1 {unit tests from the 'test' project} -setup {
    55     55     catch {file delete [file join [file dirname $testExeFile] Test.db3]}

Changes to Tests/tkt-00f86f9739.eagle.

    27     27   set testLinqExeFile [getBuildFileName testlinq.exe]
    28     28   set northwindEfDbFile [file nativename [file join [file dirname $path] \
    29     29       testlinq northwindEF.db]]
    30     30   
    31     31   #
    32     32   # NOTE: Setup the test constraints specific to the tests in this file.
    33     33   #
    34         -if {![haveConstraint file_[file tail $testLinqExeFile]]} then {
           34  +if {![haveConstraint [appendArgs file_ [file tail $testLinqExeFile]]]} then {
    35     35     checkForFile $test_channel $testLinqExeFile
    36     36   }
    37     37   
    38         -if {![haveConstraint file_[file tail $northwindEfDbFile]]} then {
           38  +if {![haveConstraint [appendArgs file_ [file tail $northwindEfDbFile]]]} then {
    39     39     checkForFile $test_channel $northwindEfDbFile
    40     40   }
    41     41   
    42     42   ###############################################################################
    43     43   
    44     44   runTest {test tkt-00f86f9739-1.1 {LINQ with StartsWith} -body {
    45     45     set result [list]

Changes to Tests/tkt-59edc1018b.eagle.

    27     27   set testLinqExeFile [getBuildFileName testlinq.exe]
    28     28   set northwindEfDbFile [file nativename [file join [file dirname $path] \
    29     29       testlinq northwindEF.db]]
    30     30   
    31     31   #
    32     32   # NOTE: Setup the test constraints specific to the tests in this file.
    33     33   #
    34         -if {![haveConstraint file_[file tail $testLinqExeFile]]} then {
           34  +if {![haveConstraint [appendArgs file_ [file tail $testLinqExeFile]]]} then {
    35     35     checkForFile $test_channel $testLinqExeFile
    36     36   }
    37     37   
    38         -if {![haveConstraint file_[file tail $northwindEfDbFile]]} then {
           38  +if {![haveConstraint [appendArgs file_ [file tail $northwindEfDbFile]]]} then {
    39     39     checkForFile $test_channel $northwindEfDbFile
    40     40   }
    41     41   
    42     42   ###############################################################################
    43     43   
    44     44   runTest {test tkt-59edc1018b-1.1 {LINQ with EndsWith} -body {
    45     45     set result [list]

Changes to Tests/tkt-8b7d179c3c.eagle.

    27     27   set testLinqExeFile [getBuildFileName testlinq.exe]
    28     28   set northwindEfDbFile [file nativename [file join [file dirname $path] \
    29     29       testlinq northwindEF.db]]
    30     30   
    31     31   #
    32     32   # NOTE: Setup the test constraints specific to the tests in this file.
    33     33   #
    34         -if {![haveConstraint file_[file tail $testLinqExeFile]]} then {
           34  +if {![haveConstraint [appendArgs file_ [file tail $testLinqExeFile]]]} then {
    35     35     checkForFile $test_channel $testLinqExeFile
    36     36   }
    37     37   
    38         -if {![haveConstraint file_[file tail $northwindEfDbFile]]} then {
           38  +if {![haveConstraint [appendArgs file_ [file tail $northwindEfDbFile]]]} then {
    39     39     checkForFile $test_channel $northwindEfDbFile
    40     40   }
    41     41   
    42     42   ###############################################################################
    43     43   
    44     44   runTest {test tkt-8b7d179c3c-1.1 {LINQ with Skip and Take} -body {
    45     45     set result [list]

Changes to Tests/tkt-ccfa69fc32.eagle.

    27     27   set testLinqExeFile [getBuildFileName testlinq.exe]
    28     28   set northwindEfDbFile [file nativename [file join [file dirname $path] \
    29     29       testlinq northwindEF.db]]
    30     30   
    31     31   #
    32     32   # NOTE: Setup the test constraints specific to the tests in this file.
    33     33   #
    34         -if {![haveConstraint file_[file tail $testLinqExeFile]]} then {
           34  +if {![haveConstraint [appendArgs file_ [file tail $testLinqExeFile]]]} then {
    35     35     checkForFile $test_channel $testLinqExeFile
    36     36   }
    37     37   
    38         -if {![haveConstraint file_[file tail $northwindEfDbFile]]} then {
           38  +if {![haveConstraint [appendArgs file_ [file tail $northwindEfDbFile]]]} then {
    39     39     checkForFile $test_channel $northwindEfDbFile
    40     40   }
    41     41   
    42     42   ###############################################################################
    43     43   
    44     44   runTest {test tkt-ccfa69fc32-1.1 {Entity Framework / Transaction Scope} -body {
    45     45     set result [list]

Added Tests/version.eagle.

            1  +###############################################################################
            2  +#
            3  +# version.eagle --
            4  +#
            5  +# Written by Joe Mistachkin.
            6  +# Released to the public domain, use at your own risk!
            7  +#
            8  +###############################################################################
            9  +
           10  +package require Eagle
           11  +package require EagleLibrary
           12  +package require EagleTest
           13  +
           14  +runTestPrologue
           15  +
           16  +###############################################################################
           17  +
           18  +package require System.Data.SQLite.Test
           19  +runSQLiteTestPrologue
           20  +
           21  +###############################################################################
           22  +# ******************** BEGIN VOLATILE VERSION INFORMATION *********************
           23  +###############################################################################
           24  +
           25  +#
           26  +# NOTE: For these unit tests to be useful and accurate, the following version
           27  +#       numbers must be manually kept synchronized with the version numbers for
           28  +#       the source code files, the built binaries, and the release packages.
           29  +#
           30  +set version(major)             1
           31  +set version(minor)             0
           32  +set version(build)            76; # NOTE: Incremented with each release.
           33  +set version(revision)          0
           34  +
           35  +###############################################################################
           36  +# ********************* END VOLATILE VERSION INFORMATION **********************
           37  +###############################################################################
           38  +
           39  +#
           40  +# NOTE: Build the full version number using the components setup above.  This
           41  +#       should not have to be changed.
           42  +#
           43  +set version(full) [appendArgs $version(major) . $version(minor) . \
           44  +                              $version(build) . $version(revision)]
           45  +
           46  +###############################################################################
           47  +
           48  +#
           49  +# NOTE: Setup the variables that refer to the various files required by the
           50  +#       tests in this file.
           51  +#
           52  +set systemDataSQLiteDllFile [getBuildFileName System.Data.SQLite.dll]
           53  +set systemDataSQLiteLinqDllFile [getBuildFileName System.Data.SQLite.Linq.dll]
           54  +set testExeFile [getBuildFileName test.exe]
           55  +set testLinqExeFile [getBuildFileName testlinq.exe]
           56  +
           57  +#
           58  +# NOTE: Setup the test constraints specific to the tests in this file.
           59  +#
           60  +if {![haveConstraint [appendArgs file_ \
           61  +    [file tail $systemDataSQLiteDllFile]]]} then {
           62  +  checkForFile $test_channel $systemDataSQLiteDllFile
           63  +}
           64  +
           65  +if {![haveConstraint [appendArgs file_ \
           66  +    [file tail $systemDataSQLiteLinqDllFile]]]} then {
           67  +  checkForFile $test_channel $systemDataSQLiteLinqDllFile
           68  +}
           69  +
           70  +if {![haveConstraint [appendArgs file_ [file tail $testExeFile]]]} then {
           71  +  checkForFile $test_channel $testExeFile
           72  +}
           73  +
           74  +if {![haveConstraint [appendArgs file_ [file tail $testLinqExeFile]]]} then {
           75  +  checkForFile $test_channel $testLinqExeFile
           76  +}
           77  +
           78  +###############################################################################
           79  +
           80  +runTest {test version-1.1 {'System.Data.SQLite' binary version} -body {
           81  +  file version $systemDataSQLiteDllFile
           82  +} -constraints {eagle file_System.Data.SQLite.dll} -result $version(full)}
           83  +
           84  +###############################################################################
           85  +
           86  +runTest {test version-1.2 {'System.Data.SQLite.Linq' binary version} -body {
           87  +  file version $systemDataSQLiteLinqDllFile
           88  +} -constraints {eagle file_System.Data.SQLite.Linq.dll} -result $version(full)}
           89  +
           90  +###############################################################################
           91  +
           92  +runTest {test version-1.3 {'test' binary version} -body {
           93  +  file version $testExeFile
           94  +} -constraints {eagle file_test.exe} -result $version(full)}
           95  +
           96  +###############################################################################
           97  +
           98  +runTest {test version-1.4 {'testlinq' binary version} -body {
           99  +  file version $testLinqExeFile
          100  +} -constraints {eagle file_testlinq.exe} -result $version(full)}
          101  +
          102  +###############################################################################
          103  +
          104  +set patterns [list \
          105  +    [appendArgs <version> [string map [list . \\.] $version(full)] \
          106  +        </version>] \
          107  +    [appendArgs <version> [string map [list . \\.] $version(full)] \
          108  +        </version>] \
          109  +    [appendArgs <version> [string map [list . \\.] $version(full)] \
          110  +        </version>] \
          111  +    [appendArgs <version> [string map [list . \\.] $version(full)] \
          112  +        </version>] \
          113  +    [appendArgs Version= [string map [list . \\.] $version(full)] ,] \
          114  +    [appendArgs &quot\; [format %03d $version(build)] &quot\;] \
          115  +    [appendArgs AssemblyVersion\\(\" [string map [list . \\.] \
          116  +        $version(full)] \"\\)] \
          117  +    [appendArgs AssemblyFileVersion\\(\" [string map [list . \\.] \
          118  +        $version(full)] \"\\)] \
          119  +    [appendArgs Value=\" [format %03d $version(build)] \"] \
          120  +    [appendArgs Value=\" [string map [list . \\.] $version(full)] \"] \
          121  +    [appendArgs Value=\" [string map [list . ,] $version(full)] \"] \
          122  +    [appendArgs <INTEROP_BUILD_NUMBER> [format %03d $version(build)] \
          123  +        </INTEROP_BUILD_NUMBER>] \
          124  +    [appendArgs <INTEROP_MANIFEST_VERSION> [string map [list . \\.] \
          125  +        $version(full)] </INTEROP_MANIFEST_VERSION>] \
          126  +    [appendArgs <INTEROP_RC_VERSION> [string map [list . ,] \
          127  +        $version(full)] </INTEROP_RC_VERSION>] \
          128  +    [appendArgs \" [string map [list . \\.] $version(full)] \"] \
          129  +    [appendArgs AssemblyVersion\\(\" [string map [list . \\.] \
          130  +        $version(full)] \"\\)] \
          131  +    [appendArgs AssemblyFileVersion\\(\" [string map [list . \\.] \
          132  +        $version(full)] \"\\)] \
          133  +    [appendArgs \" [string map [list . \\.] $version(full)] \"] \
          134  +    [appendArgs \"SQLite.Interop. [format %03d $version(build)] .dll\"] \
          135  +    [appendArgs AssemblyVersion\\(\" [string map [list . \\.] \
          136  +        $version(full)] \"\\)] \
          137  +    [appendArgs AssemblyFileVersion\\(\" [string map [list . \\.] \
          138  +        $version(full)] \"\\)] \
          139  +    [appendArgs Version= [string map [list . \\.] $version(full)] ,] \
          140  +    [appendArgs Version= [string map [list . \\.] $version(full)] ,] \
          141  +    [appendArgs Version= [string map [list . \\.] $version(full)] ,]]
          142  +
          143  +set fileNames [list \
          144  +    SQLite.nuspec \
          145  +    SQLite.MSIL.nuspec \
          146  +    SQLite.x64.nuspec \
          147  +    SQLite.x86.nuspec \
          148  +    [file join Doc Extra dbfactorysupport.html] \
          149  +    [file join Doc Extra welcome.html] \
          150  +    [file join SQLite.Designer AssemblyInfo.cs] \
          151  +    [file join SQLite.Designer AssemblyInfo.cs] \
          152  +    [file join SQLite.Interop props SQLite.Interop.vsprops] \
          153  +    [file join SQLite.Interop props SQLite.Interop.vsprops] \
          154  +    [file join SQLite.Interop props SQLite.Interop.vsprops] \
          155  +    [file join SQLite.Interop props SQLite.Interop.props] \
          156  +    [file join SQLite.Interop props SQLite.Interop.props] \
          157  +    [file join SQLite.Interop props SQLite.Interop.props] \
          158  +    [file join SQLite.Interop src win interop.h] \
          159  +    [file join System.Data.SQLite AssemblyInfo.cs] \
          160  +    [file join System.Data.SQLite AssemblyInfo.cs] \
          161  +    [file join System.Data.SQLite SQLite3.cs] \
          162  +    [file join System.Data.SQLite UnsafeNativeMethods.cs] \
          163  +    [file join System.Data.SQLite.Linq AssemblyInfo.cs] \
          164  +    [file join System.Data.SQLite.Linq AssemblyInfo.cs] \
          165  +    [file join test app.config] \
          166  +    [file join testlinq 2008 App.config] \
          167  +    [file join testlinq 2010 App.config]]
          168  +
          169  +for {set i 1} {$i <= [llength $fileNames]} {incr i} {
          170  +  set pattern [lindex $patterns [expr {$i - 1}]]
          171  +  set fileName [lindex $fileNames [expr {$i - 1}]]
          172  +  set constraint [string map [list / _ \\ _] $fileName]
          173  +  set fileName [file join $root_path $fileName]
          174  +
          175  +  if {![haveConstraint [appendArgs file_ $constraint]]} then {
          176  +    checkForFile $test_channel $fileName $constraint
          177  +  }
          178  +
          179  +  runTest {test [appendArgs version-1.5. $i] \
          180  +      [appendArgs "pattern {" $pattern "} in file \"" $fileName \"] -body {
          181  +    regexp -- $pattern [readFile $fileName]
          182  +  } -constraints [list eagle [appendArgs file_ $constraint]] -result {1}}
          183  +}
          184  +
          185  +###############################################################################
          186  +
          187  +unset -nocomplain constraint fileName pattern fileNames patterns i version
          188  +
          189  +###############################################################################
          190  +
          191  +unset -nocomplain testLinqExeFile testExeFile systemDataSQLiteLinqDllFile \
          192  +    systemDataSQLiteDllFile
          193  +
          194  +###############################################################################
          195  +
          196  +runSQLiteTestEpilogue
          197  +runTestEpilogue

Changes to www/build.wiki.

   107    107   
   108    108     <li>
   109    109       Make sure the version information is correct for System.Data.SQLite in the
   110    110       following files:
   111    111   
   112    112       <ul>
   113    113         <li>&lt;root&gt;\SQLite.nuspec</li>
          114  +      <li>&lt;root&gt;\SQLite.MSIL.nuspec</li>
   114    115         <li>&lt;root&gt;\SQLite.x86.nuspec</li>
   115    116         <li>&lt;root&gt;\SQLite.x64.nuspec</li>
   116    117         <li>&lt;root&gt;\Doc\Extra\dbfactorysupport.html</li>
   117    118         <li>&lt;root&gt;\Doc\Extra\welcome.html</li>
   118         -      <li>&lt;root&gt;\test\app.config</li>
   119         -      <li>&lt;root&gt;\testlinq\2008\App.config</li>
   120         -      <li>&lt;root&gt;\testlinq\2010\App.config</li>
   121    119         <li>&lt;root&gt;\SQLite.Designer\AssemblyInfo.cs</li>
   122    120         <li>&lt;root&gt;\SQLite.Interop\props\SQLite.Interop.vsprops</li>
   123    121         <li>&lt;root&gt;\SQLite.Interop\props\SQLite.Interop.props</li>
   124    122         <li>&lt;root&gt;\SQLite.Interop\src\win\interop.h</li>
   125    123         <li>&lt;root&gt;\System.Data.SQLite\AssemblyInfo.cs</li>
   126    124         <li>&lt;root&gt;\System.Data.SQLite\SQLite3.cs</li>
   127    125         <li>&lt;root&gt;\System.Data.SQLite\UnsafeNativeMethods.cs</li>
   128    126         <li>&lt;root&gt;\System.Data.SQLite.Linq\AssemblyInfo.cs</li>
          127  +      <li>&lt;root&gt;\test\app.config</li>
          128  +      <li>&lt;root&gt;\testlinq\2008\App.config</li>
          129  +      <li>&lt;root&gt;\testlinq\2010\App.config</li>
          130  +      <li>&lt;root&gt;\Tests\version.eagle</li>
   129    131       </ul>
   130    132   
   131    133       You'll need to update the INTEROP_BUILD_NUMBER, INTEROP_MANIFEST_VERSION,
   132    134       and INTEROP_RC_VERSION properties in the &quot;.vsprops&quot; and
   133    135       &quot;.props&quot; files, and the INTEROP_VERSION define in
   134    136       &quot;interop.h&quot;.  This version number should track the release
   135    137       versions of the System.Data.SQLite packages (i.e. [./news.wiki | 1.0.x]).