synta 0.2.4

#!/usr/bin/env python3
"""
Basic tests for Synta Python bindings

Run these tests after installing the synta package:
    python3 tests/python/test_basic.py
"""

import base64
import synta
import synta.oids as oids


def test_integer_decode():
    """Test INTEGER decoding"""
    print("Testing INTEGER decode...")
    data = b'\x02\x01\x2A'  # INTEGER 42
    decoder = synta.Decoder(data, synta.Encoding.DER)
    integer = decoder.decode_integer()
    assert integer.to_int() == 42
    print("  ✓ INTEGER decode: OK")


def test_integer_encode():
    """Test INTEGER encoding"""
    print("Testing INTEGER encode...")
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_integer(42)
    output = encoder.finish()
    assert output == b'\x02\x01\x2A'
    print("  ✓ INTEGER encode: OK")


def test_large_integer():
    """Test large INTEGER values"""
    print("Testing large INTEGER...")
    # Create a large integer
    large_val = 2**128 - 1
    encoder = synta.Encoder(synta.Encoding.DER)

    # Large integers need to be created from bytes
    large_bytes = large_val.to_bytes(17, byteorder='big')  # 16 bytes + sign byte
    large_int = synta.Integer.from_bytes(large_bytes)
    encoder.encode_integer_object(large_int)
    output = encoder.finish()

    # Decode it back
    decoder = synta.Decoder(output, synta.Encoding.DER)
    decoded = decoder.decode_integer()
    assert decoded.to_bytes() == large_bytes
    print("  ✓ Large INTEGER: OK")


def test_oid_decode():
    """Test OBJECT IDENTIFIER decoding"""
    print("Testing OID decode...")
    # RSA encryption OID: 1.2.840.113549.1.1.1
    oid_data = b'\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01'
    decoder = synta.Decoder(oid_data, synta.Encoding.DER)
    oid = decoder.decode_oid()
    assert oid == oids.RSA_ENCRYPTION
    print("  ✓ OID decode: OK")


def test_oid_create():
    """Test OBJECT IDENTIFIER creation"""
    print("Testing OID create...")
    oid = synta.ObjectIdentifier(str(oids.EC_PUBLIC_KEY))
    assert oid == oids.EC_PUBLIC_KEY
    components = oid.components()
    assert components == (1, 2, 840, 10045, 2, 1)
    print("  ✓ OID create: OK")


def test_oid_from_components():
    """Test OBJECT IDENTIFIER from components"""
    print("Testing OID from components...")
    oid = synta.ObjectIdentifier.from_components([1, 2, 840, 10045, 4, 3, 2])
    assert oid == oids.ECDSA_WITH_SHA256
    print("  ✓ OID from components: OK")


def test_oid_encode():
    """Test OBJECT IDENTIFIER encoding"""
    print("Testing OID encode...")
    oid = oids.RSA_ENCRYPTION
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_oid(oid)
    output = encoder.finish()
    assert output == b'\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01'
    print("  ✓ OID encode: OK")


def test_octet_string_decode():
    """Test OCTET STRING decoding"""
    print("Testing OCTET STRING decode...")
    octet_data = b'\x04\x05hello'
    decoder = synta.Decoder(octet_data, synta.Encoding.DER)
    octet_string = decoder.decode_octet_string()
    assert octet_string.to_bytes() == b'hello'
    assert len(octet_string) == 5
    print("  ✓ OCTET STRING decode: OK")


def test_octet_string_encode():
    """Test OCTET STRING encoding"""
    print("Testing OCTET STRING encode...")
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_octet_string(b'hello')
    output = encoder.finish()
    assert output == b'\x04\x05hello'
    print("  ✓ OCTET STRING encode: OK")


def test_boolean_decode():
    """Test BOOLEAN decoding"""
    print("Testing BOOLEAN decode...")
    # TRUE
    bool_data = b'\x01\x01\xff'
    decoder = synta.Decoder(bool_data, synta.Encoding.DER)
    boolean = decoder.decode_boolean()
    assert boolean.value()
    assert bool(boolean)

    # FALSE
    bool_data = b'\x01\x01\x00'
    decoder = synta.Decoder(bool_data, synta.Encoding.DER)
    boolean = decoder.decode_boolean()
    assert not boolean.value()
    assert not bool(boolean)
    print("  ✓ BOOLEAN decode: OK")


def test_boolean_encode():
    """Test BOOLEAN encoding"""
    print("Testing BOOLEAN encode...")
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_boolean(True)
    output = encoder.finish()
    assert output == b'\x01\x01\xff'

    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_boolean(False)
    output = encoder.finish()
    assert output == b'\x01\x01\x00'
    print("  ✓ BOOLEAN encode: OK")


def test_bit_string_create():
    """Test BIT STRING creation"""
    print("Testing BIT STRING create...")
    bit_string = synta.BitString(b'\xff\x00', 0)
    assert bit_string.unused_bits() == 0
    assert bit_string.bit_len() == 16
    assert bit_string.to_bytes() == b'\xff\x00'
    print("  ✓ BIT STRING create: OK")


def test_bit_string_encode_decode():
    """Test BIT STRING encode/decode round-trip"""
    print("Testing BIT STRING encode/decode...")

    # Known encoding: tag 0x03, length 0x03, unused-bits 0x00, data 0xff 0x00
    bs = synta.BitString(b'\xff\x00', 0)
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_bit_string(bs)
    encoded = encoder.finish()
    assert encoded == b'\x03\x03\x00\xff\x00', f"Unexpected encoding: {encoded.hex()}"

    # Decode it back
    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    decoded = decoder.decode_bit_string()
    assert decoded.to_bytes() == b'\xff\x00'
    assert decoded.unused_bits() == 0
    assert decoded.bit_len() == 16
    assert decoder.is_empty()

    # With unused bits: 3 unused bits in last byte
    bs2 = synta.BitString(b'\xff\x80', 3)
    encoder2 = synta.Encoder(synta.Encoding.DER)
    encoder2.encode_bit_string(bs2)
    encoded2 = encoder2.finish()
    assert encoded2 == b'\x03\x03\x03\xff\x80'

    decoder2 = synta.Decoder(encoded2, synta.Encoding.DER)
    decoded2 = decoder2.decode_bit_string()
    assert decoded2.to_bytes() == b'\xff\x80'
    assert decoded2.unused_bits() == 3
    assert decoded2.bit_len() == 13

    print("  ✓ BIT STRING encode/decode: OK")


def test_decoder_state():
    """Test decoder state tracking"""
    print("Testing decoder state...")
    # Multiple values in sequence
    data = b'\x02\x01\x2A\x01\x01\xff'  # INTEGER 42, BOOLEAN TRUE
    decoder = synta.Decoder(data, synta.Encoding.DER)

    assert not decoder.is_empty()
    assert decoder.remaining() == 6
    assert decoder.position() == 0

    integer = decoder.decode_integer()
    assert integer.to_int() == 42
    assert decoder.position() == 3
    assert decoder.remaining() == 3

    boolean = decoder.decode_boolean()
    assert boolean.value()
    assert decoder.position() == 6
    assert decoder.remaining() == 0
    assert decoder.is_empty()
    print("  ✓ Decoder state: OK")


