Verifica del codice mediante l'automazione interfaccia utente

Articolo
06/08/2015

I test automatizzati che eseguono operazioni sull'applicazione tramite l'interfaccia utente sono noti come test codificati dell'interfaccia utente (CUIT).Questi test includono test funzionali dei controlli dell'interfaccia utentee consentono di verificare il corretto funzionamento dell'intera applicazione, compresa l'interfaccia utente.I test codificati dell'interfaccia utente sono particolarmente utili quando l'interfaccia utente contiene codice di convalida o logica di altro tipo, come ad esempio in una pagina Web.Sono spesso usati anche per automatizzare un test manuale esistente.

Come mostrato nell'illustrazione seguente, in una procedura di sviluppo tipica si può iniziare semplicemente compilando l'applicazione (F5) e poi facendo clic sui vari controlli dell'interfaccia utente per verificare che il funzionamento sia corretto.Si può quindi decidere di creare un test codificato per non dover continuare a testare l'applicazione manualmente.In base alla specifica funzionalità da testare nell'applicazione, si può scrivere codice per un test funzionale o per un test di integrazione, che può includere o meno il testing a livello di interfaccia utente.Se si vuole semplicemente accedere alla logica di business, si può scrivere il codice di uno unit test.In alcuni casi, tuttavia, può essere utile includere il testing dei vari controlli dell'interfaccia utente nell'applicazione.Un test codificato dell'interfaccia utente può automatizzare lo scenario iniziale (F5), verificando che la varianza del codice non incida sul funzionamento dell'applicazione.

Test durante lo sviluppo dell'applicazione

Creare un test codificato dell'interfaccia utente è semplice.Basta eseguire il test manualmente mentre il Generatore di test codificati dell'interfaccia utente è in esecuzione in background.È anche possibile specificare i valori che devono apparire in specifici campi.Il Generatore di test codificati dell'interfaccia utente registra le azioni e genera codice dalla registrazione.Dopo aver creato il test, è possibile modificarlo in un editor specializzato che consente di modificare la sequenza di azioni.

In alternativa, se si dispone di un test case registrato in Microsoft Test Manager, si può generare codice a partire da esso.Per altre informazioni, vedere Registrare e riprodurre test manuali.

L'editor specializzato e il Generatore di test codificati dell'interfaccia utente agevolano la creazione e la modifica di test codificati dell'interfaccia utente, anche se proprie competenze principali sono orientate al testing piuttosto che alla scrittura di codice.Per gli sviluppatori che vogliono estendere i test in modo più avanzato, tuttavia, il codice è strutturato in modo da essere estremamente semplice da copiare e adattare.Ad esempio, si può registrare un test per l'acquisto di un articolo in un sito Web e quindi modificare il codice generato per aggiungere un ciclo che acquista molti articoli.

Requisiti

Visual Studio Ultimate, Visual Studio Premium

Per altre informazioni sulle piattaforme e le configurazioni supportate dai test codificati dell'interfaccia utente, vedere Configurazioni e piattaforme supportate per i test codificati dell'interfaccia utente e le registrazioni delle azioni.

In questo argomento

Creazione di test codificati dell'interfaccia utente
- Procedura principale
- Avvio e arresto dell'applicazione
- Convalida delle proprietà dei controlli dell'interfaccia utente
Personalizzazione del test codificato dell'interfaccia utente
- Il codice generato
- Codifica di azioni e proprietà del controllo dell'interfaccia utente
- Debug
Passaggi successivi

Creazione di test codificati dell'interfaccia utente

Creare un progetto di test codificato dell'interfaccia utente.

