System.Data.SQLite

Check-in [22a734f9c5]
Login

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

Overview
Comment:Add design-time installer and testing support for Visual Studio 2012.
Downloads: Tarball | ZIP archive
Timelines: family | ancestors | descendants | both | vs2012
Files: files | file ages | folders
SHA1: 22a734f9c5bd24ca60b4452302de6c16b235187d
User & Date: mistachkin 2012-09-14 08:06:25.256
Context
2012-09-14
08:07
Fix missing constructor argument for the design-time installer. check-in: c5cb2d4419 user: mistachkin tags: vs2012
08:06
Add design-time installer and testing support for Visual Studio 2012. check-in: 22a734f9c5 user: mistachkin tags: vs2012
07:37
Add comment about INTEROP_LINKER_VERSION. check-in: 5a2eb7fddd user: mistachkin tags: vs2012
Changes
Side-by-Side Diff Ignore Whitespace Patch
Changes to Externals/Eagle/lib/Eagle1.0/vendor.eagle.
︙
158
159
160
161
162
163
164
165


166
167
168
169
170
171
172

158
159
160
161
162
163
164

165
166
167
168
169
170
171
172
173








-
+
+









    #
    # NOTE: Check for any overridden settings that may have been specified via
    #       the command line, etc.
    #
    checkForTestOverrides stdout [list binary_directory build_base_directory \
        build_directory common_directory connection_flags database_directory \
        datetime_format test_configuration test_year vendor_directory] false
        datetime_format test_configuration test_year test_year_netFx20 \
        test_year_netFx40 vendor_directory] false

    #
    # NOTE: This variable will contain the name of the directory containing the
    #       vendor-specific testing infrastructure.  If the variable does not
    #       already exist, create it; otherwise, it has been overridden and the
    #       existing value should be left intact.
    #
︙
Changes to Tests/common.eagle.
︙
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

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
91
92
93
94
95
96








-
-
-
+
+
+









+
+
+














+
-
+


-
+
+
+

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








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

    proc getBuildYear {} {
      #
      # NOTE: See if the "year" setting has been overridden by the user (e.g. on
      #       the command line).  This helps control exactly which set of
      #       binaries we are testing, those produced using the Visual Studio
      #       2005, 2008, or 2010 build systems.  To override this value via the
      #       command line, enter a command similar to one of the following (all
      #       on one line):
      #       2005, 2008, 2010, or 2012 build systems.  To override this value
      #       via the command line, enter a command similar to one of the
      #       following (all on one line):
      #
      #       EagleShell.exe -preInitialize "set test_year 2005"
      #         -file .\path\to\all.eagle
      #
      #       EagleShell.exe -preInitialize "set test_year 2008"
      #         -file .\path\to\all.eagle
      #
      #       EagleShell.exe -preInitialize "set test_year 2010"
      #         -file .\path\to\all.eagle
      #
      #       EagleShell.exe -preInitialize "set test_year 2012"
      #         -file .\path\to\all.eagle
      #
      #       EagleShell.exe -preInitialize "unset -nocomplain test_year"
      #         -file .\path\to\all.eagle
      #
      if {[info exists ::test_year] && [string length $::test_year] > 0} then {
        #
        # NOTE: Use the specified test year.  If this variable is not set, the
        #       default value will be based on whether or not Eagle has been
        #       compiled against the .NET Framework 2.0 or 4.0.
        #
        return $::test_year
      } else {
        #
        # NOTE: If Eagle has been compiled against the .NET Framework 4.0, use
        #       "2010" by default (we could use "2012" in that case as well) as
        #       "2010" as the test year; otherwise, use "2008" (we could use
        #       the test year; otherwise, use "2008" by default (we could use
        #       "2005" in that case as well).  If another major [incompatible]
        #       version of the .NET Framework is released, this check will have
        #       to be changed.
        #       to be changed.  The default test year to use for a particular
        #       .NET Framework version may be overridden using another global
        #       variable (i.e. test_year_netFxYZ).
        #
        return [expr {[haveConstraint imageRuntime40] ? "2010" : "2008"}]
        if {[haveConstraint imageRuntime40]} then {
          if {[info exists ::test_year_netFx40] && \
              [string length $::test_year_netFx40] > 0} then {
            #
            # NOTE: Use the specified test year for the .NET Framework 4.0.
            #
            return $::test_year_netFx40
          } else {
            #
            # NOTE: Use the default test year for the .NET Framework 4.0.
            #
            return 2010
          }
        } else {
          if {[info exists ::test_year_netFx20] && \
              [string length $::test_year_netFx20] > 0} then {
            #
            # NOTE: Use the specified test year for the .NET Framework 2.0.
            #
            return $::test_year_netFx20
          } else {
            #
            # NOTE: Use the default test year for the .NET Framework 2.0.
            #
            return 2008
          }
        }
      }
    }

    proc getBuildConfiguration {} {
      #
      # NOTE: See if the "configuration" setting has been overridden by the user
      #       (e.g. on the command line).  This helps control exactly which set
︙
Changes to Tests/installer.eagle.
︙
36
37
38
39
40
41
42



43
44
45
46
47
48
49
50
51



52
53
54
55
56
57
58

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








+
+
+









+
+
+








    Installer_Test_Vs2005.log]]