def test_error_handling():
    """Test error handling"""
    print("Testing error handling...")

    # Invalid OID (first component must be 0, 1, or 2)
    try:
        synta.ObjectIdentifier("5.2.840")
        assert False, "Should have raised ValueError"
    except ValueError:
        pass

    # Truncated data
    try:
        decoder = synta.Decoder(b'\x02\x05', synta.Encoding.DER)
        decoder.decode_integer()
        assert False, "Should have raised EOFError"
    except EOFError:
        pass

    # Invalid tag
    try:
        decoder = synta.Decoder(b'\x05\x00', synta.Encoding.DER)  # NULL
        decoder.decode_integer()  # Expecting INTEGER
        assert False, "Should have raised ValueError"
    except ValueError:
        pass

    print("  ✓ Error handling: OK")


def test_null_decode():
    """Test NULL decoding"""
    print("Testing NULL decode...")
    null_data = b'\x05\x00'
    decoder = synta.Decoder(null_data, synta.Encoding.DER)
    null = decoder.decode_null()
    assert isinstance(null, synta.Null)
    assert decoder.is_empty()
    print("  ✓ NULL decode: OK")


def test_null_encode():
    """Test NULL encoding"""
    print("Testing NULL encode...")
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_null()
    output = encoder.finish()
    assert output == b'\x05\x00'
    print("  ✓ NULL encode: OK")


def test_utf8_string():
    """Test UTF8String encode/decode"""
    print("Testing UTF8String...")
    text = "Hello, World!"
    # Encode
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_utf8_string(text)
    encoded = encoder.finish()

    # Decode
    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    s = decoder.decode_utf8_string()
    assert s.as_str() == text
    assert str(s) == text
    assert len(s) == len(text)

    # Object creation
    s2 = synta.Utf8String("test")
    assert s2.as_str() == "test"
    assert s2 == synta.Utf8String("test")
    print("  ✓ UTF8String: OK")


def test_printable_string():
    """Test PrintableString encode/decode"""
    print("Testing PrintableString...")
    text = "Example Corp"
    # Encode
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_printable_string(text)
    encoded = encoder.finish()

    # Decode
    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    s = decoder.decode_printable_string()
    assert s.as_str() == text
    assert str(s) == text

    # Invalid characters should raise ValueError
    try:
        synta.PrintableString("Hello@World")  # '@' not in PrintableString charset
        assert False, "Should have raised ValueError"
    except ValueError:
        pass
    print("  ✓ PrintableString: OK")


def test_ia5_string():
    """Test IA5String encode/decode"""
    print("Testing IA5String...")
    text = "user@example.com"
    # Encode
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_ia5_string(text)
    encoded = encoder.finish()

    # Decode
    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    s = decoder.decode_ia5_string()
    assert s.as_str() == text
    assert str(s) == text

    # Non-ASCII should raise ValueError
    try:
        synta.IA5String("héllo")  # non-ASCII
        assert False, "Should have raised ValueError"
    except ValueError:
        pass
    print("  ✓ IA5String: OK")


def test_integer_to_i128():
    """Test INTEGER to_i128 for large values"""
    print("Testing INTEGER to_i128...")
    # Large value that fits in i128 but not i64
    large = 2**64 + 1
    large_bytes = large.to_bytes(9, byteorder='big')
    n = synta.Integer.from_bytes(large_bytes)
    val = n.to_i128()
    assert val == large

    # from_u64
    n2 = synta.Integer.from_u64(2**63)
    assert n2.to_i128() == 2**63
    print("  ✓ INTEGER to_i128: OK")


def test_utc_time_constructor():
    """Test UtcTime constructor and accessors"""
    print("Testing UtcTime constructor...")
    t = synta.UtcTime(2024, 1, 15, 10, 30, 0)
    assert t.year == 2024
    assert t.month == 1
    assert t.day == 15
    assert t.hour == 10
    assert t.minute == 30
    assert t.second == 0

    # Encode and decode round-trip
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_utc_time(t)
    encoded = encoder.finish()
    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    t2 = decoder.decode_utc_time()
    assert t2.year == 2024
    assert t2.month == 1
    assert t2.day == 15
    print("  ✓ UtcTime constructor: OK")


def test_generalized_time_constructor():
    """Test GeneralizedTime constructor and accessors"""
    print("Testing GeneralizedTime constructor...")
    t = synta.GeneralizedTime(2024, 6, 15, 12, 0, 0, None)
    assert t.year == 2024
    assert t.month == 6
    assert t.milliseconds is None

    t2 = synta.GeneralizedTime(2024, 6, 15, 12, 0, 0, 500)
    assert t2.milliseconds == 500
    print("  ✓ GeneralizedTime constructor: OK")


def test_decode_any_real():
    """Test that decode_any correctly recognises REAL values"""
    import math
    import struct
    print("Testing decode_any with REAL...")

    # Zero
    decoder = synta.Decoder(b'\x09\x00', synta.Encoding.DER)
    r = decoder.decode_any()
    assert isinstance(r, synta.Real), f"Expected Real, got {type(r)}"
    assert r.value() == 0.0

    # PLUS-INFINITY
    decoder = synta.Decoder(b'\x09\x01\x40', synta.Encoding.DER)
    r = decoder.decode_any()
    assert isinstance(r, synta.Real)
    assert math.isinf(float(r)) and float(r) > 0

    # MINUS-INFINITY
    decoder = synta.Decoder(b'\x09\x01\x41', synta.Encoding.DER)
    r = decoder.decode_any()
    assert isinstance(r, synta.Real)
    assert math.isinf(float(r)) and float(r) < 0

    # Finite value: info byte 0x80 (binary, base-2) + 8 bytes big-endian f64
    value = 2.71828
    data = bytes([0x09, 0x09, 0x80]) + struct.pack('>d', value)
    decoder = synta.Decoder(data, synta.Encoding.DER)
    r = decoder.decode_any()
    assert isinstance(r, synta.Real)
    assert r.value() == value

    print("  ✓ decode_any Real: OK")


def test_decode_any_primitive():
    """Test decode_any for primitive types"""
    print("Testing decode_any (primitives)...")
    # INTEGER
    decoder = synta.Decoder(b'\x02\x01\x2A', synta.Encoding.DER)
    val = decoder.decode_any()
    assert isinstance(val, synta.Integer)
    assert val.to_int() == 42

    # BOOLEAN
    decoder = synta.Decoder(b'\x01\x01\xff', synta.Encoding.DER)
    val = decoder.decode_any()
    assert isinstance(val, synta.Boolean)
    assert val.value() is True

    # NULL
    decoder = synta.Decoder(b'\x05\x00', synta.Encoding.DER)
    val = decoder.decode_any()
    assert isinstance(val, synta.Null)

    # OctetString
    decoder = synta.Decoder(b'\x04\x03abc', synta.Encoding.DER)
    val = decoder.decode_any()
    assert isinstance(val, synta.OctetString)
    assert val.to_bytes() == b'abc'
    print("  ✓ decode_any (primitives): OK")


def test_decode_any_sequence():
    """Test decode_any for SEQUENCE"""
    print("Testing decode_any (SEQUENCE)...")
    # SEQUENCE { INTEGER 1, BOOLEAN TRUE }
    # 30 06 02 01 01 01 01 ff
    data = b'\x30\x06\x02\x01\x01\x01\x01\xff'
    decoder = synta.Decoder(data, synta.Encoding.DER)
    seq = decoder.decode_any()
    assert isinstance(seq, list)
    assert len(seq) == 2
    assert isinstance(seq[0], synta.Integer)
    assert seq[0].to_int() == 1
    assert isinstance(seq[1], synta.Boolean)
    assert seq[1].value() is True
    print("  ✓ decode_any (SEQUENCE): OK")


