web-dev-qa-db-fra.com

Quels sont les appareils en programmation?

J'avais entendu ce terme plusieurs fois auparavant (quand je parlais de programmation) mais je ne trouvais aucune explication de ce que cela signifiait. Des bons articles ou des explications? Je n'ai rien trouvé qui mérite d'être mentionné.

fixturesui-testinguitesttest-fixture
142
Matjaz Muhic

Je pense que vous faites référence à appareils de test :

Le but d'une installation de test est de s'assurer qu'il existe un environnement bien connu et fixe dans lequel les tests sont exécutés afin que les résultats puissent être répétés. Certaines personnes appellent cela le contexte de test.

Exemples de fixtures:

- Loading a database with a specific, known set of data
- Erasing a hard disk and installing a known clean operating system installation
- Copying a specific known set of files
- Preparation of input data and set-up/creation of fake or mock objects

(source: wikipedia, voir lien ci-dessus)

Voici également quelques exemples pratiques tirés de la documentation du framework "Google Test" .

139
m01

Je pense que les tests PHP-unit expliquent très bien ceci:

L'une des parties les plus fastidieuses de l'écriture de tests est l'écriture du code pour définir le monde dans un état connu, puis le remettre dans son état d'origine à la fin du test. Cet état connu s'appelle le montage du test.

De plus, Yii) documents décrivent les appareils testés dans de bonnes conditions:

Les tests automatisés doivent être exécutés plusieurs fois. Pour nous assurer que le processus de test est répétable, nous aimerions exécuter les tests dans un état connu appelé fixture. Par exemple, pour tester la fonctionnalité de post-création dans une application de blog, chaque fois que nous exécutons les tests, les tables stockant les données pertinentes sur les publications (par exemple, la table Post, la table Comment) doivent être restaurées à un état fixe.

Voici le simple exemple de test de fixtures

<?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));
    }
}
?>

Ce PHP Ce test unitaire a des fonctions portant les noms setUp et tearDown qu’avant d’exécuter votre test, vous configurez vos données et, une fois terminé, vous pourrez les restaurer à l’état initial. .

9
Ebrahim Poursadeqi

Exactement à ce sujet, JUnit a un doc bien expliqué. Ici est le lien!

La partie liée de l'article est:

Les tests doivent être exécutés sur l'arrière-plan d'un ensemble d'objets connu. Cet ensemble d'objets s'appelle un appareil de test. Lorsque vous écrivez des tests, vous constaterez souvent que vous passez plus de temps à écrire le code pour configurer le projecteur que vous ne le faites réellement dans les valeurs testées.

Dans une certaine mesure, vous pouvez faciliter l'écriture du code de fixture en accordant une attention particulière aux constructeurs que vous écrivez. Cependant, le partage du code de fixture représente une économie bien plus importante. Souvent, vous pourrez utiliser le même appareil pour plusieurs tests différents. Chaque cas enverra des messages ou des paramètres légèrement différents à l'appareil et vérifiera les résultats.

Lorsque vous avez un appareil commun, voici ce que vous faites:

Ajouter un champ pour chaque partie de la fixture Annoter une méthode avec @ org.junit.Before et initialiser les variables dans cette méthode Annoter une méthode avec @ org.junit.After pour libérer les ressources permanentes que vous avez allouées dans setUp Par exemple, pour écrire Plusieurs cas de test qui veulent travailler avec différentes combinaisons de 12 francs suisses, 14 francs suisses et 28 dollars US, créent d'abord un montage:

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");
    }
}
3
Reizz

Dans Xamarin.UITest, il est expliqué comme suit:

En général, chaque Xamarin.UITest est écrit comme une méthode appelée test. La classe qui contient le test est appelée un appareil de test. Le dispositif de test contient un seul test ou un groupe logique de tests et est responsable de toute configuration permettant d'exécuter le test et de tout nettoyage à effectuer à la fin du test. Chaque test doit suivre le modèle Arrange-Act-Assert:

  • Arranger - Le test définira les conditions et initialisera les objets afin que le test puisse être exécuté.
  • Act - Le test va interagir avec l'application, saisir du texte, appuyer sur des boutons, etc.
  • Assert - Le test examine les résultats des actions effectuées dans l'étape Act pour déterminer l'exactitude. Par exemple, l'application peut vérifier qu'un message d'erreur particulier est affiché.

Lien pour l'article original de l'extrait ci-dessus

Et dans le code Xamarin.UITest, il ressemble à ceci:

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.");
        }
    }
}

J'espère que cela pourrait être utile à quelqu'un qui est à la recherche d'une meilleure compréhension de Fixtures in Programming.

2
Randika Vishman