System.Data.SQLite
Check-in [7ac032e0ad]
Not logged in

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

Overview
Comment:Skip running the design-time installer tests when running tests on WoW64.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: 7ac032e0ad613c0bdae952c365b42c02871f009d
User & Date: mistachkin 2014-01-24 18:04:56
Context
2014-01-28
22:32
Add 'single' data type to the mappings returned by GetSchema. check-in: 0a225477e0 user: mistachkin tags: trunk
2014-01-24
18:04
Skip running the design-time installer tests when running tests on WoW64. check-in: 7ac032e0ad user: mistachkin tags: trunk
17:37
Fix typo from the previous commit. check-in: bcc7595e57 user: mistachkin tags: trunk
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

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

1895
1896
1897
1898
1899
1900
1901

1902
1903
1904

1905
1906
1907
1908
1909
1910

1911
1912
1913
1914
1915
1916
1917
      #       appropriate error message.
      #
      # TODO: Add support for auto-loading packages here in the future?
      #
      return -code error "invalid command name \"$name\""
    }
 

    #
    # TODO: Revise or remove this procedure when full [namespace]
    #       support has been added.

    #
    proc ::tcl::tm::UnknownHandler { original name args } {
      #
      # NOTE: Do nothing except call the original handler.
      #
      uplevel 1 $original [::linsert $args 0 $name]

    }
 
    proc tclPkgUnknown { name args } {
      #
      # NOTE: Force a rescan of "pkgIndex" files.  This must be done in
      #       the global scope so that the special global variable 'dir'
      #       set by the package index loading subsystem can be accessed.







>
|
<
|
>
|
|
|
|
|
|
>







1895
1896
1897
1898
1899
1900
1901
1902
1903

1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
      #       appropriate error message.
      #
      # TODO: Add support for auto-loading packages here in the future?
      #
      return -code error "invalid command name \"$name\""
    }
 
    namespace eval ::tcl::tm {
      #

      # NOTE: Ideally, this procedure should be created in the "::tcl::tm"
      #       namespace.
      #
      proc ::tcl::tm::UnknownHandler { original name args } {
        #
        # NOTE: Do nothing except call the original handler.
        #
        uplevel 1 $original [::linsert $args 0 $name]
      }
    }
 
    proc tclPkgUnknown { name args } {
      #
      # NOTE: Force a rescan of "pkgIndex" files.  This must be done in
      #       the global scope so that the special global variable 'dir'
      #       set by the package index loading subsystem can be accessed.

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

255
256
257
258
259
260
261
262
263
264
265
266











267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300

301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320

321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336



337
338
339
340
341
342
343
...
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
...
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
...
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
...
773
774
775
776
777
778
779

780
781
782
783
784
785
786
787
788
....
1960
1961
1962
1963
1964
1965
1966

1967
1968
1969
1970
1971
1972
1973
....
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284

2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
    #
    if {$milliseconds <= 0} then {
      unset -nocomplain ::test_suite_running
      error "number of milliseconds must be greater than zero"
    }

    #
    # HACK: Different techniques are used here to calculate the performance of
    #       the machine for Tcl and Eagle.
    #
    if {!$legacy && [isEagle]} then {
      #











      # NOTE: Save the current background error handler for later restoration
      #       and then reset the current background error handler to nothing.
      #
      set bgerror [interp bgerror {}]
      interp bgerror {} ""

      try {
        #
        # NOTE: Save the current [after] flags for later restoration and then
        #       reset them to process events immediately.
        #
        set flags [after flags]
        after flags =Immediate

        try {
          set code [catch {
            #
            # NOTE: First, make sure that the [after] event queue for the
            #       interpreter is totally empty.
            #
            catch {eval after cancel [after info]}

            #
            # NOTE: Schedule the event to cancel the script we are about to
            #       evaluate, capturing the name so we can cancel it later, if
            #       necessary.
            #
            set event [after $milliseconds [list interp cancel]]

            #
            # HACK: There is the potential for a "race condition" here.  If the
            #       specified number of milliseconds elapses before (or after)
            #       entering the [catch] script block (below) then the resulting
            #       script cancellation error will not be caught and we will be

            #       unable to return the correct result to the caller.
            #
            set before [info cmdcount]
            catch {time {nop} -1}; # uses the [time] internal busy loop.
            set after [info cmdcount]

            #
            # HACK: Mono has a bug that results in excessive trailing zeros
            #       here (Mono bug #655780).
            #
            if {[isMono]} then {
              expr {double(($after - $before) / ($milliseconds / 1000.0))}
            } else {
              expr {($after - $before) / ($milliseconds / 1000.0)}
            }
          } result]

          #
          # NOTE: If we failed to calculate the number of commands-per-second
          #       due to some subtle race condition [as explained above], return

          #       an obviously invalid result instead.
          #
          if {$code == 0} then {
            return $result
          } else {
            return 0
          }
        } finally {
          if {[info exists event]} then {
            catch {after cancel $event}
          }

          after flags =$flags
        }
      } finally {
        interp bgerror {} $bgerror



      }
    } else {
      #
      # NOTE: Record the initial Tcl command count.
      #
      set before [info cmdcount]

................................................................................
    }
  }
 
  proc sourceIfValid { type fileName } {
    if {[string length $fileName] > 0} then {
      if {[file exists $fileName]} then {
        tputs $::test_channel [appendArgs \
            "---- evaluating $type file: \"" $fileName \"\n]

        if {[catch {uplevel 1 [list source $fileName]} error]} then {
          tputs $::test_channel [appendArgs \
              "---- error during $type file: " $error \n]

          #
          # NOTE: The error has been logged, now re-throw it.
          #
          unset -nocomplain ::test_suite_running
          error $error $::errorInfo $::errorCode
        }
      } else {
        tputs $::test_channel [appendArgs \
            "---- skipped $type file: \"" $fileName \
            "\", it does not exist\n"]
      }
    }
  }
 
  proc processTestArguments { varName args } {
    #
................................................................................
      #       test log file having been setup and we do not want to just
      #       lose this output).
      #
      if {[lsearch -exact $options $name] != -1} then {
        set array($name) $value

        tqputs $::test_channel [appendArgs \
            "---- overrode test option \"" $name "\" with value \"" $value \
            \"\n]
      } else {
        tqputs $::test_channel [appendArgs \
            "---- unknown test option \"" $name "\" with value \"" $value \
            "\" ignored\n"]
      }
    }

    #
    # NOTE: Now, attempt to flush the test log queue, if available.
    #
    tlog ""
................................................................................
      } else {
        #
        # HACK: Mono does not currently support calling the String.Format
        #       overload that takes a variable number of arguments via
        #       reflection (Mono bug #636939).  Also, strip any leading
        #       minus signs for cleanliness.
        #
        return [hash normal sha256 [appendArgs [info host] [string trimleft \
            [pid] -] [string trimleft [info tid] -] [string trimleft \
            [clock now] -] [string trimleft [clock clicks] -] [string trimleft \
            [expr $expr] -]]]
      }
    } else {
      #
      # NOTE: Generate a random number using [expr] and then convert it
      #       to hexadecimal.
      #
      binary scan [binary format d* [expr {rand()}]] w* random
................................................................................
      #
      # NOTE: Build the final result with the [format] command, converting
      #       all the pieces to hexadecimal (except the host, which is
      #       already hexadecimal).
      #
      set pid [pid]; set seconds [clock seconds]; set clicks [clock clicks]


      return [appendArgs $host [format [appendArgs % [getLengthModifier $pid] \
          X% [getLengthModifier $seconds] X% [getLengthModifier $clicks] X% \
          [getLengthModifier $random] X] $pid $seconds $clicks $random]]
    }
  }
 
  proc getTestLogId {} {
    return [expr {[info exists ::test_log_id] ? \
        [append result . $::test_log_id] : ""}]
................................................................................
      #         the test suite:
      #
      #         debug procedureflags test +ScriptLocation
      #         debug procedureflags runTest +ScriptLocation
      #
      # NOTE: Setup the necessary compatibility shims for the test suite.
      #

      setupTestShims true [expr {![isTestSuiteRunning]}]

      #
      # NOTE: Fake having the tcltest package.
      #
      package provide tcltest 2.2.10; # Tcl 8.4
    } else {
................................................................................
      return 0; # no tests were run, etc.
    }
 
    proc cleanupThread { thread {timeout 2000} } {
      if {[$thread IsAlive]} then {
        if {[catch {$thread Interrupt} error]} then {
          tputs $::test_channel [appendArgs \
              "---- failed to interrupt test thread \"" $thread "\": " $error \
              \n]
        } else {
          tputs $::test_channel [appendArgs "---- test thread \"" $thread \
              "\" interrupted\n"]
        }

        if {[$thread IsAlive]} then {
          if {[catch {$thread Join $timeout} error]} then {
            tputs $::test_channel [appendArgs \
                "---- failed to join test thread \"" $thread "\": " $error \n]

          } elseif {$error} then {
            tputs $::test_channel [appendArgs "---- joined test thread \"" \
                $thread \"\n]
          } else {
            tputs $::test_channel [appendArgs \
                "---- timeout joining test thread \"" $thread " (" $timeout \
                " milliseconds)\"\n"]
          }

          if {[$thread IsAlive]} then {
            if {[catch {$thread Abort} error]} then {
              tputs $::test_channel [appendArgs \
                  "---- failed to abort test thread \"" $thread "\": " $error \
                  \n]
            } else {
              tputs $::test_channel [appendArgs "---- test thread \"" $thread \
                  "\" aborted\n"]
            }

            if {[$thread IsAlive]} then {
              tputs $::test_channel [appendArgs "---- test thread \"" $thread \
                  "\" appears to be a zombie\n"]
            } else {
              return true; # aborted?
            }
          } else {
            return true; # joined?
          }
        } else {







|
|



>
>
>
>
>
>
>
>
>
>
>
|
|
|
|
|

|
|
|
|
|
|
|

|
|
|
|
|
|
|

|
|
|
|
|
|

|
|
|
|
|
>
|
|
|
|
|

|
|
|
|
|
|
|
|
|
|

|
<
<
>
|
|
|
|
|
|
|
|
|
|
|

|
|
|
|
>
>
>







 







|



|









|







 







|
|


|
|







 







|
|
|
|







 







>
|
|







 







>







 







|
|








|
>





|
|





|
|

|
|



|
|







255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330


331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
...
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
...
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
...
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
...
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
....
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
....
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
    #
    if {$milliseconds <= 0} then {
      unset -nocomplain ::test_suite_running
      error "number of milliseconds must be greater than zero"
    }

    #
    # HACK: Different techniques are used to calculate the performance of the
    #       machine for Tcl and Eagle.
    #
    if {!$legacy && [isEagle]} then {
      #
      # NOTE: Save the current readiness limit for later restoration and then
      #       set the current readiness limit to always check the interpreter
      #       readiness (default).  If this was not done, the [interp cancel]
      #       command in this procedure may have no effect, which could cause
      #       this procedure to run forever.
      #
      set readylimit [interp readylimit {}]
      interp readylimit {} 0

      try {
        #
        # NOTE: Save the current background error handler for later restoration
        #       and then reset the current background error handler to nothing.
        #
        set bgerror [interp bgerror {}]
        interp bgerror {} ""

        try {
          #
          # NOTE: Save the current [after] flags for later restoration and then
          #       reset them to process events immediately.
          #
          set flags [after flags]
          after flags =Immediate

          try {
            set code [catch {
              #
              # NOTE: First, make sure that the [after] event queue for the
              #       interpreter is totally empty.
              #
              catch {eval after cancel [after info]}

              #
              # NOTE: Schedule the event to cancel the script we are about to
              #       evaluate, capturing the name so we can cancel it later,
              #       if necessary.
              #
              set event [after $milliseconds [list interp cancel]]

              #
              # HACK: There is a potential "race condition" here.  If the
              #       specified number of milliseconds elapses before (or
              #       after) entering the [catch] script block (below) then
              #       the resulting script cancellation error will not be
              #       caught and we will be unable to return the correct
              #       result to the caller.
              #
              set before [info cmdcount]
              catch {time {nop} -1}; # uses the [time] internal busy loop.
              set after [info cmdcount]

              #
              # HACK: Mono has a bug that results in excessive trailing zeros
              #       here (Mono bug #655780).
              #
              if {[isMono]} then {
                expr {double(($after - $before) / ($milliseconds / 1000.0))}
              } else {
                expr {($after - $before) / ($milliseconds / 1000.0)}
              }
            } result]

            #


            # NOTE: If we failed due to the race condition explained above,
            #       return an obviously invalid result instead.
            #
            if {$code == 0} then {
              return $result
            } else {
              return 0
            }
          } finally {
            if {[info exists event]} then {
              catch {after cancel $event}
            }

            after flags =$flags
          }
        } finally {
          interp bgerror {} $bgerror
        }
      } finally {
        interp readylimit {} $readylimit
      }
    } else {
      #
      # NOTE: Record the initial Tcl command count.
      #
      set before [info cmdcount]

................................................................................
    }
  }
 
  proc sourceIfValid { type fileName } {
    if {[string length $fileName] > 0} then {
      if {[file exists $fileName]} then {
        tputs $::test_channel [appendArgs \
            "---- evaluating " $type " file: \"" $fileName \"\n]

        if {[catch {uplevel 1 [list source $fileName]} error]} then {
          tputs $::test_channel [appendArgs \
              "---- error during " $type " file: " $error \n]

          #
          # NOTE: The error has been logged, now re-throw it.
          #
          unset -nocomplain ::test_suite_running
          error $error $::errorInfo $::errorCode
        }
      } else {
        tputs $::test_channel [appendArgs \
            "---- skipped " $type " file: \"" $fileName \
            "\", it does not exist\n"]
      }
    }
  }
 
  proc processTestArguments { varName args } {
    #
................................................................................
      #       test log file having been setup and we do not want to just
      #       lose this output).
      #
      if {[lsearch -exact $options $name] != -1} then {
        set array($name) $value

        tqputs $::test_channel [appendArgs \
            "---- overrode test option \"" $name "\" with value \"" \
            $value \"\n]
      } else {
        tqputs $::test_channel [appendArgs \
            "---- unknown test option \"" $name "\" with value \"" \
            $value "\" ignored\n"]
      }
    }

    #
    # NOTE: Now, attempt to flush the test log queue, if available.
    #
    tlog ""
................................................................................
      } else {
        #
        # HACK: Mono does not currently support calling the String.Format
        #       overload that takes a variable number of arguments via
        #       reflection (Mono bug #636939).  Also, strip any leading
        #       minus signs for cleanliness.
        #
        return [hash normal sha256 [appendArgs [info host] [string \
            trimleft [pid] -] [string trimleft [info tid] -] [string \
            trimleft [clock now] -] [string trimleft [clock clicks] -] \
            [string trimleft [expr $expr] -]]]
      }
    } else {
      #
      # NOTE: Generate a random number using [expr] and then convert it
      #       to hexadecimal.
      #
      binary scan [binary format d* [expr {rand()}]] w* random
................................................................................
      #
      # NOTE: Build the final result with the [format] command, converting
      #       all the pieces to hexadecimal (except the host, which is
      #       already hexadecimal).
      #
      set pid [pid]; set seconds [clock seconds]; set clicks [clock clicks]

      return [appendArgs \
          $host [format [appendArgs % [getLengthModifier $pid] X% \
          [getLengthModifier $seconds] X% [getLengthModifier $clicks] X% \
          [getLengthModifier $random] X] $pid $seconds $clicks $random]]
    }
  }
 
  proc getTestLogId {} {
    return [expr {[info exists ::test_log_id] ? \
        [append result . $::test_log_id] : ""}]
................................................................................
      #         the test suite:
      #
      #         debug procedureflags test +ScriptLocation
      #         debug procedureflags runTest +ScriptLocation
      #
      # NOTE: Setup the necessary compatibility shims for the test suite.
      #
      namespace eval ::tcltest {}; # HACK: Force namespace creation now.
      setupTestShims true [expr {![isTestSuiteRunning]}]

      #
      # NOTE: Fake having the tcltest package.
      #
      package provide tcltest 2.2.10; # Tcl 8.4
    } else {
................................................................................
      return 0; # no tests were run, etc.
    }
 
    proc cleanupThread { thread {timeout 2000} } {
      if {[$thread IsAlive]} then {
        if {[catch {$thread Interrupt} error]} then {
          tputs $::test_channel [appendArgs \
              "---- failed to interrupt test thread \"" $thread "\": " \
              $error \n]
        } else {
          tputs $::test_channel [appendArgs "---- test thread \"" $thread \
              "\" interrupted\n"]
        }

        if {[$thread IsAlive]} then {
          if {[catch {$thread Join $timeout} error]} then {
            tputs $::test_channel [appendArgs \
                "---- failed to join test thread \"" $thread "\": " \
                $error \n]
          } elseif {$error} then {
            tputs $::test_channel [appendArgs "---- joined test thread \"" \
                $thread \"\n]
          } else {
            tputs $::test_channel [appendArgs \
                "---- timeout joining test thread \"" $thread " (" \
                $timeout " milliseconds)\"\n"]
          }

          if {[$thread IsAlive]} then {
            if {[catch {$thread Abort} error]} then {
              tputs $::test_channel [appendArgs \
                  "---- failed to abort test thread \"" $thread "\": " \
                  $error \n]
            } else {
              tputs $::test_channel [appendArgs "---- test thread \"" \
                  $thread "\" aborted\n"]
            }

            if {[$thread IsAlive]} then {
              tputs $::test_channel [appendArgs "---- test thread \"" \
                  $thread "\" appears to be a zombie\n"]
            } else {
              return true; # aborted?
            }
          } else {
            return true; # joined?
          }
        } else {

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

233
234
235
236
237
238
239








240
241
242
243
244
245
    #
    # HACK: Prevent the Eagle core test suite infrastructure from checking
    #       test constraints that are time-consuming and/or most likely to
    #       be superfluous to third-party test suites (i.e. those that are
    #       not testing the Eagle core library itself).
    #
    set no(core) 1








  }
}
 
###############################################################################
############################### END VENDOR CODE ###############################
###############################################################################







>
>
>
>
>
>
>
>






233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
    #
    # HACK: Prevent the Eagle core test suite infrastructure from checking
    #       test constraints that are time-consuming and/or most likely to
    #       be superfluous to third-party test suites (i.e. those that are
    #       not testing the Eagle core library itself).
    #
    set no(core) 1

    #
    # HACK: Prevent the Eagle core test suite infrastructure from doing
    #       things that require beta 29 (or later) binaries.  This section
    #       should be removed when the Eagle beta 29 binaries are checked
    #       into the System.Data.SQLite repository.
    #
    set no(bogoCops) 1; # NOTE: Lack of [interp readylimit].
  }
}
 
###############################################################################
############################### END VENDOR CODE ###############################
###############################################################################

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

51
52
53
54
55
56
57


















58
59
60
61
62
63
64
...
828
829
830
831
832
833
834


























835
836
837
838
839
840
841
....
1094
1095
1096
1097
1098
1099
1100

1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112








1113
1114
1115
1116
1117
1118
1119
....
2180
2181
2182
2183
2184
2185
2186

















2187
2188
2189
2190
2191
2192
2193
....
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
    #
    return [list \
        [list 2 0] [list 2 2] [list 2 4] [list 2 6] [list 2 8] [list 2 10] \
        [list 2 11] [list 2 12] [list 3 0] [list 3 1] [list 3 2] [list 3 3] \
        [list 3 4] [list 3 5] [list 3 6]]
  }
 


















  #
  # NOTE: This procedure should return non-zero if the native Tcl shell may
  #       be executed by the test suite infrastructure outside the context
  #       of any specific tests.  The specific tests themselves must make
  #       use of their own constraints to prevent execution of the native
  #       Tcl shell.
  #
................................................................................
      addConstraint [appendArgs command. $name]

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


























 
  proc checkForTestExec { channel } {
    tputs $channel "---- checking for test use of \"exec\" command... "

    if {![info exists ::no(testExec)]} then {
      addConstraint testExec

................................................................................
      tputs $channel no\n
    }
  }
 
  proc checkForTip285 { channel } {
    tputs $channel "---- checking for TIP #285... "


    #
    # NOTE: Is the interpreter TIP #285 ready?
    #
    catch {interp cancel} error

    if {$error eq "eval canceled"} then {
      addConstraint tip285

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








  }
 
  proc checkForTip405 { channel } {
    tputs $channel "---- checking for TIP #405... "

    #
    # NOTE: Does the interpreter have TIP #405 (i.e. [lmap])?
................................................................................
          #
          return
        }
      }

      tputs $channel no\n
    }

















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

      if {[catch {object invoke System.Threading.Thread.CurrentThread \
              GetApartmentState} apartmentState] == 0 && \
          $apartmentState eq "STA"} then {
................................................................................
    ###########################################################################

    #
    # NOTE: We need several of our test constraint related commands in the
    #       global namespace.
    #
    exportAndImportPackageCommands [namespace current] [list \
        getKnownCompileOptions getKnownMonoVersions canExecTclShell \
        canExecFossil checkForTestSuiteFiles checkForPlatform \
        checkForWindowsVersion checkForScriptLibrary checkForVariable \
        checkForTclOptions checkForWindowsCommandProcessor checkForFossil \
        checkForEagle checkForSymbols checkForLogFile checkForGaruda \
        checkForShell checkForDebug checkForTk checkForVersion \
        checkForCommand checkForTestExec checkForTestMachine \
        checkForTestPlatform checkForTestConfiguration checkForTestSuffix \
        checkForFile checkForPathFile checkForNativeCode checkForTip127 \
        checkForTip194 checkForTip241 checkForTip285 checkForTip405 \
        checkForTip426 checkForTiming checkForPerformance checkForBigLists \
        checkForStackIntensive checkForInteractive checkForInteractiveCommand \
        checkForUserInteraction checkForNetwork checkForCompileOption \
        checkForKnownCompileOptions] false false

    ###########################################################################
    ############################## END Tcl ONLY ###############################
    ###########################################################################
  }
 
  #
  # NOTE: Provide the Eagle test constraints package to the interpreter.
  #
  package provide Eagle.Test.Constraints \
    [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
}
 







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







 







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







 







