import random import time from utils.scalar_to_string import convert_bytes_to_scalar, scalar_to_string def validate_target_string_reconstruction(): """ Test target string reconstruction Given target string, add random value and try to reconstruct """ print("=== Test target string reconstruction ===") # test cases: various types of strings validate_strings = [ "", "a", "hello", "ガンダム", "test123", "ABC", "你好", # Chinese "αβγ", # Greek letters "🌟", # emoji "café", # with diacritical marks "Hello世界", # mixed " ", # long string with spaces "This is a test string with special characters: !@#$%^&*()_+-=[]{};':,./<>?", # special characters "This is a test string with non-ASCII characters: äöüÄÖÜÉéèÈ", # non-ASCII characters ] for original_string in validate_strings: print(f"\n{'=' * 60}") print(f"Original string: '{original_string}'") try: # 1. convert original string to scalar original_scalar = convert_bytes_to_scalar(original_string.encode("utf-8")) # print(f"Original scalar: {original_scalar}") print( f"Original UTF-8 bytes: {[hex(b) for b in original_string.encode('utf-8')]}" ) # 2. add small random offset as target random_offset = random.uniform(-1000, 1000) # small random offset target_scalar = original_scalar + random_offset # print(f"Target scalar (add random offset): {target_scalar}") print(f"Random offset: {random_offset}") # 3. set reasonable upper and lower bounds margin = ( abs(original_scalar) * 0.01 + 10000 ) # 1% of the original scalar + fixed margin lower_bound = target_scalar - margin upper_bound = target_scalar + margin print(f"Margin: {margin}") # print(f"Search range: [{lower_bound}, {upper_bound}]") # 4. start reconstruction start_time = time.time() reconstructed_string, reconstructed_scalar = scalar_to_string( target_scalar, lower_bound, upper_bound ) end_time = time.time() execution_time = (end_time - start_time) * 1000 # convert to milliseconds # 5. output results print(f"Execution time: {execution_time:.4f} ms") if reconstructed_string is not None: print(f"Reconstructed string: '{reconstructed_string}'") print(f"Reconstructed scalar: {reconstructed_scalar}") print( f"Reconstructed UTF-8 bytes: {[hex(b) for b in reconstructed_string.encode('utf-8')]}" ) # # Precision issue, may be directly rounded to 0, need to use byte reverse calculation later # # calculate difference # scalar_diff = abs(reconstructed_scalar - target_scalar) # original_diff = abs(reconstructed_scalar - original_scalar) # print(f"Difference from target scalar: {scalar_diff}") # print(f"Difference from original scalar: {original_diff}") # similarity analysis if original_string == reconstructed_string: print("✅ Perfect match!") else: # calculate character-level similarity common_chars = set(original_string) & set(reconstructed_string) similarity = len(common_chars) / max( len(set(original_string)), len(set(reconstructed_string)), 1 ) print(f"Character similarity: {similarity:.2%}") # length comparison print( f"Length comparison: Original={len(original_string)}, Reconstructed={len(reconstructed_string)}" ) # validate if within range in_range = lower_bound <= reconstructed_scalar <= upper_bound print(f"Range validation: {in_range}") else: print("❌ Failed to reconstruct string") except Exception as e: print(f"❌ Test failed: {e}") import traceback traceback.print_exc() def validate_charset_support(): """ Test different charset support """ print(f"\n{'=' * 60}") print("=== Test charset support ===") validate_string = "hello" original_scalar = convert_bytes_to_scalar(validate_string.encode("utf-8")) target_scalar = original_scalar + 100 margin = 1000 # Test supported charsets supported_charsets = ["utf8mb4", "utf8", "UTF8MB4", "UTF8"] # test case insensitive for charset in supported_charsets: print(f"\n--- Testing charset: {charset} ---") try: result, scalar = scalar_to_string( target_scalar, target_scalar - margin, target_scalar + margin, charset=charset, ) print(f"✅ Success: '{result}' (scalar: {scalar})") except Exception as e: print(f"❌ Failed: {e}") # Test unsupported charsets unsupported_charsets = ["latin1", "ascii", "gbk", "binary", "invalid_charset"] for charset in unsupported_charsets: print(f"\n--- Testing unsupported charset: {charset} ---") try: result, scalar = scalar_to_string( target_scalar, target_scalar - margin, target_scalar + margin, charset=charset, ) print(f"❌ Unexpected success: '{result}' (scalar: {scalar})") except NotImplementedError as e: print(f"✅ Expected NotImplementedError: {e}") except ValueError as e: print(f"✅ Expected ValueError: {e}") except Exception as e: print(f"❌ Unexpected error: {e}") def validate_utf8_vs_utf8mb4(): """ Test the difference between utf8 and utf8mb4 charsets """ print(f"\n{'=' * 60}") print("=== Test utf8 vs utf8mb4 difference ===") # Test with emoji (4-byte UTF-8 character) emoji_string = "🌟" # This requires 4-byte UTF-8 encoding original_scalar = convert_bytes_to_scalar(emoji_string.encode("utf-8")) target_scalar = original_scalar + 100 margin = 10000 print(f"Original emoji string: '{emoji_string}'") print(f"UTF-8 bytes: {[hex(b) for b in emoji_string.encode('utf-8')]}") print(f"Original scalar: {original_scalar}") # Test with utf8mb4 (should handle 4-byte characters) print("\n--- Testing with utf8mb4 ---") try: result_mb4, scalar_mb4 = scalar_to_string( target_scalar, target_scalar - margin, target_scalar + margin, charset="utf8mb4", ) print(f"Result: '{result_mb4}' (scalar: {scalar_mb4})") print(f"UTF-8 bytes: {[hex(b) for b in result_mb4.encode('utf-8')]}") except Exception as e: print(f"Error: {e}") # Test with utf8 (should still work but may use different fallback strategy) print("\n--- Testing with utf8 ---") try: result_utf8, scalar_utf8 = scalar_to_string( target_scalar, target_scalar - margin, target_scalar + margin, charset="utf8", ) print(f"Result: '{result_utf8}' (scalar: {scalar_utf8})") print(f"UTF-8 bytes: {[hex(b) for b in result_utf8.encode('utf-8')]}") except Exception as e: print(f"Error: {e}") def validate_performance_comparison(): """ Performance comparison test """ print(f"\n{'=' * 60}") print("=== Performance test ===") validate_cases = [ ("short", "a"), ("medium", "hello"), ("long", "verylongstring"), ("unicode", "你好世界"), ("mixed", "Hello世界123"), ] for case_name, validate_string in validate_cases: print(f"\n--- {case_name}: '{validate_string}' ---") original_scalar = convert_bytes_to_scalar(validate_string.encode("utf-8")) target_scalar = original_scalar + random.uniform(-100, 100) margin = abs(original_scalar) * 0.01 + 1000 # multiple tests to get average times = [] success_count = 0 for _ in range(100): start_time = time.time() result, _ = scalar_to_string( target_scalar, target_scalar - margin, target_scalar + margin ) end_time = time.time() times.append((end_time - start_time) * 1000) if result is not None: success_count += 1 avg_time = sum(times) / len(times) success_rate = success_count / 100 print(f"Average execution time: {avg_time:.4f} ms") print(f"Success rate: {success_rate:.1%}") print(f"Fastest: {min(times):.4f} ms") print(f"Slowest: {max(times):.4f} ms") if __name__ == "__main__": # set random seed for reproducibility random.seed(42) # run tests validate_target_string_reconstruction() validate_charset_support() validate_utf8_vs_utf8mb4() validate_performance_comparison()