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 io
import re
import importlib
from contextlib import redirect_stdout

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

class TestInventoryProcessing(unittest.TestCase):
    def setUp(self):
        # reload and capture stdout
        self.f = io.StringIO()
        with redirect_stdout(self.f):
            import user_code
            importlib.reload(user_code)
        self.output = normalize_text(self.f.getvalue())
        import user_code as uc
        self.inventory = uc.inventory
        self.discount_threshold = uc.discount_threshold
        # store originals
        self.original = {
            "Bread": [30, 50, 10, False],
            "Eggs": [120, 200, 40, False],
            "Milk": [60, 100, 20, False],
            "Apples": [15, 50, 15, False]
        }

    def test_stock_meets_minimum(self):
        # 1. stock >= min required
        cond = all(self.inventory[item][0] >= self.inventory[item][1] for item in self.inventory)
        _dynamic_test(
            self,
            cond,
            "All items have stock >= minimum required",
            "Some items have stock below minimum required"
        )

    def test_stock_correct_restock_increment(self):
        # 2. stock == original + increments * n
        cond = True
        for item, vals in self.inventory.items():
            orig_stock, min_stock, restock_qty, _ = self.original[item]
            final_stock = vals[0]
            needed = max(0, min_stock - orig_stock)
            increments = (needed + restock_qty - 1) // restock_qty
            expected = orig_stock + increments * restock_qty
            if final_stock != expected:
                cond = False
                break
        _dynamic_test(
            self,
            cond,
            "Final stock equals original plus correct restock increments",
            f"Final stock not matching expected restock calculation for some item"
        )

    def test_sale_status_set_if_exceeds_threshold(self):
        # 3. if final stock > threshold and originally not on sale, sale must be True
        cond = True
        for item, vals in self.inventory.items():
            final_stock, _, _, on_sale = vals
            orig_on_sale = self.original[item][3]
            if final_stock > self.discount_threshold and not orig_on_sale:
                if not on_sale:
                    cond = False
                    break
        _dynamic_test(
            self,
            cond,
            "Sale status correctly set to True for items exceeding threshold",
            "Sale status not set for item exceeding threshold"
        )

    def test_sale_status_unchanged_if_not_exceeds(self):
        # 4. if final stock <= threshold, sale status unchanged
        cond = True
        for item, vals in self.inventory.items():
            final_stock, _, _, on_sale = vals
            orig_on_sale = self.original[item][3]
            if final_stock <= self.discount_threshold:
                if on_sale != orig_on_sale:
                    cond = False
                    break
        _dynamic_test(
            self,
            cond,
            "Sale status unchanged for items not exceeding threshold",
            "Sale status changed for item not exceeding threshold"
        )

    def test_print_final_inventory_report(self):
        # 5. print "Final Inventory Report"
        expected = normalize_text("Final Inventory Report")
        _dynamic_test(
            self,
            expected in self.output,
            "Printed 'Final Inventory Report'",
            "Did not print 'Final Inventory Report'"
        )

    def test_print_item_lines(self):
        # 6. print line "<Item>: <current_stock> units (Min: <min_stock> units) - On sale: <on_sale>"
        cond = True
        for item, vals in self.inventory.items():
            curr, min_s, _, on_sale = vals
            line = normalize_text(f"{item}: {curr} units (Min: {min_s} units) - On sale: {on_sale}")
            if line not in self.output:
                cond = False
                break
        _dynamic_test(
            self,
            cond,
            "Printed inventory line for each item",
            "Missing inventory line for one or more items"
        )

    def test_print_processing_messages(self):
        # 7. print "Processing <item>..." before each item
        cond = True
        for item in self.inventory:
            msg = normalize_text(f"Processing {item}...")
            if msg not in self.output:
                cond = False
                break
        _dynamic_test(
            self,
            cond,
            "Printed processing messages for each item",
            "Missing processing message for one or more items"
        )

    def test_discount_application_messages(self):
        # 8. discount messages for Eggs (exceeds threshold) and not on sale before
        # Eggs original 120 > 100
        applied = normalize_text("Eggs stock has exceeded 100 units. Discount applied.")
        already = normalize_text("Eggs is already discounted.")
        # Should have applied message and not the already discounted message
        cond = applied in self.output and already not in self.output
        _dynamic_test(
            self,
            cond,
            "Printed correct discount applied message for Eggs",
            "Discount message incorrect or missing for Eggs"
        )

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.

Python

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

Requirements checklist

解答