test(ui): add tests for remaining std functions

ui-tests/pass/stdlib/get.jsonnet

@@ -0,0 +1,26 @@
+std.assertEqual(std.get({}, "a"), null) &&
+std.assertEqual(std.get({}, "a", "?"), "?") &&
+std.assertEqual(std.get({}, "a", "?", true), "?") &&
+std.assertEqual(std.get({}, "a", "?", false), "?") &&
+
+std.assertEqual(std.get({ a: 1 }, "a"), 1) &&
+std.assertEqual(std.get({ a: 1 }, "a", "?"), 1) &&
+std.assertEqual(std.get({ a: 1 }, "a", "?", true), 1) &&
+std.assertEqual(std.get({ a: 1 }, "a", "?", false), 1) &&
+
+std.assertEqual(std.get({ a: 1 }, "b"), null) &&
+std.assertEqual(std.get({ a: 1 }, "b", "?"), "?") &&
+std.assertEqual(std.get({ a: 1 }, "b", "?", true), "?") &&
+std.assertEqual(std.get({ a: 1 }, "b", "?", false), "?") &&
+
+std.assertEqual(std.get({ a:: 1 }, "a"), 1) &&
+std.assertEqual(std.get({ a:: 1 }, "a", "?"), 1) &&
+std.assertEqual(std.get({ a:: 1 }, "a", "?", true), 1) &&
+std.assertEqual(std.get({ a:: 1 }, "a", "?", false), "?") &&
+
+std.assertEqual(std.get({ a:: 1 }, "b"), null) &&
+std.assertEqual(std.get({ a:: 1 }, "b", "?"), "?") &&
+std.assertEqual(std.get({ a:: 1 }, "b", "?", true), "?") &&
+std.assertEqual(std.get({ a:: 1 }, "b", "?", false), "?") &&
+
+true

ui-tests/pass/stdlib/isEmpty.jsonnet

@@ -0,0 +1,29 @@
+std.assertEqual(std.isEmpty(""), true) &&
+std.assertEqual(std.isEmpty("string"), false) &&
+std.assertEqual(std.isEmpty("\uFFFF"), false) &&
+std.assertEqual(std.isEmpty("\uD800\uDD56"), false) &&
+
+std.assertEqual(std.isEmpty([]), true) &&
+std.assertEqual(std.isEmpty([0]), false) &&
+std.assertEqual(std.isEmpty([0, 0, 0]), false) &&
+std.assertEqual(std.isEmpty([1, 2, 3, 4]), false) &&
+
+std.assertEqual(std.isEmpty({}), true) &&
+std.assertEqual(std.isEmpty({ a:: 1 }), true) &&
+std.assertEqual(std.isEmpty({ a: 1 }), false) &&
+std.assertEqual(std.isEmpty({ a: 1, b:: 2 }), false) &&
+std.assertEqual(std.isEmpty({ a: 1, b: 2 }), false) &&
+std.assertEqual(std.isEmpty({ a: 1, b: 2 } + { a: 3 }), false) &&
+std.assertEqual(std.isEmpty({ a: 1, b: 2 } + { c: 4 }), false) &&
+std.assertEqual(std.isEmpty({ a: 1, b: 2 } + { a: 3, c: 4 }), false) &&
+std.assertEqual(std.isEmpty(std), true) &&
+
+std.assertEqual(std.isEmpty(function() null), true) &&
+std.assertEqual(std.isEmpty(function(x) null), false) &&
+std.assertEqual(std.isEmpty(function(x, y) null), false) &&
+std.assertEqual(std.isEmpty(function(x=1, y=2) null), false) &&
+
+std.assertEqual(std.isEmpty(std.type), false) &&
+std.assertEqual(std.isEmpty(std.sort), false) &&
+
+true

ui-tests/pass/stdlib/lines.jsonnet

@@ -0,0 +1,9 @@
+std.assertEqual(std.lines([]), "") &&
+std.assertEqual(std.lines([null]), "") &&
+std.assertEqual(std.lines(["a"]), "a\n") &&
+std.assertEqual(std.lines(["a", null]), "a\n") &&
+std.assertEqual(std.lines(["a", "b"]), "a\nb\n") &&
+std.assertEqual(std.lines(["a", "b", "c"]), "a\nb\nc\n") &&
+std.assertEqual(std.lines(["a", null, "b"]), "a\nb\n") &&
+
+true