set testInstallVs2008LogFile [file nativename [file join $path \
    Installer_Test_Vs2008.log]]

set testInstallVs2010LogFile [file nativename [file join $path \
    Installer_Test_Vs2010.log]]

set testInstallVs2012LogFile [file nativename [file join $path \
    Installer_Test_Vs2012.log]]

set testUninstallVs2005LogFile [file nativename [file join $path \
    Uninstaller_Test_Vs2005.log]]

set testUninstallVs2008LogFile [file nativename [file join $path \
    Uninstaller_Test_Vs2008.log]]

set testUninstallVs2010LogFile [file nativename [file join $path \
    Uninstaller_Test_Vs2010.log]]

set testUninstallVs2012LogFile [file nativename [file join $path \
    Uninstaller_Test_Vs2012.log]]

#
# NOTE: Setup the test constraints specific to the tests in this file.
#
if {![haveConstraint [appendArgs file_ \
    [file tail $systemDataSQLiteDllFile]]]} then {
  checkForFile $test_channel $systemDataSQLiteDllFile
︙
78
79
80
81
82
83
84





85
86
87
88
89
90
91
92
93
94
95
96
97
98
99





100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117



118
119
120
121
122
123
124

84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130



131
132
133
134
135
136
137
138
139
140








+
+
+
+
+















+
+
+
+
+















-
-
-
+
+
+








  checkForFile $test_channel $testInstallVs2008LogFile
}

if {![haveConstraint [appendArgs file_ \
    [file tail $testInstallVs2010LogFile]]]} then {
  checkForFile $test_channel $testInstallVs2010LogFile
}

if {![haveConstraint [appendArgs file_ \
    [file tail $testInstallVs2012LogFile]]]} then {
  checkForFile $test_channel $testInstallVs2012LogFile
}

if {![haveConstraint [appendArgs file_ \
    [file tail $testUninstallVs2005LogFile]]]} then {
  checkForFile $test_channel $testUninstallVs2005LogFile
}

if {![haveConstraint [appendArgs file_ \
    [file tail $testUninstallVs2008LogFile]]]} then {
  checkForFile $test_channel $testUninstallVs2008LogFile
}

if {![haveConstraint [appendArgs file_ \
    [file tail $testUninstallVs2010LogFile]]]} then {
  checkForFile $test_channel $testUninstallVs2010LogFile
}

