Cosa sono gli apparecchi nella programmazione?

Ho sentito parlare di questo termine molte volte (nel contesto della programmazione) ma non sono riuscito a trovare alcuna spiegazione di cosa significasse. Qualche buon articolo o spiegazione?

Penso che ti riferisci ai dispositivi di prova :

Lo scopo di un dispositivo di prova è quello di garantire un ambiente ben noto e fisso in cui i test vengono eseguiti in modo che i risultati siano ripetibili. Alcune persone lo chiamano il contesto di prova.

Esempi di apparecchi:

• Caricamento di un database con un set di dati specifico e noto
• Cancellazione di un disco rigido e installazione di un'installazione pulita e nota del sistema operativo
• Copia di uno specifico set di file noto
• Preparazione dei dati di input e impostazione / creazione di oggetti falsi o finti

(fonte: Wikipedia, vedi link sopra)

Ecco anche alcuni esempi pratici tratti dalla documentazione del framework "Google Test" .

Penso che i test dell'unità PHP abbiano un'ottima spiegazione di questo:

Una delle parti che richiedono più tempo per scrivere i test è scrivere il codice per impostare il mondo in uno stato noto e poi riportarlo allo stato originale quando il test è completo. Questo stato noto è chiamato il dispositivo del test.

Anche i documenti Yii descrivono una buona prova degli infissi:

I test automatizzati devono essere eseguiti più volte. Per garantire che il processo di test sia ripetibile, vorremmo eseguire i test in uno stato noto chiamato fixture. Ad esempio, per testare la funzione di creazione di post in un'applicazione blog, ogni volta che eseguiamo i test, le tabelle che memorizzano i dati rilevanti sui post (ad esempio la tabella Post, la tabella Comment) devono essere ripristinate su uno stato fisso.

Qui il semplice esempio di test degli infissi

<?php
use PHPUnit\Framework\TestCase;

class StackTest extends TestCase
{
    protected $stack;

    protected function setUp()
    {
        $this->stack = [];
    }

    protected function tearDown()
    {
        $this->stack = [];
    }

    public function testEmpty()
    {
        $this->assertTrue(empty($this->stack));
    }

    public function testPush()
    {
        array_push($this->stack, 'foo');
        $this->assertEquals('foo', $this->stack[count($this->stack)-1]);
        $this->assertFalse(empty($this->stack));
    }

    public function testPop()
    {
        array_push($this->stack, 'foo');
        $this->assertEquals('foo', array_pop($this->stack));
        $this->assertTrue(empty($this->stack));
    }
}
?>

Questo test di unità PHP ha funzioni con nomi setUpe tearDownche prima di eseguire il test imposti i tuoi dati e alla fine puoi ripristinarli allo stato iniziale.

Il termine apparecchio varia in base al contesto, al linguaggio di programmazione o alla struttura.

1. Uno stato noto contro il quale è in esecuzione un test

Una delle parti che richiedono più tempo per scrivere i test è scrivere il codice per impostare il mondo in uno stato noto e poi riportarlo allo stato originale quando il test è completo. Questo stato noto è chiamato il dispositivo del test. Documentazione dell'unità PHP

Un dispositivo di prova (noto anche come contesto di prova) è l'insieme delle condizioni preliminari o dello stato necessario per eseguire una prova. Lo sviluppatore dovrebbe impostare uno stato buono noto prima dei test e tornare allo stato originale dopo i test. Wikipedia (xUnit)

2. Un file contenente dati di esempio

Fixtures è una parola elaborata per i dati di esempio. Le partite ti consentono di popolare il tuo database di test con dati predefiniti prima che i test vengano eseguiti. Le partite sono indipendenti dal database e scritte in YAML. C'è un file per modello. RubyOnRails.org

3. Un processo che imposta uno stato richiesto. 

Un dispositivo di test del software configura il sistema per il processo di test fornendo tutto il codice necessario per inizializzarlo, soddisfacendo in tal modo tutti i presupposti possibili. Un esempio potrebbe essere il caricamento di un database con parametri noti da un sito del cliente prima di eseguire il test. Wikipedia

Proprio su questo argomento, JUnit ha un documento ben spiegato. Ecco il link!

La parte correlata dell'articolo è:

I test devono essere eseguiti sullo sfondo di un insieme noto di oggetti. Questo insieme di oggetti è chiamato dispositivo di prova. Quando si scrivono i test, spesso si nota che si impiega più tempo a scrivere il codice per impostare l'apparecchiatura rispetto a quando si eseguono effettivamente i test dei valori.

In una certa misura, è possibile semplificare la scrittura del codice del dispositivo prestando particolare attenzione ai costruttori che si scrivono. Tuttavia, un risparmio molto maggiore deriva dalla condivisione del codice del dispositivo. Spesso, sarai in grado di utilizzare lo stesso apparecchio per diversi test. Ogni caso invierà messaggi o parametri leggermente diversi all'apparecchio e verificherà risultati diversi.

Quando hai un dispositivo comune, ecco cosa fai:

Aggiungi un campo per ogni parte del dispositivo Annota un metodo con @ org.junit.Prima e inizializza le variabili in quel metodo Annota un metodo con @ org.junit.Dopo aver rilasciato tutte le risorse permanenti che hai allocato in setUp Ad esempio, per scrivere diversi casi di test che vogliono lavorare con diverse combinazioni di 12 franchi svizzeri, 14 franchi svizzeri e 28 dollari statunitensi, creano innanzitutto un dispositivo:

public class MoneyTest {
    private Money f12CHF;
    private Money f14CHF;
    private Money f28USD;

    @Before public void setUp() {
    f12CHF= new Money(12, "CHF");
    f14CHF= new Money(14, "CHF");
    f28USD= new Money(28, "USD");
    }
}

In Xamarin.UITest è spiegato come segue:

In genere, ogni Xamarin.UITest è scritto come un metodo che viene chiamato test. La classe che contiene il test è nota come dispositivo di test. L'apparecchiatura di test contiene un singolo test o un raggruppamento logico di test ed è responsabile di qualsiasi configurazione per l'esecuzione del test e di qualsiasi pulizia che deve essere eseguita al termine del test. Ogni test dovrebbe seguire il modello Arrange-Act-Assert:

• Disponi: il test imposterà le condizioni e inizializzerà le cose in modo da poter eseguire il test.
• Act: il test interagirà con l'applicazione, inserirà il testo, premendo i pulsanti e così via.
• Assert: il test esamina i risultati delle azioni eseguite nella fase Act per determinare la correttezza. Ad esempio, l'applicazione potrebbe verificare che venga visualizzato un messaggio di errore specifico.

Link per l'articolo originale dell'Estratto sopra

E all'interno del codice Xamarin.UITest appare come segue:

using System;
using System.IO;
using System.Linq;
using NUnit.Framework;
using Xamarin.UITest;
using Xamarin.UITest.Queries;

namespace xamarin_stembureau_poc_tests
{
    [TestFixture(Platform.Android)]
    [TestFixture(Platform.iOS)]
    public class TestLaunchScreen
    {
        IApp app;
        Platform platform;

        public Tests(Platform platform)
        {
            this.platform = platform;
        }

        [SetUp]
        public void BeforeEachTest()
        {
            app = AppInitializer.StartApp(platform);
        }

        [Test]
        public void AppLaunches()
        {
            app.Screenshot("First screen.");
        }

        [Test]
        public void LaunchScreenAnimationWorks()
        {
            app.Screenshot("Launch screen animation works.");
        }
    }
}

Spero che ciò possa essere utile a qualcuno che è alla ricerca di una migliore comprensione delle partite in programmazione.