Your grocery store's system is designed to track the inventory of items on different shelves using **tuples**, as tuples provide a way to ensure the data is **immutable** once set. 

However, the store needs to **monitor certain items** and track their quantities or positions to assist in restocking or rearranging.

You are tasked with analyzing and managing inventory data using tuples to determine certain metrics and take actions based on specific criteria.

import unittest
import importlib
import io
import re
from contextlib import redirect_stdout
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 TestFruitShelfTuple(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_apple_count(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'apple_count') and user_code.apple_count == 3,
            "apple_count is correct (3)",
            f"Expected apple_count to be 3, got {getattr(user_code, 'apple_count', None)}"
        )

    def test_banana_index(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'banana_index') and user_code.banana_index == 2,
            "banana_index is correct (2)",
            f"Expected banana_index to be 2, got {getattr(user_code, 'banana_index', None)}"
        )

    def test_grape_count_logic(self):
        importlib.reload(user_code)
        grape_count = user_code.shelf.count("grapes")
        _dynamic_test(
            self,
            grape_count == 1,
            "grape_count is correct and equals 1",
            f"Expected grape count to be 1, got {grape_count}"
        )

    def test_oranges_in_shelf(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            "oranges" in user_code.shelf,
            "'oranges' is present in shelf",
            "'oranges' expected in shelf, but not found"
        )

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

        expected_fragments = [
            self.normalize_text("Number of Apples: 3"),
            self.normalize_text("First Banana Index: 2"),
            self.normalize_text("Apples need to be restocked."),
            self.normalize_text("Grapes need to be restocked."),
            self.normalize_text("Oranges are at index: 1"),
        ]

        for expected in expected_fragments:
            _dynamic_test(
                self,
                expected in output,
                f"Output includes: {expected}",
                f"Expected output to include '{expected}', but got: '{output}'"
            )

    def test_in_operator_used(self):
        source = strip_comments_from_source(user_code)
        found = re.search(r'\s+in\s+', source)
        _dynamic_test(
            self,
            found is not None,
            "'in' operator is used to check for 'oranges'",
            "Expected use of 'in' to check for 'oranges'"
        )


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!

How can you access the third element in this list?

How would you change "green" to "yellow"?

Challenge: Tuple Operations

解答