Ceux présentés ci-dessous sont disponibles sur Github.
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
Python 3.6.1
En Python, le pack'unittest 'est disponible en standard, alors utilisez-le.
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'
)
Exécutez python setup.py test
depuis le terminal.
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
Java 9 JUnit 5
Java a plusieurs bibliothèques autonomes, mais utilise le célèbre JUnit.
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);
}
}
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)
NodeJS v8.6.0 npm v5.3.0
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.
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"
]
}
Exécutez npm test
dans le dossier NodeJS.
PHP
PHP 7.1.0
Il existe différentes bibliothèques, mais cette fois, nous utiliserons PHPUnit.
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>
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
Go 1.9.2
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 ~~
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");
}
}
Dans le répertoire Go go test ./src/sample/calc_test.go Exécutez
.
Je voudrais toucher différentes langues, donc je peux l'augmenter (les demandes sont également les bienvenues)
Recommended Posts