"unittest" --- ユニットテストフレームワーク
*******************************************

**ソースコード:** Lib/unittest/__init__.py

======================================================================

(すでにテストの基本概念について詳しいようでしたら、この部分をとばして
アサートメソッド一覧 に進むと良いでしょう。)

"unittest" ユニットテストフレームワークは元々 JUnit に触発されたもので
、 他の言語の主要なユニットテストフレームワークと同じような感じです。
テストの自動化、テスト用のセットアップやシャットダウンのコードの共有、
テストのコレクション化、そして報告フレームワークからのテストの独立性を
サポートしています。

これを実現するために、 "unittest" はいくつかの重要な概念をオブジェクト
指向の方法でサポートしています:

テストフィクスチャ (test fixture)
   テストフィクスチャ (*test fixture*) とは、テスト実行のために必要な
   準備や終了処理を指します。例: テスト用データベースの作成・ディレク
   トリ・サーバプロセスの起動など。

テストケース (test case)
   テストケース (*test case*) はテストの独立した単位で、各入力に対する
   結果をチェックします。テストケースを作成する場合は、 "unittest" が
   提供する "TestCase" クラスを基底クラスとして利用することができます
   。

テストスイート (test suite)
   テストスイート (*test suite*) はテストケースとテストスイートの集ま
   りで、同時に実行しなければならないテストをまとめる場合に使用します
   。

テストランナー (test runner)
   テストランナー (*test runner*) はテストの実行を管理し結果を提供する
   要素です。ランナーはグラフィカルインターフェースやテキストインター
   フェースを使用しても構いませんし、テストの実行結果を示す特別な値を
   返しても構いません。

参考:

  "doctest" モジュール
     テストをサポートするもうひとつのモジュールで、このモジュールとは
     趣きがだいぶ異なります。

  Simple Smalltalk Testing: With Patterns
     Kent Beck のテスティングフレームワークに関する原論文で、ここに記
     載されたパターンを "unittest" が使用しています。

  >>`<<pytest >>`<<_
     サードパーティのユニットテストフレームワークでより軽量な構文でテ
     ストを書くことができます。例えば、"assert func(10) == 42"  のよう
     に書きます。

  The Python Testing Tools Taxonomy
     多くの Python のテストツールが一覧で紹介されています。ファンクシ
     ョナルテストのフレームワークやモックライブラリも掲載されています
     。

  Testing in Python メーリングリスト
     Python でテストやテストツールについての議論に特化したグループです
     。

  Python のソースコード配布物にあるスクリプト
  "Tools/unittestgui/unittestgui.py" はテストディスカバリとテスト実行
  のための GUI ツールです。 主な目的は単体テストの初心者が簡単に使える
  ようにすることです。 実際の生産環境では、 >>`<<Buildbot >>`<<_ 、
  >>`<<Jenkins >>`<<_ 、 >>`<<Travis-CI >>`<<_, >>`<<AppVeyor >>`<<_
  のような継続的インテグレーションシステムでテストを実行することを推奨
  します。


基本的な例
==========

"unittest" モジュールには、テストの開発や実行の為の優れたツールが用意
されており、この節では、その一部を紹介します。ほとんどのユーザとっては
、ここで紹介するツールだけで十分でしょう。

以下は、三つの文字列メソッドをテストするスクリプトです:

   import unittest

   class TestStringMethods(unittest.TestCase):

       def test_upper(self):
           self.assertEqual('foo'.upper(), 'FOO')

       def test_isupper(self):
           self.assertTrue('FOO'.isupper())
           self.assertFalse('Foo'.isupper())

       def test_split(self):
           s = 'hello world'
           self.assertEqual(s.split(), ['hello', 'world'])
           # check that s.split fails when the separator is not a string
           with self.assertRaises(TypeError):
               s.split(2)

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

テストケースは、 "unittest.TestCase" のサブクラスとして作成します。メ
ソッド名が "test" で始まる三つのメソッドがテストです。テストランナーは
この命名規約によってテストを行うメソッドを検索します。

これらのテスト内では、予定の結果が得られていることを確かめるために
"assertEqual()" を、条件のチェックに "assertTrue()" や "assertFalse()"
を、例外が発生する事を確認するために "assertRaises()" をそれぞれ呼び出
しています。 "assert" 文の代わりにこれらのメソッドを使用すると、テスト
ランナーでテスト結果を集計してレポートを作成する事ができます。

"setUp()" および "tearDown()" メソッドによって各テストメソッドの前後に
実行する命令を実装することが出来ます。 詳細は テストコードの構成 を参
照してください。

最後のブロックは簡単なテストの実行方法を示しています。
"unittest.main()" は、テストスクリプトのコマンドライン用インターフェー
スを提供します。コマンドラインから起動された場合、上記のスクリプトは以
下のような結果を出力します:

   ...
   ----------------------------------------------------------------------
   Ran 3 tests in 0.000s

   OK

"-v" オプションをテストスクリプトに渡すことで "unittest.main()" はより
冗長になり、以下のような出力をします:

   test_isupper (__main__.TestStringMethods) ... ok
   test_split (__main__.TestStringMethods) ... ok
   test_upper (__main__.TestStringMethods) ... ok

   ----------------------------------------------------------------------
   Ran 3 tests in 0.001s

   OK

上の例が "unittest" モジュールで最もよく使われる機能で、ほとんどのテス
トではこれで十分です。以下では全ての機能を一から解説しています。


コマンドラインインターフェイス
==============================

ユニットテストモジュールはコマンドラインから使って、モジュール、クラス
、あるいは個別のテストメソッドで定義されたテストを実行することが出来ま
す:

   python -m unittest test_module1 test_module2
   python -m unittest test_module.TestClass
   python -m unittest test_module.TestClass.test_method

モジュール名ならびに完全修飾されたクラス名やメソッド名の任意の組み合わ
せを一覧で渡すことが出来ます。

テストモジュールはファイルパスで指定することも出来ます:

   python -m unittest tests/test_something.py

そのため、テストモジュールを指定するのにシェルのファイル名補完が使えま
す。指定されたファイルはやはりモジュールとしてインポート可能でなければ
なりません。パスから '.py' を取り除き、パスセパレータを '.' に置き換え
ることでモジュール名に変換されます。モジュールとしてインポート可能でな
いテストファイルを実行したい場合は、代わりにそのファイルを直接実行する
のが良いでしょう。

テスト実行時に (より冗長な) 詳細を表示するには -v フラグを渡します:

   python -m unittest -v test_module

引数無しで実行すると テストディスカバリ が開始されます:

   python -m unittest

コマンドラインプションの一覧を表示するには以下のコマンドを実行します:

   python -m unittest -h

バージョン 3.2 で変更: 以前のバージョンでは、個々のテストメソッドしか
実行することができず、モジュール単位やクラス単位で実行することは不可能
でした。


コマンドラインオプション
------------------------

**unittest** には以下のコマンドラインオプションがあります:

-b, --buffer

   標準出力と標準エラーのストリームをテストの実行中にバッファします。
   テストが成功している間は結果の出力は破棄されます。テストの失敗やエ
   ラーの場合、出力は通常通り表示され、エラーメッセージに追加されます
   。

-c, --catch

   "Control-C" を実行中のテストが終了するまで遅延させ、そこまでの結果
   を出力します。二回目の "Control-C" は、通常通り "KeyboardInterrupt"
   の例外を発生させます。

   この機能の仕組みについては、シグナルハンドリング を参照してください
   。

-f, --failfast

   初回のエラーもしくは失敗の時にテストを停止します。

-k

   Only run test methods and classes that match the pattern or
   substring. This option may be used multiple times, in which case
   all test cases that match of the given patterns are included.

   ワイルドカード("*") を含むパターンは "fnmatch.fnmatchcase()" を使用
   してテスト名と照合され、それ以外の場合は単純な大文字と小文字を区別
   した部分文字列マッチングが使用されます。

   パターンは、テストローダがインポートする時の完全修飾されたテストメ
   ソッド名と照合されます。

   たとえば、 "-k foo" は "foo_tests.SomeTest.test_something",
   "bar_tests.SomeTest.test_foo" にマッチし、
   "bar_tests.FooTest.test_something" はマッチしません。

--locals

   トレースバック内の局所変数を表示します。

バージョン 3.2 で追加: コマンドラインオプションの "-b"、"-c"、"-f" が
追加されました。

バージョン 3.5 で追加: コマンドラインオプション "--locals"。

バージョン 3.7 で追加: コマンドラインオプション "-k"。

コマンドラインによってテストディスカバリ、すなわちプロジェクトの全テス
トを実行したりサブセットのみを実行したりすることも出来ます。


テストディスカバリ
==================

バージョン 3.2 で追加.

unittest はシンプルなテストディスカバリをサポートします。 テストディス
カバリに対応するには、全テストファイルはプロジェクトの最上位のディスカ
バリからインポート可能な モジュール か (*名前空間パッケージ* を含む)
パッケージ でなければなりません (つまりそれらのファイル名は有効な 識別
子 でなければなりません)。

テストディスカバリは "TestLoader.discover()" で実装されていますが、コ
マンドラインから使う事も出来ます。その基本的な使い方は:

   cd project_directory
   python -m unittest discover

注釈:

  "python -m unittest" は "python -m unittest discover" と等価なショー
  トカットです。テストディスカバリに引数を渡したい場合は、"discover"
  サブコマンドを明示的に使用しなければなりません。

"discover" サブコマンドには以下のオプションがあります:

-v, --verbose

   詳細な出力

-s, --start-directory directory

   ディスカバリを開始するディレクトリ (デフォルトは ".")

-p, --pattern pattern

   テストファイル名を識別するパターン (デフォルトは "test*.py")

-t, --top-level-directory directory

   プロジェクトの最上位のディスカバリのディレクトリ (デフォルトは開始
   のディレクトリ)

"-s" 、 "-p" 、および "-t" オプションは、この順番であれば位置引数とし
て渡す事ができます。以下の二つのコマンドは等価です:

   python -m unittest discover -s project_directory -p "*_test.py"
   python -m unittest discover project_directory "*_test.py"

パスと同様にパッケージ名を、例えば "myproject.subpackage.test" のよう
に、開始ディレクトリとして渡すことができます。 指定したパッケージ名は
インポートされ、そのファイルシステム上の場所が開始ディレクトリとして使
われます。

ご用心:

  テストディスカバリはインポートによりテストを読み込みます。 一旦テス
  トディスカバリが指定された開始ディレクトリから全テストファイルを見付
  けると、パスはインポートするパッケージ名に変換されます。 例えば、
  "foo/bar/baz.py" は "foo.bar.baz" としてインポートされます。グローバ
  ルにインストールされたパッケージがあり、それとは異なるコピーでディス
  カバリしようとしたとき、誤った場所からインポートが行われる *かもしれ
  ません*。 その場合テストディスカバリは警告し、停止します。ディレクト
  リのパスではなくパッケージ名を開始ディレクトリに指定した場合、ディス
  カバリはインポートするいずれの場所も意図した場所とするため、警告を受
  けないはずです。

テストモジュールとパッケージは、 load_tests プロトコル によってテスト
のロードとディスカバリをカスタマイズすることができます。

バージョン 3.4 で変更: Test discovery supports *namespace packages*
for start directory. Note that you need to the top level directory
too. (e.g. "python -m unittest discover -s root/namespace -t root").


テストコードの構成
==================

ユニットテストの基本的な構成要素は、 *テストケース* --- 設定され正しさ
のためにチェックされるべき単独のシナリオ --- です。 "unittest" では、
テストケースは "unittest.TestCase" クラスのインスタンスで表現されます
。 独自のテストケースを作成するには "TestCase" のサブクラスを記述する
か、 "FunctionTestCase" を使用しなければなりません。