I test codificati dell'interfaccia utente devono essere contenuti in un progetto di test codificato dell'interfaccia utente.Se non si dispone già di un progetto di test codificato dell'interfaccia utente, crearne uno.In Esplora soluzioni, scegliere Aggiungi, Nuovo progetto dal menu di scelta rapida della soluzione e quindi selezionare Visual Basic o Visual C#.Scegliere quindi Test, Test codificato dell'interfaccia utente.
- I modelli di Test codificato dell'interfaccia utente non sono disponibili.
  
  È possibile che si usi una versione di Microsoft Visual Studio 2012 che non supporta i test codificati dell'interfaccia utente.Per creare test codificati dell'interfaccia utente è necessario usare Visual Studio Ultimate o Visual Studio Premium.
Aggiungere un file di test codificato dell'interfaccia utente.

Se è stato appena creato un progetto di test codificato dell'interfaccia utente, il primo file di test codificato dell'interfaccia utente viene aggiunto automaticamente.Per aggiungere un altro file di test, aprire il menu di scelta rapida nel progetto di test codificato dell'interfaccia utente, scegliere Aggiungi e quindi Test codificato dell'interfaccia utente .

Nella finestra di dialogo Genera codice per test codificato dell'interfaccia utente scegliere Registra azioni, modifica mappa dell'interfaccia utente o aggiungi asserzioni.

Verrà visualizzato Generatore di test codificati dell'interfaccia utente e Visual Studio verrà ridotto a icona.

Registrare una sequenza di azioni.

Per avviare la registrazione, scegliere l'icona Registra.Eseguire le azioni da testare nell'applicazione, incluso l'avvio dell'applicazione se necessario.

Ad esempio, se si sta testando un'applicazione Web, si potrebbe avviare un browser, passare al sito Web e accedere all'applicazione.

Per sospendere la registrazione, ad esempio per controllare la posta elettronica, scegliere Sospendi.

Attenzione
Tutte le azioni eseguite sul desktop verranno registrate.Sospendere la registrazione se si eseguono azioni che possono comportare l'inserimento di dati sensibili nella registrazione.

Per eliminare le azioni registrate per errore, scegliere Modifica azioni.

Per generare codice che replicherà le azioni, scegliere l'icona Genera codice e digitare un nome per il metodo del test codificato dell'interfaccia utente.

Verificare i valori nei campi dell'interfaccia utente, ad esempio le caselle di testo.

Scegliere Aggiungi asserzioni nel Generatore di test codificati dell'interfaccia utente e quindi scegliere un controllo dell'interfaccia utente nell'applicazione in esecuzione.Nell'elenco delle proprietà visualizzato selezionare una proprietà, ad esempio, Testo in una casella di testo.Scegliere Aggiungi asserzione dal menu di scelta rapida.Nella finestra di dialogo selezionare l'operatore di confronto, il valore di confronto e il messaggio di errore.

Chiudere la finestra delle asserzioni e scegliere Genera codice.

Elemento per il test codificato dell'interfaccia utente

Suggerimento
Passare alternativamente dalla registrazione delle azioni alla verifica dei valori.Generare il codice al termine di ogni sequenza di azioni o verifiche.Se necessario, sarà possibile inserire nuove azioni e verifiche in un secondo momento.

Per informazioni dettagliate, vedere Convalida delle proprietà dei controlli.

Visualizzare il codice di test generato.

Per visualizzare il codice di test generato, chiudere la finestra del Generatore di test codificati dell'interfaccia utente.Nel codice è possibile visualizzare i nomi assegnati a ogni passaggio.Il codice si trova nel test codificato dell'interfaccia utente creato:

    [CodedUITest]
    public class CodedUITest1
    { ...
      [TestMethod]
      public void CodedUITestMethod1()
      {
          this.UIMap.AddTwoNumbers();
          this.UIMap.VerifyResultValue();
          // To generate more code for this test, select 
          // "Generate Code" from the shortcut menu.
      }
    }

Aggiungere altre azioni e asserzioni.

Posizionare il cursore nel punto appropriato nel metodo di test e quindi scegliere Genera codice per test codificato dell'interfaccia utente dal menu di scelta rapida.Il nuovo codice verrà inserito nel punto specificato.
Modificare i dettagli delle azioni di test e delle asserzioni.