# Real RSA certificate (self-signed, generated with openssl req -x509 -newkey rsa:2048)
_RSA_CERT_PEM = """\
MIIDiTCCAnGgAwIBAgIUXhaeS3ad5SJp60GRJU73OQaO0xkwDQYJKoZIhvcNAQEL
BQAwVDELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMRYwFAYDVQQHDA1TYW4gRnJh
bmNpc2NvMQ0wCwYDVQQKDARUZXN0MREwDwYDVQQDDAh0ZXN0LmNvbTAeFw0yNjAy
MjMxMDU0MzRaFw0yNzAyMjMxMDU0MzRaMFQxCzAJBgNVBAYTAlVTMQswCQYDVQQI
DAJDQTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzENMAsGA1UECgwEVGVzdDERMA8G
A1UEAwwIdGVzdC5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDP
9oir0NwIXFZ6gOUo//akzjNjvUhA/V1KSUY0L/iXOGWRHFcdcf4gVhoCgR+DgCV6
bJKKrYPIvfEwmd8DdpPj1WU4Dztb4NNLgxquFZym2Swe0xDLQdtWoIQYerF/ER8D
9Pk0qQ5QVaCO+KB3UKyXiJwcTc/LJnDqEX24mrf0ZH/HqB2GsUE3aI9aW5Lgwm9A
7+gV7FrumaT7fQqpfNucWwlXU2SIRm//JKUrT0MGrh99vmmkGRZK+c9wLfIK+pny
UQxSD1E395bpQTqTWIfcMWti6af3ix3GsWeoXwY+GDfZlZ1w22GjLmSgg1RMhhKZ
9l+QFnI/GtmiXX2pCRZfAgMBAAGjUzBRMB0GA1UdDgQWBBRCjPvAUpiRe0Zs6DTL
K+KLoTZfezAfBgNVHSMEGDAWgBRCjPvAUpiRe0Zs6DTLK+KLoTZfezAPBgNVHRMB
Af8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQC+xBpTScGlcZGYvwtWLZuF2qRu
o9xhYzHXgIDJglXZ8i70O+ut2WRyI9RJOSMsa7BI2qmc87Ki9ZMCO2QIMQCQo7cB
kZtQvK8iGGHhSwepMORekzdbfUUs7N4YEM3Xako1+4RzL+T1Z3qzQ6nrnQ+gYyQo
GiIFKbYZONu2OlqXGQe5LPwbsPU52GUbttkxodaHgCdP7yKO/l3sDifXpaFEXJhY
5RZqgSG77jymh8YKcY0X9J53OtP1So/IOS1Za137k+eYci6iCB4w511qEhSRZdCy
+3NEoGrBearMcJHttGbMplR6TU6fDFRIUAdelPdWfpfmtl1iElRDwNdQkBBR"""

# Real ECDSA certificate (self-signed, generated with openssl ecparam + req -x509)
_ECDSA_CERT_PEM = """\
MIICCTCCAa+gAwIBAgIUZVVIpXfjuxT9d3gDVq3eCWYxwkUwCgYIKoZIzj0EAwIw
WjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMRYwFAYDVQQHDA1TYW4gRnJhbmNp
c2NvMQ0wCwYDVQQKDARUZXN0MRcwFQYDVQQDDA5lY2RzYS50ZXN0LmNvbTAeFw0y
NjAyMjMxMDU0NTNaFw0yNzAyMjMxMDU0NTNaMFoxCzAJBgNVBAYTAlVTMQswCQYD
VQQIDAJDQTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzENMAsGA1UECgwEVGVzdDEX
MBUGA1UEAwwOZWNkc2EudGVzdC5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC
AATLXHqYJi2uIgdejzQyxF+jpAgyRylYeRh6JBKtXXoNH1m85zRmhEVR9hqUhPb+
Hm0xMX3xgAs3U52aIRATRZpYo1MwUTAdBgNVHQ4EFgQUxha7J/RFOfgWVwUZPgig
jbCihNwwHwYDVR0jBBgwFoAUxha7J/RFOfgWVwUZPgigjbCihNwwDwYDVR0TAQH/
BAUwAwEB/zAKBggqhkjOPQQDAgNIADBFAiEAhhM4PhuCnuqSYeGLtBaaVCxx+4pu
fyHLHbI1YzgOlBkCIBXAMEJWKCp22U253kkRGjdflyJmn2GGHKHeGvEl91dF"""


def test_certificate_rsa():
    """Test parsing a real RSA X.509 certificate"""
    print("Testing Certificate.from_der (RSA)...")
    der = base64.b64decode(_RSA_CERT_PEM)
    cert = synta.Certificate.from_der(der)

    # Version should be v3 (value 2)
    assert cert.version == 2, f"Expected v3 (2), got {cert.version}"

    # Signature algorithm: sha256WithRSAEncryption (oids.SHA256_WITH_RSA)
    assert str(cert.signature_algorithm) == oids.identify_signature_algorithm(oids.SHA256_WITH_RSA), \
        f"Unexpected sig alg: {cert.signature_algorithm}"

    # Public key algorithm: rsaEncryption (oids.RSA_ENCRYPTION)
    assert str(cert.public_key_algorithm) == oids.identify_public_key_algorithm(oids.RSA_ENCRYPTION), \
        f"Unexpected pubkey alg: {cert.public_key_algorithm}"

    # Public key bytes are non-empty
    assert len(cert.public_key) > 0

    # Serial number is a valid Python int
    assert isinstance(cert.serial_number, int)

    # Validity strings are non-empty
    assert cert.not_before
    assert cert.not_after

    # Subject and issuer are non-empty strings
    assert cert.subject
    assert cert.issuer

    # Self-signed: subject == issuer
    assert cert.subject == cert.issuer

    print("  ✓ Certificate RSA: OK")


def test_certificate_ecdsa():
    """Test parsing a real ECDSA X.509 certificate"""
    print("Testing Certificate.from_der (ECDSA)...")
    der = base64.b64decode(_ECDSA_CERT_PEM)
    cert = synta.Certificate.from_der(der)

    # Signature algorithm: ecdsa-with-SHA256 (oids.ECDSA_WITH_SHA256)
    assert str(cert.signature_algorithm) == oids.identify_signature_algorithm(oids.ECDSA_WITH_SHA256), \
        f"Unexpected sig alg: {cert.signature_algorithm}"

    # Public key algorithm: id-ecPublicKey (oids.EC_PUBLIC_KEY)
    assert str(cert.public_key_algorithm) == oids.identify_public_key_algorithm(oids.EC_PUBLIC_KEY), \
        f"Unexpected pubkey alg: {cert.public_key_algorithm}"

    assert cert.version == 2
    assert isinstance(cert.serial_number, int)
    assert len(cert.public_key) > 0
    assert cert.subject == cert.issuer

    print("  ✓ Certificate ECDSA: OK")


