Freigeben über

Enable Coded UI Testing of Your Controls

  • Artikel

Das Steuerelement kann problemlos getestet werden, wenn Sie Unterstützung für das Framework für den Test der codierten UI implementieren.Sie können die Ebenen der Unterstützung inkrementell hinzufügen.Sie können beginnen, indem Sie Aufzeichnungs- und Wiedergabe - und Eigenschaftvalidierung unterstützen.Sie können auf dem erstellen, um dem Test-Generator für codierte UI zu ermöglichen, die benutzerdefinierten Eigenschaften des Steuerelements zu erkennen und stellen benutzerdefinierte Klassen, um auf diese Eigenschaften von generiertem Code zuzugreifen.Sie können dem Test-Generator für codierte UI auch leichter, Aktionen auf eine Weise aufzuzeichnen, die näher an der Absicht der Aktion ist, die aufgezeichnet wird.

In diesem Thema:

  1. Sichern Sie Datensatz- und Wiedergabe -und Eigenschaft-Validierung, indem Sie Barrierefreiheit implementieren

  2. Sichern Sie benutzerdefinierte Eigenschaft-Validierung, indem Sie einen Eigenschaft-Anbieter implementieren

  3. Sichern Sie Codegenerierung, indem Sie eine Klasse implementieren, um auf benutzerdefinierte Eigenschaften zuzugreifen

  4. Sichern Sie Absicht-bewusste Aktionen, indem Sie einen Aktionsfilter implementieren

CUIT_Full

Sichern Sie Datensatz- und Wiedergabe -und Eigenschaft-Validierung, indem Sie Barrierefreiheit implementieren

Der Test-Generator für codierte UI erfasst Informationen zu Steuerelementen, die es während einer Aufzeichnung trifft und dann Code generiert, um dieser Sitzung wiederzugeben.Wenn das Steuerelement nicht Barrierefreiheit unterstützt, dann wird der Test-Generator für codierte UI Aktionen (wie Mausklicks) mit der Bildschirmkoordinaten auf.Wenn der Test wiedergegeben handelt, wird der generierte Code diese Mausklicks in den gleichen Bildschirmkoordinaten aus.Wenn das Steuerelement in einem anderen Platz auf dem Bildschirm angezeigt wird, wenn der Test wiedergegeben ist, kann der generierte Code diese Aktion auf dem Steuerelement nicht ausführen.Dies kann zu Fehlern führen, wenn der Test wiedergegeben auf verschiedenen Bildschirmkonfigurationen, in anderen Umgebungen ist, oder nachdem er Änderungen am Benutzeroberfläche-Layout geändert hat.

CUIT_RecordNoSupport

Wenn Sie Barrierefreiheit implementieren, obwohl, der Test-Generator für codierte UI den verwendet, um Informationen über das Steuerelement zu erfassen, wenn er einen Test erfasst und Code generiert.Wenn Sie den Test ausführen, gibt der generierte Code diese Ereignisse für das - Steuerelement erneut, wenn er an anderer Stelle in der Benutzeroberfläche ist.Testautoren sind auch erstellen Assertionen mit der grundlegenden Eigenschaften des Steuerelements in der Lage.

CUIT_Record

Hh552522.collapse_all(de-de,VS.110).gifSo Datensatz und Wiedergabe, Eigenschaftvalidierung und Navigation für ein Windows Forms-Steuerelement unterstützen

Implementieren Sie Barrierefreiheit für das Steuerelement wie in der folgenden Prozedur dargestellt, und im Detail beschrieben in AccessibleObject.

CUIT_Accessible

  1. Implementieren Sie eine Klasse, die von Control.ControlAccessibleObject berechnet, und überschreiben Sie die - Eigenschaft AccessibilityObject, um ein Objekt der Klasse zurückgegeben wird.

    public partial class ChartControl : UserControl
{
    // Overridden to return the custom AccessibleObject for the control.
    protected override AccessibleObject CreateAccessibilityInstance()
    {
        return new ChartControlAccessibleObject(this);
    }

