Add tests for SER and UNSER.

python-processing-unit · python-processing-unit · commit b933af57d98b · 2026-04-18T23:20:17.000-04:00
diff --git a/tests/cases/failing/ser-arity-two.pre b/tests/cases/failing/ser-arity-two.pre
@@ -0,0 +1 @@
+SER(TRUE, FALSE)
diff --git a/tests/cases/failing/ser-arity-zero.pre b/tests/cases/failing/ser-arity-zero.pre
@@ -0,0 +1 @@
+SER()
diff --git a/tests/cases/failing/unser-arity-two.pre b/tests/cases/failing/unser-arity-two.pre
@@ -0,0 +1 @@
+UNSER("{}", "{}")
diff --git a/tests/cases/failing/unser-arity-zero.pre b/tests/cases/failing/unser-arity-zero.pre
@@ -0,0 +1 @@
+UNSER()
diff --git a/tests/cases/failing/unser-type-bool.pre b/tests/cases/failing/unser-type-bool.pre
@@ -0,0 +1 @@
+UNSER(TRUE)
diff --git a/tests/cases/failing/unser-type-flt.pre b/tests/cases/failing/unser-type-flt.pre
@@ -0,0 +1 @@
+UNSER(0d1.0)
diff --git a/tests/cases/failing/unser-type-func.pre b/tests/cases/failing/unser-type-func.pre
@@ -0,0 +1,5 @@
+FUNC INT: identity(INT: value){
+    RETURN(value)
+}
+
+UNSER(identity)
diff --git a/tests/cases/failing/unser-type-int.pre b/tests/cases/failing/unser-type-int.pre
@@ -0,0 +1 @@
+UNSER(0d1)
diff --git a/tests/cases/failing/unser-type-map.pre b/tests/cases/failing/unser-type-map.pre
@@ -0,0 +1 @@
+UNSER(<"n" = 0d1>)
diff --git a/tests/cases/failing/unser-type-thr.pre b/tests/cases/failing/unser-type-thr.pre
@@ -0,0 +1,3 @@
+THR(worker){}
+
+UNSER(worker)
diff --git a/tests/cases/failing/unser-type-tns.pre b/tests/cases/failing/unser-type-tns.pre
@@ -0,0 +1 @@
+UNSER([0d1])
diff --git a/tests/cases/passing/ser-func-ref.pre b/tests/cases/passing/ser-func-ref.pre
@@ -0,0 +1,23 @@
+FUNC BOOL: contains(STR: haystack, STR: needle){
+    RETURN(GT(TLEN(SPLIT(haystack, needle), 0d1), 0d1))
+}
+
+FUNC INT: occurrences(STR: haystack, STR: needle){
+    RETURN(SUB(TLEN(SPLIT(haystack, needle), 0d1), 0d1))
+}
+
+FUNC INT: identity(INT: value){
+    RETURN(value)
+}
+
+MAP: shared = <"first" = identity, "second" = identity>
+STR: json = SER(shared)
+
+ASSERT(contains(json, '\R"t":"FUNC"'))
+ASSERT(contains(json, '\R"name":"identity"'))
+ASSERT(GT(occurrences(json, '\R"def":{'), 0d0))
+ASSERT(contains(json, '\R"ref":true'))
+
+MAP: roundtrip = UNSER(SER(shared))
+ASSERT(EQ(roundtrip<"first">(0d4), 0d4))
+ASSERT(EQ(roundtrip<"second">(0d5), 0d5))
diff --git a/tests/cases/passing/ser-func.pre b/tests/cases/passing/ser-func.pre
@@ -0,0 +1,24 @@
+FUNC BOOL: contains(STR: haystack, STR: needle){
+    RETURN(GT(TLEN(SPLIT(haystack, needle), 0d1), 0d1))
+}
+
+INT: seed = 0d9
+INT: alias = @seed
+
+FUNC INT: add_seed(~INT: count, INT: step = 0d1){
+    RETURN(ADD(alias, ADD(count, step)))
+}
+
+STR: json = SER(add_seed)
+
+ASSERT(contains(json, '\R"t":"FUNC"'))
+ASSERT(contains(json, '\R"name":"add_seed"'))
+ASSERT(contains(json, '\R"return":"INT"'))
+ASSERT(contains(json, '\R"coerced":true'))
+ASSERT(contains(json, '\R"default":{"n":"Literal"'))
+ASSERT(contains(json, '\R"closure":{"t":"ENV"'))
+ASSERT(contains(json, '\R"t":"PTR"'))
+ASSERT(contains(json, '\R"name":"seed"'))
+ASSERT(contains(json, '\R"value_type":"INT"'))
+ASSERT(contains(json, '\R"n":"ReturnStatement"'))
+ASSERT(contains(json, '\R"n":"CallExpression"'))
diff --git a/tests/cases/passing/ser-map.pre b/tests/cases/passing/ser-map.pre
@@ -0,0 +1,7 @@
+MAP: ordered = <"alpha" = 0d1, 0d2 = "two", 0d3.5 = TRUE>
+
+ASSERT(EQ(SER(ordered), '\R{"t":"MAP","v":[{"k":{"t":"STR","v":"alpha"},"v":{"t":"INT","v":"0d1"}},{"k":{"t":"INT","v":"0d2"},"v":{"t":"STR","v":"two"}},{"k":{"t":"FLT","v":"0d3.5"},"v":{"t":"BOOL","v":true}}]}'))
+
+MAP: nested = <"outer" = <"inner" = [0d1, 0d2]>>
+ASSERT(EQ(UNSER(SER(nested)), nested))
+ASSERT(EQ(KEYS(UNSER(SER(ordered))), ["alpha", 0d2, 0d3.5]))
diff --git a/tests/cases/passing/ser-scalars.pre b/tests/cases/passing/ser-scalars.pre
@@ -0,0 +1,12 @@
+ASSERT(EQ(SER(TRUE), '{"t":"BOOL","v":true}'))
+ASSERT(EQ(SER(FALSE), '{"t":"BOOL","v":false}'))
+
+ASSERT(EQ(SER(0d42), '{"t":"INT","v":"0d42"}'))
+ASSERT(EQ(SER(-0xA), '{"t":"INT","v":"-0xA"}'))
+
+ASSERT(EQ(SER(0d3.5), '{"t":"FLT","v":"0d3.5"}'))
+ASSERT(EQ(SER(-INF), '{"t":"FLT","v":"-INF"}'))
+ASSERT(EQ(SER(NaN), '{"t":"FLT","v":"NaN"}'))
+
+ASSERT(EQ(UNSER(SER(0x2A)), 0x2A))
+ASSERT(EQ(STR(UNSER(SER(NaN))), "NaN"))
diff --git a/tests/cases/passing/ser-strings.pre b/tests/cases/passing/ser-strings.pre
@@ -0,0 +1,10 @@
+ASSERT(EQ(SER("Prefix"), '{"t":"STR","v":"Prefix"}'))
+
+STR: escaped = "\"\\\b\f\n\r\t"
+ASSERT(EQ(SER(escaped), '\R{"t":"STR","v":"\"\\\b\f\n\r\t"}'))
+
+ASSERT(EQ(SER("\x01"), '\R{"t":"STR","v":"\u0001"}'))
+
+STR: unicode_json = SER("\u00E9")
+ASSERT(OR(EQ(unicode_json, '\R{"t":"STR","v":"\u00E9"}'), EQ(unicode_json, '\R{"t":"STR","v":"\u00e9"}')))
+ASSERT(EQ(UNSER(unicode_json), "\u00E9"))
diff --git a/tests/cases/passing/ser-tensor.pre b/tests/cases/passing/ser-tensor.pre
@@ -0,0 +1,5 @@
+ASSERT(EQ(SER([0d1, 0d2]), '\R{"t":"TNS","shape":[2],"v":[{"t":"INT","v":"0d1"},{"t":"INT","v":"0d2"}]}'))
+
+TNS: square = [[0d1, 0d2], [0d3, 0d4]]
+ASSERT(EQ(SER(square), '\R{"t":"TNS","shape":[2,2],"v":[{"t":"INT","v":"0d1"},{"t":"INT","v":"0d2"},{"t":"INT","v":"0d3"},{"t":"INT","v":"0d4"}]}'))
+ASSERT(EQ(UNSER(SER(square)), square))
diff --git a/tests/cases/passing/ser-thr.pre b/tests/cases/passing/ser-thr.pre
@@ -0,0 +1,25 @@
+FUNC BOOL: contains(STR: haystack, STR: needle){
+    RETURN(GT(TLEN(SPLIT(haystack, needle), 0d1), 0d1))
+}
+
+FUNC INT: occurrences(STR: haystack, STR: needle){
+    RETURN(SUB(TLEN(SPLIT(haystack, needle), 0d1), 0d1))
+}
+
+THR(worker){}
+AWAIT(worker)
+
+STR: json = SER(worker)
+
+ASSERT(contains(json, '\R"t":"THR"'))
+ASSERT(contains(json, '\R"id":"t1"'))
+ASSERT(contains(json, '\R"state":"finished"'))
+ASSERT(contains(json, '\R"paused":false'))
+ASSERT(contains(json, '\R"finished":true'))
+ASSERT(contains(json, '\R"stop":false'))
+ASSERT(contains(json, '\R"env":'))
+ASSERT(contains(json, '\R"block":{"n":"Block"'))
+
+MAP: shared = <"first" = worker, "second" = worker>
+STR: shared_json = SER(shared)
+ASSERT(EQ(occurrences(shared_json, '\R"id":"t1"'), 0d2))
diff --git a/tests/cases/passing/unser-errors-json.pre b/tests/cases/passing/unser-errors-json.pre
@@ -0,0 +1,27 @@
+INT: errors = 0d0
+
+TRY{
+    UNSER("{")
+} CATCH(err){
+    ADD(@errors, 0d1)
+}
+
+TRY{
+    UNSER('\R{"v":true}')
+} CATCH(err){
+    ADD(@errors, 0d1)
+}
+
+TRY{
+    UNSER('\R{"t":"BOOL"}')
+} CATCH(err){
+    ADD(@errors, 0d1)
+}
+
+TRY{
+    UNSER('\R{"t":"NOPE","v":0}')
+} CATCH(err){
+    ADD(@errors, 0d1)
+}
+
+ASSERT(EQ(errors, 0d4))
diff --git a/tests/cases/passing/unser-errors-numeric.pre b/tests/cases/passing/unser-errors-numeric.pre
@@ -0,0 +1,21 @@
+INT: errors = 0d0
+
+TRY{
+    UNSER('\R{"t":"INT","v":"12"}')
+} CATCH(err){
+    ADD(@errors, 0d1)
+}
+
+TRY{
+    UNSER('\R{"t":"FLT","v":"0d1"}')
+} CATCH(err){
+    ADD(@errors, 0d1)
+}
+
+TRY{
+    UNSER('\R{"t":"FLT","v":"-NaN"}')
+} CATCH(err){
+    ADD(@errors, 0d1)
+}
+
+ASSERT(EQ(errors, 0d3))
diff --git a/tests/cases/passing/unser-errors-structure.pre b/tests/cases/passing/unser-errors-structure.pre
@@ -0,0 +1,27 @@
+INT: errors = 0d0
+
+TRY{
+    UNSER('\R{"t":"TNS","shape":[0],"v":[]}')
+} CATCH(err){
+    ADD(@errors, 0d1)
+}
+
+TRY{
+    UNSER('\R{"t":"TNS","shape":[2,2],"v":[{"t":"INT","v":"0d1"},{"t":"INT","v":"0d2"},{"t":"INT","v":"0d3"}]}')
+} CATCH(err){
+    ADD(@errors, 0d1)
+}
+
+TRY{
+    UNSER('\R{"t":"MAP","v":[{"k":{"t":"TNS","shape":[1],"v":[{"t":"INT","v":"0d1"}]},"v":{"t":"INT","v":"0d2"}}]}')
+} CATCH(err){
+    ADD(@errors, 0d1)
+}
+
+TRY{
+    UNSER('\R{"t":"MAP","v":[{"k":{"t":"STR","v":"x"}}]}')
+} CATCH(err){
+    ADD(@errors, 0d1)
+}
+
+ASSERT(EQ(errors, 0d4))
diff --git a/tests/cases/passing/unser-func-closure.pre b/tests/cases/passing/unser-func-closure.pre
@@ -0,0 +1,15 @@
+STR: loc = '\R{"file":"<unknown>","line":1,"column":1,"statement":""}'
+
+STR: json = JOIN( ^
+    '\R{"t":"FUNC","id":"f1","name":"read_alias","return":"INT","params":[],"def":{"name":"read_alias","return":"INT","params":[],"body":{"n":"Block","loc":', ^
+    loc, ^
+    '\R,"statements":[{"n":"ReturnStatement","loc":', ^
+    loc, ^
+    '\R,"expression":{"n":"Identifier","loc":', ^
+    loc, ^
+    '\R,"name":"alias"}}]},"closure":{"t":"ENV","id":"e1","def":{"values":{"seed":{"t":"INT","v":"0d9"},"alias":{"t":"PTR","name":"seed","env":{"t":"ENV","id":"e1","ref":true},"value_type":"INT"}},"declared":{"seed":"INT","alias":"INT"},"frozen":[],"permafrozen":[],"parent":null}}}}' ^
+)
+
+FUNC: reader = UNSER(json)
+ASSERT(EQ(TYPE(reader), "FUNC"))
+ASSERT(EQ(reader(), 0d9))
diff --git a/tests/cases/passing/unser-func-params.pre b/tests/cases/passing/unser-func-params.pre
@@ -0,0 +1,37 @@
+STR: loc = '\R{"file":"<unknown>","line":1,"column":1,"statement":""}'
+
+STR: step_default = JOIN( ^
+    '\R{"n":"Literal","loc":', ^
+    loc, ^
+    '\R,"value":2,"base":10,"literal_type":"INT"}' ^
+)
+
+STR: params = JOIN( ^
+    '\R[{"name":"value","type":"INT","coerced":true,"default":null},{"name":"step","type":"INT","coerced":false,"default":', ^
+    step_default, ^
+    '\R}]' ^
+)
+
+STR: json = JOIN( ^
+    '\R{"t":"FUNC","id":"f1","name":"add_default","return":"INT","params":', ^
+    params, ^
+    '\R,"def":{"name":"add_default","return":"INT","params":', ^
+    params, ^
+    '\R,"body":{"n":"Block","loc":', ^
+    loc, ^
+    '\R,"statements":[{"n":"ReturnStatement","loc":', ^
+    loc, ^
+    '\R,"expression":{"n":"CallExpression","loc":', ^
+    loc, ^
+    '\R,"callee":{"n":"Identifier","loc":', ^
+    loc, ^
+    '\R,"name":"ADD"},"args":[{"n":"CallArgument","name":null,"expression":{"n":"Identifier","loc":', ^
+    loc, ^
+    '\R,"name":"value"}},{"n":"CallArgument","name":null,"expression":{"n":"Identifier","loc":', ^
+    loc, ^
+    '\R,"name":"step"}}]}}]},"closure":null}}' ^
+)
+
+FUNC: add_default = UNSER(json)
+ASSERT(EQ(add_default("0d3"), 0d5))
+ASSERT(EQ(add_default("0d3", step = 0d4), 0d7))
diff --git a/tests/cases/passing/unser-func-ref.pre b/tests/cases/passing/unser-func-ref.pre
@@ -0,0 +1,22 @@
+STR: loc = '\R{"file":"<unknown>","line":1,"column":1,"statement":""}'
+
+STR: full = JOIN( ^
+    '\R{"t":"FUNC","id":"f1","name":"five","return":"INT","params":[],"def":{"name":"five","return":"INT","params":[],"body":{"n":"Block","loc":', ^
+    loc, ^
+    '\R,"statements":[{"n":"ReturnStatement","loc":', ^
+    loc, ^
+    '\R,"expression":{"n":"Literal","loc":', ^
+    loc, ^
+    '\R,"value":5,"base":10,"literal_type":"INT"}}]},"closure":null}}' ^
+)
+
+STR: json = JOIN( ^
+    '\R{"t":"MAP","v":[{"k":{"t":"STR","v":"first"},"v":', ^
+    full, ^
+    '\R},{"k":{"t":"STR","v":"second"},"v":{"t":"FUNC","id":"f1","ref":true}}]}' ^
+)
+
+MAP: funcs = UNSER(json)
+ASSERT(EQ(funcs<"first">, funcs<"second">))
+ASSERT(EQ(funcs<"first">(), 0d5))
+ASSERT(EQ(funcs<"second">(), 0d5))
diff --git a/tests/cases/passing/unser-func.pre b/tests/cases/passing/unser-func.pre
@@ -0,0 +1,21 @@
+STR: loc = '\R{"file":"<unknown>","line":1,"column":1,"statement":""}'
+
+STR: json = JOIN( ^
+    '\R{"t":"FUNC","id":"f1","name":"double","return":"INT","params":[{"name":"value","type":"INT","coerced":false,"default":null}],"def":{"name":"double","return":"INT","params":[{"name":"value","type":"INT","coerced":false,"default":null}],"body":{"n":"Block","loc":', ^
+    loc, ^
+    '\R,"statements":[{"n":"ReturnStatement","loc":', ^
+    loc, ^
+    '\R,"expression":{"n":"CallExpression","loc":', ^
+    loc, ^
+    '\R,"callee":{"n":"Identifier","loc":', ^
+    loc, ^
+    '\R,"name":"ADD"},"args":[{"n":"CallArgument","name":null,"expression":{"n":"Identifier","loc":', ^
+    loc, ^
+    '\R,"name":"value"}},{"n":"CallArgument","name":null,"expression":{"n":"Identifier","loc":', ^
+    loc, ^
+    '\R,"name":"value"}}]}}]},"closure":null}}' ^
+)
+
+FUNC: double = UNSER(json)
+ASSERT(EQ(TYPE(double), "FUNC"))
+ASSERT(EQ(double(0d3), 0d6))
diff --git a/tests/cases/passing/unser-map.pre b/tests/cases/passing/unser-map.pre
@@ -0,0 +1,6 @@
+MAP: value = UNSER('\R{"t":"MAP","v":[{"k":{"t":"STR","v":"alpha"},"v":{"t":"INT","v":"0d1"}},{"k":{"t":"INT","v":"0d2"},"v":{"t":"STR","v":"two"}},{"k":{"t":"FLT","v":"0d3.5"},"v":{"t":"MAP","v":[{"k":{"t":"STR","v":"nested"},"v":{"t":"BOOL","v":true}}]}}]}')
+
+ASSERT(EQ(value<"alpha">, 0d1))
+ASSERT(EQ(value<0d2>, "two"))
+ASSERT(EQ(value<0d3.5, "nested">, TRUE))
+ASSERT(EQ(KEYS(value), ["alpha", 0d2, 0d3.5]))
diff --git a/tests/cases/passing/unser-scalars.pre b/tests/cases/passing/unser-scalars.pre
@@ -0,0 +1,10 @@
+ASSERT(EQ(UNSER('\R{"t":"BOOL","v":true}'), TRUE))
+
+STR: spaced_false = JOIN("\n  ", '\R{"t":"BOOL","v":false}', "\r\t")
+ASSERT(EQ(UNSER(spaced_false), FALSE))
+
+ASSERT(EQ(UNSER('\R{"t":"INT","v":"-0xA"}'), -0xA))
+ASSERT(EQ(UNSER('\R{"t":"FLT","v":"0d3.5"}'), 0d3.5))
+ASSERT(EQ(STR(UNSER('\R{"t":"FLT","v":"NaN"}')), "NaN"))
+ASSERT(EQ(UNSER('\R{"t":"STR","v":"Prefix\n"}'), "Prefix\n"))
+ASSERT(EQ(UNSER('\R{"t":"STR","v":"\u00E9"}'), "\u00E9"))
diff --git a/tests/cases/passing/unser-tensor.pre b/tests/cases/passing/unser-tensor.pre
@@ -0,0 +1,7 @@
+TNS: tensor = UNSER('\R{"t":"TNS","shape":[2,2],"v":[{"t":"INT","v":"0d1"},{"t":"INT","v":"0d2"},{"t":"INT","v":"0d3"},{"t":"INT","v":"0d4"}]}')
+
+ASSERT(EQ(tensor, [[0d1, 0d2], [0d3, 0d4]]))
+ASSERT(EQ(SHAPE(tensor), [0d2, 0d2]))
+
+TNS: mixed = UNSER('\R{"t":"TNS","shape":[3],"v":[{"t":"BOOL","v":true},{"t":"STR","v":"two"},{"t":"FLT","v":"0d3.5"}]}')
+ASSERT(EQ(mixed, [TRUE, "two", 0d3.5]))
diff --git a/tests/cases/passing/unser-thr-ref.pre b/tests/cases/passing/unser-thr-ref.pre
@@ -0,0 +1,13 @@
+STR: thread_json = '\R{"t":"THR","id":"t1","state":"finished","paused":false,"finished":true,"stop":false,"env":null,"block":null}'
+
+STR: json = JOIN( ^
+    '\R{"t":"MAP","v":[{"k":{"t":"STR","v":"first"},"v":', ^
+    thread_json, ^
+    '\R},{"k":{"t":"STR","v":"second"},"v":', ^
+    thread_json, ^
+    '\R}]}' ^
+)
+
+MAP: threads = UNSER(json)
+ASSERT(EQ(threads<"first">, threads<"second">))
+ASSERT(NOT(BOOL(threads<"first">)))
diff --git a/tests/cases/passing/unser-thr.pre b/tests/cases/passing/unser-thr.pre
@@ -0,0 +1,9 @@
+THR: finished = UNSER('\R{"t":"THR","id":"t1","state":"finished","paused":false,"finished":true,"stop":false,"env":null,"block":null}')
+
+ASSERT(EQ(TYPE(finished), "THR"))
+ASSERT(NOT(BOOL(finished)))
+ASSERT(EQ(AWAIT(finished), finished))
+
+THR: paused = UNSER('\R{"t":"THR","id":"t2","state":"paused","paused":true,"finished":false,"stop":false,"env":null,"block":null}')
+ASSERT(PAUSED(paused))
+ASSERT(BOOL(paused))

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+THR(worker){}`
	`2`	`+`
	`3`	`+UNSER(worker)`