#!/usr/bin/env python3
# Copyright 2022 The Pigweed Authors
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations under
# the License.
"""Tests the tokenized string decode module."""

from datetime import datetime
import math
import unittest

import tokenized_string_decoding_test_data as tokenized_string
import varint_test_data
from pw_tokenizer import decode
from pw_tokenizer import encode


def error(msg, value=None) -> str:
    """Formats msg as the message for an argument that failed to parse."""
    if value is None:
        return '<[{}]>'.format(msg)
    return '<[{} ({})]>'.format(msg, value)


class TestDecodeTokenized(unittest.TestCase):
    """Tests decoding tokenized strings with various arguments."""

    def test_decode_generated_data(self) -> None:
        self.assertGreater(len(tokenized_string.TEST_DATA), 100)

        for fmt, decoded, encoded in tokenized_string.TEST_DATA:
            self.assertEqual(decode.decode(fmt, encoded, True), decoded)

    def test_unicode_decode_errors(self) -> None:
        """Tests unicode errors, which do not occur in the C++ decoding code."""
        self.assertEqual(
            decode.decode('Why, %c', b'\x01', True),
            'Why, ' + error('%c ERROR', -1),
        )

        self.assertEqual(
            decode.decode('%sXY%+ldxy%u', b'\x83N\x80!\x01\x02', True),
            '{}XY{}xy{}'.format(
                error('%s ERROR', "'N\\x80!'"),
                error('%+ld SKIPPED', -1),
                error('%u SKIPPED', 1),
            ),
        )

        self.assertEqual(
            decode.decode('%s%lld%9u', b'\x82$\x80\x80', True),
            '{0}{1}{2}'.format(
                error("%s ERROR ('$\\x80')"),
                error('%lld SKIPPED'),
                error('%9u SKIPPED'),
            ),
        )

        self.assertEqual(
            decode.decode('%c', b'\xff\xff\xff\xff\x0f', True),
            error('%c ERROR', -2147483648),
        )

    def test_ignore_errors(self) -> None:
        self.assertEqual(decode.decode('Why, %c', b'\x01'), 'Why, %c')

        self.assertEqual(decode.decode('%s %d', b'\x01!'), '! %d')

    def test_pointer(self) -> None:
        """Tests pointer args, which are not natively supported in Python."""
        self.assertEqual(
            decode.decode('Hello: %p', b'\x00', True), 'Hello: 0x00000000'
        )
        self.assertEqual(
            decode.decode('%p%d%d', b'\x02\x80', True),
            '0x00000001<[%d ERROR]><[%d SKIPPED]>',
        )

    def test_nothing_printed_fails(self) -> None:
        result = decode.FormatString('%n').format(b'')
        self.assertFalse(result.ok())


class TestPercentLiteralDecoding(unittest.TestCase):
    """Tests decoding the %-literal in various invalid situations."""

    def test_percent(self) -> None:
        result = decode.FormatString('%%').format(b'')
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '%')
        self.assertEqual(result.remaining, b'')

    def test_percent_with_leading_plus_fails(self) -> None:
        result = decode.FormatString('%+%').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

    def test_percent_with_leading_negative(self) -> None:
        result = decode.FormatString('%-%').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

    def test_percent_with_leading_space(self) -> None:
        result = decode.FormatString('% %').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

    def test_percent_with_leading_hashtag(self) -> None:
        result = decode.FormatString('%#%').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

    def test_percent_with_leading_zero(self) -> None:
        result = decode.FormatString('%0%').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

    def test_percent_with_length(self) -> None:
        """Test that all length prefixes fail to decode with %."""

        result = decode.FormatString('%hh%').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%h%').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%l%').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%ll%').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%L%').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%j%').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%z%').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%t%').format(b'')
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, b'')

    def test_percent_with_width(self):
        result = decode.FormatString('%9%').format(b'')
        self.assertFalse(result.ok())

    def test_percent_with_multidigit_width(self):
        result = decode.FormatString('%10%').format(b'')
        self.assertFalse(result.ok())

    def test_percent_with_star_width(self):
        result = decode.FormatString('%*%').format(b'')
        self.assertFalse(result.ok())

    def test_percent_with_precision(self):
        result = decode.FormatString('%.5%').format(b'')
        self.assertFalse(result.ok())

    def test_percent_with_multidigit_precision(self):
        result = decode.FormatString('%.10%').format(b'')
        self.assertFalse(result.ok())

    def test_percent_with_star_precision(self):
        result = decode.FormatString('%.*%').format(b'')
        self.assertFalse(result.ok())