def test_certificate_serial_number_round_trip():
    """Regression test: serial_number must round-trip for all sizes.

    Before the fix, positive integers whose bit_length was a multiple of 8
    (e.g. 2^63, 2^127) were stored as negative DER INTEGERs and decoded back
    as negative Python ints.  This affected RSNv3 random serials which always
    set the high bit for consistent length (secrets.randbits(128) | (1 << 127)).
    """
    import secrets, datetime

    key = synta.PrivateKey.generate_rsa(2048)
    now = datetime.datetime.now(datetime.timezone.utc)

    def round_trip(sn_in):
        b = synta.CertificateBuilder()
        b = b.subject_name(b'\x30\x00')
        b = b.issuer_name(b'\x30\x00')
        b = b.public_key(key.public_key)
        b = b.serial_number(sn_in)
        b = b.not_valid_before_utc(now)
        b = b.not_valid_after_utc(now + datetime.timedelta(days=365))
        cert = b.sign(key, 'sha256')
        return cert.serial_number

    cases = [
        (42, "small"),
        (2**63 - 1, "max i64"),
        (2**63, "first value past i64"),
        (2**63 + 1, "2^63 + 1"),
        (2**127 - 1, "max positive 127-bit"),
        (2**127, "2^127 (MSB set, typical RSNv3)"),
        (2**127 + 42, "2^127 + 42"),
        (secrets.randbits(128) | (1 << 127), "128-bit RSNv3 random"),
    ]

    for sn_in, label in cases:
        sn_out = round_trip(sn_in)
        assert sn_out == sn_in, (
            f"serial_number round-trip failed for {label}: "
            f"in={sn_in:#x} out={sn_out:#x}"
        )

    print("  ✓ Certificate serial_number round-trip: OK")


def test_certificate_invalid():
    """Test that invalid DER raises an error"""
    print("Testing Certificate.from_der (invalid input)...")
    try:
        synta.Certificate.from_der(b'\x00\x00\x00')
        assert False, "Should have raised an error"
    except Exception:
        pass
    print("  ✓ Certificate invalid input: OK")


def test_real_decode():
    """Test REAL decoding — zero, finite, and special values"""
    print("Testing Real decode...")

    # Zero: tag=0x09, length=0x00
    zero_data = b'\x09\x00'
    decoder = synta.Decoder(zero_data, synta.Encoding.DER)
    r = decoder.decode_real()
    assert isinstance(r, synta.Real)
    assert r.value() == 0.0
    assert float(r) == 0.0
    assert r.is_finite()
    assert decoder.is_empty()

    # PLUS-INFINITY: tag=0x09, length=0x01, content=0x40
    inf_data = b'\x09\x01\x40'
    decoder = synta.Decoder(inf_data, synta.Encoding.DER)
    r = decoder.decode_real()
    assert r.is_infinite()
    assert float(r) > 0

    # MINUS-INFINITY: tag=0x09, length=0x01, content=0x41
    neg_inf_data = b'\x09\x01\x41'
    decoder = synta.Decoder(neg_inf_data, synta.Encoding.DER)
    r = decoder.decode_real()
    assert r.is_infinite()
    assert float(r) < 0

    # NaN: tag=0x09, length=0x01, content=0x42
    nan_data = b'\x09\x01\x42'
    decoder = synta.Decoder(nan_data, synta.Encoding.DER)
    r = decoder.decode_real()
    assert r.is_nan()

    print("  ✓ Real decode: OK")


def test_real_encode():
    """Test REAL encoding round-trip"""
    import math
    print("Testing Real encode...")

    # Encode zero
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_real(0.0)
    data = encoder.finish()
    assert data == b'\x09\x00', f"Expected zero encoding, got {data.hex()}"

    # Encode positive infinity
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_real(math.inf)
    data = encoder.finish()
    assert data == b'\x09\x01\x40', f"Expected +inf encoding, got {data.hex()}"

    # Encode negative infinity
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_real(-math.inf)
    data = encoder.finish()
    assert data == b'\x09\x01\x41', f"Expected -inf encoding, got {data.hex()}"

    # Encode NaN
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_real(math.nan)
    data = encoder.finish()
    assert data == b'\x09\x01\x42', f"Expected NaN encoding, got {data.hex()}"

    # Round-trip a finite value
    value = 3.14
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_real(value)
    encoded = encoder.finish()
    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    r = decoder.decode_real()
    assert r.value() == value
    assert r.is_finite()
    assert not r.is_nan()
    assert not r.is_infinite()

    # encode_real_object round-trip
    real_obj = synta.Real(2.71828)
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_real_object(real_obj)
    encoded = encoder.finish()
    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    r2 = decoder.decode_real()
    assert r2.value() == real_obj.value()

    print("  ✓ Real encode: OK")


def test_real_object():
    """Test Real object construction and methods"""
    import math
    print("Testing Real object...")
    r = synta.Real(1.5)
    assert r.value() == 1.5
    assert float(r) == 1.5
    assert r.is_finite()
    assert not r.is_nan()
    assert not r.is_infinite()
    assert repr(r) == "Real(1.5)"
    assert str(r) == "1.5"

    # Equality
    assert r == synta.Real(1.5)
    assert not (r == synta.Real(2.0))

    # Special values via constructor
    assert synta.Real(math.inf).is_infinite()
    assert synta.Real(-math.inf).is_infinite()
    assert synta.Real(math.nan).is_nan()

    print("  ✓ Real object: OK")


def test_encode_object_variants():
    """Test encode_*_object variants produce identical output to the raw-value methods"""
    print("Testing encode_*_object variants...")

    # encode_boolean_object: decode a BOOLEAN to get the object, re-encode it
    bool_obj = synta.Decoder(b'\x01\x01\xff', synta.Encoding.DER).decode_boolean()
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_boolean_object(bool_obj)
    assert enc.finish() == b'\x01\x01\xff'

    # encode_octet_string_object
    os_obj = synta.Decoder(b'\x04\x03abc', synta.Encoding.DER).decode_octet_string()
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_octet_string_object(os_obj)
    assert enc.finish() == b'\x04\x03abc'

    # encode_oid_object: alias for encode_oid — both accept a PyObjectIdentifier
    oid_bytes = b'\x06\x03\x55\x04\x03'  # 2.5.4.3 commonName
    oid_obj = synta.Decoder(oid_bytes, synta.Encoding.DER).decode_oid()
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_oid_object(oid_obj)
    assert enc.finish() == oid_bytes

    # encode_bit_string_object
    bs_bytes = b'\x03\x02\x00\xff'  # BIT STRING, 0 unused bits, value 0xff
    bs_obj = synta.Decoder(bs_bytes, synta.Encoding.DER).decode_bit_string()
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_bit_string_object(bs_obj)
    assert enc.finish() == bs_bytes

    # encode_null_object
    null_obj = synta.Decoder(b'\x05\x00', synta.Encoding.DER).decode_null()
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_null_object(null_obj)
    assert enc.finish() == b'\x05\x00'

    # encode_utc_time_object: encode_utc_time and encode_utc_time_object must agree
    t = synta.UtcTime(2024, 3, 1, 9, 0, 0)
    enc1 = synta.Encoder(synta.Encoding.DER)
    enc1.encode_utc_time(t)
    enc2 = synta.Encoder(synta.Encoding.DER)
    enc2.encode_utc_time_object(t)
    assert enc1.finish() == enc2.finish()

    # encode_generalized_time_object
    gt = synta.GeneralizedTime(2024, 6, 15, 12, 0, 0, None)
    enc1 = synta.Encoder(synta.Encoding.DER)
    enc1.encode_generalized_time(gt)
    enc2 = synta.Encoder(synta.Encoding.DER)
    enc2.encode_generalized_time_object(gt)
    assert enc1.finish() == enc2.finish()

    # encode_utf8_string_object
    s = synta.Utf8String("hello")
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_utf8_string_object(s)
    data = enc.finish()
    assert synta.Decoder(data, synta.Encoding.DER).decode_utf8_string().as_str() == "hello"

    # encode_printable_string_object
    ps = synta.PrintableString("Test Corp")
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_printable_string_object(ps)
    data = enc.finish()
    assert synta.Decoder(data, synta.Encoding.DER).decode_printable_string().as_str() == "Test Corp"

    # encode_ia5_string_object
    ia5 = synta.IA5String("user@example.com")
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_ia5_string_object(ia5)
    data = enc.finish()
    assert synta.Decoder(data, synta.Encoding.DER).decode_ia5_string().as_str() == "user@example.com"

    print("  ✓ encode_*_object variants: OK")


