tl.testing

tl.testing bied verskeie fasiliteite wat gebruik kan word wanneer die skryf van toetse. & Nbsp; Dit is geskik vir Python weergawes 2.6 en 2.7.
Zandbakken van gidse en lêers
Wanneer die toets-kode wat verander gidse en lêers, is dit nuttig om in staat wees om 'n monster boom van gidse en lêers te maklik te skep en te inspekteer. Die tl.testing.fs module bied ondersteuning vir die skep van 'n boom van 'n tekstuele beskrywing, lys dit in dieselfde formaat en skoon te maak na self.
In 'n doc toets, kan hierdie fasiliteite soos hierdie gebruik word om te skep en 'n lys van 'n gids, 'n lêer en 'n simboliese skakel:
>>> Van tl.testing.fs invoer new_sandbox, ls
>>> New_sandbox ("" ​​"
... D cat
... F cat / bar asdf
... L baz -> cat / bar
... "" ")
>>> Ls ()
l baz -> cat / bar
d cat
f cat / bar asdf
Sien die lêer fs.txt gevind met die bron-kode vir verdere advies, insluitende hoe om te stel en af ​​te breek toetse met behulp van lêer-stelsel zandbakken.
Die installering call able skrifte
Sommige funksies mens kan wil toets maak gebruik van eksterne programme soos 'n pager of 'n teks editor. Die tl.testing.script module bied utilities wat eenvoudige spot skrifte installeer in die plekke waar die kode om getoets te word, sal dit vind. Hulle neem 'n string van Python kode en skep 'n wrapper script wat stel die Python pad wat na die wedstryd van die toets en loop die kode.
Dit is hoe so 'n spot script kan in 'n doc toets gebruik word:
>>> Van tl.testing.script invoer installeer
>>> Script_path = installeer ("druk 'n eenvoudige script '.")
>>> Druk oop (script_path) .read ()
#! ...

invoer sys
sys.path [:] = [...]

Druk 'n eenvoudige script. "
>>> Invoer subprocess
>>> Sub = subprocess.Popen (script_path, dop = True, stdout = subprocess.PIPE)
>>> Stdout, stderr = sub.communicate ()
>>> Druk stdout
'N eenvoudige script.
Sien die lêer script.txt gevind met die bron-kode vir verdere moontlikhede hoe om te installeer en toegang spot skrifte asook hoe om af te breek toetse met behulp van spot skrifte.
Doc-toets van die grafiese inhoud van Kaïro oppervlaktes
Terwyl dit is reguit-vorentoe die inhoud van twee cairo oppervlaktes in Python kode te vergelyk, hantering grafiese is buite doc toetse. Tog kan die Manuel pakket gebruik word om meer algemene toets gevalle van 'n teks dokument te onttrek terwyl hulle hul te meng met doc toetse in 'n natuurlike manier.
Die tl.testing.cairo module bied 'n toets suite fabriek wat gebruik Manuel grafiese toetse geformuleer as herstruktureer teks syfers uit te voer. Die opskrif van so 'n figuur is veronderstel om 'n letterlike Python uitdrukking waarvan die waarde is 'n Kaïro oppervlak te wees, en sy beeld word gebruik as die toets verwagting.
Dit is hoe 'n oppervlak kan vergelyk word met 'n verwagte beeld in 'n doc toets:
>>> Invoer cairo
>>> Van pkg_resources invoer resource_filename
>>> Beeld = resource_filename ('tl.testing', 'testimages / correct.png')
.. Figuur :: tl / toets / testimages / correct.png
& Nbsp; `` cairo.ImageSurface.create_from_png (beeld) ``
Sien die lêer cairo.txt gevind met die bron-kode vir verdere advies en dokumentasie van die moontlike toets uitset.
Werk met drade in die toets-kode
Die standaard toets besluit klas nie foute en mislukkings wat in ander drade as die belangrikste een plaasgevind samel. Die tl.testing.thread module bied draad klasse en 'n ThreadAwareTestCase klas net dat, asook 'n paar ander geriewe vir toetse wat handel oor drade laat: die voorkoming van verwagte unhandled uitsonderings in drade uit om met die toets uitset gedruk, verslagdoening drade agter gelaat deur 'n toets, hardloop kode in 'n daemon draad, by drade en die tel van die drade in die toets se hardloop tyd begin:
>>> Invoer tyd
>>> Invoer tl.testing.thread
>>> Klas SampleTest (tl.testing.thread.ThreadAwareTestCase):
...
... Def test_error_in_thread_should_be_reported (self):
... Met tl.testing.thread.ThreadJoiner (1):
... Self.run_in_thread (lambda: 1/0)
...
... Def test_active_count_should_count_only_new_threads (self):
... Met tl.testing.thread.ThreadJoiner (1):
... Self.run_in_thread (lambda: time.sleep (0.1))
... Self.assertEqual (1, self.active_count ())
... Self.assertEqual (0, self.active_count ())
>>> Invoer unittest
>>> Hardloop (unittest.makeSuite (SampleTest))
================================================== ====================
FOUT: test_error_in_thread_should_be_reported (__builtin __ SampleTest.)
-------------------------------------------------- --------------------
Stapelspoor (mees onlangse oproep laaste):
& Nbsp; ...
ZeroDivisionError: integer afdeling of modulo deur nul
-------------------------------------------------- --------------------
Hardloop 2 toetse in N.NNNs
Misluk (foute = 1)
Sien die lêer thread.txt gevind met die bron-kode vir verdere besonderhede van die ThreadAwareTestCase klas.
Konstruksie toets suites wat gebruik Manuel
As Manuel bied 'n paar kragtige kenmerke in Benewens die standaard doctests, is Manuel toets suites opstel effens anders van standaard kinders. Die tl.testing.doctest module implementeer 'n DocFileSuite fabriek wat soos die standaard een wat gebruik kan word nie, maar skep 'n toets suite met behulp van Manuel en laat 'n paar ekstra opset wat verband hou met Manuel, onder hulle die vermoë voetnote wat gebruik word om te gedoen word met behulp van die deprecated te interpreteer zope.testing.doctest:
>>> Sample_txt = skryf ('sample.txt', "" "
... [#footnote] _
... >>> X
... 1
...
... .. [#footnote]
... >>> X = 1
... "" ")
>>> Van tl.testing.doctest invoer DocFileSuite
>>> Hardloop (DocFileSuite (sample_txt, voetnote = True))
-------------------------------------------------- --------------------
Gehardloop 1 toets in N.NNNs
OK
>>> Sample_txt = skryf ('sample.txt', "" "
... .. Kode-blok :: python
... X = 1
...
... >>> X
... 1
... "" ")
>>> Invoer manuel.codeblock
>>> Hardloop (DocFileSuite (sample_txt, Manuel = manuel.codeblock.Manuel ()))
-------------------------------------------------- --------------------
Gehardloop 1 toets in N.NNNs
OK

Vereistes :

• Python