You are managing the inventory for a grocery store, and your task is to ensure that the stock for each product is properly maintained and restocked when necessary. 

If an item's stock level **falls below the minimum required amount**, it needs to be restocked.

Additionally, if the stock level of an item **exceeds a certain threshold**, a discount is applied, and the item is marked as "on sale."

import unittest
import importlib
import io
import re
import inspect
from contextlib import redirect_stdout
import user_code


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 strip_comments_from_source(module):
    try:
        source = inspect.getsource(module)
        lines = source.split('\\n')
        cleaned = []
        for line in lines:
            stripped = line.rstrip()
            if stripped.startswith('#'):
                continue
            if '#' in line:
                line = line.split('#')[0]
            if line.strip():
                cleaned.append(line)
        return '\\n'.join(cleaned)
    except Exception:
        return ""


class TestInventoryDiscountRestock(unittest.TestCase):

    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        text = re.sub(r'\s*([,:?\[\]\(\)])\s*', r'\1', text)
        return text.strip()


    def test_bread_stock_and_sale_status(self):
        importlib.reload(user_code)
        item = user_code.inventory["Bread"]
        _dynamic_test(
            self,
            item[0] == 50 and item[3] is False,
            "Bread stock updated to 50 and not on sale",
            f"Expected Bread to have 50 units and not be on sale, got {item}"
        )

    def test_eggs_stock_and_sale_status(self):
        importlib.reload(user_code)
        item = user_code.inventory["Eggs"]
        _dynamic_test(
            self,
            item[0] == 200 and item[3] is True,
            "Eggs stock updated to 200 and on sale",
            f"Expected Eggs to have 200 units and be on sale, got {item}"
        )

    def test_milk_stock_and_sale_status(self):
        importlib.reload(user_code)
        item = user_code.inventory["Milk"]
        _dynamic_test(
            self,
            item[0] == 100 and item[3] is False,
            "Milk stock updated to 100 and not on sale",
            f"Expected Milk to have 100 units and not be on sale, got {item}"
        )

    def test_apples_stock_and_sale_status(self):
        importlib.reload(user_code)
        item = user_code.inventory["Apples"]
        _dynamic_test(
            self,
            item[0] == 60 and item[3] is False,
            "Apples stock updated to 60 and not on sale",
            f"Expected Apples to have 60 units and not be on sale, got {item}"
        )


    def test_output_content(self):
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = self.normalize_text(f.getvalue())

        expected_lines = [
            "Processing Bread...",
            "Processing Eggs...",
            "Eggs stock has exceeded 100 units. Discount applied.",
            "Processing Milk...",
            "Processing Apples...",
            "Final Inventory Report",
            "Bread: 50 units (Min: 50 units) - On sale: False",
            "Eggs: 200 units (Min: 200 units) - On sale: True",
            "Milk: 100 units (Min: 100 units) - On sale: False",
            "Apples: 60 units (Min: 50 units) - On sale: False"
        ]

        for line in expected_lines:
            expected = self.normalize_text(line)
            _dynamic_test(
                self,
                expected in output,
                f"Output includes line: {line}",
                f"Expected output: '{line}' not found."
            )


    def test_for_loop_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'for', source),
            "'for' loop is used in the code",
            "Expected use of 'for' loop in the code"
        )

    def test_while_loop_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'while', source),
            "'while' loop is used in the code",
            "Expected use of 'while' loop in the code"
        )


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

test_main.py

Python is a high-level, interpreted, general-purpose programming
language. Distinguished from languages such as HTML, CSS, and JavaScript, which are mainly
utilized in web development, Python boasts versatility across multiple domains, including
software development, data science, and back-end development. This course will guide you
through Python's fundamental concepts, equipping you with the skills to create your own
functions by the conclusion of the program.

In this section, you will explore the fundamentals of Python, get acquainted
with your workspace, perform simple math operations, and display your findings.

In this section, you'll discover how to save items such as numbers and text
in computer memory and retrieve them by name. Additionally, you'll gain an introduction to text
manipulation in Python.

In this section, you'll explore the boolean data type and learn how it is used
to develop programs that react to certain conditions.

In this section, you will continue learning about data types and discover
how to organize various attributes in a single variable using lists, tuples, and dictionaries.

In this section, you'll learn how to create loops in Python — an essential skill
for iterating through lists, tuples, and dictionaries.

To conclude this introductory course, you will explore some built-in
functions and then begin to develop your own!

Challenge: Automating Stock Control

Output Requirements

解答