[PYTHON] J'ai écrit un test unitaire pour différentes langues

Dépôt

Ceux présentés ci-dessous sont disponibles sur Github.

introduction

J'ai décidé d'essayer différentes langues et d'écrire un test unitaire simple à titre d'essai. Je n'expliquerai pas en détail, veuillez donc vous référer à la doc externe pour cela.

Puisque ~~~~ peut être facilement exécuté en utilisant chaque IDE, il n'est pas nécessaire de l'exécuter sur la ligne de commande et il n'est pas décrit. C'est juste un manque de connaissances ~~

Tout fonctionne sur Windown 10 Pro Insider Preview Build 17025.

Python

Environnement d'exécution

Python 3.6.1

Aperçu

En Python, le pack'unittest 'est disponible en standard, alors utilisez-le.

Fichier

Python/
　├ src/
　│　└ sample.py
　├ test/
　│　└ sample_test.py
　└ setup.py

sample.py

sample.py

class Calc:
    def add(self, x, y):
        return x + y

    def pow(self, x, y):
        return x ** y

sample_test.py

sample_test.py

import sys
import unittest

from sample import Calc


class TestSample(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.calc = Calc()

    def test_add(self):
        self.assertEqual(15, self.calc.add(10, 5))
        self.assertEqual(5, self.calc.add(8, -3))

    def test_pow(self):
        self.assertEqual(125, self.calc.pow(5, 3))
        self.assertEqual(sys.maxsize, self.calc.pow(2, 31) - 1)

setup.py

setup.py

from setuptools import setup, find_packages
import sys
import unittest

#Pip installer même pendant le développement-e .Vous pouvez vous référer au module d'exemple à partir de n'importe quel fichier en faisant
#Dans ce cas, le sys suivant.path.ajouter n'est plus nécessaire.
sys.path.append('./src')


def my_test_suite():
    """Sous le répertoire de test,*_test.Reconnaître py comme un module de test"""
    test_loader = unittest.TestLoader()
    test_suite = test_loader.discover('test', pattern='*_test.py')
    return test_suite


setup(
    name="Sample",
    version="1.0",
    #Si src est la racine et correspond à pip, par exemple, définissez comme suit
    package_dir={'': 'src'},
    packages=find_packages('src'),

    test_suite='setup.my_test_suite'
)

Méthode d'exécution

Exécutez python setup.py test depuis le terminal.

Exemple de test avec doctest

sample.py

"""exemple doctest

L'exécution de ce module directement lancera doctest.
S'il y a un échec du test

File "sample.py", line 11, in __main__
Failed example:
    calc.pow(5, 3)
Expected:
    126
Got:
    125
**********************************************************************
1 items had failures:
   1 of   4 in __main__
***Test Failed*** 1 failures.
Est affiché.

>>> calc = Calc()
>>> calc.add(10, 5)
15
>>> calc.add(8, -3)
5
>>> calc.pow(5, 3)
126

"""

class Calc:
    def add(self, x, y):
        return x + y

    def pow(self, x, y):
        return x ** y


if __name__ == "__main__":
    import doctest
    doctest.testmod()

Java

Environnement d'exécution

Java 9 JUnit 5

Aperçu

Java a plusieurs bibliothèques autonomes, mais utilise le célèbre JUnit.

Fichier

Java/
　├ src/
　│　└ Calc.java
　└ test/
   　└ CalcTest.java

Calc.java

Calc.java

public class Calc {
	public int add(int x, int y) {
		return x + y;
	}

	public double pow(int x, int y) {
		return Math.pow(x, y);
	}
}

CalcTest.java

CalcTest.java

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class CalcTest {
	private Calc calc = new Calc();

	@Test
	void add() {
		assertEquals(15, calc.add(10, 5));
		assertEquals(5, calc.add(8, -3));
	}

	@Test
	void pow() {
		assertEquals(125, calc.pow(5, 3));
		assertEquals(Integer.MAX_VALUE, calc.pow(2, 31) - 1);
	}

}

Méthode d'exécution

Puisque JUnit peut être facilement exécuté en utilisant chaque IDE, il n'est pas nécessaire de l'exécuter sur la ligne de commande et il n'est pas décrit.

JavaScript(Node.js)

Environnement d'exécution

NodeJS v8.6.0 npm v5.3.0

Aperçu

Il existe différentes bibliothèques, mais cette fois, nous utiliserons mocha. Nous avons utilisé babel-cli et babel-preset-env pour gérer la syntaxe de la classe.

Fichier

NodeJS/
　├ src/
　│　└ Calc.js
　├ test/
　│　└ calc.spec.js
　└ package.json

Calc.js

Calc.js

class Calc {
	add(x, y) {
		return x + y;
	}

	pow(x, y) {
		return Math.pow(x, y);
	}
}

export default Calc

calc.spec.js

js:calc.spec.js

import Calc from '../src/Calc';

const assert = require('assert');

describe('Calc', () => {
	const calc = new Calc();

	describe('add()', () => {
		assert.equal(15, calc.add(10, 5));
		assert.equal(5, calc.add(8, -3));
	});

	describe('pow', () => {
		assert.equal(125, calc.pow(5, 3));
		assert.equal(0x7FFFFFFF, calc.pow(2, 31) - 1);
	});
});

package.json

package.json

//Omission
　"scripts": {
    "test": "mocha --compilers js:babel-register --recursive $(find test -name '*.spec.js')"
  },
  "devDependencies": {
    "babel-cli": "^6.26.0",
    "babel-preset-env": "^1.6.1",
    "mocha": "^4.0.1"
  },
  "babel": {
    "presets": [
      "env"
    ]
  }

Méthode d'exécution

Exécutez npm test dans le dossier NodeJS.

PHP

Environnement d'exécution

PHP 7.1.0

Aperçu

Il existe différentes bibliothèques, mais cette fois, nous utiliserons PHPUnit.

Fichier

PHP/
　├ src/
　│　├ autoload.php
　│　└ Calc.php
　├ tests/
　│　└ CalcTest.php
　├ composer.json
　└ phpunit.xml

autoload.php

autoload.php

<?php
require_once "Calc.php";

Calc.php

Calc.php

<?php
namespace Sample;

class Calc
{
    public function add($x, $y)
    {
        return $x + $y;
    }

    public function pow($x, $y)
    {
        return $x ** $y;
    }
}

CalcTest.php

CalcTest.php

<?php
namespace Sample;

use PHPUnit\Framework\TestCase;

class CalcTest extends TestCase
{
    public $calc;

    function __construct($name = null, array $data = [], $dataName = '')
    {
        parent::__construct($name, $data, $dataName);
        $this->calc = new Calc();
    }

    public function testAdd()
    {
        $this->assertEquals(15, $this->calc->add(10, 5));
        $this->assertEquals(5, $this->calc->add(8, -3));
    }

    public function testPow()
    {
        $this->assertEquals(125, $this->calc->pow(5, 3));
        $this->assertEquals(0x7FFFFFFF, $this->calc->pow(2, 31) - 1);
    }
}

composer.json

composer.json

{
  //Omission
  "require": {
    "phpunit/phpunit": "6.4.4"
  }
}

phpunit.php

phpunit.php

<phpunit bootstrap="src/autoload.php">
    <testsuites>
        <testsuite name="calc">
            <directory>tests</directory>
        </testsuite>
    </testsuites>
</phpunit>

Méthode d'exécution

Puisque PHPUnit peut être facilement exécuté en utilisant chaque IDE, il n'est pas nécessaire de l'exécuter sur la ligne de commande et il n'est pas décrit.

Go

Environnement d'exécution

Go 1.9.2

Aperçu

Go a un package testing en standard, alors utilisez-le. ~~ Au début, je pensais qu'il n'y avait pas de système d'affirmation, mais j'étais convaincu pour une bonne raison ~~

Fichier

Go/
　└ src/
　 　└ sample/
　 　 　├ calc.go
　 　 　└ calc_test.go

calc.go

calc.go

package sample

import (
	"math"
)

type Calc struct {}

func (calc *Calc) Add(x, y int) int {
	return x + y
}

func (calc *Calc) Pow(x, y float64) float64 {
	return math.Pow(x, y)
}

calc_test.go

calc_test.go

package sample_test

import (
	"testing"
	c "."
)

var calc = c.Calc{}

func TestCalc_Add(t *testing.T) {
	if calc.Add(10, 5) != 15 {
		t.Error("Add Failed");
	}
	if calc.Add(8, -3) != 5 {
		t.Error("Add Failed");
	}
}

func TestCalc_Pow(t *testing.T) {
	if calc.Pow(5, 3) != 125 {
		t.Error("Pow Failed");
	}
	if calc.Pow(2, 31) - 1 != 0x7FFFFFFF {
		t.Error("Pow Failed");
	}
}

Méthode d'exécution

Dans le répertoire Go go test ./src/sample/calc_test.go Exécutez .

finalement

Je voudrais toucher différentes langues, donc je peux l'augmenter (les demandes sont également les bienvenues)