>
|
|
|
|

|
|

|
<
<
|
>
>
>
>
>
>
>
>







 







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







 







|
|




|
|
|
|
|
|
|
|













51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
...
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
....
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154


1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
....
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
....
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
    #
    return [list \
        [list 2 0] [list 2 2] [list 2 4] [list 2 6] [list 2 8] [list 2 10] \
        [list 2 11] [list 2 12] [list 3 0] [list 3 1] [list 3 2] [list 3 3] \
        [list 3 4] [list 3 5] [list 3 6]]
  }
 
  proc alwaysFullInterpReady {} {
    #
    # NOTE: The [interp readylimit] sub-command is only in Eagle.
    #
    if {![isEagle]} then {
      return true
    }

    #
    # NOTE: If this Eagle version lacks [interp readylimit] -OR- it has
    #       the default value (i.e. it always fully checks readiness),
    #       return true.
    #
    return [expr {
      [catch {interp readylimit {}} readylimit] != 0 || $readylimit == 0
    }]
  }
 
  #
  # NOTE: This procedure should return non-zero if the native Tcl shell may
  #       be executed by the test suite infrastructure outside the context
  #       of any specific tests.  The specific tests themselves must make
  #       use of their own constraints to prevent execution of the native
  #       Tcl shell.
  #