    // Inner class ChartControlAccessibleObject represents accessible information
    // associated with the ChartControl and is used when recording tests.
    public class ChartControlAccessibleObject : ControlAccessibleObject
    {
        ChartControl myControl;
        public ChartControlAccessibleObject(ChartControl ctrl)
            : base(ctrl)
        {
            myControl = ctrl;
        }
    }
}

  2. Überschreiben Sie Role des Objekt, auf das zugegriffen werden kann, State, GetChild und GetChildCount-Eigenschaften und Methoden.

  3. Implementieren Sie ein anderes Barrierefreiheitsobjekt für das untergeordnete Steuerelement und AccessibilityObject überschreiben Sie die - Eigenschaft des untergeordneten Steuerelements, um dass Barrierefreiheitsobjekt zurückzukehren.

  4. Überschreiben Sie Bounds, Name, Parent, Role, State, Navigate und Select-Eigenschaften und Methoden für das Barrierefreiheitsobjekt des untergeordneten Steuerelements.

HinweisHinweis

Dieser Thema mit dem Barrierefreiheitsbeispiel in AccessibleObject in dieser Prozedur und dann Builds auf der in den anderen Prozeduren.Wenn Sie eine funktionierende Version des Barrierefreiheitsbeispiels erstellen möchten, erstellen Sie eine Konsolenanwendung und ersetzen Sie den Code in Program.cs durch den Beispielcode.Sie müssen Verweise auf Barrierefreiheit, zu zu System.Drawing und System.Windows.Forms hinzufügen.Sie sollten Interoptypen einbetten für Barrierefreiheit auf False ändern, um eine Buildwarnung auszuschließen.Sie können den Ausgabetyp des Projekts über die Konsolenanwendung zu Windows-Anwendung ändern, sodass ein Konsolenfenster nicht angezeigt wird, wenn Sie die Anwendung ausführen.

Sichern Sie benutzerdefinierte Eigenschaft-Validierung, indem Sie einen Eigenschaft-Anbieter implementieren

Sobald Sie grundlegende Unterstützung für Aufzeichnungs- und Wiedergabe - und Eigenschaftvalidierung implementiert haben, können Sie die benutzerdefinierten Eigenschaften des Steuerelements machen für Tests der codierten UI, indem Sie ein UITestPropertyProvider Plug-In implementieren.Zum Beispiel zeigt die folgende Prozedur einen Eigenschaftenanbieter erstellt, der Tests der codierten UI ermöglicht, auf das der Zustandseigenschaften das CurveLegend-untergeordnetenSteuerelemente des Diagrammsteuerelements zuzugreifen.

CUIT_CustomProps

Hh552522.collapse_all(de-de,VS.110).gifUm benutzerdefinierte Eigenschaftvalidierung unterstützen

CUIT_Props

  1. Überschreiben Sie die Description-Eigenschaft des Kurvenlegendenobjekts, auf das zugegriffen werden kann, zu großen Eigenschaftswerten der Phase in der Beschreibungszeichenfolge, getrennt von der Beschreibung (und von, wenn Sie mehrere Eigenschaften implementieren), durch Semikolons (;).

    public class CurveLegendAccessibleObject : AccessibleObject
{
    // add the state property value to the description
    public override string Description
    {
        get
        {
            // Add “;” and the state value to the end
            // of the curve legend’s description
            return "CurveLegend; " + State.ToString();
        }
    }
}

  2. Erstellen Sie ein UI-Test-Erweiterungspaket für das Steuerelement, indem Sie ein Klassenbibliotheksprojekt erstellen und fügen Sie Verweise auf Barrierefreiheit, zu Microsoft.VisualStudio.TestTools.UITesting, zu Microsoft.VisualStudio.TestTools.UITest.Common und zu Microsoft.VisualStudio.TestTools.Extension hinzu.Ändern Sie Interoptypen einbetten für Barrierefreiheit auf False.

  3. Fügen Sie eine Eigenschaftanbieterklasse hinzu, die von UITestPropertyProvider abgeleitet wird.

    using System;
