import unittest

from byteb4rb1e_utils.string import (
    ChunkedRollingHash,
    ChunkedRollingHashOptions,
    RollingHash,
)

class test___init__(unittest.TestCase):
    """ChunkedRollingHash.__init__()"""
    def test_default(self):
        """default options"""
        result = ChunkedRollingHash(b'abcdefgh')

        self.assertEqual(result._mod, ChunkedRollingHashOptions.mod)
        self.assertEqual(result._base, ChunkedRollingHashOptions.base)
        self.assertEqual(result._max_chunk_size, ChunkedRollingHashOptions.max_chunk_size)

        control_hash = RollingHash.compute_initial_hash(
            b'abcdefgh',
            base = result._base,
            mod = result._mod
        )

        self.assertEqual(result._length, 8)
        self.assertEqual(result._chunk_count, 1)
        self.assertEqual(len(result._chunks_hash), result._chunk_count)
        self.assertEqual(result._hash, control_hash)
        self.assertEqual(result._chunks_hash[0], control_hash)

    def test_override(self):
        """override of options"""
        options = ChunkedRollingHashOptions(
            mod = 4,
            base = 10,
            max_chunk_size = 5,
        )
        result = ChunkedRollingHash(b'abcdefgh', options)

        self.assertEqual(result._mod, options.mod)
        self.assertEqual(result._base, options.base)
        self.assertEqual(result._max_chunk_size, options.max_chunk_size)

        control_hash1 = RollingHash.compute_initial_hash(
            b'abcde',
            base = result._base,
            mod = result._mod
        )
        control_hash2 = RollingHash.compute_initial_hash(
            b'fgh',
            base = result._base,
            mod = result._mod
        )

        self.assertEqual(result._chunks_hash[0], control_hash1)
        self.assertEqual(result._chunks_hash[1], control_hash2)