Great job mastering **variables**, **data types**, **slicing**, and **concatenation**! 

Now, let's apply your new skills to a realistic scenario involving organizing new grocery store inventory.

import unittest
import importlib

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):
    import re
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

class TestSlicingAndPrices(unittest.TestCase):

    def test_candy1_substring(self):
        import user_code
        importlib.reload(user_code)
        candy1 = getattr(user_code, 'candy1', None)
        expected = "Bubblegum"
        _dynamic_test(
            self,
            candy1 == expected,
            "candy1 correctly sliced to 'Bubblegum'",
            f"Expected candy1 to be '{expected}', got '{candy1}'"
        )

    def test_candy2_substring(self):
        import user_code
        importlib.reload(user_code)
        candy2 = getattr(user_code, 'candy2', None)
        expected = "Chocolate"
        _dynamic_test(
            self,
            candy2 == expected,
            "candy2 correctly sliced to 'Chocolate'",
            f"Expected candy2 to be '{expected}', got '{candy2}'"
        )

    def test_dry_goods_substring(self):
        import user_code
        importlib.reload(user_code)
        dry_goods = getattr(user_code, 'dry_goods', None)
        expected = "Pasta"
        _dynamic_test(
            self,
            dry_goods == expected,
            "dry_goods correctly sliced to 'Pasta'",
            f"Expected dry_goods to be '{expected}', got '{dry_goods}'"
        )

    def test_category1_substring(self):
        import user_code
        importlib.reload(user_code)
        category1 = getattr(user_code, 'category1', None)
        expected = "Candy Aisle"
        _dynamic_test(
            self,
            category1 == expected,
            "category1 correctly sliced to 'Candy Aisle'",
            f"Expected category1 to be '{expected}', got '{category1}'"
        )

    def test_category2_substring(self):
        import user_code
        importlib.reload(user_code)
        category2 = getattr(user_code, 'category2', None)
        expected = "Pasta Aisle"
        _dynamic_test(
            self,
            category2 == expected,
            "category2 correctly sliced to 'Pasta Aisle'",
            f"Expected category2 to be '{expected}', got '{category2}'"
        )

    def test_bubblegum_price_value(self):
        import user_code
        importlib.reload(user_code)
        bubblegum_price = getattr(user_code, 'bubblegum_price', None)
        expected = "$1.50"
        _dynamic_test(
            self,
            bubblegum_price == expected,
            "bubblegum_price correctly set to '$1.50'",
            f"Expected bubblegum_price to be '{expected}', got '{bubblegum_price}'"
        )

    def test_chocolate_price_value(self):
        import user_code
        importlib.reload(user_code)
        chocolate_price = getattr(user_code, 'chocolate_price', None)
        expected = "$2.00"
        _dynamic_test(
            self,
            chocolate_price == expected,
            "chocolate_price correctly set to '$2.00'",
            f"Expected chocolate_price to be '{expected}', got '{chocolate_price}'"
        )

    def test_pasta_price_value(self):
        import user_code
        importlib.reload(user_code)
        pasta_price = getattr(user_code, 'pasta_price', None)
        expected = "$5.40"
        _dynamic_test(
            self,
            pasta_price == expected,
            "pasta_price correctly set to '$5.40'",
            f"Expected pasta_price to be '{expected}', got '{pasta_price}'"
        )

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!

Which of these is a correct way to create a variable?

Given the string `"Banana"`, which code retrieves its first character?

What will be the output of the following code?

Challenge: Inventory Sorting Capstone

Output Requirements

Requirements checklist

Solution