using System.Collections.Generic;
using Accessibility;
using Microsoft.VisualStudio.TestTools.UITesting;
using Microsoft.VisualStudio.TestTools.UITest.Extension;
using Microsoft.VisualStudio.TestTools.UITesting.WinControls;
using Microsoft.VisualStudio.TestTools.UITest.Common;

namespace ChartControlExtensionPackage
{
    public class ChartControlPropertyProvider : UITestPropertyProvider
    {
    }
}

  4. Implementieren Sie den Eigenschaftenanbieter, indem Sie Eigenschaftennamen und Eigenschaftdeskriptoren in Dictionary<TKey, TValue> platzieren.

    // Define a map of property descriptors for CurveLegend
private static Dictionary<string, UITestPropertyDescriptor> curveLegendPropertiesMap = null;
private static Dictionary<string, UITestPropertyDescriptor> CurveLegendPropertiesMap
{
    get
    {
        if (curveLegendPropertiesMap == null)
        {
            UITestPropertyAttributes read =
                UITestPropertyAttributes.Readable |
                UITestPropertyAttributes.DoNotGenerateProperties;
            curveLegendPropertiesMap =
                new Dictionary<string, UITestPropertyDescriptor>
                    (StringComparer.OrdinalIgnoreCase);
            curveLegendPropertiesMap.Add("State",
                new UITestPropertyDescriptor(typeof(string), read));
        }
        return curveLegendPropertiesMap;
    }
}

// return the property descriptor
public override UITestPropertyDescriptor GetPropertyDescriptor(UITestControl uiTestControl, string propertyName)
{
    return CurveLegendPropertiesMap[propertyName];
}

// return the property names
public override ICollection<string> GetPropertyNames(UITestControl uiTestControl)
{
    if (uiTestControl.ControlType.NameEquals("Chart") || uiTestControl.ControlType.NameEquals("Text"))
    {
        // the keys of the property map are the collection of property names
        return CurveLegendPropertiesMap.Keys;
    }

    // this is not my control
    throw new NotSupportedException();
}

// Get the property value by parsing the accessible description
public override object GetPropertyValue(UITestControl uiTestControl, string propertyName)
{
    if (String.Equals(propertyName, "State", StringComparison.OrdinalIgnoreCase))
    {
        object[] native = uiTestControl.NativeElement as object[];
        IAccessible acc = native[0] as IAccessible;

        string[] descriptionTokens = acc.accDescription.Split(new char[] { ';' });
        return descriptionTokens[1];
    }

    // this is not my control
    throw new NotSupportedException();
}

  5. Überschreiben Sie UITestPropertyProvider.GetControlSupportLevel, um anzugeben, dass die Assembly steuerelementspezifische Unterstützung für das Steuerelement und seine untergeordneten Elemente bietet.

    public override int GetControlSupportLevel(UITestControl uiTestControl)
{
    // For MSAA, check the control type
    if (string.Equals(uiTestControl.TechnologyName, "MSAA",
        StringComparison.OrdinalIgnoreCase) &&
        (uiTestControl.ControlType == "Chart"||uiTestControl.ControlType == "Text"))
    {
        return (int)ControlSupport.ControlSpecificSupport;
    }

    // This is not my control, so return NoSupport
    return (int)ControlSupport.NoSupport;
}

  6. Überschreiben Sie die übrigen abstrakten Methoden von Microsoft.VisualStudio.TestTools.UITesting.UITestPropertyProvider.

    public override string[] GetPredefinedSearchProperties(Type specializedClass)
{
    throw new NotImplementedException();
}

public override Type GetSpecializedClass(UITestControl uiTestControl)
{
    throw new NotImplementedException();
}