Aprire UIMap.uitest.Il file verrà aperto nell'Editor di test codificati dell'interfaccia utente, in cui è possibile modificare qualsiasi sequenza di azioni registrate e modificare le asserzioni.

Per altre informazioni, vedere Modifica di test codificati dell'interfaccia utente utilizzando l'editor di test codificato dell'interfaccia utente.
Eseguire il test.

Usare Esplora test o aprire il menu di scelta rapida nel metodo di test e scegliere Esegui test.Per altre informazioni sull'esecuzione dei test, vedere Esecuzione di unit test con Esplora test e Opzioni aggiuntive per l'esecuzione di test codificati dell'interfaccia utente nella sezione Passaggi successivi alla fine di questo argomento.

Le sezioni rimanenti di questo argomento offrono informazioni più dettagliate sui passaggi di questa procedura.

Per un esempio più dettagliato, vedere Procedura dettagliata: creazione, modifica e gestione di un test codificato dell'interfaccia utente.In questa procedura dettagliata verrà creata una semplice applicazione Windows Presentation Foundation (WPF) per dimostrare come creare, modificare e gestire un test codificato dell'interfaccia utente.Nella procedura dettagliata vengono fornite le soluzioni per correggere i test interrotti da vari problemi di temporizzazione e dal refactoring del controllo.

Avvio e arresto dell'applicazione sottoposta a test

Non si vuole avviare e interrompere separatamente l'applicazione, il browser o il database.Come evitare il problema.

Se non si vogliono registrare le azioni per avviare l'applicazione sottoposta a test, è necessario avviare l'applicazione prima di fare clic sull'icona Registra.
Alla fine di un test, il processo in cui viene eseguito il test viene terminato.Se l'applicazione è stato avviata nel test, in genere viene chiusa.Se non si vuole che il test chiuda l'applicazione all'uscita, è necessario aggiungere un file .runsettings alla soluzione e usare l'opzione KeepExecutorAliveAfterLegacyRun.Per altre informazioni, vedere Configurazione di unit test mediante un file .runsettings.
È possibile aggiungere un metodo Initialize del test, identificato da un attributo [TestInitialize], che esegua il codice all'inizio di ogni metodo di test.Ad esempio, si può avviare l'applicazione dal metodo TestInitialize.
È possibile aggiungere un metodo Cleanup del test, identificato da un attributo [TestCleanup], che esegua il codice alla fine di ogni metodo di test.Ad esempio, il metodo per chiudere l'applicazione potrebbe essere chiamato dal metodo TestCleanup.

Convalida delle proprietà dei controlli dell'interfaccia utente

Si può usare il Generatore di test codificati dell'interfaccia utente per aggiungere un controllo dell'interfaccia utente a UIMap per il test o per generare codice per un metodo di convalida che usa un'asserzione per un controllo dell'interfaccia utente.

Per generare asserzioni per i controlli dell'interfaccia utente, scegliere lo strumento Aggiungi asserzioni nel Generatore di test codificati dell'interfaccia utente e trascinarlo sul controllo dell'applicazione sottoposta a test da verificare.Quando il controllo risulta delimitato da una casella, rilasciare il mouse.Il codice della classe di controllo viene creato immediatamente nel file UIMap.Designer.cs.

Elemento per il test codificato dell'interfaccia utente

Le proprietà per questo controllo sono ora elencate nella finestra di dialogo Aggiungi asserzioni.

Un altro modo per passare a un particolare controllo consiste nel fare clic sulla freccia (<<) per espandere la visualizzazione della mappa del controllo dell'interfaccia utente.Per trovare un controllo padre, di pari livello o figlio, fare clic in qualsiasi punto della mappa e usare i tasti di direzione per spostarsi all'interno dell'albero.

Proprietà del test codificato dell'interfaccia utente

Quando si seleziona un controllo nell'applicazione non vengono visualizzate proprietà o il controllo non viene visualizzato nella mappa del controllo dell'interfaccia utente.

