Voortbouwend op je kennis van bestandsbewerkingen en contextmanagers ga je nu een oplossing implementeren op basis van een contextmanager om inhoud van het ene bestand naar het andere te kopiëren. Deze uitdaging benadrukt het belang van veilig resourcebeheer – met name het garanderen dat zowel het bron- als het doelbestand altijd correct worden gesloten, zelfs als er tijdens het kopiëren een fout optreedt. Je gebruikt `with`-statements om bestanden automatisch te openen en te sluiten, waarbij je de lees- en schrijftechnieken toepast die in eerdere hoofdstukken zijn behandeld.

import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import os

class TestTask(unittest.TestCase):
    def setUp(self):
        # Prepare a simple binary file for copying
        self.source_file = 'test_source.bin'
        self.dest_file = 'test_dest.bin'
        self.content = b'Hello, file copy!' + bytes([0, 1, 2])
        with open(self.source_file, 'wb') as f:
            f.write(self.content)
        # Clean up destination file if it exists
        if os.path.exists(self.dest_file):
            os.remove(self.dest_file)

    def tearDown(self):
        if os.path.exists(self.source_file):
            os.remove(self.source_file)
        if os.path.exists(self.dest_file):
            os.remove(self.dest_file)

    def test_copy_file_copies_content(self):
        import user_code
        importlib.reload(user_code)
        user_code.copy_file(self.source_file, self.dest_file)
        _dynamic_test(
            self,
            os.path.exists(self.dest_file),
            "Destination file was created successfully.",
            "Destination file was not created as expected.",
        )
        with open(self.dest_file, 'rb') as f:
            copied = f.read()
        _dynamic_test(
            self,
            copied == self.content,
            "File content was copied correctly.",
            f"Expected content: {self.content}, got: {copied}",
        )

    def test_copy_file_overwrites_existing(self):
        import user_code
        importlib.reload(user_code)
        # Write different content to destination first
        with open(self.dest_file, 'wb') as f:
            f.write(b'old content')
        user_code.copy_file(self.source_file, self.dest_file)
        with open(self.dest_file, 'rb') as f:
            copied = f.read()
        _dynamic_test(
            self,
            copied == self.content,
            "Destination file was overwritten with correct content.",
            f"Expected overwritten content: {self.content}, got: {copied}",
        )

    def test_copy_file_empty_source(self):
        import user_code
        importlib.reload(user_code)
        # Empty the source file
        with open(self.source_file, 'wb') as f:
            pass
        user_code.copy_file(self.source_file, self.dest_file)
        with open(self.dest_file, 'rb') as f:
            copied = f.read()
        _dynamic_test(
            self,
            copied == b'',
            "Empty source file results in empty destination file.",
            f"Expected empty file, got: {copied}",
        )

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()


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

test_main.py

Je verwerft praktische vaardigheden in het gebruik van Python-modules en imports voor efficiënt codebeheer. Beheers geavanceerde foutafhandelings­technieken voor betrouwbaardere applicaties, automatiseer bestandsbewerkingen met bestandsafhandeling en leer robuuste teststrategieën met Pytest en Unittest om de integriteit van je code te waarborgen.

Master Python's exception system for robust error handling and debugging.

Explore advanced techniques for file operations and resource management using context managers.

Compare and apply Python's multithreading and multiprocessing modules for concurrent programming.

Master asynchronous programming in Python using the asyncio library for scalable I/O-bound applications.

Explore how to write, organize, and run tests using Python's unittest and pytest frameworks.

Uitdaging: Implementeer een Contextmanager voor het Kopiëren van Bestanden

Oplossing