# pylint: disable=too-many-public-methods
class TestIntegerDecoding(unittest.TestCase):
    """Tests decoding variable-length integers."""

    def test_signed_integer_d(self) -> None:
        result = decode.FormatString('%d').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_d_with_minus(self) -> None:
        result = decode.FormatString('%-5d').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '10   ')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_d_with_plus(self) -> None:
        result = decode.FormatString('%+d').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+10')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_d_with_blank_space(self) -> None:
        result = decode.FormatString('% d').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, ' 10')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_d_with_plus_and_blank_space_ignores_blank_space(
        self,
    ) -> None:
        result = decode.FormatString('%+ d').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('% +d').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+10')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_d_with_hashtag(self) -> None:
        result = decode.FormatString('%#d').format(encode.encode_args(10))
        self.assertFalse(result.ok())

    def test_signed_integer_d_with_zero(self) -> None:
        result = decode.FormatString('%05d').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '00010')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_d_with_length(self) -> None:
        """Tests that length modifiers do not affect signed integer decoding."""
        result = decode.FormatString('%hhd').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%hd').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%ld').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lld').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%jd').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zd').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%td').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_d_with_width(self) -> None:
        result = decode.FormatString('%5d').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '  -10')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_d_with_width_and_0_flag(self) -> None:
        result = decode.FormatString('%05d').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-0010')

    def test_signed_integer_d_with_multidigit_width(self) -> None:
        result = decode.FormatString('%10d').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '       -10')

    def test_signed_integer_d_with_star_width(self) -> None:
        result = decode.FormatString('%*d').format(encode.encode_args(10, -10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '       -10')

    def test_signed_integer_d_with_missing_width_or_value(self) -> None:
        result = decode.FormatString('%*d').format(encode.encode_args(-10))
        self.assertFalse(result.ok())

    def test_signed_integer_d_with_precision(self) -> None:
        result = decode.FormatString('%.5d').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-00010')

    def test_signed_integer_d_with_multidigit_precision(self) -> None:
        result = decode.FormatString('%.10d').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-0000000010')

    def test_signed_integer_d_with_star_precision(self) -> None:
        result = decode.FormatString('%.*d').format(encode.encode_args(10, -10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-0000000010')

    def test_signed_integer_d_with_zero_precision(self) -> None:
        result = decode.FormatString('%.0d').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')

    def test_signed_integer_d_with_empty_precision(self) -> None:
        result = decode.FormatString('%.d').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')

    def test_zero_with_zero_precision(self) -> None:
        result = decode.FormatString('%.0d').format(encode.encode_args(0))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '')

    def test_zero_with_empty_precision(self) -> None:
        result = decode.FormatString('%.d').format(encode.encode_args(0))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '')

    def test_signed_integer_d_with_width_and_precision(self) -> None:
        result = decode.FormatString('%10.5d').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '    -00010')

    def test_signed_integer_d_with_star_width_and_precision(self) -> None:
        result = decode.FormatString('%*.*d').format(
            encode.encode_args(15, 10, -10)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '    -0000000010')

    def test_signed_integer_d_with_missing_precision_or_value(self) -> None:
        result = decode.FormatString('%.*d').format(encode.encode_args(-10))
        self.assertFalse(result.ok())

    def test_64_bit_specifier_workaround(self) -> None:
        result = decode.FormatString('%.u%.*lu%0*lu').format(
            encode.encode_args(0, 0, 0, 0, 0)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '0')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%.u%.*lu%0*lu').format(
            encode.encode_args(0, 0, 1, 9, 0)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '1000000000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%.u%.*lu%0*lu').format(
            encode.encode_args(1, 9, 0, 9, 0)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '1000000000000000000')
        self.assertEqual(result.remaining, b'')

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_signed_integer_i(self) -> None:
        result = decode.FormatString('%i').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_i_with_minus(self) -> None:
        result = decode.FormatString('%-5i').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '10   ')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_i_with_plus(self) -> None:
        result = decode.FormatString('%+i').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+10')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_i_with_blank_space(self) -> None:
        result = decode.FormatString('% i').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, ' 10')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_i_with_plus_and_blank_space_ignores_blank_space(
        self,
    ) -> None:
        result = decode.FormatString('%+ i').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('% +i').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+10')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_i_with_hashtag(self) -> None:
        result = decode.FormatString('%#i').format(encode.encode_args(10))
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args(10))

    def test_signed_integer_i_with_zero(self) -> None:
        result = decode.FormatString('%05i').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '00010')
        self.assertEqual(result.remaining, b'')

    def test_signed_integer_i_with_length(self) -> None:
        """Tests that length modifiers do not affect signed integer decoding."""
        result = decode.FormatString('%hhi').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%hi').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%li').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lli').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%ji').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zi').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%ti').format(encode.encode_args(-10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '-10')
        self.assertEqual(result.remaining, b'')

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_unsigned_integer(self) -> None:
        result = decode.FormatString('%u').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '10')
        self.assertEqual(result.remaining, b'')

    def test_unsigned_integer_with_hashtag(self) -> None:
        result = decode.FormatString('%#u').format(encode.encode_args(10))
        self.assertFalse(result.ok())

    def test_unsigned_integer_with_length(self) -> None:
        """Tests that length modifiers pass unsigned integer decoding."""
        result = decode.FormatString('%hhu').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%hu').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lu').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%llu').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%ju').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zu').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%tu').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '10')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%Lu').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '10')
        self.assertEqual(result.remaining, b'')

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_octal_integer(self) -> None:
        result = decode.FormatString('%o').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '12')
        self.assertEqual(result.remaining, b'')

    def test_octal_integer_with_hashtag(self) -> None:
        result = decode.FormatString('%#o').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '012')
        self.assertEqual(result.remaining, b'')

    def test_octal_integer_with_hashtag_and_width(self) -> None:
        result = decode.FormatString('%#10o').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '       012')
        self.assertEqual(result.remaining, b'')

    def test_octal_integer_with_hashtag_and_zero_and_width(self) -> None:
        result = decode.FormatString('%#010o').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '0000000012')
        self.assertEqual(result.remaining, b'')

    def test_octal_integer_with_minus_and_hashtag(self) -> None:
        result = decode.FormatString('%#-5o').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '012  ')
        self.assertEqual(result.remaining, b'')

    def test_octal_integer_with_plus_and_hashtag(self) -> None:
        result = decode.FormatString('%+#o').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+012')
        self.assertEqual(result.remaining, b'')

    def test_octal_integer_with_space_and_hashtag(self) -> None:
        result = decode.FormatString('% #o').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, ' 012')
        self.assertEqual(result.remaining, b'')

    def test_octal_integer_with_zero_and_hashtag(self) -> None:
        result = decode.FormatString('%#05o').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '00012')
        self.assertEqual(result.remaining, b'')

    def test_octal_integer_with_plus_and_space_and_hashtag_ignores_space(
        self,
    ) -> None:
        result = decode.FormatString('%+ #o').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+012')
        self.assertEqual(result.remaining, b'')

    def test_octal_integer_with_length(self) -> None:
        """Tests that length modifiers do not affect octal integer decoding."""
        result = decode.FormatString('%hho').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '12')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%ho').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '12')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lo').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '12')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%llo').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '12')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%jo').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '12')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zo').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '12')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%to').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '12')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%Lo').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '12')
        self.assertEqual(result.remaining, b'')

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_lowercase_hex_integer(self) -> None:
        result = decode.FormatString('%x').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'a')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_hex_integer_with_hashtag(self) -> None:
        result = decode.FormatString('%#x').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '0xa')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_hex_integer_with_length(self) -> None:
        """Tests that length modifiers do not affect lowercase hex decoding."""
        result = decode.FormatString('%hhx').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'a')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%hx').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'a')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lx').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'a')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%llx').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'a')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%jx').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'a')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zx').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'a')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%tx').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'a')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%Lx').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'a')
        self.assertEqual(result.remaining, b'')

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_uppercase_hex_integer(self) -> None:
        result = decode.FormatString('%X').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'A')
        self.assertEqual(result.remaining, b'')

    def test_uppercase_hex_integer_with_hashtag(self) -> None:
        result = decode.FormatString('%#X').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '0XA')
        self.assertEqual(result.remaining, b'')

    def test_uppercase_hex_integer_with_length(self) -> None:
        """Tests that length modifiers do not affect uppercase hex decoding."""
        result = decode.FormatString('%hhX').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'A')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%hX').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'A')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lX').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'A')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%llX').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'A')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%jX').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'A')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zX').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'A')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%tX').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'A')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%LX').format(encode.encode_args(10))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'A')
        self.assertEqual(result.remaining, b'')

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_decode_generated_data(self) -> None:
        test_data = varint_test_data.TEST_DATA
        self.assertGreater(len(test_data), 100)

        for signed_spec, signed, unsigned_spec, unsigned, encoded in test_data:
            self.assertEqual(
                int(signed),
                decode.FormatSpec.from_string(signed_spec)
                .decode(bytearray(encoded))
                .value,
            )

            self.assertEqual(
                int(unsigned),
                decode.FormatSpec.from_string(unsigned_spec)
                .decode(bytearray(encoded))
                .value,
            )