"TestCase" インスタンスのテストコードは完全に独立していなければなりま
せん。 すなわち単独でか、他の様々なテストケースの任意の組み合わせのい
ずれかで実行可能でなければなりません。

最も単純な "TestCase" のサブクラスは、特定のテストコードを実行するため
のテストメソッド (すなわち名前が "test" で始まるメソッド) を実装するだ
けで簡単に書くことができます:

   import unittest

   class DefaultWidgetSizeTestCase(unittest.TestCase):
       def test_default_widget_size(self):
           widget = Widget('The widget')
           self.assertEqual(widget.size(), (50, 50))

何らかのテストを行うには、 "TestCase" ベースクラスが提供する
"assert*()" メソッドのうちの一つを使用してください。 テストが失敗した
場合は、例外が説明のメッセージとともに送出され、 "unittest" はテスト結
果を *failure* とします。 その他の例外は *error* として扱われます。

テストは多くなり、それらの設定は繰り返しになるかもしれません。 幸いに
も、"setUp()" メソッドを実装することで設定コードをくくり出すことができ
ます。 テストフレームワークは実行するテストごとに自動的に "setUp()" を
呼びます:

   import unittest

   class WidgetTestCase(unittest.TestCase):
       def setUp(self):
           self.widget = Widget('The widget')

       def test_default_widget_size(self):
           self.assertEqual(self.widget.size(), (50,50),
                            'incorrect default size')

       def test_widget_resize(self):
           self.widget.resize(100,150)
           self.assertEqual(self.widget.size(), (100,150),
                            'wrong size after resize')

注釈:

  いろいろなテストが実行される順序は、文字列の組み込みの順序でテストメ
  ソッド名をソートすることで決まります。

テスト中に "setUp()" メソッドで例外が発生した場合、フレームワークはそ
のテストに問題があるとみなし、そのテストメソッドは実行されません。

同様に、テストメソッド実行後に片付けをする "tearDown()" メソッドを提供
出来ます:

   import unittest

   class WidgetTestCase(unittest.TestCase):
       def setUp(self):
           self.widget = Widget('The widget')

       def tearDown(self):
           self.widget.dispose()

"setUp()" が成功した場合、テストメソッドが成功したかどうかに関わらず
"tearDown()" が実行されます。

そのようなテストコードのための作業環境は *テストフィクスチャ (test
fixture)* と呼ばれます。 新しい TestCase インスタンスはある単一のテス
トフィクスチャとして作成され、個々のテストメソッドを実行するのに使われ
ます。 従って、 "setUp()", "tearDown()",, "__init__()" は1回のテストに
つき1回だけ呼び出されます。

テストケースの実装では、テストする機能に従ってテストをまとめるのをお勧
めします。 "unittest" はこのための機構、"unittest" の "TestSuite" クラ
スで表現される *test suite*、を提供します。 たいていの場合
"unittest.main()" を呼び出しは正しい処理を行い、モジュールの全テストケ
ースを集めて実行します。

しかし、テストスイートの構築をカスタマイズしたい場合、自分ですることが
できます:

   def suite():
       suite = unittest.TestSuite()
       suite.addTest(WidgetTestCase('test_default_widget_size'))
       suite.addTest(WidgetTestCase('test_widget_resize'))
       return suite

   if __name__ == '__main__':
       runner = unittest.TextTestRunner()
       runner.run(suite())

テストケースやテストコードの定義を ("widget.py" のような) テスト対象コ
ードと同じモジュールに置くことが出来ますが、テストコードを
("test_widget.py" のような) 独立したモジュールに置くのには以下のような
利点があります:

* テストモジュールだけをコマンドラインから独立に実行することができる。

* テストコードと出荷するコードをより簡単に分ける事ができる。

* 余程のことがない限り、テスト対象のコードに合わせてテストコードを変更
  することになりにくい。

* テストコードは、テスト対象コードほど頻繁に変更されない。

* テストコードをより簡単にリファクタリングすることができる。

* Cで書いたモジュールのテストはどうせ独立したモジュールなのだから、同
  様にしない理由がない

* テストの方策を変更した場合でも、ソースコードを変更する必要がない。


既存テストコードの再利用
========================

既存のテストコードが有るとき、このテストを "unittest" で実行しようとす
るために古いテスト関数をいちいち "TestCase" クラスのサブクラスに変換す
るのは大変です。

このような場合は、 "unittest" では "TestCase" のサブクラスである
"FunctionTestCase" クラスを使い、既存のテスト関数をラップします。初期
設定と終了処理も行なえます。

以下のテストコードがあった場合:

   def testSomething():
       something = makeSomething()
       assert something.name is not None
       # ...

オプションの set-up と tear-down メソッドを持った同等のテストケースイ
ンスタンスは次のように作成します:

   testcase = unittest.FunctionTestCase(testSomething,
                                        setUp=makeSomethingDB,
                                        tearDown=deleteSomethingDB)

注釈:

  "FunctionTestCase" を使って既存のテストを "unittest" ベースのテスト
  体系に変換することができますが、この方法は推奨されません。時間を掛け
  て "TestCase" のサブクラスに書き直した方が将来的なテストのリファクタ
  リングが限りなく易しくなります。

既存のテストが "doctest" を使って書かれている場合もあるでしょう。その
場合、 "doctest" は "DocTestSuite" クラスを提供します。このクラスは、
既存の "doctest"ベースのテストから、自動的に "unittest.TestSuite" のイ
ンスタンスを作成します。


テストのスキップと予期された失敗
================================

バージョン 3.1 で追加.

unittest は特定のテストメソッドやテストクラス全体をスキップする仕組み
を備えています。さらに、この機能はテスト結果を「予期された失敗
(expected failure)」とすることができ、テストが失敗しても "TestResult"
の失敗数にはカウントされなくなります。

テストをスキップするには、 "skip()" デコレータかその条件付きバージョン
の一つを使うか、"setUp()" やテストメソッドの中で "TestCase.skipTest()"
を呼び出すか、あるいは直接 "SkipTest" を送出するだけです。

基本的なスキップは以下のようになります:

   class MyTestCase(unittest.TestCase):

       @unittest.skip("demonstrating skipping")
       def test_nothing(self):
           self.fail("shouldn't happen")

       @unittest.skipIf(mylib.__version__ < (1, 3),
                        "not supported in this library version")
       def test_format(self):
           # Tests that work for only a certain version of the library.
           pass

       @unittest.skipUnless(sys.platform.startswith("win"), "requires Windows")
       def test_windows_support(self):
           # windows specific testing code
           pass

       def test_maybe_skipped(self):
           if not external_resource_available():
               self.skipTest("external resource not available")
           # test code that depends on the external resource
           pass

このサンプルを冗長モードで実行すると以下のように出力されます:

   test_format (__main__.MyTestCase) ... skipped 'not supported in this library version'
   test_nothing (__main__.MyTestCase) ... skipped 'demonstrating skipping'
   test_maybe_skipped (__main__.MyTestCase) ... skipped 'external resource not available'
   test_windows_support (__main__.MyTestCase) ... skipped 'requires Windows'

   ----------------------------------------------------------------------
   Ran 4 tests in 0.005s

   OK (skipped=4)

テストクラスは以下のようにメソッドをスキップすることができます:

   @unittest.skip("showing class skipping")
   class MySkippedTestCase(unittest.TestCase):
       def test_not_run(self):
           pass

"TestCase.setUp()" もスキップすることができます。この機能はセットアッ
プの対象のリソースが使用不可能な時に便利です。

予期された失敗の機能を使用するには "expectedFailure()" デコレータを使
います。

   class ExpectedFailureTestCase(unittest.TestCase):
       @unittest.expectedFailure
       def test_fail(self):
           self.assertEqual(1, 0, "broken")

独自のスキップ用のデコレータの作成は簡単です。 そのためには、独自のデ
コレータのスキップしたい時点で "skip()" を呼び出します。 以下のデコレ
ータはオブジェクトに指定した属性が無い場合にテストをスキップします:

   def skipUnlessHasattr(obj, attr):
       if hasattr(obj, attr):
           return lambda func: func
       return unittest.skip("{!r} doesn't have {!r}".format(obj, attr))

以下のデコレータと例外はテストのスキップと予期された失敗を実装していま
す:

@unittest.skip(reason)

   デコレートしたテストを無条件でスキップします。*reason* にはテストを
   スキップした理由を記載します。

@unittest.skipIf(condition, reason)

   *condition* が真の場合、デコレートしたテストをスキップします。

@unittest.skipUnless(condition, reason)

   *condition* が偽の場合、デコレートしたテストをスキップします。

@unittest.expectedFailure

   Mark the test as an expected failure or error.  If the test fails
   or errors it will be considered a success.  If the test passes, it
   will be considered a failure.

exception unittest.SkipTest(reason)

   この例外はテストをスキップするために送出されます。

   ふつうはこれを直接送出する代わりに "TestCase.skipTest()" やスキッピ
   ングデコレータの一つを使用出来ます。

スキップしたテストの前後では、 "setUp()" および "tearDown()" は実行さ
れません。同様に、スキップしたクラスの前後では、 "setUpClass()" および
"tearDownClass()" は実行されません。スキップしたモジュールの前後では、
"setUpModule()" および "tearDownModule()" は実行されません。


サブテストを利用して繰り返しテストの区別を付ける
================================================

バージョン 3.4 で追加.

テストの間にとても小さな差異がある場合（例えばいくつかのパラメータなど
）、unittestでは "subTest()" コンテキストマネージャを使用してテストメ
ソッドの内部でそれらを区別することができます。

例えば以下のテストは:

   class NumbersTest(unittest.TestCase):

       def test_even(self):
           """
           Test that numbers between 0 and 5 are all even.
           """
           for i in range(0, 6):
               with self.subTest(i=i):
                   self.assertEqual(i % 2, 0)

以下の出力をします:

   ======================================================================
   FAIL: test_even (__main__.NumbersTest) (i=1)
   ----------------------------------------------------------------------
   Traceback (most recent call last):
     File "subtests.py", line 32, in test_even
       self.assertEqual(i % 2, 0)
   AssertionError: 1 != 0

   ======================================================================
   FAIL: test_even (__main__.NumbersTest) (i=3)
   ----------------------------------------------------------------------
   Traceback (most recent call last):
     File "subtests.py", line 32, in test_even
       self.assertEqual(i % 2, 0)
   AssertionError: 1 != 0

   ======================================================================
   FAIL: test_even (__main__.NumbersTest) (i=5)
   ----------------------------------------------------------------------
   Traceback (most recent call last):
     File "subtests.py", line 32, in test_even
       self.assertEqual(i % 2, 0)
   AssertionError: 1 != 0

サブテスト無しの場合、最初の失敗で実行は停止し、"i" の値が表示されない
ためエラーの原因を突き止めるのは困難になります:

   ======================================================================
   FAIL: test_even (__main__.NumbersTest)
   ----------------------------------------------------------------------
   Traceback (most recent call last):
     File "subtests.py", line 32, in test_even
       self.assertEqual(i % 2, 0)
   AssertionError: 1 != 0


クラスと関数
============

この節では、 "unittest" モジュールのAPIの詳細について説明します。


テストクラス
------------

