`test` — Paket med regressionstester för Python¶

Anteckning

Paketet test är endast avsett för internt bruk av Python. Det är dokumenterat till förmån för Pythons kärnutvecklare. All användning av detta paket utanför Pythons standardbibliotek avråds eftersom koden som nämns här kan ändras eller tas bort utan förvarning mellan utgåvor av Python.

Paketet test innehåller alla regressionstester för Python samt modulerna test.support och test.regrtest. test.support används för att förbättra dina tester medan test.regrtest driver testsviten.

Varje modul i paketet test vars namn börjar med test_ är en testsvit för en specifik modul eller funktion. Alla nya tester bör skrivas med hjälp av modulen unittest eller doctest. Vissa äldre tester är skrivna med en ”traditionell” teststil som jämför utdata som skrivs ut till sys.stdout; denna teststil anses vara föråldrad.

Se även

Modul unittest: Skriva PyUnit regressionstester.
Modul doctest: Tester inbäddade i dokumentationssträngar.

Skriva enhetstester för `test`-paketet¶

Det är önskvärt att tester som använder modulen unittest följer några riktlinjer. En är att namnge testmodulen genom att börja den med test_ och avsluta den med namnet på den modul som testas. Testmetoderna i testmodulen bör börja med test_ och sluta med en beskrivning av vad metoden testar. Detta behövs för att testdrivrutinen ska känna igen metoderna som testmetoder. Dessutom bör ingen dokumentationssträng för metoden inkluderas. En kommentar (t.ex. # Testfunktionen returnerar endast True eller False) bör användas för att tillhandahålla dokumentation för testmetoder. Detta görs för att dokumentationssträngar skrivs ut om de finns och därmed anges inte vilket test som körs.

En grundläggande boilerplate används ofta:

import unittest
from test import support

class MyTestCase1(unittest.TestCase):

    # Only use setUp() and tearDown() if necessary

    def setUp(self):
        ... code to execute in preparation for tests ...

    def tearDown(self):
        ... code to execute to clean up after tests ...

    def test_feature_one(self):
        # Test feature one.
        ... testing code ...

    def test_feature_two(self):
        # Test feature two.
        ... testing code ...

    ... more test methods ...

class MyTestCase2(unittest.TestCase):
    ... same structure as MyTestCase1 ...

... more test classes ...

if __name__ == '__main__':
    unittest.main()

Detta kodmönster gör att testsviten kan köras av test.regrtest, på egen hand som ett skript som stöder unittest CLI, eller via python -m unittest CLI.

Målet med regressionstestning är att försöka knäcka koden. Detta leder till några riktlinjer som ska följas:

Testsviten bör omfatta alla klasser, funktioner och konstanter. Detta inkluderar inte bara det externa API som ska presenteras för omvärlden utan även ”privat” kod.
Whitebox-testning (undersökning av den kod som testas när testerna skrivs) är att föredra. Blackbox-testning (testning av endast det publicerade användargränssnittet) är inte tillräckligt komplett för att säkerställa att alla gräns- och kantfall testas.
Se till att alla möjliga värden testas, inklusive ogiltiga värden. På så sätt säkerställs inte bara att alla giltiga värden accepteras utan också att felaktiga värden hanteras korrekt.
Utnyttja så många kodvägar som möjligt. Testa var förgreningar förekommer och anpassa därmed indata för att se till att så många olika vägar genom koden som möjligt tas.
Lägg till ett uttryckligt test för eventuella buggar som upptäcks i den testade koden. Detta kommer att säkerställa att felet inte dyker upp igen om koden ändras i framtiden.
Se till att städa upp efter dina tester (t.ex. genom att stänga och ta bort alla temporära filer).
Om ett test är beroende av ett specifikt tillstånd i operativsystemet ska du kontrollera att tillståndet redan finns innan du utför testet.
Importera så få moduler som möjligt och gör det så snart som möjligt. Detta minimerar externa beroenden för tester och minimerar också eventuella avvikande beteenden från bieffekter av att importera en modul.
Försök att maximera återanvändning av kod. Ibland kommer testerna att variera genom något så litet som vilken typ av indata som används. Minimera kodduplicering genom att underklassa en grundläggande testklass med en klass som specificerar indata:
```
class TestFuncAcceptsSequencesMixin:

    func = mySuperWhammyFunction

    def test_func(self):
        self.func(self.arg)

class AcceptLists(TestFuncAcceptsSequencesMixin, unittest.TestCase):
    arg = [1, 2, 3]

class AcceptStrings(TestFuncAcceptsSequencesMixin, unittest.TestCase):
    arg = 'abc'

class AcceptTuples(TestFuncAcceptsSequencesMixin, unittest.TestCase):
    arg = (1, 2, 3)
```
När du använder det här mönstret ska du komma ihåg att alla klasser som ärver från unittest.TestCase körs som tester. Klassen TestFuncAcceptsSequencesMixin i exemplet ovan har ingen data och kan därför inte köras själv, och den ärver därför inte från unittest.TestCase.

Se även

Testdriven utveckling: En bok av Kent Beck om att skriva tester före kod.

Utföra tester med hjälp av kommandoradsgränssnittet¶

Paketet test kan köras som ett skript för att driva Pythons regressionstestsvit, tack vare alternativet -m: python -m test. Under huven använder det test.regrtest; anropet python -m test.regrtest som användes i tidigare Python-versioner fungerar fortfarande. Om du kör skriptet själv börjar du automatiskt köra alla regressionstester i paketet test. Detta görs genom att hitta alla moduler i paketet vars namn börjar med test_, importera dem och köra funktionen test_main() om den finns eller ladda testerna via unittest.TestLoader.loadTestsFromModule om test_main inte finns. Namnen på de tester som ska köras kan också skickas till skriptet. Om du anger ett enda regressionstest (python -m test test_spam) minimeras utdata och det skrivs bara ut om testet godkändes eller misslyckades.

Om du kör test direkt kan du ställa in vilka resurser som ska vara tillgängliga för tester. Detta görs genom att använda kommandoradsalternativet -u. Om du anger all som värde för alternativet -u aktiveras alla möjliga resurser: python -m test -uall. Om alla resurser utom en önskas (ett vanligare fall) kan en kommaseparerad lista med resurser som inte önskas anges efter all. Kommandot python -m test -uall,-audio,-largefile kommer att köra test med alla resurser utom resurserna audio och largefile. För en lista över alla resurser och fler kommandoradsalternativ, kör python -m test -h.

Några andra sätt att köra regressionstesterna beror på vilken plattform testerna körs på. På Unix kan du köra make test i den katalog på högsta nivån där Python byggdes. På Windows kan du köra alla regressionstester genom att köra rt.bat från din PCbuild-katalog.

Tillagd i version 3.14: Utdata är färgade som standard och kan kontrolleras med hjälp av miljövariabler.

`test.support` — Verktyg för Python-testsviten¶

Modulen test.support ger stöd för Pythons regressionstestsvit.

Anteckning

test.support är inte en publik modul. Den är dokumenterad här för att hjälpa Python-utvecklare att skriva tester. API:et för denna modul kan komma att ändras utan hänsyn till bakåtkompatibilitet mellan utgåvor.

Denna modul definierar följande undantag:

exception test.support.TestFailed¶: Undantag som ska tas upp när ett test misslyckas. Detta är föråldrat till förmån för unittest -baserade tester och unittest.TestCase s assertion-metoder.

exception test.support.ResourceDenied¶: Underklass till unittest.SkipTest. Utlöses när en resurs (t.ex. en nätverksanslutning) inte är tillgänglig. Utlöses av funktionen requires().

Modulen test.support definierar följande konstanter:

test.support.verbose¶: True när verbose-utdata är aktiverat. Bör markeras när mer detaljerad information önskas om ett test som körs. verbose ställs in av test.regrtest.

test.support.is_jython¶: True om den körande tolken är Jython.

test.support.is_android¶: True om sys.platform är android.

test.support.is_emscripten¶: True om sys.platform är emscripten.

test.support.is_wasi¶: True om sys.platform är wasi.

test.support.is_apple_mobile¶: True om sys.platform är ios, tvos eller watchos.

test.support.is_apple¶: True om sys.platform är darwin eller is_apple_mobile är True.

test.support.unix_shell¶: Sökväg till skalet om det inte finns på Windows; annars None.

test.support.LOOPBACK_TIMEOUT¶

Timeout i sekunder för tester som använder en nätverksserver som lyssnar på nätverkets lokala loopback-gränssnitt, t.ex. 127.0.0.1.

Timeouten är tillräckligt lång för att förhindra att testet misslyckas: den tar hänsyn till att klienten och servern kan köras i olika trådar eller till och med olika processer.

Timeouten ska vara tillräckligt lång för metoderna connect(), recv() och send() i socket.socket.

Dess standardvärde är 5 sekunder.

Se även INTERNET_TIMEOUT.

test.support.INTERNET_TIMEOUT¶

Timeout i sekunder för nätverksförfrågningar som går till internet.

Timeouten är tillräckligt kort för att förhindra att ett test får vänta för länge om internetbegäran blockeras av någon anledning.

Vanligtvis bör en timeout som använder INTERNET_TIMEOUT inte markera ett test som misslyckat, utan hoppa över testet istället: se transient_internet().

Dess standardvärde är 1 minut.

Se även LOOPBACK_TIMEOUT.

test.support.SHORT_TIMEOUT¶

Timeout i sekunder för att markera ett test som misslyckat om testet tar ”för lång tid”.

Timeout-värdet beror på regrtests kommandoradsalternativ --timeout.

Om ett test som använder SHORT_TIMEOUT börjar misslyckas slumpmässigt på långsamma byggrobotar, använd LONG_TIMEOUT istället.

Dess standardvärde är 30 sekunder.

test.support.LONG_TIMEOUT¶

Timeout i sekunder för att upptäcka när ett test hänger sig.

Den är tillräckligt lång för att minska risken för att testet misslyckas på de långsammaste Python-byggrobotarna. Det ska inte användas för att markera ett test som misslyckat om testet tar ”för lång tid”. Timeout-värdet beror på regrtests kommandoradsalternativ --timeout.

Dess standardvärde är 5 minuter.

Se även LOOPBACK_TIMEOUT, INTERNET_TIMEOUT och SHORT_TIMEOUT.

test.support.PGO¶: Ställ in när tester kan hoppas över när de inte är användbara för PGO.

test.support.PIPE_MAX_SIZE¶: En konstant som sannolikt är större än den underliggande OS-pipebuffertstorleken, för att göra skrivningar blockerande.

test.support.Py_DEBUG¶: True om Python byggdes med makrot Py_DEBUG definierat, det vill säga om Python byggdes i felsökningsläge.

Tillagd i version 3.12.

test.support.SOCK_MAX_SIZE¶: En konstant som sannolikt är större än den underliggande OS-socketbuffertstorleken, för att göra skrivningar blockerande.

test.support.TEST_SUPPORT_DIR¶: Ställs in till den katalog på högsta nivån som innehåller test.support.

test.support.TEST_HOME_DIR¶: Ställs in till den översta katalogen för testpaketet.

test.support.TEST_DATA_DIR¶: Sätts till katalogen data inom testpaketet.

test.support.MAX_Py_ssize_t¶: Sätts till sys.maxsize för stora minnestester.

test.support.max_memuse¶: Ställs in av set_memlimit() som minnesgräns för stora minnestester. Begränsas av MAX_Py_ssize_t.

test.support.real_max_memuse¶: Ställs in av set_memlimit() som minnesgräns för stora minnestester. Begränsas inte av MAX_Py_ssize_t.

test.support.MISSING_C_DOCSTRINGS¶

Ställs in till True om Python byggs utan docstrings (makrot WITH_DOC_STRINGS är inte definierat). Se alternativet configure --without-doc-strings.

Se även variabeln HAVE_DOCSTRINGS.

test.support.HAVE_DOCSTRINGS¶

Ställs in till True om funktionsdokumentrar finns tillgängliga. Se alternativet python -OO, som tar bort dokumentsträngar för funktioner som implementerats i Python.

Se även variabeln MISSING_C_DOCSTRINGS.

test.support.TEST_HTTP_URL¶: Definiera URL:en till en dedikerad HTTP-server för nätverkstesterna.

test.support.ALWAYS_EQ¶: Objekt som är lika med vad som helst. Används för att testa jämförelse av blandad typ.

test.support.NEVER_EQ¶: Objekt som inte är lika med något (inte ens med ALWAYS_EQ). Används för att testa jämförelse av blandade typer.

test.support.LARGEST¶: Objekt som är större än något annat (utom sig självt). Används för att testa jämförelse av blandade typer.

test.support.SMALLEST¶: Objekt som är mindre än något annat (utom sig självt). Används för att testa jämförelse av blandade typer.

Modulen test.support definierar följande funktioner:

test.support.busy_retry(timeout, err_msg=None, /, *, error=True)¶

Kör slingkroppen tills break stoppar slingan.

Efter timeout sekunder, skapa ett AssertionError om error är sant, eller bara stoppa slingan om error är falskt.

Exempel:

for _ in support.busy_retry(support.SHORT_TIMEOUT):
    if check():
        break

Exempel på användning av error=False:

for _ in support.busy_retry(support.SHORT_TIMEOUT, error=False):
    if check():
        break
else:
    raise RuntimeError('my custom error')

test.support.sleeping_retry(timeout, err_msg=None, /, *, init_delay=0.010, max_delay=1.0, error=True)¶

Vänta-strategi som tillämpar exponentiell backoff.

Kör slingan tills break stoppar slingan. Sömn vid varje loop-iteration, men inte vid den första iterationen. Sömnfördröjningen fördubblas vid varje iteration (upp till max_delay sekunder).

Se dokumentation för busy_retry() för parametrarnas användning.

Exempel på undantag efter SHORT_TIMEOUT sekunder:

for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
    if check():
        break

Exempel på användning av error=False:

for _ in support.sleeping_retry(support.SHORT_TIMEOUT, error=False):
    if check():
        break
else:
    raise RuntimeError('my custom error')

test.support.is_resource_enabled(resource)¶: Returnerar True om resource är aktiverad och tillgänglig. Listan över tillgängliga resurser anges endast när test.regrtest kör testerna.

test.support.python_is_optimized()¶: Returnerar True om Python inte byggdes med -O0 eller -Og.

test.support.with_pymalloc()¶: Returnerar _testcapi.WITH_PYMALLOC.

test.support.requires(resource, msg=None)¶: Utlös ResourceDenied om resurs inte är tillgänglig. msg är argumentet till ResourceDenied om det aktiveras. Returnerar alltid True om den anropas av en funktion vars __name__ är '__main__'. Används när tester exekveras av test.regrtest.

test.support.sortdict(dict)¶: Returnerar en repr av dict med nycklar sorterade.

test.support.findfile(filename, subdir=None)¶

Returnerar sökvägen till filen med namnet filnamn. Om ingen matchning hittas returneras filnamn. Detta är inte detsamma som ett misslyckande eftersom det kan vara sökvägen till filen.

Om du anger subdir anges en relativ sökväg som ska användas för att hitta filen i stället för att leta direkt i sökvägskatalogerna.

test.support.get_pagesize()¶: Hämta storleken på en sida i byte.

Tillagd i version 3.12.

test.support.setswitchinterval(interval)¶: Ställ in sys.setswitchinterval() till det angivna intervallet. Definierar ett minimiintervall för Android-system för att förhindra att systemet hänger sig.

test.support.check_impl_detail(**guards)¶

Använd denna kontroll för att skydda CPythons implementationsspecifika tester eller för att endast köra dem på de implementationer som skyddas av argumenten. Denna funktion returnerar True eller False beroende på värdplattformen. Exempel på användning:

check_impl_detail()               # Only on CPython (default).
check_impl_detail(jython=True)    # Only on Jython.
check_impl_detail(cpython=False)  # Everywhere except CPython.

test.support.set_memlimit(limit)¶: Ställ in värdena för max_memuse och real_max_memuse för stora minnestester.

test.support.record_original_stdout(stdout)¶: Lagra värdet från stdout. Det är tänkt att hålla stdout vid den tidpunkt då regrtestet började.

test.support.get_original_stdout()¶: Returnerar den ursprungliga stdout som ställdes in av record_original_stdout() eller sys.stdout om den inte är inställd.

test.support.args_from_interpreter_flags()¶: Returnerar en lista med kommandoradsargument som återger de aktuella inställningarna i sys.flags och sys.warnoptions.

test.support.optim_args_from_interpreter_flags()¶: Returnerar en lista med kommandoradsargument som återger de aktuella optimeringsinställningarna i sys.flags.

test.support.captured_stdin()¶

test.support.captured_stdout()¶

test.support.captured_stderr()¶

En kontexthanterare som tillfälligt ersätter den angivna strömmen med io.StringIO-objekt.

Exempel på användning med utdataströmmar:

with captured_stdout() as stdout, captured_stderr() as stderr:
    print("hello")
    print("error", file=sys.stderr)
assert stdout.getvalue() == "hello\n"
assert stderr.getvalue() == "error\n"

Exempel på användning med inmatningsström:

with captured_stdin() as stdin:
    stdin.write('hello\n')
    stdin.seek(0)
    # call test code that consumes from sys.stdin
    captured = input()
self.assertEqual(captured, "hello")

test.support.disable_faulthandler()¶: En kontexthanterare som tillfälligt inaktiverar faulthandler.

test.support.gc_collect()¶: Tvinga så många objekt som möjligt att samlas in. Detta behövs eftersom skräpsamlaren inte kan garantera att deallokering sker i rätt tid. Detta innebär att __del__-metoder kan anropas senare än förväntat och att weakrefs kan leva kvar längre än förväntat.

test.support.disable_gc()¶: En kontexthanterare som inaktiverar skräpsamlaren vid inmatning. Vid avslut återställs skräpsamlaren till sitt tidigare tillstånd.

test.support.swap_attr(obj, attr, new_val)¶

Kontexthanterare för att byta ut ett attribut mot ett nytt objekt.

Användning:

with swap_attr(obj, "attr", 5):
    ...

Detta kommer att sätta obj.attr till 5 under hela with-blocket och återställa det gamla värdet i slutet av blocket. Om attr inte finns på obj kommer den att skapas och sedan tas bort i slutet av blocket.

Det gamla värdet (eller None om det inte finns) kommer att tilldelas målet för ”as”-klausulen, om det finns ett sådant.

test.support.swap_item(obj, attr, new_val)¶

Context manager för att byta ut ett objekt mot ett nytt.

Användning:

with swap_item(obj, "item", 5):
    ...

Detta kommer att sätta obj["item"] till 5 under hela with-blocket, och återställa det gamla värdet i slutet av blocket. Om item inte finns på obj, kommer det att skapas och sedan raderas i slutet av blocket.

Det gamla värdet (eller None om det inte finns) kommer att tilldelas målet för ”as”-klausulen, om det finns ett sådant.

test.support.flush_std_streams()¶: Anropa metoden flush() på sys.stdout och sedan på sys.stderr. Den kan användas för att se till att loggarnas ordning är konsekvent innan de skrivs till stderr.

Tillagd i version 3.11.

test.support.print_warning(msg)¶: Skriv ut en varning i sys.__stderr__. Formatera meddelandet som: f"Varning -- {msg}". Om msg består av flera rader, lägg till prefixet "Warning --" på varje rad.

Tillagd i version 3.9.

test.support.wait_process(pid, *, exitcode, timeout=None)¶

Vänta tills process pid har avslutats och kontrollera att processens exitkod är exitcode.

Utlöser ett AssertionError om processens utgångskod inte är lika med exitcode.

Om processen pågår längre än timeout sekunder (SHORT_TIMEOUT som standard), dödas processen och ett AssertionError visas. Timeout-funktionen är inte tillgänglig i Windows.

Tillagd i version 3.9.

test.support.calcobjsize(fmt)¶: Returnerar storleken på PyObject vars strukturmedlemmar definieras av fmt. Det returnerade värdet inkluderar storleken på Python-objektets rubrik och justering.

test.support.calcvobjsize(fmt)¶: Returnerar storleken på PyVarObject vars strukturmedlemmar definieras av fmt. Det returnerade värdet inkluderar storleken på Python-objektets rubrik och justering.

test.support.checksizeof(test, o, size)¶: För testfall test, hävda att sys.getsizeof för o plus GC-huvudstorleken är lika med size.

@test.support.anticipate_failure(condition)¶: En dekorator för att villkorligt markera tester med unittest.expectedFailure(). Varje användning av denna dekorator bör ha en associerad kommentar som identifierar den relevanta spårningsfrågan.

test.support.system_must_validate_cert(f)¶: En dekorator som hoppar över det dekorerade testet vid fel i valideringen av TLS-certifieringen.

@test.support.run_with_locale(catstr, *locales)¶: En dekorator för att köra en funktion i en annan locale och återställa den korrekt efter att den är klar. catstr är lokalkategorin som en sträng (t.ex. "LC_ALL"). De locales som skickas kommer att prövas sekventiellt, och den första giltiga locale kommer att användas.

@test.support.run_with_tz(tz)¶: En dekorator för att köra en funktion i en specifik tidszon och återställa den korrekt efter att den har avslutats.

@test.support.requires_freebsd_version(*min_version)¶: Dekorator för minimiversionen när test körs på FreeBSD. Om FreeBSD-versionen är mindre än minimiversionen hoppas testet över.

@test.support.requires_linux_version(*min_version)¶: Dekorator för minimiversionen när test körs på Linux. Om Linux-versionen är mindre än minimiversionen hoppas testet över.

@test.support.requires_mac_version(*min_version)¶: Dekorator för minimiversionen när du kör test på macOS. Om macOS-versionen är mindre än minimiversionen hoppas testet över.

@test.support.requires_gil_enabled¶: Dekorator för att hoppa över tester på den fri-trådade byggnaden. Om GIL är avaktiverad, hoppas testet över.

@test.support.requires_IEEE_754¶: Dekorator för att hoppa över tester på plattformar som inte är IEEE 754.

@test.support.requires_zlib¶: Dekorator för att hoppa över tester om zlib inte finns.

@test.support.requires_gzip¶: Dekorator för att hoppa över tester om gzip inte finns.

@test.support.requires_bz2¶: Dekorator för att hoppa över tester om bz2 inte finns.

@test.support.requires_lzma¶: Dekorator för att hoppa över tester om lzma inte finns.

@test.support.requires_resource(resource)¶: Dekorator för att hoppa över tester om resurs inte är tillgänglig.

@test.support.requires_docstrings¶: Dekorator för att bara köra testet om HAVE_DOCSTRINGS.

@test.support.requires_limited_api¶: Dekorator för att bara köra testet om Limited C API är tillgängligt.

@test.support.cpython_only¶: Dekorator för tester som endast är tillämpliga på CPython.

@test.support.impl_detail(msg=None, **guards)¶: Dekorator för att anropa check_impl_detail() på guards. Om det returnerar False, så används msg som anledning till att hoppa över testet.

@test.support.thread_unsafe(reason=None)¶: Dekorator för att markera tester som tråd-osäkra. Detta test körs alltid i en tråd även när det anropas med --parallel-threads.

@test.support.no_tracing¶: Dekoratör för att tillfälligt stänga av spårning under testets gång.

@test.support.refcount_test¶: Dekorator för tester som involverar referensräkning. Dekoratorn kör inte testet om det inte körs av CPython. Eventuella spårningsfunktioner avaktiveras under testets gång för att förhindra oväntade referensräkningar som orsakas av spårningsfunktionen.

@test.support.bigmemtest(size, memuse, dry_run=True)¶

Dekorator för bigmem-tester.

size är en begärd storlek för testet (i godtyckliga, testtolkade enheter.) memuse är antalet byte per enhet för testet, eller en bra uppskattning av det. Till exempel kan ett test som behöver två bytebuffertar på 4 GiB vardera dekoreras med @bigmemtest(size=_4G, memuse=2).

Argumentet size skickas normalt till den dekorerade testmetoden som ett extra argument. Om dry_run är True kan det värde som skickas till testmetoden vara mindre än det begärda värdet. Om dry_run är False betyder det att testet inte stöder dummykörningar när -M inte har angetts.

@test.support.bigaddrspacetest¶: Dekorator för tester som fyller adressrymden.

test.support.linked_with_musl()¶: Returnerar False om det inte finns några bevis för att tolken kompilerades med musl, annars returneras en versionstrippel, antingen (0, 0, 0) om versionen är okänd, eller den faktiska versionen om den är känd. Avsedd för användning i skip dekoratorer. emscripten och wasi antas vara kompilerade med musl; annars kontrolleras platform.libc_ver.

test.support.check_syntax_error(testcase, statement, errtext='', *, lineno=None, offset=None)¶: Testa för syntaxfel i statement genom att försöka kompilera statement. testcase är unittest-instansen för testet. errtext är det reguljära uttryck som ska matcha strängrepresentationen av det uppkomna SyntaxError. Om lineno inte är None, jämförs med raden för undantaget. Om offset inte är None, jämförs med undantagets offset.

test.support.open_urlresource(url, *args, **kw)¶: Öppna url. Om öppningen misslyckas, utlöses TestFailed.

test.support.reap_children()¶: Använd detta i slutet av test_main närhelst underprocesser startas. Detta hjälper till att säkerställa att inga extra barn (zombies) stannar kvar för att ta resurser och skapa problem när man letar efter refleaks.

test.support.get_attribute(obj, name)¶: Hämtar ett attribut och ger upphov till unittest.SkipTest om AttributeError ges upphov till.

test.support.catch_unraisable_exception()¶

Kontexthanteraren fångar upp ett undantag som inte kan bedömas med hjälp av sys.unraisablehook().

Genom att lagra undantagsvärdet (cm.unraisable.exc_value) skapas en referenscykel. Referenscykeln bryts explicit när kontexthanteraren avslutas.

Om du lagrar objektet (cm.unraisable.object) kan det återuppstå om det är inställt på ett objekt som håller på att slutföras. Om du avslutar kontexthanteraren rensas det lagrade objektet.

Användning:

with support.catch_unraisable_exception() as cm:
    # code creating an "unraisable exception"
    ...

    # check the unraisable exception: use cm.unraisable
    ...

# cm.unraisable attribute no longer exists at this point
# (to break a reference cycle)

Tillagd i version 3.8.

test.support.load_package_tests(pkg_dir, loader, standard_tests, pattern)¶

Generisk implementation av protokollet unittest load_tests för användning i testpaket. pkg_dir är rotkatalogen för paketet; loader, standard_tests och pattern är de argument som förväntas av load_tests. I enkla fall kan testpaketets __init__.py se ut på följande sätt:

import os
from test.support import load_package_tests

def load_tests(*args):
    return load_package_tests(os.path.dirname(__file__), *args)

test.support.detect_api_mismatch(ref_api, other_api, *, ignore=())¶

Returnerar den uppsättning attribut, funktioner eller metoder i ref_api som inte finns i other_api, med undantag för en definierad lista över objekt som ska ignoreras vid denna kontroll och som anges i ignore.

Som standard utelämnas privata attribut som börjar med ”_”, men alla magiska metoder inkluderas, dvs. de som börjar och slutar med ”__”.

Tillagd i version 3.5.

test.support.patch(test_instance, object_to_patch, attr_name, new_value)¶: Åsidosätt object_to_patch.attr_name med new_value. Lägg också till en rensningsprocedur till test_instance för att återställa object_to_patch för attr_name. attr_name ska vara ett giltigt attribut för object_to_patch.

test.support.run_in_subinterp(code)¶: Kör kod i undertolk. Utlös unittest.SkipTest om tracemalloc är aktiverat.

test.support.check_free_after_iterating(test, iter, cls, args=())¶: Försäkra att instanser av cls avallokeras efter iterering.

test.support.missing_compiler_executable(cmd_names=[])¶: Kontrollera om det finns körbara kompilatorer vars namn anges i cmd_names eller alla körbara kompilatorer om cmd_names är tom och returnera den första körbara filen som saknas eller None om ingen saknas.

test.support.check__all__(test_case, module, name_of_module=None, extra=(), not_exported=())¶

Försäkra att variabeln __all__ i modul innehåller alla offentliga namn.

Modulens publika namn (dess API) identifieras automatiskt baserat på om de överensstämmer med konventionen för publika namn och om de definierades i module.

Argumentet name_of_module kan ange (som en sträng eller en tupel därav) vilken eller vilka moduler ett API kan definieras i för att upptäckas som ett offentligt API. Ett fall för detta är när modul importerar en del av sitt offentliga API från andra moduler, eventuellt en C-backend (som csv och dess _csv).

Argumentet extra kan vara en uppsättning namn som annars inte automatiskt skulle identifieras som ”public”, t.ex. objekt utan ett korrekt __module__-attribut. Om det anges kommer det att läggas till de automatiskt upptäckta.

Argumentet not_exported kan vara en uppsättning namn som inte får behandlas som en del av det publika API:et även om deras namn anger något annat.

Exempel på användning:

import bar
import foo
import unittest
from test import support

class MiscTestCase(unittest.TestCase):
    def test__all__(self):
        support.check__all__(self, foo)

class OtherTestCase(unittest.TestCase):
    def test__all__(self):
        extra = {'BAR_CONST', 'FOO_CONST'}
        not_exported = {'baz'}  # Undocumented name.
        # bar imports part of its API from _bar.
        support.check__all__(self, bar, ('bar', '_bar'),
                             extra=extra, not_exported=not_exported)

Tillagd i version 3.6.

test.support.skip_if_broken_multiprocessing_synchronize()¶: Hoppa över tester om modulen multiprocessing.synchronize saknas, om det inte finns någon tillgänglig semaforimplementering eller om skapandet av ett lås ger upphov till ett OSError.

Tillagd i version 3.10.

test.support.check_disallow_instantiation(test_case, tp, *args, **kwds)¶: Påstå att typen tp inte kan instansieras med hjälp av args och kwds.

Tillagd i version 3.10.

test.support.adjust_int_max_str_digits(max_digits)¶: Denna funktion returnerar en kontexthanterare som ändrar den globala inställningen sys.set_int_max_str_digits() under kontextens varaktighet för att möjliggöra exekvering av testkod som behöver en annan gräns för antalet siffror vid konvertering mellan ett heltal och en sträng.

Tillagd i version 3.11.

Modulen test.support definierar följande klasser:

class test.support.SuppressCrashReport¶

En kontexthanterare som används för att försöka förhindra popup-fönster i kraschdialogen vid tester som förväntas krascha en underprocess.

I Windows inaktiveras dialogrutorna för Windows Felrapportering med hjälp av SetErrorMode.

På UNIX används resource.setrlimit() för att sätta resource.RLIMIT_CORE:s mjuka gräns till 0 för att förhindra att coredump-filer skapas.

På båda plattformarna återställs det gamla värdet av __exit__().

class test.support.SaveSignals¶

Klass för att spara och återställa signalhanterare som registrerats av Pythons signalhanterare.

save(self)¶: Spara signalhanterarna till en ordbok som mappar signalnummer till den aktuella signalhanteraren.

restore(self)¶: Ställ in signalnumren från save()-ordlistan till den sparade hanteraren.

class test.support.Matcher¶

matches(self, d, **kwargs)¶: Försök att matcha en enda dict med de angivna argumenten.

match_value(self, k, dv, v)¶: Försök att matcha ett enskilt lagrat värde (dv) med ett medföljande värde (v).

`test.support.socket_helper` — Hjälpmedel för socket-tester¶

Modulen test.support.socket_helper ger stöd för socket-tester.

Tillagd i version 3.9.

test.support.socket_helper.IPV6_ENABLED¶: Sätts till True om IPv6 är aktiverat på denna värd, annars False.

test.support.socket_helper.find_unused_port(family=socket.AF_INET, socktype=socket.SOCK_STREAM)¶

Returnerar en oanvänd port som bör vara lämplig för bindning. Detta uppnås genom att skapa ett tillfälligt uttag med samma familj och typ som parametern sock (standard är AF_INET, SOCK_STREAM) och binda det till den angivna värdadressen (standard är 0.0.0.0) med porten inställd på 0, vilket framkallar en oanvänd efemär port från operativsystemet. Det tillfälliga uttaget stängs och raderas sedan och den tillfälliga porten returneras.

Antingen denna metod eller bind_port() bör användas för alla tester där ett serveruttag måste bindas till en viss port under hela testet. Vilken som ska användas beror på om den anropande koden skapar ett Python-socket, eller om en oanvänd port måste tillhandahållas i en konstruktör eller skickas till ett externt program (t.ex. argumentet -accept till openssl:s s_server-läge). Föredra alltid bind_port() framför find_unused_port() när det är möjligt. Att använda en hårdkodad port avrådes eftersom det kan göra det omöjligt att köra flera instanser av testet samtidigt, vilket är ett problem för buildbots.

test.support.socket_helper.bind_port(sock, host=HOST)¶

Binder uttaget till en ledig port och returnerar portnumret. Förlitar sig på efemära portar för att säkerställa att vi använder en obunden port. Detta är viktigt eftersom många tester kan köras samtidigt, särskilt i en buildbot-miljö. Denna metod ger upphov till ett undantag om sock.family är AF_INET och sock.type är SOCK_STREAM, och uttaget har SO_REUSEADDR eller SO_REUSEPORT inställt på det. Tester bör aldrig ställa in dessa socket-alternativ för TCP/IP-sockets. Det enda fallet för att ställa in dessa alternativ är att testa multicasting via flera UDP-sockets.

Om uttagsalternativet SO_EXCLUSIVEADDRUSE är tillgängligt (t.ex. i Windows) kommer det dessutom att ställas in på uttaget. Detta kommer att förhindra att någon annan binder till vår värd/port under hela testet.

test.support.socket_helper.bind_unix_socket(sock, addr)¶: Binder ett Unix-uttag och ger upphov till unittest.SkipTest om PermissionError ges upphov till.

@test.support.socket_helper.skip_unless_bind_unix_socket¶: En dekorator för att köra tester som kräver en funktionell bind() för Unix-sockets.

test.support.socket_helper.transient_internet(resource_name, *, timeout=30.0, errnos=())¶: En kontexthanterare som utlöser ResourceDenied när olika problem med internetanslutningen manifesterar sig som undantag.

`test.support.script_helper` — Hjälpmedel för Python-testkörning¶

Modulen test.support.script_helper ger stöd för Pythons tester för exekvering av skript.

test.support.script_helper.interpreter_requires_environment()¶

Returnerar True om sys.executable interpreter kräver miljövariabler för att överhuvudtaget kunna köras.

Detta är utformat för att användas med @unittest.skipIf() för att kommentera tester som behöver använda en assert_python*()-funktion för att starta en subinterpreterprocess i isolerat läge (-I) eller inget miljöläge (-E).

En normal build & test stöter inte på den här situationen, men det kan hända när man försöker köra standardbibliotekets testsvit från en tolk som inte har en uppenbar hemvist med Pythons nuvarande logik för att hitta hemvist.

Att ställa in PYTHONHOME är ett sätt att få det mesta av testsuiten att köras i den situationen. PYTHONPATH eller PYTHONUSERSITE är andra vanliga miljövariabler som kan påverka om tolken kan starta eller inte.

test.support.script_helper.run_python_until_end(*args, **env_vars)¶: Ställ in miljön baserat på env_vars för att köra tolken i en underprocess. Värdena kan inkludera __isolated, __cleanenv, __cwd och TERM.

Ändrad i version 3.9: Funktionen tar inte längre bort blanksteg från stderr.

test.support.script_helper.assert_python_ok(*args, **env_vars)¶

Försäkra att körningen av tolken med args och de valfria miljövariablerna env_vars lyckas (rc == 0) och returnera en (returkod, stdout, stderr)-tupel.

Om parametern __cleanenv (endast nyckelord) har angetts används env_vars som en ny miljö.

Python startas i isolerat läge (kommandoradsalternativet -I), utom om parametern __isolated keyword-only är inställd på False.

Ändrad i version 3.9: Funktionen tar inte längre bort blanksteg från stderr.

test.support.script_helper.assert_python_failure(*args, **env_vars)¶

Försäkra att körning av tolken med args och valfria miljövariabler env_vars misslyckas (rc != 0) och returnera en (returkod, stdout, stderr)-tupel.

Se assert_python_ok() för fler alternativ.

Ändrad i version 3.9: Funktionen tar inte längre bort blanksteg från stderr.

test.support.script_helper.spawn_python(*args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, **kw)¶

Kör en Python-subprocess med de angivna argumenten.

kw är extra nyckelord att skicka till subprocess.Popen(). Returnerar ett subprocess.Popen-objekt.

test.support.script_helper.kill_python(p)¶: Kör den angivna subprocess.Popen-processen tills den är klar och returnera stdout.

test.support.script_helper.make_script(script_dir, script_basename, source, omit_suffix=False)¶: Skapa skript som innehåller källa i sökvägen script_dir och script_basnamn. Om omit_suffix är False, lägg till .py till namnet. Returnerar den fullständiga sökvägen till skriptet.

test.support.script_helper.make_zip_script(zip_dir, zip_basename, script_name, name_in_zip=None)¶: Skapa en zip-fil på zip_dir och zip_basnamn med tillägget zip som innehåller filerna i script_name. name_in_zip är arkivnamnet. Returnera en tupel som innehåller (fullständig sökväg, fullständig sökväg till arkivnamnet).

test.support.script_helper.make_pkg(pkg_dir, init_source='')¶: Skapa en katalog med namnet pkg_dir som innehåller en __init__-fil med init_source som innehåll.

test.support.script_helper.make_zip_pkg(zip_dir, zip_basename, pkg_name, script_basename, source, depth=1, compiled=False)¶: Skapa en zip-paketkatalog med sökvägen zip_dir och zip_basnamn som innehåller en tom __init__-fil och en fil script_basnamn som innehåller källan. Om compiled är True kommer båda källfilerna att kompileras och läggas till i zip-paketet. Returnerar en tupel av den fullständiga zip-sökvägen och arkivnamnet för zip-filen.

`test.support.bytecode_helper` — Stödverktyg för att testa korrekt generering av bytekoder¶

Modulen test.support.bytecode_helper ger stöd för att testa och inspektera generering av bytekoder.

Tillagd i version 3.9.

Modulen definierar följande klass:

class test.support.bytecode_helper.BytecodeTestCase(unittest.TestCase)¶: Denna klass har anpassade assertion-metoder för att inspektera bytecode.

BytecodeTestCase.get_disassembly_as_string(co)¶: Returnera demonteringen av co som en sträng.

BytecodeTestCase.assertInBytecode(x, opname, argval=_UNSPECIFIED)¶: Returnerar instr om opname hittas, annars kastar AssertionError.

BytecodeTestCase.assertNotInBytecode(x, opname, argval=_UNSPECIFIED)¶: Kastar AssertionError om opname hittas.

`test.support.threading_helper` — Hjälpmedel för trådning av tester¶

Modulen test.support.threading_helper ger stöd för trådning av tester.

Tillagd i version 3.10.

test.support.threading_helper.join_thread(thread, timeout=None)¶: Gå med i en tråd inom timeout. Skapa ett AssertionError om tråden fortfarande är vid liv efter timeout sekunder.

@test.support.threading_helper.reap_threads¶: Dekorator för att säkerställa att trådarna rensas upp även om testet misslyckas.

test.support.threading_helper.start_threads(threads, unlock=None)¶: Kontexthanterare för att starta threads, vilket är en sekvens av trådar. unlock är en funktion som anropas efter att trådarna har startats, även om ett undantag har uppstått; ett exempel skulle vara threading.Event.set(). start_threads kommer att försöka ansluta de startade trådarna vid avslut.

test.support.threading_helper.threading_cleanup(*original_values)¶: Rensa upp trådar som inte specificerats i original_values. Utformad för att avge en varning om ett test lämnar pågående trådar i bakgrunden.

test.support.threading_helper.threading_setup()¶: Returnerar aktuellt trådantal och kopia av hängande trådar.

test.support.threading_helper.wait_threads_exit(timeout=None)¶: Kontexthanterare som väntar tills alla trådar som skapats i with-satsen avslutas.

test.support.threading_helper.catch_threading_exception()¶

Kontexthanterare som fångar upp threading.Thread undantag med threading.excepthook().

Attribut som anges när ett undantag fångas upp:

exc_type
exc_value
exc_traceback
thread

Se dokumentation för threading.excepthook().

Dessa attribut raderas när kontexthanteraren avslutas.

Användning:

med threading_helper.catch_threading_exception() som cm:
    # kod som skapar en tråd som ger upphov till ett undantag
    ...

    # kontrollera trådundantaget, använd cm-attribut:
    # exc_type, exc_value, exc_traceback, thread
    ...

# exc_type, exc_value, exc_traceback, thread attribut för cm finns inte längre
# existerar vid denna tidpunkt
# (för att undvika referenscykler)

Tillagd i version 3.8.

test.support.threading_helper.run_concurrently(worker_func, nthreads, args=(), kwargs={})¶: Kör arbetsfunktionen samtidigt i flera trådar. Löser ut ett undantag igen om någon tråd löser ut ett, efter att alla trådar har avslutats.

`test.support.os_helper` — Hjälpmedel för os-test¶

Modulen test.support.os_helper ger stöd för os-tester.

Tillagd i version 3.10.

test.support.os_helper.FS_NONASCII¶: Ett icke-ASCII-tecken som kan kodas med os.fsencode().

test.support.os_helper.SAVEDCWD¶: Ställs in på os.getcwd().

test.support.os_helper.TESTFN¶: Ange ett namn som är säkert att använda som namn på en tillfällig fil. Alla temporära filer som skapas ska stängas och avlänkas (tas bort).

test.support.os_helper.TESTFN_NONASCII¶: Sätts till ett filnamn som innehåller tecknet FS_NONASCII, om det finns. Detta garanterar att om filnamnet existerar kan det kodas och avkodas med filsystemets standardkodning. Detta gör att tester som kräver ett icke-ASCII-filnamn enkelt kan hoppas över på plattformar där de inte kan fungera.

test.support.os_helper.TESTFN_UNENCODABLE¶: Sätts till ett filnamn (str-typ) som inte bör kunna kodas av filsystemets kodning i strikt läge. Det kan vara None om det inte är möjligt att generera ett sådant filnamn.

test.support.os_helper.TESTFN_UNDECODABLE¶: Sätts till ett filnamn (bytes-typ) som inte bör kunna avkodas av filsystemets kodning i strikt läge. Det kan vara None om det inte är möjligt att generera ett sådant filnamn.

test.support.os_helper.TESTFN_UNICODE¶: Ange ett icke-ASCII-namn för en temporär fil.

class test.support.os_helper.EnvironmentVarGuard¶: Klass som används för att temporärt ställa in eller ta bort miljövariabler. Instanser kan användas som en kontexthanterare och har ett komplett dictionary-gränssnitt för att fråga/ändra den underliggande os.environ. Efter avslut från kontexthanteraren kommer alla ändringar av miljövariabler som gjorts genom denna instans att återställas.

Ändrad i version 3.1: Lagt till gränssnitt för ordbok.

class test.support.os_helper.FakePath(path)¶: Enkelt path-like object. Det implementerar metoden __fspath__() som bara returnerar argumentet path. Om path är ett undantag kommer det att tas upp i __fspath__().

EnvironmentVarGuard.set(envvar, value)¶: Tillfälligt ställa in miljövariabeln envvar till värdet value.

EnvironmentVarGuard.unset(envvar, *others)¶: Tillfälligt avaktivera en eller flera miljövariabler.

Ändrad i version 3.14: Mer än en miljövariabel kan avaktiveras.

test.support.os_helper.can_symlink()¶: Returnerar True om operativsystemet stöder symboliska länkar, annars False.

test.support.os_helper.can_xattr()¶: Returnerar True om operativsystemet stöder xattr, False annars.

test.support.os_helper.change_cwd(path, quiet=False)¶

En kontexthanterare som temporärt ändrar den aktuella arbetskatalogen till path och lämnar ut katalogen.

Om quiet är False, gör kontexthanteraren ett undantag vid fel. I annat fall utfärdas endast en varning och den aktuella arbetskatalogen förblir densamma.

test.support.os_helper.create_empty_file(filename)¶: Skapa en tom fil med filnamn. Om den redan finns, avkorta den.

test.support.os_helper.fd_count()¶: Räkna antalet öppna filbeskrivare.

test.support.os_helper.fs_is_case_insensitive(directory)¶: Returnerar True om filsystemet för katalog är skiftlägesokänsligt.

test.support.os_helper.make_bad_fd()¶: Skapa en ogiltig filbeskrivare genom att öppna och stänga en temporär fil och returnera dess beskrivare.

test.support.os_helper.rmdir(filename)¶: Anropa os.rmdir() på filnamn. På Windows-plattformar är detta omslutet av en vänteslinga som kontrollerar att filen finns, vilket behövs på grund av antivirusprogram som kan hålla filer öppna och förhindra radering.

test.support.os_helper.rmtree(path)¶: Anropa shutil.rmtree() på sökväg eller anropa os.lstat() och os.rmdir() för att ta bort en sökväg och dess innehåll. Precis som med rmdir(), på Windows-plattformar är detta omslutet av en vänteslinga som kontrollerar att filerna finns.

@test.support.os_helper.skip_unless_symlink¶: En dekorator för att köra tester som kräver stöd för symboliska länkar.

@test.support.os_helper.skip_unless_xattr¶: En dekorator för att köra tester som kräver stöd för xattr.

test.support.os_helper.temp_cwd(name='tempcwd', quiet=False)¶

En kontexthanterare som tillfälligt skapar en ny katalog och ändrar den aktuella arbetskatalogen (CWD).

Kontexthanteraren skapar en temporär katalog i den aktuella katalogen med namnet name innan den aktuella arbetskatalogen ändras temporärt. Om namn är None skapas den temporära katalogen med hjälp av tempfile.mkdtemp().

Om quiet är False och det inte är möjligt att skapa eller ändra CWD:n, utlöses ett fel. I annat fall utfärdas endast en varning och den ursprungliga CWD:n används.

test.support.os_helper.temp_dir(path=None, quiet=False)¶

En kontexthanterare som skapar en tillfällig katalog på sökväg och lämnar ut katalogen.

Om path är None skapas den temporära katalogen med tempfile.mkdtemp(). Om quiet är False, gör kontexthanteraren ett undantag vid fel. I annat fall, om path anges och inte kan skapas, utfärdas endast en varning.

test.support.os_helper.temp_umask(umask)¶: En kontexthanterare som temporärt ställer in processens umask.

test.support.os_helper.unlink(filename)¶: Anropa os.unlink() på filename. Precis som med rmdir(), på Windows-plattformar, är detta omslutet av en vänteslinga som kontrollerar om filen finns.

`test.support.import_helper` — Hjälpmedel för importtester¶

Modulen test.support.import_helper ger stöd för importtester.

Tillagd i version 3.10.

test.support.import_helper.forget(module_name)¶: Ta bort modulen med namnet modul_namn från sys.modules och radera alla bytekompilerade filer i modulen.

test.support.import_helper.import_fresh_module(name, fresh=(), blocked=(), deprecated=False)¶

Denna funktion importerar och returnerar en ny kopia av den namngivna Python-modulen genom att ta bort den namngivna modulen från sys.modules innan importen görs. Observera att till skillnad från reload() påverkas inte den ursprungliga modulen av denna operation.

fresh är en iterabel med ytterligare modulnamn som också tas bort från sys.modules cache innan importen görs.

blocked är en iterabel av modulnamn som ersätts med None i modulcachen under importen för att säkerställa att försök att importera dem ger upphov till ImportError.

Den namngivna modulen och alla moduler som namnges i parametrarna fresh och blocked sparas innan importen påbörjas och återinförs sedan i sys.modules när den nya importen är klar.

Meddelanden om modul- och paketdepreciering undertrycks under denna import om deprecated är True.

Denna funktion ger ImportError om den namngivna modulen inte kan importeras.

Exempel på användning:

# Hämta kopior av varningsmodulen för testning utan att påverka den
# version som används av resten av testsviten. En kopia använder
# C-implementeringen, den andra tvingas använda den rena Python-fallbacken
# implementeringen
py_warnings = import_fresh_module('warnings', blocked=['_warnings'])
c_warnings = import_fresh_module('warnings', fresh=['_warnings'])

Tillagd i version 3.1.

test.support.import_helper.import_module(name, deprecated=False, *, required_on=())¶

Denna funktion importerar och returnerar den namngivna modulen. Till skillnad från en vanlig import ger den här funktionen upphov till unittest.SkipTest om modulen inte kan importeras.

Meddelanden om modul- och paketdepreciering undertrycks under denna import om deprecated är True. Om en modul krävs på en plattform men är valfri för andra, ange required_on till en iterabel av plattformsprefix som kommer att jämföras med sys.platform.

Tillagd i version 3.1.

test.support.import_helper.modules_setup()¶: Returnera en kopia av sys.modules.

test.support.import_helper.modules_cleanup(oldmodules)¶: Ta bort moduler med undantag för oldmodules och encodings för att bevara intern cache.

test.support.import_helper.unload(name)¶: Ta bort namn från sys.modules.

test.support.import_helper.make_legacy_pyc(source)¶: Flyttar en PEP 3147/PEP 488 pyc-fil till dess äldre pyc-plats och returnerar filsystemets sökväg till den äldre pyc-filen. Värdet source är filsystemets sökväg till källfilen. Den behöver inte finnas, men PEP 3147/488 pyc-filen måste finnas.

class test.support.import_helper.CleanImport(*module_names)¶

En kontexthanterare som tvingar import att returnera en ny modulreferens. Detta är användbart för att testa beteenden på modulnivå, t.ex. utfärdandet av en DeprecationWarning vid import. Exempel på användning:

with CleanImport('foo'):
    importlib.import_module('foo')  # New reference.

class test.support.import_helper.DirsOnSysPath(*paths)¶

En kontexthanterare för att tillfälligt lägga till kataloger i sys.path.

Detta gör en kopia av sys.path, lägger till alla kataloger som anges som positionsargument och återställer sedan sys.path till de kopierade inställningarna när kontexten avslutas.

Observera att alla sys.path-ändringar i kontexthanterarens kropp, inklusive ersättning av objektet, kommer att återställas i slutet av blocket.

`test.support.warnings_helper` — Hjälpmedel för test av varningar¶

Modulen test.support.warnings_helper ger stöd för varningstest.

Tillagd i version 3.10.

test.support.warnings_helper.ignore_warnings(*, category)¶

Undertrycker varningar som är instanser av category, som måste vara Warning eller en underklass. Ungefär likvärdigt med warnings.catch_warnings() med warnings.simplefilter('ignore', category=category). Till exempel:

@warning_helper.ignore_warnings(category=DeprecationWarning)
def test_suppress_warning():
    # gör något

Tillagd i version 3.8.

test.support.warnings_helper.check_no_resource_warning(testcase)¶: Kontexthanterare för att kontrollera att ingen ResourceWarning har skapats. Du måste ta bort det objekt som kan ge upphov till ResourceWarning innan kontexthanteraren avslutas.

test.support.warnings_helper.check_syntax_warning(testcase, statement, errtext='', *, lineno=1, offset=None)¶: Testa för syntaxvarning i statement genom att försöka kompilera statement. Testa också att SyntaxWarning bara sänds ut en gång och att den konverteras till SyntaxError när den blir ett fel. testcase är unittest-instansen för testet. errtext är det reguljära uttryck som skall matcha strängrepresentationen av den utsända SyntaxWarning och den uppkomna SyntaxError. Om lineno inte är None, jämförs med raden för varningen och undantaget. Om offset inte är None, jämförs med undantagets offset.

Tillagd i version 3.8.

test.support.warnings_helper.check_warnings(*filters, quiet=True)¶

En bekväm omslutning för warnings.catch_warnings() som gör det enklare att testa att en varning har utlösts korrekt. Det motsvarar ungefär att anropa warnings.catch_warnings(record=True) med warnings.simplefilter() satt till always och med alternativet att automatiskt validera de resultat som registreras.

check_warnings accepterar 2-tuples av formen ("message regexp", WarningCategory) som positionella argument. Om ett eller flera filter anges, eller om det valfria nyckelordsargumentet quiet är False, kontrolleras att varningarna är som förväntat: varje angivet filter måste matcha minst en av de varningar som den bifogade koden ger upphov till, annars misslyckas testet, och om några varningar ges upphov till som inte matchar något av de angivna filtren misslyckas testet. För att inaktivera den första av dessa kontroller, sätt quiet till True.

Om inga argument anges är standardvärdet:

check_warnings(("", Varning), quiet=True)

I det här fallet fångas alla varningar upp och inga felmeddelanden skickas ut.

Vid inmatning till kontexthanteraren returneras en WarningRecorder-instans. Den underliggande varningslistan från catch_warnings() är tillgänglig via recorder-objektets attribut warnings. Som en bekvämlighet kan attributen för det objekt som representerar den senaste varningen också nås direkt via recorder-objektet (se exemplet nedan). Om ingen varning har utlösts, kommer alla attribut som annars skulle förväntas på ett objekt som representerar en varning att returnera None.

Recorder-objektet har också en reset()-metod, som rensar varningslistan.

Kontexthanteraren är utformad för att användas på följande sätt:

with check_warnings(("assertion is always true", SyntaxWarning),
                    ("", UserWarning)):
    exec('assert(False, "Hey!")')
    warnings.warn(UserWarning("Hide me!"))

I det här fallet skulle check_warnings() ge upphov till ett fel om någon av varningarna inte gavs, eller om någon annan varning gavs.

När ett test behöver titta djupare på varningarna, snarare än att bara kontrollera om de inträffade eller inte, kan kod som denna användas:

with check_warnings(quiet=True) as w:
    warnings.warn("foo")
    assert str(w.args[0]) == "foo"
    warnings.warn("bar")
    assert str(w.args[0]) == "bar"
    assert str(w.warnings[0].args[0]) == "foo"
    assert str(w.warnings[1].args[0]) == "bar"
    w.reset()
    assert len(w.warnings) == 0

Här kommer alla varningar att fångas upp och testkoden testar de fångade varningarna direkt.

Ändrad i version 3.2: Nya valfria argument filters och quiet.

class test.support.warnings_helper.WarningsRecorder¶: Klass som används för att registrera varningar för enhetstester. Se dokumentation av check_warnings() ovan för mer information.

`test` — Paket med regressionstester för Python¶

Skriva enhetstester för `test`-paketet¶

Utföra tester med hjälp av kommandoradsgränssnittet¶

`test.support` — Verktyg för Python-testsviten¶

`test.support.socket_helper` — Hjälpmedel för socket-tester¶

`test.support.script_helper` — Hjälpmedel för Python-testkörning¶

`test.support.bytecode_helper` — Stödverktyg för att testa korrekt generering av bytekoder¶

`test.support.threading_helper` — Hjälpmedel för trådning av tester¶

`test.support.os_helper` — Hjälpmedel för os-test¶

`test.support.import_helper` — Hjälpmedel för importtester¶

`test.support.warnings_helper` — Hjälpmedel för test av varningar¶

Innehåll

Föregående ämne

Nästa ämne

Denna sidan

test — Paket med regressionstester för Python¶

Skriva enhetstester för test-paketet¶

Utföra tester med hjälp av kommandoradsgränssnittet¶

test.support — Verktyg för Python-testsviten¶

test.support.socket_helper — Hjälpmedel för socket-tester¶

test.support.script_helper — Hjälpmedel för Python-testkörning¶

test.support.bytecode_helper — Stödverktyg för att testa korrekt generering av bytekoder¶

test.support.threading_helper — Hjälpmedel för trådning av tester¶

test.support.os_helper — Hjälpmedel för os-test¶

test.support.import_helper — Hjälpmedel för importtester¶

test.support.warnings_helper — Hjälpmedel för test av varningar¶

`test` — Paket med regressionstester för Python¶

Skriva enhetstester för `test`-paketet¶

`test.support` — Verktyg för Python-testsviten¶

`test.support.socket_helper` — Hjälpmedel för socket-tester¶

`test.support.script_helper` — Hjälpmedel för Python-testkörning¶

`test.support.bytecode_helper` — Stödverktyg för att testa korrekt generering av bytekoder¶

`test.support.threading_helper` — Hjälpmedel för trådning av tester¶

`test.support.os_helper` — Hjälpmedel för os-test¶

`test.support.import_helper` — Hjälpmedel för importtester¶

`test.support.warnings_helper` — Hjälpmedel för test av varningar¶