# pylint: disable=too-many-public-methods
class TestFloatDecoding(unittest.TestCase):
    """Tests decoding floating-point values using f or F."""

    def test_lowercase_float(self) -> None:
        result = decode.FormatString('%f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_with_minus(self) -> None:
        result = decode.FormatString('%-10f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000  ')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_with_plus(self) -> None:
        result = decode.FormatString('%+f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+2.200000')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_with_blank_space(self) -> None:
        result = decode.FormatString('% f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, ' 2.200000')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_with_plus_and_blank_space_ignores_blank_space(
        self,
    ) -> None:
        result = decode.FormatString('%+ f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('% +f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+2.200000')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_with_hashtag(self) -> None:
        result = decode.FormatString('%.0f').format(encode.encode_args(2.0))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%#.0f').format(encode.encode_args(2.0))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_with_zero(self) -> None:
        result = decode.FormatString('%010f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '002.200000')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_with_length(self) -> None:
        """Tests that length modifiers do not affect f decoding."""
        result = decode.FormatString('%hhf').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%hf').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lf').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%llf').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%jf').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zf').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%tf').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%Lf').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_with_width(self) -> None:
        result = decode.FormatString('%9f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, ' 2.200000')

    def test_lowercase_float_with_multidigit_width(self) -> None:
        result = decode.FormatString('%10f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '  2.200000')

    def test_lowercase_float_with_star_width(self) -> None:
        result = decode.FormatString('%*f').format(encode.encode_args(10, 2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '  2.200000')

    def test_lowercase_float_non_number(self) -> None:
        result = decode.FormatString('%f').format(encode.encode_args(math.inf))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'inf')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_with_precision(self) -> None:
        result = decode.FormatString('%.4f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2000')

    def test_lowercase_float_with_multidigit_precision(self) -> None:
        result = decode.FormatString('%.10f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2000000477')

    def test_lowercase_float_with_star_preision(self) -> None:
        result = decode.FormatString('%.*f').format(encode.encode_args(10, 2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2000000477')

    def test_lowercase_float_with_zero_precision(self) -> None:
        result = decode.FormatString('%.0f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2')

    def test_lowercase_float_with_empty_precision(self) -> None:
        result = decode.FormatString('%.f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2')

    def test_lowercase_float_with_width_and_precision(self) -> None:
        result = decode.FormatString('%10.0f').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '         2')

    def test_lowercase_float_with_star_width_and_star_precision(self) -> None:
        result = decode.FormatString('%*.*f').format(
            encode.encode_args(20, 10, 2.2)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '        2.2000000477')

    def test_lowercase_float_non_number_with_minus(self) -> None:
        result = decode.FormatString('%-5f').format(
            encode.encode_args(math.inf)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'inf  ')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_non_number_with_plus(self) -> None:
        result = decode.FormatString('%+f').format(encode.encode_args(math.inf))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+inf')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_non_number_with_blank_space(self) -> None:
        result = decode.FormatString('% f').format(encode.encode_args(math.inf))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, ' inf')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_non_number_with_plus_and_blank_ignores_blank(
        self,
    ) -> None:
        result = decode.FormatString('%+ f').format(
            encode.encode_args(math.inf)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+inf')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('% +f').format(
            encode.encode_args(math.inf)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+inf')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_non_number_with_hashtag(self) -> None:
        result = decode.FormatString('%#f').format(encode.encode_args(math.inf))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'inf')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_non_number_zero(self) -> None:
        result = decode.FormatString('%05f').format(
            encode.encode_args(math.inf)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '  inf')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_float_non_number_with_width(self) -> None:
        result = decode.FormatString('%9f').format(encode.encode_args(math.inf))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '      inf')

    def test_lowercase_float_non_number_with_multidigit_width(self) -> None:
        result = decode.FormatString('%10f').format(
            encode.encode_args(math.inf)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '       inf')

    def test_lowercase_float_non_number_with_star_width(self) -> None:
        result = decode.FormatString('%*f').format(
            encode.encode_args(10, math.inf)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '       inf')

    def test_lowercase_float_non_number_with_precision(self) -> None:
        result = decode.FormatString('%.4f').format(
            encode.encode_args(math.inf)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'inf')

    def test_lowercase_float_non_number_with_multidigit_precision(self) -> None:
        result = decode.FormatString('%.10f').format(
            encode.encode_args(math.inf)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'inf')

    def test_lowercase_float_non_number_with_star_preision(self) -> None:
        result = decode.FormatString('%.*f').format(
            encode.encode_args(10, math.inf)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'inf')

    def test_lowercase_float_non_number_with_zero_precision(self) -> None:
        result = decode.FormatString('%.0f').format(
            encode.encode_args(math.inf)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'inf')

    def test_lowercase_float_non_number_with_empty_precision(self) -> None:
        result = decode.FormatString('%.f').format(encode.encode_args(math.inf))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'inf')

    def test_lowercase_float_non_number_with_width_and_precision(self) -> None:
        result = decode.FormatString('%10.0f').format(
            encode.encode_args(math.inf)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '       inf')

    def test_lowercase_float_non_number_with_star_width_and_star_precision(
        self,
    ) -> None:
        result = decode.FormatString('%*.*f').format(
            encode.encode_args(10, 0, math.inf)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '       inf')

    def test_zero_with_zero_precision(self) -> None:
        result = decode.FormatString('%.0f').format(encode.encode_args(0.0))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '0')

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_uppercase_float(self) -> None:
        result = decode.FormatString('%F').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

    def test_uppercase_float_with_length(self) -> None:
        """Tests that length modifiers do not affect F decoding."""
        result = decode.FormatString('%hhF').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%hF').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lF').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%llF').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%jF').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zF').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')

        result = decode.FormatString('%tF').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%LF').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000')
        self.assertEqual(result.remaining, b'')

    def test_uppercase_float_non_number(self) -> None:
        result = decode.FormatString('%F').format(encode.encode_args(math.inf))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'INF')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_exponential(self) -> None:
        result = decode.FormatString('%e').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000e+00')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_exponential_with_length(self) -> None:
        """Tests that length modifiers do not affect e decoding."""
        result = decode.FormatString('%hhe').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000e+00')
        self.assertEqual(result.remaining, b'')

        # inclusive-language: disable
        result = decode.FormatString('%he').format(encode.encode_args(2.2))
        # inclusive-language: enable
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000e+00')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%le').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000e+00')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lle').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000e+00')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%je').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000e+00')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%ze').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000e+00')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%te').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000e+00')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%Le').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000e+00')
        self.assertEqual(result.remaining, b'')

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_uppercase_exponential(self) -> None:
        result = decode.FormatString('%E').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000E+00')
        self.assertEqual(result.remaining, b'')

    def test_uppercase_exponential_with_length(self) -> None:
        """Tests that length modifiers do not affect E decoding."""
        result = decode.FormatString('%hhE').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000E+00')
        self.assertEqual(result.remaining, b'')

        # inclusive-language: disable
        result = decode.FormatString('%hE').format(encode.encode_args(2.2))
        # inclusive-language: enable
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000E+00')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lE').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000E+00')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%llE').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000E+00')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%jE').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000E+00')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zE').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000E+00')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%tE').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000E+00')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%LE').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.200000E+00')
        self.assertEqual(result.remaining, b'')

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_lowercase_shortest_take_normal(self) -> None:
        result = decode.FormatString('%g').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_shortest_take_exponential(self) -> None:
        result = decode.FormatString('%g').format(encode.encode_args(1048580.0))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '1.04858e+06')
        self.assertEqual(result.remaining, b'')

    def test_lowercase_shortest_with_length(self) -> None:
        """Tests that length modifiers do not affect g decoding."""
        result = decode.FormatString('%hhg').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%hg').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lg').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%llg').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%jg').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zg').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%tg').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%Lg').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_uppercase_shortest_take_normal(self) -> None:
        result = decode.FormatString('%G').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

    def test_uppercase_shortest_take_exponential(self) -> None:
        result = decode.FormatString('%G').format(encode.encode_args(1048580.0))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '1.04858E+06')
        self.assertEqual(result.remaining, b'')

    def test_uppercase_shortest_with_length(self) -> None:
        """Tests that length modifiers do not affect G decoding."""
        result = decode.FormatString('%hhG').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%hG').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lG').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%llG').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%jG').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zG').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%tG').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%LG').format(encode.encode_args(2.2))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '2.2')
        self.assertEqual(result.remaining, b'')


