Summary  
This chapter explains how to use the various assert methods in unittest.TestCase—such as assertEqual, assertTrue, assertIn, and assertRaises—to validate expected outcomes and errors in code.  

General domain of usage  
automated testing

`assert` メソッドは `unittest.TestCase` クラスの一部であり、テスト内の条件を検証するために使用されます。
簡単に言えば、Test クラス内の各テストメソッドは `self.assert` のような文で終了します。

## よく使われる assert メソッド
| **Method** | **Check** | **Example** |
|--------------|-------|-------------|
| assertEqual(a, b) | a == b | assertEqual(sum([1, 2, 3]), 6) |
| assertNotEqual(a, b) | a != b | assertNotEqual(1, 2) |
| assertTrue(x) | bool(x) is True | assertTrue(isinstance(123, int)) |
| assertFalse(x) | bool(x) is False | assertFalse(isinstance("hello", int)) |
| assertIs(a, b) | a is b | a = 1, b = a |
| assertIsNone(x) | x is None | book.price = None |
| assertIn(a, b) | a in b | assertIn(2, [1, 2, 3]) |
| assertIsInstance(a, b) | isinstance(a, b) | assertIsInstance(123, int) |

また、`assertRaises(Error, func, *args, **kwargs)` はエラーが発生することをテストするために使用されます。例：
``` python
with self.assertRaises(ValueError):
    int("xyz")
```
これは "xyz" を整数に変換しようとすると `ValueError` が発生することを確認します。


import unittest
import user_code
import ast
import re   
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_add_equal(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        _dynamic_test(self, test_class is not None, "TestFunctions class exists", "TestFunctions class not found")
        test_method = getattr(test_class, 'test_add_equal', None)
        _dynamic_test(self, callable(test_method), "test_add_equal method exists", "test_add_equal method missing")
        test_case = test_class('test_add_equal')
        try:
            test_case.test_add_equal()
            _dynamic_test(self, True, "add(2, 3) == 5 passes assertEqual", "add(2, 3) == 5 failed assertEqual")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"add(2, 3) == 5 failed assertEqual: {e}")

    def test_add_not_equal(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_add_not_equal', None)
        _dynamic_test(self, callable(test_method), "test_add_not_equal method exists", "test_add_not_equal method missing")
        test_case = test_class('test_add_not_equal')
        try:
            test_case.test_add_not_equal()
            _dynamic_test(self, True, "add(2, 2) != 5 passes assertNotEqual", "add(2, 2) != 5 failed assertNotEqual")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"add(2, 2) != 5 failed assertNotEqual: {e}")

    def test_is_even_true(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_is_even_true', None)
        _dynamic_test(self, callable(test_method), "test_is_even_true method exists", "test_is_even_true method missing")
        test_case = test_class('test_is_even_true')
        try:
            test_case.test_is_even_true()
            _dynamic_test(self, True, "is_even(4) is True passes assertTrue", "is_even(4) is True failed assertTrue")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"is_even(4) is True failed assertTrue: {e}")

    def test_is_even_false(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_is_even_false', None)
        _dynamic_test(self, callable(test_method), "test_is_even_false method exists", "test_is_even_false method missing")
        test_case = test_class('test_is_even_false')
        try:
            test_case.test_is_even_false()
            _dynamic_test(self, True, "is_even(5) is False passes assertFalse", "is_even(5) is False failed assertFalse")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"is_even(5) is False failed assertFalse: {e}")

    def test_get_item_is(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_get_item_is', None)
        _dynamic_test(self, callable(test_method), "test_get_item_is method exists", "test_get_item_is method missing")
        test_case = test_class('test_get_item_is')
        try:
            test_case.test_get_item_is()
            _dynamic_test(self, True, "get_item([10, 20, 30], 1) is 20 passes assertIs", "get_item([10, 20, 30], 1) is 20 failed assertIs")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"get_item([10, 20, 30], 1) is 20 failed assertIs: {e}")

    def test_get_item_is_none(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_get_item_is_none', None)
        _dynamic_test(self, callable(test_method), "test_get_item_is_none method exists", "test_get_item_is_none method missing")
        test_case = test_class('test_get_item_is_none')
        try:
            test_case.test_get_item_is_none()
            _dynamic_test(self, True, "get_item([1,2,3], 10) is None passes assertIsNone", "get_item([1,2,3], 10) is None failed assertIsNone")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"get_item([1,2,3], 10) is None failed assertIsNone: {e}")

    def test_in_list(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_in_list', None)
        _dynamic_test(self, callable(test_method), "test_in_list method exists", "test_in_list method missing")
        test_case = test_class('test_in_list')
        try:
            test_case.test_in_list()
            _dynamic_test(self, True, "2 in [1,2,3] passes assertIn", "2 in [1,2,3] failed assertIn")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"2 in [1,2,3] failed assertIn: {e}")

    def test_add_is_instance(self):
        import user_code
        importlib.reload(user_code)
        test_class = getattr(user_code, 'TestFunctions', None)
        test_method = getattr(test_class, 'test_add_is_instance', None)
        _dynamic_test(self, callable(test_method), "test_add_is_instance method exists", "test_add_is_instance method missing")
        test_case = test_class('test_add_is_instance')
        try:
            test_case.test_add_is_instance()
            _dynamic_test(self, True, "add(1,2) is int passes assertIsInstance", "add(1,2) is int failed assertIsInstance")
        except AssertionError as e:
            _dynamic_test(self, False, "", f"add(1,2) is int failed assertIsInstance: {e}")

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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


