Add tests for C# and Basic encapsulatefield

src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpEncapsulateField.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.VisualStudio.IntegrationTest.Utilities;
+using Roslyn.Test.Utilities;
+using Roslyn.VisualStudio.IntegrationTests.Extensions;
+using Roslyn.VisualStudio.IntegrationTests.Extensions.Editor;
+using Xunit;
+
+namespace Roslyn.VisualStudio.IntegrationTests.CSharp
+{
+    [Collection(nameof(SharedIntegrationHostFixture))]
+    public class CSharpEncapsulateField : AbstractEditorTest
+    {
+        public CSharpEncapsulateField(VisualStudioInstanceFactory instanceFactory)
+            : base(instanceFactory, nameof(CSharpEncapsulateField))
+        {
+        }
+
+        protected override string LanguageName => LanguageNames.CSharp;
+
+        private const string TestSource = @"
+namespace myNamespace
+{
+    class Program
+    {
+        private static int? $$param = 0;
+        static void Main(string[] args)
+        {
+            param = 80;
+        }
+    }
+}";
+
+        [Fact, Trait(Traits.Feature, Traits.Features.EncapsulateField)]
+        public void EncapsulateThroughCommand()
+        {
+            SetUpEditor(TestSource);
+
+            var encapsulateField = VisualStudio.Instance.EncapsulateField;
+            var dialog = VisualStudio.Instance.PreviewChangesDialog;
+            encapsulateField.Invoke();
+            dialog.VerifyOpen(encapsulateField.DialogName);
+            dialog.ClickCancel(encapsulateField.DialogName);
+            dialog.VerifyClosed(encapsulateField.DialogName);
+            encapsulateField.Invoke();
+            dialog.VerifyOpen(encapsulateField.DialogName);
+            dialog.ClickApply(encapsulateField.DialogName);
+            this.VerifyTextContains("public static int? Param { get => param; set => param = value; }");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.EncapsulateField)]
+        public void EncapsulateThroughLightbulbIncludingReferences()
+        {
+            SetUpEditor(TestSource);
+            this.InvokeCodeActionList();
+            this.VerifyCodeAction("Encapsulate field: 'param' (and use property)", applyFix: true, blockUntilComplete: true);
+            this.VerifyTextContains(@"
+namespace myNamespace
+{
+    class Program
+    {
+        private static int? param = 0;
+
+        public static int? Param { get => param; set => param = value; }
+
+        static void Main(string[] args)
+        {
+            Param = 80;
+        }
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.EncapsulateField)]
+        public void EncapsulateThroughLightbulbDefinitionsOnly()
+        {
+            SetUpEditor(TestSource);
+            this.InvokeCodeActionList();
+            this.VerifyCodeAction("Encapsulate field: 'param' (but still use field)", applyFix: true, blockUntilComplete: true);
+            this.VerifyTextContains(@"
+namespace myNamespace
+{
+    class Program
+    {
+        private static int? param = 0;
+
+        public static int? Param { get => param; set => param = value; }
+
+        static void Main(string[] args)
+        {
+            param = 80;
+        }
+    }
+}");
+        }
+    }
+}
\ No newline at end of file

src/VisualStudio/IntegrationTest/IntegrationTests/Extensions/EditorExtensions.cs

@@ -63,7 +63,7 @@ public static void PressDialogButton(this AbstractIntegrationTest test, string d
 
         public static AutomationElement GetDialog(this AbstractIntegrationTest test, string dialogAutomationId)
         {
-            var dialog = DialogHelpers.FindDialog(test.VisualStudio.Instance.Shell.GetHWnd(), dialogAutomationId, isOpen: true);
+            var dialog = DialogHelpers.FindDialogByAutomationId(test.VisualStudio.Instance.Shell.GetHWnd(), dialogAutomationId, isOpen: true);
             return dialog;
         }
     }

src/VisualStudio/IntegrationTest/IntegrationTests/VisualBasic/BasicEncapsulateField.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.VisualStudio.IntegrationTest.Utilities;
+using Roslyn.Test.Utilities;
+using Roslyn.VisualStudio.IntegrationTests.Extensions;
+using Roslyn.VisualStudio.IntegrationTests.Extensions.Editor;
+using Xunit;
+
+namespace Roslyn.VisualStudio.IntegrationTests.Basic
+{
+    [Collection(nameof(SharedIntegrationHostFixture))]
+    public class BasicEncapsulateField : AbstractEditorTest
+    {
+        public BasicEncapsulateField(VisualStudioInstanceFactory instanceFactory)
+            : base(instanceFactory, nameof(BasicEncapsulateField))
+        {
+        }
+
+        protected override string LanguageName => LanguageNames.VisualBasic;
+
+        private const string TestSource = @"
+Module Module1
+        Public $$name As Integer? = 0
+    Sub Main()
+        name = 90
+    End Sub
+End Module";
+
+        [Fact, Trait(Traits.Feature, Traits.Features.EncapsulateField)]
+        public void EncapsulateThroughCommand()
+        {
+            SetUpEditor(TestSource);
+
+            var encapsulateField = VisualStudio.Instance.EncapsulateField;
+            var dialog = VisualStudio.Instance.PreviewChangesDialog;
+            encapsulateField.Invoke();
+            dialog.VerifyOpen(encapsulateField.DialogName);
+            dialog.ClickCancel(encapsulateField.DialogName);
+            dialog.VerifyClosed(encapsulateField.DialogName);
+            encapsulateField.Invoke();
+            dialog.VerifyOpen(encapsulateField.DialogName);
+            dialog.ClickApply(encapsulateField.DialogName);
+            this.VerifyTextContains(@"    Private _name As Integer? = 0
+
+    Public Property Name As Integer?
+        Get
+            Return _name
+        End Get
+        Set(value As Integer?)
+            _name = value
+        End Set
+    End Property");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.EncapsulateField)]
+        public void EncapsulateThroughLightbulbIncludingReferences()
+        {
+            SetUpEditor(TestSource);
+            this.InvokeCodeActionList();
+            this.VerifyCodeAction("Encapsulate field: 'name' (and use property)", applyFix: true, blockUntilComplete: true);
+            this.VerifyTextContains(@"
+Module Module1
+    Private _name As Integer? = 0
+
+    Public Property Name As Integer?
+        Get
+            Return _name
+        End Get
+        Set(value As Integer?)
+            _name = value
+        End Set
+    End Property
+
+    Sub Main()
+        Name = 90
+    End Sub
+End Module");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.EncapsulateField)]
+        public void EncapsulateThroughLightbulbDefinitionsOnly()
+        {
+            SetUpEditor(TestSource);
+            this.InvokeCodeActionList();
+            this.VerifyCodeAction("Encapsulate field: 'name' (but still use field)", applyFix: true, blockUntilComplete: true);
+            this.VerifyTextContains(@"
+Module Module1
+    Private _name As Integer? = 0
+
+    Public Property Name As Integer?
+        Get
+            Return _name
+        End Get
+        Set(value As Integer?)
+            _name = value
+        End Set
+    End Property
+
+    Sub Main()
+        name = 90
+    End Sub
+End Module");
+        }
+    }
+}
\ No newline at end of file

src/VisualStudio/IntegrationTest/IntegrationTests/VisualStudioIntegrationTests.csproj

@@ -21,6 +21,7 @@
   <ItemGroup>
     <Compile Include="AbstractIntegrationTest.cs" />
     <Compile Include="AbstractInteractiveWindowTest.cs" />
+    <Compile Include="CSharp\CSharpEncapsulateField.cs" />
     <Compile Include="CSharp\CSharpInteractiveBoxSelection.cs" />
     <Compile Include="CSharp\CSharpChangeSignatureDialog.cs" />
     <Compile Include="CSharp\CSharpClassification.cs" />
@@ -62,6 +63,7 @@
     <Compile Include="Extensions\SolutionExplorerExtensions.Verifiers.cs" />
     <Compile Include="Extensions\SolutionExplorerExtensions.cs" />
     <Compile Include="Extensions\SetOptionsExtensions.cs" />
+    <Compile Include="VisualBasic\BasicEncapsulateField.cs" />
     <Compile Include="VisualBasic\BasicSquigglesCommon.cs" />
     <Compile Include="VisualBasic\BasicSquigglesDesktop.cs" />
     <Compile Include="VisualBasic\BasicSquigglesNetCore.cs" />

src/VisualStudio/IntegrationTest/TestUtilities/DialogHelpers.cs

@@ -11,25 +11,36 @@ public static class DialogHelpers
     {
         /// <summary>
         /// Returns an <see cref="AutomationElement"/> representing the open dialog with automation ID
-        /// <paramref name="dialogAutomationName"/>.
+        /// <paramref name="dialogAutomationId"/>.
         /// Throws an <see cref="InvalidOperationException"/> if an open dialog with that name cannot be
         /// found.
         /// </summary>
-        public static AutomationElement GetOpenDialog(int visualStudioHWnd, string dialogAutomationName)
+        public static AutomationElement GetOpenDialogById(int visualStudioHWnd, string dialogAutomationId)
         {
-            var dialogAutomationElement = FindDialog(visualStudioHWnd, dialogAutomationName, isOpen: true);
+            var dialogAutomationElement = FindDialogByAutomationId(visualStudioHWnd, dialogAutomationId, isOpen: true);
             if (dialogAutomationElement == null)
             {
-                throw new InvalidOperationException($"Expected the {dialogAutomationName} dialog to be open, but it is not.");
+                throw new InvalidOperationException($"Expected the {dialogAutomationId} dialog to be open, but it is not.");
             }
 
             return dialogAutomationElement;
         }
 
-        public static AutomationElement FindDialog(int visualStudioHWnd, string dialogAutomationName, bool isOpen)
+        public static AutomationElement FindDialogByAutomationId(int visualStudioHWnd, string dialogAutomationId, bool isOpen)
         {
             return Retry(
-                () => FindDialogWorker(visualStudioHWnd, dialogAutomationName),
+                () => FindDialogWorker(visualStudioHWnd, dialogAutomationId),
+                stoppingCondition: automationElement => isOpen ? automationElement != null : automationElement == null,
+                delay: TimeSpan.FromMilliseconds(250));
+        }
+
+        /// <summary>
+        /// Used to find legacy dialogs that don't have an AutomationId
+        /// </summary>
+        public static AutomationElement FindDialogByName(int visualStudioHWnd, string dialogName, bool isOpen)
+        {
+            return Retry(
+                () => FindDialogByNameWorker(visualStudioHWnd, dialogName),
                 stoppingCondition: automationElement => isOpen ? automationElement != null : automationElement == null,
                 delay: TimeSpan.FromMilliseconds(250));
         }
@@ -40,7 +51,7 @@ public static AutomationElement FindDialog(int visualStudioHWnd, string dialogAu
         /// </summary>
         public static void SelectComboBoxItem(int visualStudioHWnd, string dialogAutomationName, string comboBoxAutomationName, string itemText)
         {
-            var dialogAutomationElement = GetOpenDialog(visualStudioHWnd, dialogAutomationName);
+            var dialogAutomationElement = GetOpenDialogById(visualStudioHWnd, dialogAutomationName);
 
             var comboBoxAutomationElement = dialogAutomationElement.FindDescendantByAutomationId(comboBoxAutomationName);
             comboBoxAutomationElement.Expand();
@@ -52,11 +63,11 @@ public static void SelectComboBoxItem(int visualStudioHWnd, string dialogAutomat
         }
 
         /// <summary>
-        /// Selects a specific radio button.
+        /// Selects a specific radio button from a dialog found by Id.
         /// </summary>
         public static void SelectRadioButton(int visualStudioHWnd, string dialogAutomationName, string radioButtonAutomationName)
         {
-            var dialogAutomationElement = GetOpenDialog(visualStudioHWnd, dialogAutomationName);
+            var dialogAutomationElement = GetOpenDialogById(visualStudioHWnd, dialogAutomationName);
 
             var radioButton = dialogAutomationElement.FindDescendantByAutomationId(radioButtonAutomationName);
             radioButton.Select();
@@ -66,11 +77,11 @@ public static void SelectRadioButton(int visualStudioHWnd, string dialogAutomati
         /// Sets the value of the specified element in the dialog.
         /// Used for setting the values of things like combo boxes and text fields.
         /// </summary>
-        public static void SetElementValue(int visualStudioHWnd, string dialogAutomationName, string elementAutomationName, string value)
+        public static void SetElementValue(int visualStudioHWnd, string dialogAutomationId, string elementAutomationId, string value)
         {
-            var dialogAutomationElement = GetOpenDialog(visualStudioHWnd, dialogAutomationName);
+            var dialogAutomationElement = GetOpenDialogById(visualStudioHWnd, dialogAutomationId);
 
-            var control = dialogAutomationElement.FindDescendantByAutomationId(elementAutomationName);
+            var control = dialogAutomationElement.FindDescendantByAutomationId(elementAutomationId);
             control.SetValue(value);
         }
 
@@ -79,11 +90,11 @@ public static void SetElementValue(int visualStudioHWnd, string dialogAutomation
         /// The button is identified using its automation ID; see <see cref="PressButtonWithName(int, string, string)"/>
         /// for the equivalent method that finds the button by name.
         /// </summary>
-        public static void PressButton(int visualStudioHWnd, string dialogAutomationName, string buttonAutomationName)
+        public static void PressButton(int visualStudioHWnd, string dialogAutomationId, string buttonAutomationId)
         {
-            var dialogAutomationElement = GetOpenDialog(visualStudioHWnd, dialogAutomationName);
+            var dialogAutomationElement = GetOpenDialogById(visualStudioHWnd, dialogAutomationId);
 
-            var buttonAutomationElement = dialogAutomationElement.FindDescendantByAutomationId(buttonAutomationName);
+            var buttonAutomationElement = dialogAutomationElement.FindDescendantByAutomationId(buttonAutomationId);
             buttonAutomationElement.Invoke();
         }
 
@@ -92,20 +103,42 @@ public static void PressButton(int visualStudioHWnd, string dialogAutomationName
         /// The button is identified using its name; see <see cref="PressButton(int, string, string)"/>
         /// for the equivalent methods that finds the button by automation ID.
         /// </summary>
-        public static void PressButtonWithName(int visualStudioHWnd, string dialogAutomationName, string buttonName)
+        public static void PressButtonWithName(int visualStudioHWnd, string dialogAutomationId, string buttonName)
+        {
+            var dialogAutomationElement = GetOpenDialogById(visualStudioHWnd, dialogAutomationId);
+
+            var buttonAutomationElement = dialogAutomationElement.FindDescendantByName(buttonName);
+            buttonAutomationElement.Invoke();
+        }
+
+        /// <summary>
+        /// Presses the specified button from a legacy dialog that has no AutomationId.
+        /// The button is identified using its name; see <see cref="PressButton(int, string, string)"/>
+        /// for the equivalent methods that finds the button by automation ID.
+        /// </summary>
+        public static void PressButtonWithNameFromDialogWithName(int visualStudioHWnd, string dialogName, string buttonName)
         {
-            var dialogAutomationElement = GetOpenDialog(visualStudioHWnd, dialogAutomationName);
+            var dialogAutomationElement = FindDialogByName(visualStudioHWnd, dialogName, isOpen: true);
 
             var buttonAutomationElement = dialogAutomationElement.FindDescendantByName(buttonName);
             buttonAutomationElement.Invoke();
         }
 
         private static AutomationElement FindDialogWorker(int visualStudioHWnd, string dialogAutomationName)
+            => FindDialogByPropertyWorker(visualStudioHWnd, dialogAutomationName, AutomationElement.AutomationIdProperty);
+
+        private static AutomationElement FindDialogByNameWorker(int visualStudioHWnd, string dialogName)
+            => FindDialogByPropertyWorker(visualStudioHWnd, dialogName, AutomationElement.NameProperty);
+
+        private static AutomationElement FindDialogByPropertyWorker(
+            int visualStudioHWnd, 
+            string propertyValue, 
+            AutomationProperty nameProperty)
         {
             var vsAutomationElement = AutomationElement.FromHandle(new IntPtr(visualStudioHWnd));
 
             Condition elementCondition = new AndCondition(
-                new PropertyCondition(AutomationElement.AutomationIdProperty, dialogAutomationName),
+                new PropertyCondition(nameProperty, propertyValue),
                 new PropertyCondition(AutomationElement.ControlTypeProperty, ControlType.Window));
 
             return vsAutomationElement.FindFirst(TreeScope.Descendants, elementCondition);

src/VisualStudio/IntegrationTest/TestUtilities/InProcess/Editor_InProc.cs

@@ -229,7 +229,7 @@ public void MessageBox(string message)
 
         public void VerifyDialog(string dialogAutomationId, bool isOpen)
         {
-            var dialogAutomationElement = DialogHelpers.FindDialog(GetDTE().MainWindow.HWnd, dialogAutomationId, isOpen);
+            var dialogAutomationElement = DialogHelpers.FindDialogByAutomationId(GetDTE().MainWindow.HWnd, dialogAutomationId, isOpen);
 
             if ((isOpen && dialogAutomationElement == null) ||
                 (!isOpen && dialogAutomationElement != null))
@@ -240,7 +240,7 @@ public void VerifyDialog(string dialogAutomationId, bool isOpen)
 
         public void DialogSendKeys(string dialogAutomationName, string keys)
         {
-            var dialogAutomationElement = DialogHelpers.GetOpenDialog(GetDTE().MainWindow.HWnd, dialogAutomationName);
+            var dialogAutomationElement = DialogHelpers.GetOpenDialogById(GetDTE().MainWindow.HWnd, dialogAutomationName);
 
             dialogAutomationElement.SetFocus();
             SendKeys.SendWait(keys);

src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/ChangeSignatureDialog_OutOfProc.cs

@@ -21,13 +21,13 @@ public ChangeSignatureDialog_OutOfProc(VisualStudioInstance visualStudioInstance
         public void VerifyOpen()
         {
             // FindDialog will wait until the dialog is open, so the return value is unused.
-            DialogHelpers.FindDialog(GetMainWindowHWnd(), ChangeSignatureDialogAutomationId, isOpen: true);
+            DialogHelpers.FindDialogByAutomationId(GetMainWindowHWnd(), ChangeSignatureDialogAutomationId, isOpen: true);
         }
   
         public void VerifyClosed()
         {
             // FindDialog will wait until the dialog is closed, so the return value is unused.
-            DialogHelpers.FindDialog(GetMainWindowHWnd(), ChangeSignatureDialogAutomationId, isOpen: false);
+            DialogHelpers.FindDialogByAutomationId(GetMainWindowHWnd(), ChangeSignatureDialogAutomationId, isOpen: false);
         }
 
         public void Invoke()
@@ -53,7 +53,7 @@ public void ClickRestoreButton()
 
         public void SelectParameter(string parameterName)
         {
-            var dialogAutomationElement = DialogHelpers.FindDialog(GetMainWindowHWnd(), ChangeSignatureDialogAutomationId, isOpen: true);
+            var dialogAutomationElement = DialogHelpers.FindDialogByAutomationId(GetMainWindowHWnd(), ChangeSignatureDialogAutomationId, isOpen: true);
 
             Condition propertyCondition = new PropertyCondition(AutomationElement.AutomationIdProperty, "MemberSelectionList");
             var grid = dialogAutomationElement.FindFirst(TreeScope.Descendants, propertyCondition);

src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/Editor_OutOfProc.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.IntegrationTest.Utilities.Common;
 using Microsoft.VisualStudio.IntegrationTest.Utilities.InProcess;
+using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
 
 namespace Microsoft.VisualStudio.IntegrationTest.Utilities.OutOfProcess
 {
@@ -127,5 +129,10 @@ public void WaitForActiveView(string viewName)
 
         public string[] GetErrorTags()
             => _editorInProc.GetErrorTags();
+
+        public void EncapsulateField()
+        {
+            SendKeys(new KeyPress(VirtualKey.R, ShiftState.Ctrl), new KeyPress(VirtualKey.E, ShiftState.Ctrl));
+        }
     }
 }
\ No newline at end of file

src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/EncapsulateField_OutOfProc.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Windows.Automation;
+using Microsoft.VisualStudio.IntegrationTest.Utilities.InProcess;
+using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+
+namespace Microsoft.VisualStudio.IntegrationTest.Utilities.OutOfProcess
+{
+    public class EncapsulateField_OutOfProc : OutOfProcComponent
+    {
+        public string DialogName = "Preview Changes - Encapsulate Field";
+
+        public EncapsulateField_OutOfProc(VisualStudioInstance visualStudioInstance) : base(visualStudioInstance)
+        {
+        }
+
+        public void Invoke()
+            => VisualStudioInstance.Editor.SendKeys(new KeyPress(VirtualKey.R, ShiftState.Ctrl), new KeyPress(VirtualKey.E, ShiftState.Ctrl));
+    }
+}

src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/GenerateTypeDialog_OutOfProc.cs

@@ -18,7 +18,7 @@ public GenerateTypeDialog_OutOfProc(VisualStudioInstance visualStudioInstance)
 
         public void VerifyOpen()
         {
-            var dialog = DialogHelpers.FindDialog(GetMainWindowHWnd(), GenerateTypeDialogID, isOpen: true);
+            var dialog = DialogHelpers.FindDialogByAutomationId(GetMainWindowHWnd(), GenerateTypeDialogID, isOpen: true);
 
             if (dialog == null)
             {
@@ -28,7 +28,7 @@ public void VerifyOpen()
 
         public void VerifyClosed()
         {
-            var dialog = DialogHelpers.FindDialog(GetMainWindowHWnd(), GenerateTypeDialogID, isOpen: false);
+            var dialog = DialogHelpers.FindDialogByAutomationId(GetMainWindowHWnd(), GenerateTypeDialogID, isOpen: false);
 
             if (dialog != null)
             {
@@ -83,7 +83,7 @@ public void ClickCancel()
 
         public string[] GetNewFileComboBoxItems()
         {
-            var dialog = DialogHelpers.GetOpenDialog(GetMainWindowHWnd(), GenerateTypeDialogID);
+            var dialog = DialogHelpers.GetOpenDialogById(GetMainWindowHWnd(), GenerateTypeDialogID);
             var createNewFileComboBox = dialog.FindDescendantByAutomationId("CreateNewFileComboBox");
             createNewFileComboBox.Expand();
 

src/VisualStudio/IntegrationTest/TestUtilities/OutOfProcess/PreviewChangesDialog_OutOfProc.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Windows.Automation;
+using Microsoft.VisualStudio.IntegrationTest.Utilities.InProcess;
+using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+
+namespace Microsoft.VisualStudio.IntegrationTest.Utilities.OutOfProcess
+{
+    public class PreviewChangesDialog_OutOfProc : OutOfProcComponent
+    {
+        public PreviewChangesDialog_OutOfProc(VisualStudioInstance visualStudioInstance) : base(visualStudioInstance)
+        {
+        }
+
+        /// <summary>
+        /// Verifies that the Preview Changes dialog is showing with the
+        /// specified title. The dialog does not have an AutomationId and the 
+        /// title can be changed by features, so callers of this method must
+        /// specify a title.
+        /// </summary>
+        /// <param name="expectedTitle"></param>
+        public void VerifyOpen(string expectedTitle)
+            => DialogHelpers.FindDialogByName(GetMainWindowHWnd(), expectedTitle, isOpen: true);
+
+        public void VerifyClosed(string expectedTitle)
+            => DialogHelpers.FindDialogByName(GetMainWindowHWnd(), expectedTitle, isOpen: false);
+
+        public void ClickApply(string expectedTitle)
+            => DialogHelpers.PressButtonWithNameFromDialogWithName(GetMainWindowHWnd(), expectedTitle, "Apply"); 
+
+        public void ClickCancel(string expectedTitle)
+            => DialogHelpers.PressButtonWithNameFromDialogWithName(GetMainWindowHWnd(), expectedTitle, "Cancel");
+
+        private int GetMainWindowHWnd()
+            => VisualStudioInstance.Shell.GetHWnd();
+    }
+}

src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioInstance.cs

@@ -21,24 +21,28 @@ public class VisualStudioInstance
         private readonly IpcClientChannel _integrationServiceChannel;
         private readonly VisualStudio_InProc _inProc;
 
-        public SendKeys SendKeys { get; }
-
         public ChangeSignatureDialog_OutOfProc ChangeSignatureDialog { get; }
 
         public CSharpInteractiveWindow_OutOfProc CSharpInteractiveWindow { get; }
 
         public Editor_OutOfProc Editor { get; }
 
+        public EncapsulateField_OutOfProc EncapsulateField { get; }
+
+        public ErrorList_OutOfProc ErrorList { get; }
+
         public FindReferencesWindow_OutOfProc FindReferencesWindow { get; }
 
         public GenerateTypeDialog_OutOfProc GenerateTypeDialog { get; }
 
+        public PreviewChangesDialog_OutOfProc PreviewChangesDialog { get; }
+
+        public SendKeys SendKeys { get; }
+
         public Shell_OutOfProc Shell { get; }
 
         public SolutionExplorer_OutOfProc SolutionExplorer { get; }
 
-        public ErrorList_OutOfProc ErrorList { get; }
-
         public VisualStudioWorkspace_OutOfProc VisualStudioWorkspace { get; }
 
         internal DTE Dte { get; }
@@ -84,9 +88,11 @@ public VisualStudioInstance(Process hostProcess, DTE dte, ImmutableHashSet<strin
             ChangeSignatureDialog = new ChangeSignatureDialog_OutOfProc(this);
             CSharpInteractiveWindow = new CSharpInteractiveWindow_OutOfProc(this);
             Editor = new Editor_OutOfProc(this);
+            EncapsulateField = new EncapsulateField_OutOfProc(this);
             ErrorList = new ErrorList_OutOfProc(this);
             FindReferencesWindow = new FindReferencesWindow_OutOfProc(this);
             GenerateTypeDialog = new GenerateTypeDialog_OutOfProc(this);
+            PreviewChangesDialog = new PreviewChangesDialog_OutOfProc(this);
             Shell = new Shell_OutOfProc(this);
             SolutionExplorer = new SolutionExplorer_OutOfProc(this);
             VisualStudioWorkspace = new VisualStudioWorkspace_OutOfProc(this);

src/VisualStudio/IntegrationTest/TestUtilities/VisualStudioIntegrationTestUtilities.csproj

@@ -53,10 +53,12 @@
     <Compile Include="Interop\NativeMethods.cs" />
     <Compile Include="LightBulbHelper.cs" />
     <Compile Include="OutOfProcess\ChangeSignatureDialog_OutOfProc.cs" />
+    <Compile Include="OutOfProcess\EncapsulateField_OutOfProc.cs" />
     <Compile Include="OutOfProcess\ErrorList_OutOfProc.cs" />
     <Compile Include="OutOfProcess\FindReferencesWindow_OutOfProc.cs" />
     <Compile Include="OutOfProcess\GenerateTypeDialog_OutOfProc.cs" />
     <Compile Include="OutOfProcess\OutOfProcComponent.cs" />
+    <Compile Include="OutOfProcess\PreviewChangesDialog_OutOfProc.cs" />
     <Compile Include="OutOfProcess\Shell_OutOfProc.cs" />
     <Compile Include="OutOfProcess\SolutionExplorer_OutOfProc.cs" />
     <Compile Include="InProcess\VisualStudioWorkspace_InProc.cs" />