ui-tests/pass/stdlib/manifestJson.jsonnet

@@ -104,4 +104,9 @@ std.assertEqual(std.manifestJsonMinified({ a: 1 }), '{"a":1}') &&
 std.assertEqual(std.manifestJsonMinified({ a: 1, b: 2 }), '{"a":1,"b":2}') &&
 std.assertEqual(std.manifestJsonMinified({ a: {} }), '{"a":{}}') &&
 
+std.assertEqual(
+  std.manifestJsonEx({ a: 1, b: [1, 2] }, "\t", "\r", " :"),
+  '{\r\t"a" :1,\r\t"b" :[\r\t\t1,\r\t\t2\r\t]\r}',
+) &&
+
 true

ui-tests/pass/stdlib/math.jsonnet

@@ -21,6 +21,10 @@ std.assertEqual(std.max(-1, -2), -1) &&
 std.assertEqual(std.max(-2, -1), -1) &&
 std.assertEqual(std.max(1, 1), 1) &&
 
+std.assertEqual(std.clamp(-3, 1, 5), 1) &&
+std.assertEqual(std.clamp(4, 1, 5), 4) &&
+std.assertEqual(std.clamp(7, 1, 5), 5) &&
+
 std.assertEqual(std.exponent(0), 0) &&
 std.assertEqual(std.exponent(0.09375), -3) &&
 std.assertEqual(std.exponent(-0.09375), -3) &&

ui-tests/pass/stdlib/objectKeysValues.jsonnet

@@ -0,0 +1,56 @@
+local test(obj, not_all, all) =
+  std.assertEqual(std.objectKeysValues(obj), not_all) &&
+  std.assertEqual(std.objectKeysValuesAll(obj), all);
+
+local mkKv(key, value) = { key: key, value: value };
+
+test({}, [], []) &&
+test({ a: 1 }, [mkKv("a", 1)], [mkKv("a", 1)]) &&
+test({ a: 1, b: 2 }, [mkKv("a", 1), mkKv("b", 2)], [mkKv("a", 1), mkKv("b", 2)]) &&
+test({ a: 1, b:: 2 }, [mkKv("a", 1)], [mkKv("a", 1), mkKv("b", 2)]) &&
+test({ a: 1, b::: 2 }, [mkKv("a", 1), mkKv("b", 2)], [mkKv("a", 1), mkKv("b", 2)]) &&
+
+std.all([
+  local kv = std.objectKeysValues(obj);
+  local kvAll = std.objectKeysValuesAll(obj);
+
+  test(obj + {}, kv, kvAll) &&
+  test({} + obj, kv, kvAll) &&
+  true
+
+  for obj in [{}, { a: 1 }, { a:: 1 }, { a::: 1 }]
+]) &&
+
+std.all([
+  test(obj + { a: 1 }, std.objectKeysValues(obj), [mkKv("a", 1)]) &&
+  test(obj + { a:: 1 }, [], [mkKv("a", 1)]) &&
+  test(obj + { a::: 1 }, [mkKv("a", 1)], [mkKv("a", 1)]) &&
+  true
+
+  for obj in [{ a: 1 }, { a:: 1 }, { a::: 1 }]
+]) &&
+
+std.all([
+  local kv = std.objectKeysValues(obj1 + obj2);
+  local kvAll = std.objectKeysValuesAll(obj1 + obj2);
+
+  test(obj1 + obj2 + {}, kv, kvAll) &&
+  test(obj1 + {} + obj2, kv, kvAll) &&
+  test({} + obj1 + obj2, kv, kvAll) &&
+  true
+
+  for obj1 in [{}, { a: 1 }, { a:: 1 }, { a::: 1 }]
+  for obj2 in [{}, { a: 1 }, { a:: 1 }, { a::: 1 }]
+]) &&
+
+std.all([
+  test(obj1 + obj2 + { a: 1 }, std.objectKeysValues(obj1 + obj2), [mkKv("a", 1)]) &&
+  test(obj1 + obj2 + { a:: 1 }, [], [mkKv("a", 1)]) &&
+  test(obj1 + obj2 + { a::: 1 }, [mkKv("a", 1)], [mkKv("a", 1)]) &&
+  true
+
+  for obj1 in [{ a: 1 }, { a:: 1 }, { a::: 1 }]
+  for obj2 in [{ a: 1 }, { a:: 1 }, { a::: 1 }]
+]) &&
+
+true