................................................................................
      addConstraint [appendArgs command. $name]

      tputs $channel yes\n
    } else {
      tputs $channel no\n
    }
  }
 
  proc checkForNamespaces { channel } {
    tputs $channel "---- checking for namespace support... "

    if {[isEagle]} then {
      if {[catch {object invoke -flags +NonPublic Interpreter.GetActive \
              AreNamespacesEnabled} enabled] == 0 && \
          $enabled} then {
        #
        # NOTE: Yes, it appears that it is available.
        #
        addConstraint namespaces

        tputs $channel yes\n
      } else {
        tputs $channel no\n
      }
    } else {
      #
      # NOTE: All supported versions of native Tcl have namespaces.
      #
      addConstraint namespaces

      tputs $channel yes\n
    }
  }
 
  proc checkForTestExec { channel } {
    tputs $channel "---- checking for test use of \"exec\" command... "

    if {![info exists ::no(testExec)]} then {
      addConstraint testExec

................................................................................
      tputs $channel no\n
    }
  }
 
  proc checkForTip285 { channel } {
    tputs $channel "---- checking for TIP #285... "

    if {[alwaysFullInterpReady]} then {
      #
      # NOTE: Is the interpreter TIP #285 ready?
      #
      catch {interp cancel} error

      if {$error eq "eval canceled"} then {
        addConstraint tip285

        tputs $channel yes\n



        #
        # NOTE: We are done here, return now.
        #
        return
      }
    }

    tputs $channel no\n
  }
 
  proc checkForTip405 { channel } {
    tputs $channel "---- checking for TIP #405... "

    #
    # NOTE: Does the interpreter have TIP #405 (i.e. [lmap])?
................................................................................
          #
          return
        }
      }

      tputs $channel no\n
    }
 
    proc checkForWoW64 { channel } {
      tputs $channel "---- checking for WoW64... "

      if {[info exists ::eagle_platform(wow64)] && \
          [string is boolean -strict $::eagle_platform(wow64)] && \
          $::eagle_platform(wow64)} then {
        #
        # NOTE: Yes, we are running in a WoW64 process.
        #
        addConstraint wow64

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

      if {[catch {object invoke System.Threading.Thread.CurrentThread \
              GetApartmentState} apartmentState] == 0 && \
          $apartmentState eq "STA"} then {
................................................................................
    ###########################################################################

    #
    # NOTE: We need several of our test constraint related commands in the
    #       global namespace.
    #
    exportAndImportPackageCommands [namespace current] [list \
        getKnownCompileOptions getKnownMonoVersions alwaysFullInterpReady \
        canExecTclShell canExecFossil checkForTestSuiteFiles checkForPlatform \
        checkForWindowsVersion checkForScriptLibrary checkForVariable \
        checkForTclOptions checkForWindowsCommandProcessor checkForFossil \
        checkForEagle checkForSymbols checkForLogFile checkForGaruda \
        checkForShell checkForDebug checkForTk checkForVersion \
        checkForCommand checkForNamespaces checkForTestExec \
        checkForTestMachine checkForTestPlatform checkForTestConfiguration \
        checkForTestSuffix checkForFile checkForPathFile checkForNativeCode \
        checkForTip127 checkForTip194 checkForTip241 checkForTip285 \
        checkForTip405 checkForTip426 checkForTiming checkForPerformance \
        checkForBigLists checkForStackIntensive checkForInteractive \
        checkForInteractiveCommand checkForUserInteraction checkForNetwork \
        checkForCompileOption checkForKnownCompileOptions] false false

    ###########################################################################
    ############################## END Tcl ONLY ###############################
    ###########################################################################
  }
 
  #
  # NOTE: Provide the Eagle test constraints package to the interpreter.
  #
  package provide Eagle.Test.Constraints \
    [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
}
 

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

1754
1755
1756
1757
1758
1759
1760










1761
1762
1763
1764
1765
1766
1767
....
2334
2335
2336
2337
2338
2339
2340







2341
2342
2343
2344
2345
2346
2347
....
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
      #
      # NOTE: For tests "object-13.1.*", "object-13.2.*", and
      #       "winForms-*.*".
      #
      checkForWindowsForms $test_channel
    }











    #
    # NOTE: Are we running in an STA thread?
    #
    if {![info exists no(staThread)]} then {
      #
      # NOTE: For tests "xaml-1.*".
      #
................................................................................
    checkForCommand $test_channel tcl
  }

  if {![info exists no(xmlCommand)]} then {
    checkForCommand $test_channel xml
  }








  #
  # NOTE: Check for various features that were added through
  #       the TIP process.
  #
  if {![info exists no(tip127)]} then {
    checkForTip127 $test_channel
  }
................................................................................
  if {![info exists no(core)] && ![info exists no(network)]} then {
    checkForNetwork $test_channel $test_host $test_timeout
  }

  #
  # NOTE: Figure out the approximate relative performance of this machine.
  #
  if {[haveConstraint performance]} then {
    tputs $test_channel [appendArgs \
        "---- checking for baseline BogoCops (commands-per-second)... "]

    if {![info exists test_base_cops]} then {
      #
      # NOTE: The expected performance numbers for all the
      #       performance tests will be calibrated based on







>
>
>
>
>
>
>
>
>
>







 







>
>
>
>
>
>
>







 







|







1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
....
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
....
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
      #
      # NOTE: For tests "object-13.1.*", "object-13.2.*", and
      #       "winForms-*.*".
      #
      checkForWindowsForms $test_channel
    }

    #
    # NOTE: Are we running in a WoW64 process?
    #
    if {![info exists no(wow64)]} then {
      #
      # NOTE: This is not currently used by any tests.
      #
      checkForWoW64 $test_channel
    }

    #
    # NOTE: Are we running in an STA thread?
    #
    if {![info exists no(staThread)]} then {
      #
      # NOTE: For tests "xaml-1.*".
      #
................................................................................
    checkForCommand $test_channel tcl
  }

  if {![info exists no(xmlCommand)]} then {
    checkForCommand $test_channel xml
  }

  #
  # NOTE: Has namespace detection support been disabled?
  #
  if {![info exists no(namespaces)]} then {
    checkForNamespaces $test_channel
  }

  #
  # NOTE: Check for various features that were added through
  #       the TIP process.
  #
  if {![info exists no(tip127)]} then {
    checkForTip127 $test_channel
  }
................................................................................
  if {![info exists no(core)] && ![info exists no(network)]} then {
    checkForNetwork $test_channel $test_host $test_timeout
  }

  #
  # NOTE: Figure out the approximate relative performance of this machine.
  #
  if {![info exists no(bogoCops)] && [haveConstraint performance]} then {
    tputs $test_channel [appendArgs \
        "---- checking for baseline BogoCops (commands-per-second)... "]

    if {![info exists test_base_cops]} then {
      #
      # NOTE: The expected performance numbers for all the
      #       performance tests will be calibrated based on

Changes to SQLite.NET.targets.

108
109
110
111
112
113
114
115

116
117
118
119
120
121
122
...
140
141
142
143
144
145
146
147

148
149
150
151
152
153
154
              PropertyName="DirForCloneAndMark32BitOnly" />
    </GetFrameworkSDKPath>

    <Copy SourceFiles="$(TargetPath)"
          DestinationFiles="$(TargetDir)$(TargetName)32$(TargetExt)" />

    <Copy SourceFiles="$(TargetPath).config"
          DestinationFiles="$(TargetDir)$(TargetName)32$(TargetExt).config" />


    <Exec Condition="'$(DirForCloneAndMark32BitOnly)' != '' And
                     HasTrailingSlash('$(DirForCloneAndMark32BitOnly)') And
                     Exists('$(DirForCloneAndMark32BitOnly)bin\CorFlags.exe')"
          Command="&quot;$(DirForCloneAndMark32BitOnly)bin\CorFlags.exe&quot; &quot;$(TargetDir)$(TargetName)32$(TargetExt)&quot; /32BIT+ /Force" />

    <Exec Condition="'$(DirForCloneAndMark32BitOnly)' != '' And
................................................................................
          Condition="'$(CloneAndMark32BitOnlySdkToolsTargetName32)' != 'false'"
          Inputs="$(TargetPath)"
          Outputs="$(TargetPath).CloneAndMark32BitOnly.done">
    <Copy SourceFiles="$(TargetPath)"
          DestinationFiles="$(TargetDir)$(TargetName)32$(TargetExt)" />

    <Copy SourceFiles="$(TargetPath).config"
          DestinationFiles="$(TargetDir)$(TargetName)32$(TargetExt).config" />


    <Exec Condition="'$(TargetFrameworkSDKToolsDirectory)' != '' And
                     HasTrailingSlash('$(TargetFrameworkSDKToolsDirectory)') And
                     Exists('$(TargetFrameworkSDKToolsDirectory)CorFlags.exe')"
          Command="&quot;$(TargetFrameworkSDKToolsDirectory)CorFlags.exe&quot; &quot;$(TargetDir)$(TargetName)32$(TargetExt)&quot; /32BIT+ /Force" />

    <Exec Condition="'$(TargetFrameworkSDKToolsDirectory)' != '' And







|
>







 







|
>







108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
...
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
              PropertyName="DirForCloneAndMark32BitOnly" />
    </GetFrameworkSDKPath>

    <Copy SourceFiles="$(TargetPath)"
          DestinationFiles="$(TargetDir)$(TargetName)32$(TargetExt)" />

    <Copy SourceFiles="$(TargetPath).config"
          DestinationFiles="$(TargetDir)$(TargetName)32$(TargetExt).config"
          Condition="Exists('$(TargetPath).config')" />

    <Exec Condition="'$(DirForCloneAndMark32BitOnly)' != '' And
                     HasTrailingSlash('$(DirForCloneAndMark32BitOnly)') And
                     Exists('$(DirForCloneAndMark32BitOnly)bin\CorFlags.exe')"
          Command="&quot;$(DirForCloneAndMark32BitOnly)bin\CorFlags.exe&quot; &quot;$(TargetDir)$(TargetName)32$(TargetExt)&quot; /32BIT+ /Force" />

    <Exec Condition="'$(DirForCloneAndMark32BitOnly)' != '' And
................................................................................
          Condition="'$(CloneAndMark32BitOnlySdkToolsTargetName32)' != 'false'"
          Inputs="$(TargetPath)"
          Outputs="$(TargetPath).CloneAndMark32BitOnly.done">
    <Copy SourceFiles="$(TargetPath)"
          DestinationFiles="$(TargetDir)$(TargetName)32$(TargetExt)" />

    <Copy SourceFiles="$(TargetPath).config"
          DestinationFiles="$(TargetDir)$(TargetName)32$(TargetExt).config"
          Condition="Exists('$(TargetPath).config')" />

    <Exec Condition="'$(TargetFrameworkSDKToolsDirectory)' != '' And
                     HasTrailingSlash('$(TargetFrameworkSDKToolsDirectory)') And
                     Exists('$(TargetFrameworkSDKToolsDirectory)CorFlags.exe')"
          Command="&quot;$(TargetFrameworkSDKToolsDirectory)CorFlags.exe&quot; &quot;$(TargetDir)$(TargetName)32$(TargetExt)&quot; /32BIT+ /Force" />

    <Exec Condition="'$(TargetFrameworkSDKToolsDirectory)' != '' And

Changes to Tests/common.eagle.

301
302
303
304
305
306
307
308
309
310


311
312
313
314
315
316
317
        #       should not be reached.
        #
        return ""
      }
    }
 
    proc isRunningWoW64 {} {
      return [expr {
        [info exists ::eagle_platform(wow64)] && $::eagle_platform(wow64)
      }]


    }
 
    proc isMixedModeAssembly { fileName {varName ""} } {
      #
      # NOTE: First, make sure the test suite infrastructure is allowed to
      #       use the [exec] command.
      #







|
|
|
>
>







301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
        #       should not be reached.
        #
        return ""
      }
    }
 
    proc isRunningWoW64 {} {
      #
      # NOTE: For now, just use the existing test constraint for detecting
      #       a WoW64 process.
      #
      return [haveConstraint wow64]
    }
 
    proc isMixedModeAssembly { fileName {varName ""} } {
      #
      # NOTE: First, make sure the test suite infrastructure is allowed to
      #       use the [exec] command.
      #

Changes to Tests/installer.eagle.

172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
...
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
...
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
...
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
...
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
...
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
...
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
...
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
...
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
...
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testInstallVs2005LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints {eagle administrator buildYear.2005 visualStudio2005\
System.Data.SQLite.dll_v2.0.50727 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_SQLite.Designer.dll\
file_Installer_Test_Vs2005.log} -result {0 True}}

###############################################################################

runTest {test installer-1.2 {uninstaller tool / Visual Studio 2005} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testUninstallVs2005LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testUninstallVs2005LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints {eagle administrator buildYear.2005 visualStudio2005\
System.Data.SQLite.dll_v2.0.50727 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_SQLite.Designer.dll\
file_Uninstaller_Test_Vs2005.log} -result {0 True}}

###############################################################################

runTest {test installer-1.3 {installer tool / Visual Studio 2008} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testInstallVs2008LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testInstallVs2008LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints {eagle administrator buildYear.2008 visualStudio2008\
System.Data.SQLite.dll_v2.0.50727 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_SQLite.Designer.dll file_Installer_Test_Vs2008.log} -result {0 True}}

###############################################################################

runTest {test installer-1.4 {uninstaller tool / Visual Studio 2008} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testUninstallVs2008LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testUninstallVs2008LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints {eagle administrator buildYear.2008 visualStudio2008\
System.Data.SQLite.dll_v2.0.50727 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_SQLite.Designer.dll file_Uninstaller_Test_Vs2008.log} -result {0 True}}

###############################################################################

runTest {test installer-1.5 {installer tool / Visual Studio 2010} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testInstallVs2010LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testInstallVs2010LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints {eagle administrator buildYear.2010 visualStudio2010\
System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_System.Data.SQLite.EF6.dll file_SQLite.Designer.dll\
file_Installer_Test_Vs2010.log} -result {0 True}}

###############################################################################

runTest {test installer-1.6 {uninstaller tool / Visual Studio 2010} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testUninstallVs2010LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testUninstallVs2010LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints {eagle administrator buildYear.2010 visualStudio2010\
System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_System.Data.SQLite.EF6.dll file_SQLite.Designer.dll\
file_Uninstaller_Test_Vs2010.log} -result {0 True}}

###############################################################################

runTest {test installer-1.7 {installer tool / Visual Studio 2012} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testInstallVs2012LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testInstallVs2012LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints {eagle administrator buildYear.2012 visualStudio2012\
System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_System.Data.SQLite.EF6.dll file_SQLite.Designer.dll\
file_Installer_Test_Vs2012.log} -result {0 True}}

###############################################################################

runTest {test installer-1.8 {uninstaller tool / Visual Studio 2012} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testUninstallVs2012LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testUninstallVs2012LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints {eagle administrator buildYear.2012 visualStudio2012\
System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_System.Data.SQLite.EF6.dll file_SQLite.Designer.dll\
file_Uninstaller_Test_Vs2012.log} -result {0 True}}

###############################################################################

runTest {test installer-1.9 {installer tool / Visual Studio 2013} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testInstallVs2013LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testInstallVs2013LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints {eagle administrator buildYear.2013 visualStudio2013\
System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_System.Data.SQLite.EF6.dll file_SQLite.Designer.dll\
file_Installer_Test_Vs2013.log} -result {0 True}}

###############################################################################

runTest {test installer-1.10 {uninstaller tool / Visual Studio 2013} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testUninstallVs2013LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testUninstallVs2013LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints {eagle administrator buildYear.2013 visualStudio2013\
System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_System.Data.SQLite.EF6.dll file_SQLite.Designer.dll\
file_Uninstaller_Test_Vs2013.log} -result {0 True}}

###############################################################################

unset -nocomplain testUninstallVs2013LogFile testUninstallVs2012LogFile \
    testUninstallVs2010LogFile testUninstallVs2008LogFile \
    testUninstallVs2005LogFile testInstallVs2013LogFile \
    testInstallVs2012LogFile testInstallVs2010LogFile \







|
|

|







 







|
|

|







 







|
|

|







 







|
|

|







 







|
|


|







 







|
|


|







 







|
|


|







 







|
|


|







 







|
|


|







 







|
|


|







172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
...
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
...
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
...
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
...
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
...
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
...
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
...
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
...
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
...
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testInstallVs2005LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints [fixConstraints {eagle administrator !wow64 buildYear.2005\
visualStudio2005 System.Data.SQLite.dll_v2.0.50727 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_SQLite.Designer.dll\
file_Installer_Test_Vs2005.log}] -result {0 True}}