Nel codice dell'applicazione, il controllo da verificare deve avere un ID univoco, ad esempio un attributo ID HTML o un UId WPF.Per aggiungere questi ID può essere necessario aggiornare il codice dell'applicazione.

Aprire quindi il menu di scelta rapida della proprietà del controllo dell'interfaccia utente da verificare e scegliere Aggiungi asserzione.Nella finestra di dialogo Aggiungi asserzione selezionare i Criteri di confronto per l'asserzione, ad esempio AreEqual, quindi digitare il valore per l'asserzione in Valore di confronto.

Asserzioni del test codificato dell'interfaccia utente

Dopo avere aggiunto tutte le asserzioni per il test, fare clic su OK.

Per generare codice per le asserzioni e aggiungere il controllo alla mappa dell'interfaccia utente fare clic sull'icona Genera codice.Digitare un nome e una descrizione per il metodo del test codificato dell'interfaccia utente, che verranno aggiunti come commenti per il metodo.Scegliere Aggiungi e genera.Fare clic sull'icona Chiudi per chiudere il Generatore di test codificati dell'interfaccia utente.Verrà generato codice simile al seguente.Ad esempio, se il nome immesso è AssertForAddTwoNumbers, il codice sarà simile a quello di questo esempio:

Aggiunge una chiamata al metodo di asserzione AssertForAddTwoNumbers al metodo di test nel file del test codificato dell'interfaccia utente:
```
      [TestMethod]
      public void CodedUITestMethod1()
      {
          this.UIMap.AddTwoNumbers();
          this.UIMap.AssertForAddTwoNumbers();
      }
```
È possibile modificare questo file per modificare l'ordine dei passaggi e delle asserzioni o per creare nuovi metodi di test.Per aggiungere codice, posizionare il cursore sul metodo di test e scegliere Genera codice per test codificato dell'interfaccia utente dal menu di scelta rapida.
Aggiunge un metodo denominato AssertForAddTwoNumbers alla mappa dell'interfaccia utente (UIMap.uitest).Il file viene aperto nell'Editor di test codificati dell'interfaccia utente, in cui è possibile modificare le asserzioni.

Per altre informazioni, vedere Modifica di test codificati dell'interfaccia utente utilizzando l'editor di test codificato dell'interfaccia utente.

È anche possibile visualizzare il codice generato del metodo di asserzione nel file UIMap.Designer.cs.Tuttavia, è consigliabile non modificare questo file.Se si vuole creare una versione modificata del codice, copiare i metodi in un altro file, ad esempio UIMap.cs, rinominare i metodi e modificarli in quel file.
```
      public void AssertForAddTwoNumbers()
      {
          ...
      }
```

Il controllo da selezionare perde lo stato attivo e scompare quando si cerca di selezionare lo strumento Aggiungi asserzioni dal Generatore di test codificati dell'interfaccia utente. Come selezionare il controllo.

Selezione di un controllo nascosto tramite tastiera

A volte, durante l'aggiunta di controlli e la convalida delle proprietà, può essere necessario usare la tastiera.Ad esempio, quando si tenta di registrare un test codificato dell'interfaccia utente che usa un controllo del menu di scelta rapida, l'elenco delle voci di menu nel controllo perderà lo stato attivo e sparirà quando si cerca di selezionare lo strumento Aggiungi asserzioni dal Generatore di test codificati dell'interfaccia utente.Questa situazione è illustrata nella figura seguente, in cui il menu di scelta rapida in Internet Explorer perde lo stato attivo e scompare quando si cerca di selezionarlo con lo strumento Aggiungi asserzioni.

CodedUITest_SelectControlKeyboard

Per usare la tastiera per selezionare un controllo dell'interfaccia utente, passare il puntatore del mouse sul controllo.Tenere premuti contemporaneamente CTRL e I.Rilasciare i tasti.Il controllo viene registrato dal Generatore di test codificati dell'interfaccia utente.

