Note
Access to this page requires authorization. You can try signing in or changing directories.
Access to this page requires authorization. You can try changing directories.
The following code sample shows how to enumerate, retrieve and schedule tests in a project by content levels. It enumerates all tests in a project and gives a project test summary for content level type.
A test can be mapped to at least one of the 6 content level types:
Basic
Functional
Reliability
Certification
Experiences
Optional
The sample also shows how we can schedule only "Basic" tests in a Project.
GetRollupsByContentLevel Sample
C#
// ------------------------------------------------------------------------------------------------
// <copyright file="GetRollupsByContentLevel.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
// ------------------------------------------------------------------------------------------------
//[assembly: System.CLSCompliant(true)]
namespace Microsoft.Windows.Kits.Samples.ContentLevel
{
using System;
using System.Collections.ObjectModel;
using Microsoft.Windows.Kits.Hardware.ObjectModel;
using Microsoft.Windows.Kits.Hardware.ObjectModel.DBConnection;
/// <summary>
/// Sample code for getting test roll-up by content level
/// </summary>
public class GetRollupsByContentLevel
{
/// <summary>
/// Prevents a default instance of the <see cref="GetRollupsByContentLevel"/> class from being created.
/// </summary>
private GetRollupsByContentLevel()
{
}
/// <summary>
/// Entry point method for the sample application
/// </summary>
/// <param name="args">standard parameter arguments</param>
public static void Main(string[] args)
{
string controllerName;
string projectName;
if (args.Length == 2)
{
controllerName = args[0];
projectName = args[1];
}
else
{
Console.WriteLine("Usage:\tGetRollupsByContentLevel.exe [ControllerMachineName] [ProjectName]");
return;
}
// first we need to connect to the Server
ProjectManager manager = new DatabaseProjectManager(controllerName);
// load the project
Project project = manager.GetProject(projectName);
// Let's retrieve the new property that returns project test roll-up for each content level type
ReadOnlyCollection<ContentLevelRollupInfo> rollupSummaryByContentLevels = project.Info.RollupSummaryByContentLevels;
Console.Out.WriteLine("Roll-up summary by content level for project: '{0}'", projectName);
foreach (ContentLevelRollupInfo rollupInfo in rollupSummaryByContentLevels)
{
Console.Out.WriteLine("\tSummary for '{0}' level:", rollupInfo.ContentLevel);
Console.Out.WriteLine("\t\tFailedCount: {0}", rollupInfo.FailedCount);
Console.Out.WriteLine("\t\tNotRunCount: {0}", rollupInfo.NotRunCount);
Console.Out.WriteLine("\t\tPassedCount: {0}", rollupInfo.PassedCount);
Console.Out.WriteLine("\t\tRunningCount: {0}", rollupInfo.RunningCount);
Console.Out.WriteLine("\t\tTotalCount: {0}", rollupInfo.TotalCount);
Console.Out.WriteLine("\t\tStatus: {0}", rollupInfo.Status);
}
// Other existing properties in ProjectInfo will now only return roll-up counts for tests that are mapped to certification content level
// this to keep backwards compatibility with HCK 2.0 OM API
ProjectInfo projectInfo = project.Info;
Console.Out.WriteLine();
Console.Out.WriteLine("\tCurrent Roll-up properties should be same as the roll-up counts for 'Certification' level");
Console.Out.WriteLine("\t\tFailedCount: {0}", projectInfo.FailedCount);
Console.Out.WriteLine("\t\tNotRunCount: {0}", projectInfo.NotRunCount);
Console.Out.WriteLine("\t\tPassedCount: {0}", projectInfo.PassedCount);
Console.Out.WriteLine("\t\tRunningCount: {0}", projectInfo.RunningCount);
Console.Out.WriteLine("\t\tTotalCount: {0}", projectInfo.TotalCount);
Console.Out.WriteLine("\t\tStatus: {0}", projectInfo.Status);
}
}
}
Windows PowerShell®
. ..\Initialization.ps1
Clear-Host
$Manager = Initialize
#Load Project
$Project = $Manager.GetProject("SampleTestProject")
#Let's retrieve the new property that returns project test roll-up for each content level type
$RollupSummaryByContentLevels = $Project.Info.RollupSummaryByContentLevels
Write-Host ("Roll-up summary by content level for project: '{0}'" -f $Project.Name)
foreach ($RollupInfo in rollupSummaryByContentLevels)
{
Write-Host ("Summary for '{0}' level:" -f $RollupInfo.ContentLevel)
Write-Host ("FailedCount: {0}" -f $RollupInfo.FailedCount)
Write-Host ("NotRunCount: {0}" -f $RollupInfo.NotRunCount)
Write-Host ("PassedCount: {0}" -f $RollupInfo.PassedCount)
Write-Host ("RunningCount: {0}" -f $RollupInfo.RunningCount)
Write-Host ("TotalCount: {0}" -f $RollupInfo.TotalCount)
Write-Host ("Status: {0}" -f $RollupInfo.Status)
}
#Other existing properties in ProjectInfo will now only return roll-up counts for tests that are mapped to certification content level
#this to keep backwards compatibility with HCK 2.0 OM API
$ProjectInfo = $Project.Info
Write-Host ""
Write-Host "Current Roll-up properties should be same as the roll-up counts for 'Certification' level"
Write-Host ("FailedCount: {0}" -f $ProjectInfo.FailedCount)
Write-Host ("NotRunCount: {0}" -f $ProjectInfo.NotRunCount)
Write-Host ("PassedCount: {0}" -f $ProjectInfo.PassedCount)
Write-Host ("RunningCount: {0}" -f $ProjectInfo.RunningCount)
Write-Host ("TotalCount: {0}" -f $ProjectInfo.TotalCount)
Write-Host ("Status: {0}" -f $ProjectInfo.Status)
ScheduleTestsByContentLevel Sample
C#
// ------------------------------------------------------------------------------------------------
// <copyright file="ScheduleTestsByContentLevel.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
// ------------------------------------------------------------------------------------------------
[assembly: System.CLSCompliant(true)]
namespace Microsoft.Windows.Kits.Samples.ContentLevel
{
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Windows.Kits.Hardware.ObjectModel;
using Microsoft.Windows.Kits.Hardware.ObjectModel.DBConnection;
/// <summary>
/// Sample code for enumerating tests by content level
/// </summary>
public class ScheduleTestsByContentLevel
{
/// <summary>
/// Prevents a default instance of the <see cref="ScheduleTestsByContentLevel"/> class from being created.
/// </summary>
private ScheduleTestsByContentLevel()
{
}
/// <summary>
/// Entry point method for the sample application
/// </summary>
/// <param name="args">standard parameter arguments</param>
public static void Main(string[] args)
{
string controllerName;
string projectName;
if (args.Length == 2)
{
controllerName = args[0];
projectName = args[1];
}
else
{
Console.WriteLine("Usage:\tScheduleTestsByContentLevel.exe [ControllerMachineName] [ProjectName]");
return;
}
// first we need to connect to the Server
ProjectManager manager = new DatabaseProjectManager(controllerName);
// load the project
Project project = manager.GetProject(projectName);
// Calling the default GetTests() method will now return tests that are mapped to certification content level
// this to keep backwards compatibility with HCK 2.0 OM API
IList<Test> tests = project.GetTests();
Console.Out.WriteLine("Assertion for all tests mapped to certification level should be true: {0}", tests.All(test => test.ContentLevels.Contains(ContentLevelType.Certification)));
/*
* Let's now get project test summary for all content levels.
*/
List<ContentLevelType> contentLevelTypes = new List<ContentLevelType>
{
ContentLevelType.Basic,
ContentLevelType.Functional,
ContentLevelType.Reliability,
ContentLevelType.Certification,
ContentLevelType.Experiences,
ContentLevelType.Optional
};
tests = project.GetTests(contentLevelTypes);
Console.Out.WriteLine("Test summary for project '{0}'", project.Name);
Console.Out.WriteLine("\t Basic tests: '{0}'", tests.Count(test => test.ContentLevels.Contains(ContentLevelType.Basic)));
Console.Out.WriteLine("\t Functional tests: '{0}'", tests.Count(test => test.ContentLevels.Contains(ContentLevelType.Functional)));
Console.Out.WriteLine("\t Reliability tests: '{0}'", tests.Count(test => test.ContentLevels.Contains(ContentLevelType.Reliability)));
Console.Out.WriteLine("\t Certification tests: '{0}'", tests.Count(test => test.ContentLevels.Contains(ContentLevelType.Certification)));
Console.Out.WriteLine("\t Experiences tests: '{0}'", tests.Count(test => test.ContentLevels.Contains(ContentLevelType.Experiences)));
Console.Out.WriteLine("\t Optional tests: '{0}'", tests.Count(test => test.ContentLevels.Contains(ContentLevelType.Optional)));
Console.Out.WriteLine("\t Total tests: '{0}'", tests.Count);
/*
* Scheduling tests based on Content level.
* Here, we use the existing project.GetTests() method and then filter tests for a specific content level ("Basic")
*/
// this will retrieve all jobs/tests that are tagged with "Basic" content level
tests = project.GetTests(new[] { ContentLevelType.Basic });
// this will schedule "Basic" jobs/tests that we just retrieved
foreach (Test test in tests)
{
Console.Out.WriteLine("Scheduling 'Basic' test: '{0}'", test.Name);
test.QueueTest();
}
/*
* Scheduling tests based on multiple content levels
* Here, we use the existing project.GetTests() method and then filter tests for a specific set of content levels ("Basic" and "Reliability")
*/
// this will retrieve all jobs/tests that are tagged with "Basic" and "Reliability" content level
tests = project.GetTests(new[] { ContentLevelType.Basic, ContentLevelType.Reliability });
// this will schedule "Basic" and "Reliability" jobs/tests that we just retrieved
foreach (Test test in tests)
{
Console.Out.WriteLine("Scheduling test: '{0}'", test.Name);
test.QueueTest();
}
/*
* Scheduling tests based on multiple content levels using the new method - project.GetTests(contentLevels)
* Here, we use the new method project.GetTests(contentLevels) to retrieve tests only for a specific set of content levels ("Functional" and "Reliability")
*/
// let's retrieve tests for "Functional" and "Reliability" content levels
List<ContentLevelType> contentLevels = new List<ContentLevelType>
{
ContentLevelType.Functional,
ContentLevelType.Reliability
};
tests = project.GetTests(contentLevels);
// this will schedule "Functional" and "Reliability" jobs/tests that we just retrieved
foreach (Test test in tests)
{
Console.Out.WriteLine("Scheduling test: '{0}'", test.Name);
test.QueueTest();
}
// calling GetTests(contentLevels) method with an empty list of content levels will return an empty set of tests
tests = project.GetTests(new List<ContentLevelType>());
Console.Out.WriteLine("Tests count should be zero. Count: {0}", tests.Count);
}
}
}
Windows PowerShell®
$ObjectModel = [Reflection.Assembly]::LoadFrom($env:WTTSTDIO + "Microsoft.Windows.Kits.Hardware.objectmodel.dll")
$ObjectModel = [Reflection.Assembly]::LoadFrom($env:WTTSTDIO + "Microsoft.Windows.Kits.Hardware.objectmodel.dbconnection.dll")
$ObjectModel = [Reflection.Assembly]::LoadFrom($env:WTTSTDIO + "Microsoft.Windows.Kits.Hardware.objectmodel.submission.dll")
$connectFileName = $env:WTTSTDIO + "connect.xml"
Write-Host Opening connection file $connectFileName
$connectFile = [xml](Get-Content $connectFileName)
$ControllerName = $connectFile.Connection.GetAttribute("Server")
$DatabaseName = $connectFile.Connection.GetAttribute("Source")
Clear-Host
$Manager = new-object -typename Microsoft.Windows.Kits.Hardware.ObjectModel.DBConnection.DatabaseProjectManager -Args $ControllerName, $DatabaseName
#Load Project
$Project = $Manager.GetProject("system test")
#let's define enumerations for all content levels
$BasicTestContentLevel = [Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]::Basic
$FunctionalTestContentLevel = [Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]::Functional
$ReliabilityTestContentLevel = [Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]::Reliability
$CertificationTestContentLevel = [Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]::Certification
$ExperiencesTestContentLevel = [Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]::Experiences
$OptionalTestContentLevel = [Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]::Optional
# Calling the default GetTests() method will now return tests that are mapped to certification content level
# this to keep backwards compatibility with HCK 2.0 OM API
$Tests = $Project.GetTests()
Write-Host ("Assertion for all tests mapped to certification level should be true: {0}", ($Tests | where {-not $_.ContentLevels.Contains($CertificationTestContentLevel)}).Length -eq 0)
#Project test summary for each content levels.
$allContentLevels = New-Object "System.Collections.Generic.List[Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]"
@($BasicTestContentLevel, $FunctionalTestContentLevel, $ReliabilityTestContentLevel, $CertificationTestContentLevel, $ExperiencesTestContentLevel, $OptionalTestContentLevel) |% {$allContentLevels.Add($_)}
$allContentLevels
$Tests = $Project.GetTests($allContentLevels)
Write-Host ("Test summary for project {0}" -f $Project.Name)
Write-Host ("Basic tests: {0}" -f ($Tests | where { $_.ContentLevels.Contains($BasicTestContentLevel)}).Length)
Write-Host ("Functional tests: {0}" -f ($Tests | where { $_.ContentLevels.Contains($FunctionalTestContentLevel)}).Length)
Write-Host ("Reliability tests: {0}" -f ($Tests | where { $_.ContentLevels.Contains($ReliabilityTestContentLevel)}).Length)
Write-Host ("Certification tests: {0}" -f ($Tests | where { $_.ContentLevels.Contains($CertificationTestContentLevel)}).Length)
Write-Host ("Experiences tests: {0}" -f ($Tests | where { $_.ContentLevels.Contains($ExperiencesTestContentLevel)}).Length)
Write-Host ("Optional tests: {0}" -f ($Tests | where { $_.ContentLevels.Contains($OptionalTestContentLevel)}).Length)
Write-Host ("Total tests: {0}" -f ($Tests.Count))
#schedule all basic tests in the project
$contentLevels = New-Object "System.Collections.Generic.List[Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]"
$contentLevels.Add($BasicTestContentLevel)
foreach($Test in $Project.GetTests($contentLevels))
{
Write-Host ("Scheduling 'Basic' test: {0}" -f $Test.Name)
$Test.QueueTest()
}
# Scheduling tests based on multiple content levels using the new method - project.GetTests(contentLevels)
# Here, we use the new method project.GetTests(contentLevels) to retrieve tests only for a specific set of content levels ("Functional" and "Reliability")
$contentLevels = New-Object "System.Collections.Generic.List[Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]"
@($FunctionalTestContentLevel, $ReliabilityTestContentLevel) |% {$contentLevels.Add($_)}
foreach($Test in $Project.GetTests($contentLevels))
{
Write-Host ("Scheduling 'Basic' test: {0}" -f $Test.Name)
$Test.QueueTest()
}
#calling GetTests(contentLevels) method with an empty list of content levels will return an empty set of tests
$contentLevels = New-Object "System.Collections.Generic.List[Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]"
$Tests = $Project.GetTests($contentLevels)
Write-Host ("Tests count should be zero. Count: {0}" -f $Tests.Count)
# Sample code for creating a new project and scheduling Basic tests
# create the project name
$now = [System.DateTime]::Now
$ProjectName = "SampleContentLevelTestProject $now"
$RootPool = $Manager.GetRootMachinePool()
$DefaultPool = $RootPool.DefaultPool
# create the pool
$TestPool = $RootPool.GetChildPools() | Where {$_.Name -eq "TestPool" }[0]
if ($TestPool -eq $null)
{
$TestPool = $RootPool.CreateChildPool("TestPool")
}
# move all machines in the default pool
$DefaultPool.GetMachines() | foreach {
write-host $_.Name
$DefaultPool.MoveMachineTo($_, $TestPool)
}
#reset all machines
$TestPool.GetMachines() | foreach { $_.SetMachineStatus([Microsoft.Windows.Kits.Hardware.ObjectModel.MachineStatus]::Ready, 1) }
#-----------
# Creating a project
#-----------
$Project = $manager.CreateProject($ProjectName)
Write-Host "created a project named : "$Project.Name
$OSPlatform = $TestPool.GetMachines()[0].OSPlatform
$ProductInstance = $Project.CreateProductInstance("My Product Instance",
$TestPool,
$OSPlatform)
# this will find all systems in the test pool, and return those as a list of system test targets
$data = $ProductInstance.FindTargetFromSystem()
# for now, just use the first one found
Write-Host "Creating a target for " $data[0].Name
$Target = $ProductInstance.CreateTarget($data[0])
write-Host Successfully created a Target for $Target.Name that has $Target.GetTests().Count tests
# Schedule "Basic" test - i.e., tests that is marked as "Basic" content level
# Get the first "Basic" test and schedule it
$Test = $Target.GetTests() | where { $_.ContentLevels.Contains($BasicTestContentLevel)}[0]
$Test.QueueTest()