def test_numeric_string():
    """Test NumericString encode/decode"""
    print("Testing NumericString...")
    text = "12345 67890"
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_numeric_string(text)
    encoded = encoder.finish()

    # Tag 18 (0x12), primitive, universal
    assert encoded[0] == 0x12, f"Wrong tag: {encoded[0]:#x}"

    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    s = decoder.decode_numeric_string()
    assert s.as_str() == text
    assert str(s) == text
    assert len(s) == len(text)

    # Object creation — valid
    s2 = synta.NumericString("0 9")
    assert s2.as_str() == "0 9"
    assert s2 == synta.NumericString("0 9")

    # Invalid characters raise ValueError
    try:
        synta.NumericString("abc")
        assert False, "Should have raised ValueError"
    except ValueError:
        pass

    # encode_numeric_string_object round-trip
    obj = synta.NumericString("999")
    encoder2 = synta.Encoder(synta.Encoding.DER)
    encoder2.encode_numeric_string_object(obj)
    encoded2 = encoder2.finish()
    decoder2 = synta.Decoder(encoded2, synta.Encoding.DER)
    s3 = decoder2.decode_numeric_string()
    assert s3.as_str() == "999"

    print("  ✓ NumericString: OK")


def test_teletex_string():
    """Test TeletexString encode/decode"""
    print("Testing TeletexString...")
    data = b"hello\x80\xff"
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_teletex_string(data)
    encoded = encoder.finish()

    # Tag 20 (0x14), primitive, universal
    assert encoded[0] == 0x14, f"Wrong tag: {encoded[0]:#x}"

    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    s = decoder.decode_teletex_string()
    assert s.to_bytes() == data
    assert len(s) == len(data)

    # Object creation from bytes
    obj = synta.TeletexString(b"test")
    assert obj.to_bytes() == b"test"
    assert obj == synta.TeletexString(b"test")

    # from_str helper (Latin-1 encode)
    obj2 = synta.TeletexString.from_str("Hello")
    assert obj2.as_str() == "Hello"

    # encode_teletex_string_object round-trip
    encoder2 = synta.Encoder(synta.Encoding.DER)
    encoder2.encode_teletex_string_object(obj)
    encoded2 = encoder2.finish()
    decoder2 = synta.Decoder(encoded2, synta.Encoding.DER)
    s2 = decoder2.decode_teletex_string()
    assert s2.to_bytes() == b"test"

    print("  ✓ TeletexString: OK")


def test_visible_string():
    """Test VisibleString encode/decode"""
    print("Testing VisibleString...")
    text = "Hello, World!"
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_visible_string(text)
    encoded = encoder.finish()

    # Tag 26 (0x1a), primitive, universal
    assert encoded[0] == 0x1a, f"Wrong tag: {encoded[0]:#x}"

    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    s = decoder.decode_visible_string()
    assert s.as_str() == text
    assert str(s) == text
    assert len(s) == len(text)

    # Object creation — valid
    s2 = synta.VisibleString("test123")
    assert s2.as_str() == "test123"
    assert s2 == synta.VisibleString("test123")

    # Control characters are invalid
    try:
        synta.VisibleString("\x00")
        assert False, "Should have raised ValueError"
    except ValueError:
        pass

    # encode_visible_string_object round-trip
    obj = synta.VisibleString("visible")
    encoder2 = synta.Encoder(synta.Encoding.DER)
    encoder2.encode_visible_string_object(obj)
    encoded2 = encoder2.finish()
    decoder2 = synta.Decoder(encoded2, synta.Encoding.DER)
    s3 = decoder2.decode_visible_string()
    assert s3.as_str() == "visible"

    print("  ✓ VisibleString: OK")


def test_general_string():
    """Test GeneralString encode/decode"""
    print("Testing GeneralString...")
    data = b"krbtgt\x00"
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_general_string(data)
    encoded = encoder.finish()

    # Tag 27 (0x1b), primitive, universal
    assert encoded[0] == 0x1b, f"Wrong tag: {encoded[0]:#x}"

    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    s = decoder.decode_general_string()
    assert s.to_bytes() == data
    assert len(s) == len(data)

    # Object creation from bytes
    obj = synta.GeneralString(b"EXAMPLE.COM")
    assert obj.to_bytes() == b"EXAMPLE.COM"
    assert obj == synta.GeneralString(b"EXAMPLE.COM")

    # from_str helper (Latin-1 encode)
    obj2 = synta.GeneralString.from_str("test")
    assert obj2.as_str() == "test"

    # encode_general_string_object round-trip
    encoder2 = synta.Encoder(synta.Encoding.DER)
    encoder2.encode_general_string_object(obj)
    encoded2 = encoder2.finish()
    decoder2 = synta.Decoder(encoded2, synta.Encoding.DER)
    s2 = decoder2.decode_general_string()
    assert s2.to_bytes() == b"EXAMPLE.COM"

    print("  ✓ GeneralString: OK")


def test_universal_string():
    """Test UniversalString encode/decode"""
    print("Testing UniversalString...")
    text = "Hello"
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_universal_string(text)
    encoded = encoder.finish()

    # Tag 28 (0x1c), primitive, universal
    assert encoded[0] == 0x1c, f"Wrong tag: {encoded[0]:#x}"
    # UCS-4: 4 bytes per character
    assert len(encoded) == 2 + 4 * len(text)

    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    s = decoder.decode_universal_string()
    assert s.as_str() == text
    assert str(s) == text

    # Unicode content
    text2 = "你好"
    encoder2 = synta.Encoder(synta.Encoding.DER)
    encoder2.encode_universal_string(text2)
    encoded2 = encoder2.finish()
    decoder2 = synta.Decoder(encoded2, synta.Encoding.DER)
    s2 = decoder2.decode_universal_string()
    assert s2.as_str() == text2

    # Object creation
    obj = synta.UniversalString("test")
    assert obj.as_str() == "test"
    assert obj == synta.UniversalString("test")

    # from_bytes (UCS-4 BE)
    # "A" = 0x00 0x00 0x00 0x41
    obj2 = synta.UniversalString.from_bytes(b"\x00\x00\x00\x41")
    assert obj2.as_str() == "A"

    # encode_universal_string_object round-trip
    encoder3 = synta.Encoder(synta.Encoding.DER)
    encoder3.encode_universal_string_object(obj)
    encoded3 = encoder3.finish()
    decoder3 = synta.Decoder(encoded3, synta.Encoding.DER)
    s3 = decoder3.decode_universal_string()
    assert s3.as_str() == "test"

    print("  ✓ UniversalString: OK")