Attenzione
Se si usa Microsoft Lync, è necessario chiudere Lync prima di avviare il Generatore di test codificati dell'interfaccia utente.Microsoft Lync interferisce con la scelta rapida da tastiera CTRL+I.

Non è possibile registrare un passaggio del mouse su un controllo. Come risolvere il problema.

Registrazione manuale dei passaggi del mouse

In alcuni casi circostanze, un particolare controllo usato in un test codificato dell'interfaccia utente può richiedere l'uso della tastiera per registrare manualmente gli eventi di passaggio del mouse.Ad esempio, quando si testa un Windows Form o un'applicazione Windows Presentation Foundation (WPF) può essere presente codice personalizzatooppure può essere stato definito un comportamento speciale definito per il passaggio del puntatore su un controllo, ad esempio l'espansione di un nodo dell'albero.Per testare casi come questi, è necessario notificare manualmente al Generatore di test codificati dell'interfaccia utente che si sta passando il puntatore sul controllo premendo specifici tasti.

Quando si esegue il test codificato dell'interfaccia utente, passare il puntatore sul controllo.Quindi, tenere contemporaneamente premuti CTRL, MAIUSC e R.Rilasciare i tasti.Il Generatore di test codificati dell'interfaccia utente registrerà un evento di passaggio del mouse.

Dopo aver generato il metodo di test, al file UIMap.Desinger.cs verrà aggiunto codice simile a quello riportato nell'esempio seguente:
```
// Mouse hover '1' label at (87, 9)
Mouse.Hover(uIItem1Text, new Point(87, 9));
```

La scelta rapida da tastiera assegnata all'acquisizione degli eventi di passaggio del mouse è già in uso nell'ambiente. Come modificare scelta rapida da tastiera predefinita.

Configurazione della scelta rapida da tastiera per il passaggio del mouse

Se necessario, è possibile modificare la scelta rapida da tastiera CTRL+MAIUSC+R usata per applicare gli eventi di passaggio del mouse nei test codificati dell'interfaccia utente, in modo da usare tasti diversi.

Attenzione
In circostanze normali, non è necessario modificare la scelta rapida da tastiera per gli eventi di passaggio del mouse.Prestare attenzione nella riassegnazione dei tasti.La scelta rapida da tastiera potrebbe essere già in uso in Visual Studio o nell'applicazione sottoposta a test.

Per modificare le scelte rapida da tastiera è necessario modificare il file di configurazione seguente:

<lettera di unità:>\Programmi (x86)\Microsoft Visual Studio 11.0\Common7\IDE\CodedUITestBuilder.exe.config

Nel file di configurazione modificare i valori per i tasti HoverKeyModifier e HoverKey per modificare la scelta rapida da tastiera:

<!-- Begin : Background Recorder Settings -->
<!-- HoverKey to use. -->
<add key="HoverKeyModifier" value="Control, Shift"/>
<add key="HoverKey" value="R"/>

Non si riesce a registrare gli eventi di passaggio del mouse in un sito Web. Come risolvere il problema.

Impostazione di eventi di passaggio del mouse impliciti per il Web browser

In molti siti Web, quando si passa il puntatore su un particolare controllo, questo si espande per visualizzare ulteriori dettagli.In genere, nelle applicazioni desktop, questi vengono visualizzati come menu.Poiché si tratta di un comportamento comune, i test codificati dell'interfaccia utente consentono gli eventi di passaggio del mouse impliciti per l'esplorazione Web.Ad esempio, se si registrano passaggi del mouse in Internet Explorer, viene generato un evento.Questi eventi possono causare la registrazione di passaggi del mouse ridondanti.Per questo motivo, gli eventi di passaggio del mouse impliciti vengono registrati nel file di configurazione del test dell'interfaccia utente con ContinueOnError impostato su true.In questo modo, in caso di errore di un evento di passaggio del mouse, la riproduzione continua.

Per abilitare la registrazione degli eventi di passaggio del mouse impliciti in un Web browser, aprire il file di configurazione:

