from unittest import TestCase
from utils.memory_cell import MemoryCell
from utils.literal import Literal
import random


class TestMemoryCell(TestCase):

    def test_create_cell(self):
        v = random.randint(1, 100)
        cell = MemoryCell(v)
        self.assertEqual(cell.value, v)
        self.assertEqual(cell.read_count, 0)
        self.assertEqual(cell.write_count, 1)
        self.assertEqual(cell.add_count, 0)
        self.assertEqual(cell.sub_count, 0)
        self.assertEqual(cell.mul_count, 0)
        self.assertEqual(cell.div_count, 0)
        self.assertEqual(cell.bitop_count, 0)

    def test_cast_cell(self):
        v = random.randint(1, 100)
        cell = MemoryCell(v)
        self.assertEqual(int(cell), v)
        self.assertEqual(cell.read_count, 1)
        self.assertEqual(cell.write_count, 1)
        self.assertEqual(cell.add_count, 0)
        self.assertEqual(cell.sub_count, 0)
        self.assertEqual(cell.mul_count, 0)
        self.assertEqual(cell.div_count, 0)
        self.assertEqual(cell.bitop_count, 0)

    def test_add(self):
        v1 = random.randint(1, 100)
        v2 = random.randint(1, 100)

        # "in place" Addition zweier MemoryCells
        cell1 = MemoryCell(v1)
        cell2 = MemoryCell(v2)
        cell1 += cell2
        self.assertEqual(cell1.value, v1 + v2)
        self.assertEqual(cell1.add_count, 1)
        self.assertEqual(cell1.read_count, 1)
        self.assertEqual(cell2.read_count, 1)
        self.assertTrue(isinstance(cell1, MemoryCell))
        self.assertTrue(isinstance(cell2, MemoryCell))

        # Freie Addition zweier MemoryCells
        cell1 = MemoryCell(v1)
        cell2 = MemoryCell(v2)
        result = cell1 + cell2

        self.assertEqual(result.value, v1 + v2)
        self.assertEqual(cell1.add_count, 1)
        self.assertEqual(cell1.read_count, 1)
        self.assertEqual(cell2.read_count, 1)
        self.assertTrue(isinstance(result, Literal))

    def test_sub(self):
        v1 = random.randint(1, 100)
        v2 = random.randint(1, 100)

        # "in place" Subtraktion zweier MemoryCells
        cell1 = MemoryCell(v1)
        cell2 = MemoryCell(v2)
        cell1 -= cell2

        self.assertEqual(cell1.value, v1 - v2)
        self.assertEqual(cell1.sub_count, 1)
        self.assertEqual(cell1.read_count, 1)
        self.assertEqual(cell2.read_count, 1)
        self.assertTrue(isinstance(cell1, MemoryCell))
        self.assertTrue(isinstance(cell2, MemoryCell))

        # Freie Subtraktion zweier MemoryCells
        cell1 = MemoryCell(v1)
        cell2 = MemoryCell(v2)
        result = cell1 - cell2
        self.assertEqual(result.value, v1 - v2)
        self.assertEqual(cell1.sub_count, 1)
        self.assertEqual(cell1.read_count, 1)
        self.assertEqual(cell2.read_count, 1)
        self.assertTrue(isinstance(result, Literal))

    def test_mul(self):
        v1 = random.randint(1, 100)
        v2 = random.randint(1, 100)

        # "in place" Multiplikation zweier MemoryCells
        cell1 = MemoryCell(v1)
        cell2 = MemoryCell(v2)
        cell1 *= cell2

        self.assertEqual(cell1.value, v1 * v2)
        self.assertEqual(cell1.mul_count, 1)
        self.assertEqual(cell1.read_count, 1)
        self.assertEqual(cell2.read_count, 1)
        self.assertTrue(isinstance(cell1, MemoryCell))
        self.assertTrue(isinstance(cell2, MemoryCell))

        # Freie Multiplikation zweier MemoryCells
        cell1 = MemoryCell(v1)
        cell2 = MemoryCell(v2)
        result = cell1 * cell2
        self.assertEqual(result.value, v1 * v2)
        self.assertEqual(cell1.mul_count, 1)
        self.assertEqual(cell1.read_count, 1)
        self.assertEqual(cell2.read_count, 1)
        self.assertTrue(isinstance(result, Literal))

    def test_div(self):
        v1 = random.randint(1, 100)
        v2 = random.randint(1, 100)

        # "in place" Division zweier MemoryCells
        cell1 = MemoryCell(v1)
        cell2 = MemoryCell(v2)
        cell1 //= cell2

        self.assertEqual(cell1.value, v1 // v2)
        self.assertEqual(cell1.div_count, 1)
        self.assertEqual(cell1.read_count, 1)
        self.assertEqual(cell2.read_count, 1)
        self.assertTrue(isinstance(cell1, MemoryCell))
        self.assertTrue(isinstance(cell2, MemoryCell))

        # Freie Division zweier MemoryCells
        cell1 = MemoryCell(v1)
        cell2 = MemoryCell(v2)
        result = cell1 // cell2
        self.assertEqual(result.value, v1 // v2)
        self.assertEqual(cell1.div_count, 1)
        self.assertEqual(cell1.read_count, 1)
        self.assertEqual(cell2.read_count, 1)
        self.assertTrue(isinstance(result, Literal))

    def test_reset_counters(self):
        v1 = random.randint(1, 100)
        v2 = random.randint(1, 100)
        cell = MemoryCell(v1)
        cell += Literal(v2)

        self.assertEqual(cell.value, v1+v2)
        self.assertEqual(cell.read_count, 1)
        self.assertEqual(cell.add_count, 1)
        self.assertEqual(cell.write_count, 2)

        cell.reset_counters()

        self.assertEqual(cell.value, v1+v2)
        self.assertEqual(cell.read_count, 0)
        self.assertEqual(cell.add_count, 0)
        self.assertEqual(cell.write_count, 0)


    def test_set(self):
        v1 = random.randint(1, 100)
        v2 = random.randint(1, 100)

        cell = MemoryCell(v1)
        cell.set(v2)

        self.assertEqual(cell.value, v2)
        self.assertEqual(cell.read_count, 0)
        self.assertEqual(cell.write_count, 2)