###############################################################################

runTest {test installer-1.2 {uninstaller tool / Visual Studio 2005} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testUninstallVs2005LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testUninstallVs2005LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints [fixConstraints {eagle administrator !wow64 buildYear.2005\
visualStudio2005 System.Data.SQLite.dll_v2.0.50727 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_SQLite.Designer.dll\
file_Uninstaller_Test_Vs2005.log}] -result {0 True}}

###############################################################################

runTest {test installer-1.3 {installer tool / Visual Studio 2008} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testInstallVs2008LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testInstallVs2008LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints [fixConstraints {eagle administrator !wow64 buildYear.2008\
visualStudio2008 System.Data.SQLite.dll_v2.0.50727 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_SQLite.Designer.dll file_Installer_Test_Vs2008.log}] -result {0 True}}

###############################################################################

runTest {test installer-1.4 {uninstaller tool / Visual Studio 2008} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testUninstallVs2008LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testUninstallVs2008LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints [fixConstraints {eagle administrator !wow64 buildYear.2008\
visualStudio2008 System.Data.SQLite.dll_v2.0.50727 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_SQLite.Designer.dll file_Uninstaller_Test_Vs2008.log}] -result {0 True}}

###############################################################################

runTest {test installer-1.5 {installer tool / Visual Studio 2010} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testInstallVs2010LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testInstallVs2010LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints [fixConstraints {eagle administrator !wow64 buildYear.2010\
visualStudio2010 System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_System.Data.SQLite.EF6.dll file_SQLite.Designer.dll\
file_Installer_Test_Vs2010.log}] -result {0 True}}

