System.Data.SQLite
Check-in [22a734f9c5]
Not logged in

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 | SQL archive
Timelines: family | ancestors | descendants | both | vs2012
Files: files | file ages | folders
SHA1: 22a734f9c5bd24ca60b4452302de6c16b235187d
User & Date: mistachkin 2012-09-14 08:06:25
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
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

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

   158    158   
   159    159       #
   160    160       # NOTE: Check for any overridden settings that may have been specified via
   161    161       #       the command line, etc.
   162    162       #
   163    163       checkForTestOverrides stdout [list binary_directory build_base_directory \
   164    164           build_directory common_directory connection_flags database_directory \
   165         -        datetime_format test_configuration test_year vendor_directory] false
          165  +        datetime_format test_configuration test_year test_year_netFx20 \
          166  +        test_year_netFx40 vendor_directory] false
   166    167   
   167    168       #
   168    169       # NOTE: This variable will contain the name of the directory containing the
   169    170       #       vendor-specific testing infrastructure.  If the variable does not
   170    171       #       already exist, create it; otherwise, it has been overridden and the
   171    172       #       existing value should be left intact.
   172    173       #

Changes to Tests/common.eagle.

    19     19       ###########################################################################
    20     20   
    21     21       proc getBuildYear {} {
    22     22         #
    23     23         # NOTE: See if the "year" setting has been overridden by the user (e.g. on
    24     24         #       the command line).  This helps control exactly which set of
    25     25         #       binaries we are testing, those produced using the Visual Studio
    26         -      #       2005, 2008, or 2010 build systems.  To override this value via the
    27         -      #       command line, enter a command similar to one of the following (all
    28         -      #       on one line):
           26  +      #       2005, 2008, 2010, or 2012 build systems.  To override this value
           27  +      #       via the command line, enter a command similar to one of the
           28  +      #       following (all on one line):
    29     29         #
    30     30         #       EagleShell.exe -preInitialize "set test_year 2005"
    31     31         #         -file .\path\to\all.eagle
    32     32         #
    33     33         #       EagleShell.exe -preInitialize "set test_year 2008"
    34     34         #         -file .\path\to\all.eagle
    35     35         #
    36     36         #       EagleShell.exe -preInitialize "set test_year 2010"
    37     37         #         -file .\path\to\all.eagle
           38  +      #
           39  +      #       EagleShell.exe -preInitialize "set test_year 2012"
           40  +      #         -file .\path\to\all.eagle
    38     41         #
    39     42         #       EagleShell.exe -preInitialize "unset -nocomplain test_year"
    40     43         #         -file .\path\to\all.eagle
    41     44         #
    42     45         if {[info exists ::test_year] && [string length $::test_year] > 0} then {
    43     46           #
    44     47           # NOTE: Use the specified test year.  If this variable is not set, the
................................................................................
    45     48           #       default value will be based on whether or not Eagle has been
    46     49           #       compiled against the .NET Framework 2.0 or 4.0.
    47     50           #
    48     51           return $::test_year
    49     52         } else {
    50     53           #
    51     54           # NOTE: If Eagle has been compiled against the .NET Framework 4.0, use
    52         -        #       "2010" as the test year; otherwise, use "2008" (we could use
           55  +        #       "2010" by default (we could use "2012" in that case as well) as
           56  +        #       the test year; otherwise, use "2008" by default (we could use
    53     57           #       "2005" in that case as well).  If another major [incompatible]
    54     58           #       version of the .NET Framework is released, this check will have
    55         -        #       to be changed.
           59  +        #       to be changed.  The default test year to use for a particular
           60  +        #       .NET Framework version may be overridden using another global
           61  +        #       variable (i.e. test_year_netFxYZ).
    56     62           #
    57         -        return [expr {[haveConstraint imageRuntime40] ? "2010" : "2008"}]
           63  +        if {[haveConstraint imageRuntime40]} then {
           64  +          if {[info exists ::test_year_netFx40] && \
           65  +              [string length $::test_year_netFx40] > 0} then {
           66  +            #
           67  +            # NOTE: Use the specified test year for the .NET Framework 4.0.
           68  +            #
           69  +            return $::test_year_netFx40
           70  +          } else {
           71  +            #
           72  +            # NOTE: Use the default test year for the .NET Framework 4.0.
           73  +            #
           74  +            return 2010
           75  +          }
           76  +        } else {
           77  +          if {[info exists ::test_year_netFx20] && \
           78  +              [string length $::test_year_netFx20] > 0} then {
           79  +            #
           80  +            # NOTE: Use the specified test year for the .NET Framework 2.0.
           81  +            #
           82  +            return $::test_year_netFx20
           83  +          } else {
           84  +            #
           85  +            # NOTE: Use the default test year for the .NET Framework 2.0.
           86  +            #
           87  +            return 2008
           88  +          }
           89  +        }
    58     90         }
    59     91       }
    60     92   
    61     93       proc getBuildConfiguration {} {
    62     94         #
    63     95         # NOTE: See if the "configuration" setting has been overridden by the user
    64     96         #       (e.g. on the command line).  This helps control exactly which set

Changes to Tests/installer.eagle.

    36     36       Installer_Test_Vs2005.log]]
    37     37   
    38     38   set testInstallVs2008LogFile [file nativename [file join $path \
    39     39       Installer_Test_Vs2008.log]]
    40     40   
    41     41   set testInstallVs2010LogFile [file nativename [file join $path \
    42     42       Installer_Test_Vs2010.log]]
           43  +
           44  +set testInstallVs2012LogFile [file nativename [file join $path \
           45  +    Installer_Test_Vs2012.log]]
    43     46   
    44     47   set testUninstallVs2005LogFile [file nativename [file join $path \
    45     48       Uninstaller_Test_Vs2005.log]]
    46     49   
    47     50   set testUninstallVs2008LogFile [file nativename [file join $path \
    48     51       Uninstaller_Test_Vs2008.log]]
    49     52   
    50     53   set testUninstallVs2010LogFile [file nativename [file join $path \
    51     54       Uninstaller_Test_Vs2010.log]]
           55  +
           56  +set testUninstallVs2012LogFile [file nativename [file join $path \
           57  +    Uninstaller_Test_Vs2012.log]]
    52     58   
    53     59   #
    54     60   # NOTE: Setup the test constraints specific to the tests in this file.
    55     61   #
    56     62   if {![haveConstraint [appendArgs file_ \
    57     63       [file tail $systemDataSQLiteDllFile]]]} then {
    58     64     checkForFile $test_channel $systemDataSQLiteDllFile
................................................................................
    78     84     checkForFile $test_channel $testInstallVs2008LogFile
    79     85   }
    80     86   
    81     87   if {![haveConstraint [appendArgs file_ \
    82     88       [file tail $testInstallVs2010LogFile]]]} then {
    83     89     checkForFile $test_channel $testInstallVs2010LogFile
    84     90   }
           91  +
           92  +if {![haveConstraint [appendArgs file_ \
           93  +    [file tail $testInstallVs2012LogFile]]]} then {
           94  +  checkForFile $test_channel $testInstallVs2012LogFile
           95  +}
    85     96   
    86     97   if {![haveConstraint [appendArgs file_ \
    87     98       [file tail $testUninstallVs2005LogFile]]]} then {
    88     99     checkForFile $test_channel $testUninstallVs2005LogFile
    89    100   }
    90    101   
    91    102   if {![haveConstraint [appendArgs file_ \
................................................................................
    93    104     checkForFile $test_channel $testUninstallVs2008LogFile
    94    105   }
    95    106   
    96    107   if {![haveConstraint [appendArgs file_ \
    97    108       [file tail $testUninstallVs2010LogFile]]]} then {
    98    109     checkForFile $test_channel $testUninstallVs2010LogFile
    99    110   }
          111  +
          112  +if {![haveConstraint [appendArgs file_ \
          113  +    [file tail $testUninstallVs2012LogFile]]]} then {
          114  +  checkForFile $test_channel $testUninstallVs2012LogFile
          115  +}
   100    116   
   101    117   ###############################################################################
   102    118   
   103    119   runTest {test installer-1.1 {installer tool / Visual Studio 2005} -setup {
   104    120     set fileName [file join [getTemporaryPath] [file tail [string map [list \
   105    121         .log [appendArgs _ [pid] .log]] $testInstallVs2005LogFile]]]
   106    122   
................................................................................
   108    124   } -body {
   109    125     set output ""
   110    126   
   111    127     set code [catch {
   112    128       testClrExec $installerExeFile [list -eventflags Wait -stdout output \
   113    129           -success 0] -debugPriority Lowest -tracePriority MediumHigh \
   114    130           -noRuntimeVersion true -noCompact true -noNetFx40 true -noVs2008 true \
   115         -        -noVs2010 true -whatIf true -verbose true -confirm true -install true \
   116         -        -logFileName [appendArgs \" [file nativename $fileName] \"] \
   117         -        -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
          131  +        -noVs2010 true -noVs2012 true -whatIf true -verbose true -confirm true \
          132  +        -install true -logFileName [appendArgs \" [file nativename $fileName] \
          133  +        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
   118    134     } error]
   119    135   
   120    136     tlog "---- BEGIN STDOUT OUTPUT\n"
   121    137     tlog $output
   122    138     tlog "\n---- END STDOUT OUTPUT\n"
   123    139   
   124    140     set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
................................................................................
   144    160   } -body {
   145    161     set output ""
   146    162   
   147    163     set code [catch {
   148    164       testClrExec $installerExeFile [list -eventflags Wait -stdout output \
   149    165           -success 0] -debugPriority Lowest -tracePriority MediumHigh \
   150    166           -noRuntimeVersion true -noCompact true -noNetFx40 true -noVs2008 true \
   151         -        -noVs2010 true -whatIf true -verbose true -confirm true -install false \
   152         -        -logFileName [appendArgs \" [file nativename $fileName] \"] \
   153         -        -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
          167  +        -noVs2010 true -noVs2012 true -whatIf true -verbose true -confirm true \
          168  +        -install false -logFileName [appendArgs \" [file nativename $fileName] \
          169  +        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
   154    170     } error]
   155    171   
   156    172     tlog "---- BEGIN STDOUT OUTPUT\n"
   157    173     tlog $output
   158    174     tlog "\n---- END STDOUT OUTPUT\n"
   159    175   
   160    176     set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
................................................................................
   180    196   } -body {
   181    197     set output ""
   182    198   
   183    199     set code [catch {
   184    200       testClrExec $installerExeFile [list -eventflags Wait -stdout output \
   185    201           -success 0] -debugPriority Lowest -tracePriority MediumHigh \
   186    202           -noRuntimeVersion true -noCompact true -noNetFx40 true -noVs2005 true \
   187         -        -noVs2010 true -whatIf true -verbose true -confirm true -install true \
   188         -        -logFileName [appendArgs \" [file nativename $fileName] \"] \
   189         -        -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
          203  +        -noVs2010 true -noVs2012 true -whatIf true -verbose true -confirm true \
          204  +        -install true -logFileName [appendArgs \" [file nativename $fileName] \
          205  +        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
   190    206     } error]
   191    207   
   192    208     tlog "---- BEGIN STDOUT OUTPUT\n"
   193    209     tlog $output
   194    210     tlog "\n---- END STDOUT OUTPUT\n"
   195    211   
   196    212     set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
................................................................................
   216    232   } -body {
   217    233     set output ""
   218    234   
   219    235     set code [catch {
   220    236       testClrExec $installerExeFile [list -eventflags Wait -stdout output \
   221    237           -success 0] -debugPriority Lowest -tracePriority MediumHigh \
   222    238           -noRuntimeVersion true -noCompact true -noNetFx40 true -noVs2005 true \
   223         -        -noVs2010 true -whatIf true -verbose true -confirm true -install false \
   224         -        -logFileName [appendArgs \" [file nativename $fileName] \"] \
   225         -        -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
          239  +        -noVs2010 true -noVs2012 true -whatIf true -verbose true -confirm true \
          240  +        -install false -logFileName [appendArgs \" [file nativename $fileName] \
          241  +        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
   226    242     } error]
   227    243   
   228    244     tlog "---- BEGIN STDOUT OUTPUT\n"
   229    245     tlog $output
   230    246     tlog "\n---- END STDOUT OUTPUT\n"
   231    247   
   232    248     set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
................................................................................
   252    268   } -body {
   253    269     set output ""
   254    270   
   255    271     set code [catch {
   256    272       testClrExec $installerExeFile [list -eventflags Wait -stdout output \
   257    273           -success 0] -debugPriority Lowest -tracePriority MediumHigh \
   258    274           -noRuntimeVersion true -noCompact true -noNetFx20 true -noVs2005 true \
   259         -        -noVs2008 true -whatIf true -verbose true -confirm true -install true \
   260         -        -logFileName [appendArgs \" [file nativename $fileName] \"] \
   261         -        -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
          275  +        -noVs2008 true -noVs2012 true -whatIf true -verbose true -confirm true \
          276  +        -install true -logFileName [appendArgs \" [file nativename $fileName] \
          277  +        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
   262    278     } error]
   263    279   
   264    280     tlog "---- BEGIN STDOUT OUTPUT\n"
   265    281     tlog $output
   266    282     tlog "\n---- END STDOUT OUTPUT\n"
   267    283   
   268    284     set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
................................................................................
   288    304   } -body {
   289    305     set output ""
   290    306   
   291    307     set code [catch {
   292    308       testClrExec $installerExeFile [list -eventflags Wait -stdout output \
   293    309           -success 0] -debugPriority Lowest -tracePriority MediumHigh \
   294    310           -noRuntimeVersion true -noCompact true -noNetFx20 true -noVs2005 true \
   295         -        -noVs2008 true -whatIf true -verbose true -confirm true -install false \
   296         -        -logFileName [appendArgs \" [file nativename $fileName] \"] \
   297         -        -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
          311  +        -noVs2008 true -noVs2012 true -whatIf true -verbose true -confirm true \
          312  +        -install false -logFileName [appendArgs \" [file nativename $fileName] \
          313  +        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
   298    314     } error]
   299    315   
   300    316     tlog "---- BEGIN STDOUT OUTPUT\n"
   301    317     tlog $output
   302    318     tlog "\n---- END STDOUT OUTPUT\n"
   303    319   
   304    320     set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
................................................................................
   312    328   } -constraints {eagle administrator visualStudio2010\
   313    329   System.Data.SQLite.dll_v4.0.30319 file_Installer.exe\
   314    330   file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
   315    331   file_Uninstaller_Test_Vs2010.log} -result {0 True}}
   316    332   
   317    333   ###############################################################################
   318    334   
   319         -unset -nocomplain testUninstallVs2010LogFile testUninstallVs2008LogFile \
   320         -    testUninstallVs2005LogFile testInstallVs2010LogFile \
          335  +runTest {test installer-1.7 {installer tool / Visual Studio 2012} -setup {
          336  +  set fileName [file join [getTemporaryPath] [file tail [string map [list \
          337  +      .log [appendArgs _ [pid] .log]] $testInstallVs2012LogFile]]]
          338  +
          339  +  cleanupFile $fileName
          340  +} -body {
          341  +  set output ""
          342  +
          343  +  set code [catch {
          344  +    testClrExec $installerExeFile [list -eventflags Wait -stdout output \
          345  +        -success 0] -debugPriority Lowest -tracePriority MediumHigh \
          346  +        -noRuntimeVersion true -noCompact true -noNetFx20 true -noVs2005 true \
          347  +        -noVs2008 true -noVs2010 true -whatIf true -verbose true -confirm true \
          348  +        -install true -logFileName [appendArgs \" [file nativename $fileName] \
          349  +        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
          350  +  } error]
          351  +
          352  +  tlog "---- BEGIN STDOUT OUTPUT\n"
          353  +  tlog $output
          354  +  tlog "\n---- END STDOUT OUTPUT\n"
          355  +
          356  +  set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
          357  +
          358  +  list $code [expr {$code == 0 ? [string equal [readFile $fileName] \
          359  +      [subst -nobackslashes [readFile $testInstallVs2012LogFile]]] : $error}]
          360  +} -cleanup {
          361  +  cleanupFile $fileName
          362  +
          363  +  unset -nocomplain wow64 code output error fileName
          364  +} -constraints {eagle administrator visualStudio2012\
          365  +System.Data.SQLite.dll_v4.0.30319 file_Installer.exe\
          366  +file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
          367  +file_Installer_Test_Vs2012.log} -result {0 True}}
          368  +
          369  +###############################################################################
          370  +
          371  +runTest {test installer-1.8 {uninstaller tool / Visual Studio 2012} -setup {
          372  +  set fileName [file join [getTemporaryPath] [file tail [string map [list \
          373  +      .log [appendArgs _ [pid] .log]] $testUninstallVs2012LogFile]]]
          374  +
          375  +  cleanupFile $fileName
          376  +} -body {
          377  +  set output ""
          378  +
          379  +  set code [catch {
          380  +    testClrExec $installerExeFile [list -eventflags Wait -stdout output \
          381  +        -success 0] -debugPriority Lowest -tracePriority MediumHigh \
          382  +        -noRuntimeVersion true -noCompact true -noNetFx20 true -noVs2005 true \
          383  +        -noVs2008 true -noVs2010 true -whatIf true -verbose true -confirm true \
          384  +        -install false -logFileName [appendArgs \" [file nativename $fileName] \
          385  +        \"] -traceFormat [appendArgs \" "#{0}: {2}" \"] -debug true -wow64 true
          386  +  } error]
          387  +
          388  +  tlog "---- BEGIN STDOUT OUTPUT\n"
          389  +  tlog $output
          390  +  tlog "\n---- END STDOUT OUTPUT\n"
          391  +
          392  +  set wow64 [expr {[haveConstraint amd64.64bit] ? "\\Wow6432Node" : ""}]
          393  +
          394  +  list $code [expr {$code == 0 ? [string equal [readFile $fileName] \
          395  +      [subst -nobackslashes [readFile $testUninstallVs2012LogFile]]] : $error}]
          396  +} -cleanup {
          397  +  cleanupFile $fileName
          398  +
          399  +  unset -nocomplain wow64 code output error fileName
          400  +} -constraints {eagle administrator visualStudio2012\
          401  +System.Data.SQLite.dll_v4.0.30319 file_Installer.exe\
          402  +file_System.Data.SQLite.dll file_System.Data.SQLite.Linq.dll\
          403  +file_Uninstaller_Test_Vs2012.log} -result {0 True}}
          404  +
          405  +###############################################################################
          406  +
          407  +unset -nocomplain testUninstallVs2012LogFile testUninstallVs2010LogFile \
          408  +    testUninstallVs2008LogFile testUninstallVs2005LogFile \
          409  +    testInstallVs2012LogFile testInstallVs2010LogFile \
   321    410       testInstallVs2008LogFile testInstallVs2005LogFile installerExeFile \
   322    411       systemDataSQLiteLinqDllFile systemDataSQLiteDllFile
   323    412   
   324    413   ###############################################################################
   325    414   
   326    415   runSQLiteTestEpilogue
   327    416   runTestEpilogue

Changes to Tests/tkt-2ce0870fad.eagle.

    40     40   
    41     41       #
    42     42       # NOTE: Keep track of whether or not the global test year and configuration
    43     43       #       variables already exist in the primary application domain before the
    44     44       #       test.  If not, we will need to unset them after the test.
    45     45       #
    46     46       set hadTestYear {[info exists ::test_year]}
           47  +    set hadTestYearNetFx20 {[info exists ::test_year_netFx20]}
           48  +    set hadTestYearNetFx40 {[info exists ::test_year_netFx40]}
    47     49       set hadTestConfiguration {[info exists ::test_configuration]}
    48     50     }] -body {
    49     51       set appDomainId(3) [object invoke AppDomain.CurrentDomain Id]
    50     52   
    51     53       package require Eagle.Library
    52     54       package require Eagle.Test
    53     55       package require System.Data.SQLite.Test
................................................................................
    62     64           $appDomainId($i) == $appDomainId(3)}] [setupDb $fileName]
    63     65     } -cleanup {
    64     66       cleanupDb $fileName
    65     67   
    66     68       if {!$hadTestConfiguration} then {
    67     69         unset -nocomplain ::test_configuration
    68     70       }
           71  +
           72  +    if {!$hadTestYearNetFx40} then {
           73  +      unset -nocomplain ::test_year_netFx40
           74  +    }
           75  +
           76  +    if {!$hadTestYearNetFx20} then {
           77  +      unset -nocomplain ::test_year_netFx20
           78  +    }
    69     79   
    70     80       if {!$hadTestYear} then {
    71     81         unset -nocomplain ::test_year
    72     82       }
    73     83   
    74     84       #
    75     85       # NOTE: If this is the primary application domain, skip unsetting the

Changes to tools/install/Installer.cs.

  1776   1776                   bool noDesktop,
  1777   1777                   bool noCompact,
  1778   1778                   bool noNetFx20,
  1779   1779                   bool noNetFx40,
  1780   1780                   bool noVs2005,
  1781   1781                   bool noVs2008,
  1782   1782                   bool noVs2010,
         1783  +                bool noVs2012,
  1783   1784                   bool noTrace,
  1784   1785                   bool noConsole,
  1785   1786                   bool noLog,
  1786   1787                   bool throwOnMissing,
  1787   1788                   bool whatIf,
  1788   1789                   bool debug,
  1789   1790                   bool verbose,
................................................................................
  1807   1808                   this.noDesktop = noDesktop;
  1808   1809                   this.noCompact = noCompact;
  1809   1810                   this.noNetFx20 = noNetFx20;
  1810   1811                   this.noNetFx40 = noNetFx40;
  1811   1812                   this.noVs2005 = noVs2005;
  1812   1813                   this.noVs2008 = noVs2008;
  1813   1814                   this.noVs2010 = noVs2010;
         1815  +                this.noVs2012 = noVs2012;
  1814   1816                   this.noTrace = noTrace;
  1815   1817                   this.noConsole = noConsole;
  1816   1818                   this.noLog = noLog;
  1817   1819                   this.throwOnMissing = throwOnMissing;
  1818   1820                   this.whatIf = whatIf;
  1819   1821                   this.debug = debug;
  1820   1822                   this.verbose = verbose;
................................................................................
  2463   2465                                       return false;
  2464   2466   
  2465   2467                                   continue;
  2466   2468                               }
  2467   2469   
  2468   2470                               configuration.noVs2010 = (bool)value;
  2469   2471                           }
         2472  +                        else if (MatchOption(newArg, "noVs2012"))
         2473  +                        {
         2474  +                            bool? value = ParseBoolean(text);
         2475  +
         2476  +                            if (value == null)
         2477  +                            {
         2478  +                                error = TraceOps.DebugAndTrace(
         2479  +                                    TracePriority.Lowest, debugCallback,
         2480  +                                    traceCallback, String.Format(
         2481  +                                    "Invalid {0} boolean value: {1}",
         2482  +                                    ForDisplay(arg), ForDisplay(text)),
         2483  +                                    traceCategory);
         2484  +
         2485  +                                if (strict)
         2486  +                                    return false;
         2487  +
         2488  +                                continue;
         2489  +                            }
         2490  +
         2491  +                            configuration.noVs2012 = (bool)value;
         2492  +                        }
  2470   2493                           else if (MatchOption(newArg, "strict"))
  2471   2494                           {
  2472   2495                               bool? value = ParseBoolean(text);
  2473   2496   
  2474   2497                               if (value == null)
  2475   2498                               {
  2476   2499                                   error = TraceOps.DebugAndTrace(
................................................................................
  2860   2883                           //       practice as the CLR v4.0 can load and use an
  2861   2884                           //       assembly compiled with the CLR v2.0; however,
  2862   2885                           //       since this project offers both configurations,
  2863   2886                           //       we currently disallow this mismatch.
  2864   2887                           //
  2865   2888                           configuration.noNetFx40 = true;
  2866   2889                           configuration.noVs2010 = true;
         2890  +                        configuration.noVs2012 = true;
  2867   2891   
  2868   2892                           TraceOps.DebugAndTrace(TracePriority.Medium,
  2869   2893                               debugCallback, traceCallback, String.Format(
  2870   2894                               "Assembly is compiled for the .NET Framework {0}, " +
  2871   2895                               "support for .NET Framework {1} is now disabled.",
  2872   2896                               CLRv2ImageRuntimeVersion, CLRv4ImageRuntimeVersion),
  2873   2897                               traceCategory);
................................................................................
  3020   3044                       traceCallback(String.Format(NameAndValueFormat,
  3021   3045                           "NoVs2008", ForDisplay(noVs2008)),
  3022   3046                           traceCategory);
  3023   3047   
  3024   3048                       traceCallback(String.Format(NameAndValueFormat,
  3025   3049                           "NoVs2010", ForDisplay(noVs2010)),
  3026   3050                           traceCategory);
         3051  +
         3052  +                    traceCallback(String.Format(NameAndValueFormat,
         3053  +                        "NoVs2012", ForDisplay(noVs2012)),
         3054  +                        traceCategory);
  3027   3055   
  3028   3056                       traceCallback(String.Format(NameAndValueFormat,
  3029   3057                           "NoTrace", ForDisplay(noTrace)),
  3030   3058                           traceCategory);
  3031   3059   
  3032   3060                       traceCallback(String.Format(NameAndValueFormat,
  3033   3061                           "NoConsole", ForDisplay(noConsole)),
................................................................................
  3260   3288   
  3261   3289               private bool noVs2010;
  3262   3290               public bool NoVs2010
  3263   3291               {
  3264   3292                   get { return noVs2010; }
  3265   3293                   set { noVs2010 = value; }
  3266   3294               }
         3295  +
         3296  +            ///////////////////////////////////////////////////////////////////
         3297  +
         3298  +            private bool noVs2012;
         3299  +            public bool NoVs2012
         3300  +            {
         3301  +                get { return noVs2012; }
         3302  +                set { noVs2012 = value; }
         3303  +            }
  3267   3304   
  3268   3305               ///////////////////////////////////////////////////////////////////
  3269   3306   
  3270   3307               private bool noTrace;
  3271   3308               public bool NoTrace
  3272   3309               {
  3273   3310                   get { return noTrace; }
................................................................................
  4212   4249                   vsList.RootKey = rootKey;
  4213   4250   
  4214   4251               if (vsList.Versions == null)
  4215   4252               {
  4216   4253                   vsList.Versions = new VersionList();
  4217   4254   
  4218   4255                   if ((configuration == null) || !configuration.NoVs2005)
  4219         -                    vsList.Versions.Add(new Version(8, 0)); // Visual Studio 2005
         4256  +                    vsList.Versions.Add(new Version(8, 0)); // 2005
  4220   4257   
  4221   4258                   if ((configuration == null) || !configuration.NoVs2008)
  4222         -                    vsList.Versions.Add(new Version(9, 0)); // Visual Studio 2008
         4259  +                    vsList.Versions.Add(new Version(9, 0)); // 2008
  4223   4260   
  4224   4261                   if ((configuration == null) || !configuration.NoVs2010)
  4225         -                    vsList.Versions.Add(new Version(10, 0));// Visual Studio 2010
         4262  +                    vsList.Versions.Add(new Version(10, 0));// 2010
         4263  +
         4264  +                if ((configuration == null) || !configuration.NoVs2012)
         4265  +                    vsList.Versions.Add(new Version(11, 0));// 2012
  4226   4266               }
  4227   4267           }
  4228   4268   
  4229   4269           ///////////////////////////////////////////////////////////////////////
  4230   4270   
  4231   4271           private static bool HaveVsVersion(
  4232   4272               MockRegistryKey rootKey,