<lettera di unità:>\Programmi (x86)\Microsoft Visual Studio 11.0\Common7\IDE\CodedUITestBuilder.exe.config

Verificare che nel file di configurazione il tasto RecordImplicitiHovers sia impostato sul valore true, come mostrato nell'esempio seguente:
```

<add key="RecordImplicitHover" value="true"/>
```

Personalizzazione del test codificato dell'interfaccia utente

Dopo aver creato il test codificato dell'interfaccia utente, è possibile modificarlo usando uno qualsiasi degli strumenti seguenti in Visual Studio:

Generatore di test codificati dell'interfaccia utente: usare il Generatore di test codificati dell'interfaccia utente per aggiungere controlli e convalida ai test.Vedere la sezione Aggiunta di controlli e la convalida delle proprietà in questo argomento.
Editor di test codificati dell'interfaccia utente: l'Editor di test codificati dell'interfaccia utente consente di modificare facilmente i test.Con l'Editor di test codificati dell'interfaccia utente è possibile individuare, visualizzare e modificare i metodi di test.È anche possibile modificare le azioni dell'interfaccia utente e i relativi controlli associati nella mappa di controllo dell'interfaccia utente.Per altre informazioni, vedere Modifica di test codificati dell'interfaccia utente utilizzando l'editor di test codificato dell'interfaccia utente.
Editor di codice:
- Aggiungere manualmente il codice per i controlli nel test come descritto nella sezione Codifica di azioni e proprietà del controllo dell'interfaccia utente in questo argomento.
- Dopo aver creato un test codificato dell'interfaccia utente, è possibile modificarlo in modo che sia basato sui dati.Per altre informazioni, vedere Creazione di un test codificati dell'interfaccia utente basato sui dati.
- Nella riproduzione di un test codificato dell'interfaccia utente è possibile fare in modo che il test attenda che si verifichino determinati eventi, ad esempio che venga visualizzata finestra, venga nascosto l'indicatore di stato e così via.A questo scopo, usare il metodo UITestControl.WaitForControlXXX() appropriato.Per un elenco completo dei metodi disponibili, vedere Impostazione dei test codificati dell'interfaccia utente per l'attesa di eventi specifici durante la riproduzione.Per un esempio di test codificato dell'interfaccia utente impostato in modo da attendere che un controllo venga abilitato tramite il metodo WaitForControlEnabled, vedere Procedura dettagliata: creazione, modifica e gestione di un test codificato dell'interfaccia utente.
- I test codificati dell'interfaccia utente includono il supporto per alcuni dei controlli HTML5 inclusi in Internet Explorer 9 e Internet Explorer 10.Per altre informazioni, vedere Utilizzo dei controlli HTML5 nei test codificati dell'interfaccia utente.
- Informazioni aggiuntive sui test codificati dell'interfaccia utente:

Il codice generato

Quando si sceglie Genera codice, vengono create diverse parti di codice:

Una riga nel metodo di test.
```
    [CodedUITest]
    public class CodedUITest1
    { ...
      [TestMethod]
      public void CodedUITestMethod1()
      {
          this.UIMap.AddTwoNumbers();
          // To generate more code for this test, select 
          // "Generate Code" from the shortcut menu.      }
    }
```
Facendo con il pulsante destro del mouse sul metodo è possibile aggiungere altre azioni registrate e verifiche,nonché modificarlo manualmente per estendere o modificare il codice.Ad esempio, si può racchiudere parte del codice in un ciclo.

È anche possibile aggiungere nuovi metodi di test e aggiungere codice nello stesso modo.Tutti i metodi di test devono disporre dell'attributo [TestMethod].
Un metodo in UIMap.uitest

Questo metodo include i dettagli delle azioni registrate o il valore verificato.Per modificare questo codice, aprire UIMap.uitest.Il file verrà aperto in un editor specializzato, in cui è possibile eliminare o effettuare il refactoring delle azioni registrate.

