Interger_container_impl.py


import inspect
import os
import sys
from timeout_decorator import timeout
import unittest
from integer_container_impl import IntegerContainerImpl

# Adjust system path to import necessary modules from parent directory
current_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parent_dir = os.path.dirname(current_dir)
sys.path.insert(0, parent_dir)

class SandboxTests(unittest.TestCase):
    """
    Playground for custom tests. Modify, add, or delete tests as needed.
    These tests do not affect final scoring but help in developing and debugging the code.
    """
    
    @classmethod
    def setUpClass(cls):
        # Set up an instance of IntegerContainerImpl for all test cases
        cls.container = IntegerContainerImpl()
        
        
    def test_add_numbers(self):
        self.container.data.clear()
        result = self.container.add(5)
        self.assertEqual(result, 1, "Should return 1 after adding one number")
        print("Current container state after adding 5:", self.container.data) 
        
        result = self.container.add(10)
        self.assertEqual(result, 2, "Should return 2 after adding two numbers")
        print("Current container state after adding 10:", self.container.data)
        
        result = self.container.add(5)
        self.assertEqual(result, 3, "Should return 3 after adding another 5")
        print("Current container state after adding another 5:", self.container.data)

    # def test_delete_numbers(self):
    #     # Test deleting existing and non-existing numbers
    #     self.container.add(10)  # Setup by adding a number
    #     self.assertTrue(self.container.delete(10), "Should return True when deleting an existing number")
    #     self.assertFalse(self.container.delete(10), "Should return False when deleting a non-existent number")
        
    def test_delete_numbers(self):
        self.container.data.clear()
        self.container.add(10)
        self.assertTrue(self.container.delete(10), "Should return True when deleting an existing number")
        self.assertFalse(self.container.delete(10), "Should return False when deleting a non-existent number")

    def test_add_and_delete(self):
        # Test adding and then deleting numbers to check correctness
        self.container.add(1)
        self.container.add(2)
        self.assertTrue(self.container.delete(1), "Should be able to delete added number 1")
        self.assertFalse(self.container.delete(3), "Should return False when deleting a number not in the container")
        self.assertEqual(self.container.add(1), 2, "Should return 2 as the count after re-adding number 1")

interger_container.py

from integer_container import IntegerContainer

class IntegerContainerImpl(IntegerContainer):
    def __init__(self):
        # Initialize an empty list to hold the integers.
        self.data = []

    def add(self, value: int) -> int:
        # Add the specified integer `value` to the container
        self.data.append(value)
        # Return the number of integers in the container after the addition
        return len(self.data)

    def delete(self, value: int) -> bool:
        # Attempt to remove the specified integer `value` from the container
        if value in self.data:
            self.data.remove(value)
            # Return True if the value was present and removed
            return True
        # Return False if the value was not found
        return False

from abc import ABC

class IntegerContainer(ABC):
    """
    `IntegerContainer` interface.
    """

    def add(self, value: int) -> int:
        """
        Should add the specified integer `value` to the container
        and return the number of integers in the container after the
        addition.
        """
        # default implementation
        return 0

    def delete(self, value: int) -> bool:
        """
        Should attempt to remove the specified integer `value` from
        the container.
        If the `value` is present in the container, remove it and
        return `True`, otherwise, return `False`.
        """
        # default implementation
        return False

import inspect, os, sys
current_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parent_dir = os.path.dirname(current_dir)
sys.path.insert(0, parent_dir)

from timeout_decorator import timeout
import unittest
from integer_container_impl import IntegerContainerImpl

