ਪਾਈਥਨ ਇੱਕ ਮਿਆਰੀ doctest ਮੋਡੀਊਲ ਦੇ ਨਾਲ ਆਉਂਦਾ ਹੈ ਜੋ ਇੱਕ docstring ਦੀ ਸਮੱਗਰੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ, docstring ਵਿੱਚ ਇੰਪੁੱਟ ਅਤੇ ਆਉਟਪੁੱਟ ਉਦਾਹਰਨਾਂ ਨੂੰ ਲਿਖਣਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਸਮਝਣ ਵਿੱਚ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।
ਹੇਠਾਂ ਦਿੱਤੀ ਜਾਣਕਾਰੀ ਇੱਥੇ ਦਿੱਤੀ ਗਈ ਹੈ।
- Doctest ਨਾਲ ਟੈਸਟਿੰਗ ਦੀ ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਨ
- ਜੇਕਰ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੈ
- ਜੇਕਰ ਕੋਈ ਗਲਤੀ ਹੈ
- ਵਿਕਲਪਾਂ ਅਤੇ ਦਲੀਲਾਂ ਦੁਆਰਾ ਆਉਟਪੁੱਟ ਨਤੀਜਿਆਂ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰੋ
-vਵਿਕਲਪverboseਆਰਗੂਮੈਂਟ (ਉਦਾਹਰਨ ਲਈ ਫੰਕਸ਼ਨ, ਪ੍ਰੋਗਰਾਮ, ਪ੍ਰੋਗਰਾਮ)
- ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ doctest ਮੋਡੀਊਲ ਚਲਾਓ
- ਇੱਕ ਬਾਹਰੀ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਟੈਸਟ ਲਿਖਣਾ
- ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਕਿਵੇਂ ਲਿਖਣੀ ਹੈ
- py ਫਾਈਲ ਤੋਂ ਕਾਲ ਕੀਤੀ ਗਈ
- ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਸਿੱਧਾ ਚਲਾਓ
Doctest ਨਾਲ ਟੈਸਟਿੰਗ ਦੀ ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਨ
ਇੱਕ ਡੌਕਸਟ੍ਰਿੰਗ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ ਜੋ ਹੇਠਾਂ ਦਿੱਤੇ ਵਿੱਚੋਂ ਇੱਕ ਵਿੱਚ ਬੰਦ ਹੈ: (1) ਟੈਸਟ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਫੰਕਸ਼ਨ ਦਾ ਨਾਮ, (2) ਟੈਸਟ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਫੰਕਸ਼ਨ ਦਾ ਨਾਮ, ਅਤੇ (3) ਪਾਈਥਨ ਇੰਟਰਐਕਟਿਵ ਮੋਡ ਵਿੱਚ ਸੰਭਾਵਿਤ ਆਉਟਪੁੱਟ ਮੁੱਲ।
"""''
ਜੇਕਰ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੈ
ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਕੋਡ ਫੰਕਸ਼ਨ ਅਤੇ docstring ਸਮੱਗਰੀ ਵਿੱਚ ਸਹੀ ਹੈ।
def add(a, b):
'''
>>> add(1, 2)
3
>>> add(5, 10)
15
'''
return a + b
if __name__ == '__main__':
import doctest
doctest.testmod()
ਇਸ ਫਾਈਲ ਨੂੰ ਚਲਾਓ।
$ python3 doctest_example.py
ਜੇਕਰ ਕੋਈ ਤਰੁੱਟੀਆਂ ਨਹੀਂ ਹਨ, ਤਾਂ ਕੁਝ ਵੀ ਆਉਟਪੁੱਟ ਨਹੀਂ ਹੋਵੇਗਾ।
if __name__ == '__main__'ਇਸਦਾ ਅਰਥ ਹੈ “ਉਦੋਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਉਦੋਂ ਹੀ ਲਾਗੂ ਕਰੋ ਜਦੋਂ ਅਨੁਸਾਰੀ ਸਕ੍ਰਿਪਟ ਫਾਈਲ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਚਲਾਈ ਜਾਂਦੀ ਹੈ।
ਜੇਕਰ ਕੋਈ ਗਲਤੀ ਹੈ
ਜੇਕਰ ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਗਲਤ ਕੋਡ ਨੂੰ ਬਣਾਉਂਦੇ ਅਤੇ ਲਾਗੂ ਕਰਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਆਉਟਪੁੱਟ ਹੋਵੇਗੀ।
def add(a, b):
'''
>>> add(1, 2)
3
>>> add(5, 10)
10
'''
return a * b
if __name__ == '__main__':
import doctest
doctest.testmod()
$ python3 doctest_example_error.py
**********************************************************************
File "doctest_example_error.py", line 3, in __main__.add
Failed example:
add(1, 2)
Expected:
3
Got:
2
**********************************************************************
File "doctest_example_error.py", line 5, in __main__.add
Failed example:
add(5, 10)
Expected:
10
Got:
50
**********************************************************************
1 items had failures:
2 of 2 in __main__.add
***Test Failed*** 2 failures.
ਇਹ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਦਿਖਾਇਆ ਗਿਆ ਹੈ.
| doctest ਵਿੱਚ ਲਿਖੇ ਸੰਭਾਵਿਤ ਆਉਟਪੁੱਟ ਮੁੱਲ। | Expected |
| ਅਸਲ ਆਉਟਪੁੱਟ ਮੁੱਲ | Got |
ਵਿਕਲਪਾਂ ਅਤੇ ਦਲੀਲਾਂ ਦੁਆਰਾ ਆਉਟਪੁੱਟ ਨਤੀਜਿਆਂ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰੋ
-vਵਿਕਲਪ
ਜੇਕਰ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਆਉਟਪੁੱਟ ਨਤੀਜੇ ਪ੍ਰਦਰਸ਼ਿਤ ਹੋਣ ਭਾਵੇਂ ਕੋਈ ਗਲਤੀ ਨਾ ਹੋਵੇ, ਕਮਾਂਡ ਲਾਈਨ ‘ਤੇ -v ਵਿਕਲਪ ਨਾਲ ਕਮਾਂਡ ਚਲਾਓ।
$ python3 doctest_example.py -v
Trying:
add(1, 2)
Expecting:
3
ok
Trying:
add(5, 10)
Expecting:
15
ok
1 items had no tests:
__main__
1 items passed all tests:
2 tests in __main__.add
2 tests in 2 items.
2 passed and 0 failed.
Test passed.
verboseਆਰਗੂਮੈਂਟ (ਉਦਾਹਰਨ ਲਈ ਫੰਕਸ਼ਨ, ਪ੍ਰੋਗਰਾਮ, ਪ੍ਰੋਗਰਾਮ)
ਜੇਕਰ ਤੁਸੀਂ ਹਮੇਸ਼ਾ ਆਉਟਪੁੱਟ ਨਤੀਜੇ ਦਿਖਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ py ਫਾਈਲ ਵਿੱਚ ਆਰਗੂਮੈਂਟ verbose=True in doctest.testmod() ਦਿਓ।
if __name__ == '__main__':
import doctest
doctest.testmod(verbose=True)
ਰਨਟਾਈਮ ‘ਤੇ ਆਉਟਪੁੱਟ ਨਤੀਜੇ ਹਮੇਸ਼ਾ -v ਵਿਕਲਪ ਤੋਂ ਬਿਨਾਂ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਣਗੇ।
$ python3 doctest_example_verbose.py
Trying:
add(1, 2)
Expecting:
3
ok
Trying:
add(5, 10)
Expecting:
15
ok
1 items had no tests:
__main__
1 items passed all tests:
2 tests in __main__.add
2 tests in 2 items.
2 passed and 0 failed.
Test passed.
ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ doctest ਮੋਡੀਊਲ ਚਲਾਓ
if __name__ == '__main__'ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਵਿੱਚ ਕੁਝ ਹੋਰ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ py ਫਾਈਲ ਵਿੱਚ doctest.testmod() ਨੂੰ ਕਾਲ ਕੀਤੇ ਬਿਨਾਂ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਸਿੱਧਾ doctest ਮੋਡੀਊਲ ਚਲਾ ਸਕਦੇ ਹੋ।
ਉਦਾਹਰਨ ਲਈ, ਹੇਠਲੇ ਮਾਮਲਿਆਂ ਵਿੱਚ
def add(a, b):
'''
>>> add(1, 2)
3
>>> add(5, 10)
15
'''
return a + b
if __name__ == '__main__':
import sys
result = add(int(sys.argv[1]), int(sys.argv[2]))
print(result)
ਇਹ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਆਮ ਵਾਂਗ ਚਲਾ ਸਕਦਾ ਹੈ।
$ python3 doctest_example_without_import.py 3 4
7
ਜੇਕਰ ਤੁਸੀਂ -m ਵਿਕਲਪ ਦੇ ਨਾਲ ਇੱਕ ਸਕ੍ਰਿਪਟ ਦੇ ਰੂਪ ਵਿੱਚ doctest ਨੂੰ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਟੈਸਟ ਉਸ ਫੰਕਸ਼ਨ ਦੇ ਵਿਰੁੱਧ ਚਲਾਇਆ ਜਾਵੇਗਾ ਜਿਸ ਵਿੱਚ doctest ਲਿਖਿਆ ਗਿਆ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਆਉਟਪੁੱਟ ਨਤੀਜੇ ਦਿਖਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਪਹਿਲਾਂ ਵਾਂਗ -v ਜੋੜੋ।
$ python3 -m doctest doctest_example_without_import.py
$ python3 -m doctest -v doctest_example_without_import.py
Trying:
add(1, 2)
Expecting:
3
ok
Trying:
add(5, 10)
Expecting:
15
ok
1 items had no tests:
doctest_example_without_import
1 items passed all tests:
2 tests in doctest_example_without_import.add
2 tests in 2 items.
2 passed and 0 failed.
Test passed.
ਇੱਕ ਬਾਹਰੀ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਟੈਸਟ ਲਿਖਣਾ
ਤੁਸੀਂ ਡੌਕਸਟ੍ਰਿੰਗ ਦੀ ਬਜਾਏ ਇੱਕ ਬਾਹਰੀ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਟੈਸਟ ਕੋਡ ਵੀ ਲਿਖ ਸਕਦੇ ਹੋ।
ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਕਿਵੇਂ ਲਿਖਣੀ ਹੈ
ਪਾਈਥਨ ਇੰਟਰਐਕਟਿਵ ਮੋਡ ਫਾਰਮੈਟ ਵਿੱਚ ਲਿਖੋ, ਜਿਵੇਂ ਕਿ docstring ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ। ਵਰਤੇ ਜਾਣ ਵਾਲੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਆਯਾਤ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ।
ਜੇਕਰ ਤੁਸੀਂ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਉਸੇ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਸਦੀ .py ਫਾਈਲ ਦੀ ਜਾਂਚ ਕੀਤੀ ਜਾਣੀ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ ਆਯਾਤ ਕਰੋ।
>>> from doctest_example import add
>>> add(1, 2)
3
>>> add(5, 10)
15
py ਫਾਈਲ ਤੋਂ ਕਾਲ ਕੀਤੀ ਗਈ
ਜਾਂਚ ਲਈ ਕਿਸੇ ਹੋਰ .py ਫਾਈਲ ਵਿੱਚ doctest.testfile() ਨੂੰ ਕਾਲ ਕਰੋ।
ਟੈਕਸਟ ਫਾਈਲ ਦਾ ਮਾਰਗ ਨਿਰਧਾਰਤ ਕਰੋ ਜਿੱਥੇ ਟੈਸਟ ਕੋਡ ਨੂੰ doctest.testfile() ਦੀ ਦਲੀਲ ਵਜੋਂ ਲਿਖਿਆ ਗਿਆ ਹੈ।
import doctest
doctest.testfile('doctest_text.txt')
ਇਸ py ਫਾਈਲ ਨੂੰ ਚਲਾਓ।
$ python3 doctest_example_testfile.py -v
Trying:
from doctest_example import add
Expecting nothing
ok
Trying:
add(1, 2)
Expecting:
3
ok
Trying:
add(5, 10)
Expecting:
15
ok
1 items passed all tests:
3 tests in doctest_text.txt
3 tests in 1 items.
3 passed and 0 failed.
Test passed.
ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਸਿੱਧਾ ਚਲਾਓ
ਭਾਵੇਂ ਤੁਹਾਡੇ ਕੋਲ py ਫਾਈਲ ਨਹੀਂ ਹੈ, ਤੁਸੀਂ ਟੈਕਸਟ ਫਾਈਲ ਨੂੰ ਸਿੱਧੇ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਪੜ੍ਹ ਸਕਦੇ ਹੋ ਅਤੇ ਟੈਸਟ ਚਲਾ ਸਕਦੇ ਹੋ।
doctest ਨੂੰ ਸਕ੍ਰਿਪਟ ਦੇ ਤੌਰ ‘ਤੇ ਚਲਾਉਣ ਲਈ -m ਵਿਕਲਪ ਨਾਲ Python ਕਮਾਂਡ ਚਲਾਓ। ਤੁਸੀਂ ਟੈਕਸਟ ਫਾਈਲ ਪਾਥ ਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ਤੇ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।
$ python3 -m doctest -v doctest_text.txt
Trying:
from doctest_example import add
Expecting nothing
ok
Trying:
add(1, 2)
Expecting:
3
ok
Trying:
add(5, 10)
Expecting:
15
ok
1 items passed all tests:
3 tests in doctest_text.txt
3 tests in 1 items.
3 passed and 0 failed.
Test passed.