public override Type GetPropertyNamesClassType(UITestControl uiTestControl)
{
    throw new NotImplementedException();
}

public override void SetPropertyValue(UITestControl uiTestControl, string propertyName, object value)
{
    throw new NotImplementedException();
}

public override string GetPropertyForAction(UITestControl uiTestControl, UITestAction action)
{
    throw new NotImplementedException();
}

public override string[] GetPropertyForControlState(UITestControl uiTestControl, ControlStates uiState, out bool[] stateValues)
{
    throw new NotImplementedException();
}

  7. Fügen Sie eine Erweiterungspaketklasse hinzu, die von UITestExtensionPackage abgeleitet wird.

    using System;
using Microsoft.VisualStudio.TestTools.UITesting;
using Microsoft.VisualStudio.TestTools.UITest.Extension;
using Microsoft.VisualStudio.TestTools.UITest.Common;

namespace ChartControlExtensionPackage
{
    internal class ChartControlExtensionPackage : UITestExtensionPackage
    {
    }
}

  8. Definieren Sie das UITestExtensionPackage-Attribut für die Assembly.

    [assembly: Microsoft.VisualStudio.TestTools.UITest.Extension.UITestExtensionPackage(
                "ChartControlExtensionPackage",
                typeof(ChartControlExtensionPackage.ChartControlExtensionPackage))]
namespace ChartControlExtensionPackage
{
   …

  9. In der Erweiterungspaketklasse Überschreibung UITestExtensionPackage.GetService, um die Eigenschaftanbieterklasse zurückzugeben, wenn ein Eigenschaftenanbieter angefordert wird.

    internal class ChartControlExtensionPackage : UITestExtensionPackage
{
    public override object GetService(Type serviceType)
    {
        if (serviceType == typeof(UITestPropertyProvider))
        {
            if (propertyProvider == null)
            {
                propertyProvider = new ChartControlPropertyProvider();
            }
            return propertyProvider;
        }
        return null;
    }

    private UITestPropertyProvider propertyProvider = null;
}

  10. Überschreiben Sie die übrigen abstrakten Methoden und Eigenschaften von UITestExtensionPackage.

    public override void Dispose() { }

public override string PackageDescription
{
    get { return "Supports coded UI testing of ChartControl"; }
}

public override string PackageName
{
    get { return "ChartControl Test Extension"; }
}

public override string PackageVendor
{
    get { return "Microsoft (sample)"; }
}

public override Version PackageVersion
{
    get { return new Version(1, 0); }
}

public override Version VSVersion
{
    get { return new Version(10, 0); }
}

  11. Erstellen Sie die Binärdateien und kopieren Sie sie in %ProgramFiles%\Common\Microsoft Shared\VSTT\10.0\UITestExtensionPackages.

HinweisHinweis

Dieses Erweiterungspaket wird für jedes Steuerelement angewendet, das vom Typ "Text" ist.Wenn Sie mehrere Steuerelemente desselben Typs testen, müssen Sie diese separat testen und verwalten, die Erweiterungspakete bereitgestellt werden, wenn Sie die Tests aufzeichnen.

Sichern Sie Codegenerierung, indem Sie eine Klasse implementieren, um auf benutzerdefinierte Eigenschaften zuzugreifen

Wenn der Test-Generator für codierte UI Code aus einer Sitzungsaufzeichnung generiert, wird die UITestControl-Klasse, um auf die Steuerelemente zuzugreifen.

UITestControl uIAText = this.UIItemWindow.UIChartControlWindow.UIAText;
Assert.AreEqual(this.AssertMethod3ExpectedValues.UIATextState, uIAText.GetProperty("State").ToString());

Wenn Sie einen Eigenschaftenanbieter implementiert haben, um Zugriff auf benutzerdefinierte Eigenschaften des Steuerelements zu ermöglichen, können Sie eine spezielle Klasse hinzufügen, die verwendet wird, um auf diese Eigenschaften zuzugreifen, sodass der generierte Code vereinfacht wird.

ControlLegend uIAText = this.UIItemWindow.UIChartControlWindow.UIAText;
Assert.AreEqual(this.AssertMethod3ExpectedValues.UIATextState, uIAText.State);

Hh552522.collapse_all(de-de,VS.110).gifSo fügen Sie eine spezialisierte Klasse hinzu, um auf das Steuerelement zuzugreifen

CUIT_CodeGen

