Microsoft Visual Studio 2005 Team System, part of the Microsoft Visual Studio 2005 release, includes tools and technologies for all members of software development teams: project architects, developers, testers, managers, etc. For instance, Team System includes special utilities for code analysis and special types of Visual Studio projects (test projects) that can be used for testing purposes.

AutomatedQA is committed to offering a tight integration with Microsoft Visual Studio 2005 Team System services and subsystems. The integration of AutomatedQA tools allows you to --

Extending Visual Studio's Test Items with TestComplete Tests

AutomatedQA offers a Team System plug-in that lets you use TestComplete scripts as part of your test project(s) created in Visual Studio 2005. After the plug-in is installed, it adds a special test item to the list of test project items available in Visual Studio. The item name is TestComplete test if you use TestComplete 3, or TestComplete4 test if you use TestComplete 4.

The integration with Visual Studio is seamless and natural, and the use of TestComplete Test items is similar to the use of any other test item available in Visual Studio.

After you add a TestComplete Test item to your test project, it will appear as a child node of the project's node in the Solution Explorer. In the test item properties you can --

Once you set the properties of the TestComplete Test item, you will be able to add this item to the list of tests to be run:

To run the test project, click the Run button on the Visual Studio toolbar. When the TestComplete Test item is being executed, it launches TestComplete (or TestExecute), loads the specified TestComplete project and runs a script routine or test suites.

After the test project run is completed, the results of the TestComplete Test items are shown in the Test Results panel along with other testing results:

Here you can quickly see whether TestComplete tests passed successfully or failed. To view a detailed output of a TestComplete test, simply double-click it in the panel:

Integrating Tests for Memory Leaks and Platform Compliance into Visual Studio Test Projects

The search for memory leaks and check for platform compliance is performed by AQtime, which is AutomatedQA's performance profiler and memory and resource debugger for both Win32 and .NET applications.

Once AQtime is integrated into Visual Studio 2005 Team System, a new AQtime test is added to the list of available test items:

To integrate a test for memory leaks (or platform compliance) into your Visual Studio tests, simply add the AQtime test item to your test project. The item will appear in the Solution Explorer as a child node of your test project.

Double-click the AQtime test item to modify its properties:

The Select Profiler property specifies the profiler that will be used for your tests. You can select one of the following profilers:

The AQtime Project property specifies which AQtime project will be run.

The TestComplete Project property specifies the TestComplete project that can be run to simulate user actions (mouse clicks, keystrokes, etc.) over the application under test. When TestComplete is used together with AQtime, no user action is required to perform the tests.

The results of AQtime test are shown in the Test Results panel along with other test results:

To view a more detailed test output, simply double-click the desired AQtime test item in the Test Results panel. Below are sample outputs of AQtime test items:

Allocation Profiler Results

Resource Profiler Results

Platform Compliance Results

Extending Your Test Batteries with Visual Studio Unit Tests

You can use unit tests created with Visual Studio in Automated Build Studio projects and TestComplete projects.

Automated Build Studio includes the Run MSTest operation that lets you call tests created with MSTest directly from your Build Studio macro. By using this operation you can easily integrate Visual Studio unit tests into the collection of tests that you use to test your application(s). All you have to do to call unit tests is to --

That's all. After adding the operation and specifying its parameters, you will be able to run your macro and then analyze the results of your unit tests.

In Build Studio, by using the built-in configurations support or the If... Then operation, you can enable or disable the execution of your unit tests according to specific conditions (for example, running your unit tests only as part of the “test”/“debug” builds). That is, by running MSTest tests from Build Studio, you can not only extend your existing test collection, but also make the testing process more flexible.

TestComplete includes the Unit Testing project item that lets you call unit tests created with MSTest directly from your TestComplete project. By using this functionality you can easily add Visual Studio unit tests into the collection of unit tests. To call Visual Studio unit tests --

After adding the MSTest you will be able to run the unit test in TestComplete and then post and analyze the results in the Test Log.

Editing and Creating Work Items in Team System

Creation and editing of work items stored in Team System can be done with two special Automated Build Studio operations: Create New Item in Team System and Edit Item in Team System.

For example, using these operations you can easily create or edit work items if your tests failed. This ensures that the results of test runs are not lost and that the person responsible for this (a developer or a tester) is notified about the problem as soon as it occurs.

Team Foundation Version Control Support

Support for Team Foundation version control (TFVC) is implemented as a special set of operations in Automated Build Studio. These operations allow you to work with TFVC directly from your Automated Build Studio visual macros:

Using these operations you can check files in and check them out from TFVC in the same way as you do this with Microsoft Visual SourceSafe operations in Automated Build Studio.

Besides checking files in and checking them out, you can also --

As you can see, using Automated Build Studio you can perform any source control operation that can be done in TFVC.

Calling Automated Build Studio Macros From MSBuild Projects and Vice Versa

You can call Automated Build Studio macros directly from your MSBuild projects. For this purpose, you need to install a special assembly, MSBuildABSTask, on your computer. Below is an example of an MSBUild project file that runs a Build Studio macro:

<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <UsingTask TaskName="ABS.ExecuteMacro" 
             AssemblyName="msbuildabstask, Version=1.1.0.0, Culture=neutral, PublicKeyToken=550bc1d712c881df"/>

  <Target Name="Build">
    <ExecuteMacro
       MacroFile="C:\MyFolder\MyProject.bxp"
       Configuration="Release; Debug"
       StopIfFail="true"
       AdditionalOptions=""
     />
   </Target>

</Project>

By calling a Build Studio macro from your MSBuild projects, you can perform almost any actions during the build process initiated by MSBuild. For instance, using macros you can get files from a source control system, send notifications, etc. MSBuild cannot perform these actions itself, without the help of Build Studio.

You can also build your applications with MSBuild directly from your macros. The support for MSBuild is implemented as a special operation of Automated Build Studio. This operation lets you run MSBuild projects directly from your macros. Operation properties let you specify the MSBuild project name and project options (configurations, etc.):

Automated Build Studio Integration into Team Explorer

Automated Build Studio is tightly integrated with Microsoft's Visual Studio 2005 Team Explorer panel and allows you to run macros directly from Team Explorer. You can use macros to build projects and solutions that make up your team project, or to perform any other actions. Since the Team Explorer integration package is installed each team project will have the AutomatedBuildStudio node.

The AutomatedBuildStudio node holds two sub-nodes: Macro File and Macro Runs. The Macro File node provides access to the Build Studio macro associated with the project. The Macro Runs node is used to initiate and monitor macro runs and to view the macro run results and history.

Running TestComplete Tests From MSBuild Projects

TestComplete Enterprise edition includes the MSBuildTC4Task assembly that lets you execute TestComplete tests as part of your MSBuild projects. Below is a typical example of executing a TestComplete project suite from an MSBuild project:

<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <UsingTask TaskName="TC4.ExecuteSolution" 
             AssemblyName="msbuildtc4task, Version=1.1.0.0, Culture=neutral, PublicKeyToken=948a15855538eecd"/>

  <Target Name="Build">
    <ExecuteSolution
       SolutionFile="C:\MyProjects\MyProjectSuite.pjs"
       StopIfFail="true"
       AdditionalOptions="/project:MyProject"
       GUIInteractive="true"
       LogFile="c:\MyProjects\MyResults.mht"
     />
   </Target>

</Project>

The results are posted in the log file, specified by the LogFile attribute. You can view the log file in Internet Explorer, since it is stored in the Multipart HyperText format. By using this method you can achieve all the benefits of TestComplete scripts in your MSBuild projects: work with applications via the user interface, access internal structure of "open" applications, perform unit testing and so on.