fix: preserve base64 invalid-character errors

Motivation:

Non-ASCII base64 inputs can have lengths that are not multiples of four, but they should fail as invalid characters rather than padding-length errors.

Modification:

Factor the strict ASCII padding predicate into Base64Validation, reuse it in decode catch paths, and add direct high-codepoint decode regression tests while restoring golden output.

Result:

std.base64Decode and std.base64DecodeBytes report the correct failure class for high-codepoint inputs without changing ASCII padding validation.

Author: He-Pin

sjsonnet/src/sjsonnet/stdlib/Base64Validation.scala

@@ -6,6 +6,20 @@ package sjsonnet.stdlib
  */
 object Base64Validation {
 
+  def hasStrictPaddingLengthError(input: String): Boolean = {
+    val len = input.length
+    if (len == 0 || len % 4 == 0) false
+    else {
+      var allAscii = true
+      var i = 0
+      while (i < len && allAscii) {
+        if (input.charAt(i) > 127) allAscii = false
+        i += 1
+      }
+      allAscii
+    }
+  }
+
   /**
    * Validate strict RFC 4648 padding: reject ASCII input whose length is not a multiple of 4.
    *
@@ -20,19 +34,10 @@ object Base64Validation {
    * bytes (so "ĀQ=" is 4 bytes, passes the length check, and fails on the invalid character).
    */
   def requireStrictPadding(input: String): Unit = {
-    val len = input.length
-    if (len > 0 && len % 4 != 0) {
-      var allAscii = true
-      var i = 0
-      while (i < len && allAscii) {
-        if (input.charAt(i) > 127) allAscii = false
-        i += 1
-      }
-      if (allAscii) {
-        throw new IllegalArgumentException(
-          "Last unit does not have enough valid bits"
-        )
-      }
+    if (hasStrictPaddingLengthError(input)) {
+      throw new IllegalArgumentException(
+        "Last unit does not have enough valid bits"
+      )
     }
   }
 }

sjsonnet/src/sjsonnet/stdlib/EncodingModule.scala

@@ -118,7 +118,7 @@ object EncodingModule extends AbstractFunctionModule {
          else Val.Str(pos, value)): Val
       } catch {
         case e: IllegalArgumentException =>
-          if (str.length % 4 != 0)
+          if (Base64Validation.hasStrictPaddingLengthError(str))
             Error.fail(
               s"input string appears not to be a base64 encoded string. Wrong length found (${str.length})"
             )
@@ -140,7 +140,7 @@ object EncodingModule extends AbstractFunctionModule {
         Val.Arr.fromBytes(pos, PlatformBase64.decode(str))
       } catch {
         case e: IllegalArgumentException =>
-          if (str.length % 4 != 0)
+          if (Base64Validation.hasStrictPaddingLengthError(str))
             Error.fail(
               s"input string appears not to be a base64 encoded string. Wrong length found (${str.length})"
             )

sjsonnet/test/resources/go_test_suite/builtinBase64DecodeBytes_high_codepoint.jsonnet.golden

@@ -1,2 +1,2 @@
-sjsonnet.Error: [std.base64DecodeBytes] input string appears not to be a base64 encoded string. Wrong length found (3)
+sjsonnet.Error: [std.base64DecodeBytes] failed to decode: Illegal base64 character 3f
     at [<root>].(builtinBase64DecodeBytes_high_codepoint.jsonnet:1:22)

sjsonnet/test/resources/go_test_suite/builtinBase64Decode_high_codepoint.jsonnet.golden

@@ -1,2 +1,2 @@
-sjsonnet.Error: [std.base64Decode] input string appears not to be a base64 encoded string. Wrong length found (3)
+sjsonnet.Error: [std.base64Decode] failed to decode: Illegal base64 character 3f
     at [<root>].(builtinBase64Decode_high_codepoint.jsonnet:1:17)

sjsonnet/test/src/sjsonnet/Base64Tests.scala

@@ -465,6 +465,16 @@ object Base64Tests extends TestSuite {
         val err = evalErr("""std.base64Decode("!!!!")""")
         assert(err.contains("failed to decode"))
       }
+      test("highCodepointInvalidChar") {
+        val err = evalErr("""std.base64Decode("\u0100Q=")""")
+        assert(err.contains("failed to decode"))
+        assert(!err.contains("Wrong length found"))
+      }
+      test("decodeBytesHighCodepointInvalidChar") {
+        val err = evalErr("""std.base64DecodeBytes("\u0100Q=")""")
+        assert(err.contains("failed to decode"))
+        assert(!err.contains("Wrong length found"))
+      }
       test("invalidByteArrayValue") {
         val err = evalErr("""std.base64([256])""")
         assert(err.contains("invalid codepoint"))