class Level1Tests(unittest.TestCase):
    """
    The test class below includes 10 tests for Level 1.

    All have the same score.
    You are not allowed to modify this file, but feel free to read the source code to better understand what is happening in every specific case.
    """

    failureException = Exception

    @classmethod
    def setUp(cls):
        cls.container = IntegerContainerImpl()

    @timeout(0.4)
    def test_level_1_case_01_add_two_numbers(self):
        self.assertEqual(self.container.add(10), 1)
        self.assertEqual(self.container.add(100), 2)

    @timeout(0.4)
    def test_level_1_case_02_add_many_numbers(self):
        self.assertEqual(self.container.add(10), 1)
        self.assertEqual(self.container.add(9), 2)
        self.assertEqual(self.container.add(8), 3)
        self.assertEqual(self.container.add(7), 4)
        self.assertEqual(self.container.add(6), 5)
        self.assertEqual(self.container.add(5), 6)
        self.assertEqual(self.container.add(4), 7)
        self.assertEqual(self.container.add(3), 8)
        self.assertEqual(self.container.add(2), 9)
        self.assertEqual(self.container.add(1), 10)

    @timeout(0.4)
    def test_level_1_case_03_delete_number(self):
        self.assertEqual(self.container.add(10), 1)
        self.assertEqual(self.container.add(100), 2)
        self.assertTrue(self.container.delete(10))

    @timeout(0.4)
    def test_level_1_case_04_delete_nonexisting_number(self):
        self.assertEqual(self.container.add(10), 1)
        self.assertEqual(self.container.add(100), 2)
        self.assertFalse(self.container.delete(20))
        self.assertTrue(self.container.delete(10))
        self.assertFalse(self.container.delete(10))

    @timeout(0.4)
    def test_level_1_case_05_add_and_delete_same_numbers(self):
        self.assertEqual(self.container.add(10), 1)
        self.assertEqual(self.container.add(10), 2)
        self.assertEqual(self.container.add(10), 3)
        self.assertEqual(self.container.add(10), 4)
        self.assertEqual(self.container.add(10), 5)
        self.assertTrue(self.container.delete(10))
        self.assertTrue(self.container.delete(10))
        self.assertTrue(self.container.delete(10))
        self.assertTrue(self.container.delete(10))
        self.assertTrue(self.container.delete(10))
        self.assertFalse(self.container.delete(10))
        self.assertFalse(self.container.delete(10))

    @timeout(0.4)
    def test_level_1_case_06_add_delete_several_times(self):
        self.assertEqual(self.container.add(555), 1)
        self.assertTrue(self.container.delete(555))
        self.assertFalse(self.container.delete(555))
        self.assertEqual(self.container.add(555), 1)
        self.assertTrue(self.container.delete(555))
        self.assertFalse(self.container.delete(555))

    @timeout(0.4)
    def test_level_1_case_07_delete_in_random_order(self):
        self.assertEqual(self.container.add(10), 1)
        self.assertEqual(self.container.add(20), 2)
        self.assertEqual(self.container.add(30), 3)
        self.assertEqual(self.container.add(40), 4)
        self.assertEqual(self.container.add(40), 5)
        self.assertTrue(self.container.delete(30))
        self.assertFalse(self.container.delete(30))
        self.assertTrue(self.container.delete(10))
        self.assertFalse(self.container.delete(10))
        self.assertTrue(self.container.delete(40))
        self.assertTrue(self.container.delete(40))
        self.assertFalse(self.container.delete(40))
        self.assertTrue(self.container.delete(20))
        self.assertFalse(self.container.delete(20))

    @timeout(0.4)
    def test_level_1_case_08_delete_before_add(self):
        self.assertFalse(self.container.delete(1))
        self.assertFalse(self.container.delete(2))
        self.assertFalse(self.container.delete(3))
        self.assertEqual(self.container.add(1), 1)
        self.assertEqual(self.container.add(2), 2)
        self.assertEqual(self.container.add(3), 3)
        self.assertTrue(self.container.delete(3))
        self.assertTrue(self.container.delete(2))
        self.assertTrue(self.container.delete(1))
        self.assertFalse(self.container.delete(3))
        self.assertFalse(self.container.delete(2))
        self.assertFalse(self.container.delete(1))

    @timeout(0.4)
    def test_level_1_case_09_mixed_operation_1(self):
        self.assertEqual(self.container.add(10), 1)
        self.assertEqual(self.container.add(15), 2)
        self.assertEqual(self.container.add(20), 3)
        self.assertEqual(self.container.add(10), 4)
        self.assertEqual(self.container.add(5), 5)
        self.assertTrue(self.container.delete(15))
        self.assertTrue(self.container.delete(20))
        self.assertFalse(self.container.delete(20))
        self.assertFalse(self.container.delete(0))
        self.assertEqual(self.container.add(7), 4)
        self.assertEqual(self.container.add(9), 5)
        self.assertTrue(self.container.delete(7))
        self.assertTrue(self.container.delete(10))
        self.assertTrue(self.container.delete(10))
        self.assertFalse(self.container.delete(10))
        self.assertFalse(self.container.delete(100))

    @timeout(0.4)
    def test_level_1_case_10_mixed_operation_2(self):
        self.assertFalse(self.container.delete(6))
        self.assertEqual(self.container.add(100), 1)
        self.assertFalse(self.container.delete(200))
        self.assertEqual(self.container.add(500), 2)
        self.assertFalse(self.container.delete(0))
        self.assertEqual(self.container.add(300), 3)
        self.assertFalse(self.container.delete(1000))
        self.assertEqual(self.container.add(400), 4)
        self.assertTrue(self.container.delete(300))
        self.assertTrue(self.container.delete(400))
        self.assertTrue(self.container.delete(100))
        self.assertTrue(self.container.delete(500))
        self.assertEqual(self.container.add(1000), 1)
        self.assertEqual(self.container.add(100), 2)
        self.assertEqual(self.container.add(10), 3)
        self.assertEqual(self.container.add(1), 4)
        self.assertTrue(self.container.delete(100))
        self.assertFalse(self.container.delete(500))
        self.assertFalse(self.container.delete(300))
        self.assertFalse(self.container.delete(400))