class unittest.TestCase(methodName='runTest')

   "TestCase" クラスのインスタンスは、 "unittest" の世界における論理的
   なテストの単位を示します。このクラスをベースクラスとして使用し、必
   要なテストを具象サブクラスに実装します。 "TestCase" クラスでは、テ
   ストランナーがテストを実行するため のインターフェースと、各種の失敗
   をチェックしレポートするためのメソッドを実装しています。

   "TestCase" の各インスタンスは *methodName* という名前の単一の基底メ
   ソッドを実行します。 "TestCase" を使用する大半の場合 *methodName*
   を変更したりデフォルトの "runTest()" メソッドを再実装することはあり
   ません。

   バージョン 3.2 で変更: "TestCase" が *methodName* を指定しなくても
   インスタンス化できるようになりました。これにより対話的インタプリタ
   から "TestCase" を簡単に試せるようになりました。

   "TestCase" のインスタンスのメソッドは3種類のグループを提供します。
   1つ目のグループはテストの実行で使用されます。 2つ目のグループは条件
   のチェックおよび失敗のレポートを行うテストの実装で使用されます。 3
   つ目のグループである問い合わせ用のメソッドによってテスト自身の情報
   が収集されます。

   はじめのグループ (テスト実行) に含まれるメソッドは以下の通りです:

   setUp()

      テストフィクスチャの準備のために呼び出されるメソッドです。テスト
      メソッドの直前に呼び出されます。このメソッドで "AssertionError"
      や "SkipTest" 以外の例外が発生した場合、テストの失敗ではなくエラ
      ーとされます。デフォルトの実装では何も行いません。

   tearDown()

      テストメソッドが実行され、結果が記録された直後に呼び出されるメソ
      ッドです。 このメソッドはテストメソッドで例外が投げられても呼び
      出されます。 そのため、サブクラスでこのメソッドを実装する場合は
      、内部状態を確認することが必要になるでしょう。 このメソッドで
      "AssertionError" や "SkipTest" 以外の例外が発生した場合、テスト
      の失敗とは別のエラーとみなされます (従って報告されるエラーの総数
      は増えます)。 このメソッドは、テストの結果に関わらず "setUp()"
      が成功した場合にのみ呼ばれます。 デフォルトの実装では何も行いま
      せん。

   setUpClass()

      個別のクラス内のテストが実行される前に呼び出されるクラスメソッド
      です。 "setUpClass" はクラスを唯一の引数として取り、
      "classmethod()" でデコレートされていなければなりません:

         @classmethod
         def setUpClass(cls):
             ...

      詳しくは クラスとモジュールのフィクスチャ を参照してください。

      バージョン 3.2 で追加.

   tearDownClass()

      個別のクラス内のテストが実行された後に呼び出されるクラスメソッド
      です。 "tearDownClass" はクラスを唯一の引数として取り、
      "classmethod()" でデコレーされていなければなりません:

         @classmethod
         def tearDownClass(cls):
             ...

      詳しくは クラスとモジュールのフィクスチャ を参照してください。

      バージョン 3.2 で追加.

   run(result=None)

      テストを実行し、テスト結果を *result* に指定された "TestResult"
      オブジェクトにまとめます。 *result* が省略されるか "None" が渡さ
      れた場合、 ("defaultTestResult()" メソッドを呼んで)  一時的な結
      果オブジェクトを生成し、使用します。 結果オブジェクトは "run()"
      の呼び出し元に返されます。

      このメソッドは、単に "TestCase" インスタンスを呼び出した場合と同
      様に振る舞います。

      バージョン 3.3 で変更: 以前のバージョンの "run" は結果オブジェク
      トを返しませんでした。また "TestCase" インスタンスを呼び出した場
      合も同様でした。

   skipTest(reason)

      テストメソッドや "setUp()" が現在のテストをスキップする間に呼ば
      れます。詳細については、 テストのスキップと予期された失敗 を参照
      してください。

      バージョン 3.1 で追加.

   subTest(msg=None, **params)

      このメソッドを囲っているブロックをサブテストとして実行するコンテ
      キストマネージャを返します。 *msg* と *params* はサブテストが失
      敗したときに表示されるオプションの任意の値で、どんな値が使われた
      かを明確にするものです。

      テストケースには subtest 宣言を幾らでも含めることができ、任意に
      ネストすることができます。

      詳細は サブテストを利用して繰り返しテストの区別を付ける を参照し
      てください。

      バージョン 3.4 で追加.

   debug()

      テスト結果を収集せずにテストを実行します。例外が呼び出し元に通知
      されます。また、テストをデバッガで実行することができます。

   "TestCase" クラスは失敗の検査と報告を行う多くのメソッドを提供してい
   ます。 以下の表は最も一般的に使われるメソッドを列挙しています (より
   多くのアサートメソッドについては表の下を見てください):

   +-------------------------------------------+-------------------------------+-----------------+
   | メソッド                                  | 確認事項                      | 初出            |
   |===========================================|===============================|=================|
   | "assertEqual(a, b)"                       | "a == b"                      |                 |
   +-------------------------------------------+-------------------------------+-----------------+
   | "assertNotEqual(a, b)"                    | "a != b"                      |                 |
   +-------------------------------------------+-------------------------------+-----------------+
   | "assertTrue(x)"                           | "bool(x) is True"             |                 |
   +-------------------------------------------+-------------------------------+-----------------+
   | "assertFalse(x)"                          | "bool(x) is False"            |                 |
   +-------------------------------------------+-------------------------------+-----------------+
   | "assertIs(a, b)"                          | "a is b"                      | 3.1             |
   +-------------------------------------------+-------------------------------+-----------------+
   | "assertIsNot(a, b)"                       | "a is not b"                  | 3.1             |
   +-------------------------------------------+-------------------------------+-----------------+
   | "assertIsNone(x)"                         | "x is None"                   | 3.1             |
   +-------------------------------------------+-------------------------------+-----------------+
   | "assertIsNotNone(x)"                      | "x is not None"               | 3.1             |
   +-------------------------------------------+-------------------------------+-----------------+
   | "assertIn(a, b)"                          | "a in b"                      | 3.1             |
   +-------------------------------------------+-------------------------------+-----------------+
   | "assertNotIn(a, b)"                       | "a not in b"                  | 3.1             |
   +-------------------------------------------+-------------------------------+-----------------+
   | "assertIsInstance(a, b)"                  | "isinstance(a, b)"            | 3.2             |
   +-------------------------------------------+-------------------------------+-----------------+
   | "assertNotIsInstance(a, b)"               | "not isinstance(a, b)"        | 3.2             |
   +-------------------------------------------+-------------------------------+-----------------+

   全てのアサートメソッドは *msg* 引数を受け取り、指定された場合、失敗
   時のエラーメッセージとして使われます。 ("longMessage" も参照してく
   ださい)。 *msg* キーワード引数は "assertRaises()" 、
   "assertRaisesRegex()" 、 "assertWarns()" 、 "assertWarnsRegex()" に
   は、そのメソッドをコンテキストマネージャとして使った場合にのみ使え
   ます。

   assertEqual(first, second, msg=None)

      *first* と *second* が等しいことをテストします。両者が等しくない
      場合、テストは失敗です。

      さらに、 *first* と *second* が厳密に同じ型であり、list、tuple、
      dict、set、frozenset もしくは str のいずれか、またはサブクラスが
      "addTypeEqualityFunc()" に登録されている任意の型の場合、より有用
      なデフォルトのエラーメッセージを生成するために、その型特有の比較
      関数が呼ばれます（型固有のメソッドの一覧 も参照してください）。

      バージョン 3.1 で変更: 自動で型固有の比較関数が呼ばれるようにな
      りました。

      バージョン 3.2 で変更: 文字列比較のデフォルトの比較関数として
      "assertMultiLineEqual()" が追加されました。

   assertNotEqual(first, second, msg=None)

      *first* と *second* が等しくないことをテストします。両者が等しい
      場合、テストは失敗です。

   assertTrue(expr, msg=None)
   assertFalse(expr, msg=None)

      *expr* が真 (偽) であることをテストします。

      このメソッドは、"bool(expr) is True" と等価であり、"expr is
      True" と等価ではないことに注意が必要です (後者のためには、
      "assertIs(expr, True)" が用意されています)。また、専用のメソッド
      が使用できる場合には、そちらを使用してください (例えば
      "assertTrue(a == b)" の代わりに "assertEqual(a, b)" を使用してく
      ださい)。そうすることにより、テスト失敗時のエラーメッセージを詳
      細に表示することができます。

   assertIs(first, second, msg=None)
   assertIsNot(first, second, msg=None)

      *first* と *second* が同じオブジェクトであること (またはそうでな
      いこと) をテストします。

      バージョン 3.1 で追加.

   assertIsNone(expr, msg=None)
   assertIsNotNone(expr, msg=None)

      *expr* が "None" であること (および、そうでないこと) をテストし
      ます。

      バージョン 3.1 で追加.

   assertIn(member, container, msg=None)
   assertNotIn(member, container, msg=None)

      *member* が *container* に含まれること (またはそうでないこと) を
      テストします。

      バージョン 3.1 で追加.

   assertIsInstance(obj, cls, msg=None)
   assertNotIsInstance(obj, cls, msg=None)

      *obj* が *cls* のインスタンスであること (あるいはそうでないこと)
      をテストします (この *cls* は、 "isinstance()" が扱うことのでき
      る、クラスもしくはクラスのタプルである必要があります)。正確な型
      をチェックするためには、 "assertIs(type(obj), cls)" を使用してく
      ださい。

      バージョン 3.2 で追加.

   以下のメソッドを使用して例外、警告、およびログメッセージの発生を確
   認することが出来ます:

   +-----------------------------------------------------------+----------------------------------------+--------------+
   | メソッド                                                  | 確認事項                               | 初出         |
   |===========================================================|========================================|==============|
   | "assertRaises(exc, fun, *args, **kwds)"                   | "fun(*args, **kwds)" が *exc* を送出す |              |
   |                                                           | る                                     |              |
   +-----------------------------------------------------------+----------------------------------------+--------------+
   | "assertRaisesRegex(exc, r, fun, *args, **kwds)"           | "fun(*args, **kwds)" が *exc* を送出し | 3.1          |
   |                                                           | てメッセージが正規表現 *r* と マッチす |              |
   |                                                           | る                                     |              |
   +-----------------------------------------------------------+----------------------------------------+--------------+
   | "assertWarns(warn, fun, *args, **kwds)"                   | "fun(*args, **kwds)" が *warn* を送出  | 3.2          |
   |                                                           | する                                   |              |
   +-----------------------------------------------------------+----------------------------------------+--------------+
   | "assertWarnsRegex(warn, r, fun, *args, **kwds)"           | "fun(*args, **kwds)" が *warn* を送出  | 3.2          |
   |                                                           | してメッセージが正規表現 *r* とマッチ  |              |
   |                                                           | する                                   |              |
   +-----------------------------------------------------------+----------------------------------------+--------------+
   | "assertLogs(logger, level)"                               | "with" ブロックが 最低 *level* で      | 3.4          |
   |                                                           | *logger* を使用する                    |              |
   +-----------------------------------------------------------+----------------------------------------+--------------+

   assertRaises(exception, callable, *args, **kwds)
   assertRaises(exception, *, msg=None)

      *callable* を呼び出した時に例外が発生することをテストします。
      "assertRaises()" で指定した位置パラメータとキーワードパラメータ
      を該当メソッドに渡します。 *exception* が送出された場合、テスト
      は成功です。また、他の例外が投げられた場合はエラー、例外が送出さ
      れなかった場合は失敗になります。複数の例外をキャッチする場合には
      、例外クラスのタプルを *exception* に指定してください。

      *exception* 引数のみ（またはそれに加えて *msg* 引数）が渡された
      場合には、コンテキストマネージャが返されます。これにより関数名を
      渡す形式ではなく、インラインでテスト対象のコードを書くことができ
      ます:

         with self.assertRaises(SomeException):
             do_something()

      コンテキストマネージャとして使われたときは、 "assertRaises()" は
      加えて *msg* キーワード引数も受け付けます。

      このコンテキストマネージャは "exception" で指定されたオブジェク
      トを格納します。これにより、例外発生時の詳細な確認をおこなうこと
      ができます:

         with self.assertRaises(SomeException) as cm:
             do_something()

         the_exception = cm.exception
         self.assertEqual(the_exception.error_code, 3)

      バージョン 3.1 で変更: "assertRaises()" がコンテキストマネージャ
      として使えるようになりました。

      バージョン 3.2 で変更: "exception" 属性が追加されました。

      バージョン 3.3 で変更: コンテキストマネージャとして使用したとき
      に *msg* キーワード引数が追加されました。

   assertRaisesRegex(exception, regex, callable, *args, **kwds)
   assertRaisesRegex(exception, regex, *, msg=None)

      "assertRaises()" と同等ですが、例外の文字列表現が *regex* にマッ
      チすることもテストします。 *regex* は正規表現オブジェクトか、
      "re.search()" が扱える正規表現が書かれた文字列である必要がありま
      す。例えば以下のようになります:

         self.assertRaisesRegex(ValueError, "invalid literal for.*XYZ'$",
                                int, 'XYZ')

      もしくは:

         with self.assertRaisesRegex(ValueError, 'literal'):
            int('XYZ')

      バージョン 3.1 で追加: >>``<<assertRaisesRegexp``という名前で追
      加されました。

      バージョン 3.2 で変更: "assertRaisesRegex()" にリネームされまし
      た。

      バージョン 3.3 で変更: コンテキストマネージャとして使用したとき
      に *msg* キーワード引数が追加されました。

   assertWarns(warning, callable, *args, **kwds)
   assertWarns(warning, *, msg=None)

      *callable* を呼び出した時に警告が発生することをテストします。
      "assertWarns()" で指定した位置パラメータとキーワードパラメータを
      該当メソッドに渡します。 *warning* が発生した場合にテストが成功
      し、そうでなければ失敗になります。例外が送出された場合はエラーに
      なります。複数の警告を捕捉する場合には、警告クラスのタプルを
      *warnings* に指定してください。

      *warning* 引数のみ（またはそれに加えて *msg* 引数）が渡された場
      合には、コンテキストマネージャが返されます。これにより関数名を渡
      す形式ではなく、インラインでテスト対象のコードを書くことができま
      す:

         with self.assertWarns(SomeWarning):
             do_something()

      コンテキストマネージャとして使われたときは、 "assertWarns()" は
      加えて *msg* キーワード引数も受け付けます。

      このコンテキストマネージャは、捕捉した警告オブジェクトを
      "warning" 属性に、警告が発生したソース行を "filename" 属性と
      "lineno" 属性に格納します。これは警告発生時に捕捉された警告に対
      して追加の確認を行いたい場合に便利です:

         with self.assertWarns(SomeWarning) as cm:
             do_something()

         self.assertIn('myfile.py', cm.filename)
         self.assertEqual(320, cm.lineno)

      このメソッドは呼び出されたときに警告フィルタを無視して動作します
      。

      バージョン 3.2 で追加.

      バージョン 3.3 で変更: コンテキストマネージャとして使用したとき
      に *msg* キーワード引数が追加されました。

   assertWarnsRegex(warning, regex, callable, *args, **kwds)
   assertWarnsRegex(warning, regex, *, msg=None)

      "assertWarns()" と同等ですが、警告メッセージが *regex* にマッチ
      することもテストします。 *regex* は正規表現オブジェクトか、
      "re.search()" が扱える正規表現が書かれた文字列である必要がありま
      す。例えば以下のようになります:

         self.assertWarnsRegex(DeprecationWarning,
                               r'legacy_function\(\) is deprecated',
                               legacy_function, 'XYZ')

      もしくは:

         with self.assertWarnsRegex(RuntimeWarning, 'unsafe frobnicating'):
             frobnicate('/etc/passwd')

      バージョン 3.2 で追加.

      バージョン 3.3 で変更: コンテキストマネージャとして使用したとき
      に *msg* キーワード引数が追加されました。

   assertLogs(logger=None, level=None)

      *logger* かその子ロガーのうちの1つに、少なくとも1つのログメッセ
      ージが少なくとも与えられた *level* で出力されることをテストする
      コンテキストマネージャです。

      If given, *logger* should be a "logging.Logger" object or a
      "str" giving the name of a logger.  The default is the root
      logger, which will catch all messages that were not blocked by a
      non-propagating descendent logger.

      *level* が与えられた場合、ログレベルを表す数値もしくはそれに相当
      する文字列 (例えば ""ERROR"" もしくは "logging.ERROR") であるべ
      きです。 デフォルトは "logging.INFO" です。

      "with" ブロック内で出たメッセージの少なくとも一つが *logger* お
      よび *level* 条件に合っている場合、このテストをパスします。それ
      以外の場合は失敗です。

      コンテキストマネージャから返されるオブジェクトは、条件に該当する
      ログメッセージを追跡し続ける記録のためのヘルパーです。 このオブ
      ジェクトには2つの属性があります:

      records

         該当するログメッセージを表す "logging.LogRecord" オブジェクト
         のリスト。

      output

         該当するメッセージ出力をフォーマットした "str" オブジェクトの
         リスト。

      以下はプログラム例です:

         with self.assertLogs('foo', level='INFO') as cm:
            logging.getLogger('foo').info('first message')
            logging.getLogger('foo.bar').error('second message')
         self.assertEqual(cm.output, ['INFO:foo:first message',
                                      'ERROR:foo.bar:second message'])

      バージョン 3.4 で追加.

   より具体的な確認を行うために以下のメソッドが用意されています:

   +-----------------------------------------+----------------------------------+----------------+
   | メソッド                                | 確認事項                         | 初出           |
   |=========================================|==================================|================|
   | "assertAlmostEqual(a, b)"               | "round(a-b, 7) == 0"             |                |
   +-----------------------------------------+----------------------------------+----------------+
   | "assertNotAlmostEqual(a, b)"            | "round(a-b, 7) != 0"             |                |
   +-----------------------------------------+----------------------------------+----------------+
   | "assertGreater(a, b)"                   | "a > b"                          | 3.1            |
   +-----------------------------------------+----------------------------------+----------------+
   | "assertGreaterEqual(a, b)"              | "a >= b"                         | 3.1            |
   +-----------------------------------------+----------------------------------+----------------+
   | "assertLess(a, b)"                      | "a < b"                          | 3.1            |
   +-----------------------------------------+----------------------------------+----------------+
   | "assertLessEqual(a, b)"                 | "a <= b"                         | 3.1            |
   +-----------------------------------------+----------------------------------+----------------+
   | "assertRegex(s, r)"                     | "r.search(s)"                    | 3.1            |
   +-----------------------------------------+----------------------------------+----------------+
   | "assertNotRegex(s, r)"                  | "not r.search(s)"                | 3.2            |
   +-----------------------------------------+----------------------------------+----------------+
   | "assertCountEqual(a, b)"                | *a* と *b* に、順番によらず同じ  | 3.2            |
   |                                         | 要素が同じ数だけある。           |                |
   +-----------------------------------------+----------------------------------+----------------+

   assertAlmostEqual(first, second, places=7, msg=None, delta=None)
   assertNotAlmostEqual(first, second, places=7, msg=None, delta=None)

      *first* と *second* が近似的に等しい (等しくない) ことをテストし
      ます。これは、*places* (デフォルト7) で指定した小数位で丸めた差
      分をゼロと比較することで行われます。これらのメソッドは
      ("round()" と同様に) *小数位* を指定するのであって、*有効桁数*
      を指定するのではないことに注意してください。

      *places* の代わりに *delta* が渡された場合には、*first* と
      *second* の差分が *delta* 以下 (以上) であることをテストします。

      *delta* と *places* の両方が指定された場合は "TypeError" が送出
      されます。

      バージョン 3.2 で変更: "assertAlmostEqual()" は、オブジェクトが
      等しい場合には自動で近似的に等しいとみなすようになりました。
      "assertNotAlmostEqual()" は、オブジェクトが等しい場合には自動的
      に失敗するようになりました。 *delta* 引数が追加されました。

   assertGreater(first, second, msg=None)
   assertGreaterEqual(first, second, msg=None)
   assertLess(first, second, msg=None)
   assertLessEqual(first, second, msg=None)

      *first* が *second* と比べて、メソッド名に対応して >, >=, < もし
      くは <= であることをテストします。そうでない場合はテストは失敗で
      す:

         >>> self.assertGreaterEqual(3, 4)
         AssertionError: "3" unexpectedly not greater than or equal to "4"

      バージョン 3.1 で追加.

   assertRegex(text, regex, msg=None)
   assertNotRegex(text, regex, msg=None)

      *regex* の検索が *text* とマッチする (またはマッチしない) ことを
      テストします。テスト失敗時には、エラーメッセージにパターンと
      *text* が表示されます（もしくは、パターンと意図しないかたちでマ
      ッチした *text* の一部が表示されます）。 *regex* は正規表現オブ
      ジェクトか、 "re.search()" が扱える正規表現が書かれた文字列であ
      る必要があります。

      バージョン 3.1 で追加: >>``<<assertRegexpMatches``という名前で追
      加されました。

      バージョン 3.2 で変更: メソッド "assertRegexpMatches()" は
      "assertRegex()" にリネームされました。

      バージョン 3.2 で追加: "assertNotRegex()"。

      バージョン 3.5 で追加: "assertNotRegexpMatches" は
      "assertNotRegex()" のエイリアスであることから非推奨となります。

   assertCountEqual(first, second, msg=None)

      シーケンス *first* が *second* と同じ要素を含んでいることをテス
      トします。要素の順序はテスト結果に影響しません。要素が含まれてい
      ない場合には、シーケンスの差分がエラーメッセージとして表示されま
      す。

      *first* と *second* の比較では、重複した要素は無視 *されません*
      。両者に同じ数の要素が含まれていることを検証します。このメソッド
      は "assertEqual(Counter(list(first)), Counter(list(second)))" と
      同等に振る舞うことに加えて、ハッシュ化できないオブジェクトのシー
      ケンスでも動作します。

      バージョン 3.2 で追加.

   "assertEqual()" メソッドは、同じ型のオブジェクトの等価性確認のため
   に、型ごとに特有のメソッドにディスパッチします。これらのメソッドは
   、ほとんどの組み込み型用のメソッドは既に実装されています。さらに、
   "addTypeEqualityFunc()" を使う事で新たなメソッドを登録することがで
   きます:

   addTypeEqualityFunc(typeobj, function)

      "assertEqual()" で呼び出される型特有のメソッドを登録します。登録
      するメソッドは、比較する2つのオブジェクトの型が厳密に *typeobj*
      と同じ (サブクラスでもいけません) の場合に等価性を確認します。
      *function*  は "assertEqual()" と同様に、2つの位置引数と、3番目
      に msg=None のキーワード引数を取れる必要があります。このメソッド
      は、始めの2つに指定したパラメータ間の差分を検出した時に
      "self.failureException(msg)" の例外を投げる必要があります。この
      例外を投げる際は、出来る限り、エラーの内容が分かる有用な情報と差
      分の詳細をエラーメッセージに含めてください。

      バージョン 3.1 で追加.

   "assertEqual()" が自動的に呼び出す型特有のメソッドの概要を以下の表
   示に記載しています。これらのメソッドは通常は直接呼び出す必要がない
   ことに注意が必要です。

   +-------------------------------------------+-------------------------------+----------------+
   | メソッド                                  | 比較の対象                    | 初出           |
   |===========================================|===============================|================|
   | "assertMultiLineEqual(a, b)"              | 文字列                        | 3.1            |
   +-------------------------------------------+-------------------------------+----------------+
   | "assertSequenceEqual(a, b)"               | シーケンス                    | 3.1            |
   +-------------------------------------------+-------------------------------+----------------+
   | "assertListEqual(a, b)"                   | リスト                        | 3.1            |
   +-------------------------------------------+-------------------------------+----------------+
   | "assertTupleEqual(a, b)"                  | タプル                        | 3.1            |
   +-------------------------------------------+-------------------------------+----------------+
   | "assertSetEqual(a, b)"                    | set または frozenset          | 3.1            |
   +-------------------------------------------+-------------------------------+----------------+
   | "assertDictEqual(a, b)"                   | 辞書                          | 3.1            |
   +-------------------------------------------+-------------------------------+----------------+

   assertMultiLineEqual(first, second, msg=None)

      複数行の文字列 *first* が文字列 *second* と等しいことをテストし
      ます。等しくない場合には、両者の差分がハイライトされてエラーメッ
      セージに表示されます。このメソッドは、デフォルトで、
      "assertEqual()" が string を比較するときに自動的に使用します。

      バージョン 3.1 で追加.

   assertSequenceEqual(first, second, msg=None, seq_type=None)

      2つのシーケンスが等しいことをテストします。*seq_type* が指定され
      た場合、*first* と *second* が *seq_type* のインスタンスで無い場
      合にはテストが失敗します。シーケンスどうしが異なる場合には、両者
      の差分がエラーメッセージに表示されます。

      このメソッドは直接 "assertEqual()" からは呼ばれませんが、
      "assertListEqual()" と "assertTupleEqual()" の実装で使われていま
      す。

      バージョン 3.1 で追加.

   assertListEqual(first, second, msg=None)
   assertTupleEqual(first, second, msg=None)

      2つのリストまたはタプルが等しいかどうかをテストします。等しくな
      い場合には、両者の差分を表示します。2つのパラメータの型が異なる
      場合にはテストがエラーになります。このメソッドは、デフォルトで、
      "assertEqual()" が list または tuple を比較するときに自動的に使
      用します。

      バージョン 3.1 で追加.

   assertSetEqual(first, second, msg=None)

      2つのセットが等しいかどうかをテストします。等しくない場合には、
      両者の差分を表示します。このメソッドは、デフォルトで、
      "assertEqual()" が set もしくは frozenset を比較するときに自動的
      に使用します。

      *first* or *second* のいずれかに "set.difference()" が無い場合に
      はテストは失敗します。

      バージョン 3.1 で追加.

   assertDictEqual(first, second, msg=None)

      2つの辞書が等しいかどうかをテストします。等しくない場合には、両
      者の差分を表示します。このメソッドは、デフォルトで、
      "assertEqual()" が dict を比較するときに自動的に使用します。

      バージョン 3.1 で追加.

   最後に、 "TestCase" の残りのメソッドと属性を紹介します:

   fail(msg=None)

      無条件にテストを失敗させます。エラーメッセージの表示に、*msg* ま
      たは "None" が使われます。

   failureException

      "test()" メソッドが送出する例外を指定するクラス属性です。例えば
      テストフレームワークで追加情報を付した特殊な例外が必要になる場合
      、この例外のサブクラスとして作成します。この属性の初期値は
      "AssertionError" です。

   longMessage

      このクラス属性は、失敗した assertXYY の呼び出しで独自の失敗時の
      メッセージが msg 引数として渡されていたときにどうするかを決定し
      ます。 "True" がデフォルト値です。 この場合、標準の失敗時のメッ
      セージの後に独自のメッセージが追記されます。 "False" に設定した
      ときは、標準のメッセージを独自のメッセージで置き換えます。

      アサートメソッドを呼び出す前に、個別のテストメソッドの中でインス
      タンス属性 self.longMessage を "True" または "False" に設定して
      、この設定を上書きできます。

      このクラスの設定はそれぞれのテストを呼び出す前にリセットされます
      。

      バージョン 3.1 で追加.

   maxDiff

      この属性は、アサーションメソッドが失敗をレポートする時に表示する
      差分の長さをコントロールします。デフォルトは 80*8 文字です。この
      属性が影響するメソッドは、 "assertSequenceEqual()" (およびこのメ
      ソッドに委譲するシーケンス比較メソッド)、 "assertDictEqual()" と
      "assertMultiLineEqual()" です。

      "maxDiff" を "None" に設定すると差分表示の上限がなくなります。

      バージョン 3.2 で追加.

   テストフレームワークは、テスト情報を収集するために以下のメソッドを
   使用します:

   countTestCases()

      テストオブジェクトに含まれるテストの数を返します。 "TestCase" イ
      ンスタンスは常に "1" を返します。

   defaultTestResult()

      このテストケースクラスで使われるテスト結果クラスのインスタンスを
      (もし "run()" メソッドに他の結果インスタンスが提供されないならば
      ) 返します。

      "TestCase" インスタンスに対しては、いつも "TestResult" のインス
      タンスですので、 "TestCase" のサブクラスでは必要に応じてこのメソ
      ッドをオーバライドしてください。

   id()

      テストケースを特定する文字列を返します。通常、*id* はモジュール
      名・クラス名を含む、テストメソッドのフルネームを指定します。

   shortDescription()

      テストの説明を一行分、または説明がない場合には "None" を返します
      。デフォルトでは、テストメソッドの docstring の先頭の一行、また
      は "None" を返します。

      バージョン 3.1 で変更: 3.1で docstring があったとしても、返され
      る短い説明文字列にテスト名が付けられるようになりました。 この変
      更によって unittest 拡張に互換性の問題が発生し、 Python 3.2 でテ
      スト名が追加される場所は "TextTestResult" へ移動しました。

   addCleanup(function, *args, **kwargs)

      "tearDown()" の後に呼び出される関数を追加します。この関数はリソ
      ースのクリーンアップのために使用します。追加された関数は、追加さ
      れた順と逆の順番で呼び出されます（LIFO (last-in, first-out)）。
      "addCleanup()" に渡された引数とキーワード引数が追加された関数に
      も渡されます。

      "setUp()" が失敗した場合、つまり "tearDown()" が呼ばれなかった場
      合でも、追加されたクリーンアップ関数は呼び出されます。

      バージョン 3.1 で追加.

   doCleanups()

      このメソッドは、 "tearDown()" の後、もしくは、 "setUp()" が例外
      を投げた場合は "setUp()" の後に、無条件で呼ばれます。

      このメソッドは、 "addCleanup()" で追加された関数を呼び出す責務を
      担います。もし、クリーンアップ関数を "tearDown()" より前に呼び出
      す必要がある場合には、 "doCleanups()" を明示的に呼び出してくださ
      い。

      "doCleanups()" は、どこで呼び出されても、クリーンアップ関数をス
      タックから削除して実行します。

      バージョン 3.1 で追加.

   classmethod addClassCleanup(function, /, *args, **kwargs)

      "tearDownClass()" の後に呼び出される関数を追加します。この関数は
      リソースのクリーンアップのために使用します。追加された関数は、追
      加された順と逆の順番で呼び出されます（LIFO (last-in, first-out)
      ）。 "addClassCleanup()" に渡された引数とキーワード引数が追加さ
      れた関数にも渡されます。

      "setUpClass()" が失敗した場合、つまり "tearDownClass()" が呼ばれ
      なかった場合でも、追加されたクリーンアップ関数は呼び出されます。

      バージョン 3.8 で追加.

   classmethod doClassCleanups()

      このメソッドは、 "tearDownClass()" の後、もしくは、
      "setUpClass()" が例外を投げた場合は "setUpClass()" の後に、無条
      件で呼ばれます。

      このメソッドは、 "addClassCleanup()" で追加された関数を呼び出す
      責務を担います。もし、クリーンアップ関数を "tearDownClass()" よ
      り前に呼び出す必要がある場合には、 "doClassCleanups()" を明示的
      に呼び出してください。

      "doClassCleanups()" は、どこで呼び出されても、クリーンアップ関数
      をスタックから削除して実行します。

      バージョン 3.8 で追加.

