TechPrufer
Get started
Microsoft
Microsoft logoMicrosoft · Feature trail

Coded UI Test Deprecation and Alternatives

49 posts · Sep 2011 – Apr 2019

What this trail covers

This thread tracks the evolution of Coded UI Test functionality and its alternatives. Initially, Coded UI Test was the primary tool for UI automation. With its deprecation in Visual Studio 2019, the focus has shifted to migrating to open-source alternatives like Selenium for web applications and Appium with WinAppDriver for desktop and UWP apps. The goal is to provide robust and maintainable solutions for UI testing in modern development workflows. This post details improvements to Coded UI Test playback performance by optimizing search hierarchies, leveraging PlaybackSettings, restricting search depth with MaxDepth, prioritizing window search properties, utilizing NextSibling for faster searches, employing AlwaysSearch for dynamic controls, and using unique properties for items within containers. It also provides scenario-specific guidelines for form filling with CopyPastedText, selecting items in lists with SelectedItems vs. SelectedIndices, expanding TreeView nodes, cautious usage of the Items property, and comparing WinList, WinTable, and WinTree. Finally, it offers debugging tips for performance issues by analyzing warning and error messages in logs.

All Microsoft trails
  1. Changes to Coded UI Test in Visual Studio 2019This post announces the deprecation of Coded UI test functionality in Visual Studio 2019, explaining the decision by highlighting the rise of open-source tools like Selenium and Appium, the shift towards unit and API testing in agile development, and customer experiences with these alternatives. It provides specific recommendations for using Selenium and Appium with WinAppDriver for different application types, and mentions the EasyRepro framework for Dynamics 365 Customer Engagement and the Regression Suite Automation Tool for Dynamics 365 Finance and Operations. The post assures continued support for Coded UI tests in Visual Studio 2019 for bug fixes and discusses side-by-side installation for maintaining existing test assets and CI/CD pipelines. It explicitly states that there are no automated migration tools available and advises users to plan their migration and re-evaluate their test portfolios.
  2. Troubleshooting launch issues with xaml based apps using Coded UI TestThis post addresses a specific troubleshooting issue with launching XAML-based Windows Store apps using Coded UI Test in Windows 10. It explains that the automationID returned by the Coded UI Test engine has changed in Windows 10, causing a 'Package was not found' exception when using the XamlWindow.Launch() API. The post provides a workaround by stripping the 'tile-' prefix and '_b3rhdqcqv1gj2!App' postfix from the reported automationID to successfully launch the application.
  3. Coded UI Test Extensibility V2This post details the V2 extensibility changes for Coded UI Tests, focusing on windowless control support (including Modern Apps), control-specific targeting, and APIs not tied to window handles. Key design changes include modifications to authoring logic, where the Technology Abstraction Layer (TAL) stitches query IDs based on UIA hierarchy and queries registered plugins. Playback/Navigation now uses AutomationElement as a common factor for technology switches. New APIs in UITechnologyManagerProxy/UITechnologyManager and UITechnologyElementProxy/UITechnologyElement are introduced to facilitate these changes, with default implementations for backward compatibility.
  4. Coded UI testing support for Silverlight using Visual Studio 2013This post announces the availability of a Coded UI test plugin for Silverlight that works with Visual Studio 2013. It supports browser-hosted Silverlight 5 applications and Internet Explorer versions 8, 9, 10, and 11. Users require Visual Studio 2013 RTM or Visual Studio 2013 Update 3 CTP1 or higher.
  5. Test controllers are not visible or marked offline in MTM when multiple versions of MTM are installedDetails a known issue where Test Controllers appear offline in Microsoft Test Manager (MTM) when multiple versions of Visual Studio are installed on the same machine, and a newer MTM version attempts to connect to an older Test Controller. The issue is caused by assembly version conflicts. Workarounds involve using assembly redirection in `mtm.exe.config` to point to the correct assembly versions or using the older MTM client to connect to the older Test Controller.
  7. Using Coded UI to test XAML-based Windows Phone appsThis post details the essentials of creating a Coded UI test for XAML-based Windows Phone apps using Visual Studio 2013 Update 2 RC. It covers using the Coded UI test builder to spy on UI controls and generate a UIMap, interacting with UI elements using specialized Xaml* classes (e.g., XamlButton, XamlEdit) from the Microsoft.VisualStudio.TestTools.UITesting.WindowsRuntimeControls namespace, and handling Shell controls as UITestControl. It also explains how to launch apps using the XamlWindow.Launch API and the app's AutomationId, execute tests from Visual Studio or the command-line using vstest.console.exe with a runsettings file, and data-drive tests using the DataRow attribute. Key differences between Coded UI for Windows and Windows Phone apps are highlighted, including target execution environments, command-line execution requirements, specialized classes for shell controls, WebView control support, and data-driving methods. Limitations such as the lack of action step recording and support only for XAML-based store apps are also noted.
  8. Coded UI MTM Issues on Internet Explorer with KB2870699This post addresses issues with Coded UI Tests, MTM Record and Playback, and MTM Exploratory Testing on Internet Explorer caused by a recent security update (KB2870699) affecting IE11, IE10, and IE9. The issues manifest as recording failures and errors during recording when navigating to a new page and performing an action. Fixes for Visual Studio 2012 and Visual Studio 2010 SP1 are provided.
  9. Coded UI Test Gesture support in Visual Studio 2013Introduced playback support for touch gestures on Windows Store Apps within Coded UI Test. This includes API support for Static Gestures (Tap, Double Tap, Press-and-Hold) and Manipulation Gestures (Slide, Swipe, Flick, Pinch, Stretch, Turn). The post details the parameters and usage for each gesture type, including control-based and control-less operations. Limitations regarding custom gestures, UI synchronization, and edge gestures in multi-monitor setups are also outlined.
  10. Using Coded UI to test XAML-based Windows Store appsIntroduces the ability to use Coded UI tests for XAML-based Windows Store apps in Visual Studio 2013 Preview. This includes new specialized classes for XAML controls (e.g., XamlButton, XamlList) under the Microsoft.VisualStudio.TestTools.UITesting.WindowsRuntimeControls namespace, support for touch gestures via the Gesture class, and methods for launching Store apps using the app tile or the XamlWindow.Launch API. Limitations include no recording of action steps and support only for XAML-based store apps, not WinJS apps.
  11. Managing Browser Profiles when using Cross Browser testing in Coded UI TestThis post addresses specific challenges in managing browser profiles for cross-browser testing with Coded UI Test. It details two common issues: 1) when a profile is not picked up, providing solutions involving command-line arguments (`--user-data-dir`) and environment variables (`ChromeProfileDirectory`, `FireFoxProfileDirectory`), and 2) when multiple Chrome browser launches fail due to profile locking, explaining that Chrome's profile directory cannot be shared by multiple instances and suggesting workarounds like creating temporary copies of the profile folder. It also notes that Firefox handles this by copying profiles internally.
  12. Mixed Native and Managed Debugging Improvements for Windows Store AppsIntroduced improvements to mixed native and managed debugging for Windows Store apps in Visual Studio 2012 Update 1. This includes enabling mixed mode debugging via project properties, enhancing object inspection in locals/watch windows for WinRT objects, applying Debugger Type Visualizers, and enabling remote debugging on x86/x64 machines. Execution control improvements allow for more reliable stepping between WinRT and native components.
  13. February CTP for Visual Studio Update 2This CTP introduces the ability to execute JavaScript within Coded UI tests for Internet Explorer and cross-browser scenarios (Firefox, Chrome), providing an `ExecuteScript` API. It also adds Fakes to Visual Studio Premium, enables cloning test cases in Microsoft Test Manager, introduces a Visual Profiler for HTML/JavaScript Windows Store apps, and enhances web-based test case management with pause/resume functionality and attachment support.
  14. UI Testing of Microsoft SharePoint 2013 with Visual Studio 2012This post details the use of Coded UI Test for Microsoft SharePoint 2013 applications, including record and play support, cross-browser testing with Chrome and Firefox (requiring VS Update 1), and specific hand-coding changes for Excel (double-clicking cells, using RowIndex/ColumnIndex for cell identification) and cross-browser scenarios (setting CUIT_SELENIUM_CLICKCOORDINATEBASED, adding waits, changing UI control to parent). It also lists unsupported features like Silverlight and Visio controls.
  15. Introducing window based smart match for Cross Browser Testing with Coded UI TestIntroduced smart matching for top-level windows in cross-browser testing with Coded UI Test for Firefox and Chrome. This enhancement improves resilience by applying heuristics to identify windows when titles change, such as variations in unread counts or spacing. The post also provides tips for optimizing performance by using 'Contains' based searches when parts of the title are known to change.
  16. Introducing JavaScript Execution on InternetExplorer and CrossBrowser in Coded UI TestIntroduced JavaScript execution capabilities within Coded UI Tests for Internet Explorer and cross-browser scenarios (Firefox 15+, Chrome 21+) via the `ExecuteScript` method on the `BrowserWindow` class. This enables users to perform complex actions, use custom controls, and potentially simplify test code by leveraging JavaScript directly. The API supports passing various argument types and returning values, including HTML controls. Limitations include no built-in timeout for script execution and specific handling for 'Int' types and frame access.
  17. Troubleshooting tips for cross browser testing in Coded UI TestThis post provides troubleshooting tips for cross-browser testing with Coded UI Test, focusing on common failure scenarios and their workarounds. It details how to diagnose and fix search failures by using browser developer tools to inspect control properties and comparing them with test code. It also addresses issues with dynamic IDs, the need to move filter properties to search properties, and the 'Element does not exist in cache' error, suggesting `WaitForControlExist`. For blocked control exceptions, it recommends relative coordinate clicks or hand-coding workarounds. Known limitations regarding new tab behavior in Chrome and handling of OS dialogs are also outlined.
  18. Coded UI Test: Configuring Search Properties while recording on Internet ExplorerIntroduces a new feature in Coded UI Test (VS Update 1) that allows users to configure search and filter properties for controls during recording, specifically for Internet Explorer. This customization is managed via an XML configuration file (IEPropertyConfiguration.xml) and an XSD validator. Users can add, remove, or interchange properties for different control types. The post also details the 'ApplySmartConfiguration' attribute, which controls whether Coded UI Test applies its own smart logic (like auto-property interchange) on top of user configurations, and outlines various property-specific validations and restrictions.
  19. Integrating existing testing systems with Microsoft Test Manager, Team Foundation Server and Visual StudioThis post details how to integrate existing test tools with Microsoft Test Manager and Team Foundation Server. It outlines a four-step pattern: filing bugs from an IDE into TFS, creating test cases in TFS programmatically using the Test Management Service API, creating a Visual Studio test type that wraps an existing test execution engine (demonstrated by shelling out to an executable), and associating these automated tests with test cases in TFS using TCM or programmatically. It provides code snippets for creating test cases and executing external processes from within a Visual Studio test.
  20. Retrying failed playback actions with Coded UIIntroduced API support for retrying or skipping failed UI actions in Coded UI tests, allowing for continued playback of subsequent steps. This enhances test resilience by handling transient issues like unexpected dialogs or slow server responses without requiring a full test rerun.
  21. Migrating Coded UI Test Projects on VS 2012This post details the silent upgrade mechanism for Coded UI Test projects between Visual Studio 2010 SP1 and Visual Studio 2012. It explains how conditional referencing in project files allows projects to be compatible with both versions by enabling specific assembly references based on the Visual Studio version. It also covers handling custom references, in-house assemblies, and specific scenarios like converting VS 2012 projects to 2010 SP1, dealing with Visual Studio 2010 Feature Pack 2, and issues with Team Build and Ordered Tests.
  22. Coded UI Test: Why does application close after each test in Visual Studio 2012?This post addresses a bug in Visual Studio 2012 related to the `CloseOnPlaybackCleanup` flag in Coded UI Tests. Previously, the flag was not honored, causing applications to remain open after test completion. In VS 2012, the fix ensures the flag is respected, meaning applications will close by default after each test. To reuse an application instance across multiple tests, `CloseOnPlaybackCleanup` must be set to `false` for the `ApplicationUnderTest` or `BrowserWindow` object.
  23. Enabling Tracing and HtmlLogger in Coded UI TestThis post details how to enable tracing and HtmlLogger for Coded UI Tests in Visual Studio 2012. It explains the configuration methods for different scenarios, including when an App.config file is present or absent, and for both .NET v4.0 and v4.5 target framework versions. It also highlights the deprecation of specific settings like EnableHtmlLogger and EnableSnapshotInfo in favor of EqtTraceLevel.
  24. Edit Test Case properties directly from the test runner of Microsoft Test ManagerIntroduced the ability to edit test case properties directly from the test runner in Microsoft Test Manager. This allows for on-the-fly modifications to test case steps, text, iteration, state, and summary fields during a test run. The changes are saved but do not affect the current test run; a new test run is required for modifications to take effect. This feature aims to improve test case maintenance and quality by enabling direct edits during the testing process.
  25. UI Testing SharePoint 2010 with Visual Studio 2012This post enumerates minor workarounds for using Coded UI Tests with SharePoint 2010 applications in Visual Studio 2012. It provides specific code examples for handling Excel web parts, including double-clicking cells and interacting with dynamically generated `<div>` controls. It also details the setup process for testing SharePoint Silverlight controls using a Visual Studio UI Test Plugin for Silverlight and Fiddler, including copying helper DLLs and generating test code that references `Microsoft.VisualStudio.TestTools.UITest.Extension.Silverlight.dll`.
  26. Introducing Cross Browser Testing with Coded UI TestsIntroduces cross-browser testing capabilities for Coded UI Tests by integrating with Selenium WebDriver. Allows tests recorded in IE to be played back on Firefox and Chrome by setting BrowserWindow.CurrentBrowser. Provides features for recording, hand-coding, and troubleshooting cross-browser tests. Lists system requirements including specific browser versions and Visual Studio editions.
  27. Microsoft Update available for Visual Studio 2010 SP1This update provides compatibility support for Visual Studio 2012 and Windows 8 for Visual Studio 2010 SP1 Test Tools. It enables running Coded UI Tests for .NET Framework 4.5-based WPF controls and 64-bit Internet Explorer 10 on Windows 8. It also includes bug fixes for issues related to opening code coverage files generated by Visual Studio 2012 or TFS 2012 in Visual Studio 2010 SP1, assigning test artifacts to invalid users after upgrading TFS 2010 to TFS 2012, and operating system crashes when running load tests with non-LAN network types on Windows 8.
  28. Odin ships Axe 3.4 simultaneously with Visual Studio 2012Odin's Axe product uses code generation to enable testers to define tests in Excel spreadsheets, generating approximately 95% of the automation code, with the remaining 5% handled by test or development teams. Axe also handles writing test steps in MTM in a human-readable format. Axe 3.4 adds support for Visual Studio and TFS 2012, integration with IBM Rational Quality Manager (RQM) and SAP GUI Scripting, and enhancements to TFS integration for automated test association and results import.
  29. Few tips on implementing a Coded UI Test Plugin ExtensionThis post provides specific technical tips for implementing Coded UI Test plugin extensions, including setting ComVisibleAttribute, implementing caching mechanisms for property providers, limiting class hierarchy, avoiding live UITestControl property access in GetControlSupportLevel, using unique names for extension managers, avoiding specific implementation inside specialized class properties, and utilizing new extension proxy classes.
  30. Significance of Window Titles in Coded UI Test PlaybackThis post explains the control search mechanism in Coded UI Test playback, detailing how window titles are used to locate top-level windows and their child controls. It describes the two-phase search heuristic and the impact of dynamic window title changes on test playback. The post also highlights a bug fix in VS2011 RC that simplifies the process of updating window titles for controls within a top-level window.
  31. UI Test Plugin for Silverlight ApplicationsIntroduced a Microsoft Visual Studio UI Test plugin for Silverlight applications, enabling the creation of Coded UI Tests or action recordings for Silverlight applications. This plugin supports Silverlight 4 & 5 applications hosted in Internet Explorer versions 8, 9 & 10 and requires Microsoft Visual Studio 2012 RC. This plugin was built as an off-hours project by a few members of the product team.
  32. Visual Studio Coded UI for Word Add-In v2 Sample Solution has shipped!This post announces the release of a sample solution for Visual Studio Coded UI with a Microsoft Word Add-in. This add-in extends Coded UI capabilities to Microsoft Word documents by enabling document location referencing for mouse and keyboard actions, and supporting assertions on contiguous document selections. This addresses limitations of the base Coded UI feature, which previously only supported referencing Word menu/ribbon controls and screen locations.
  33. DevExpress Releases DXperience 12.1 with Coded UI SupportThis post announces DevExpress DXperience 12.1's Coded UI support for WinForms controls, enabling UI testing from Visual Studio and Microsoft Test Manager. It provides links to MSDN documentation, DevExpress's white paper and videos on Coded UI support, and a trial download. This contributes to the ongoing evolution of Coded UI testing capabilities by showcasing third-party vendor support.
  34. Enabling Coded UI Test playback logs in Visual Studio 2012 Release CandidateThis post details how to enable Coded UI Test playback logs by modifying the QTAgent32.exe.config file. It provides specific XML configurations for `<system.diagnostics>` switches (EqtTraceLevel set to 4 for verbose) and `<appSettings>` (EnableHtmlLogger, EnableSnapshotInfo, LogSizeLimitInMegs, etc.). It also shows how to access the generated UITestActionLog.html file from the Test Explorer results.
  35. Coded UI Test - New Extensibility QFEIntroduced a new, simpler extension model for Coded UI Test, enabling the creation of plugins for custom controls (Windows Forms, WPF, ASP.NET) in minutes rather than days. This is achieved by abstracting complex processing into a proxy technology manager, exposing only a limited set of overrides via `UITechnologyElementProxy` and `UITechnologyManagerProxy` classes. This significantly reduces the effort required to customize control identification and record/playback for automation tests.
  36. Acceptance Testing UI using Visual Studio 2010 Microsoft Test Manager and Fit style tablesThis post details how to create data-bound Coded UI Tests using Microsoft Test Manager and Fit-style tables in Visual Studio 2010. It outlines the steps for creating test cases, recording actions, generating Coded UI tests, data-binding them to CSV files, and using the 'Params' object to set input values from the data source. It also mentions the option to change the data access method from sequential to random.
  37. Visual Studio Coded UI for Word Add-In Sample Solution has shipped!This post announces the release of a sample solution for the Visual Studio Coded UI Microsoft Word Add-in. This add-in extends Coded UI support to Microsoft Word documents, addressing limitations such as only being able to reference Word menu and ribbon controls, screen locations of actions, and lacking support for assertions within a document. The add-in provides document location referencing for mouse and keyboard actions, and assertions on contiguous document selection.
  38. Visual Studio 11 Beta - What is new in Coded UI Tests?This post announces enhancements to Coded UI Tests in Visual Studio 11 Beta, including support for new features in Internet Explorer 9 & 10 (HTML5, spell checking, 64-bit IE, pinned sites, semantic tags, whitespace handling, notification area), new UI Testing APIs (HtmlControls, WinControls, WpfControls), an integrated Coded UI Test Editor, changes to the project creation workflow (using Unit Test Explorer, removal of Data Source Wizard), and enhancements to the Coded UI Test Builder (method descriptions, assertion messages). It also lists third-party control support links and feedback channels.
  39. Handling playback failures in Coded UI Test due to stale UI controlsThis post addresses playback failures in Coded UI Test caused by stale UI controls, specifically when interacting with controls within popup windows like dialog boxes or context menus. It explains that the error 'FailedToPerformActionOnBlockedControlException' often stems from a stale accessible object persisting after an earlier instance of the same window was not disposed of properly. The post provides three workarounds: 1. Using the `VisibleOnly` search configuration for the target control and its ancestors. 2. Combining `VisibleOnly` with `AlwaysSearch` (with caution due to performance impact). 3. Using the `OrderOfInvocation` property for the top-level window to disambiguate duplicate windows. It also suggests using `DrawHighlight()` for visual verification and provides a method to collect all matching windows to verify the desktop session state.
  40. Test View Issue: An exception was encountered while constructing the content of this frameThis post addresses a specific bug encountered in Visual Studio 2010's Test View window, where an exception occurs during content construction. It provides a temporary fix (closing and reopening Visual Studio) and a permanent solution by adjusting the 'Test Tools' options to disable the prompt for test changes when background discovery is off. The underlying exception details indicate a conflict with command handlers for a menu command.
  41. Guidelines on improving performance of Coded UI Test playbackThis post provides guidelines on improving the performance of Coded UI Test playback. It details techniques such as extending auto-generated search hierarchies, making use of PlaybackSettings, using MaxDepth to restrict search sub-trees, giving precedence to window search properties over accessibility properties, utilizing NextSibling for faster searches, and employing the AlwaysSearch configuration option. It also offers scenario-specific guidelines for form filling using the CopyPastedText property, preferring SelectedItems over SelectedIndices for large lists, expanding all nodes in a TreeView control, being cautious about Items property usage, comparing WinList, WinTable, and WinTree, and using the Exists property. Additionally, it provides debugging tips for performance issues by analyzing warning and error messages in logs.
  42. How To: Bulk edit action recording?Introduced sample code to programmatically edit existing action recordings in Microsoft Test Manager (MTM) to update UI Map changes, avoiding the need to re-record tests.
  43. Sample XPath utility for Coded UI TestIntroduced a sample utility that adds XPath query support to Coded UI Test for searching controls. This utility provides two extension methods, `FindFirstByXPath` and `FindAllByXPath`, to the `UITestControl` class. It leverages the built-in XPath parser and .NET classes, conforming to .NET's XPath Syntax. The post highlights two key limitations: a semantic difference in search (depth-first vs. breadth-first) and a performance penalty compared to the built-in search. It advises prudent use of this utility, recommending it for scenarios where the ease of use and power of XPath are critical and the control tree is not excessively deep.
  44. Troubleshooting Record and Playback issues in Coded UI TestThis post provides troubleshooting steps and workarounds for common record and playback issues encountered with Coded UI Test. It enumerates basic validations that users can perform to debug problems and offers solutions for specific failure scenarios.
  45. Coded UI Test Extension for 3rd party Windows Forms controls–How to?This post details how to extend Coded UI Test support to third-party Windows Forms controls by implementing Microsoft Active Accessibility (MSAA) on the control, overriding accessibility methods for basic record and playback, and implementing a custom PropertyProvider to enable rich property validation (e.g., BackColor, ForeColor) via the Coded UI Test Builder. It also covers creating specialized classes for custom controls to enable code generation for these controls in recorded tests. The post provides detailed code examples for each level of implementation.
  46. Coded UI Test Extension for 3rd party controls - the basics explainedThis post details the four levels of implementing Coded UI Test support for third-party controls: Level 1 (Basic Record and Playback) allows for element identification and basic property validation; Level 2 (Rich Property Validation) enables assertions on custom properties; Level 3 (Code Generation) allows for specialized classes and more readable auto-generated test code; and Level 4 (Intent Aware Actions) aggregates actions for more accurate recording based on control behavior. Implementing these levels requires extending the Technology Abstraction Layer (TAL), PropertyProvider, and ActionFilter.
  47. A custom data diagnostic adapter for Visual Studio Coded UI Test using Windows PSRIntroduced a custom diagnostic data adapter for Visual Studio Coded UI Test that integrates with Windows Problem Steps Recorder (PSR). This adapter automatically starts PSR at the beginning of each test case to capture UI actions and screenshots, and stops PSR at the end of the test case to generate a zipped HTML report. In case of test failure, an additional screenshot is captured and attached to the test results. This enhances debugging capabilities for UI test automation by providing detailed, yet concise, troubleshooting logs without the overhead of full video recordings.
  48. Visual Studio 11 Developer Preview Testing DocumentationThis post announces new documentation for Visual Studio 11 Developer Preview, specifically covering testing features. It introduces Exploratory Testing in Microsoft Test Manager, detailing its capabilities for unscripted testing, bug filing, and manual test case creation. It also covers manual testing for Metro style apps on remote devices and introduces unit testing for Metro style apps. A significant update is the Unit Test Explorer, which unifies the running of various test types (.NET, unmanaged, database) and supports different unit test frameworks.