test_main.py

Pythonのモジュールとインポートによる効率的なコード管理の実践的スキルを習得します。より信頼性の高いアプリケーションのための高度なエラーハンドリング技術をマスターし、ファイル操作の自動化をファイルハンドリングで実現し、PytestとUnittestによる堅牢なテスト戦略を学ぶことで、コードの完全性を確保します。

インポート文の扱いに悩んでいる方、モジュールとライブラリの違いが分からない方、またはPythonプロジェクトの構造管理に困っている方にとって、このセクションは明確な理解への鍵となります。

コードのデバッグを効果的に行い、さまざまなエラーを活用する力を理解したい方へ。このセクションでは、Pythonにおけるエラー処理を分かりやすく解説し、堅牢なアプリケーションを開発するために開発者がこれらのスキルを習得する重要性を紹介します。

プロジェクトでのファイル操作を自動化したい方に最適なセクションです。本セクションでは、Pythonにおけるファイル操作の基本を詳しく解説し、ファイルの読み書きや管理を効率的に行うためのツールを習得できます。これにより、よりスムーズで高機能なアプリケーション開発が可能となります。

Pytestを用いたテストの詳細およびテスト駆動開発（TDD）の基礎を学習します。このセクションでは、コードの信頼性を高め、開発プロセスを効率化する堅牢なテストの作成方法を案内します。

Unittestを使用した自動化テストの習得。セットアップ、ティアダウン、モックを活用し、さまざまなテストケースを効果的に網羅する方法を学習します。

Pythonにおいて、イテレータとジェネレータは効率的かつメモリ効率の高いデータ処理を可能にする重要な概念です。イテレータはデータへ逐次的にアクセスするための特定のプロトコルに従い、ジェネレータはyieldキーワードを用いて必要に応じて値を生成することでイテレーションを簡素化します。本セクションでは、これらの概念とその実践的な応用について解説し、メモリ効率の高いプログラミングの習得を支援します。

Unittestにおけるアサートメソッドの使用：テスト結果の検証

よく使われる assert メソッド

解答

Method	Check	Example
assertEqual(a, b)	a == b	assertEqual(sum([1, 2, 3]), 6)
assertNotEqual(a, b)	a != b	assertNotEqual(1, 2)
assertTrue(x)	bool(x) is True	assertTrue(isinstance(123, int))
assertFalse(x)	bool(x) is False	assertFalse(isinstance("hello", int))
assertIs(a, b)	a is b	a = 1, b = a
assertIsNone(x)	x is None	book.price = None
assertIn(a, b)	a in b	assertIn(2, [1, 2, 3])
assertIsInstance(a, b)	isinstance(a, b)	assertIsInstance(123, int)