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
from contextlib import redirect_stdout
import re
import inspect
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.strip()
            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 TestMakeDiscountLogic(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_overstockRisk_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'overstock_risk') and user_code.overstock_risk is True,
            "overstock_risk is correctly set to True",
            f"Expected overstock_risk to be True, got {getattr(user_code, 'overstock_risk', None)}"
        )

    def test_discountEligible_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'discount_eligible') and user_code.discount_eligible is True,
            "discount_eligible is correctly set to True",
            f"Expected discount_eligible to be True, got {getattr(user_code, 'discount_eligible', None)}"
        )

    def test_makeDiscount_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'make_discount') and user_code.make_discount is True,
            "make_discount is correctly set to True",
            f"Expected make_discount to be True, got {getattr(user_code, 'make_discount', None)}"
        )

    def test_print_output(self):
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = self.normalize_text(f.getvalue())
        expected = self.normalize_text("Should the item be discounted? True")
        _dynamic_test(
            self,
            expected in output,
            "Print output is correct",
            f"Expected output to include: '{expected}', got: '{output}'"
        )

    def test_or_operator_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'\s+or\s+', source) is not None,
            "'or' operator is used in the code",
            "Expected use of 'or' logical operator"
        )

    def test_and_operator_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'\s+and\s+', source) is not None,
            "'and' operator is used in the code",
            "Expected use of 'and' logical operator"
        )

    def test_not_operator_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'\s+not\s+', source) is not None,
            "'not' operator is used in the code",
            "Expected use of 'not' logical operator"
        )


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

Output Requirements

Oplossing

Challenge: Boolean Logic

Output Requirements

Oplossing