diskcache/modified_testcases/test_index.py

"""Test diskcache.persistent.Index."""

import pickle
import shutil
import tempfile
import unittest

import main  # Assuming 'main' is the name of the module where Index is defined


def rmdir(directory):
    try:
        shutil.rmtree(directory)
    except OSError:
        pass


class TestIndex(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.directory = tempfile.mkdtemp()

    @classmethod
    def tearDownClass(cls):
        rmdir(cls.directory)

    def setUp(self):
        self.index = main.Index(self.directory)  # Use the Index class from main.py

    def tearDown(self):
        rmdir(self.index.directory)

    def test_init(self):
        mapping = {'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1}
        index = main.Index(None, mapping)

        self.assertEqual(index, mapping)

        rmdir(index.directory)
        del index

        index = main.Index(self.directory, mapping)

        self.assertEqual(index.directory, self.directory)
        self.assertEqual(index, mapping)

        other = main.Index(self.directory)

        self.assertEqual(other, index)

        del index
        del other
        rmdir(self.directory)
        index = main.Index(self.directory, mapping.items())

        self.assertEqual(index, mapping)

        del index
        rmdir(self.directory)
        index = main.Index(self.directory, a=5, b=4, c=3, d=2, e=1)

        self.assertEqual(index, mapping)

    def test_getsetdel(self):
        letters = 'abcde'
        self.assertEqual(len(self.index), 0)

        for num, key in enumerate(letters):
            self.index[key] = num

        for num, key in enumerate(letters):
            self.assertEqual(self.index[key], num)

        for key in letters:
            del self.index[key]

        self.assertEqual(len(self.index), 0)

    def test_pop(self):
        letters = 'abcde'
        self.assertEqual(len(self.index), 0)

        for num, key in enumerate(letters):
            self.index[key] = num

        self.assertEqual(self.index.pop('a'), 0)
        self.assertEqual(self.index.pop('c'), 2)
        self.assertEqual(self.index.pop('e'), 4)
        self.assertEqual(self.index.pop('b'), 1)
        self.assertEqual(self.index.pop('d'), 3)
        self.assertEqual(len(self.index), 0)

    def test_pop_keyerror(self):
        with self.assertRaises(KeyError):
            self.index.pop('a')

    def test_popitem(self):
        letters = 'abcde'

        for num, key in enumerate(letters):
            self.index[key] = num

        self.assertEqual(self.index.popitem(), ('e', 4))
        self.assertEqual(self.index.popitem(last=True), ('d', 3))
        self.assertEqual(self.index.popitem(last=False), ('a', 0))
        self.assertEqual(len(self.index), 2)

    def test_popitem_keyerror(self):
        with self.assertRaises(KeyError):
            self.index.popitem()

    def test_setdefault(self):
        self.assertEqual(self.index.setdefault('a', 0), 0)
        self.assertEqual(self.index.setdefault('a', 1), 0)

    def test_iter(self):
        letters = 'abcde'

        for num, key in enumerate(letters):
            self.index[key] = num

        for num, key in enumerate(self.index):
            self.assertEqual(self.index[key], num)

    def test_reversed(self):
        letters = 'abcde'

        for num, key in enumerate(letters):
            self.index[key] = num

        for num, key in enumerate(reversed(self.index)):
            self.assertEqual(self.index[key], (len(letters) - num - 1))

    def test_state(self):
        mapping = {'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1}
        self.index.update(mapping)
        self.assertEqual(self.index, mapping)
        state = pickle.dumps(self.index)
        values = pickle.loads(state)
        self.assertEqual(values, mapping)

    def test_memoize(self):
        count = 1000

        def fibiter(num):
            alpha, beta = 0, 1

            for _ in range(num):
                alpha, beta = beta, alpha + beta

            return alpha

        @self.index.memoize()
        def fibrec(num):
            if num == 0:
                return 0
            elif num == 1:
                return 1
            else:
                return fibrec(num - 1) + fibrec(num - 2)

        self.index._cache.stats(enable=True)

        for value in range(count):
            self.assertEqual(fibrec(value), fibiter(value))

        hits1, misses1 = self.index._cache.stats()

        for value in range(count):
            self.assertEqual(fibrec(value), fibiter(value))

        hits2, misses2 = self.index._cache.stats()

        self.assertEqual(hits2, hits1 + count)
        self.assertEqual(misses2, misses1)

    def test_repr(self):
        self.assertTrue(repr(self.index).startswith('Index('))


if __name__ == '__main__':
    unittest.main()