###############################################################################

runTest {test installer-1.6 {uninstaller tool / Visual Studio 2010} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testUninstallVs2010LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testUninstallVs2010LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints [fixConstraints {eagle administrator !wow64 buildYear.2010\
visualStudio2010 System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_System.Data.SQLite.EF6.dll file_SQLite.Designer.dll\
file_Uninstaller_Test_Vs2010.log}] -result {0 True}}

###############################################################################

runTest {test installer-1.7 {installer tool / Visual Studio 2012} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testInstallVs2012LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testInstallVs2012LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints [fixConstraints {eagle administrator !wow64 buildYear.2012\
visualStudio2012 System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_System.Data.SQLite.EF6.dll file_SQLite.Designer.dll\
file_Installer_Test_Vs2012.log}] -result {0 True}}

###############################################################################

runTest {test installer-1.8 {uninstaller tool / Visual Studio 2012} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testUninstallVs2012LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testUninstallVs2012LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints [fixConstraints {eagle administrator !wow64 buildYear.2012\
visualStudio2012 System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_System.Data.SQLite.EF6.dll file_SQLite.Designer.dll\
file_Uninstaller_Test_Vs2012.log}] -result {0 True}}

###############################################################################

runTest {test installer-1.9 {installer tool / Visual Studio 2013} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testInstallVs2013LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testInstallVs2013LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints [fixConstraints {eagle administrator !wow64 buildYear.2013\
visualStudio2013 System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_System.Data.SQLite.EF6.dll file_SQLite.Designer.dll\
file_Installer_Test_Vs2013.log}] -result {0 True}}

