Merge pull request #10499 from MicrosoftDocs/repo_sync_working_branch

Confirm merge from repo_sync_working_branch to main to sync with https://github.com/MicrosoftDocs/visualstudio-docs (branch main)

Author: Taojunshen

docs/code-quality/roslyn-analyzers-overview.md

@@ -24,7 +24,7 @@ ms.workload:
 
 Analyzers are divided into the following groups:
 
-- [Code style](/dotnet/fundamentals/code-analysis/code-style-rule-options?preserve-view=true&view=vs-2019#convention-categories) analyzers are built into Visual Studio. The analyzer's diagnostic ID, or code format is IDExxxx, for example, IDE0067. You can configure preferences in the [text editor options page](../ide/code-styles-and-code-cleanup.md) or in an [EditorConfig file](/dotnet/fundamentals/code-analysis/code-style-rule-options). Starting in .NET 5.0, code style analyzers are included with the .NET SDK and can be strictly enforced as build warnings or errors. For more information, see [Overview of .NET source code analysis](/dotnet/fundamentals/productivity/code-analysis#code-style-analysis).
+- [Code style](/dotnet/fundamentals/code-analysis/code-style-rule-options?preserve-view=true&view=vs-2019#convention-categories) analyzers are built into Visual Studio. The analyzer's diagnostic ID, or code format is IDExxxx, for example, IDE0001. You can configure preferences in the [text editor options page](../ide/code-styles-and-code-cleanup.md) or in an [EditorConfig file](/dotnet/fundamentals/code-analysis/code-style-rule-options). Starting in .NET 5.0, code style analyzers are included with the .NET SDK and can be strictly enforced as build warnings or errors. For more information, see [Overview of .NET source code analysis](/dotnet/fundamentals/productivity/code-analysis#code-style-analysis).
 
 - [Code quality](/dotnet/fundamentals/code-analysis/quality-rules/index) analyzers are now included with the .NET 5 SDK and enabled by default. The analyzer's diagnostic ID, or code format is CAxxxx, for example, CA1822. For more information, see [Overview of .NET code quality analysis](/dotnet/fundamentals/productivity/code-analysis#code-quality-analysis).
 
@@ -103,4 +103,4 @@ You can't configure the severity of rules from analyzers that were installed as
 
 - [Analyzers FAQ](analyzers-faq.yml)
 - [Write your own code analyzer](../extensibility/getting-started-with-roslyn-analyzers.md)
-- [.NET Compiler Platform SDK](/dotnet/csharp/roslyn-sdk/)
+- [.NET Compiler Platform SDK](/dotnet/csharp/roslyn-sdk/)

docs/extensibility/roslyn-version-support.md

@@ -23,7 +23,7 @@ As an example, to ensure that your custom analyzer works on all versions of Visu
 
 | Roslyn package version | Minimum supported Visual Studio version |
 | - | - |
-| 4.3.0 | Visual Studio 2022 version 17.3 |
+| 4.3.1 | Visual Studio 2022 version 17.3 |
 | 4.2.0 | Visual Studio 2022 version 17.2 |
 | 4.1.0 | Visual Studio 2022 version 17.1 |
 | 4.0.1 | Visual Studio 2022 RTM |

docs/ide/file-nesting-solution-explorer.md

@@ -16,10 +16,10 @@ ms.technology: vs-ide-general
 
  [!INCLUDE [Visual Studio](~/includes/applies-to-version/vs-windows-only.md)]
 
-**Solution Explorer** nests related files to help organize them and make them easier to locate. For example, if you add a Windows Forms form to a project, the code file for the form is nested below the form in **Solution Explorer**. In ASP.NET Core projects, file nesting can be taken a step further. You can choose between the file nesting presets **Off**, **Default**, and **Web**. You can also [customize how files are nested](#customize-file-nesting) or [create solution-specific and project-specific settings](#create-project-specific-settings).
+**Solution Explorer** nests related files to help organize them and make them easier to locate. For example, if you add a Windows Forms form to a project, the code file for the form is nested below the form in **Solution Explorer**. In .NET Core (and .NET 5 and later) projects, file nesting can be taken a step further. You can choose between the file nesting presets **Off**, **Default**, and **Web**. You can also [customize how files are nested](#customize-file-nesting) or [create solution-specific and project-specific settings](#create-project-specific-settings).
 
 > [!NOTE]
-> Until Visual Studio 2022 version 17.3, this feature was only supported for ASP.NET Core projects.
+> In Visual Studio 2022 version 17.2 and earlier, this feature was only supported for ASP.NET Core projects.
 
 ## File nesting options
 

docs/ide/reference/options-text-editor-javascript-linting.md

@@ -2,7 +2,7 @@
 title: Options, Text Editor, JavaScript, Linting
 description: Learn how to use the Linting page of the Options dialog box to set options for analyzing code in the Code Editor.
 ms.custom: SEO-VS-2020
-ms.date: 1/15/2019
+ms.date: 9/30/2022
 ms.technology: vs-javascript
 ms.topic: reference
 f1_keywords:
@@ -20,7 +20,7 @@ ms.workload:
 
  [!INCLUDE [Visual Studio](~/includes/applies-to-version/vs-windows-only.md)]
 
-Use the **Linting** page of the **Options** dialog box to set options for analyzing code in the Code Editor. To access this page, on the menu bar, choose **Tools** > **Options**, and then expand **Text Editor** > **JavaScript/TypeScript** > **Linting**.
+Use the **Linting** page of the **Options** dialog box to set options for analyzing code in the Code Editor (note that you can override these options in some project types, like the [standalone React project templates](../../javascript/tutorial-create-react-app.md)). To access this page, on the menu bar, choose **Tools** > **Options**, and then expand **Text Editor** > **JavaScript/TypeScript** > **Linting**.
 
 ## ESLint Settings
 
@@ -31,12 +31,9 @@ These options let you enable static JavaScript and TypeSCript code analysis, and
 |Option|Description|
 |------------|-----------------|
 |**Enable ESLint**|When this option is selected, the Code Editor allows for static analysis on the code.|
-|**Lint all files included in project, even closed files**|When this option is selected, closed files are analyzed, unless diagnostics are only reported for open files.|
-
-## Global ESLint Config Options
-
-This option lets you copy the location of the global ESLint configuration file. Also, if you previously changed the location, you can reset the file to its default location.
+|**Lint *file extension* files**|These options allow you to configure which file extensions should be linted. For example, if "Lint TypeScript files" is selected, then documents with a *.ts* file extension will be linted.|
 
 ## See also
 
-- [General, Environment, Options Dialog Box](../../ide/reference/general-environment-options-dialog-box.md)
+- [Linting JavaScript in Visual Studio](../../javascript/linting-javascript.md)
+- [General, Environment, Options Dialog Box](../../ide/reference/general-environment-options-dialog-box.md)

docs/javascript/linting-javascript.md

@@ -25,7 +25,7 @@ To enable linting support in Visual Studio 2022 or later versions, enable the **
 
 :::image type="content" source="media/vs-2022/linting-tools-options.png" alt-text="Screenshot of linting Tools Options page.":::
 
-In the options page, you can also modify the set of files that you want to lint. By default, all file extensions that can be linted (*.js*, *.jsx*, *.ts*, *.tsx*) will be linted.
+In the options page, you can also modify the set of files that you want to lint. By default, all file extensions that can be linted (*.js*, *.jsx*, *.ts*, *.tsx*, *.vue*, *.html*) will be linted. The HTML LSP-based editor must be enabled for linting Vue and HTML files. The respective setting can be found in **Tools > Options > Environment > Preview Features**.
 
 You can override these options in some project types, like the [standalone React project templates](../javascript/tutorial-create-react-app.md). In these projects, you can override the settings from the **Tools > Options** page using project properties:
 

docs/javascript/media/vs-2022/linting-project-properties.png

@@ -16,7 +16,7 @@ ms.workload:
 ---
 # MSBuild inline tasks with RoslynCodeTaskFactory
 
-Similar to the [CodeTaskFactory](../msbuild/msbuild-inline-tasks.md), RoslynCodeTaskFactory uses the cross-platform Roslyn compilers to generate in-memory task assemblies for use as inline tasks.  RoslynCodeTaskFactory tasks target .NET Standard and can work on .NET Framework and .NET Core runtimes as well as other platforms such as Linux and Mac OS.
+Similar to the [CodeTaskFactory](../msbuild/msbuild-inline-tasks.md), RoslynCodeTaskFactory uses the cross-platform Roslyn compilers to generate in-memory task assemblies for use as inline tasks.  RoslynCodeTaskFactory tasks target .NET Standard and can work on .NET Framework and .NET Core runtimes as well as other platforms such as Linux and macOS.
 
 >[!NOTE]
 >The RoslynCodeTaskFactory is available in MSBuild 15.8 and above only. MSBuild versions follow Visual Studio versions, so RoslynCodeTaskFactory is available in Visual Studio 2017 version 15.8 and higher.

docs/javascript/media/vs-2022/linting-tools-options.png

@@ -2,7 +2,7 @@
 title: Create Data-Driven Unit Tests
 description: Learn how to use the Microsoft unit test framework for managed code to set up a unit test method to retrieve values from a data source.
 ms.custom: SEO-VS-2020
-ms.date: 05/08/2019
+ms.date: 10/17/2012
 ms.topic: how-to
 f1_keywords: 
   - vs.test.testresults.unittest.datadriven
@@ -22,17 +22,13 @@ author: mikejo5000
 
  [!INCLUDE [Visual Studio](~/includes/applies-to-version/vs-windows-only.md)]
 
-You can use the Microsoft unit test framework for managed code to set up a unit test method to retrieve values from a data source. The method is run successively for each row in the data source, which makes it easy to test a variety of input by using a single method.
+You can use the Microsoft unit test framework (MSTest) for managed code to set up a unit test method to retrieve values from a data source. The method is run successively for each row in the data source, which makes it easy to test a variety of input by using a single method.
 
-Creating a data-driven unit test involves the following steps:
+A data-driven unit test can use any of the following kind:
 
-1. Create a data source that contains the values that you use in the test method. The data source can be any type that is registered on the machine that runs the test.
-
-2. Add a private <xref:Microsoft.VisualStudio.TestTools.UnitTesting.TestContext> field and a public `TestContext` property to the test class.
-
-3. Create a unit test method and add a <xref:Microsoft.VisualStudio.TestTools.UnitTesting.DataSourceAttribute> attribute to it.
-
-4. Use the <xref:Microsoft.VisualStudio.TestTools.UnitTesting.TestContext.DataRow%2A> indexer property to retrieve the values that you use in a test.
+- inline data using the `DataRow` attribute
+- member data using the `DynamicData` attribute
+- from some well-known source provider using the `DataSource` attribute
 
 ## The method under test
 
@@ -54,15 +50,94 @@ We'll test a method in `Maths` that adds two integers using a loop:
 public int AddIntegers(int first, int second)
 {
     int sum = first;
-    for( int i = 0; i < second; i++)
+    for (int i = 0; i < second; i++)
     {
         sum += 1;
     }
+
     return sum;
 }
 ```
 
-## Create a data source
+## Test test method
+
+### Inline data-driven test
+
+For inline tests, MSTest uses `DataRow` to specify values used by the data-driven test. The test in this example runs successively for each data row.
+
+```csharp
+[DataTestMethod]
+[DataRow(1, 1, 2)]
+[DataRow(2, 2, 4)]
+[DataRow(3, 3, 6)]
+[DataRow(0, 0, 1)] // The test run with this row fails
+public void AddIntegers_FromDataRowTest(int x, int y, int expected)
+{
+    var target = new Maths();
+    int actual = target.AddIntegers(x, y);
+    Assert.AreEqual(expected, actual,
+        "x:<{0}> y:<{1}>",
+        new object[] {x, y});
+}
+```
+
+### Member data-driven test
+
+MSTest uses `DynamicData` attribute to specify the name, kind (property, the default, or method) and defining type (by default current type is used) of the member that will provide the data used by the data-driven test.
+
+```csharp
+public static IEnumerable<object[]> AdditionData
+{
+    get
+    {
+        return new[]
+        { 
+            new object[] { 1, 1, 2 },
+            new object[] { 2, 2, 4 },
+            new object[] { 3, 3, 6 },
+            new object[] { 0, 0, 1 }, // The test run with this row fails
+        };
+    }
+}
+
+[TestMethod]
+[DynamicData(nameof(ReusableTestDataProperty))]
+public void AddIntegers_FromDynamicDataTest(int x, int y, int expected)
+{
+    var target = new Maths();
+    int actual = target.AddIntegers(x, y);
+    Assert.AreEqual(expected, actual,
+        "x:<{0}> y:<{1}>",
+        new object[] {x, y});
+}
+```
+
+It is also possible to override the default generated display name, using the `DynamicDataDisplayName` property of the `DynamicData` attribute. The display name method signature must be `publc static string` and accept two parameters, the first of type `MethodInfo` and the second of type `object[]`.
+
+```csharp
+public static string GetCustomDynamicDataDisplayName(MethodInfo methodInfo, object[] data)
+{
+    return string.Format("DynamicDataTestMethod {0} with {1} parameters", methodInfo.Name, data.Length);
+}
+
+[DynamicData(nameof(AdditionData), DynamicDataDisplayName = nameof(GetCustomDynamicDataDisplayName))]
+```
+
+### Source provider data-driven test
+
+Creating a data source driven unit test involves the following steps:
+
+1. Create a data source that contains the values that you use in the test method. The data source can be any type that is registered on the machine that runs the test.
+
+2. Add a public `TestContext` property of type <xref:Microsoft.VisualStudio.TestTools.UnitTesting.TestContext> to the test class.
+
+3. Create a unit test method
+
+4. Add a <xref:Microsoft.VisualStudio.TestTools.UnitTesting.DataSourceAttribute> attribute to it.
+
+5. Use the <xref:Microsoft.VisualStudio.TestTools.UnitTesting.TestContext.DataRow%2A> indexer property to retrieve the values that you use in a test.
+
+#### Create a data source
 
 To test the `AddIntegers` method, create a data source that specifies a range of values for the parameters and the sum that you expect to be returned. In this example, we'll create a Sql Compact database named `MathsData` and a table named `AddIntegersData` that contains the following column names and values
 
@@ -72,31 +147,26 @@ To test the `AddIntegers` method, create a data source that specifies a range of
 |1|1|2|
 |2|-3|-1|
 
-## Add a TestContext to the test class
+#### Add a TestContext to the test class
 
 The unit test framework creates a `TestContext` object to store the data source information for a data-driven test. The framework then sets this object as the value of the `TestContext` property that you create.
 
 ```csharp
-private TestContext testContextInstance;
-public TestContext TestContext
-{
-    get { return testContextInstance; }
-    set { testContextInstance = value; }
-}
+public TestContext TestContext { get; set; }
 ```
 
 In your test method, you access the data through the `DataRow` indexer property of the `TestContext`.
 
 > [!NOTE]
-> .NET Core does not support the [DataSource](xref:Microsoft.VisualStudio.TestTools.UnitTesting.DataSourceAttribute) attribute. If you try to access test data in this way in a .NET Core or UWP unit test project, you'll see an error similar to **"'TestContext' does not contain a definition for 'DataRow' and no accessible extension method 'DataRow' accepting a first argument of type 'TestContext' could be found (are you missing a using directive or an assembly reference?)"**.
+> .NET Core does not support the [DataSource](xref:Microsoft.VisualStudio.TestTools.UnitTesting.DataSourceAttribute) attribute. If you try to access test data in this way in a .NET Core, UWP or WinUI unit test project, you will see an error similar to **"'TestContext' does not contain a definition for 'DataRow' and no accessible extension method 'DataRow' accepting a first argument of type 'TestContext' could be found (are you missing a using directive or an assembly reference?)"**.
 
-## Write the test method
+#### Write the test method
 
 The test method for `AddIntegers` is fairly simple. For each row in the data source, call `AddIntegers` with the **FirstNumber** and **SecondNumber** column values as parameters, and verify the return value against **Sum** column value:
 
 ```csharp
+[TestMethod]
 [DataSource(@"Provider=Microsoft.SqlServerCe.Client.4.0; Data Source=C:\Data\MathsData.sdf;", "Numbers")]
-[TestMethod()]
 public void AddIntegers_FromDataSourceTest()
 {
     var target = new Maths();
@@ -105,16 +175,14 @@ public void AddIntegers_FromDataSourceTest()
     int x = Convert.ToInt32(TestContext.DataRow["FirstNumber"]);
     int y = Convert.ToInt32(TestContext.DataRow["SecondNumber"]);
     int expected = Convert.ToInt32(TestContext.DataRow["Sum"]);
-    int actual = target.IntegerMethod(x, y);
+    int actual = target.AddIntegers(x, y);
     Assert.AreEqual(expected, actual,
         "x:<{0}> y:<{1}>",
         new object[] {x, y});
 }
 ```
 
-The `Assert` method includes a message that displays the `x` and `y` values of a failed iteration. By default, the asserted values - `expected` and `actual` - are already included in failed test details.
-
-### Specify the DataSourceAttribute
+#### Specify the DataSourceAttribute
 
 The `DataSource` attribute specifies the connection string for the data source and the name of the table that you use in the test method. The exact information in the connection string differs, depending on what kind of data source you are using. In this example, we used a SqlServerCe database.
 
@@ -149,7 +217,7 @@ The connection strings depend on the type of the type of data source, but it sho
     )]
 ```
 
-### Use TestContext.DataRow to access the data
+#### Use TestContext.DataRow to access the data
 
 To access the data in the `AddIntegersData` table, use the `TestContext.DataRow` indexer. `DataRow` is a <xref:System.Data.DataRow> object, so retrieve column values by index or column names. Because the values are returned as objects, convert them to the appropriate type:
 
@@ -166,26 +234,10 @@ The test results bar at the top of **Test Explorer** is animated as your test ru
 > [!NOTE]
 > There's a result for each row of data and also one summary result. If the test passed on each row of data, the summary run shows as **Passed**. If the test failed on any data row, the summary run shows as **Failed**.
 
-If you ran the `AddIntegers_FromDataSourceTest` method in our example, the results bar turns red and the test method is moved to the **Failed Tests**. A data-driven test fails if any of the iterated methods from the data source fails. When you choose a failed data-driven test in the **Test Explorer** window, the details pane displays the results of each iteration that is identified by the data row index. In our example, it appears that the `AddIntegers` algorithm does not handle negative values correctly.
+If you ran any of the `AddIntegers_FromDataRowTest`, `AddIntegers_FromDynamicDataTest` or `AddIntegers_FromDataSourceTest` method in our example, the results bar turns red and the test method is moved to the **Failed Tests**. A data-driven test fails if any of the iterated methods from the data source fails. When you choose a failed data-driven test in the **Test Explorer** window, the details pane displays the results of each iteration that is identified by the data row index. In our example, it appears that the `AddIntegers` algorithm does not handle negative values correctly.
 
 When the method under test is corrected and the test rerun, the results bar turns green and the test method is moved to the **Passed Test** group.
 
-## Run an inline data-driven test
-
-For inline tests, MSTest uses `DataRow` to retrieve values from a data source. The test in this example runs successively for each data row.
-
-```csharp
-[DataTestMethod]
-[DataRow(1, 1, 2)]
-[DataRow(2, 2, 4)]
-[DataRow(3, 3, 6)]
-[DataRow(0, 0, 1)] // The test run with this row fails
-public void AddTests(int x, int y, int expected)
-{
-  Assert.AreEqual(expected, x + y);
-}
-```
-
 ## See also
 
 - <xref:Microsoft.VisualStudio.TestTools.UnitTesting.DataSourceAttribute?displayProperty=fullName>