Ready to put everything you've learned into **practice**? This challenge will require you to use the `and`, `or`, and `not` **operators** as well as **boolean comparison operators** to manage a complex scenario for a grocery store. 

Let's dive in!


import unittest
import importlib
import io
import re
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 TestUserCode(unittest.TestCase):
    def test_overstock_risk_logic(self):
        import user_code
        importlib.reload(user_code)
        # Check attribute exists and is bool
        val = getattr(user_code, 'overstock_risk', None)
        condition = isinstance(val, bool) and val is True
        _dynamic_test(
            self,
            condition,
            "overstock_risk correctly True when seasonal and stock high",
            f"Expected overstock_risk to be True, got {val}"
        )

    def test_discount_eligible_logic(self):
        import user_code
        importlib.reload(user_code)
        val = getattr(user_code, 'discount_eligible', None)
        condition = isinstance(val, bool) and val is True
        _dynamic_test(
            self,
            condition,
            "discount_eligible correctly True when not selling and not on sale",
            f"Expected discount_eligible to be True, got {val}"
        )

    def test_make_discount_logic(self):
        import user_code
        importlib.reload(user_code)
        val = getattr(user_code, 'make_discount', None)
        condition = isinstance(val, bool) and val is True
        _dynamic_test(
            self,
            condition,
            "make_discount correctly True when overstock_risk or discount_eligible True",
            f"Expected make_discount to be True, got {val}"
        )

    def test_output_contains_make_discount(self):
        # Capture stdout
        with open("user_code.py", "r") as f:
            code = f.read()
        fbuf = io.StringIO()
        with redirect_stdout(fbuf):
            exec(code, {})
        output = normalize_text(fbuf.getvalue())
        expected_phrase = normalize_text("Should the item be discounted?")
        make_discount_val = "true"  # normalized form
        condition = expected_phrase in output and make_discount_val in output
        _dynamic_test(
            self,
            condition,
            "Printed output includes prompt and make_discount value",
            f"Output missing prompt or value. Got: '{output}'"
        )

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: Boolean Logic

Output Requirements

Requirements checklist

解答