###############################################################################

runTest {test installer-1.10 {uninstaller tool / Visual Studio 2013} -setup {
  set fileName [file join [getTemporaryPath] [file tail [string map [list \
      .log [appendArgs _ [pid] .log]] $testUninstallVs2013LogFile]]]

................................................................................

  list $code [expr {$code == 0 ? [string equal -nocase [readFile $fileName] \
      [subst -nobackslashes [readFile $testUninstallVs2013LogFile]]] : $error}]
} -cleanup {
  cleanupFile $fileName

  unset -nocomplain wow64 is64 code output error fileName
} -constraints [fixConstraints {eagle administrator !wow64 buildYear.2013\
visualStudio2013 System.Data.SQLite.dll_v4.0.30319 file_Installer.exe testExec\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
file_System.Data.SQLite.EF6.dll file_SQLite.Designer.dll\
file_Uninstaller_Test_Vs2013.log}] -result {0 True}}

###############################################################################

unset -nocomplain testUninstallVs2013LogFile testUninstallVs2012LogFile \
    testUninstallVs2010LogFile testUninstallVs2008LogFile \
    testUninstallVs2005LogFile testInstallVs2013LogFile \
    testInstallVs2012LogFile testInstallVs2010LogFile \

Changes to tools/install/Installer.2005.csproj.