class TestCharDecoding(unittest.TestCase):
    """Tests decoding character values."""

    def test_char(self) -> None:
        result = decode.FormatString('%c').format(encode.encode_args(ord('c')))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'c')
        self.assertEqual(result.remaining, b'')

    def test_char_with_minus(self) -> None:
        result = decode.FormatString('%-5c').format(
            encode.encode_args(ord('c'))
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'c    ')
        self.assertEqual(result.remaining, b'')

    def test_char_with_plus(self) -> None:
        result = decode.FormatString('%+c').format(encode.encode_args(ord('c')))
        self.assertFalse(result.ok())

    def test_char_with_blank_space(self) -> None:
        result = decode.FormatString('% c').format(encode.encode_args(ord('c')))
        self.assertFalse(result.ok())

    def test_char_with_hashtag(self) -> None:
        result = decode.FormatString('%#c').format(encode.encode_args(ord('c')))
        self.assertFalse(result.ok())

    def test_char_with_zero(self) -> None:
        result = decode.FormatString('%0c').format(encode.encode_args(ord('c')))
        self.assertFalse(result.ok())

    def test_char_with_length(self) -> None:
        """Tests that length modifiers do not affectchar decoding."""
        result = decode.FormatString('%hhc').format(
            encode.encode_args(ord('c'))
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'c')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%hc').format(encode.encode_args(ord('c')))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'c')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lc').format(encode.encode_args(ord('c')))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'c')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%llc').format(
            encode.encode_args(ord('c'))
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'c')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%jc').format(encode.encode_args(ord('c')))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'c')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zc').format(encode.encode_args(ord('c')))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'c')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%tc').format(encode.encode_args(ord('c')))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'c')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%Lc').format(encode.encode_args(ord('c')))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'c')
        self.assertEqual(result.remaining, b'')

    def test_char_with_width(self) -> None:
        result = decode.FormatString('%5c').format(encode.encode_args(ord('c')))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '    c')

    def test_char_with_multidigit_width(self) -> None:
        result = decode.FormatString('%10c').format(
            encode.encode_args(ord('c'))
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '         c')

    def test_char_with_star_width(self) -> None:
        result = decode.FormatString('%*c').format(
            encode.encode_args(10, ord('c'))
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '         c')

    def test_char_with_precision(self) -> None:
        result = decode.FormatString('%.4c').format(
            encode.encode_args(ord('c'))
        )
        self.assertFalse(result.ok())

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_long_char(self) -> None:
        result = decode.FormatString('%lc').format(encode.encode_args(ord('c')))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'c')
        self.assertEqual(result.remaining, b'')

    def test_long_char_with_hashtag(self) -> None:
        result = decode.FormatString('%#lc').format(
            encode.encode_args(ord('c'))
        )
        self.assertFalse(result.ok())

    def test_long_char_with_zero(self) -> None:
        result = decode.FormatString('%0lc').format(
            encode.encode_args(ord('c'))
        )
        self.assertFalse(result.ok())