if {![haveConstraint [appendArgs file_ \
    [file tail $testUninstallVs2012LogFile]]]} then {
  checkForFile $test_channel $testUninstallVs2012LogFile
}

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

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

  cleanupFile $fileName
} -body {
  set output ""

  set code [catch {
    testClrExec $installerExeFile [list -eventflags Wait -stdout output \
        -success 0] -debugPriority Lowest -tracePriority MediumHigh \
        -noRuntimeVersion true -noCompact true -noNetFx40 true -noVs2008 true \
        -noVs2010 true -whatIf true -verbose true -confirm true -install true \
        -logFileName [appendArgs \" [file nativename $fileName] \"] \
        -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
        -noVs2010 true -noVs2012 true -whatIf true -verbose true -confirm true \
        -install true -logFileName [appendArgs \" [file nativename $fileName] \
        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
  } error]

  tlog "---- BEGIN STDOUT OUTPUT\n"
  tlog $output
  tlog "\n---- END STDOUT OUTPUT\n"

  set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
︙
144
145
146
147
148
149
150
151
152
153



154
155
156
157
158
159
160

160
161
162
163
164
165
166



167
168
169
170
171
172
173
174
175
176








-
-
-
+
+
+








} -body {
  set output ""

  set code [catch {
    testClrExec $installerExeFile [list -eventflags Wait -stdout output \
        -success 0] -debugPriority Lowest -tracePriority MediumHigh \
        -noRuntimeVersion true -noCompact true -noNetFx40 true -noVs2008 true \
        -noVs2010 true -whatIf true -verbose true -confirm true -install false \
        -logFileName [appendArgs \" [file nativename $fileName] \"] \
        -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
        -noVs2010 true -noVs2012 true -whatIf true -verbose true -confirm true \
        -install false -logFileName [appendArgs \" [file nativename $fileName] \
        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
  } error]

  tlog "---- BEGIN STDOUT OUTPUT\n"
  tlog $output
  tlog "\n---- END STDOUT OUTPUT\n"

  set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
︙
180
181
182
183
184
185
186
187
188
189



190
191
192
193
194
195
196

196
197
198
199
200
201
202



203
204
205
206
207
208
209
210
211
212








-
-
-
+
+
+








} -body {
  set output ""

  set code [catch {
    testClrExec $installerExeFile [list -eventflags Wait -stdout output \
        -success 0] -debugPriority Lowest -tracePriority MediumHigh \
        -noRuntimeVersion true -noCompact true -noNetFx40 true -noVs2005 true \
        -noVs2010 true -whatIf true -verbose true -confirm true -install true \
        -logFileName [appendArgs \" [file nativename $fileName] \"] \
        -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
        -noVs2010 true -noVs2012 true -whatIf true -verbose true -confirm true \
        -install true -logFileName [appendArgs \" [file nativename $fileName] \
        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
  } error]

  tlog "---- BEGIN STDOUT OUTPUT\n"
  tlog $output
  tlog "\n---- END STDOUT OUTPUT\n"

  set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
︙
216
217
218
219
220
221
222
223
224
225



226
227
228
229
230
231
232

232
233
234
235
236
237
238



239
240
241
242
243
244
245
246
247
248








-
-
-
+
+
+








} -body {
  set output ""

  set code [catch {
    testClrExec $installerExeFile [list -eventflags Wait -stdout output \
        -success 0] -debugPriority Lowest -tracePriority MediumHigh \
        -noRuntimeVersion true -noCompact true -noNetFx40 true -noVs2005 true \
        -noVs2010 true -whatIf true -verbose true -confirm true -install false \
        -logFileName [appendArgs \" [file nativename $fileName] \"] \
        -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
        -noVs2010 true -noVs2012 true -whatIf true -verbose true -confirm true \
        -install false -logFileName [appendArgs \" [file nativename $fileName] \
        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
  } error]

  tlog "---- BEGIN STDOUT OUTPUT\n"
  tlog $output
  tlog "\n---- END STDOUT OUTPUT\n"

  set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
︙
252
253
254
255
256
257
258
259
260
261



262
263
264
265
266
267
268

268
269
270
271
272
273
274



275
276
277
278
279
280
281
282
283
284








-
-
-
+
+
+








} -body {
  set output ""

  set code [catch {
    testClrExec $installerExeFile [list -eventflags Wait -stdout output \
        -success 0] -debugPriority Lowest -tracePriority MediumHigh \
        -noRuntimeVersion true -noCompact true -noNetFx20 true -noVs2005 true \
        -noVs2008 true -whatIf true -verbose true -confirm true -install true \
        -logFileName [appendArgs \" [file nativename $fileName] \"] \
        -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
        -noVs2008 true -noVs2012 true -whatIf true -verbose true -confirm true \
        -install true -logFileName [appendArgs \" [file nativename $fileName] \
        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
  } error]

  tlog "---- BEGIN STDOUT OUTPUT\n"
  tlog $output
  tlog "\n---- END STDOUT OUTPUT\n"

  set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
︙
288
289
290
291
292
293
294
295
296
297



298
299
300
301
302
303
304

304
305
306
307
308
309
310



311
312
313
314
315
316
317
318
319
320








-
-
-
+
+
+








} -body {
  set output ""

  set code [catch {
    testClrExec $installerExeFile [list -eventflags Wait -stdout output \
        -success 0] -debugPriority Lowest -tracePriority MediumHigh \
        -noRuntimeVersion true -noCompact true -noNetFx20 true -noVs2005 true \
        -noVs2008 true -whatIf true -verbose true -confirm true -install false \
        -logFileName [appendArgs \" [file nativename $fileName] \"] \
        -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
        -noVs2008 true -noVs2012 true -whatIf true -verbose true -confirm true \
        -install false -logFileName [appendArgs \" [file nativename $fileName] \
        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
  } error]

  tlog "---- BEGIN STDOUT OUTPUT\n"
  tlog $output
  tlog "\n---- END STDOUT OUTPUT\n"

  set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
︙
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
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406


407
408
409
410
411
412
413
414
415
416








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








} -constraints {eagle administrator visualStudio2010\
System.Data.SQLite.dll_v4.0.30319 file_Installer.exe\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.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]]]

  cleanupFile $fileName
} -body {
  set output ""

  set code [catch {
    testClrExec $installerExeFile [list -eventflags Wait -stdout output \
        -success 0] -debugPriority Lowest -tracePriority MediumHigh \
        -noRuntimeVersion true -noCompact true -noNetFx20 true -noVs2005 true \
        -noVs2008 true -noVs2010 true -whatIf true -verbose true -confirm true \
        -install true -logFileName [appendArgs \" [file nativename $fileName] \
        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
  } error]

  tlog "---- BEGIN STDOUT OUTPUT\n"
  tlog $output
  tlog "\n---- END STDOUT OUTPUT\n"

  set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]

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

  unset -nocomplain wow64 code output error fileName
} -constraints {eagle administrator visualStudio2012\
System.Data.SQLite.dll_v4.0.30319 file_Installer.exe\
file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.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]]]

  cleanupFile $fileName
} -body {
  set output ""

  set code [catch {
    testClrExec $installerExeFile [list -eventflags Wait -stdout output \
        -success 0] -debugPriority Lowest -tracePriority MediumHigh \
        -noRuntimeVersion true -noCompact true -noNetFx20 true -noVs2005 true \
        -noVs2008 true -noVs2010 true -whatIf true -verbose true -confirm true \
        -install false -logFileName [appendArgs \" [file nativename $fileName] \
        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
  } error]

  tlog "---- BEGIN STDOUT OUTPUT\n"
  tlog $output
  tlog "\n---- END STDOUT OUTPUT\n"

  set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]

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

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

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

unset -nocomplain testUninstallVs2010LogFile testUninstallVs2008LogFile \
    testUninstallVs2005LogFile testInstallVs2010LogFile \
unset -nocomplain testUninstallVs2012LogFile testUninstallVs2010LogFile \
    testUninstallVs2008LogFile testUninstallVs2005LogFile \
    testInstallVs2012LogFile testInstallVs2010LogFile \
    testInstallVs2008LogFile testInstallVs2005LogFile installerExeFile \
    systemDataSQLiteLinqDllFile systemDataSQLiteDllFile

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

runSQLiteTestEpilogue
runTestEpilogue
Changes to Tests/tkt-2ce0870fad.eagle.
︙
40
41
42
43
44
45
46


47
48
49
50
51
52
53

40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55








+
+









    #
    # NOTE: Keep track of whether or not the global test year and configuration
    #       variables already exist in the primary application domain before the
    #       test.  If not, we will need to unset them after the test.
    #
    set hadTestYear {[info exists ::test_year]}
    set hadTestYearNetFx20 {[info exists ::test_year_netFx20]}
    set hadTestYearNetFx40 {[info exists ::test_year_netFx40]}
    set hadTestConfiguration {[info exists ::test_configuration]}
  }] -body {
    set appDomainId(3) [object invoke AppDomain.CurrentDomain Id]

    package require Eagle.Library
    package require Eagle.Test
    package require System.Data.SQLite.Test
︙
62
63
64
65
66
67
68








69
70
71
72
73
74
75

64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85








+
+
+
+
+
+
+
+








        $appDomainId($i) == $appDomainId(3)}] [setupDb $fileName]
  } -cleanup {
    cleanupDb $fileName

    if {!$hadTestConfiguration} then {
      unset -nocomplain ::test_configuration
    }

    if {!$hadTestYearNetFx40} then {
      unset -nocomplain ::test_year_netFx40
    }

    if {!$hadTestYearNetFx20} then {
      unset -nocomplain ::test_year_netFx20
    }

    if {!$hadTestYear} then {
      unset -nocomplain ::test_year
    }

    #
    # NOTE: If this is the primary application domain, skip unsetting the
︙
Changes to tools/install/Installer.cs.
︙
1776
1777
1778
1779
1780
1781
1782

1783
1784
1785
1786
1787
1788
1789

1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790








+








                bool noDesktop,
                bool noCompact,
                bool noNetFx20,
                bool noNetFx40,
                bool noVs2005,
                bool noVs2008,
                bool noVs2010,
                bool noVs2012,
                bool noTrace,
                bool noConsole,
                bool noLog,
                bool throwOnMissing,
                bool whatIf,
                bool debug,
                bool verbose,
︙
1807
1808
1809
1810
1811
1812
1813

1814
1815
1816
1817
1818
1819
1820

1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822








+








                this.noDesktop = noDesktop;
                this.noCompact = noCompact;
                this.noNetFx20 = noNetFx20;
                this.noNetFx40 = noNetFx40;
                this.noVs2005 = noVs2005;
                this.noVs2008 = noVs2008;
                this.noVs2010 = noVs2010;
                this.noVs2012 = noVs2012;
                this.noTrace = noTrace;
                this.noConsole = noConsole;
                this.noLog = noLog;
                this.throwOnMissing = throwOnMissing;
                this.whatIf = whatIf;
                this.debug = debug;
                this.verbose = verbose;
︙
2463
2464
2465
2466
2467
2468
2469





















2470
2471
2472
2473
2474
2475
2476

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








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








                                    return false;

                                continue;
                            }

                            configuration.noVs2010 = (bool)value;
                        }
                        else if (MatchOption(newArg, "noVs2012"))
                        {
                            bool? value = ParseBoolean(text);

                            if (value == null)
                            {
                                error = TraceOps.DebugAndTrace(
                                    TracePriority.Lowest, debugCallback,
                                    traceCallback, String.Format(
                                    "Invalid {0} boolean value: {1}",
                                    ForDisplay(arg), ForDisplay(text)),
                                    traceCategory);

                                if (strict)
                                    return false;

                                continue;
                            }

                            configuration.noVs2012 = (bool)value;
                        }
                        else if (MatchOption(newArg, "strict"))
                        {
                            bool? value = ParseBoolean(text);

                            if (value == null)
                            {
                                error = TraceOps.DebugAndTrace(
︙
2860
2861
2862
2863
2864
2865
2866

2867
2868
2869
2870
2871
2872
2873

2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897








+








                        //       practice as the CLR v4.0 can load and use an
                        //       assembly compiled with the CLR v2.0; however,
                        //       since this project offers both configurations,
                        //       we currently disallow this mismatch.
                        //
                        configuration.noNetFx40 = true;
                        configuration.noVs2010 = true;
                        configuration.noVs2012 = true;

                        TraceOps.DebugAndTrace(TracePriority.Medium,
                            debugCallback, traceCallback, String.Format(
                            "Assembly is compiled for the .NET Framework {0}, " +
                            "support for .NET Framework {1} is now disabled.",
                            CLRv2ImageRuntimeVersion, CLRv4ImageRuntimeVersion),
                            traceCategory);
︙
3020
3021
3022
3023
3024
3025
3026




3027
3028
3029
3030
3031
3032
3033

3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061








+
+
+
+








                    traceCallback(String.Format(NameAndValueFormat,
                        "NoVs2008", ForDisplay(noVs2008)),
                        traceCategory);

                    traceCallback(String.Format(NameAndValueFormat,
                        "NoVs2010", ForDisplay(noVs2010)),
                        traceCategory);

                    traceCallback(String.Format(NameAndValueFormat,
                        "NoVs2012", ForDisplay(noVs2012)),
                        traceCategory);

                    traceCallback(String.Format(NameAndValueFormat,
                        "NoTrace", ForDisplay(noTrace)),
                        traceCategory);

                    traceCallback(String.Format(NameAndValueFormat,
                        "NoConsole", ForDisplay(noConsole)),
︙
3260
3261
3262
3263
3264
3265
3266









3267
3268
3269
3270
3271
3272
3273

3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310








+
+
+
+
+
+
+
+
+









            private bool noVs2010;
            public bool NoVs2010
            {
                get { return noVs2010; }
                set { noVs2010 = value; }
            }

            ///////////////////////////////////////////////////////////////////

            private bool noVs2012;
            public bool NoVs2012
            {
                get { return noVs2012; }
                set { noVs2012 = value; }
            }

            ///////////////////////////////////////////////////////////////////

            private bool noTrace;
            public bool NoTrace
            {
                get { return noTrace; }
︙
4212
4213
4214
4215
4216
4217
4218
4219

4220
4221
4222

4223
4224
4225




4226
4227
4228
4229
4230
4231
4232

4249
4250
4251
4252
4253
4254
4255

4256
4257
4258

4259
4260
4261

4262
4263
4264
4265
4266
4267
4268
4269
4270
4271
4272








-
+


-
+


-
+
+
+
+








                vsList.RootKey = rootKey;

            if (vsList.Versions == null)
            {
                vsList.Versions = new VersionList();

                if ((configuration == null) || !configuration.NoVs2005)
                    vsList.Versions.Add(new Version(8, 0)); // Visual Studio 2005
                    vsList.Versions.Add(new Version(8, 0)); // 2005

                if ((configuration == null) || !configuration.NoVs2008)
                    vsList.Versions.Add(new Version(9, 0)); // Visual Studio 2008
                    vsList.Versions.Add(new Version(9, 0)); // 2008

                if ((configuration == null) || !configuration.NoVs2010)
                    vsList.Versions.Add(new Version(10, 0));// Visual Studio 2010
                    vsList.Versions.Add(new Version(10, 0));// 2010

                if ((configuration == null) || !configuration.NoVs2012)
                    vsList.Versions.Add(new Version(11, 0));// 2012
            }
        }

        ///////////////////////////////////////////////////////////////////////

        private static bool HaveVsVersion(
            MockRegistryKey rootKey,
︙