57
58
59
60
61
62
63

64
65
66
67
68
69
70
71
72
73
  <Import Project="$(SQLiteNetDir)\System.Data.SQLite\System.Data.SQLite.Properties.targets" />
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <PropertyGroup>
    <BuildDependsOn>
      $(BuildDependsOn);
      EmbedExeManifest;
      StrongNameSignFrameworkTargetPath;

    </BuildDependsOn>
  </PropertyGroup>
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>







>










57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
  <Import Project="$(SQLiteNetDir)\System.Data.SQLite\System.Data.SQLite.Properties.targets" />
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <PropertyGroup>
    <BuildDependsOn>
      $(BuildDependsOn);
      EmbedExeManifest;
      StrongNameSignFrameworkTargetPath;
      CloneAndMark32BitOnlyFrameworkTargetName32;
    </BuildDependsOn>
  </PropertyGroup>
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

Changes to tools/install/Installer.2008.csproj.

58
59
60
61
62
63
64

65
66
67
68
69
70
71
72
73
74
  <Import Project="$(SQLiteNetDir)\System.Data.SQLite\System.Data.SQLite.Properties.targets" />
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <PropertyGroup>
    <BuildDependsOn>
      $(BuildDependsOn);
      EmbedExeManifest;
      StrongNameSignFrameworkTargetPath;

    </BuildDependsOn>
  </PropertyGroup>
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>