class unittest.IsolatedAsyncioTestCase(methodName='runTest')

   このクラスは:class:*TestCase* と似たAPIを提供し、テスト関数としてコ
   ルーチンも許容します。

   バージョン 3.8 で追加.

   coroutine asyncSetUp()

      テストフィクスチャを用意するために呼び出されるメソッドです。これ
      は "setUp()". の後に呼び出されます。これはテストメソッドを呼び出
      す直前に呼び出されます。"AssertionError" と "SkipTest" を除いて
      、このメソッドのによって送出されたあらゆる例外はテストの失敗では
      なくエラーとみなされます。デフォルトの実装では何もしません。

   coroutine asyncTearDown()

      テストメソッドが呼び出され、その結果が記録された直後に呼び出され
      るメソッドです。これは "tearDown`の前に呼び出されます。これはテ
      ストメソッドが例外を送出した場合でも呼び出されるので、サブクラス
      の実装では内部状態のチェックに特に気を付ける必要があります。この
      メソッドで送出された:exc:`AssertionError()" と "SkipTest`以外の
      例外は、テストの失敗ではなく追加のエラーとみなされます(そのため
      、報告されるエラーの総数が増えることになります)。このメソッドは
      テストメソッドの結果に関係なく、:meth:`asyncSetUp" が成功した場
      合にのみ呼び出されます。デフォルトの実装では何もしません。

   addAsyncCleanup(function, /, *args, **kwargs)

      このメソッドはクリーンアップ関数として使用できるコルーチンを受け
      入れます。

   run(result=None)

      テストを実行するための新しいイベントループを作成し、
      >>*<<result*として渡された:class:>>`<<TestResult`オブジェクトに
      結果を収集します。>>*<<result*が省略された場合や``None``の場合は
      、一時的なresultオブジェクトが(:meth:>>`<<defaultTestResult`メソ
      ッドの呼び出しによって)作成され、使用されます。このresultオブジ
      ェクトは :meth:>>`<<run`の呼び出し元に返されます。テスト終了時に
      は、イベントループ内のすべてのタスクがキャンセルされます。

   順番を示す例です:

      from unittest import IsolatedAsyncioTestCase

      events = []


      class Test(IsolatedAsyncioTestCase):


          def setUp(self):
              events.append("setUp")

          async def asyncSetUp(self):
              self._async_connection = await AsyncConnection()
              events.append("asyncSetUp")

          async def test_response(self):
              events.append("test_response")
              response = await self._async_connection.get("https://example.com")
              self.assertEqual(response.status_code, 200)
              self.addAsyncCleanup(self.on_cleanup)

          def tearDown(self):
              events.append("tearDown")

          async def asyncTearDown(self):
              await self._async_connection.close()
              events.append("asyncTearDown")

          async def on_cleanup(self):
              events.append("cleanup")

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

   テスト実行後、>>``<<events``には``["setUp", "asyncSetUp",
   "test_response", "asyncTearDown", "tearDown", "cleanup"]``が含まれ
   ます。

class unittest.FunctionTestCase(testFunc, setUp=None, tearDown=None, description=None)

   このクラスでは "TestCase" インターフェースの内、テストランナーがテ
   ストを実行するためのインターフェースだけを実装しており、テスト結果
   のチェックやレポートに関するメソッドは実装していません。既存のテス
   トコードを "unittest" によるテストフレームワークに組み込むために使
   用します。


非推奨のエイリアス
~~~~~~~~~~~~~~~~~~

歴史的な経緯で、 "TestCase" のいくつかのエイリアスは非推奨となりました
。以下の表に、非推奨のエイリアスをまとめます:

   +--------------------------------+------------------------+-------------------------+
   | メソッド名                     | 非推奨のエイリアス     | 非推奨のエイリアス      |
   |================================|========================|=========================|
   | "assertEqual()"                | failUnlessEqual        | assertEquals            |
   +--------------------------------+------------------------+-------------------------+
   | "assertNotEqual()"             | failIfEqual            | assertNotEquals         |
   +--------------------------------+------------------------+-------------------------+
   | "assertTrue()"                 | failUnless             | assert_                 |
   +--------------------------------+------------------------+-------------------------+
   | "assertFalse()"                | failIf                 |                         |
   +--------------------------------+------------------------+-------------------------+
   | "assertRaises()"               | failUnlessRaises       |                         |
   +--------------------------------+------------------------+-------------------------+
   | "assertAlmostEqual()"          | failUnlessAlmostEqual  | assertAlmostEquals      |
   +--------------------------------+------------------------+-------------------------+
   | "assertNotAlmostEqual()"       | failIfAlmostEqual      | assertNotAlmostEquals   |
   +--------------------------------+------------------------+-------------------------+
   | "assertRegex()"                |                        | assertRegexpMatches     |
   +--------------------------------+------------------------+-------------------------+
   | "assertNotRegex()"             |                        | assertNotRegexpMatches  |
   +--------------------------------+------------------------+-------------------------+
   | "assertRaisesRegex()"          |                        | assertRaisesRegexp      |
   +--------------------------------+------------------------+-------------------------+

   バージョン 3.1 で非推奨: 2列目に記載されている fail* エイリアスは非
   推奨になりました。

   バージョン 3.2 で非推奨: 3列目に記載されている assert* エイリアスは
   非推奨になりました。

   バージョン 3.2 で非推奨: "assertRegexpMatches" は "assertRegex()"
   に、 "assertRaisesRegexp" は "assertRaisesRegex()" にメソッド名が変
   更されました

   バージョン 3.5 で非推奨: >>``<<assertNotRegexpMatches``という名前は
   非推奨となり、:meth:>>`<<.assertNotRegex`になりました。


テストのグループ化
------------------

class unittest.TestSuite(tests=())

   このクラスは、個々のテストケースやテストスイートの集合を表現してい
   ます。 通常のテストケースと同じようにテストランナーで実行するための
   インタフェースを備えています。 "TestSuite" インスタンスを実行するこ
   とはスイートをイテレートして得られる個々のテストを実行することと同
   じです。

   引数 *tests* が指定された場合、それはテストケースに亘る繰り返し可能
   オブジェクトまたは内部でスイートを組み立てるための他のテストスイー
   トでなければなりません。後からテストケースやスイートをコレクション
   に付け加えるためのメソッドも提供されています。

   "TestSuite" は "TestCase" オブジェクトのように振る舞います。違いは
   、スイートにはテストを実装しない点にあります。代わりに、テストをま
   とめてグループ化して、同時に実行します。 "TestSuite" のインスタンス
   にテスト追加するためのメソッドが用意されています:

   addTest(test)

      "TestCase" 又は "TestSuite" のインスタンスをスイートに追加します
      。

   addTests(tests)

      イテラブル *tests* に含まれる全ての "TestCase" 又は "TestSuite"
      のインスタンスをスイートに追加します。

      このメソッドは *tests* 上のイテレーションをしながらそれぞれの要
      素に "addTest()" を呼び出すのと等価です。

   "TestSuite" クラスは "TestCase" と以下のメソッドを共有します:

   run(result)

      スイート内のテストを実行し、結果を *result* で指定した結果オブジ
      ェクトに収集します。 "TestCase.run()" と異なり、
      "TestSuite.run()" では必ず結果オブジェクトを指定する必要がありま
      す。

   debug()

      このスイートに関連づけられたテストを結果を収集せずに実行します。
      これによりテストで送出された例外は呼び出し元に伝わるようになり、
      デバッガの下でのテスト実行をサポートできるようになります。

   countTestCases()

      このテストオブジェクトによって表現されるテストの数を返します。こ
      れには個別のテストと下位のスイートも含まれます。

   __iter__()

      "TestSuite" でグループ化されたテストは反復アクセスできます。 サ
      ブクラスは "__iter__()" をオーバーライドすることで、遅延処理でテ
      ストを提供できます。 1つのスイート内でこのメソッドは何度も呼ばれ
      る可能性があることに注意してください (例えば、テスト数のカウント
      や等価性の比較)。 そのため、 "TestSuite.run()" を実行する前に反
      復アクセスを何度繰り返しても同じテスト群を返すようにしなければな
      りません。 呼び出し側が "TestSuite._removeTestAtIndex()" をオー
      バーライドしたサブクラスを使いテストへの参照を保存していない限り
      、 "TestSuite.run()" を実行した後はこのメソッドが返すテスト群を
      信頼すべきではありません。

      バージョン 3.2 で変更: 以前のバージョンでは "TestSuite" はイテレ
      ータではなく、直接テストにアクセスしていました。そのため、
      "__iter__()" をオーバーラードしてもテストにアクセスできませんで
      した。

      バージョン 3.4 で変更: 以前のバージョンでは、 "TestSuite.run()"
      の実行後は "TestSuite" が各 "TestCase" への参照を保持していまし
      た。 サブクラスで "TestSuite._removeTestAtIndex()" をオーバーラ
      イドすることでこの振る舞いを復元できます。

   通常、 "TestSuite" の "run()" メソッドは "TestRunner" が起動するた
   め、ユーザが直接実行する必要はありません。


テストのロードと起動
--------------------

class unittest.TestLoader

   "TestLoader" クラスはクラスとモジュールからテストスイートを生成しま
   す。通常、このクラスのインスタンスを明示的に生成する必要はありませ
   ん。 "unittest" モジュールの "unittest.defaultTestLoader" を共用イ
   ンスタンスとして使用することができます。 しかし、このクラスのサブク
   ラスやインスタンスで、属性をカスタマイズすることができます。

   "TestLoader" オブジェクトには以下の属性があります:

   errors

      テストの読み込み中に起きた致命的でないエラーのリストです。 どの
      時点でもローダーからリセットされることはありません。 致命的なエ
      ラーは適切なメソッドが例外を送出して、呼び出し元に通知します。
      致命的でないエラーも、実行したときのエラーを総合テストが通知して
      くれます。

      バージョン 3.5 で追加.

   "TestLoader" のオブジェクトには以下のメソッドがあります:

   loadTestsFromTestCase(testCaseClass)

      "TestCase" の派生クラス "testCaseClass" に含まれる全テストケース
      のスイートを返します。

      "getTestCaseNames()" で指定されたメソッドに対し、テストケースイ
      ンスタンスが作成されます。 デフォルトでは "test" で始まる名前の
      メソッド群です。 "getTestCaseNames()" がメソッド名を返さなかった
      が、 "runTest()" メソッドが実装されている場合は、そのメソッドに
      対するテストケースが代わりに作成されます。

   loadTestsFromModule(module, pattern=None)

      指定したモジュールに含まれる全テストケースのスイートを返します。
      このメソッドは *module* 内の "TestCase" 派生クラスを検索し、見つ
      かったクラスのテストメソッドごとにクラスのインスタンスを作成しま
      す。

      注釈:

        "TestCase" クラスを基底クラスとしてクラス階層を構築するとテス
        トフィクスチャや補助的な関数をうまく共用することができますが、
        基底クラスに直接インスタンス化できないテストメソッドがあると、
        この "loadTestsFromModule()" を使うことができません。この場合
        でも、 fixture が全て別々で定義がサブクラスにある場合は使用す
        ることができます。

      モジュールが "load_tests" 関数を用意している場合、この関数がテス
      トの読み込みに使われます。 これによりテストの読み込み処理がカス
      タマイズできます。 これが load_tests プロトコル です。 *pattern*
      引数は "load_tests" に第3引数として渡されます。

      バージョン 3.2 で変更: "load_tests" のサポートが追加されました。

      バージョン 3.5 で変更: ドキュメントにない、非公式の
      *use_load_tests* デフォルト引数は非推奨で、後方互換性のために残
      されていますが無視されます。 また、このメソッドはキーワード専用
      引数 *pattern* を受け取るようになりました。これは "load_tests"
      の第三引数に渡されます。

   loadTestsFromName(name, module=None)

      文字列で指定される全テストケースを含むスイートを返します。

      *name* には "ドット修飾名" でモジュールかテストケースクラス、テ
      ストケースクラス内のメソッド、 "TestSuite" インスタンスまたは
      "TestCase" か "TestSuite" のインスタンスを返す呼び出し可能オブジ
      ェクトを指定します。このチェックはここで挙げた順番に行なわれます
      。すなわち、候補テストケースクラス内のメソッドは「呼び出し可能オ
      ブジェクト」としてではなく「テストケースクラス内のメソッド」とし
      て拾い出されます。

      例えば "SampleTests" モジュールに "TestCase" から派生した
      "SampleTestCase" クラスがあり、 "SampleTestCase" にはテストメソ
      ッド "test_one()" ・ "test_two()" ・ "test_three()" があるとしま
      す。この場合、 *name* に "'SampleTests.SampleTestCase'" と指定す
      ると、 "SampleTestCase" の三つのテストメソッドを実行するテストス
      イートが作成されます。 "'SampleTests.SampleTestCase.test_two'"
      と指定すれば、 "test_two()" だけを実行するテストスイートが作成さ
      れます。インポートされていないモジュールやパッケージ名を含んだ名
      前を指定した場合は自動的にインポートされます。

      また、*module* を指定した場合、*module* 内の *name* を取得します
      。

      バージョン 3.5 で変更: *name* を巡回している間に "ImportError"
      か "AttributeError" が発生した場合、実行するとその例外を発生させ
      るようなテストを合成して返します。それらのエラーは self.errors
      に集められます。

   loadTestsFromNames(names, module=None)

      "loadTestsFromName()" と同じですが、名前を一つだけ指定するのでは
      なく、複数の名前のシーケンスを指定する事ができます。戻り値は
      *names* 中の名前で指定されるテスト全てを含むテストスイートです。

   getTestCaseNames(testCaseClass)

      *testCaseClass* 中の全てのメソッド名を含むソート済みシーケンスを
      返します。 *testCaseClass* は "TestCase" のサブクラスでなければ
      なりません。

   discover(start_dir, pattern='test*.py', top_level_dir=None)

      指定された開始ディレクトリからサブディレクトリに再帰することです
      べてのテストモジュールを検索し、それらを含む TestSuite オブジェ
      クトを返します。*pattern* にマッチしたテストファイルだけがロード
      の対象になります。 (シェルスタイルのパターンマッチングが使われま
      す)。その中で、インポート可能なもジュール (つまり Python の識別
      子として有効であるということです) がロードされます。

      すべてのテストモジュールはプロジェクトのトップレベルからインポー
      ト可能である必要があります。開始ディレクトリがトップレベルディレ
      クトリでない場合は、トップレベルディレクトリを個別に指定しなけれ
      ばなりません。

      シンタックスエラーなどでモジュールのインポートに失敗した場合、エ
      ラーが記録され、ディスカバリ自体は続けられます。 import  の失敗
      が "SkipTest" 例外が発生したためだった場合は、そのモジュールはエ
      ラーではなく skip として記録されます。

      パッケージ ("__init__.py" という名前のファイルがあるディレクトリ
      ) が見付かった場合、そのパッケージに "load_tests" 関数があるかを
      チェックします。 関数があった場合、次に
      "package.load_tests(loader, tests, pattern)" が呼ばれます。 テス
      トの検索の実行では、たとえ load_tests 関数自身が
      "loader.discover" を呼んだとしても、パッケージのチェックは1回の
      みとなることが保証されています。

      "load_tests" が存在して、ディスカバリがパッケージ内を再帰的な検
      索を続けている途中で *ない* 場合、"load_tests" はそのパッケージ
      内の全てのテストをロードする責務を担います。

      意図的にパターンはローダの属性として保持されないようになっていま
      す。それにより、パッケージが自分自身のディスカバリを続ける事がで
      きます。*top_level_dir* は保持されるため、"load_tests" はこの引
      数を "loader.discover()" に渡す必要はありません。

      *start_dir* はドット付のモジュール名でもディレクトリでも構いませ
      ん。

      バージョン 3.2 で追加.

      バージョン 3.4 で変更: インポート時に "SkipTest" を送出するモジ
      ュールはエラーではなくスキップとして記録されます。

      バージョン 3.4 で変更: >>*<<start_dir*に:term:>>`<<名前空間パッ
      ケージ <namespace package>`を指定できます。

      バージョン 3.4 で変更: ファイルシステムの順序がファイル名に従わ
      ないとしても実行順序が一定になるように、パスはインポートする前に
      ソートされます。

      バージョン 3.5 で変更: パッケージ名がデフォルトのパターンに適合
      するのは不可能なので、パスが *pattern* に適合するかどうかに関係
      無く、見付けたパッケージに "load_tests" があるかをチェックするよ
      うになりました。

   以下の属性は、サブクラス化またはインスタンスの属性値を変更して
   "TestLoader" をカスタマイズする場合に使用します:

   testMethodPrefix

      テストメソッドの名前と判断されるメソッド名の接頭語を示す文字列。
      デフォルト値は "'test'" です。

      この値は "getTestCaseNames()" と全ての "loadTestsFrom*()" メソッ
      ドに影響を与えます。

   sortTestMethodsUsing

      "getTestCaseNames()" および全ての "loadTestsFrom*()" メソッドで
      メソッド名をソートする際に使用する比較関数。

   suiteClass

      テストのリストからテストスイートを構築する呼び出し可能オブジェク
      ト。メソッドを持つ必要はありません。デフォルト値は "TestSuite"
      です。

      この値は全ての "loadTestsFrom*()" メソッドに影響を与えます。

   testNamePatterns

      テストメソッドがテストスイートに含まれるためにマッチしなければな
      らないUnixシェルスタイルのワイルドカードテスト名パターンのリスト
      です(>>``<<-v``オプションを参照)。

      この属性が``None`` (デフォルト)でない場合、テストスイートに含ま
      れるすべてのテストメソッドはこのリストのパターンのいずれかにマッ
      チしていなければなりません。マッチは常に "fnmatch.fnmatchcase`を
      使用して実行されるため、`()"-v``オプションに渡されるパターンとは
      異なり、単純な部分文字列パターンは >>``<<>>*<<>>``<<ワイルドカー
      ドを使用して変換する必要があることに注意してください。

      この値は全ての "loadTestsFrom*()" メソッドに影響を与えます。

      バージョン 3.7 で追加.

class unittest.TestResult

   このクラスはどのテストが成功しどのテストが失敗したかという情報を収
   集するのに使います。

   "TestResult" は、複数のテスト結果を記録します。 "TestCase" クラスと
   "TestSuite" クラスのテスト結果を正しく記録しますので、テスト開発者
   が独自にテスト結果を管理する処理を開発する必要はありません。

   "unittest" を利用したテストフレームワークでは、 "TestRunner.run()"
   が返す "TestResult" インスタンスを参照し、テスト結果をレポートしま
   す。

   "TestResult" インスタンスの以下の属性は、テストの実行結果を検査する
   際に使用することができます:

   errors

      "TestCase" と例外のトレースバック情報をフォーマットした文字列の
      2 要素タプルからなるリスト。それぞれのタプルは予想外の例外を送出
      したテストに対応します。

   failures

      "TestCase" と例外のトレースバック情報をフォーマットした文字列の
      2 要素タプルからなるリスト。それぞれのタプルは
      "TestCase.assert*()" メソッドを使って見つけ出した失敗に対応しま
      す。

   skipped

      "TestCase" インスタンスとテストをスキップした理由を保持する文字
      列の2要素タプルからなるリストです。

      バージョン 3.1 で追加.

   expectedFailures

      "TestCase" と例外のトレースバック情報をフォーマット済の文字列の
      2 要素タプルからなるリストです。それぞれのタプルは予期された失敗
      またはエラーに対応します。

   unexpectedSuccesses

      予期された失敗とされていながら成功してしまった "TestCase" のイン
      スタンスのリスト。

   shouldStop

      "True" が設定されると "stop()" によりテストの実行が停止します。

   testsRun

      これまでに実行したテストの総数です。

   buffer

      "True" が設定されると、 "sys.stdout" と "sys.stderr" は、
      "startTest()" から "stopTest()" が呼ばれるまでの間バッファリング
      されます。実際に、結果が "sys.stdout" と "sys.stderr" に出力され
      るのは、テストが失敗するかエラーが発生した時になります。表示の際
      には、全ての失敗 / エラーメッセージが表示されます。

      バージョン 3.2 で追加.

   failfast

      真の場合 "stop()" が始めの失敗もしくはエラーの時に呼び出され、テ
      ストの実行が終了します。

      バージョン 3.2 で追加.

   tb_locals

      真の場合、局所変数がトレースバックに表示されます。

      バージョン 3.5 で追加.

   wasSuccessful()

      これまでに実行したテストが全て成功していれば "True" を、それ以外
      なら "False" を返します。

      バージョン 3.4 で変更: "expectedFailure()" デコレ－タでマークさ
      れたテストに "unexpectedSuccesses" があった場合 "False" を返しま
      す。

   stop()

      このメソッドを呼び出して "TestResult" の "shouldStop" 属性に
      "True" をセットすることで、実行中のテストは中断しなければならな
      いというシグナルを送ることができます。 "TestRunner" オブジェクト
      はこのフラグを順守してそれ以上のテストを実行することなく復帰しな
      ければなりません。

      たとえばこの機能は、ユーザのキーボード割り込みを受け取って
      "TextTestRunner" クラスがテストフレームワークを停止させるのに使
      えます。 "TestRunner" の実装を提供する対話的なツールでも同じよう
      に使用することができます。

   "TestResult" クラスの以下のメソッドは内部データ管理用のメソッドです
   が、対話的にテスト結果をレポートするテストツールを開発する場合など
   にはサブクラスで拡張することができます。

   startTest(test)

      *test* を実行する直前に呼び出されます。

   stopTest(test)

      *test* の実行直後に、テスト結果に関わらず呼び出されます。

   startTestRun()

      全てのテストが実行される前に一度だけ実行されます。

      バージョン 3.1 で追加.

   stopTestRun()

      全てのテストが実行された後に一度だけ実行されます。

      バージョン 3.1 で追加.

   addError(test, err)

      テスト *test* 実行中に、想定外の例外が発生した場合に呼び出されま
      す。 *err* は "sys.exc_info()" が返すタプル "(type, value,
      traceback)" です。

      デフォルトの実装では、タプル、 "(test, formatted_err)" をインス
      タンスの "errors" 属性に追加します。ここで、 *formatted_err* は
      、 *err* から導出される、整形されたトレースバックです。

   addFailure(test, err)

      テストケース *test* が失敗した場合に呼び出されます。 *err* は
      "sys.exc_info()" が返すタプル "(type, value, traceback)" です。

      デフォルトの実装では、タプル、 "(test, formatted_err)" をインス
      タンスの "failures" 属性に追加します。ここで、 *formatted_err*
      は、 *err* から導出される、整形されたトレースバックです。

   addSuccess(test)

      テストケース *test* が成功した場合に呼び出されます。

      デフォルトの実装では何もしません。

   addSkip(test, reason)

      *test* がスキップされた時に呼び出されます。*reason* はスキップの
      際に渡された理由の文字列です。

      デフォルトの実装では、 "(test, reason)" のタプルをインスタンスの
      "skipped" 属性に追加します。

   addExpectedFailure(test, err)

      "expectedFailure()" のデコレータでマークされた *test* が失敗また
      はエラーの時に呼び出されます。

      デフォルトの実装では "(test, formatted_err)" のタプルをインスタ
      ンスの "expectedFailures" に追加します。ここで *formatted_err*
      は *err* から派生した整形されたトレースバックです。

   addUnexpectedSuccess(test)

      "expectedFailure()" のデコレータでマークされた *test* が成功した
      時に呼び出されます。

      デフォルトの実装ではテストをインスタンスの "unexpectedSuccesses"
      属性に追加します。

   addSubTest(test, subtest, outcome)

      サブテストが終了すると呼ばれます。 *test* はテストメソッドに対応
      するテストケースです。 *subtest* はサブテストを記述するカスタム
      の "TestCase" インスタンスです。

      *outcome* が "None" の場合サブテストは成功です。 それ以外の場合
      は失敗で、"sys.exc_info()" が返す形式 "(type, value, traceback)"
      の *outcome* を持つ例外を伴います。

      結果が成功の場合デフォルトの実装では何もせず、サブテストの失敗を
      通常の失敗として報告します。

      バージョン 3.4 で追加.

class unittest.TextTestResult(stream, descriptions, verbosity)

   "TextTestRunner" に使用される "TestResult" の具象実装です。

   バージョン 3.2 で追加: このクラスは以前 "_TextTestResult" という名
   前でした。以前の名前はエイリアスとして残っていますが非推奨です。

unittest.defaultTestLoader

   "TestLoader" のインスタンスで、共用することが目的です。
   "TestLoader" をカスタマイズする必要がなければ、新しい "TestLoader"
   オブジェクトを作らずにこのインスタンスを使用します。

class unittest.TextTestRunner(stream=None, descriptions=True, verbosity=1, failfast=False, buffer=False, resultclass=None, warnings=None, *, tb_locals=False)

   結果をストリームに出力する、基本的なテストランナーの実装です。
   *stream* が "None" の場合、デフォルトで "sys.stderr" が出力ストリー
   ムとして使われます。 このクラスはいくつかの設定項目があるだけで、基
   本的に非常に単純です。 グラフィカルなテスト実行アプリケーションでは
   、独自のテストランナーを実装してください。 テストランナーの実装は、
   unittest に新しい機能が追加されランナーを構築するインターフェースが
   変更されたときに備えて "**kwargs" を受け取れるようにするべきです。

   デフォルトで無視 に設定されているとしても、このランナーのデフォルト
   では "DeprecationWarning", "PendingDeprecationWarning",
   "ResourceWarning", "ImportWarning" を表示します。 unittest の非推奨
   メソッド で起きた非推奨警告も特別な場合として扱われ、警告フィルタが
   "'default'" もしくは "'always'" だったとき、対象の警告メッセージが
   出ないようにモジュールごとに1回だけ表示されます。 Python の "-Wd"
   オプションや "-Wa" オプション (警告の制御 を参照してください) を使
   ったり、 *warnings* を "None" にしたりしておくと、この動作を上書き
   できます。

   バージョン 3.2 で変更: "warnings" 引数が追加されました。

   バージョン 3.2 で変更: インポート時でなくインスタンス化時にデフォル
   トのストリームが "sys.stderr" に設定されます。

   バージョン 3.5 で変更: tb_locals 引数が追加されました。

   _makeResult()

      このメソッドは "run()" で使われる "TestResult" のインスタンスを
      返します。このメソッドは明示的に呼び出す必要はありませんが、サブ
      クラスで "TestResult" をカスタマイズすることができます。

      "_makeResult()" は、 "TextTestRunner" のコンストラクタで
      "resultclass" 引数として渡されたクラスもしくはコーラブルオブジェ
      クトをインスタンス化します。 "resultclass" が指定されていない場
      合には、デフォルトで "TextTestResult" が使用されます。結果のクラ
      スは以下の引数が渡されインスタンス化されます:

         stream, descriptions, verbosity

   run(test)

      このメソッドは "TextTestRunner" へのメインの公開インターフェース
      です。 このメソッドは "TestSuite" インスタンスあるいは
      "TestCase" インスタンスを受け取ります。 "_makeResult()" が呼ばれ
      て "TestResult" が作成され、テストが実行され、結果が標準出力に表
      示されます。

unittest.main(module='__main__', defaultTest=None, argv=None, testRunner=None, testLoader=unittest.defaultTestLoader, exit=True, verbosity=1, failfast=None, catchbreak=None, buffer=None, warnings=None)

   *module* から複数のテストを読み込んで実行するためのコマンドラインプ
   ログラム。この関数を使えば、簡単に実行可能なテストモジュールを作成
   する事ができます。一番簡単なこの関数の使い方は、以下の行をテストス
   クリプトの最後に置くことです:

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

   より詳細な情報は verbosity 引数を指定して実行すると得られます:

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

   *defaultTest* 引数は、 *argv* にテスト名が指定されていない場合に実
   行する、ある1つのテストの名前もしくはテスト名のイテラブルです。 こ
   の引数を指定しないか "None" を指定し、かつ *argv* にテスト名が与え
   られない場合は、 *module* にある全てのテストを実行します。

   *argv* 引数には、プログラムに渡されたオプションのリストを、最初の要
   素がプログラム名のままで渡せます。指定しないか "None" の場合は
   "sys.argv" が使われます。

   引数、 *testRunner* は、test runner class、あるいは、そのインスタン
   スのどちらでも構いません。でフォルトでは "main" はテストが成功した
   か失敗したかに対応した終了コードと共に "sys.exit()" を呼び出します
   。

   *testLoader* 引数は "TestLoader" インスタンスでなければなりません。
   デフォルトは "defaultTestLoader" です。

   "main" は、 "exit=False" を指定する事で対話的なインタプリタから使用
   することもできます。この引数を指定すると、 "sys.exit()" を呼ばずに
   、結果のみを出力します:

      >>> from unittest import main
      >>> main(module='test_module', exit=False)

   *failfast*, *catchbreak*, *buffer* は、コマンドラインオプション に
   ある同名のオプションと同じ効果のあるパラメータです。

   *warnings* 引数では、テストの実行中に使うべき 警告フィルタ を指定し
   ます。 この引数が指定されない場合には、 "-W" オプションが
   **python** に渡されていなければ "None" のまま (警告の制御 を参照し
   てください) で、そうでなければ "'default'" が設定されます。

   "main" を呼び出すと、"TestProgram" のインスタンスが返されます。この
   インスタンスは、"result" 属性にテスト結果を保持します。

   バージョン 3.1 で変更: *exit* パラメータが追加されました。

   バージョン 3.2 で変更: *verbosity*、*failfast*、*catchbreak*、
   *buffer*、*warnings* 引数が追加されました。

   バージョン 3.4 で変更: *defaultTest* 引数がテスト名のイテラブルも受
   け取るようになりました。


load_tests プロトコル
~~~~~~~~~~~~~~~~~~~~~

バージョン 3.2 で追加.

モジュールやパッケージには、"load_tests" と呼ばれる関数を実装できます
。これにより、通常のテスト実行時やテストディスカバリ時のテストのロード
され方をカスタマイズできます。

テストモジュールが "load_tests" を定義していると、それが
"TestLoader.loadTestsFromModule()" から呼ばれます。引数は以下です:

   load_tests(loader, standard_tests, pattern)

*pattern* は "loadTestsFromModule" からそのまま渡されます。デフォルト
は "None" です。

これは "TestSuite" を返すべきです。

*loader* はローディングを行う "TestLoader" のインスタンスです。
*standard_tests* は、そのモジュールからデフォルトでロードされるテスト
です。これは、テストの標準セットのテストの追加や削除のみを行いたいテス
トモジュールに一般に使われます。第三引数は、パッケージをテストディスカ
バリの一部としてロードするときに使われます。

特定の "TestCase" クラスのセットからテストをロードする典型的な
"load_tests" 関数は、このようになります:

   test_cases = (TestCase1, TestCase2, TestCase3)

   def load_tests(loader, tests, pattern):
       suite = TestSuite()
       for test_class in test_cases:
           tests = loader.loadTestsFromTestCase(test_class)
           suite.addTests(tests)
       return suite

コマンドラインからでも "TestLoader.discover()" の呼び出しでも、パッケ
ージを含むディレクトリで検索を始めた場合、そのパッケージの
"__init__.py" をチェックして "load_tests" を探します。 その関数が存在
しない場合、他のディレクトリであるかのようにパッケージの中を再帰的に検
索します。 その関数が存在した場合、パッケージのテストの検索をそちらに
任せ、 "load_tests" が次の引数で呼び出されます:

   load_tests(loader, standard_tests, pattern)

これはパッケージ内のすべてのテストを表す "TestSuite" を返すべきです。
("standard_tests" には、 "__init__.py" から収集されたテストのみが含ま
れます。)

パターンは "load_tests" に渡されるので、パッケージは自由にテストディス
カバリを継続 (必要なら変更) できます。テストパッケージに '何もしない'
"load_tests" 関数は次のようになります:

   def load_tests(loader, standard_tests, pattern):
       # top level directory cached on loader instance
       this_dir = os.path.dirname(__file__)
       package_tests = loader.discover(start_dir=this_dir, pattern=pattern)
       standard_tests.addTests(package_tests)
       return standard_tests

バージョン 3.5 で変更: パッケージ名がデフォルトのパターンに適合するの
が不可能なため、検索ではパッケージ名が *pattern* に適合するかのチェッ
クは行われなくなりました。


クラスとモジュールのフィクスチャ
================================

クラスレベルとモジュールレベルのフィクスチャが "TestSuite" に実装され
ました。 テストスイートが新しいクラスのテストを始める時、以前のクラス
(あれば)の "tearDownClass()" を呼び出し、その後に新しいクラスの
"setUpClass()" を呼び出します。

同様に、今回のテストのモジュールが前回のテストとは異なる場合、以前のモ
ジュールの "tearDownModule" を実行し、次に新しいモジュールの
"setUpModule" を実行します。

すべてのテストが実行された後、最後の "tearDownClass" と
"tearDownModule" が実行されます。

なお、共有フィクスチャは、テストの並列化などの [潜在的な] 機能と同時に
はうまくいかず、テストの分離を壊すので、気をつけて使うべきです。

unittest テストローダによるテスト作成のデフォルトの順序では、同じモジ
ュールやクラスからのテストはすべて同じグループにまとめられます。これに
より、"setUpClass" / "setUpModule" (など) は、一つのクラスやモジュール
につき一度だけ呼ばれます。この順序をバラバラにし、異なるモジュールやク
ラスのテストが並ぶようにすると、共有フィクスチャ関数は、一度のテストで
複数回呼ばれるようにもなります。

共有フィクスチャは標準でない順序で実行されることを意図していません。
共有フィクスチャをサポートしたくないフレームワークのために、
"BaseTestSuite" がまだ存在しています。

共有フィクスチャ関数のいずれかで例外が発生した場合、そのテストはエラー
として報告されます。 そのとき、対応するテストインスタンスが無いので
("TestCase" と同じインタフェースの) "_ErrorHolder" オブジェクトが生成
され、エラーを表します。 標準 unittest テストランナーを使っている場合
はこの詳細は問題になりませんが、あなたがフレームワークの作者である場合
は注意してください。


setUpClass と tearDownClass
---------------------------

これらはクラスメソッドとして実装されなければなりません:

   import unittest

   class Test(unittest.TestCase):
       @classmethod
       def setUpClass(cls):
           cls._connection = createExpensiveConnectionObject()

       @classmethod
       def tearDownClass(cls):
           cls._connection.destroy()

基底クラスの "setUpClass" および "tearDownClass" を使いたいなら、それ
らを自分で呼び出さなければなりません。 "TestCase" の実装は空です。

"setUpClass" の中で例外が送出されたら、クラス内のテストは実行されず、
"tearDownClass" も実行されません。スキップされたクラスは "setUpClass"
も "tearDownClass" も実行されません。例外が "SkipTest" 例外であれば、
そのクラスはエラーではなくスキップされたものとして報告されます。


setUpModule と tearDownModule
-----------------------------

これらは関数として実装されなければなりません:

   def setUpModule():
       createConnection()

   def tearDownModule():
       closeConnection()

"setUpModule" の中で例外が送出されたら、モジュール内のテストは実行され
ず、 "tearDownModule" も実行されません。例外が "SkipTest" 例外であれば
、そのモジュールはエラーではなくスキップされたものとして報告されます。

例外が発生した場合でも実行しなければならないクリーンアップコードを追加
するには``addModuleCleanup``を使用します:

unittest.addModuleCleanup(function, /, *args, **kwargs)

   "tearDownModule()" の後に呼び出される関数を追加します。この関数はリ
   ソースのクリーンアップのために使用します。追加された関数は、追加さ
   れた順と逆の順番で呼び出されます（LIFO (last-in, first-out)）。
   "addModuleCleanup()" に渡された引数とキーワード引数が追加された関数
   にも渡されます。

   "setUpModule()" が失敗した場合、つまり "tearDownModule()" が呼ばれ
   なかった場合でも、追加されたクリーンアップ関数は呼び出されます。

   バージョン 3.8 で追加.

unittest.doModuleCleanups()

   この関数は、 "tearDownModule()" の後、もしくは、 "setUpModule()" が
   例外を投げた場合は "setUpModule()" の後に、無条件で呼ばれます。

   このメソッドは、 "addCleanupModule()" で追加された関数を呼び出す責
   務を担います。もし、クリーンアップ関数を "tearDownModule()" より前
   に呼び出す必要がある場合には、 "doModuleCleanups()" を明示的に呼び
   出してください。

   "doModuleCleanups()" は、どこで呼び出されても、クリーンアップ関数を
   スタックから削除して実行します。

   バージョン 3.8 で追加.


シグナルハンドリング
====================

バージョン 3.2 で追加.

unittest の "-c/--catch" コマンドラインオプションや、
"unittest.main()" の "catchbreak" パラメタは、テスト実行中の control-C
の処理をよりフレンドリーにします。中断捕捉動作を有効である場合、
control-C が押されると、現在実行されているテストまで完了され、そのテス
トランが終わると今までの結果が報告されます。control-C がもう一度押され
ると、通常通り "KeyboardInterrupt" が送出されます。

シグナルハンドラを処理する control-c は、独自の "signal.SIGINT" ハンド
ラをインストールするコードやテストの互換性を保とうとします。
"unittest" ハンドラが呼ばれ、それがインストールされた "signal.SIGINT"
ハンドラで *なければ* 、すなわちテスト中のシステムに置き換えられて移譲
されたなら、それはデフォルトのハンドラを呼び出します。インストールされ
たハンドラを置き換えて委譲するようなコードは、通常その動作を期待するか
らです。 "unittest" の control-c 処理を無効にしたいような個別のテスト
には、 "removeHandler()" デコレータが使えます。

フレームワークの作者がテストフレームワーク内で control-c 処理を有効に
するための、いくつかのユーティリティ関数があります。

unittest.installHandler()

   control-c ハンドラをインストールします。(主にユーザが control-c を
   押したことにより) "signal.SIGINT" が受け取られると、登録した結果す
   べてに "stop()" が呼び出されます。

unittest.registerResult(result)

   control-c 処理のために "TestResult" を登録します。結果を登録すると
   それに対する弱参照が格納されるので、結果がガベージコレクトされるの
   を妨げません。

   control-c 処理が有効でなければ、 "TestResult" オブジェクトの登録に
   は副作用がありません。ですからテストフレームワークは、処理が有効か
   無効かにかかわらず、作成する全ての結果を無条件に登録できます。

unittest.removeResult(result)

   登録された結果を削除します。一旦結果が削除されると、control-c が押
   された際にその結果オブジェクトに対して "stop()" が呼び出されなくな
   ります。

unittest.removeHandler(function=None)

   引数なしで呼び出されると、この関数はCtrl+Cのシグナルハンドラを（そ
   れがインストールされていた場合）削除します。また、この関数はテスト
   が実行されている間、Ctrl+Cのハンドラを一時的に削除するテストデコレ
   ーターとしても使用できます。

      @unittest.removeHandler
      def test_signal_handling(self):
          ...