class TestStringDecoding(unittest.TestCase):
    """Tests decoding string values."""

    def test_string(self) -> None:
        result = decode.FormatString('%s').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello')
        self.assertEqual(result.remaining, b'')

    def test_string_with_minus(self) -> None:
        result = decode.FormatString('%-6s').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello ')
        self.assertEqual(result.remaining, b'')

    def test_string_with_plus(self) -> None:
        result = decode.FormatString('%+s').format(encode.encode_args('hello'))
        self.assertFalse(result.ok())

    def test_string_with_blank_space(self) -> None:
        result = decode.FormatString('% s').format(encode.encode_args('hello'))
        self.assertFalse(result.ok())

    def test_string_with_hashtag(self) -> None:
        result = decode.FormatString('%#s').format(encode.encode_args('hello'))
        self.assertFalse(result.ok())

    def test_string_with_zero(self) -> None:
        result = decode.FormatString('%0s').format(encode.encode_args('hello'))
        self.assertFalse(result.ok())

    def test_string_with_length(self) -> None:
        """Tests that length modifiers do not affect string values (s)."""
        result = decode.FormatString('%hhs').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%hs').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%ls').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%lls').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%js').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%zs').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%ts').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%Ls').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello')
        self.assertEqual(result.remaining, b'')

    def test_string_with_width(self) -> None:
        result = decode.FormatString('%6s').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, ' hello')

    def test_string_with_width_does_not_pad_a_string_with_same_length(
        self,
    ) -> None:
        result = decode.FormatString('%5s').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello')

    def test_string_with_multidigit_width(self) -> None:
        result = decode.FormatString('%10s').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '     hello')

    def test_string_with_star_width(self) -> None:
        result = decode.FormatString('%*s').format(
            encode.encode_args(10, 'hello')
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '     hello')

    def test_string_with_precision(self) -> None:
        result = decode.FormatString('%.3s').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hel')

    def test_string_with_multidigit_precision(self) -> None:
        result = decode.FormatString('%.10s').format(
            encode.encode_args('hello')
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello')

    def test_string_with_star_precision(self) -> None:
        result = decode.FormatString('%.*s').format(
            encode.encode_args(3, 'hello')
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hel')

    def test_string_with_width_and_precision(self) -> None:
        result = decode.FormatString('%10.3s').format(
            encode.encode_args('hello')
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '       hel')

    def test_string_with_star_with_and_star_precision(self) -> None:
        result = decode.FormatString('%*.*s').format(
            encode.encode_args(10, 3, 'hello')
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '       hel')

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_long_string(self) -> None:
        result = decode.FormatString('%ls').format(encode.encode_args('hello'))
        self.assertTrue(result.ok())
        self.assertEqual(result.value, 'hello')
        self.assertEqual(result.remaining, b'')

    def test_long_string_with_hashtag(self) -> None:
        result = decode.FormatString('%#ls').format(encode.encode_args('hello'))
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args('hello'))

    def test_long_string_with_zero(self) -> None:
        result = decode.FormatString('%0ls').format(encode.encode_args('hello'))
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args('hello'))