>










58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
  <Import Project="$(SQLiteNetDir)\System.Data.SQLite\System.Data.SQLite.Properties.targets" />
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <PropertyGroup>
    <BuildDependsOn>
      $(BuildDependsOn);
      EmbedExeManifest;
      StrongNameSignFrameworkTargetPath;
      CloneAndMark32BitOnlyFrameworkTargetName32;
    </BuildDependsOn>
  </PropertyGroup>
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

Changes to tools/install/Installer.2010.csproj.

60
61
62
63
64
65
66


67
68
69
70
71
72
73
74
75
76
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <PropertyGroup>
    <BuildDependsOn>
      $(BuildDependsOn);
      EmbedExeManifest;
      StrongNameSignFrameworkTargetPath;
      StrongNameSignSdkToolsTargetPath;


    </BuildDependsOn>
  </PropertyGroup>
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>







>
>










60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <PropertyGroup>
    <BuildDependsOn>
      $(BuildDependsOn);
      EmbedExeManifest;
      StrongNameSignFrameworkTargetPath;
      StrongNameSignSdkToolsTargetPath;
      CloneAndMark32BitOnlyFrameworkTargetName32;
      CloneAndMark32BitOnlySdkToolsTargetName32;
    </BuildDependsOn>
  </PropertyGroup>
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

Changes to tools/install/Installer.2012.csproj.

58
59
60
61
62
63
64


65
66
67
68
69
70
71
72
73
74
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <PropertyGroup>
    <BuildDependsOn>
      $(BuildDependsOn);
      EmbedExeManifest;
      StrongNameSignFrameworkTargetPath;
      StrongNameSignSdkToolsTargetPath;


    </BuildDependsOn>
  </PropertyGroup>
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>







>
>










58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <PropertyGroup>
    <BuildDependsOn>
      $(BuildDependsOn);
      EmbedExeManifest;
      StrongNameSignFrameworkTargetPath;
      StrongNameSignSdkToolsTargetPath;
      CloneAndMark32BitOnlyFrameworkTargetName32;
      CloneAndMark32BitOnlySdkToolsTargetName32;
    </BuildDependsOn>
  </PropertyGroup>
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

Changes to tools/install/Installer.2013.csproj.

58
59
60
61
62
63
64


65
66
67
68
69
70
71
72
73
74
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <PropertyGroup>
    <BuildDependsOn>
      $(BuildDependsOn);
      EmbedExeManifest;
      StrongNameSignFrameworkTargetPath;
      StrongNameSignSdkToolsTargetPath;


    </BuildDependsOn>
  </PropertyGroup>
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>







>
>










58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <PropertyGroup>
    <BuildDependsOn>
      $(BuildDependsOn);
      EmbedExeManifest;
      StrongNameSignFrameworkTargetPath;
      StrongNameSignSdkToolsTargetPath;
      CloneAndMark32BitOnlyFrameworkTargetName32;
      CloneAndMark32BitOnlySdkToolsTargetName32;
    </BuildDependsOn>
  </PropertyGroup>
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>