Implement codecs.strict_errors (#696)

* Implement codecs.strict_errors

* Fixed after review

Author: BCSharp

Src/IronPython/Runtime/Operations/StringOps.cs

@@ -1869,8 +1869,8 @@ private static string UserDecode(PythonTuple codecInfo, IList<byte> data, string
         }
 
 #if FEATURE_ENCODING
-        private static class CodecsInfo {
-            public static readonly Dictionary<string, Lazy<Encoding>> Codecs = MakeCodecsDict();
+        internal static class CodecsInfo {
+            internal static readonly Dictionary<string, Lazy<Encoding>> Codecs = MakeCodecsDict();
 
             private static Dictionary<string, Lazy<Encoding>> MakeCodecsDict() {
                 Dictionary<string, Lazy<Encoding>> d = new Dictionary<string, Lazy<Encoding>>();
@@ -1939,6 +1939,26 @@ private static Dictionary<string, Lazy<Encoding>> MakeCodecsDict() {
 #endif
                 return d;
             }
+
+            internal static Dictionary<string, object> MakeErrorHandlersDict() {
+                var d = new Dictionary<string, object>();
+
+                d["strict"] = BuiltinFunction.MakeFunction(
+                    "strict_errors", 
+                    ReflectionUtils.GetMethodInfos(typeof(StringOps).GetMember(nameof(StrictErrors), BindingFlags.Static | BindingFlags.NonPublic)), 
+                    typeof(StringOps));
+
+                // TODO: Implement remaining error handlers
+                d["ignore"] = null;
+
+                d["replace"] = null;
+
+                d["xmlcharrefreplace"] = null;
+
+                d["backslashreplace"] = null;
+
+                return d;
+            }
         }
 #endif
 
@@ -2677,6 +2697,16 @@ public override bool Fallback(byte[] bytesUnknown, int index) {
             }
         }
 
+        private static object StrictErrors(object unicodeError) {
+            if (unicodeError is PythonExceptions.BaseException be) {
+                unicodeError = be.GetClrException();
+            }
+            switch (unicodeError) {
+                case DecoderFallbackException dfe: throw dfe;
+                case EncoderFallbackException efe: throw efe;
+                default: throw PythonOps.TypeError("codec must pass exception instance");
+            }
+        }
 #endif
 
         #endregion

Src/IronPython/Runtime/PythonContext.cs

@@ -1887,7 +1887,11 @@ public override int ExecuteProgram(SourceUnit/*!*/ program) {
         internal Dictionary<string, object> ErrorHandlers {
             get {
                 if (_errorHandlers == null) {
+#if FEATURE_ENCODING
+                    Interlocked.CompareExchange(ref _errorHandlers, StringOps.CodecsInfo.MakeErrorHandlersDict(), null);
+#else
                     Interlocked.CompareExchange(ref _errorHandlers, new Dictionary<string, object>(), null);
+#endif
                 }
 
                 return _errorHandlers;

Tests/modules/io_related/test_codecs.py

@@ -454,6 +454,48 @@ def test_latin_1_encode(self):
         for x in ['iso-8859-1', 'iso8859-1', '8859', 'cp819', 'latin', 'latin1', 'L1']:
             self.assertEqual('abc'.encode(x), b'abc')
 
+    def test_error_handlers(self):
+        ude = UnicodeDecodeError('dummy', b"abcdefgh", 3, 5, "decoding testing purposes")
+        uee = UnicodeEncodeError('dummy', "abcdefgh", 2, 6, "encoding testing purposes")
+        unicode_data = "ab\xff\u20ac\U0001f40d"
+        uee_unicode = UnicodeEncodeError('dummy', unicode_data, 2, len(unicode_data), "encoding testing purposes")
+
+        strict = codecs.lookup_error('strict')
+        self.assertEqual(strict, codecs.strict_errors)
+        with self.assertRaises(UnicodeDecodeError) as cm:
+            strict(ude)
+        self.assertEqual(cm.exception, ude)
+        with self.assertRaises(UnicodeEncodeError) as cm:
+            strict(uee)
+        self.assertEqual(cm.exception, uee)
+        self.assertRaisesRegex(TypeError, "codec must pass exception instance", strict, None)
+        self.assertRaisesRegex(TypeError, "\w+\(\) takes exactly (one|1) argument \(0 given\)", strict)
+        self.assertRaisesRegex(TypeError, "\w+\(\) takes exactly (one|1) argument \(2 given\)", strict, ude, uee)
+        self.assertRaises(LookupError, codecs.lookup_error, "STRICT")
+
+        return # TODO: Implement remaining error handlers
+
+        ignore = codecs.lookup_error('ignore')
+        self.assertEqual(ignore, codecs.ignore_errors)
+        self.assertEqual(ignore(ude), ("", 5))
+        self.assertEqual(ignore(uee), ("", 6))
+
+        replace = codecs.lookup_error('replace')
+        self.assertEqual(replace, codecs.replace_errors)
+        self.assertEqual(replace(ude), ("�", 5))
+        self.assertEqual(replace(uee), ("????", 6))
+
+        backslashreplace = codecs.lookup_error('backslashreplace')
+        self.assertEqual(backslashreplace, codecs.backslashreplace_errors)
+        self.assertRaisesRegex(TypeError, "don't know how to handle UnicodeDecodeError in error callback", backslashreplace, ude)
+        self.assertEqual(backslashreplace(uee), (r"\x63\x64\x65\x66", 6))
+        self.assertEqual(backslashreplace(uee_unicode), (r"\xff\u20ac\U0001f40d", uee_unicode.end))
+
+        xmlcharrefreplace = codecs.lookup_error('xmlcharrefreplace')
+        self.assertEqual(xmlcharrefreplace, codecs.xmlcharrefreplace_errors)
+        self.assertRaisesRegex(TypeError, "don't know how to handle UnicodeDecodeError in error callback", xmlcharrefreplace, ude)
+        self.assertEqual(xmlcharrefreplace(uee), ("cdef", 6))
+
     #TODO: @skip("multiple_execute")
     def test_lookup_error(self):
         #sanity