È anche possibile visualizzare il metodo generato UIMap.Designer.cs.Questo metodo esegue le azioni registrate durante l'esecuzione del test.
```
// File: UIMap.Designer.cs
public partial class UIMap
{
  /// <summary>
  /// Add two numbers
  /// </summary>
  public void AddTwoNumbers()
  { ...   }
}
```
Attenzione

È consigliabile non modificare questo file, perché verrà rigenerato quando si creano ulteriori test.

È possibile creare versioni modificate di questi metodi copiandoli in UIMap.cs.Si può ad esempio creare una versione con parametri che può essere chiamata da un metodo di test:
```
// File: UIMap.cs
public partial class UIMap // Same partial class
{
  /// <summary>
  /// Add two numbers – parameterized version
  /// </summary>
  public void AddTwoNumbers(int firstNumber, int secondNumber)
  { ...   // Code modified to use parameters.
  }
}
```
Dichiarazioni in UIMap.uitest

Queste dichiarazioni rappresentano i controlli dell'interfaccia utente dell'applicazione usata dal test.Vengono usate dal codice generato per azionare i controlli e accedere alle relative proprietà.

Possono essere usate anche per la scrittura di codice personalizzato.Ad esempio, si può fare in modo che il metodo di test faccia clic su un collegamento ipertestuale in un'applicazione Web, digiti un valore in una casella di testo o crei rami ed esegua azioni di test diverse in base a un valore di un campo.

È possibile aggiungere più test codificati dell'interfaccia utente, oggetti della mappa dell'interfaccia utente e file per semplificare il test di un'applicazione di grandi dimensioni.Per altre informazioni, vedere Test di un'applicazione di grandi dimensioni con più mappe dell'interfaccia utente.

Attenzione
È consigliabile non modificare questo file, perché verrà rigenerato quando si creano ulteriori test.

Per altre informazioni sul codice generato, vedere Composizione di un test codificato dell'interfaccia utente.

Codifica di azioni e proprietà del controllo dell'interfaccia utente

Quando si usano i controlli di test dell'interfaccia utente nei test codificati dell'interfaccia utente, questi sono suddivisi in due parti: azioni e proprietà.

La prima parte consiste in azioni che è possibile eseguire sui controlli di test dell'interfaccia utente.Ad esempio, i test codificati dell'interfaccia utente possono simulare i clic del mouse su un controllo di test dell'interfaccia utente o i tasti premuti sulla tastiera per agire su un controllo di test dell'interfaccia utente.
La seconda parte consente di ottenere e impostare proprietà in un controllo di test dell'interfaccia utente. Ad esempio, i test codificati dell'interfaccia utente possono ottenere il conteggio di elementi in un elemento ListBox oppure impostare un elemento CheckBox sullo stato selezionato.

Accesso alle azioni dei controlli di test dell'interfaccia utente

Per eseguire azioni su controlli di test dell'interfaccia utente, ad esempio clic del mouse o azioni della tastiera, usare i metodi delle classi Mouse e Keyboard:

Per eseguire un'azione orientata al mouse, ad esempio un clic del mouse, su un controllo di test dell'interfaccia utente, usare Click.

Mouse.Click(buttonCancel);
Per eseguire un'azione orientata alla tastiera, ad esempio la digitazione in un controllo di modifica, usare SendKeys.

Keyboard.SendKeys(textBoxDestination, @"C:\\Temp\\Output.txt");

Accesso alle proprietà dei controlli di test dell'interfaccia utente

Per ottenere e impostare valori di proprietà specifiche del controllo dell'interfaccia utente, è possibile ottenere o impostare direttamente i valori delle proprietà di un controllo oppure usare i metodi UITestControl.GetProperty e UITestControl.SetProperty con il nome della specifica proprietà che si vuole ottenere o impostare.

GetProperty restituisce un oggetto di cui è possibile eseguire il cast nell'oggetto Type appropriato.SetProperty accetta un oggetto per il valore della proprietà.

Per ottenere e impostare proprietà direttamente dai controlli di test dell'interfaccia utente