  1. Implementieren Sie eine Klasse, die von WinControl abgeleitet ist und fügen Sie den Typ des Steuerelements der Sucheigenschaftenauflistung im Konstruktor hinzu.

    public class CurveLegend:WinControl 
{
   public CurveLegend(UITestControl c) : base(c) 
   {
      // The curve legend control is a “text” type of control
      SearchProperties.Add(
         UITestControl.PropertyNames.ControlType, "Text");
   }
}

  2. Implementieren Sie die benutzerdefinierten Eigenschaften des Steuerelements als Eigenschaften der - Klasse.

    public virtual string State
{
    get
    {
        return (string)GetProperty("State");
    }
}

  3. Überschreiben Sie UITestPropertyProvider.GetSpecializedClass-Methode des Eigenschaftanbieters, um den Typ der neuen Klasse für die Kurvenlegendenuntergeordneten Steuerelemente zurückzugeben.

    public override Type GetSpecializedClass(UITestControl uiTestControl) 
{ 
   if (uiTestControl.ControlType.NameEquals("Text")) 
   { 
      // This is text type of control. For my control,
      // that means it’s a curve legend control.
      return typeof(CurveLegend); 
   } 

   // this is not a curve legend control
   return null;
}

  4. Überschreiben Sie GetPropertyNamesClassType-Methode des Eigenschaftanbieters, um den Typ der neuen das PropertyNames-Methode der Klassen zurückzugeben.

    public override Type GetPropertyNamesClassType(UITestControl uiTestControl)
{
    if (uiTestControl.ControlType.NameEquals("Text"))
    {
      // This is text type of control. For my control,
      // that means it’s a curve legend control.
        return typeof(CurveLegend.PropertyNames);
    }

    // this is not a curve legend control
    return null;
}

Sichern Sie Absicht-bewusste Aktionen, indem Sie einen Aktionsfilter implementieren

Wenn Visual Studio einen Test erfasst wird, zeichnet es jedes Maus- und Tastaturereignis auf.In einigen Fällen kann die Absicht der Aktion in den Reihe von Maus- und Tastaturereignissen verloren gehen.Wenn die vom Steuerelement automatisch vervollständigt, kann der gleiche Satz von Tastaturereignissen Maus- und einen anderen Wert, wenn der Test wiedergegeben in einer anderen Umgebung ist.Sie können ein Aktionsfilter-Plug-In hinzufügen, das die Zeilen der Tastatur und der Mausereignisse durch eine einzelne Aktion ersetzt.Auf diese Weise, können Sie die Reihe von Maus- und Tastaturereignissen mit dem Ergebnis der Auswahl eines Werts durch eine einzelne Aktion ersetzen, die den Wert festlegt.Das eingelesen, schützt Tests der codierten UI der Unterschiede automatische Vervollständigung in aus einer Umgebung zu anderen.

Hh552522.collapse_all(de-de,VS.110).gifSo Absicht-bewusste Aktionen unterstützen

CUIT_Actions

  1. Implementieren Sie eine Aktionsfilterklasse, die von UITestActionFilter abgeleitet wird und die Eigenschaften ApplyTimeout, Category, Enabled, FilterType, Group und Name überschreibt.

    internal class MyActionFilter : UITestActionFilter
{
   // If the user actions we are aggregating exceeds the time allowed,
   // this filter is not applied. (The timeout is configured when the
   // test is run.)
   public override bool ApplyTimeout
   {
      get { return true; }
   }