class TestPointerDecoding(unittest.TestCase):
    """Tests decoding pointer values."""

    def test_pointer(self) -> None:
        result = decode.FormatString('%p').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '0xDEADBEEF')
        self.assertEqual(result.remaining, b'')

    def test_pointer_with_minus(self) -> None:
        result = decode.FormatString('%-12p').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '0xDEADBEEF  ')
        self.assertEqual(result.remaining, b'')

    def test_pointer_with_plus(self) -> None:
        result = decode.FormatString('%+p').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '+0xDEADBEEF')
        self.assertEqual(result.remaining, b'')

    def test_pointer_with_blank_space(self) -> None:
        result = decode.FormatString('% p').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, ' 0xDEADBEEF')
        self.assertEqual(result.remaining, b'')

    def test_pointer_with_hashtag(self) -> None:
        result = decode.FormatString('%#p').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args(0xDEADBEEF))

    def test_pointer_with_zero(self) -> None:
        result = decode.FormatString('%0p').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args(0xDEADBEEF))

    def test_pointer_with_length(self) -> None:
        """Tests that length modifiers do not affect decoding pointers (p)."""
        result = decode.FormatString('%hhp').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args(0xDEADBEEF))

        result = decode.FormatString('%hp').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args(0xDEADBEEF))

        result = decode.FormatString('%lp').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args(0xDEADBEEF))

        result = decode.FormatString('%llp').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args(0xDEADBEEF))

        result = decode.FormatString('%jp').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args(0xDEADBEEF))

        result = decode.FormatString('%zp').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args(0xDEADBEEF))

        result = decode.FormatString('%tp').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args(0xDEADBEEF))

        result = decode.FormatString('%Lp').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args(0xDEADBEEF))

    def test_pointer_with_width(self) -> None:
        result = decode.FormatString('%9p').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '0xDEADBEEF')
        self.assertEqual(result.remaining, b'')

    def test_pointer_with_multidigit_width(self) -> None:
        result = decode.FormatString('%11p').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, ' 0xDEADBEEF')
        self.assertEqual(result.remaining, b'')

    def test_pointer_with_star_width(self) -> None:
        result = decode.FormatString('%*p').format(
            encode.encode_args(10, 0xDEADBEEF)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '0xDEADBEEF')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%*p').format(
            encode.encode_args(15, 0xDEADBEEF)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '     0xDEADBEEF')
        self.assertEqual(result.remaining, b'')

    def test_pointer_with_precision(self) -> None:
        result = decode.FormatString('%.10p').format(
            encode.encode_args(0xDEADBEEF)
        )
        self.assertFalse(result.ok())
        self.assertEqual(result.remaining, encode.encode_args(0xDEADBEEF))

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    def test_pointer_0_padding(self) -> None:
        result = decode.FormatString('%p').format(
            encode.encode_args(0x00000000)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '0x00000000')
        self.assertEqual(result.remaining, b'')

    def test_pointer_0_with_width(self) -> None:
        result = decode.FormatString('%9p').format(
            encode.encode_args(0x00000000)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '0x00000000')
        self.assertEqual(result.remaining, b'')

    def test_pointer_0_with_multidigit_width(self) -> None:
        result = decode.FormatString('%11p').format(
            encode.encode_args(0x00000000)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, ' 0x00000000')
        self.assertEqual(result.remaining, b'')

    def test_pointer_0_with_star_width(self) -> None:
        result = decode.FormatString('%*p').format(
            encode.encode_args(10, 0x00000000)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '0x00000000')
        self.assertEqual(result.remaining, b'')

        result = decode.FormatString('%*p').format(
            encode.encode_args(15, 0x00000000)
        )
        self.assertTrue(result.ok())
        self.assertEqual(result.value, '     0x00000000')
        self.assertEqual(result.remaining, b'')


