fix: improve base64 and decodeUTF8 error messages

Motivation:
std.base64Decode leaked Java-specific IllegalArgumentException text
("Last unit does not have enough valid bits") instead of a clear error.
std.decodeUTF8 reported only the type name ("got number") instead of
the actual value, making debugging harder.

Modification:
- base64Decode/base64DecodeBytes: distinguish wrong-length input
  ("input string appears not to be a base64 encoded string.
  Wrong length found (N)") from invalid-character input
  ("failed to decode: <detail>").
- decodeUTF8: split error into three paths — non-integer floats
  ("Expected an integer, but got 17.5"), out-of-range integers
  ("Bytes must be integers in range [0, 255], got -1"), and
  non-numeric types ("Unexpected type string, expected number").

Result:
- No more Java exception text leaking from base64 decode errors.
- decodeUTF8 errors report actual values, not just types.
- All tests pass on JVM 2.12, 2.13, 3.3.

Author: He-Pin

sjsonnet/src/sjsonnet/stdlib/EncodingModule.scala

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

sjsonnet/src/sjsonnet/stdlib/StringModule.scala

@@ -1225,11 +1225,17 @@ object StringModule extends AbstractFunctionModule {
    */
   private object DecodeUTF8 extends Val.Builtin1("decodeUTF8", "arr") {
     def evalRhs(arr: Eval, ev: EvalScope, pos: Position): Val = {
-      for ((v, idx) <- arr.value.asArr.iterator.zipWithIndex) {
-        if (!v.isInstanceOf[Val.Num] || !v.asDouble.isWhole || v.asInt < 0 || v.asInt > 255) {
-          throw Error.fail(
-            "std.decodeUTF8: element " + idx + " is not an integer in range [0,255], got " + v.value.prettyName
-          )
+      for (v <- arr.value.asArr.iterator) {
+        v match {
+          case n: Val.Num =>
+            val d = n.asDouble
+            if (!d.isWhole)
+              throw Error.fail("Expected an integer, but got " + d)
+            val i = d.toInt
+            if (i < 0 || i > 255)
+              throw Error.fail("Bytes must be integers in range [0, 255], got " + i)
+          case _ =>
+            throw Error.fail("Unexpected type " + v.value.prettyName + ", expected number")
         }
       }
       Val.Str(

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

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

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

@@ -1,3 +1,2 @@
-sjsonnet.Error: [std.base64DecodeBytes] Invalid base64 string: Last unit does not have enough valid bits
+sjsonnet.Error: [std.base64DecodeBytes] input string appears not to be a base64 encoded string. Wrong length found (5)
     at [<root>].(builtinBase64DecodeBytes_invalid_base64_data.jsonnet:1:22)
-

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

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

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

@@ -1,3 +1,2 @@
-sjsonnet.Error: [std.base64Decode] Invalid base64 string: Last unit does not have enough valid bits
+sjsonnet.Error: [std.base64Decode] input string appears not to be a base64 encoded string. Wrong length found (5)
     at [<root>].(builtinBase64Decode_invalid_base64_data.jsonnet:1:17)
-

sjsonnet/test/resources/test_suite/error.decodeUTF8_float.jsonnet.golden

@@ -1,2 +1,2 @@
-sjsonnet.Error: [std.decodeUTF8] element 0 is not an integer in range [0,255], got number
+sjsonnet.Error: [std.decodeUTF8] Expected an integer, but got 17.5
     at [<root>].(error.decodeUTF8_float.jsonnet:1:15)

sjsonnet/test/resources/test_suite/error.decodeUTF8_nan.jsonnet.golden

@@ -1,2 +1,2 @@
-sjsonnet.Error: [std.decodeUTF8] element 0 is not an integer in range [0,255], got string
+sjsonnet.Error: [std.decodeUTF8] Unexpected type string, expected number
     at [<root>].(error.decodeUTF8_nan.jsonnet:1:15)

sjsonnet/test/src/sjsonnet/Base64Tests.scala

@@ -463,7 +463,7 @@ object Base64Tests extends TestSuite {
     test("errors") {
       test("invalidBase64Char") {
         val err = evalErr("""std.base64Decode("!!!!")""")
-        assert(err.contains("Invalid base64"))
+        assert(err.contains("failed to decode"))
       }
       test("invalidByteArrayValue") {
         val err = evalErr("""std.base64([256])""")
@@ -502,22 +502,22 @@ object Base64Tests extends TestSuite {
       test("missingTwoPads") {
         // "YQ" should be "YQ==" — both go-jsonnet and C++ jsonnet reject this
         val err = evalErr("""std.base64Decode("YQ")""")
-        assert(err.contains("Invalid base64"))
+        assert(err.contains("appears not to be a base64 encoded string"))
       }
       test("missingOnePad") {
         // "YWI" should be "YWI=" — rejected by both official implementations
         val err = evalErr("""std.base64Decode("YWI")""")
-        assert(err.contains("Invalid base64"))
+        assert(err.contains("appears not to be a base64 encoded string"))
       }
       test("singleChar") {
         // Single character is never valid base64
         val err = evalErr("""std.base64Decode("A")""")
-        assert(err.contains("Invalid base64"))
+        assert(err.contains("appears not to be a base64 encoded string"))
       }
       test("fiveChars") {
         // "wrong" (5 chars) — the go_test_suite canonical test case
         val err = evalErr("""std.base64Decode("wrong")""")
-        assert(err.contains("Invalid base64"))
+        assert(err.contains("appears not to be a base64 encoded string"))
       }
       test("validPaddedStillWorks") {
         // Properly padded input must still work
@@ -536,7 +536,7 @@ object Base64Tests extends TestSuite {
       // DecodeBytes also enforces strict padding
       test("decodeBytesUnpadded") {
         val err = evalErr("""std.base64DecodeBytes("YQ")""")
-        assert(err.contains("Invalid base64"))
+        assert(err.contains("appears not to be a base64 encoded string"))
       }
     }