Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-06-25 08:26
📄 __init__.py	1 B	2024-10-09 06:13
📄 test_base_detection.py from charset_normalizer.api import from_bytes from charset_normalizer.models import CharsetMatches import pytest def test_empty(): best_guess = from_bytes(b'').best() assert best_guess is not None, "Empty bytes payload SHOULD NOT return None" assert best_guess.encoding == "utf_8", "Empty bytes payload SHOULD be guessed as UTF-8 (arbitrary)" assert len(best_guess.alphabets) == 0, "" def test_bool_matches(): guesses_not_empty = from_bytes(b'') guesses_empty = CharsetMatches([]) assert bool(guesses_not_empty) is True, "Bool behaviour of CharsetMatches altered, should be True" assert bool(guesses_empty) is False, "Bool behaviour of CharsetMatches altered, should be False" @pytest.mark.parametrize( "payload, expected_encoding", [ (b'\xfe\xff', 'utf_16'), ('\uFEFF'.encode('gb18030'), 'gb18030'), (b'\xef\xbb\xbf', 'utf_8'), ("".encode('utf_32'), "utf_32") ] ) def test_empty_but_with_bom_or_sig(payload, expected_encoding): best_guess = from_bytes(payload).best() assert best_guess is not None, "Empty detection but with SIG/BOM has failed!" assert best_guess.encoding == expected_encoding, "Empty detection but with SIG/BOM is wrongly detected!" assert best_guess.raw == payload, "The RAW property should contain the original payload given for detection." assert best_guess.byte_order_mark is True, "The BOM/SIG property should return True" assert str(best_guess) == "", "The cast to str SHOULD be empty" @pytest.mark.parametrize( "payload, expected_encoding", [ ((u'\uFEFF' + '我没有埋怨，磋砣的只是一些时间。').encode('gb18030'), "gb18030",), ('我没有埋怨，磋砣的只是一些时间。'.encode('utf_32'), "utf_32",), ('我没有埋怨，磋砣的只是一些时间。'.encode('utf_8_sig'), "utf_8",), ] ) def test_content_with_bom_or_sig(payload, expected_encoding): best_guess = from_bytes(payload).best() assert best_guess is not None, "Detection but with SIG/BOM has failed!" assert best_guess.encoding == expected_encoding, "Detection but with SIG/BOM is wrongly detected!" assert best_guess.byte_order_mark is True, "The BOM/SIG property should return True" @pytest.mark.parametrize( "payload", [ b"AbAdZ pOoooOlDl mmlDoDkA lldDkeEkddA mpAlkDF", b"g4UsPJdfzNkGW2jwmKDGDilKGKYtpF2X.mx3MaTWL1tL7CNn5U7DeCcodKX7S3lwwJPKNjBT8etY", b'{"token": "g4UsPJdfzNkGW2jwmKDGDilKGKYtpF2X.mx3MaTWL1tL7CNn5U7DeCcodKX7S3lwwJPKNjBT8etY"}', b"81f4ab054b39cb0e12701e734077d84264308f5fc79494fc5f159fa2ebc07b73c8cc0e98e009664a20986706f90146e8eefcb929ce1f74a8eab21369fdc70198", b"{}", ] ) def test_obviously_ascii_content(payload): best_guess = from_bytes(payload).best() assert best_guess is not None, "Dead-simple ASCII detection has failed!" assert best_guess.encoding == "ascii", "Dead-simple ASCII detection is wrongly detected!" @pytest.mark.parametrize( "payload", [ '\u020d\x1b'.encode('utf-8'), 'h\xe9llo world!\n'.encode('utf_8'), '我没有埋怨，磋砣的只是一些时间。'.encode('utf_8'), 'Bсеки човек има право на образование. Oбразованието трябва да бъде безплатно, поне що се отнася до началното и основното образование.'.encode('utf_8'), 'Bсеки човек има право на образование.'.encode('utf_8'), "(° ͜ʖ °), creepy face, smiley 😀".encode("utf_8"), """["Financiën", "La France"]""".encode("utf_8"), "Qu'est ce que une étoile?".encode("utf_8"), """<?xml ?><c>Financiën</c>""".encode("utf_8"), "😀".encode("utf_8") ] ) def test_obviously_utf8_content(payload): best_guess = from_bytes(payload).best() assert best_guess is not None, "Dead-simple UTF-8 detection has failed!" assert best_guess.encoding == "utf_8", "Dead-simple UTF-8 detection is wrongly detected!" def test_mb_cutting_chk(): # This payload should be wrongfully split and the autofix should ran automatically # on chunks extraction. payload = b"\xbf\xaa\xbb\xe7\xc0\xfb \xbf\xb9\xbc\xf6 " \ b" \xbf\xac\xb1\xb8\xc0\xda\xb5\xe9\xc0\xba \xba\xb9\xc0\xbd\xbc\xad\xb3\xaa " * 128 guesses = from_bytes(payload, cp_isolation=["cp949"]) best_guess = guesses.best() assert len(guesses) == 1, "cp isolation is set and given seq should be clear CP949!" assert best_guess.encoding == "cp949" def test_alphabets_property(): best_guess = from_bytes( "😀 Hello World! How affairs are going? 😀".encode("utf_8") ).best() assert "Basic Latin" in best_guess.alphabets assert "Emoticons range(Emoji)" in best_guess.alphabets assert best_guess.alphabets.count("Basic Latin") == 1 def test_doc_example_short_cp1251(): best_guess = from_bytes( 'Bсеки човек има право на образование.'.encode('cp1251') ).best() assert best_guess.encoding == "cp1251" def test_direct_cmp_charset_match(): best_guess = from_bytes( "😀 Hello World! How affairs are going? 😀".encode("utf_8") ).best() assert best_guess == "utf_8" assert best_guess == "utf-8" assert best_guess != 8 assert best_guess != None	5.3 KB	2024-10-09 06:13
📄 test_cli.py import unittest from charset_normalizer.cli import cli_detect, query_yes_no from unittest.mock import patch from os.path import exists from os import remove, path, pardir DIR_PATH = path.join( path.dirname(path.realpath(__file__)), pardir ) class TestCommandLineInterface(unittest.TestCase): @patch('builtins.input', lambda args: 'y') def test_simple_yes_input(self): self.assertTrue( query_yes_no('Are u willing to chill a little bit ?') ) @patch('builtins.input', lambda args: 'N') def test_simple_no_input(self): self.assertFalse( query_yes_no('Are u willing to chill a little bit ?') ) def test_single_file(self): self.assertEqual( 0, cli_detect( [DIR_PATH + '/data/sample-arabic-1.txt'] ) ) def test_version_output_success(self): with self.assertRaises(SystemExit): cli_detect( ['--version'] ) def test_single_file_normalize(self): self.assertEqual( 0, cli_detect( [ DIR_PATH + '/data/sample-arabic-1.txt', '--normalize' ] ) ) self.assertTrue( exists(DIR_PATH + '/data/sample-arabic-1.cp1256.txt') ) try: remove(DIR_PATH + '/data/sample-arabic-1.cp1256.txt') except: pass def test_single_verbose_file(self): self.assertEqual( 0, cli_detect( [DIR_PATH + '/data/sample-arabic-1.txt', '--verbose'] ) ) def test_multiple_file(self): self.assertEqual( 0, cli_detect( [ DIR_PATH + '/data/sample-arabic-1.txt', DIR_PATH + '/data/sample-french.txt', DIR_PATH + '/data/sample-chinese.txt' ] ) ) def test_with_alternative(self): self.assertEqual( 0, cli_detect( [ '-a', DIR_PATH + '/data/sample-arabic-1.txt', DIR_PATH + '/data/sample-french.txt', DIR_PATH + '/data/sample-chinese.txt' ] ) ) def test_with_minimal_output(self): self.assertEqual( 0, cli_detect( [ '-m', DIR_PATH + '/data/sample-arabic-1.txt', DIR_PATH + '/data/sample-french.txt', DIR_PATH + '/data/sample-chinese.txt' ] ) ) def test_with_minimal_and_alt(self): self.assertEqual( 0, cli_detect( [ '-m', '-a', DIR_PATH + '/data/sample-arabic-1.txt', DIR_PATH + '/data/sample-french.txt', DIR_PATH + '/data/sample-chinese.txt' ] ) ) def test_non_existent_file(self): with self.assertRaises(SystemExit) as cm: cli_detect( [DIR_PATH + '/data/not_found_data.txt'] ) self.assertEqual(cm.exception.code, 2) def test_replace_without_normalize(self): self.assertEqual( cli_detect( [ DIR_PATH + '/data/sample-arabic-1.txt', '--replace' ] ), 1 ) def test_force_replace_without_replace(self): self.assertEqual( cli_detect( [ DIR_PATH + '/data/sample-arabic-1.txt', '--force' ] ), 1 ) if __name__ == '__main__': unittest.main()	3.87 KB	2024-10-09 06:13
📄 test_coherence_detection.py import pytest from charset_normalizer.cd import encoding_languages, mb_encoding_languages, is_multi_byte_encoding, get_target_features, filter_alt_coherence_matches @pytest.mark.parametrize( "iana_encoding, expected_languages", [ ("cp864", ["Arabic", "Farsi"]), ("cp862", ["Hebrew"]), ("cp737", ["Greek"]), ("cp424", ["Hebrew"]), ("cp273", ["Latin Based"]), ("johab", ["Korean"]), ("shift_jis", ["Japanese"]), ("mac_greek", ["Greek"]), ("iso2022_jp", ["Japanese"]) ] ) def test_infer_language_from_cp(iana_encoding, expected_languages): languages = mb_encoding_languages(iana_encoding) if is_multi_byte_encoding(iana_encoding) else encoding_languages(iana_encoding) for expected_language in expected_languages: assert expected_language in languages, "Wrongly detected language for given code page" @pytest.mark.parametrize( "language, expected_have_accents, expected_pure_latin", [ ("English", False, True), ("French", True, True), ("Hebrew", False, False), ("Arabic", False, False), ("Vietnamese", True, True), ("Turkish", True, True) ] ) def test_target_features(language, expected_have_accents, expected_pure_latin): target_have_accents, target_pure_latin = get_target_features(language) assert target_have_accents is expected_have_accents assert target_pure_latin is expected_pure_latin @pytest.mark.parametrize( "matches, expected_return", [ ([("English", 0.88,), ("English—", 0.99)], [("English", 0.99)]), ([("English", 0.88,), ("English—", 0.99), ("English——", 0.999)], [("English", 0.999)]), ([("English", 0.88,), ("English—", 0.77)], [("English", 0.88)]), ([("English", 0.88,), ("Italian", 0.77)], [("English", 0.88), ("Italian", 0.77)]), ] ) def test_filter_alt_coherence_matches(matches, expected_return): results = filter_alt_coherence_matches(matches) assert results == expected_return	1.99 KB	2024-10-09 06:13
📄 test_detect_legacy.py import unittest from charset_normalizer.legacy import detect class TestDetectLegacy(unittest.TestCase): def test_detect_dict_keys(self): r = detect( (u'\uFEFF' + '我没有埋怨，磋砣的只是一些时间。').encode('gb18030') ) with self.subTest('encoding key present'): self.assertIn( 'encoding', r.keys() ) with self.subTest('language key present'): self.assertIn( 'language', r.keys() ) with self.subTest('confidence key present'): self.assertIn( 'confidence', r.keys() ) def test_detect_dict_value_type(self): r = detect( '我没有埋怨，磋砣的只是一些时间。'.encode('utf_8') ) with self.subTest('encoding instance of str'): self.assertIsInstance( r['encoding'], str ) with self.subTest('language instance of str'): self.assertIsInstance( r['language'], str ) with self.subTest('confidence instance of float'): self.assertIsInstance( r['confidence'], float ) def test_detect_dict_value(self): r = detect( '我没有埋怨，磋砣的只是一些时间。'.encode('utf_32') ) with self.subTest('encoding is equal to utf_32'): self.assertEqual( r['encoding'], 'UTF-32' ) def test_utf8_sig_not_striped(self): r = detect( "Hello World".encode('utf-8-sig') ) with self.subTest("Verify that UTF-8-SIG is returned when using legacy detect"): self.assertEqual( r['encoding'], "UTF-8-SIG" )	1.92 KB	2024-10-09 06:13
📄 test_edge_case.py from charset_normalizer import from_bytes import pytest import platform @pytest.mark.xfail(platform.python_version_tuple()[0] == "3" and platform.python_version_tuple()[1] == "7", reason="Unicode database is too old for this case (Python 3.7)") def test_unicode_edge_case(): payload = b'\xef\xbb\xbf\xf0\x9f\xa9\xb3' best_guess = from_bytes(payload).best() assert best_guess is not None, "Payload should have given something, detection failure" assert best_guess.encoding == "utf_8", "UTF-8 payload wrongly detected" def test_issue_gh520(): """Verify that minorities does not strip basic latin characters!""" payload = b"/includes/webform.compon\xd2\xaants.inc/" best_guess = from_bytes(payload).best() assert best_guess is not None, "Payload should have given something, detection failure" assert "Basic Latin" in best_guess.alphabets def test_issue_gh509(): """Two common ASCII punctuations should render as-is.""" payload = b");" best_guess = from_bytes(payload).best() assert best_guess is not None, "Payload should have given something, detection failure" assert "ascii" == best_guess.encoding def test_issue_gh498(): """This case was mistaken for utf-16-le, this should never happen again.""" payload = b'\x84\xae\xaa\xe3\xac\xa5\xad\xe2 Microsoft Word.docx' best_guess = from_bytes(payload).best() assert best_guess is not None, "Payload should have given something, detection failure" assert "Cyrillic" in best_guess.alphabets	1.49 KB	2024-10-09 06:13
📄 test_full_detection.py from charset_normalizer.api import from_path import pytest from os import path, pardir DIR_PATH = path.join( path.dirname(path.realpath(__file__)), pardir ) @pytest.mark.parametrize( "input_data_file, expected_charset, expected_language", [ ('sample-arabic-1.txt', 'cp1256', 'Arabic'), ('sample-french-1.txt', 'cp1252', 'French'), ('sample-arabic.txt', 'utf_8', 'Arabic'), ('sample-russian-3.txt', 'utf_8', 'Russian'), ('sample-french.txt', 'utf_8', 'French'), ('sample-chinese.txt', 'big5', 'Chinese'), ('sample-greek.txt', 'cp1253', 'Greek'), ('sample-greek-2.txt', 'cp1253', 'Greek'), ('sample-hebrew-2.txt', 'cp1255', 'Hebrew'), ('sample-hebrew-3.txt', 'cp1255', 'Hebrew'), ('sample-bulgarian.txt', 'utf_8', 'Bulgarian'), ('sample-english.bom.txt', 'utf_8', 'English'), ('sample-spanish.txt', 'utf_8', 'Spanish'), ('sample-korean.txt', 'cp949', 'Korean'), ('sample-turkish.txt', 'cp1254', 'Turkish'), ('sample-russian-2.txt', 'utf_8', 'Russian'), ('sample-russian.txt', 'mac_cyrillic', 'Russian'), ('sample-polish.txt', 'utf_8', 'Polish'), ] ) def test_elementary_detection( input_data_file: str, expected_charset: str, expected_language: str, ): best_guess = from_path(DIR_PATH + "/data/{}".format(input_data_file)).best() assert best_guess is not None, "Elementary detection has failed upon '{}'".format(input_data_file) assert best_guess.encoding == expected_charset, "Elementary charset detection has failed upon '{}'".format(input_data_file) assert best_guess.language == expected_language, "Elementary language detection has failed upon '{}'".format(input_data_file)	1.73 KB	2024-10-09 06:13
📄 test_isbinary.py import pytest import typing from io import BytesIO from base64 import b64decode from charset_normalizer import is_binary from os import path, pardir DIR_PATH = path.join( path.dirname(path.realpath(__file__)), pardir ) @pytest.mark.parametrize( "raw, expected", [ (b'\x00\x5f\x2f\xff'*50, True), (b64decode("R0lGODlhAQABAAAAACw="), True), (BytesIO(b64decode("R0lGODlhAQABAAAAACw=")), True), ('sample-polish.txt', False), ('sample-arabic.txt', False) ] ) def test_isbinary(raw: typing.Union[bytes, typing.BinaryIO, str], expected: bool) -> None: if isinstance(raw, str): raw = DIR_PATH + "/data/{}".format(raw) assert is_binary(raw) is expected	724 B	2024-10-09 06:13
📄 test_large_payload.py import pytest from charset_normalizer import from_bytes from charset_normalizer.constant import TOO_BIG_SEQUENCE def test_large_payload_u8_sig_basic_entry(): payload = ('0' * TOO_BIG_SEQUENCE).encode("utf_8_sig") best_guess = from_bytes(payload).best() assert best_guess is not None, "Large U8 payload case detection completely failed" assert best_guess.encoding == "utf_8", "Large U8 payload case detection wrongly detected!" assert best_guess.bom is True, "SIG/BOM property should be True" assert len(best_guess.raw) == len(payload), "Large payload should remain untouched when accessed through .raw" assert best_guess._string is not None, "str should be decoded before direct access (sig available)" def test_large_payload_ascii_basic_entry(): payload = ('0' * TOO_BIG_SEQUENCE).encode("utf_8") best_guess = from_bytes(payload).best() assert best_guess is not None, "Large ASCII payload case detection completely failed" assert best_guess.encoding == "ascii", "Large ASCII payload case detection wrongly detected!" assert best_guess.bom is False, "SIG/BOM property should be False" assert len(best_guess.raw) == len(payload), "Large payload should remain untouched when accessed through .raw" assert best_guess._string is None, "str should not be decoded until direct access" def test_misleading_large_sequence(): content = (("hello simple ascii " * TOO_BIG_SEQUENCE) + ('我没有埋怨，磋砣的只是一些时间。磋砣的只是一些时间。')) .encode('utf_8') guesses = from_bytes(content) assert len(guesses) > 0 match = guesses.best() assert match is not None assert match._string is not None, "str should be cached as only match" assert match.encoding == 'utf_8' assert str(match) is not None	1.77 KB	2024-10-09 06:13
📄 test_logging.py import pytest import logging from charset_normalizer.utils import set_logging_handler from charset_normalizer.api import from_bytes, explain_handler from charset_normalizer.constant import TRACE class TestLogBehaviorClass: def setup_method(self): self.logger = logging.getLogger("charset_normalizer") self.logger.handlers.clear() self.logger.addHandler(logging.NullHandler()) self.logger.level = logging.WARNING def test_explain_true_behavior(self, caplog): test_sequence = b'This is a test sequence of bytes that should be sufficient' from_bytes(test_sequence, steps=1, chunk_size=50, explain=True) assert explain_handler not in self.logger.handlers for record in caplog.records: assert record.levelname in ["Level 5", "DEBUG"] def test_explain_false_handler_set_behavior(self, caplog): test_sequence = b'This is a test sequence of bytes that should be sufficient' set_logging_handler(level=TRACE, format_string="%(message)s") from_bytes(test_sequence, steps=1, chunk_size=50, explain=False) assert any(isinstance(hdl, logging.StreamHandler) for hdl in self.logger.handlers) for record in caplog.records: assert record.levelname in ["Level 5", "DEBUG"] assert "Encoding detection: ascii is most likely the one." in caplog.text def test_set_stream_handler(self, caplog): set_logging_handler( "charset_normalizer", level=logging.DEBUG ) self.logger.debug("log content should log with default format") for record in caplog.records: assert record.levelname in ["Level 5", "DEBUG"] assert "log content should log with default format" in caplog.text def test_set_stream_handler_format(self, caplog): set_logging_handler( "charset_normalizer", format_string="%(message)s" ) self.logger.info("log content should only be this message") assert caplog.record_tuples == [ ( "charset_normalizer", logging.INFO, "log content should only be this message", ) ]	2.15 KB	2024-10-09 06:13
📄 test_mess_detection.py import pytest from charset_normalizer.md import mess_ratio @pytest.mark.parametrize( "content, min_expected_ratio, max_expected_ratio", [ ('典肇乎庚辰年十二月廿一，及己丑年二月十九，收各方語言二百五十，合逾七百萬目；二十大卷佔八成，單英文卷亦過二百萬。悉文乃天下有志共筆而成；有意助之，幾網路、隨纂作，大典茁焉。', 0., 0.), ('العقلية , التنويم المغناطيسي و / أو الاقتراح', 0., 0.), ("RadoZ تـــعــــديــل الـــتــــوقــيــــت مـــن قــبــل", 0., 0.), ("Cehennemin Sava■þ²s²'da kim?", 0.1, 0.5), ("´Á¥½³ø§i -- ±i®Ìºû, ³¯·Ø©v", 0.5, 1.), ("ïstanbul, T■rkiye'nin en kalabal»k, iktisadi ve k■lt■rel aÓ»dan en —nemli", 0.1, 0.5), ("<i>Parce que Óa, c'est la vÕritable histoire de la rencontre avec votre Tante Robin.</i>", 0.01, 0.5), ("""ØĢØŠØģØ§ØĶŲ ŲŲ ØĢŲ Ø§ŲŲØ§Øģ ŲŲŲ ŲØ§ ØģŲŲŲØŠØģØ§ØĶŲŲŲØ ØŊØđŲØ§ ŲØģŲØđ ØđŲ (ŲØąŲØŊŲ) ŲØ§ŲØŪØ§ØŠŲ""", 0.8, 3.0), ("""ÇáÚŞáíÉ , ÇáÊäæíã ÇáãÛäÇØíÓí æ / Ãæ ÇáÇŞÊÑÇÍ""", 0.8, 2.5), ("""hishamkoc@yahoo.com ุชุฑุฌูููุฉ ููุดูููุงู ุงููููููููุงูRadoZ ุชูููุนููููุฏูููู ุงููููุชูููููููููููููุช ููููู ูููุจููู""", 0.5, 2.0) ] ) def test_mess_detection(content, min_expected_ratio, max_expected_ratio): calculated_mess_ratio = mess_ratio( content, maximum_threshold=1. ) assert min_expected_ratio <= calculated_mess_ratio <= max_expected_ratio, "The mess detection ratio calculated for given content is not well adjusted!"	2.08 KB	2024-10-09 06:13
📄 test_preemptive_detection.py import pytest from charset_normalizer.utils import any_specified_encoding from charset_normalizer import CharsetMatch @pytest.mark.parametrize( "payload, expected_encoding", [ (b'<?xml version="1.0" encoding="EUC-JP"?>', "euc_jp"), (b'<html><head><meta charset="utf-8"></head></html>', "utf_8"), (b'<html><head><meta charset="utf-57"></head></html>', None), (b'# coding: utf-8', "utf_8"), (b'<?xml version="1.0" encoding="UTF-8"?>', 'utf_8'), (b'<?xml version="1.0" encoding="US-ASCII"?>', 'ascii'), (b'<?xml version="1.0" encoding="JohaB"?>', 'johab'), (b'<?xml version="1.0" encoding="ibm037"?>', 'cp037'), (b'<html><head><meta charset=WINDOWS-1252></head></html>', "cp1252"), (b'<html><head><meta charset="WINDOWS-1256"></head></html>', "cp1256"), ] ) def test_detect_most_common_body_encoding(payload, expected_encoding): specified_encoding = any_specified_encoding( payload ) assert specified_encoding == expected_encoding, "Unable to determine properly encoding from given body" @pytest.mark.parametrize( "payload, expected_outcome", [ (b'<?xml version="1.0" encoding="EUC-JP"?>', b'<?xml version="1.0" encoding="utf_8"?>'), (b'<html><head><meta charset="utf-8"></head></html>', b'<html><head><meta charset="utf-8"></head></html>'), (b'<html><head><meta charset="utf-57"></head></html>', b'<html><head><meta charset="utf-57"></head></html>'), (b'# coding: utf-8', b'# coding: utf-8'), (b'<?xml version="1.0" encoding="UTF-8"?>', b'<?xml version="1.0" encoding="UTF-8"?>'), (b'<?xml version="1.0" encoding="US-ASCII"?>', b'<?xml version="1.0" encoding="utf_8"?>'), (b'<?xml version="1.0" encoding="JohaB"?>', b'<?xml version="1.0" encoding="utf_8"?>'), (b'<html><head><meta charset=WINDOWS-1252></head></html>', b'<html><head><meta charset=utf_8></head></html>'), (b'<html><head><meta charset="WINDOWS-1256"></head></html>', b'<html><head><meta charset="utf_8"></head></html>'), ] ) def test_preemptive_mark_replacement(payload, expected_outcome): """ When generating (to Unicode converted) bytes, we want to change any potential declarative charset to utf-8. This test that. """ specified_encoding = any_specified_encoding( payload ) detected_encoding = specified_encoding if specified_encoding is not None else "utf-8" m = CharsetMatch( payload, detected_encoding, 0., False, [], preemptive_declaration=specified_encoding, ) transformed_output = m.output() assert transformed_output == expected_outcome	2.65 KB	2024-10-09 06:13
📄 test_utils.py import logging import pytest from charset_normalizer.utils import is_accentuated, cp_similarity, set_logging_handler @pytest.mark.parametrize( "character, expected_is_accentuated", [ ("é", True), ("è", True), ("à", True), ("À", True), ("Ù", True), ("ç", True), ("a", False), ("€", False), ("&", False), ("Ö", True), ("ü", True), ("ê", True), ("Ñ", True), ("Ý", True), ("Ω", False), ("ø", False), ("Ё", False), ], ) def test_is_accentuated(character, expected_is_accentuated): assert ( is_accentuated(character) is expected_is_accentuated ), "is_accentuated behavior incomplete" @pytest.mark.parametrize( "cp_name_a, cp_name_b, expected_is_similar", [ ("cp1026", "cp1140", True), ("cp1140", "cp1026", True), ("latin_1", "cp1252", True), ("latin_1", "iso8859_4", True), ("latin_1", "cp1251", False), ("cp1251", "mac_turkish", False), ], ) def test_cp_similarity(cp_name_a, cp_name_b, expected_is_similar): is_similar = cp_similarity(cp_name_a, cp_name_b) >= 0.8 assert is_similar is expected_is_similar, "cp_similarity is broken"	1.25 KB	2024-10-09 06:13

Terminal