def test_bmp_string():
    """Test BMPString encode/decode"""
    print("Testing BMPString...")
    text = "café"
    encoder = synta.Encoder(synta.Encoding.DER)
    encoder.encode_bmp_string(text)
    encoded = encoder.finish()

    # Tag 30 (0x1e), primitive, universal
    assert encoded[0] == 0x1e, f"Wrong tag: {encoded[0]:#x}"

    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    s = decoder.decode_bmp_string()
    assert s.as_str() == text
    assert str(s) == text

    # Object creation — valid BMP string
    obj = synta.BmpString("Hello")
    assert obj.as_str() == "Hello"
    assert obj == synta.BmpString("Hello")

    # Supplementary plane characters (> U+FFFF) must be rejected
    try:
        synta.BmpString("\U0001F600")  # GRINNING FACE
        assert False, "Should have raised ValueError"
    except ValueError:
        pass

    # from_bytes (UCS-2 BE)
    # "A" = 0x00 0x41
    obj2 = synta.BmpString.from_bytes(b"\x00\x41")
    assert obj2.as_str() == "A"

    # encode_bmp_string_object round-trip
    encoder2 = synta.Encoder(synta.Encoding.DER)
    encoder2.encode_bmp_string_object(obj)
    encoded2 = encoder2.finish()
    decoder2 = synta.Decoder(encoded2, synta.Encoding.DER)
    s2 = decoder2.decode_bmp_string()
    assert s2.as_str() == "Hello"

    print("  ✓ BMPString: OK")


def test_encode_decode_sequence():
    """Test encode_sequence / decode_sequence"""
    print("Testing encode_sequence / decode_sequence...")
    # Build inner: INTEGER 42 + BOOLEAN TRUE
    inner = synta.Encoder(synta.Encoding.DER)
    inner.encode_integer(42)
    inner.encode_boolean(True)
    inner_bytes = inner.finish()

    outer = synta.Encoder(synta.Encoding.DER)
    outer.encode_sequence(inner_bytes)
    encoded = outer.finish()

    # Tag 0x30 = SEQUENCE
    assert encoded[0] == 0x30, f"Expected SEQUENCE tag 0x30, got {encoded[0]:#x}"
    assert encoded[1] == len(inner_bytes)

    # Decode via decode_sequence
    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    child = decoder.decode_sequence()
    assert decoder.is_empty()

    assert not child.is_empty()
    integer = child.decode_integer()
    assert integer.to_int() == 42

    assert not child.is_empty()
    boolean = child.decode_boolean()
    assert boolean.value() is True

    assert child.is_empty()

    print("  ✓ encode_sequence / decode_sequence: OK")


def test_encode_decode_set():
    """Test encode_set"""
    print("Testing encode_set...")
    inner = synta.Encoder(synta.Encoding.DER)
    inner.encode_integer(7)
    inner_bytes = inner.finish()

    outer = synta.Encoder(synta.Encoding.DER)
    outer.encode_set(inner_bytes)
    encoded = outer.finish()

    # Tag 0x31 = SET
    assert encoded[0] == 0x31, f"Expected SET tag 0x31, got {encoded[0]:#x}"
    assert encoded[1] == len(inner_bytes)

    print("  ✓ encode_set: OK")


def test_encode_decode_explicit_tag():
    """Test encode_explicit_tag / decode_explicit_tag"""
    print("Testing encode_explicit_tag / decode_explicit_tag...")
    # Encode an INTEGER wrapped in [1] EXPLICIT
    inner = synta.Encoder(synta.Encoding.DER)
    inner.encode_integer(99)
    inner_bytes = inner.finish()

    outer = synta.Encoder(synta.Encoding.DER)
    outer.encode_explicit_tag(1, "Context", inner_bytes)
    encoded = outer.finish()

    # Context-specific constructed tag [1]: 0xa1
    assert encoded[0] == 0xa1, f"Expected [1] EXPLICIT (0xa1), got {encoded[0]:#x}"

    # Decode the explicit wrapper
    decoder = synta.Decoder(encoded, synta.Encoding.DER)
    child = decoder.decode_explicit_tag(1)
    assert decoder.is_empty()

    # The child decoder should contain the raw INTEGER TLV
    integer = child.decode_integer()
    assert integer.to_int() == 99
    assert child.is_empty()

    # Wrong tag number raises ValueError
    decoder2 = synta.Decoder(encoded, synta.Encoding.DER)
    try:
        decoder2.decode_explicit_tag(2)
        assert False, "Should have raised ValueError"
    except ValueError:
        pass

    # Application and Private tag classes
    for cls in ("Application", "Private"):
        enc2 = synta.Encoder(synta.Encoding.DER)
        enc2.encode_explicit_tag(0, cls, inner_bytes)
        enc2.finish()  # just check it doesn't raise

    # Invalid class raises ValueError
    try:
        enc3 = synta.Encoder(synta.Encoding.DER)
        enc3.encode_explicit_tag(0, "Invalid", inner_bytes)
        assert False, "Should have raised ValueError"
    except ValueError:
        pass

    print("  ✓ encode_explicit_tag / decode_explicit_tag: OK")


def test_decode_any_new_string_types():
    """Test that decode_any returns correct types for new string variants"""
    print("Testing decode_any (new string types)...")

    # NumericString (tag 18 = 0x12)
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_numeric_string("123")
    data = enc.finish()
    decoder = synta.Decoder(data, synta.Encoding.DER)
    val = decoder.decode_any()
    assert isinstance(val, synta.NumericString), f"Got {type(val)}"
    assert val.as_str() == "123"

    # VisibleString (tag 26 = 0x1a)
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_visible_string("hi")
    data = enc.finish()
    decoder = synta.Decoder(data, synta.Encoding.DER)
    val = decoder.decode_any()
    assert isinstance(val, synta.VisibleString), f"Got {type(val)}"
    assert val.as_str() == "hi"

    # GeneralString (tag 27 = 0x1b)
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_general_string(b"realm")
    data = enc.finish()
    decoder = synta.Decoder(data, synta.Encoding.DER)
    val = decoder.decode_any()
    assert isinstance(val, synta.GeneralString), f"Got {type(val)}"
    assert val.to_bytes() == b"realm"

    # BMPString (tag 30 = 0x1e)
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_bmp_string("hi")
    data = enc.finish()
    decoder = synta.Decoder(data, synta.Encoding.DER)
    val = decoder.decode_any()
    assert isinstance(val, synta.BmpString), f"Got {type(val)}"
    assert val.as_str() == "hi"

    print("  ✓ decode_any (new string types): OK")


def test_decode_any_raw_element():
    """Test that decode_any returns RawElement for unknown tags"""
    print("Testing decode_any (RawElement for unknown tag)...")
    # Tag 25 (0x19) = ObjectDescriptor — not implemented, should produce RawElement
    # TLV: 0x19 (tag), 0x03 (len), b"abc"
    raw_tlv = bytes([0x19, 0x03, ord('a'), ord('b'), ord('c')])
    decoder = synta.Decoder(raw_tlv, synta.Encoding.DER)
    val = decoder.decode_any()
    assert isinstance(val, synta.RawElement), f"Got {type(val)}"
    assert val.tag_number == 25
    assert val.tag_class == "Universal"
    assert val.is_constructed is False
    assert val.data == b"abc"
    print("  ✓ decode_any (RawElement): OK")


