Building on your knowledge of file operations and context managers, you will now implement a context manager-based solution to copy content from one file to another. This challenge reinforces the importance of managing resources safely - particularly ensuring that both the source and destination files are always closed properly, even if an error occurs during copying. You will use `with` statements to open and close files automatically, applying the file reading and writing techniques covered in previous chapters.

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

A deep dive into advanced structural programming concepts in Python, focusing on robust file handling, error management, concurrency, asynchronous programming and testing.

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.

Challenge: Implement a File Copy Context Manager

Solution