class TestFormattedString(unittest.TestCase):
    """Tests scoring how successfully a formatted string decoded."""

    def test_no_args(self) -> None:
        result = decode.FormatString('string').format(b'')

        self.assertTrue(result.ok())
        self.assertEqual(result.score(), (True, True, 0, 0, datetime.max))

    def test_one_arg(self) -> None:
        result = decode.FormatString('%d').format(encode.encode_args(0))

        self.assertTrue(result.ok())
        self.assertEqual(result.score(), (True, True, 0, 1, datetime.max))

    def test_missing_args(self) -> None:
        result = decode.FormatString('%p%d%d').format(b'\x02\x80')

        self.assertFalse(result.ok())
        self.assertEqual(result.score(), (False, True, -2, 3, datetime.max))
        self.assertGreater(result.score(), result.score(datetime.now()))
        self.assertGreater(
            result.score(datetime.now()), result.score(datetime.min)
        )

    def test_compare_score(self) -> None:
        all_args_ok = decode.FormatString('%d%d%d').format(
            encode.encode_args(0, 0, 0)
        )
        missing_one_arg = decode.FormatString('%d%d%d').format(
            encode.encode_args(0, 0)
        )
        missing_two_args = decode.FormatString('%d%d%d').format(
            encode.encode_args(0)
        )
        all_args_extra_data = decode.FormatString('%d%d%d').format(
            encode.encode_args(0, 0, 0, 1)
        )
        missing_one_arg_extra_data = decode.FormatString('%d%d%d').format(
            b'\0' + b'\x80' * 100
        )

        self.assertGreater(all_args_ok.score(), missing_one_arg.score())
        self.assertGreater(missing_one_arg.score(), missing_two_args.score())
        self.assertGreater(
            missing_two_args.score(), all_args_extra_data.score()
        )
        self.assertGreater(
            all_args_extra_data.score(), missing_one_arg_extra_data.score()
        )


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