   // Gets the category of this filter. Categories of filters
   // are applied in priority order.
   public override UITestActionFilterCategory Category
   {
      get { return UITestActionFilterCategory.PostSimpleToCompoundActionConversion; }
   }

   public override bool Enabled
   {
      get { return true; }
   }


   public override UITestActionFilterType FilterType
   {
      // This action filter operates on a single action
      get { return UITestActionFilterType.Unary; }
   }

   // Gets the name of the group to which this filter belongs.
   // A group can be enabled/disabled using configuration file.
   public override string Group
   {
      get { return "ChartControlActionFilters"; }
   }

   // Gets the name of this filter.
   public override string Name
   {
      get { return "Convert Double-Click to Single-Click"; }
   }

  2. Überschreiben Sie ProcessRule.Die hier realpces Beispiel eine Doppelklickaktion mit einer Einzelklickaktion.

    public override bool ProcessRule(IUITestActionStack actionStack)
{
    if (actionStack.Count > 0)
    {
        MouseAction lastAction = actionStack.Peek() as MouseAction;
        if (lastAction != null)
        {
            if (lastAction.UIElement.ControlTypeName.Equals(
                 ControlType.Text.ToString(),
                 StringComparison.OrdinalIgnoreCase))
            {
                if(lastAction.ActionType == MouseActionType.DoubleClick)
                {
                    // Convert to single click
                    lastAction.ActionType = MouseActionType.Click;
                }
            }
        }
    }
    // Do not stop aggregation
    return false;
}

  3. Fügen Sie den Aktionsfilter der GetService-Methode des Erweiterungspakets hinzu.

    public override object GetService(Type serviceType) 
{ 
   if (serviceType == typeof(UITestPropertyProvider)) 
   { 
      if (propertyProvider == null)
      {
         propertyProvider = new PropertyProvider();
      } 
      return propertyProvider;
   } 
   else if (serviceType == typeof(UITestActionFilter)) 
   { 
      if (actionFilter == null)
      {
         actionFilter = new RadGridViewActionFilter();
      }
      return actionFilter; 
   } 
   return null;
}

  4. Erstellen Sie die Binärdateien und kopieren Sie sie in %ProgramFiles%\Common Files\Microsoft Shared\VSTT\10.0\UITestExtensionPackages.

HinweisHinweis

Der Aktionsfilter hängt nicht von der Barrierefreiheitsimplementierung oder vom Eigenschaftenanbieter ab.

Debuggen Sie den Eigenschaft-Anbieter oder Aktionsfiltern

das Eigenschaftenanbieter und Aktionsfilter werden in einem Erweiterungspaket implementiert, das und Ausführung vom Test-Generator für codierte UI in einem Prozess getrennt von der Anwendung geladen wird.

Um den Eigenschaftenanbieter oder -Aktion zu debuggen Sie filtern

  1. Erstellen Sie die Debugversion der Erweiterungspakets und kopieren Sie die DLL- und PDB-Dateien in %ProgramFiles%\Common Files\Microsoft Shared\VSTT\10.0\UITestExtensionPackages.

  2. Führen Sie die Anwendung aus (nicht im Debugger).

  3. Führen Sie den Test-Generator für codierte UI aus.

    codedUITestBuilder.exe /standalone

  4. Fügen Sie den Debugger an den Prozess codedUITestBuilder an.

  5. Legen Sie Haltepunkte im Code fest.

  6. Im Test-Generator für codierte UI erstellen Sie Assertionen, um den Eigenschaftenanbieter auszuführen, und Datensatzaktionen, die Aktion zu filtert.

Externe Ressourcen

Hh552522.collapse_all(de-de,VS.110).gifEmpfehlungen

Tests für fortlaufende Übermittlung mit Visual Studio 2012 - Chapter 2: Komponententest: Testen des Inneres

Siehe auch

Referenz

AccessibleObject

Konzepte

Überprüfen von Code mithilfe von Test der codierten Benutzeroberfläche