Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Third-Party Package
This third-party package's source repository does not contain a package manifest. Instead, its package manifest is stored in its release repository. In order to build this package from source in a Catkin workspace, please download its package manifest.Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Third-Party Package
This third-party package's source repository does not contain a package manifest. Instead, its package manifest is stored in its release repository. In order to build this package from source in a Catkin workspace, please download its package manifest.Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file
Wiki Tutorials
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged genty at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 1.3.0 |
License | Apache |
Build type | CATKIN |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/box/genty.git |
VCS Type | git |
VCS Version | v1.3.0 |
Last Updated | 2015-11-06 |
Dev Status | MAINTAINED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- AlexV
Authors
genty
About
Genty, pronounced "gen-tee", stands for "generate tests". It promotes generative testing, where a single test can execute over a variety of input. Genty makes this a breeze.
For example, consider a file sample.py containing both the code under test and the tests:
from genty import genty, genty_repeat, genty_dataset
from unittest import TestCase
# Here's the class under test
class MyClass(object):
def add_one(self, x):
return x + 1
# Here's the test code
@genty
class MyClassTests(TestCase):
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
Running the MyClassTests
using the default unittest runner
$ python -m unittest -v sample
test_add_one(0, 1) (sample.MyClassTests) ... ok
test_add_one(100000, 100001) (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
Instead of having to write multiple independent tests for various test cases, code can be refactored and parametrized using genty!
It produces readable tests. It produces maintainable tests. It produces expressive tests.
Another option is running the same test multiple times. This is useful in stress tests or when exercising code looking for race conditions. This particular test
@genty_repeat(3)
def test_adding_one_to_zero(self):
self.assertEqual(1, MyClass().add_one(0))
would be run 3 times, producing output like
$ python -m unittest -v sample
test_adding_one() iteration_1 (sample.MyClassTests) ... ok
test_adding_one() iteration_2 (sample.MyClassTests) ... ok
test_adding_one() iteration_3 (sample.MyClassTests) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK
The 2 techniques can be combined:
@genty_repeat(2)
@genty_dataset(
(0, 1),
(100000, 100001),
)
def test_add_one(self, value, expected_result):
actual_result = MyClass().add_one(value)
self.assertEqual(expected_result, actual_result)
There are more options to explore including naming your datasets and
genty_args
.
``` python
File truncated at 100 lines see the full file