def test_encode_integer_large():
    """Test encode_integer() accepts arbitrary Python ints (beyond i64/i128)."""
    print("Testing encode_integer with large Python ints...")

    enc = synta.Encoder(synta.Encoding.DER)

    # Normal i64 path still works
    enc.encode_integer(42)
    assert enc.finish() == b'\x02\x01\x2a'

    # Value beyond i64 but within i128 (e.g. 2^64)
    val = 2**64
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_integer(val)
    out = enc.finish()
    dec = synta.Decoder(out, synta.Encoding.DER)
    decoded = dec.decode_integer()
    assert decoded.to_bytes() == val.to_bytes((val.bit_length() + 8) // 8, 'big', signed=True)

    # 20-byte X.509 serial number: 2^159 - 1
    # bit_length=159 → byte_len=(159+8)//8=20; first byte 0x7f has high bit
    # clear so no extra sign byte is needed.
    serial = 2**159 - 1
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_integer(serial)
    out = enc.finish()
    dec = synta.Decoder(out, synta.Encoding.DER)
    decoded = dec.decode_integer()
    expected = b'\x7f' + b'\xff' * 19  # 20 bytes, positive
    assert decoded.to_bytes() == expected, f"Got {decoded.to_bytes().hex()}"

    # Positive value with high bit set — needs 0x00 prefix
    val = 2**127  # bit_length=128, needs 17 bytes signed
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_integer(val)
    out = enc.finish()
    assert out[0] == 0x02  # tag INTEGER
    assert out[2] == 0x00  # leading sign byte for positive

    # Negative values use two's complement
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_integer(-128)
    assert enc.finish() == b'\x02\x01\x80'

    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_integer(-129)
    assert enc.finish() == b'\x02\x02\xff\x7f'

    print("  encode_integer large ints: OK")


def test_decoder_remaining_bytes():
    """Test PyDecoder.remaining_bytes() for primitive implicit tags."""
    print("Testing Decoder.remaining_bytes()...")

    # Build a GeneralName-like structure with an implicit dNSName [2] tag.
    # dNSName [2] IMPLICIT IA5String "example.com"
    # Tag: 0x82 (context-specific, primitive, tag 2)
    name = b"example.com"
    tlv = bytes([0x82, len(name)]) + name

    decoder = synta.Decoder(tlv, synta.Encoding.DER)
    child = decoder.decode_implicit_tag(2, "Context")

    # remaining_bytes() returns the raw value content (no TLV header)
    raw = child.remaining_bytes()
    assert raw == name, f"Got {raw!r}, expected {name!r}"
    assert raw.decode("ascii") == "example.com"

    # remaining_bytes() is non-consuming: position is unchanged
    assert child.remaining() == len(name)
    raw2 = child.remaining_bytes()
    assert raw2 == name

    # Also works at top-level: bytes left after a partial decode
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_integer(1)
    enc.encode_integer(2)
    combined = enc.finish()
    dec = synta.Decoder(combined, synta.Encoding.DER)
    dec.decode_integer()  # consume the first INTEGER
    # remaining_bytes() returns the second INTEGER TLV intact
    rest = dec.remaining_bytes()
    assert rest == b'\x02\x01\x02'

    print("  Decoder.remaining_bytes(): OK")


def test_certificate_get_extension_value_der():
    """Test Certificate.get_extension_value_der()."""
    print("Testing Certificate.get_extension_value_der()...")

    der = base64.b64decode(_RSA_CERT_PEM)
    cert = synta.Certificate.from_der(der)

    # BasicConstraints (oids.BASIC_CONSTRAINTS) is present; its DER value is
    # SEQUENCE { BOOLEAN TRUE } = 30 03 01 01 ff
    bc = cert.get_extension_value_der(oids.BASIC_CONSTRAINTS)
    assert bc is not None, "BasicConstraints extension not found"
    assert bc == bytes.fromhex("30030101ff"), f"Unexpected BasicConstraints: {bc.hex()}"

    # Verify the bytes are directly decodable by synta Decoder
    bc_dec = synta.Decoder(bc, synta.Encoding.DER)
    bc_seq = bc_dec.decode_sequence()
    ca_flag = bc_seq.decode_boolean()
    assert ca_flag.value() is True

    # SubjectKeyIdentifier (oids.SUBJECT_KEY_IDENTIFIER) is a 20-byte key
    # identifier wrapped in an OCTET STRING: 04 14 <20 bytes>
    ski = cert.get_extension_value_der(oids.SUBJECT_KEY_IDENTIFIER)
    assert ski is not None, "SKI extension not found"
    assert ski[0] == 0x04 and ski[1] == 0x14, \
        f"Expected OCTET STRING(20), got {ski.hex()}"

    # Absent OID returns None
    assert cert.get_extension_value_der("1.2.3.4") is None

    # Invalid OID string raises ValueError
    try:
        cert.get_extension_value_der("not-an-oid")
        assert False, "Expected ValueError"
    except ValueError:
        pass

    # Demonstrate the full SAN-parsing pattern using a synthetic SubjectAltName.
    # Build: SEQUENCE OF { dNSName [2] "example.com", iPAddress [7] 127.0.0.1 }
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_implicit_tag(2, "Context", False, b"example.com")
    enc.encode_implicit_tag(7, "Context", False, bytes([127, 0, 0, 1]))
    san_der = synta.Encoder(synta.Encoding.DER)
    san_der.encode_sequence(enc.finish())
    san_bytes = san_der.finish()

    dec = synta.Decoder(san_bytes, synta.Encoding.DER)
    san_seq = dec.decode_sequence()

    dns_name = None
    ip_addr = None
    while not san_seq.is_empty():
        tag_num, tag_class, _ = san_seq.peek_tag()
        child = san_seq.decode_implicit_tag(tag_num, "Context")
        if tag_num == 2:
            dns_name = child.remaining_bytes().decode("ascii")
        elif tag_num == 7:
            ip_addr = child.remaining_bytes()

    assert dns_name == "example.com", f"Got {dns_name!r}"
    assert ip_addr == bytes([127, 0, 0, 1]), f"Got {ip_addr!r}"

    print("  Certificate.get_extension_value_der(): OK")


def test_oid_from_der_value():
    """Test ObjectIdentifier.from_der_value() for implicit-tagged OID decoding."""
    print("Testing ObjectIdentifier.from_der_value()...")

    # --- round-trip: encode an OID, strip TLV header, parse content bytes ---
    # sha256WithRSAEncryption (oids.SHA256_WITH_RSA)
    enc = synta.Encoder(synta.Encoding.DER)
    enc.encode_oid(oids.SHA256_WITH_RSA)
    tlv = enc.finish()
    # tlv[0] == 0x06 (tag), tlv[1] == length, tlv[2:] == content
    assert tlv[0] == 0x06
    length = tlv[1]
    content = tlv[2 : 2 + length]
    oid = synta.ObjectIdentifier.from_der_value(content)
    assert oid == oids.SHA256_WITH_RSA, f"Got {oid}"

    # --- well-known short OID: 2.5.4.3 (commonName) ---
    # DER content bytes for 2.5.4.3 are 0x55 0x04 0x03
    content_cn = bytes([0x55, 0x04, 0x03])
    oid_cn = synta.ObjectIdentifier.from_der_value(content_cn)
    assert str(oid_cn) == "2.5.4.3", f"Got {oid_cn}"

    # --- registeredID [8] IMPLICIT OID simulation ---
    # Build a synthetic GeneralName registeredID [8] wrapping OID 2.5.4.3
    enc2 = synta.Encoder(synta.Encoding.DER)
    # [8] IMPLICIT OID: tag = 0x88 (context 8, primitive), value = raw OID content
    enc2.encode_implicit_tag(8, "Context", False, content_cn)
    san_bytes = enc2.finish()

    dec = synta.Decoder(san_bytes, synta.Encoding.DER)
    tag_num, tag_class, constructed = dec.peek_tag()
    assert tag_num == 8 and tag_class == "Context" and not constructed
    child = dec.decode_implicit_tag(8, "Context")
    raw = child.remaining_bytes()
    assert raw == content_cn
    oid_reg = synta.ObjectIdentifier.from_der_value(raw)
    assert str(oid_reg) == "2.5.4.3", f"Got {oid_reg}"

    # --- error cases ---
    try:
        synta.ObjectIdentifier.from_der_value(b"")
        assert False, "Expected ValueError for empty input"
    except ValueError:
        pass

    try:
        synta.ObjectIdentifier.from_der_value(b"\xff\xff")  # invalid encoding
        assert False, "Expected ValueError for invalid OID bytes"
    except (ValueError, synta.SyntaError):
        pass

    print("  ObjectIdentifier.from_der_value(): OK")


def test_all_in_dir():
    """Every name in synta.__all__ must also appear in dir(synta)."""
    print("Testing synta.__all__ consistency...")
    missing = set(synta.__all__) - set(dir(synta))
    assert not missing, (
        f"Names listed in synta.__all__ but not found in dir(synta): {sorted(missing)}"
    )
    print("  synta.__all__ ⊆ dir(synta): OK")


def test_oids_submodule():
    """Test synta.oids constants and helper functions"""
    print("Testing synta.oids submodule...")
    import synta.oids as oids
    from synta.oids import SHA256_WITH_RSA, ED25519, ML_DSA_44
    from synta.oids.attr import COMMON_NAME, COUNTRY, ORGANIZATION

    # Constants are ObjectIdentifier instances
    assert isinstance(SHA256_WITH_RSA, synta.ObjectIdentifier)
    assert str(SHA256_WITH_RSA) == "1.2.840.113549.1.1.11"
    assert str(ED25519) == "1.3.101.112"
    assert str(ML_DSA_44) == "2.16.840.1.101.3.4.3.17"

    # String equality and set membership (requires hash+eq consistency)
    assert SHA256_WITH_RSA == "1.2.840.113549.1.1.11"
    assert SHA256_WITH_RSA in {"1.2.840.113549.1.1.11", "1.2.840.113549.1.1.5"}
    assert ED25519 not in {"1.2.840.113549.1.1.11"}

    # DN attribute OIDs
    assert str(COMMON_NAME) == "2.5.4.3"
    assert str(COUNTRY) == "2.5.4.6"
    assert str(ORGANIZATION) == "2.5.4.10"

    # All algorithm families present
    assert str(oids.ML_KEM_512) == "2.16.840.1.101.3.4.4.1"
    assert str(oids.SLH_DSA_SHA2_128S) == "2.16.840.1.101.3.4.3.20"
    assert str(oids.SHA3_256) == "2.16.840.1.101.3.4.2.8"
    assert str(oids.SUBJECT_ALT_NAME) == "2.5.29.17"
    assert str(oids.EC_CURVE_P256) == "1.2.840.10045.3.1.7"

    # identify_signature_algorithm (ObjectIdentifier and str)
    assert oids.identify_signature_algorithm(SHA256_WITH_RSA) == "SHA256WithRSA"
    assert oids.identify_signature_algorithm(ED25519) == "Ed25519"
    assert oids.identify_signature_algorithm(ML_DSA_44) == "ML-DSA-44"
    assert oids.identify_signature_algorithm("1.2.840.113549.1.1.11") == "SHA256WithRSA"
    assert oids.identify_signature_algorithm(synta.ObjectIdentifier("1.2.99999")) == "Other"

    # identify_public_key_algorithm
    assert oids.identify_public_key_algorithm(oids.RSA_ENCRYPTION) == "RSA"
    assert oids.identify_public_key_algorithm(oids.EC_PUBLIC_KEY) == "ECDSA"
    assert oids.identify_public_key_algorithm(synta.ObjectIdentifier("1.2.99999")) is None

    # EC curve helpers
    assert oids.ec_curve_short_name(oids.EC_CURVE_P256) == "prime256v1"
    assert oids.ec_curve_short_name(oids.EC_CURVE_P384) == "secp384r1"
    assert oids.ec_curve_short_name(synta.ObjectIdentifier("1.2.99999")) is None

    assert oids.ec_curve_nist_name(oids.EC_CURVE_P256) == "P-256"
    assert oids.ec_curve_nist_name(oids.EC_CURVE_SECP256K1) is None  # no NIST name

    assert oids.ec_curve_key_bits(oids.EC_CURVE_P256) == 256
    assert oids.ec_curve_key_bits(oids.EC_CURVE_P521) == 521
    assert oids.ec_curve_key_bits(synta.ObjectIdentifier("1.2.99999")) is None

    # extension_oid_name
    assert oids.extension_oid_name(oids.KEY_USAGE) == "X509v3 Key Usage"
    assert oids.extension_oid_name(oids.SUBJECT_ALT_NAME) == "X509v3 Subject Alternative Name"
    assert oids.extension_oid_name(synta.ObjectIdentifier("1.2.99999")) == "1.2.99999"

    # RFC 9925 unsigned certificate OIDs
    assert str(oids.ALG_UNSIGNED) == "1.3.6.1.5.5.7.6.36"
    assert str(oids.RDNA_UNSIGNED) == "1.3.6.1.5.5.7.25.1"
    assert oids.identify_signature_algorithm(oids.ALG_UNSIGNED) == "Unsigned"

    print("  synta.oids submodule: OK")


def main():
    """Run all tests"""
    print("=" * 60)
    print("Synta Python Bindings - Basic Tests")
    print("=" * 60)
    print()

    tests = [
        test_integer_decode,
        test_integer_encode,
        test_large_integer,
        test_oid_decode,
        test_oid_create,
        test_oid_from_components,
        test_oid_encode,
        test_octet_string_decode,
        test_octet_string_encode,
        test_boolean_decode,
        test_boolean_encode,
        test_bit_string_create,
        test_bit_string_encode_decode,
        test_decoder_state,
        test_error_handling,
        test_null_decode,
        test_null_encode,
        test_utf8_string,
        test_printable_string,
        test_ia5_string,
        test_integer_to_i128,
        test_utc_time_constructor,
        test_generalized_time_constructor,
        test_decode_any_real,
        test_decode_any_primitive,
        test_decode_any_sequence,
        test_certificate_rsa,
        test_certificate_ecdsa,
        test_certificate_serial_number_round_trip,
        test_certificate_invalid,
        test_real_decode,
        test_real_encode,
        test_real_object,
        test_encode_object_variants,
        test_numeric_string,
        test_teletex_string,
        test_visible_string,
        test_general_string,
        test_universal_string,
        test_bmp_string,
        test_encode_decode_sequence,
        test_encode_decode_set,
        test_encode_decode_explicit_tag,
        test_decode_any_new_string_types,
        test_decode_any_raw_element,
        test_encode_integer_large,
        test_decoder_remaining_bytes,
        test_certificate_get_extension_value_der,
        test_oid_from_der_value,
        test_all_in_dir,
        test_oids_submodule,
    ]

    for test in tests:
        try:
            test()
        except Exception as e:
            print(f"  ✗ {test.__name__} FAILED: {e}")
            raise

    print()
    print("=" * 60)
    print(f"All {len(tests)} tests passed! ✓")
    print("=" * 60)


if __name__ == '__main__':
    main()