TechPrufer
Get started
Microsoft
Microsoft logoMicrosoft · Feature trail

Visual Studio Unit Testing Framework

52 posts · Feb 2012 – Sep 2017

What this trail covers

The Visual Studio Test Platform has been open-sourced under the MIT license to foster collaborative innovation. This move aims to enable the community of adapter writers, test framework writers, extension writers, and application developers to define and shape the evolution of the platform. This open-sourcing is part of a larger effort to modernize the test platform, including the evolution of MSTest V2, support for .NET Core, and parallel test execution. Visual Studio 2015 Update 1 introduces support for running JavaScript unit tests using frameworks like QUnit and Jasmine via the Chutzpah test runner and its Visual Studio adapter, enabling these tests to be executed on Team Foundation Service hosted build agents.

All Microsoft trails
  1. Upgrade to MSTest V2!This post announces the widespread adoption and encourages the upgrade to MSTest V2. It highlights that new unit test projects in Visual Studio 2017 default to MSTest V2. For existing projects using MSTest V1, the post relies on communication via blogs to drive awareness and manual upgrades, acknowledging that some project types (Coded UI Test Project, Web Performance and Load Test Project) still rely on MSTest V1. Feedback is requested regarding the need for automatic or guided upgrade experiences.
  2. The TestContainer CapabilityIntroduced the 'TestContainer' project capability for .NET Core Test projects referencing the Test SDK v15.0.0 and above. This capability allows the Visual Studio Test Explorer to identify and hand off only test projects to relevant adapters, improving performance and reducing diagnostics by avoiding processing of non-test DLLs. This change is effective from Visual Studio 15.3 Preview 4.
  3. Extending MSTest V2This post details the extensibility points of the MSTest V2 Test Framework API. It explains how developers can extend attributes (e.g., `TestProperty` to strongly-typed attributes), assertions (to be more domain-specific and readable), test execution (at TestMethod and TestClass levels for finer control), and data driving (implementing `ITestDataSource` for custom data sources). The goal is to allow tests to be expressed in language closer to the specific domain model, making the framework more fluent and powerful.
  4. Visual Studio Test Platform, MSTest V2 - Transparent DevelopmentThis post announces the open-sourcing of the Visual Studio Test Platform and the MSTest Test Framework (MSTest V2). It provides comprehensive links to the GitHub repositories for implementation, documentation, issue tracking, roadmaps, RFCs, and backlogs for both projects. It also highlights the importance of community contributions and feedback in shaping the development of these tools.
  5. Run To Click Debugging in Visual Studio 2017Introduces 'Run to Click' debugging in Visual Studio 2017, a point-and-click style feature that allows users to stop execution on a specific line of code by hovering over it and clicking a glyph, without needing to set temporary breakpoints or use keyboard shortcuts. This enhances productivity for developers who prefer using a mouse during debugging.
  7. MSTest V2 - Now and AheadThis post announces that MSTest V2 has shed its pre-release tag (v1.1.11) and has crossed 100K downloads. It reiterates the key features of MSTest V2, including uniform app-platform support (.NET Core, ASP.NET Core, desktop, Store, UWP), uniform DataRow support, TestCategory attribute placement at class/assembly level, a single extensibility mechanism, and delivery as a NuGet package. It also confirms support in Visual Studio 2017 Preview 4+ for Create Unit Tests and Create IntelliTest wizards, and in-box unit test project templates. The post highlights that the team is working on making the MSTest framework open source, referencing the VSTest OSS announcement and VSTS features timeline.
  8. Evolving the Visual Studio Test Platform - Part 4: Together, in the OpenThis post announces the open-sourcing of the Visual Studio Test Platform, releasing its complete implementation under the MIT license on GitHub. It highlights the establishment of public repositories for the project and the ongoing transfer of source code and documentation. The post frames this as a continuation of the 'Modernizing the Test Platform' journey, referencing previous efforts like MSTest V2, .NET Core support, and parallel test execution. It emphasizes transparent development through visible issues, implementation, and roadmaps on GitHub, inviting community contributions and collaboration.
  9. Evolving the Visual Studio Test Platform - Part 3: .NET Core, convergence, and cross-platThis post details the convergence of the .NET Core testing experience with the Visual Studio Test Platform. It explains that the evolved vstest engine (Microsoft.TestPlatform.V2) is now cross-platform and leveraged by `dotnet test`. It also highlights that adapter writers can maintain a single adapter for both .NET Framework and .NET Core, citing MSTest V2 and xUnit.net as examples. The post demonstrates testing using the Visual Studio IDE, `vstest.console.exe`, the .NET Core CLI (`dotnet test`), and VSTS build agents, showing how the same adapters and invocation models work across different environments.
  10. Parallel Test ExecutionThis post details the implementation of parallel test execution in Visual Studio, focusing on its availability across IDE, CLI, and VSTS. It explains the core mechanism of launching tests in separate processes, the role of .runsettings files and the MaxCpuCount parameter, and the iterative approach to partitioning tests for parallel execution. It also introduces discoverable ON/OFF toggles in the IDE (Test Explorer) and VSTS (VSTest task) for easier adoption, and clarifies how these settings merge with .runsettings files.
  11. Announcing MSTest V2 Framework support for .NET Core 1.0 RTMThis post announces MSTest V2 framework support for .NET Core 1.0 RTM. It details API changes in .NET Core 1.0 that were blocking MSTest V2 packages for .NET Core 1.0 RC2, and how these have been resolved. The post provides instructions for installing the SDK, creating a class library project, adding MSTest references via NuGet, writing tests, and testing using the Visual Studio IDE, .NET CLI, vstest.console.exe, and VSTS CI.
  12. Evolving the Visual Studio Test Platform – Part 2This post details 18 features implemented and delivered in the Visual Studio 2015 cycle related to the test platform, focusing on efficiency. Key features include the invigorated MSTest V2 with new features and NuGet availability, the 'Create Unit Tests' wizard for bootstrapping tests, IntelliTest for automatic test generation and updates, incremental validation for faster inner-loop development, faster test execution and lower memory consumption, assembly resolution for configuring dependency loading, and parallel test execution. For Visual Studio "15" Preview, enhancements to the Test Explorer include grouping by namespace, control over running tests from prior builds, automatic Test Explorer display, precise test duration reporting, and improved log handling with select-and-copy support and no log truncation.
  13. Evolving the Visual Studio Test Platform - Part 1This post details the stages of the test lifecycle (acquire, author, select, configure, run, debug, analyze, report) and emphasizes efficiency as a theme for features across these stages. It highlights the open and extensible nature of the current Test Platform, which supports various test frameworks and adapters, and mentions the upcoming MSTest V2 and .NET Core support.
  14. The IntelliTest Reference ManualThis post introduces the IntelliTest Reference Manual, a new documentation resource designed to fill the gap between product-usage documentation and API usage documentation. It aims to answer questions about how test generation works, exploration bounds, coverage data interpretation, correctness testing, failure conditions, exception handling, setup/teardown integration, object creation challenges, and obtaining additional inputs for IntelliTest. It also highlights the role of community forums like Stack Overflow for user interaction and expertise sharing.
  15. Taking the MSTest Framework forward with "MSTest V2"This post announces "MSTest V2" as the next iteration of the MSTest framework, converging implementations for uniform app-platform support across desktop, Store, UWP, ASP.NET Core 1.0, and .NET Core 1.0. It introduces uniform DataRow support, the ability to place TestCategory attribute at class or assembly level, and a single end-user extensibility mechanism. MSTest V2 is delivered as a NuGet package and will be the sole focus for future bug fixes and enhancements, with older MSTest binaries maintained for compatibility in Visual Studio "15".
  16. Announcing MSTest Framework support for .NET Core RC2 / ASP.NET Core RC2This post announces MSTest framework support for .NET Core RC2 and ASP.NET Core RC2. It details the steps to install the SDK, create a class library project, add MSTest references via NuGet packages (MSTest.TestFramework and dotnet-test-mstest), configure the project.json file to use 'mstest' as the test runner, write sample tests, and run them from both Visual Studio's Test Explorer and the command line using `dotnet test`. It also explains how to target desktop .NET by updating the frameworks section in project.json.
  17. Test execution improvements – Apr 2016This post details the convergence of MSTest variants into a single variant that works across different application platforms (Win32, Phone, UWP, ASP.NET Core 1.0, and .NET Core), bringing DataRow support and a clean end-user extensibility mechanism. It also outlines planned enhancements for the Test Explorer window, including immediate opening after runs, select-and-copy from test details and output, fixed test duration reporting, and not asking to run tests from previous builds if the build fails. The post also announces that Test History, BDT support for Azure, SCVMM and VMWare environments, Insights across Exploratory Testing sessions, and Load testing (with import/create, execute, analyze web experience) are DONE.
  18. Visual Studio Team Services – Testing Tools RoadmapThis post outlines the roadmap for Visual Studio Team Services (VSTS) / Team Foundation Server (TFS) Testing Tools, detailing key shifts in testing due to trends like Agile, DevOps, Cloud, and Mobile. It highlights investments in Dev Inner Loop (Unit Testing), Testing in CI/CD, Manual and Exploratory Testing, Load and Performance Testing, and Integration with 3rd party test services. It details delivered features such as parallel and incremental test execution, MSTest support for ASP.NET 5, JUnit and code coverage support for Java applications, in-context test results in builds and release management, parallel test execution on multiple machines, support for Coded UI and Selenium, and a new exploratory testing experience on the web. Future plans include configurable test widgets, test history across branches/environments, and test impact analysis in CI. Load testing will offer JMeter support and a web experience for author-execute-analyze. The post also emphasizes the shift towards web experiences for manual and exploratory testing, with features like inline tests on Kanban boards and XT-Image action logs coming next.
  19. .NET Core Debugging in VS CodeThis post announces the C# extension for Visual Studio Code, providing editing and debugging support for .NET Core applications on Windows, Mac, and Linux. It details features like line-by-line stepping, breakpoints, variable inspection, multi-threaded debugging, call stacks, and a debug console. It also outlines getting started steps, working with console apps, and attach debugging. Limitations such as Edit & Continue, TracePoints, and Set Next Statement are noted.
  20. Parallel and Context Sensitive Test Execution with Visual studio 2015 Update 1This post details the introduction of parallel test execution in Visual Studio 2015 Update 1, which allows test assemblies to run in parallel across multiple CPU cores. It explains how to enable this feature using a .runsettings file and the `MaxCpuCount` parameter. The post also introduces context-sensitive test execution, which runs only tests affected by code changes, and explains its activation via 'Run tests after build'. Performance gains from both features are demonstrated with a sample project.
  21. Supplying Run Time Parameters to TestsIntroduces the `TestRunParameters` section in RunSettings files for MSTest framework to supply external resource connection details (e.g., `appUrl`) to tests. Enables overriding these parameters at runtime in Visual Studio Test task or Visual Studio Test using Test Agent task for CI, BDT, and Release workflows. Allows declaring build variables to avoid hardcoding values in tasks.
  22. IntelliTest - hands onThis post provides a hands-on demonstration of using IntelliTest to achieve 100% code coverage on a specific method (`GetPlayerStatisticsHandler.Handle`) within a C# application. It details the iterative workflow of using IntelliTest, understanding and addressing warnings related to object creation and uninstrumented code, suppressing warnings, and crafting parameterized unit tests (PUTs) by providing mock implementations and synthesized data. The post illustrates how IntelliTest can uncover errors like NullReferenceException, DivideByZeroException, and OverflowException by generating tests that expose these issues.
  23. Unit Test Generators Extensibility - hats off to our communityThis post announces the release of community-provided extensions for the IntelliTest and 'Create Unit Test method stubs' features. These extensions enable the generation of unit tests using the xUnit.net and NUnit test frameworks, addressing community requests for broader framework support and the ability to emit tests into existing projects. The extensions integrate with the existing dialog boxes for these features, allowing users to select their preferred test framework for generated tests.
  24. IntelliTest - One Test to rule them allThis post elaborates on IntelliTest's capability to generate parameterized unit tests (PUTs) that act as a partial specification for code-under-test. It explains how these PUTs, when combined with assertions and assumptions, allow IntelliTest to generate traditional unit test suites that not only achieve high code coverage but also validate the correctness of the code. The concept of 'universally quantified assertions' is introduced as a way to capture general input-output relationships, unlocking the full potential of IntelliTest.
  25. Smart Unit Tests - Test to Code Binding, Test Case ManagementThis post details the mechanism by which IntelliTest (formerly Smart Unit Tests) manages generated unit tests. It explains the use of Pex custom attributes (PexClass, TestMethod, PexGeneratedBy) for test-to-code binding. The post describes how the testing engine identifies previously generated tests by hashing their source code (after whitespace trimming) and uses this to prevent duplicate emissions and delete irrelevant tests when the code-under-test changes. The generated unit tests and parameterized unit test are placed in the same assembly for validation.
  26. Creating unit test method stubs with "Create Unit Tests"Introduces the 'Create Unit Tests' feature in Visual Studio 2015 CTP 6, allowing developers to generate unit test method stubs for C# code using the MSTest framework. This feature is accessible via a context menu and supports generating stubs at the method, type, or namespace scope, addressing a community request for easier unit test creation.
  27. Avoiding Visual Studio Fakes Build breakThis post addresses a specific build error encountered when upgrading to Visual Studio 2013 Update 4, related to the Microsoft.QualityTools.Testing.Fakes.dll assembly. It provides two workarounds: removing version information from the reference or setting the 'specific version' field to 'false' in .proj files. This indicates an evolution in how Visual Studio Fakes assemblies are managed and referenced across different versions, highlighting a potential compatibility issue and its resolution.
  28. Test controllers are not visible or marked offline in MTM when multiple versions of MTM are installedThis post addresses a specific issue where Test Controllers appear offline in Microsoft Test Manager (MTM) when multiple versions of Visual Studio are installed on the same machine. The root cause is identified as assembly version conflicts, specifically `System.InvalidCastException` when an MTM client attempts to connect to an older Test Controller. Two workarounds are provided: 1) using assembly redirection in `mtm.exe.config` to point to the correct assembly versions (specifically for `Microsoft.VisualStudio.QualityTools.Common`, `Microsoft.VisualStudio.QualityTools.ControllerObject`, and `Microsoft.VisualStudio.QualityTools.ExecutionCommon`), and 2) using the older MTM version to connect to older controllers. This post focuses on a specific debugging scenario within the Visual Studio testing ecosystem.
  29. Announcing: Updated Visual Studio 2013 RTM ALM Virtual Machine + Hands-on-Labs & Demo ScriptsThis post details the upgrade of the Visual Studio 2013 ALM Virtual Machine to include sample content, hands-on-labs, and demo scripts. It highlights new features in Visual Studio 2013 such as Agile Planning and Portfolio Management with Team Foundation Server 2013, Getting Started with Git using Team Foundation Server 2013, Embracing Continuous Delivery with Release Management for Visual Studio 2013, and New Collaboration Experiences for Development Teams using Team Foundation Server 2013. It also lists upgraded labs from Visual Studio 2010/2012 covering manual tests, branching and merging visualization, storyboarding, code discovery, IntelliTrace debugging and production diagnostics, exploratory testing, Coded UI tests, platform testing, PreEmptive Analytics, test case management, test planning, web performance and load testing, lab management, developer productivity, SharePoint application testing, class coupling analysis, unit testing, code coverage, code clone analysis, and code quality analysis.
  30. Case Study: Using froglogic for test UI automation with Java based applications and Microsoft Test ManagerThis post details a case study where froglogic Squish was used for UI test automation of Java-based applications with Microsoft Test Manager (MTM). It addresses the challenge of testing Java UIs with TFS by integrating froglogic's tools, which support JavaScript-based automation scripts that can be version-controlled in TFS. The integration allows for test cases defined in MTM to be linked to these scripts, enabling automated test runs from MTM and integration into team build environments for nightly or continuous testing. The post highlights the importance of seamless integration and reporting for end-to-end traceability.
  31. Visual Studio 2013 Release Candidate now available for downloadVisual Studio 2013 RC introduces enhanced unit testing for Windows Store applications on Windows 8.1, including support for Lambda, async methods, Ranges, in-line data binding, and seamless integration with team builds.
  32. Visual Studio Unit Test Generator v1 “lands”Introduced the Visual Studio Unit Test Generator v1 extension, which automates the creation of unit test projects, classes, and stubs. This extension aims to reduce routine test creation tasks, allowing developers to focus on writing the actual tests. It supports MSTest, NUnit, and XUnit test frameworks and can generate VB/C# test code. The extension provides configuration options for tailoring naming and organization schemes and serves as a reference implementation for test framework integration.
  33. Visual Studio Unit Test Generator is feature complete – v1 Release Candidate lands!This post announces the Release Candidate for the Visual Studio Unit Test Generator extension. This extension restores the "Create Unit Tests" feature that was removed in Visual Studio 2012. It focuses on automating project creation, adding references, generating stubs, extensibility, and supporting multiple test frameworks. The goal is to allow developers to quickly start writing test code without the overhead of project and file setup. The extension offers customization of unit test code generation via a context menu and supports generating stubs against multiple frameworks.
  34. Why does Visual Studio 2013 display “Visual Studio 2010” in the Test settings dialogThis post clarifies that the "Visual Studio 2010" reference in the Test Settings dialog for code coverage in Visual Studio 2013 refers to the older, manual assembly configuration method. It highlights the new, simpler method of obtaining code coverage results by right-clicking from the Test Explorer in Visual Studio 2013. It also provides instructions on how to add a Test Settings file to a solution to access the Test Settings dialog.
  35. Part 3: Unit testing with Traits and code coverage in Visual Studio 2012 using the TFS Build – and the new NuGet adapter approachThis post details how to integrate unit tests with TFS Build, focusing on test case filtering using traits and enabling code coverage. It explains how traits in Visual Studio map to TFS Build properties for test case filtering, and how to handle different test frameworks (MSTest, NUnit, XUnit, Native C++) by defining multiple test runs with specific assembly filters. It also covers the straightforward process of enabling and customizing code coverage reporting within TFS Builds, including how to access and interpret the coverage results in Visual Studio.
  36. Visual Studio 2012 – Update 2 RTM!Visual Studio Update 2 RTM is now available, bringing improvements to modern application lifecycle (quality enablement, agile development) and business application development (LightSwitch HTML Client, SharePoint support). Specific highlights include Work Item enhancements (tags, filtering, sharing), Kanban board customization, improved UI, and lightweight browser-based test management and execution. It also integrates the ASP.NET and Web Tools update 2012.2, and includes Team Foundation Server version control enhancements like Explore and Compare, Changeset summary, and zip download of VC repo contents. Backward compatibility for TFS 2010 build servers is also supported.
  37. New tool for converting test lists to Visual Studio 2012 PlaylistsThis post announces a new tool developed by InfoSupport that allows users to convert Visual Studio 2010 test lists to the Visual Studio 2012 Playlists format. It provides installation instructions for the VSIX, steps for migrating projects, saving playlists, and loading them for execution.
  38. Windows Phone Unit Tests in Visual Studio 2012 Update 2This post introduces the Windows Phone Unit Test framework for Windows Phone 8, integrated into Visual Studio 2012 Update 2 CTP 2. It allows developers to author, run, and debug unit tests for Windows Phone 8 using the familiar MSTest framework, with support for both C# and a consistent experience across Windows Store and Windows Phone unit tests. Tests can be executed on emulators or physical devices, and results can be logged via TRX files using `vstest.console.exe`. Known issues include lack of data collector support, no native C++ or VB# support, and limitations with stack trace line numbers.
  39. CTP for Visual Studio Update 2 now availableThis post introduces the CTP for Visual Studio Update 2, focusing on improvements to the Test Explorer. Key enhancements include the ability to group tests by class and the introduction of test playlists for executing specific sets of tests. It also details improved details for Coded UI tests, making hyperlinks active for attachments and log files. Additionally, it highlights the addition of Work Item Tagging for easier filtering and organization, and an updated Team Explorer Connection dialog for better management of multiple servers, collections, and projects. A significant addition is the web-based Test Case Management, allowing for browser-based test management and execution without requiring installation on the client system, supporting non-Windows platforms.
  40. Visual Studio 2012 C++ CppUnitTestFramework targeting the Visual Studio C++ 2010 compilerThis post addresses a specific compatibility issue where the Visual Studio 2012 C++ CppUnitTestFramework can be used with the Visual Studio 2010 compiler. It provides explicit instructions on how to modify project settings by adding specific include and library directories to resolve the compatibility. Additionally, it announces the restoration and update of the 'Team Foundation Server Migration and Integration Solutions' MSDN page, including a new entry for Opshub's migration and integration solutions.
  41. Implementing Traits in custom Visual Studio Test AdaptersThis post details how to implement Traits support for a custom XML Test Adapter in Visual Studio 2012 Update 1. It demonstrates modifying the XML Test Adapter to retrieve a 'category' attribute from test cases and add it to the 'Traits' property of the test case. This allows for better organization and filtering of tests within the Test Explorer. The post also highlights that out-of-the-box test adapters for C# Desktop, C++ Native, C# Windows Store, C++ Windows Store, and Managed C++ now support Traits.
  42. Introducing SharePoint EmulatorsIntroduces SharePoint Emulators, a system of Fakes based shims implementing the basic behaviors of the SharePoint 2010 server object model. These emulators are available via a NuGet package and can be incorporated into existing tests by wrapping test code in a SharePointEmulationScope. The post also details how to extend the emulators by implementing missing shims and how to run tests against both the emulators and a real SharePoint server using the EmulationMode enum.
  43. Part 2–Using Traits with different test frameworks in the Unit Test ExplorerThis post extends the 'Visual Studio Unit Testing Framework' feature thread by detailing the integration of NUnit, xUnit.net, MbUnit, and C++ test frameworks with the Unit Test Explorer's Trait system. It provides step-by-step instructions for adding NUnit and xUnit.net NuGet packages and adapters, demonstrating how to use their respective attributes (Category, Property, Trait) to define test traits. It also covers MbUnit integration and the built-in support for Managed and Native C++ traits. The post highlights the ability to run tests from multiple frameworks concurrently and merge their results in the Test Explorer, and discusses class-based traits support in xUnit.net and upcoming support in NUnit.
  44. Testing SharePoint 2010 with Visual Studio 2012 Update 1This post details specific enhancements for web testing SharePoint 2010 with Visual Studio 2012 Update 1 CTP 3. It addresses the previous limitations of web test recordings by automatically removing requests to pages like blank.htm, ScriptResx.ashx, and commandui.ashx. It also introduces the capability to recognize Site Names as parameters and provides a step-by-step guide for setting up and performing web tests on SharePoint 2010, including installing necessary components, creating a web performance test project, and configuring data sources for dynamic site names. Extraction rules for SharePoint Calendar Dates, List Items, and Documents are also highlighted.
  45. Final CTP for Visual Studio 2012 Update 1This CTP for Visual Studio 2012 Update 1 introduces several new features related to testing: the ability to group and filter tests by trait information in the Test Explorer for Windows Store unit tests and Native unit tests, data driving for Windows Store unit tests using DataRow attributes, and enhancements for C++ Windows Store unit testing including adding references to executables and custom XAML controls, with a planned helper library for asynchronous tests. It also mentions cross-browser testing support for coded UI tests using Selenium with Firefox and Chrome, and the ability to create an image action log from exploratory tests.
  46. Running selective unit tests in VS 2012 using TestCaseFilterThis post details the implementation and usage of the `TestCaseFilter` feature in Visual Studio 2012's new unit testing platform. It explains how to use `vstest.console.exe`, Team Build, and the Test Platform Client API to specify filtering expressions. The post outlines the supported operators (=, !=, ~, &, |) and properties (Name, FullyQualifiedName, Priority, TestCategory, ClassName) for the MSTest adapter, along with code examples for using the `ITestCaseFilterExpression` interface within test adapters.
  47. Odin ships Axe 3.4 simultaneously with Visual Studio 2012This post introduces the Axe product from Odin, a Visual Studio Industry Partner. Axe uses code generation to allow testers to define tests in Excel spreadsheets, generating approximately 95% of the required automation code. The remaining 5% (customization to the code generator and supporting functions) can be handled by either the test or development team. Axe also handles writing test steps in MTM in readable human form. It is installed alongside Excel and Visual Studio, and requires a VS test project to inject code into. Axe also supplies a wizard to set up the project and wire it up. Axe 3.4 introduces support for Microsoft Visual Studio and TFS 2012, new test management tool integration for IBM Rational Quality Manager (RQM), new test execution tool integration for SAP GUI Scripting, enhancements to Microsoft TFS integration including automated test association and results import, and over 50 other enhancements and improvements.
  48. Visual Studio 2012: “Where is the Test Toolbar. Couldn't find it anywhere”This post addresses a user query about the disappearance of the Test Toolbar in Visual Studio 2012. It explains that the toolbar was removed due to UI simplification and paradigm shifts with the introduction of the Test Explorer. The post provides a step-by-step guide for users to recreate similar functionality by creating a new custom toolbar and adding relevant test commands via the Tools > Customize menu. It also recommends exporting these settings to preserve the custom toolbar configuration.
  49. Writing a Visual Studio 2012 Unit Test AdapterThis post details the process of building a custom Visual Studio 2012 Unit Test Adapter for XML files. It covers the implementation of three key components: a Discoverer (ITestDiscoverer) to find tests within XML files, an Executor (ITestExecutor) to run these tests and report outcomes, and a TestContainerDiscoverer for integration with the Visual Studio Test Explorer. The post also outlines the creation of a VSIX installer to package and deploy these components.
  50. Javascript Unit Tests on Team Foundation Service with ChutzpahThis post details the steps required to integrate the Chutzpah JavaScript Test Runner and its Visual Studio adapter into Team Foundation Service hosted build agents. This involves checking in Chutzpah's extracted binaries into source control, configuring the build controller to use these custom assemblies, and modifying the build definition's automated test process to include JavaScript files (`***.js`) as test assemblies. This enables the execution and reporting of QUnit and Jasmine unit tests within the CI/CD pipeline.
  51. UI Test Plugin for Silverlight ApplicationsIntroduced a UI Test Plugin for Silverlight applications, enabling the creation of Coded UI Tests or action recordings for Silverlight applications hosted in Internet Explorer versions 8, 9 & 10. This plugin supports Silverlight 4 & 5 applications and requires Microsoft Visual Studio 2012 RC. The plugin was developed as an off-hours project by a few members of the product team.
  52. Visual Studio 2012 RC – What’s new in Unit TestingIntroduced Smart Test Discovery algorithm for faster test discovery updates in Test Explorer. Enabled 'Run Tests After Build' (Continuous Test Runner) directly in the Test Explorer toolbar. Added Assert.ThrowsException for Metro style apps unit tests, replacing ExpectedException attribute. Enabled Code Analysis for Unit Test Library (Metro style apps). Converted the Unit Test Framework into a Portable Class Library. Added a shortcut menu in the Visual Studio Editor to run or debug tests under the cursor. Maintained compatibility with Visual Studio 2010 Test List Editor (.vsmdi) and Test Templates, allowing them to be opened and run from Test Explorer.
  53. Visual Studio 11 Beta: Test Controller Goes 64 Bit!!The Test Controller in Visual Studio 11 Beta now supports 64-bit operation, overcoming the 2GB memory limitation of its 32-bit predecessor. This resolves 'Out of Memory' exceptions and enables larger-scale load test runs.
  54. The Code Index – Part 3 – Code samples for using indexed informationThis post introduces two code samples for the Code Index SDK: one for retrieving code statistics (assemblies, namespaces, types, members, inheritance, method calls) and another for discovering ignored unit tests, particularly those without linked work items, producing an HTML report. It also announces upcoming posts with more details on the query API.
  55. What’s new for MSTest unit tests in Visual Studio 11 BetaThis post details performance enhancements for MSTest unit tests in Visual Studio 11 Beta, including a new lightweight adapter for faster execution. It introduces separate, simplified project templates for unit tests, Coded UI Tests, and Load tests. Compatibility with Visual Studio 2010 projects is maintained. MSTest unit testing is now available in Visual Studio 11 Express for Web and Windows 8, with first-class support for Windows 8 Metro style apps and asynchronous code testing using the async/await pattern. Support for 64-bit execution and .NET multi-targeting for unit tests is also enhanced.
  56. What's New in Visual Studio 11 Beta Unit TestingThis post introduces significant changes to Visual Studio's unit testing capabilities in the VS11 Beta. Key contributions include: a new Unit Test Explorer UI with Red-Green Bar, search, and prioritization of failed tests; support for third-party test frameworks via a meta-runner and plugin adapters; improvements to the built-in MS-Test framework including performance, scale, .NET 64-bit support, and multi-targeting; introduction of async unit test support for methods returning Task or Task<T> using the 'await' keyword; a native C++ unit testing framework; the Visual Studio Fakes framework for test isolation (Stubs and Shims); simplified code coverage analysis and the ability to run coverage for specific tests; and a 'Run Tests After Build' feature for continuous testing. Test Lists are deprecated.
  57. Visual Studio 11 Beta - Unit Testing Plugins ListThis post announces the availability of unit testing plugins for Visual Studio 11 Beta, listing adapters for C++, JavaScript, C#, Python, Silverlight, TypeScript, and Node.js. It highlights community partners who have shipped support for the Beta release and indicates that more frameworks will be supported in the future.
  58. Test View Issue: An exception was encountered while constructing the content of this frameThis post addresses a specific issue in Visual Studio 2010 where the Test View window could fail to open, causing an exception related to command handlers. It provides a workaround (closing and reopening Visual Studio) and a permanent solution by configuring the 'Test Tools' options to 'Don't prompt' when changes are made to tests and background discovery is not enabled. The underlying exception details are also provided.