System.Data.SQLite

Check-in [ada723a97c]
Login

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

Overview
Comment:Update Eagle script library in externals to the latest code.
Downloads: Tarball | ZIP archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: ada723a97c30a37448c11ab54f29737de73626c7
User & Date: mistachkin 2015-10-02 19:21:57.345
Context
2015-10-06
00:40
Adjust naming for things related to the new xBestIndex idxFlags field for consistency. check-in: 72714fd613 user: mistachkin tags: trunk
2015-10-02
19:21
Update Eagle script library in externals to the latest code. check-in: ada723a97c user: mistachkin tags: trunk
18:05
Correct use of 'find.exe' by the batch tools. check-in: 03db10a564 user: mistachkin tags: trunk
Changes
Side-by-Side Diff Ignore Whitespace Patch
Changes to Externals/Eagle/lib/Eagle1.0/test.eagle.
︙
1327
1328
1329
1330
1331
1332
1333







1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350







1351
1352
1353
1354
1355
1356
1357

1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371








+
+
+
+
+
+
+

















+
+
+
+
+
+
+








  }

  proc returnInfoScript {} {
    return [info script]
  }

  proc runTestPrologue {} {
    #
    # NOTE: Verify that the global test path variable is available.
    #
    if {![info exists ::test_path]} then {
      error "cannot run test prologue, \"::test_path\" must be set"
    }

    #
    # HACK: We do not want to force every third-party test suite
    #       to come up with a half-baked solution to finding its
    #       own files.
    #
    if {![info exists ::no(prologue.eagle)] && ![info exists ::path]} then {
      set ::path [file normalize [file dirname [info script]]]
    }

    #
    # NOTE: Evaluate the standard test prologue in the context of
    #       the caller.
    #
    uplevel 1 [list source [file join $::test_path prologue.eagle]]
  }

  proc runTestEpilogue {} {
    #
    # NOTE: Verify that the global test path variable is available.
    #
    if {![info exists ::test_path]} then {
      error "cannot run test epilogue, \"::test_path\" must be set"
    }

    #
    # NOTE: Evaluate the standard test epilogue in the context of
    #       the caller.
    #
    uplevel 1 [list source [file join $::test_path epilogue.eagle]]

    #
︙
1566
1567
1568
1569
1570
1571
1572




1573







1574
1575
1576
1577
1578
1579
1580

1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590

1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604








+
+
+
+
-
+
+
+
+
+
+
+









    set array(time,$index) [clock seconds]
    set array(afters,$index) [llength [after info]]
    set array(variables,$index) [llength [info globals]]
    set array(commands,$index) [llength [info commands]]
    set array(procedures,$index) [llength [info procs]]
    set array(namespaces,$index) [llength [namespace children ::]]

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

    if {[info exists ::test_path]} then {
    set array(files,$index) [llength [getFiles $::test_path *]]
      set array(files,$index) [llength [getFiles $::test_path *]]
    } else {
      set array(files,$index) 0; # NOTE: Information not available.
    }

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

    set array(temporaryFiles,$index) [llength [getFiles [getTemporaryPath] *]]
    set array(channels,$index) [llength [file channels]]
    set array(aliases,$index) [llength [interp aliases]]
    set array(interpreters,$index) [llength [interp slaves]]
    set array(environment,$index) [llength [array names env]]
    set array(loaded,$index) [llength [info loaded]]
︙
1693
1694
1695
1696
1697
1698
1699














1700
1701
1702
1703
1704
1705
1706

1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744








+
+
+
+
+
+
+
+
+
+
+
+
+
+









    #
    # NOTE: Show what leaked, if anything.
    #
    set count 0; upvar 1 $statsVarName array

    foreach statistic $statistics {
      if {![info exists array($statistic,after)]} then {
        tputs $channel [appendArgs "==== \"" $fileName "\" MISSING " \
            $statistic " AFTER\n"]

        continue
      }

      if {![info exists array($statistic,before)]} then {
        tputs $channel [appendArgs "==== \"" $fileName "\" MISSING " \
            $statistic " BEFORE\n"]

        continue
      }

      if {$array($statistic,after) > $array($statistic,before)} then {
        lappend array(statistics,leaked) $statistic

        tputs $channel [appendArgs "==== \"" $fileName "\" LEAKED " \
            $statistic \n]

        if {[info exists array($statistic,before,list)]} then {
︙
2419
2420
2421
2422
2423
2424
2425

















2426
2427
2428
2429
2430
2431
2432

2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487








+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+








  proc getTestChannelOrDefault {} {
    if {[info exists ::test_channel]} then {
      return $::test_channel
    }

    return stdout; # TODO: Good default?
  }

  proc tryVerifyTestPath {} {
    #
    # NOTE: If the test path variable does not exist, the directory it
    #       points to does not exist (or is not really a directory), or
    #       it appears to be an empty directory, return false; otherwise,
    #       return true.
    #
    if {![info exists ::test_path] || \
        ![file exists $::test_path] || \
        ![file isdirectory $::test_path] || \
        [llength [getFiles $::test_path *]] == 0} then {
      return false
    }

    return true
  }

  proc checkForAndSetTestPath { whatIf {quiet false} } {
    #
    # NOTE: Everything in this procedure requires access to the file system;
    #       therefore, it cannot be used in a stock "safe" interpreter.
    #
    if {![interp issafe] && ![info exists ::test_path]} then {
︙
2460
2461
2462
2463
2464
2465
2466
2467

2468
2469

2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486

2487
2488

2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505

2506
2507

2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525

2526
2527

2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545

2546
2547

2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567

2568
2569

2570
2571
2572
2573
2574
2575
2576

2515
2516
2517
2518
2519
2520
2521

2522


2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539

2540


2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557

2558


2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576

2577


2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595

2596


2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616

2617


2618
2619
2620
2621
2622
2623
2624
2625








-
+
-
-
+
















-
+
-
-
+
















-
+
-
-
+

















-
+
-
-
+

















-
+
-
-
+



















-
+
-
-
+








          if {!$quiet} then {
            tqputs [getTestChannelOrDefault] [appendArgs \
                "---- checking #1 for Eagle test path at \"" \
                $::test_path \"...\n]
          }
        }

        if {[string length $base] > 0 && ($whatIf || \
        if {[string length $base] > 0 && \
            ![info exists ::test_path] || ![file exists $::test_path] || \
            ![file isdirectory $::test_path])} then {
            ($whatIf || ![tryVerifyTestPath])} then {
          #
          # NOTE: Try the source release directory structure again; this
          #       time, assume only the embedded script library was used.
          #       For this case, the final test path would be:
          #
          #           $base/Library/Tests
          #
          set ::test_path [file normalize [file join $base Library Tests]]

          if {!$quiet} then {
            tqputs [getTestChannelOrDefault] [appendArgs \
                "---- checking #2 for Eagle test path at \"" \
                $::test_path \"...\n]
          }
        }

        if {[string length $script] > 0 && ($whatIf || \
        if {[string length $script] > 0 && \
            ![info exists ::test_path] || ![file exists $::test_path] || \
            ![file isdirectory $::test_path])} then {
            ($whatIf || ![tryVerifyTestPath])} then {
          #
          # NOTE: Try for the test package directory.  For this case, the
          #       final test path would be:
          #
          #           $script/../Test1.0
          #
          set ::test_path [file normalize [file join [file dirname [file \
              dirname $script]] [appendArgs Test [info engine Version]]]]

          if {!$quiet} then {
            tqputs [getTestChannelOrDefault] [appendArgs \
                "---- checking #3 for Eagle test path at \"" \
                $::test_path \"...\n]
          }
        }

        if {[string length $base] > 0 && ($whatIf || \
        if {[string length $base] > 0 && \
            ![info exists ::test_path] || ![file exists $::test_path] || \
            ![file isdirectory $::test_path])} then {
            ($whatIf || ![tryVerifyTestPath])} then {
          #
          # NOTE: Try for the test package directory again; this time, use
          #       the base path and assume the source release directory
          #       structure.  For this case, the final test path would be:
          #
          #           $base/lib/Test1.0
          #
          set ::test_path [file normalize [file join $base lib [appendArgs \
              Test [info engine Version]]]]

          if {!$quiet} then {
            tqputs [getTestChannelOrDefault] [appendArgs \
                "---- checking #4 for Eagle test path at \"" \
                $::test_path \"...\n]
          }
        }

        if {[string length $base] > 0 && ($whatIf || \
        if {[string length $base] > 0 && \
            ![info exists ::test_path] || ![file exists $::test_path] || \
            ![file isdirectory $::test_path])} then {
            ($whatIf || ![tryVerifyTestPath])} then {
          #
          # NOTE: Try for the test package directory again; this time, use
          #       the base path.  For this case, the final test path would
          #       be:
          #
          #           $base/Test1.0
          #
          set ::test_path [file normalize [file join $base [appendArgs \
              Test [info engine Version]]]]

          if {!$quiet} then {
            tqputs [getTestChannelOrDefault] [appendArgs \
                "---- checking #5 for Eagle test path at \"" \
                $::test_path \"...\n]
          }
        }

        if {[string length $library] > 0 && ($whatIf || \
        if {[string length $library] > 0 && \
            ![info exists ::test_path] || ![file exists $::test_path] || \
            ![file isdirectory $::test_path])} then {
            ($whatIf || ![tryVerifyTestPath])} then {
          #
          # NOTE: This must be a binary release, no "Library" directory
          #       then.  Also, binary releases have an upper-case "Tests"
          #       directory name that originates from the "update.bat"
          #       tool.  This must match the casing used in "update.bat".
          #       For this case, the final test path would be:
          #
          #           $library/../../Tests
          #
          set ::test_path [file normalize [file join [file dirname [file \
              dirname $library]] Tests]]

          if {!$quiet} then {
            tqputs [getTestChannelOrDefault] [appendArgs \
                "---- checking #6 for Eagle test path at \"" \
                $::test_path \"...\n]
          }
        }

        if {[string length $base] > 0 && ($whatIf || \
        if {[string length $base] > 0 && \
            ![info exists ::test_path] || ![file exists $::test_path] || \
            ![file isdirectory $::test_path])} then {
            ($whatIf || ![tryVerifyTestPath])} then {
          #
          # NOTE: Fallback to using the base directory and checking for a
          #       "Tests" directory beneath it.  For this case, the final
          #       test path would be:
          #
          #           $base/Tests
          #
︙
2603
2604
2605
2606
2607
2608
2609
2610

2611
2612

2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629

2630
2631

2632
2633
2634
2635
2636
2637
2638

2652
2653
2654
2655
2656
2657
2658

2659


2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676

2677


2678
2679
2680
2681
2682
2683
2684
2685








-
+
-
-
+
















-
+
-
-
+








          if {!$quiet} then {
            tqputs [getTestChannelOrDefault] [appendArgs \
                "---- checking #1 for Tcl test path at \"" \
                $::test_path \"...\n]
          }
        }

        if {[string length $script] > 0 && ($whatIf || \
        if {[string length $script] > 0 && \
            ![info exists ::test_path] || ![file exists $::test_path] || \
            ![file isdirectory $::test_path])} then {
            ($whatIf || ![tryVerifyTestPath])} then {
          #
          # NOTE: Try for the test package directory.  For this case, the
          #       final test path would be:
          #
          #           $script/../Test1.0
          #
          set ::test_path [file normalize [file join [file dirname [file \
              dirname $script]] Test1.0]]

          if {!$quiet} then {
            tqputs [getTestChannelOrDefault] [appendArgs \
                "---- checking #2 for Tcl test path at \"" \
                $::test_path \"...\n]
          }
        }

        if {[string length $script] > 0 && ($whatIf || \
        if {[string length $script] > 0 && \
            ![info exists ::test_path] || ![file exists $::test_path] || \
            ![file isdirectory $::test_path])} then {
            ($whatIf || ![tryVerifyTestPath])} then {
          #
          # NOTE: This must be a binary release, no "Library" directory
          #       then.  Also, binary releases have an upper-case "Tests"
          #       directory name that originates from the "update.bat"
          #       tool.  This must match the casing used in "update.bat".
          #       For this case, the final test path would be:
          #
︙
3560
3561
3562
3563
3564
3565
3566
3567
3568



3569
3570
3571
3572
3573
3574
3575
3576
3577
3578
3579
3580
3581

3607
3608
3609
3610
3611
3612
3613


3614
3615
3616
3617
3618
3619
3620
3621
3622
3623
3624
3625
3626
3627
3628
3629








-
-
+
+
+














        execTestShell isRandomOrder isBreakOnLeak isStopOnFailure \
        isStopOnLeak isExitOnComplete returnInfoScript runTestPrologue \
        runTestEpilogue hookPuts unhookPuts runTest testDebugBreak \
        testArrayGet testShim tsource recordTestStatistics \
        reportTestStatistics formatList formatListAsDict pathToRegexp \
        inverseLsearchGlob removePathFromFileNames formatDecimal \
        clearTestPercent reportTestPercent runAllTests isTestSuiteRunning \
        getTestChannelOrDefault checkForAndSetTestPath configureTcltest \
        machineToPlatform getPassPercentage getSkipPercentage] false false
        getTestChannelOrDefault tryVerifyTestPath checkForAndSetTestPath \
        configureTcltest machineToPlatform getPassPercentage \
        getSkipPercentage] false false

    ###########################################################################
    ############################## END Tcl ONLY ###############################
    ###########################################################################
  }

  #
  # NOTE: Provide the Eagle test package to the interpreter.
  #
  package provide Eagle.Test \
    [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
}
Changes to Externals/Eagle/lib/Test1.0/all.eagle.
︙
46
47
48
49
50
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

46
47
48
49
50
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



83
84
85
86
87
88
89
90
91
92
93
94
95
96









+
+
+
+
+
+
+
+
+
+





-
-
+
+

-
-
-
+
+
+
+


-
-
-
+
+
+


-
-
-
+
+
+
+

+
+








  set test_all_path \
      [file normalize [file dirname [info script]]]
}

source [file join $test_all_path prologue.eagle]

if {![info exists test_path]} then {
  #
  # NOTE: Build a reusable expression that can be used to verify the
  #       candidate paths.  This is done to avoid duplication of this
  #       (quite complex) expression several times (just below).
  #
  set expr {![info exists test_path] || ![file exists $test_path] || \
      ![file isdirectory $test_path] || ([llength [info commands \
      glob]] > 0 && [llength [glob -directory $test_path -types {f r} \
      -nocomplain -- *]] == 0)}

  #
  # NOTE: Search for the "Library/Tests" -OR- "Tests" sub-directories
  #       within the sub-directory one level up and then two levels up
  #       from the sub-directory containing the "all.eagle" file from
  #       the test suite package.
  #
  set test_path [file normalize [file join [file dirname \
      $test_all_path] Library Tests]]
  set test_path [file normalize \
      [file join [file dirname $test_all_path] Library Tests]]

  if {![file exists $test_path] || ![file isdirectory $test_path]} then {
    set test_path [file normalize [file join [file dirname \
        [file dirname $test_all_path]] Library Tests]]
  if {[expr $expr]} then {
    set test_path [file normalize \
        [file join [file dirname [file dirname $test_all_path]] \
        Library Tests]]
  }

  if {![file exists $test_path] || ![file isdirectory $test_path]} then {
    set test_path [file normalize [file join [file dirname \
        $test_all_path] Tests]]
  if {[expr $expr]} then {
    set test_path [file normalize \
        [file join [file dirname $test_all_path] Tests]]
  }

  if {![file exists $test_path] || ![file isdirectory $test_path]} then {
    set test_path [file normalize [file join [file dirname \
        [file dirname $test_all_path]] Tests]]
  if {[expr $expr]} then {
    set test_path [file normalize \
        [file join [file dirname [file dirname $test_all_path]] \
        Tests]]
  }

  unset expr
}

set no(prologue.eagle) true
set no(epilogue.eagle) true

set test_time [time {
  runAllTests $test_channel $test_path \
︙
Changes to Externals/Eagle/lib/Test1.0/prologue.eagle.
︙
18
19
20
21
22
23
24
25
26
27



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47










48
49
50
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

18
19
20
21
22
23
24



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
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
83
84
85
86
87
88
89
90








-
-
-
+
+
+




















+
+
+
+
+
+
+
+
+
+





-
-
+
+

-
-
-
+
+
+
+


-
-
-
+
+
+


-
-
-
+
+
+
+

+
+








  if {[info level] > 0} then {
    error "cannot run, current level is not global"
  }

  #
  # NOTE: Make sure all the variables used by this prologue are unset.
  #
  unset -nocomplain pkg_dir pattern dummy directory name value exec encoding \
      host memory stack drive server database timeout user password percent \
      checkout timeStamp loaded
  unset -nocomplain expr pkg_dir pattern dummy directory name value \
      exec encoding host memory stack drive server database timeout \
      user password percent checkout timeStamp loaded

  #
  # NOTE: Indicate that the test suite is currently running.
  #
  if {![info exists test_suite_running] || !$test_suite_running} then {
    set test_suite_running true
  }

  #
  # NOTE: Set the location of the test suite package, if necessary.
  #
  if {![info exists test_all_path]} then {
    set test_all_path [file normalize [file dirname [info script]]]
  }

  #
  # NOTE: Set the location of the test suite, if necessary.
  #
  if {![info exists test_path]} then {
    #
    # NOTE: Build a reusable expression that can be used to verify the
    #       candidate paths.  This is done to avoid duplication of this
    #       (quite complex) expression several times (just below).
    #
    set expr {![info exists test_path] || ![file exists $test_path] || \
        ![file isdirectory $test_path] || ([llength [info commands \
        glob]] > 0 && [llength [glob -directory $test_path -types {f r} \
        -nocomplain -- *]] == 0)}

    #
    # NOTE: Search for the "Library/Tests" -OR- "Tests" sub-directories
    #       within the sub-directory one level up and then two levels up
    #       from the sub-directory containing the "all.eagle" file from
    #       the test suite package.
    #
    set test_path [file normalize [file join [file dirname \
        $test_all_path] Library Tests]]
    set test_path [file normalize \
        [file join [file dirname $test_all_path] Library Tests]]

    if {![file exists $test_path] || ![file isdirectory $test_path]} then {
      set test_path [file normalize [file join [file dirname \
          [file dirname $test_all_path]] Library Tests]]
    if {[expr $expr]} then {
      set test_path [file normalize \
          [file join [file dirname [file dirname $test_all_path]] \
          Library Tests]]
    }

    if {![file exists $test_path] || ![file isdirectory $test_path]} then {
      set test_path [file normalize [file join [file dirname \
          $test_all_path] Tests]]
    if {[expr $expr]} then {
      set test_path [file normalize \
          [file join [file dirname $test_all_path] Tests]]
    }

    if {![file exists $test_path] || ![file isdirectory $test_path]} then {
      set test_path [file normalize [file join [file dirname \
          [file dirname $test_all_path]] Tests]]
    if {[expr $expr]} then {
      set test_path [file normalize \
          [file join [file dirname [file dirname $test_all_path]] \
          Tests]]
    }

    unset expr
  }

  #
  # NOTE: Set the location of the test suite data, if necessary.
  #
  if {![info exists test_data_path]} then {
    set test_data_path [file join $test_path data]
︙