Con i controlli che derivano da T:Microsoft.VisualStudio.TestTools.UITesting.UITestControl, ad esempio T:Microsoft.VisualStudio.TestTools.UITesting.HtmlControls.HtmlList o T:Microsoft.VisualStudio.TestTools.UITesting.WinControls.WinComboBox, è possibile ottenere o impostare i valori di proprietà direttamente, come illustrato di seguito:
```
int i = myHtmlList.ItemCount;
myWinCheckBox.Checked = true;
```

Per ottenere proprietà dai controlli di test dell'interfaccia utente

Per ottenere un valore di proprietà da un controllo, usare GetProperty.
Per specificare la proprietà del controllo da ottenere, usare la stringa appropriata dalla classe PropertyNames in ogni controllo come parametro del metodo GetProperty.
GetProperty restituisce il tipo di dati appropriato, ma questo valore restituito viene sottoposto a cast come Object.È quindi necessario eseguire il cast dell'oggetto Object restituito nel tipo di dati appropriato.

Esempio:

int i = (int)GetProperty(myHtmlList.PropertyNames.ItemCount);

Per impostare proprietà per i controlli di test dell'interfaccia utente

Per impostare una proprietà in un controllo, usare SetProperty.
Per specificare la proprietà del controllo da impostare, usare la stringa appropriata dalla classe PropertyNames come primo parametro del metodo SetProperty, con il valore di proprietà come secondo parametro.

Esempio:

SetProperty(myWinCheckBox.PropertyNames.Checked, true);

Debug

È possibile analizzare i test codificati dell'interfaccia utente usando i log dei test codificati dell'interfaccia utente.I log dei test codificati dell'interfaccia utente filtrano e registrano informazioni importanti sulle esecuzioni dei test codificati dell'interfaccia utente.Il formato dei log consente di eseguire rapidamente il debug dei problemi.Per altre informazioni, vedere Analisi dei test codificati dell'interfaccia utente utilizzando i log dei test codificati dell'interfaccia utente.

Passaggi successivi

Opzioni aggiuntive per l'esecuzione di test codificati dell'interfaccia utente: come descritto in precedenza in questo argomento, è possibile eseguire test codificati dell'interfaccia utente direttamente da Visual Studio.In più, è possibile eseguire test automatizzati dell'interfaccia utente da Microsoft Test Manager o da Team Foundation Build.A differenza di altri test automatizzati, i test codificati dell'interfaccia utente automatizzati devono interagire con il desktop quando vengono eseguiti.

Aggiunta del supporto per controlli personalizzati: il framework dei test codificati dell'interfaccia utente non supporta ogni possibile interfaccia utente e potrebbe non supportare l'interfaccia utente da testare.Ad esempio, non si può creare immediatamente un test codificato per l'interfaccia utente di Microsoft Excel.Tuttavia, è possibile creare un'estensione al framework dei test codificati dell'interfaccia utente che supporterà un controllo personalizzato.

I test codificati dell'interfaccia utente vengono spesso usati per automatizzare i test manuali.Per informazioni aggiuntive, vedere il Test per la distribuzione continua con Visual Studio 2012 - Capitolo 5: automazione dei test di sistema.Per altre informazioni sui test manuali, vedere [ritirato] Creazione di test case manuali mediante Microsoft Test Manager.Per altre informazioni sui test di sistema automatizzati, vedere Creazione di test automatizzati mediante Microsoft Test Manager.

Risorse esterne

Istruzioni utili

Test per la distribuzione continua con Visual Studio 2012 – Capitolo 2: Unit Testing: Test interni

Test per la distribuzione continua con Visual Studio 2012 – Capitolo 5: automazione dei test di sistema

Domande frequenti

Domande frequenti sui test codificati dell'interfaccia utente - 1

Domande frequenti sui test codificati dell'interfaccia utente -2

Forum

Test di automazione dell'interfaccia utente di Visual Studio (include CodedUI)

Vedere anche

Condividi tramite