ui-tests/pass/stdlib/objectValues.jsonnet

@@ -0,0 +1,54 @@
+local test(obj, not_all, all) =
+  std.assertEqual(std.objectValues(obj), not_all) &&
+  std.assertEqual(std.objectValuesAll(obj), all);
+
+test({}, [], []) &&
+test({ a: 1 }, [1], [1]) &&
+test({ a: 1, b: 2 }, [1, 2], [1, 2]) &&
+test({ a: 1, b:: 2 }, [1], [1, 2]) &&
+test({ a: 1, b::: 2 }, [1, 2], [1, 2]) &&
+
+std.all([
+  local values = std.objectValues(obj);
+  local valuesAll = std.objectValuesAll(obj);
+
+  test(obj + {}, values, valuesAll) &&
+  test({} + obj, values, valuesAll) &&
+  true
+
+  for obj in [{}, { a: 1 }, { a:: 1 }, { a::: 1 }]
+]) &&
+
+std.all([
+  test(obj + { a: 1 }, std.objectValues(obj), [1]) &&
+  test(obj + { a:: 1 }, [], [1]) &&
+  test(obj + { a::: 1 }, [1], [1]) &&
+  true
+
+  for obj in [{ a: 1 }, { a:: 1 }, { a::: 1 }]
+]) &&
+
+std.all([
+  local values = std.objectValues(obj1 + obj2);
+  local valuesAll = std.objectValuesAll(obj1 + obj2);
+
+  test(obj1 + obj2 + {}, values, valuesAll) &&
+  test(obj1 + {} + obj2, values, valuesAll) &&
+  test({} + obj1 + obj2, values, valuesAll) &&
+  true
+
+  for obj1 in [{}, { a: 1 }, { a:: 1 }, { a::: 1 }]
+  for obj2 in [{}, { a: 1 }, { a:: 1 }, { a::: 1 }]
+]) &&
+
+std.all([
+  test(obj1 + obj2 + { a: 1 }, std.objectValues(obj1 + obj2), [1]) &&
+  test(obj1 + obj2 + { a:: 1 }, [], [1]) &&
+  test(obj1 + obj2 + { a::: 1 }, [1], [1]) &&
+  true
+
+  for obj1 in [{ a: 1 }, { a:: 1 }, { a::: 1 }]
+  for obj2 in [{ a: 1 }, { a:: 1 }, { a::: 1 }]
+]) &&
+
+true

ui-tests/pass/stdlib/resolvePath.jsonnet

@@ -0,0 +1,8 @@
+std.assertEqual(std.resolvePath("", "x"), "x") &&
+std.assertEqual(std.resolvePath("a", "x"), "x") &&
+std.assertEqual(std.resolvePath("a/", "x"), "a/x") &&
+std.assertEqual(std.resolvePath("a/b", "x"), "a/x") &&
+std.assertEqual(std.resolvePath("a/b/", "x"), "a/b/x") &&
+std.assertEqual(std.resolvePath("a/b/c", "x"), "a/b/x") &&
+
+true

ui-tests/pass/stdlib/sum.jsonnet

@@ -0,0 +1,7 @@
+std.assertEqual(std.sum([]), 0) &&
+std.assertEqual(std.sum([1]), 1) &&
+std.assertEqual(std.sum([1, 2]), 3) &&
+std.assertEqual(std.sum([1, 2, 3]), 6) &&
+std.assertEqual(std.sum([1, 2, 3, 4]), 10) &&
+
+true

ui-tests/pass/stdlib/xnor.jsonnet

@@ -0,0 +1,6 @@
+std.assertEqual(std.xnor(false, false), true) &&
+std.assertEqual(std.xnor(false, true), false) &&
+std.assertEqual(std.xnor(true, false), false) &&
+std.assertEqual(std.xnor(true, true), true) &&
+
+true

ui-tests/pass/stdlib/xor.jsonnet

@@ -0,0 +1,6 @@
+std.assertEqual(std.xor(false, false), false) &&
+std.assertEqual(std.xor(false, true), true) &&
+std.assertEqual(std.xor(true, false), true) &&
+std.assertEqual(std.xor(true, true), false) &&
+
+true