@momo-kits/native-kits 0.169.13-beta.4-debug → 0.169.13-debug

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (40) hide show
  1. package/CLAUDE.md +1 -4
  2. package/compose/build.gradle.kts +1 -5
  3. package/compose/compose.podspec +1 -1
  4. package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/BottomTabBar.kt +12 -4
  5. package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/CurvedContainer.kt +11 -3
  6. package/gradle/libs.versions.toml +0 -2
  7. package/gradle.properties +1 -1
  8. package/ios/Navigation/BottomTab/BottomTabBar.swift +14 -4
  9. package/ios/native-kits.podspec +1 -1
  10. package/ios-demo/MoMoUIKitsDemo.podspec +1 -1
  11. package/ios-demo/Sources/MoMoUIKitsDemo/SampleDemos/BottomTabDemo.swift +16 -3
  12. package/package.json +1 -1
  13. package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiActionsTest.kt +0 -647
  14. package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiExprTest.kt +0 -1411
  15. package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiHostTest.kt +0 -130
  16. package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiKitArgsTest.kt +0 -524
  17. package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiKitNodesTest.kt +0 -559
  18. package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiRenderPlanTest.kt +0 -741
  19. package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiRenderReuseTest.kt +0 -221
  20. package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiRendererPropsTest.kt +0 -270
  21. package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiStylePlanTest.kt +0 -849
  22. package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiStyleTest.kt +0 -212
  23. package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiTrackingTest.kt +0 -239
  24. package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiViewTest.kt +0 -252
  25. package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiActions.kt +0 -154
  26. package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiExpr.kt +0 -1038
  27. package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiKitNodes.kt +0 -848
  28. package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiLog.kt +0 -47
  29. package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiModel.kt +0 -39
  30. package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiPropsRenderer.kt +0 -463
  31. package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiRenderer.kt +0 -1146
  32. package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiStyle.kt +0 -667
  33. package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiTracking.kt +0 -240
  34. package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiValidate.kt +0 -185
  35. package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiView.kt +0 -200
  36. package/scripts/sdui-visual/README.md +0 -64
  37. package/scripts/sdui-visual/diff.py +0 -65
  38. package/scripts/sdui-visual/drive.py +0 -234
  39. package/scripts/sdui-visual/plan.json +0 -713
  40. package/scripts/sdui-visual/run.sh +0 -92
@@ -1,1411 +0,0 @@
1
- // File: compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiExprTest.kt
2
- // Created At: 2026-10-27 15:50:00 +07:00
3
- // Created By: AI
4
- // AI Agent: Claude Code
5
- // Model: claude-sonnet-5-5
6
-
7
- package vn.momo.kits.sdui
8
-
9
- import org.junit.Assert.assertEquals
10
- import org.junit.Assert.assertFalse
11
- import org.junit.Assert.assertNull
12
- import org.junit.Assert.assertSame
13
- import org.junit.Assert.assertTrue
14
- import org.junit.Test
15
- import androidx.compose.runtime.mutableStateMapOf
16
- import androidx.compose.runtime.snapshots.Snapshot
17
- import kotlinx.serialization.json.Json
18
-
19
- // AI-GENERATED START: unit tests for the SDUI expression evaluator
20
- class SduiExprTest {
21
- private val data: Map<String, Any?> = mapOf(
22
- "banner" to "https://x/y.png",
23
- "savedBill" to mapOf("name" to "Hóa đơn\nđã lưu", "icon" to "i.png"),
24
- "reviewSources" to mapOf("110851888322676" to listOf("a", "b"), "2" to listOf("c")),
25
- "categories" to listOf(mapOf("id" to "motorcycle", "name" to "Xe máy"), mapOf("id" to "car", "name" to "Ô tô")),
26
- "products" to listOf(
27
- mapOf("categoryId" to "car", "location" to "primary", "n" to 1L),
28
- mapOf("categoryId" to "car", "location" to "secondary", "n" to 2L),
29
- mapOf("categoryId" to "bike", "location" to "primary", "n" to 3L),
30
- ),
31
- "heroes" to mapOf("car" to mapOf("title" to "Bảo hiểm Ô tô")),
32
- "hero" to "{heroes[category]}",
33
- "hotProducts" to "{products.filter(p => p.categoryId == category && p.location == 'primary')}",
34
- "policies" to emptyList<Any?>(),
35
- "policyCount" to "{policies.length}",
36
- "loop1" to "{loop2}",
37
- "loop2" to "{loop1}",
38
- )
39
- private val state: Map<String, Any?> = mapOf(
40
- "reviewType" to 110851888322676L, "onboarded" to false, "page" to 1L, "category" to "car",
41
- )
42
- @Test fun failedDataExpressionLogsTheKeyNotTheText() {
43
- val lines = ArrayList<String>()
44
- val sc = SduiScope(mapOf("bad" to "{user.name(}"), emptyMap(), log = capturingLog(lines))
45
- assertNull(sc.lookup("bad"))
46
- assertEquals(1, lines.size)
47
- assertTrue(lines[0].endsWith("expr failed in data.bad"))
48
- assertFalse("user" in lines[0])
49
- assertNull(evalExpr("a b c(", sc))
50
- assertTrue(lines.any { it.endsWith("expr failed: a b c(") })
51
- }
52
-
53
- private fun scope(locals: Map<String, Any?> = emptyMap()) = SduiScope(data, state, locals)
54
- private fun ev(e: String, locals: Map<String, Any?> = emptyMap()) = evalExpr(e, scope(locals))
55
-
56
- @Test fun plainPaths() {
57
- assertEquals("https://x/y.png", ev("banner"))
58
- assertEquals("i.png", ev("savedBill.icon"))
59
- assertEquals("Hóa đơn\nđã lưu", ev("savedBill.name"))
60
- assertEquals("Ô tô", ev("c.name", mapOf("c" to data["categories"].asList()!![1])))
61
- }
62
-
63
- @Test fun negation() {
64
- assertEquals(true, ev("!state.onboarded"))
65
- assertEquals(false, ev("!state.page"))
66
- assertEquals(true, ev("!!state.page"))
67
- assertEquals(true, ev("!missing"))
68
- }
69
-
70
- @Test fun equalityFollowsJs() {
71
- assertEquals(true, ev("reviewType == r.typeId", mapOf("r" to mapOf("typeId" to 110851888322676L))))
72
- assertEquals(false, ev("reviewType == r.typeId", mapOf("r" to mapOf("typeId" to 112375004457086L))))
73
- assertEquals(true, ev("page == '1'")) // loose: the string is converted to a number
74
- assertEquals(false, ev("page === '1'"))
75
- assertEquals(true, ev("page == 1"))
76
- assertEquals(true, ev("s.badge != ''", mapOf("s" to mapOf("badge" to "Mới"))))
77
- assertEquals(false, ev("s.badge != ''", mapOf("s" to mapOf("badge" to ""))))
78
- assertEquals(true, ev("1 == 1.0"))
79
- }
80
-
81
- @Test fun indexAccess() {
82
- assertEquals(listOf("a", "b"), ev("reviewSources[reviewType]"))
83
- assertEquals("b", ev("reviewSources[reviewType][1]"))
84
- assertEquals("Xe máy", ev("categories[0].name"))
85
- assertNull(ev("reviewSources[unknownKey]"))
86
- assertNull(ev("categories[9].name"))
87
- }
88
-
89
- @Test fun arithmeticTernaryAndNullish() {
90
- assertEquals(2L, ev("state.page + 1"))
91
- assertEquals(true, ev("state.page < 2"))
92
- assertEquals(false, ev("state.page == 2"))
93
- assertEquals("Có", ev("state.page > 0 ? 'Có' : 'Không'"))
94
- assertEquals("def", ev("missing ?? 'def'"))
95
- assertEquals("Bảo vệ ngay Xe", ev("(hero2.button ?? 'Bảo vệ ngay') + ' ' + hero2.title", mapOf("hero2" to mapOf("title" to "Xe"))))
96
- assertEquals(1L, ev("i > 0 ? 1 : 0", mapOf("i" to 3L)))
97
- assertEquals("orange", ev("p.status == 'PENDING' || p.status == 'WAITING' ? 'orange' : 'grey'", mapOf("p" to mapOf("status" to "WAITING"))))
98
- }
99
-
100
- @Test fun arrayMethodsAndArrows() {
101
- assertEquals(1L, ev("categories.findIndex(c => c.id == category)"))
102
- assertEquals(2, (ev("products.filter(p => p.categoryId == 'car')") as List<*>).size)
103
- assertEquals(listOf(mapOf("categoryId" to "car", "location" to "primary", "n" to 1L)), ev("hotProducts"))
104
- assertEquals(2, (ev("products.slice(0, 2)") as List<*>).size)
105
- assertEquals(3L, ev("products.length"))
106
- assertEquals(true, ev("products.some(p => p.n == 3)"))
107
- }
108
-
109
- @Test fun derivedDataKeysResolveLazily() {
110
- assertEquals(mapOf("title" to "Bảo hiểm Ô tô"), ev("hero"))
111
- assertEquals(0L, ev("policyCount"))
112
- assertEquals(true, ev("policyCount == 0"))
113
- assertNull(ev("loop1")) // cycle reads null, never loops forever
114
- }
115
-
116
- @Test fun interpolationInsideLongerStrings() {
117
- val sc = scope(mapOf("c" to mapOf("name" to "Xe máy"), "s" to mapOf("referenceId" to "A1")))
118
- assertEquals("Mua bảo hiểm Xe máy", resolveString("Mua bảo hiểm {c.name}", sc))
119
- assertEquals("Hợp đồng bảo hiểm (0)", resolveString("Hợp đồng bảo hiểm ({policyCount})", sc))
120
- assertEquals("Số HĐ: A1", resolveString("Số HĐ: {s.referenceId}", sc))
121
- assertEquals("x ", resolveString("x {missing}", sc)) // null interpolates as ""
122
- assertEquals("plain", resolveString("plain", sc))
123
- assertEquals(110851888322676L, resolveString("{reviewType}", sc)) // whole-value binding keeps its type
124
- }
125
-
126
- @Test fun unknownOrBrokenExpressionsAreNullAndNeverThrow() {
127
- for (e in listOf("", "(", ")", "a.", "a[", "1 +", "?", "foo(", "'unterminated", "@@", "a => ", "x.y.z.w", "categories.nope()", "null.x", "undefined[0]")) {
128
- val r = runCatching { evalExpr(e, scope()) }
129
- assertTrue("threw for '$e'", r.isSuccess)
130
- }
131
- assertNull(ev("nope"))
132
- assertNull(ev("nope.deeper.still"))
133
- assertNull(ev("constructor"))
134
- assertNull(ev("categories.__proto__"))
135
- }
136
-
137
- @Test fun unwrapBindingRules() {
138
- assertEquals("a.b", unwrapBinding("{a.b}"))
139
- assertEquals(" x ", unwrapBinding("{ x }"))
140
- assertNull(unwrapBinding("a {b}"))
141
- assertNull(unwrapBinding("{a} {b}"))
142
- assertNull(unwrapBinding("plain"))
143
- assertFalse(truthy(""))
144
- assertTrue(truthy("x"))
145
- assertFalse(truthy(0L))
146
- }
147
-
148
- // ---- extended coverage -------------------------------------------------------------------------------------
149
-
150
- /** A callable local that counts invocations, to prove whether an operand was evaluated. */
151
- private class Probe {
152
- var calls = 0
153
- val fn: (List<Any?>) -> Any? = { calls++; true }
154
- }
155
-
156
- private fun list(e: String, locals: Map<String, Any?> = emptyMap()) = ev(e, locals) as List<*>
157
-
158
- @Test fun lookupPrecedenceLocalThenStateThenData() {
159
- val d = mapOf("x" to "data", "y" to "data", "z" to "data", "derived" to "{y}")
160
- val st = mapOf("x" to "state", "y" to "state")
161
- val pr = mapOf("x" to "param", "p" to "P")
162
- val sc = SduiScope(d, st, locals = mapOf("x" to "local"), params = pr)
163
- assertEquals("local", sc.lookup("x"))
164
- assertEquals("state", sc.lookup("y"))
165
- assertEquals("data", sc.lookup("z"))
166
- assertEquals("state", sc.lookup("derived")) // derived data evaluates in the same scope
167
- assertNull(sc.lookup("nope"))
168
- assertEquals("state", evalExpr("state.x", sc))
169
- assertEquals("data", evalExpr("data.x", sc))
170
- assertEquals("param", evalExpr("params.x", sc))
171
- assertEquals("P", evalExpr("params.p", sc))
172
- assertNull(evalExpr("state.z", sc))
173
- assertEquals("state", evalExpr("data.derived", sc)) // the prefixed form evaluates a derived key too
174
- // a local named like a reserved root wins over it; a null local masks state/data
175
- val shadow = SduiScope(d, st, locals = mapOf("state" to mapOf("x" to "L"), "y" to null))
176
- assertEquals("L", evalExpr("state.x", shadow))
177
- assertNull(evalExpr("y", shadow))
178
- // the reserved names beat same-named state keys (state key `params` is unreachable by bare name)
179
- val sc2 = SduiScope(emptyMap(), mapOf("params" to "st", "data" to "st"), params = mapOf("k" to 1L))
180
- assertEquals(mapOf("k" to 1L), sc2.lookup("params"))
181
- assertEquals(emptyMap<String, Any?>(), sc2.lookup("data"))
182
- }
183
-
184
- @Test fun withDoesNotMutateTheOriginalScope() {
185
- val s0 = scope()
186
- val s1 = s0.with("category", "LOCAL")
187
- assertEquals("car", s0.lookup("category"))
188
- assertEquals("LOCAL", s1.lookup("category"))
189
- assertTrue(s0.locals.isEmpty())
190
- assertEquals(mapOf("category" to "LOCAL"), s1.locals)
191
- assertSame(s0.data, s1.data); assertSame(s0.state, s1.state); assertSame(s0.params, s1.params)
192
- val s2 = s1.with("other", 1L).with("category", "L2")
193
- assertEquals("L2", s2.lookup("category"))
194
- assertEquals(1L, s2.lookup("other"))
195
- assertEquals("LOCAL", s1.lookup("category"))
196
- assertNull(s1.lookup("other"))
197
- // a derived data key that reads a repeat local sees each copy's own item
198
- val base = SduiScope(mapOf("d" to "{item.name}"), emptyMap())
199
- assertEquals("A", base.with("item", mapOf("name" to "A")).lookup("d"))
200
- assertEquals("B", base.with("item", mapOf("name" to "B")).lookup("d"))
201
- }
202
-
203
- @Test fun arithmeticOperators() {
204
- assertEquals(2L, ev("5 - 3"))
205
- assertEquals(15L, ev("5 * 3"))
206
- assertEquals(3.5, ev("7 / 2"))
207
- assertEquals(3L, ev("6 / 2"))
208
- assertTrue(ev("6 / 2") is Long)
209
- assertTrue(ev("7 / 2") is Double)
210
- assertEquals(1L, ev("7 % 3"))
211
- assertEquals(-1L, ev("-7 % 3"))
212
- assertEquals(1.5, ev("5.5 % 2"))
213
- assertEquals(2.5, ev("1 + 1.5"))
214
- assertEquals(1L, ev("0.5 + 0.5")) // integral double result is normalised to Long
215
- assertEquals(0.1 + 0.2, ev("0.1 + 0.2"))
216
- assertEquals(42L, ev("'6' * '7'"))
217
- assertEquals(3L, ev("'5' - 2"))
218
- assertEquals(7L, ev("1 + 2 * 3"))
219
- assertEquals(9L, ev("(1 + 2) * 3"))
220
- assertEquals(5L, ev("10 - 2 - 3")) // left associative
221
- assertEquals(2L, ev("100 / 10 / 5"))
222
- assertEquals(2L, ev("2 * 3 % 4"))
223
- assertEquals(2L, ev("1 - -1"))
224
- assertTrue((ev("'abc' - 1") as Double).isNaN())
225
- assertTrue((ev("[1, 2] * 2") as Double).isNaN())
226
- assertTrue((ev("o * 2", mapOf("o" to mapOf("a" to 1L))) as Double).isNaN())
227
- assertEquals(-1L, ev("missing - 1")) // missing is null -> 0
228
- assertEquals(10L, ev("[5] * 2")) // single-element array -> its number
229
- assertEquals(0L, ev("[] * 2"))
230
- assertEquals(2L, ev("true * 2"))
231
- assertEquals(5L, ev("' 5 ' * 1"))
232
- assertEquals(0L, ev("'' * 1"))
233
- assertEquals(31L, ev("'0x1F' * 1"))
234
- assertTrue((ev("'1px' * 1") as Double).isNaN())
235
- assertTrue((ev("'1d' * 1") as Double).isNaN()) // no Kotlin/Java numeric suffixes
236
- assertEquals(Double.POSITIVE_INFINITY, ev("'Infinity' * 1"))
237
- assertEquals(1500L, ev("'1.5e3' * 1"))
238
- // numbers are doubles: no Long wrap-around, integral results stay Long only below 2^53
239
- assertEquals(9.223372036854776E18, ev("9223372036854775807 + 1"))
240
- assertEquals(9007199254740991L, ev("9007199254740990 + 1"))
241
- assertEquals(9.007199254740992E15, ev("9007199254740991 + 1"))
242
- assertEquals(1.0E20, ev("10000000000 * 10000000000"))
243
- assertEquals(-9.007199254740992E15, ev("-9007199254740991 - 1"))
244
- }
245
-
246
- @Test fun divisionAndModuloByZeroDoNotThrow() {
247
- assertEquals(Double.POSITIVE_INFINITY, ev("1 / 0"))
248
- assertEquals(Double.NEGATIVE_INFINITY, ev("-1 / 0"))
249
- assertTrue((ev("0 / 0") as Double).isNaN())
250
- assertTrue((ev("5 % 0") as Double).isNaN())
251
- assertEquals("Infinity", str(ev("1 / 0")))
252
- assertEquals("NaN", str(ev("0 / 0")))
253
- assertFalse(truthy(ev("0 / 0")))
254
- assertEquals(false, ev("0 / 0 == 0 / 0")) // NaN != NaN, like JS
255
- }
256
-
257
- @Test fun unaryMinus() {
258
- assertEquals(-5L, ev("-x", mapOf("x" to 5L)))
259
- assertEquals(-2.5, ev("-x", mapOf("x" to 2.5)))
260
- assertEquals(-1L, ev("-state.page"))
261
- assertEquals(-3L, ev("-(1 + 2)"))
262
- assertEquals(2L, ev("- -2"))
263
- assertEquals(-6L, ev("-2 * 3"))
264
- assertEquals(0L, ev("-0")) // no negative zero leaks out
265
- assertEquals(-7L, ev("-'7'"))
266
- assertTrue((ev("-'abc'") as Double).isNaN())
267
- assertEquals(0L, ev("-missing")) // null -> 0
268
- assertEquals(-1L, ev("-true"))
269
- }
270
-
271
- @Test fun strictAndLooseEqualityOperators() {
272
- assertEquals(true, ev("1 === 1"))
273
- assertEquals(false, ev("1 === '1'"))
274
- assertEquals(true, ev("1 !== '1'"))
275
- assertEquals(false, ev("1 !== 1.0"))
276
- assertEquals(true, ev("'a' === 'a'"))
277
- assertEquals(true, ev("missing === null"))
278
- assertEquals(true, ev("missing == undefined"))
279
- assertEquals(true, ev("0 == false")) // loose: booleans convert to numbers
280
- assertEquals(false, ev("0 === false"))
281
- assertEquals(false, ev("true != 1"))
282
- assertEquals(true, ev("true !== 1"))
283
- assertEquals(false, ev("2 == true"))
284
- assertEquals(true, ev("'1' == true"))
285
- assertEquals(true, ev("'' == 0"))
286
- assertEquals(true, ev("' 1.0 ' == 1"))
287
- assertEquals(false, ev("'abc' == 0"))
288
- assertEquals(false, ev("'' == null")) // null only equals null / undefined
289
- assertEquals(false, ev("0 == null"))
290
- assertEquals(false, ev("false == null"))
291
- assertEquals(true, ev("null == undefined"))
292
- assertEquals(true, ev("null === undefined")) // one nullish value
293
- assertEquals(true, ev("'a' == 'a'"))
294
- assertEquals(false, ev("'a' == 'A'"))
295
- // lists / maps compare by reference, for == and ===
296
- assertEquals(true, ev("c1 == c1", mapOf("c1" to listOf(1L))))
297
- assertEquals(true, ev("c1 === c1", mapOf("c1" to listOf(1L))))
298
- assertEquals(false, ev("a == b", mapOf("a" to listOf(1L), "b" to listOf(1L))))
299
- assertEquals(false, ev("[] == []"))
300
- assertEquals(false, ev("a == b", mapOf("a" to mapOf("k" to 1L), "b" to mapOf("k" to 1L))))
301
- assertEquals(true, ev("savedBill == savedBill"))
302
- // ... and against a primitive through their string form
303
- assertEquals(true, ev("[1] == 1"))
304
- assertEquals(true, ev("[1, 2] == '1,2'"))
305
- assertEquals(true, ev("[] == ''"))
306
- assertEquals(true, ev("[] == false"))
307
- assertEquals(false, ev("[1] === 1"))
308
- assertEquals(true, ev("o == '[object Object]'", mapOf("o" to mapOf("a" to 1L))))
309
- // NaN equals nothing
310
- assertEquals(false, ev("n == n", mapOf("n" to Double.NaN)))
311
- assertEquals(true, ev("n != n", mapOf("n" to Double.NaN)))
312
- }
313
-
314
- @Test fun plusConcatenatesWhenEitherSideIsNotANumber() {
315
- assertEquals("Còn 2", ev("'Còn ' + 2"))
316
- assertEquals("2 ngày", ev("2 + ' ngày'"))
317
- assertEquals("23", ev("2 + '3'")) // number + numeric string: concatenation, like JS
318
- assertEquals("51", ev("'5' + 1"))
319
- assertEquals("3x", ev("1 + 2 + 'x'"))
320
- assertEquals("x12", ev("'x' + 1 + 2"))
321
- assertEquals("1.51", ev("'1.5' + 1"))
322
- assertEquals("a2", ev("'a' + 2.0"))
323
- assertEquals("a2.5", ev("'a' + 2.5"))
324
- assertEquals("atrue", ev("'a' + true"))
325
- assertEquals("a1,2", ev("'a' + [1, 2]"))
326
- assertEquals("a1.5", ev("'a' + 1.5"))
327
- assertEquals("a5", ev("'a' + 5.0"))
328
- assertEquals("anull", ev("'a' + null"))
329
- assertEquals("anull", ev("'a' + missing")) // missing is null
330
- assertEquals("afalse", ev("'a' + false"))
331
- assertEquals("a[object Object]", ev("'a' + o", mapOf("o" to mapOf("k" to 1L))))
332
- assertEquals("aNaN", ev("'a' + n", mapOf("n" to Double.NaN)))
333
- assertEquals("a1e+21", ev("'a' + n", mapOf("n" to 1e21)))
334
- assertEquals("a0.000001", ev("'a' + n", mapOf("n" to 1e-6)))
335
- assertEquals("1,23", ev("[1, 2] + 3")) // arrays become strings first
336
- assertEquals("1", ev("[] + 1"))
337
- // no string operand: numeric addition (null -> 0, booleans -> 1/0)
338
- assertEquals(1L, ev("1 + null"))
339
- assertEquals(0L, ev("null + null"))
340
- assertEquals(2L, ev("true + 1"))
341
- assertEquals(1L, ev("true + false"))
342
- assertEquals(5L, ev("missing + 5"))
343
- assertTrue((ev("1 + n", mapOf("n" to Double.NaN)) as Double).isNaN())
344
- }
345
-
346
- @Test fun comparisonsWithNullTreatItAsZero() {
347
- val expected = mapOf("<" to listOf(true, false, false), ">" to listOf(false, true, false),
348
- "<=" to listOf(true, false, true), ">=" to listOf(false, true, true))
349
- for ((op, want) in expected) {
350
- assertEquals("null $op 1", want[0], ev("null $op 1"))
351
- assertEquals("1 $op null", want[1], ev("1 $op null"))
352
- assertEquals("missing $op 1", want[0], ev("missing $op 1"))
353
- assertEquals("null $op null", want[2], ev("null $op null"))
354
- }
355
- assertEquals(true, ev("null >= 0"))
356
- assertEquals(false, ev("null > 0"))
357
- assertEquals(true, ev("null == null"))
358
- assertEquals(true, ev("null != 0"))
359
- // NaN on either side is always false
360
- for (op in listOf("<", ">", "<=", ">=")) {
361
- assertEquals(false, ev("n $op 1", mapOf("n" to Double.NaN)))
362
- assertEquals(false, ev("'abc' $op 1"))
363
- assertEquals(false, ev("o $op 1", mapOf("o" to mapOf("a" to 1L))))
364
- }
365
- }
366
-
367
- @Test fun stringAndMixedComparisons() {
368
- assertEquals(true, ev("'a' < 'b'"))
369
- assertEquals(false, ev("'b' < 'a'"))
370
- assertEquals(true, ev("'abc' < 'abd'"))
371
- assertEquals(true, ev("'Z' < 'a'")) // code-point order
372
- assertEquals(true, ev("'10' < '9'")) // lexicographic when both are strings
373
- assertEquals(true, ev("'a' <= 'a'"))
374
- assertEquals(false, ev("'a' >= 'b'"))
375
- assertEquals(false, ev("'10' < 9")) // string vs number: numeric
376
- assertEquals(true, ev("'2' < 10"))
377
- assertEquals(true, ev("true > false"))
378
- assertEquals(true, ev("2 >= 2.0"))
379
- assertEquals(true, ev("1.5 > 1"))
380
- assertEquals(false, ev("'abc' < 1")) // NaN -> false
381
- assertEquals(false, ev("'abc' >= 1"))
382
- assertEquals(true, ev("'' < 1")) // '' -> 0
383
- assertEquals(true, ev("[2] > 1")) // [2] -> '2' -> 2
384
- assertEquals(true, ev("[10] < [9]")) // both become strings: lexical
385
- assertEquals(true, ev("'\u00e9' > 'z'")) // UTF-16 code units
386
- }
387
-
388
- @Test fun logicalOperatorsReturnOperandValues() {
389
- assertEquals("x", ev("a || 'x'", mapOf("a" to "")))
390
- assertEquals("v", ev("a || 'x'", mapOf("a" to "v")))
391
- assertEquals("x", ev("a || 'x'"))
392
- assertEquals(0L, ev("0 && b", mapOf("b" to "never")))
393
- assertEquals("b", ev("1 && 'b'"))
394
- assertNull(ev("null && 'b'"))
395
- assertEquals(0L, ev("'' || 0"))
396
- assertEquals("c", ev("a || b || 'c'", mapOf("a" to 0L, "b" to "")))
397
- assertEquals("b", ev("0 || 'a' && 'b'")) // && binds tighter than ||
398
- assertEquals("Mới", ev("s.badge || 'Mới'", mapOf("s" to mapOf("badge" to ""))))
399
- assertEquals(listOf(1L), ev("l && l", mapOf("l" to listOf(1L)))) // empty/non-empty lists are truthy objects
400
- assertEquals(0L, ev("0 ?? 5"))
401
- assertEquals("", ev("'' ?? 'x'"))
402
- assertEquals(false, ev("false ?? 1"))
403
- assertEquals("z", ev("missing ?? other ?? 'z'"))
404
- assertEquals(0L, ev("null ?? 0"))
405
- }
406
-
407
- @Test fun logicalOperatorsShortCircuit() {
408
- val p = Probe()
409
- val loc = mapOf("probe" to p.fn)
410
- assertEquals(false, ev("false && probe()", loc)); assertEquals(0, p.calls)
411
- assertEquals(true, ev("true || probe()", loc)); assertEquals(0, p.calls)
412
- assertEquals(1L, ev("1 ?? probe()", loc)); assertEquals(0, p.calls)
413
- assertEquals(1L, ev("true ? 1 : probe()", loc)); assertEquals(0, p.calls)
414
- assertEquals(2L, ev("false ? probe() : 2", loc)); assertEquals(0, p.calls)
415
- // controls: the right side IS evaluated when the left does not decide
416
- assertEquals(true, ev("true && probe()", loc)); assertEquals(1, p.calls)
417
- assertEquals(true, ev("false || probe()", loc)); assertEquals(2, p.calls)
418
- assertEquals(true, ev("missing ?? probe()", loc)); assertEquals(3, p.calls)
419
- // a broken right-hand lookup behind a guard is simply skipped / null
420
- assertNull(ev("user && user.name.first.deep"))
421
- assertEquals("ok", ev("user ? user.name.first : 'ok'"))
422
- }
423
-
424
- @Test fun listFindEveryMapIncludesIndexOf() {
425
- assertEquals(2L, ev("[1, 2, 3].find(x => x > 1)"))
426
- assertNull(ev("[1, 2, 3].find(x => x > 5)"))
427
- assertEquals(mapOf("categoryId" to "bike", "location" to "primary", "n" to 3L), ev("products.find(p => p.n == 3)"))
428
- assertEquals(true, ev("[2, 4].every(x => x % 2 == 0)"))
429
- assertEquals(false, ev("[2, 3].every(x => x % 2 == 0)"))
430
- assertEquals(true, ev("[].every(x => false)"))
431
- assertEquals(false, ev("[].some(x => true)"))
432
- assertEquals(listOf(2L, 4L, 6L), ev("[1, 2, 3].map(x => x * 2)"))
433
- assertEquals(listOf("a0", "b1"), ev("['a', 'b'].map((x, i) => x + i)"))
434
- assertEquals(listOf(1L, 2L, 3L), ev("products.map(p => p.n)"))
435
- assertEquals(emptyList<Any?>(), ev("[].map(x => x)"))
436
- assertEquals(true, ev("[1, 2, 3].includes(2)"))
437
- assertEquals(false, ev("[1, 2, 3].includes('2')")) // strict
438
- assertEquals(true, ev("[1, 2].includes(1.0)"))
439
- assertEquals(true, ev("['a'].includes(c)", mapOf("c" to "a")))
440
- assertEquals(false, ev("categories.includes('car')"))
441
- assertEquals(1L, ev("['a', 'b'].indexOf('b')"))
442
- assertEquals(-1L, ev("['a', 'b'].indexOf('z')"))
443
- assertEquals(-1L, ev("[1].indexOf('1')"))
444
- }
445
-
446
- @Test fun listJoinConcatAndSlice() {
447
- assertEquals("1,2,3", ev("[1, 2, 3].join()"))
448
- assertEquals("1-2-3", ev("[1, 2, 3].join('-')"))
449
- assertEquals("123", ev("[1, 2, 3].join('')"))
450
- assertEquals("Xe máy, Ô tô", ev("categories.map(c => c.name).join(', ')"))
451
- assertEquals("1||a|2", ev("[1, null, 'a', 2.0].join('|')"))
452
- assertEquals("", ev("[].join('-')"))
453
- assertEquals(listOf(1L, 2L, 3L), ev("[1, 2].concat([3])"))
454
- assertEquals(listOf(1L, 2L, null), ev("[1, 2].concat(missing)"))
455
- assertEquals(listOf(1L, 2L, 3L), ev("[1, 2].concat(3)"))
456
- assertEquals(listOf(1L, 2L, 3L, 4L, "x", listOf(5L)), ev("[1].concat(2, [3, 4], 'x', [[5]])")) // flattened one level
457
- assertEquals(listOf(1L), ev("[1].concat()"))
458
- assertEquals("1-[object Object]", ev("[1, o].join('-')", mapOf("o" to mapOf("a" to 1L))))
459
- assertEquals("1,2-3", ev("[[1, 2], 3].join('-')"))
460
- assertEquals("1,2", ev("[1, 2].join(missing)")) // a null separator is treated as omitted
461
- val l = listOf(1L, 2L)
462
- ev("a.concat([9])", mapOf("a" to l)); assertEquals(listOf(1L, 2L), l)
463
- assertEquals(listOf(3L, 4L), ev("[1, 2, 3, 4].slice(-2)"))
464
- assertEquals(listOf(2L, 3L), ev("[1, 2, 3, 4].slice(1, -1)"))
465
- assertEquals(listOf(1L, 2L, 3L, 4L), ev("[1, 2, 3, 4].slice(-10)"))
466
- assertEquals(listOf(1L, 2L, 3L, 4L), ev("[1, 2, 3, 4].slice()"))
467
- assertEquals(listOf(2L, 3L), ev("[1, 2, 3, 4].slice(1, 3)"))
468
- assertEquals(emptyList<Any?>(), ev("[1, 2, 3, 4].slice(3, 1)"))
469
- assertEquals(emptyList<Any?>(), ev("[1, 2].slice(5)"))
470
- assertEquals(3L, ev("products.slice(-1)[0].n"))
471
- assertEquals(listOf(2L, 3L), ev("[1, 2, 3].filter((x, i) => i > 0)"))
472
- assertEquals(listOf(2L, 3L), ev("[1, 2, 3, 4].slice('1', 3.9)")) // indexes go through ToNumber and truncate
473
- assertEquals(listOf(1L, 2L), ev("[1, 2].slice(n)", mapOf("n" to Double.NaN)))
474
- assertEquals(true, ev("[n].includes(n)", mapOf("n" to Double.NaN))) // includes is SameValueZero
475
- assertEquals(-1L, ev("[n].indexOf(n)", mapOf("n" to Double.NaN))) // indexOf is strict
476
- assertEquals(listOf(true), ev("[o].map(x => x == o)", mapOf("o" to mapOf("a" to 1L))))
477
- assertEquals(false, ev("[a].includes(b)", mapOf("a" to listOf(1L), "b" to listOf(1L)))) // by reference
478
- }
479
-
480
- @Test fun listMethodsOnNonListsReturnNull() {
481
- assertNull(ev("missing.map(x => x)"))
482
- assertNull(ev("n.map(x => x)", mapOf("n" to 5L)))
483
- assertNull(ev("savedBill.map(x => x)"))
484
- assertNull(ev("b.filter(x => x)", mapOf("b" to true)))
485
- assertNull(ev("n.join(',')", mapOf("n" to 5L)))
486
- assertNull(ev("missing.length"))
487
- assertNull(ev("n.length", mapOf("n" to 5L)))
488
- assertNull(ev("b.length", mapOf("b" to true)))
489
- // unsupported / malformed list calls are null, not errors
490
- assertNull(ev("[1].reverse()"))
491
- assertNull(ev("[1, 2].reduce((a, b) => a + b, 0)"))
492
- assertNull(ev("[1].filter()"))
493
- assertNull(ev("[1].map(1)"))
494
- assertNull(ev("[1].find('x')"))
495
- assertNull(ev("[1].nope()"))
496
- }
497
-
498
- @Test fun stringMethods() {
499
- assertEquals("XE MÁY", ev("'xe máy'.toUpperCase()"))
500
- assertEquals("hi", ev("'Hi'.toLowerCase()"))
501
- assertEquals("hi", ev("' hi '.trim()"))
502
- assertEquals("hi", ev("s.trim()", mapOf("s" to "\n hi\t")))
503
- assertEquals(true, ev("'Hello'.includes('ell')"))
504
- assertEquals(false, ev("'Hello'.includes('hello')")) // case sensitive
505
- assertEquals(true, ev("'Hello'.startsWith('He')"))
506
- assertEquals(false, ev("'Hello'.startsWith('lo')"))
507
- assertEquals(true, ev("'Hello'.endsWith('lo')"))
508
- assertEquals(2L, ev("'hello'.indexOf('l')"))
509
- assertEquals(-1L, ev("'hello'.indexOf('z')"))
510
- assertEquals(listOf("a", "b", "c"), ev("'a,b,c'.split(',')"))
511
- assertEquals(listOf("a", "", "b"), ev("'a,,b'.split(',')"))
512
- assertEquals(listOf("a b"), ev("'a b'.split(',')"))
513
- assertEquals("el", ev("'hello'.slice(1, 3)"))
514
- assertEquals("llo", ev("'hello'.slice(-3)"))
515
- assertEquals("hell", ev("'hello'.slice(0, -1)"))
516
- assertEquals("", ev("'hello'.slice(10)"))
517
- assertEquals("", ev("'hello'.slice(3, 1)"))
518
- assertEquals("el", ev("'hello'.substring(1, 3)"))
519
- assertEquals("llo", ev("'hello'.substring(2)"))
520
- assertEquals("hello", ev("'hello'.substring(-3)")) // negative -> 0
521
- assertEquals("el", ev("'hello'.substring(3, 1)")) // swapped
522
- assertEquals("he", ev("'hello'.substring(2, -1)"))
523
- assertEquals("hello", ev("'hello'.substring(n)", mapOf("n" to Double.NaN)))
524
- assertEquals("ello", ev("'hello'.substring(1, 99)"))
525
- assertEquals("el", ev("'hello'.substring('1', '3')"))
526
- assertEquals("ell", ev("'hello'.slice(1, -1)"))
527
- assertEquals("hello", ev("'hello'.slice(-99)"))
528
- assertEquals("lo", ev("'hello'.slice(3.7)"))
529
- assertEquals(5L, ev("'hello'.length"))
530
- assertEquals(5L, ev("s.length", mapOf("s" to "hello")))
531
- assertEquals("h", ev("s[0]", mapOf("s" to "hello")))
532
- assertEquals("o", ev("s[4]", mapOf("s" to "hello")))
533
- assertNull(ev("s[5]", mapOf("s" to "hello")))
534
- assertNull(ev("s[-1]", mapOf("s" to "hello")))
535
- assertEquals(listOf("a", "b"), ev("'ab'.split('')"))
536
- assertEquals(listOf("ab"), ev("'ab'.split()"))
537
- assertEquals(emptyList<Any?>(), ev("''.split('')"))
538
- assertEquals(listOf(""), ev("''.split(',')"))
539
- assertEquals(listOf("a", "b"), ev("'a,b,c'.split(',', 2)"))
540
- assertEquals(emptyList<Any?>(), ev("'a,b,c'.split(',', 0)"))
541
- assertEquals(listOf("a", "b", "c"), ev("'abc'.split('', 5)"))
542
- assertEquals(listOf("1", "2"), ev("'1x2'.split('x')"))
543
- // position arguments
544
- assertEquals(3L, ev("'hello'.indexOf('l', 3)"))
545
- assertEquals(-1L, ev("'hello'.indexOf('h', 1)"))
546
- assertEquals(2L, ev("'hello'.indexOf('', 2)"))
547
- assertEquals(5L, ev("'hello'.indexOf('', 99)"))
548
- assertEquals(false, ev("'hello'.includes('h', 1)"))
549
- assertEquals(true, ev("'hello'.includes('o', -5)"))
550
- assertEquals(true, ev("'hello'.startsWith('ll', 2)"))
551
- assertEquals(true, ev("'hello'.endsWith('ell', 4)"))
552
- assertEquals(false, ev("'hello'.endsWith('lo', 4)"))
553
- assertEquals(true, ev("'a1'.includes(1)")) // the search value goes through ToString
554
- assertEquals("x", ev("s.trim()", mapOf("s" to "\u00a0x\ufeff")))
555
- // unsupported string methods are null (replace, charAt, repeat, padStart, concat ...)
556
- assertNull(ev("'abc'.replace('a', 'b')"))
557
- assertNull(ev("'abc'.charAt(0)"))
558
- assertNull(ev("'abc'.padStart(5)"))
559
- assertNull(ev("'abc'.nope()"))
560
- }
561
-
562
- @Test fun toFixedUsesTheExactBinaryValue() {
563
- assertEquals("1.00", toFixed(1.005, 2)) // 1.005 is really 1.00499...
564
- assertEquals("3", toFixed(2.5, 0))
565
- assertEquals("-3", toFixed(-2.5, 0))
566
- assertEquals("1", toFixed(0.5, 0))
567
- assertEquals("0", toFixed(0.4, 0))
568
- assertEquals("1234.57", toFixed(1234.5678, 2))
569
- assertEquals("3.14", toFixed(3.14159, 2))
570
- assertEquals("-3.14", toFixed(-3.14159, 2))
571
- assertEquals("5.00", toFixed(5.0, 2))
572
- assertEquals("0.00", toFixed(0.0, 2))
573
- assertEquals("0.05", toFixed(0.05, 2))
574
- assertEquals("0.5", toFixed(0.5, 1))
575
- assertEquals("12", toFixed(12.0, 0))
576
- assertEquals("0.1", toFixed(0.1, 1))
577
- assertEquals("1.4", toFixed(1.45, 1)) // 1.45 is really 1.4499999...
578
- assertEquals("-0.00", toFixed(-0.001, 2)) // the sign of a value rounding to zero is kept
579
- assertEquals("0.00", toFixed(-0.0, 2))
580
- assertEquals("1000000.00", toFixed(1_000_000.0, 2))
581
- assertTrue(runCatching { toFixed(12.4, -1) }.isFailure) // RangeError in JS
582
- assertTrue(runCatching { toFixed(12.4, 101) }.isFailure)
583
- assertEquals("NaN", toFixed(Double.NaN, 2))
584
- assertEquals("Infinity", toFixed(Double.POSITIVE_INFINITY, 2))
585
- }
586
-
587
- @Test fun toFixedMatchesJavaScriptOutputs() {
588
- // every expected string was produced by node v20 (`v.toFixed(d)`)
589
- val cases = listOf(
590
- Triple(1.45, 1, "1.4"), Triple(1.005, 2, "1.00"), Triple(-0.001, 2, "-0.00"), Triple(2.5, 0, "3"),
591
- Triple(-2.5, 0, "-3"), Triple(0.5, 0, "1"), Triple(1.5, 0, "2"), Triple(0.4, 0, "0"),
592
- Triple(1234.5678, 2, "1234.57"), Triple(8.345, 2, "8.35"), Triple(1.255, 2, "1.25"), Triple(10.235, 2, "10.23"),
593
- Triple(0.000001, 7, "0.0000010"), Triple(123.456, 10, "123.4560000000"), Triple(1e21, 2, "1e+21"),
594
- Triple(-1.5e21, 1, "-1.5e+21"), Triple(0.1, 20, "0.10000000000000000555"),
595
- Triple(0.3, 30, "0.299999999999999988897769753748"), Triple(5e-324, 2, "0.00"),
596
- Triple(1.7976931348623157e308, 0, "1.7976931348623157e+308"), Triple(999.995, 2, "1000.00"), Triple(4.35, 1, "4.3"),
597
- Triple(0.045, 2, "0.04"), Triple(0.615, 2, "0.61"), Triple(1.0000000000000002, 17, "1.00000000000000022"),
598
- Triple(123456789.98765432, 3, "123456789.988"), Triple(2.675, 2, "2.67"), Triple(0.1 + 0.2, 17, "0.30000000000000004"),
599
- Triple(1e20, 2, "100000000000000000000.00"), Triple(7.0000005, 6, "7.000000"), Triple(33.3335, 3, "33.334"),
600
- Triple(0.000123456, 8, "0.00012346"), Triple(9007199254740992.0, 1, "9007199254740992.0"), Triple(-1e-7, 5, "-0.00000"),
601
- Triple(0.5, 100, "0." + "5".padEnd(100, '0')),
602
- )
603
- for ((v, d, want) in cases) assertEquals("($v).toFixed($d)", want, toFixed(v, d))
604
- }
605
-
606
- @Test fun toFixedViaExpression() {
607
- assertEquals("3.14", ev("x.toFixed(2)", mapOf("x" to 3.14159)))
608
- assertEquals("5.00", ev("n.toFixed(2)", mapOf("n" to 5L))) // integer (Long) input
609
- assertEquals("5", ev("n.toFixed()", mapOf("n" to 5L))) // default digits 0
610
- assertEquals("3", ev("x.toFixed(0)", mapOf("x" to 2.5)))
611
- assertEquals("2.50", ev("(5 / 2).toFixed(2)"))
612
- assertEquals("3.14", ev("3.14159.toFixed(2)"))
613
- assertEquals("12.50", ev("Number('12.5').toFixed(2)"))
614
- assertEquals("1.50", ev("(price * 1.5).toFixed(2)", mapOf("price" to 1L)))
615
- assertNull(ev("missing.toFixed(2)"))
616
- assertNull(ev("'5'.toFixed(2)")) // string receiver is not a number
617
- assertEquals("1.23 đ", ev("x.toFixed(2) + ' đ'", mapOf("x" to 1.234)))
618
- assertEquals("0", ev("x.toFixed('a')", mapOf("x" to 0.4))) // non-numeric digits arg -> 0
619
- assertEquals("1.4", ev("x.toFixed(1.9)", mapOf("x" to 1.45))) // digits truncate
620
- assertEquals("1.4", ev("(1.45).toFixed(1)"))
621
- assertEquals("-0.00", ev("(-0.001).toFixed(2)"))
622
- assertNull(ev("x.toFixed(-1)", mapOf("x" to 1L))) // RangeError -> null
623
- assertNull(ev("x.toFixed(101)", mapOf("x" to 1L)))
624
- }
625
-
626
- @Test fun globalsMathNumberStringBoolean() {
627
- assertEquals(3L, ev("Math.round(2.5)"))
628
- assertEquals(2L, ev("Math.round(2.4)"))
629
- assertEquals(-2L, ev("Math.round(-2.5)")) // half rounds up, same as JS
630
- assertEquals(2L, ev("Math.floor(2.7)"))
631
- assertEquals(-3L, ev("Math.floor(-2.1)"))
632
- assertEquals(3L, ev("Math.ceil(2.1)"))
633
- assertEquals(5L, ev("Math.abs(-5)"))
634
- assertEquals(2.5, ev("Math.abs(-2.5)"))
635
- assertEquals(5L, ev("Math.max(1, 5, 3)"))
636
- assertEquals(1L, ev("Math.min(4, 1, 3)"))
637
- assertEquals(7L, ev("Math.max(1, '7')"))
638
- assertEquals(3.5, ev("Math.max(3.5, 1)"))
639
- assertEquals(12.35, ev("Math.round(x * 100) / 100", mapOf("x" to 12.3456)))
640
- assertEquals(Double.NEGATIVE_INFINITY, ev("Math.max()"))
641
- assertEquals(Double.POSITIVE_INFINITY, ev("Math.min()"))
642
- assertTrue((ev("Math.max(1, 'abc', 3)") as Double).isNaN())
643
- assertTrue((ev("Math.min(1, n)", mapOf("n" to Double.NaN)) as Double).isNaN())
644
- assertTrue((ev("Math.round('abc')") as Double).isNaN())
645
- assertTrue((ev("Math.floor()") as Double).isNaN()) // omitted argument is undefined
646
- assertEquals(0L, ev("Math.round(0.49999999999999994)"))
647
- assertEquals(-2L, ev("Math.round(-2.5)"))
648
- assertEquals(-3L, ev("Math.round(-2.6)"))
649
- assertEquals(0L, ev("Math.round(null)"))
650
- assertEquals(12L, ev("Number('12')"))
651
- assertEquals(12.5, ev("Number('12.5')"))
652
- assertEquals(0L, ev("Number('')"))
653
- assertEquals(1L, ev("Number(true)"))
654
- assertEquals(5L, ev("Number(5.0)"))
655
- assertTrue((ev("Number('abc')") as Double).isNaN())
656
- assertTrue((ev("Number('12px')") as Double).isNaN())
657
- assertTrue((ev("Number(o)", mapOf("o" to mapOf("a" to 1L))) as Double).isNaN())
658
- assertEquals(0L, ev("Number(missing)")) // missing is null -> 0
659
- assertEquals(0L, ev("Number()"))
660
- assertEquals(255L, ev("Number('0xff')"))
661
- assertEquals(5L, ev("Number([5])"))
662
- assertEquals(0L, ev("Number(' ')"))
663
- assertEquals("5", ev("String(5)"))
664
- assertEquals("2.5", ev("String(2.5)"))
665
- assertEquals("true", ev("String(true)"))
666
- assertEquals("1,2", ev("String([1, 2])"))
667
- assertEquals("null", ev("String(null)"))
668
- assertEquals("", ev("String()"))
669
- assertEquals("NaN", ev("String(0 / 0)"))
670
- assertEquals("[object Object]", ev("String(savedBill)"))
671
- assertEquals(false, ev("Boolean('')"))
672
- assertEquals(true, ev("Boolean('a')"))
673
- assertEquals(false, ev("Boolean(0)"))
674
- assertEquals(true, ev("Boolean(1)"))
675
- assertEquals(true, ev("Boolean([])"))
676
- assertEquals(false, ev("Boolean(missing)"))
677
- assertEquals(false, ev("Boolean()"))
678
- assertEquals(42L, ev("parseInt(' 42 ')"))
679
- assertEquals(42L, ev("parseInt(42)"))
680
- assertEquals(-7L, ev("parseInt('-7')"))
681
- assertTrue((ev("parseInt('abc')") as Double).isNaN())
682
- assertEquals(3.5, ev("parseFloat('3.5')"))
683
- assertEquals(3.5, ev("parseFloat(' 3.5 ')"))
684
- assertEquals(3L, ev("parseFloat('3')"))
685
- assertTrue((ev("parseFloat('abc')") as Double).isNaN())
686
- assertTrue((ev("parseFloat(missing)") as Double).isNaN()) // parses "null"
687
- assertTrue((ev("parseInt()") as Double).isNaN())
688
- }
689
-
690
- @Test fun parseIntAndParseFloatMatchJavaScript() {
691
- // expected values produced by node v20
692
- val ints = listOf(
693
- "parseInt('42px')" to 42L, "parseInt(' 3.7 ')" to 3L, "parseInt('0x1F')" to 31L, "parseInt('-12')" to -12L,
694
- "parseInt(' -0x10')" to -16L, "parseInt('ff', 16)" to 255L, "parseInt('0xff', 16)" to 255L, "parseInt('11', 2)" to 3L,
695
- "parseInt('z', 36)" to 35L, "parseInt('1e21')" to 1L, "parseInt(1000000000000000000000)" to 1L, "parseInt('123456789012345678901234567890')" to 1.2345678901234568E29,
696
- "parseInt('\u00a042')" to 42L, "parseInt('-0')" to 0L, "parseInt('12', 0)" to 12L, "parseInt('0x10', 10)" to 0L,
697
- )
698
- for ((e, want) in ints) assertEquals(e, want, ev(e))
699
- for (e in listOf("parseInt('abc')", "parseInt('12', 1)", "parseInt('12', 37)", "parseInt('')", "parseInt('-')", "parseInt('0x')", "parseInt(null)")) {
700
- assertTrue(e, (ev(e) as Double).isNaN())
701
- }
702
- val floats = listOf(
703
- "parseFloat('3.5kg')" to 3.5, "parseFloat(' 3.7 ')" to 3.7, "parseFloat('-.5e3x')" to -500L, "parseFloat('1e')" to 1L,
704
- "parseFloat('1.')" to 1L, "parseFloat('Infinityx')" to Double.POSITIVE_INFINITY, "parseFloat('-Infinity')" to Double.NEGATIVE_INFINITY,
705
- "parseFloat('+1.5')" to 1.5, "parseFloat(2.5)" to 2.5, "parseFloat('0x1F')" to 0L,
706
- )
707
- for ((e, want) in floats) assertEquals(e, want, ev(e))
708
- for (e in listOf("parseFloat('abc')", "parseFloat('.')", "parseFloat('')")) assertTrue(e, (ev(e) as Double).isNaN())
709
- }
710
-
711
- @Test fun unknownGlobalsAreNull() {
712
- assertNull(ev("foo(1)"))
713
- assertNull(ev("Date"))
714
- assertNull(ev("Date.now()"))
715
- assertNull(ev("JSON.stringify(x)", mapOf("x" to 1L)))
716
- assertNull(ev("Math.pow(2, 3)"))
717
- assertNull(ev("Math.PI"))
718
- assertNull(ev("Math.sqrt(4)"))
719
- assertNull(ev("Number.isInteger(5)"))
720
- assertNull(ev("Object.keys(savedBill)"))
721
- assertNull(ev("Array.isArray(products)"))
722
- assertTrue(ev("Math") is Map<*, *>)
723
- // a state/data/local value with a global's name wins over the global
724
- assertEquals("mine", ev("Math", mapOf("Math" to "mine")))
725
- assertEquals(5L, ev("parseInt", mapOf("parseInt" to 5L)))
726
- }
727
-
728
- @Test fun strAndTruthyHelpers() {
729
- assertEquals("5", str(5.0))
730
- assertEquals("5.5", str(5.5))
731
- assertEquals("-5", str(-5.0))
732
- assertEquals("0", str(-0.0))
733
- assertEquals("7", str(7L))
734
- assertEquals("", str(null))
735
- assertEquals("true", str(true))
736
- assertEquals("false", str(false))
737
- assertEquals("abc", str("abc"))
738
- assertEquals("1,,a,2", str(listOf(1L, null, "a", 2.0)))
739
- assertEquals("1,2,3", str(listOf(listOf(1L, 2L), 3L)))
740
- assertEquals("", str(emptyList<Any?>()))
741
- assertEquals("Infinity", str(Double.POSITIVE_INFINITY))
742
- assertEquals("NaN", str(Double.NaN))
743
- assertEquals("{a=1}", str(mapOf("a" to 1L))) // display keeps a readable map; JS ToString is "[object Object]"
744
- assertEquals("[object Object]", jsString(mapOf("a" to 1L)))
745
- assertEquals("null", jsString(null))
746
- assertEquals("-Infinity", str(Double.NEGATIVE_INFINITY))
747
- assertFalse(truthy(0.0))
748
- assertFalse(truthy(-0.0))
749
- assertFalse(truthy(Double.NaN))
750
- assertTrue(truthy(0.5))
751
- assertTrue(truthy(Double.POSITIVE_INFINITY))
752
- assertFalse(truthy(null))
753
- assertFalse(truthy(false))
754
- assertTrue(truthy(true))
755
- assertFalse(truthy(0L))
756
- assertTrue(truthy(-1L))
757
- assertFalse(truthy(""))
758
- assertTrue(truthy("0")) // like JS
759
- assertTrue(truthy("false"))
760
- assertTrue(truthy(emptyList<Any?>())) // empty list is truthy, like JS
761
- assertTrue(truthy(emptyMap<String, Any?>()))
762
- assertTrue(truthy(mapOf("a" to null)))
763
- }
764
-
765
- @Test fun toPlainConvertsJsonToKotlinValues() {
766
- val json = """{"i":1,"neg":-5,"big":12345678901234,"d":1.5,"whole":1.0,"t":true,"f":false,"n":null,""" +
767
- """"s":"x","sNum":"123","sBool":"true","l":[1,"two",null,[3]],"o":{"z":1,"a":{"deep":false}},"emptyL":[],"emptyO":{}}"""
768
- val plain = Json.parseToJsonElement(json).toPlain() as Map<*, *>
769
- assertEquals(listOf("i", "neg", "big", "d", "whole", "t", "f", "n", "s", "sNum", "sBool", "l", "o", "emptyL", "emptyO"), plain.keys.toList())
770
- assertEquals(1L, plain["i"]); assertTrue(plain["i"] is Long)
771
- assertEquals(-5L, plain["neg"])
772
- assertEquals(12345678901234L, plain["big"])
773
- assertEquals(1.5, plain["d"])
774
- assertEquals(1.0, plain["whole"]); assertTrue(plain["whole"] is Double)
775
- assertEquals(true, plain["t"])
776
- assertEquals(false, plain["f"])
777
- assertTrue(plain.containsKey("n")); assertNull(plain["n"])
778
- assertEquals("x", plain["s"])
779
- assertEquals("123", plain["sNum"]) // quoted values stay strings
780
- assertEquals("true", plain["sBool"])
781
- assertEquals(listOf(1L, "two", null, listOf(3L)), plain["l"])
782
- val o = plain["o"] as Map<*, *>
783
- assertEquals(listOf("z", "a"), o.keys.toList()) // insertion order, not sorted
784
- assertEquals(mapOf("deep" to false), o["a"])
785
- assertEquals(emptyList<Any?>(), plain["emptyL"])
786
- assertEquals(emptyMap<String, Any?>(), plain["emptyO"])
787
- // beyond Long range / exponent form fall back to Double
788
- assertEquals(1.0E20, Json.parseToJsonElement("99999999999999999999").toPlain())
789
- assertEquals(1000.0, Json.parseToJsonElement("1e3").toPlain())
790
- assertNull(Json.parseToJsonElement("null").toPlain())
791
- assertEquals(listOf(1L, 2L), Json.parseToJsonElement("[1,2]").toPlain())
792
- // the result is usable by the evaluator
793
- val sc = SduiScope(plain.entries.associate { it.key as String to it.value }, emptyMap())
794
- assertEquals("deep-ok", evalExpr("(o.a.deep ? 'x' : 'deep-ok')", sc))
795
- assertEquals(3L, evalExpr("l[3][0]", sc))
796
- }
797
-
798
- @Test fun arrowsWithTwoParamsShadowingAndOuterScope() {
799
- assertEquals(listOf(10L, 21L, 32L), ev("products.map((p, i) => p.n * 10 + i)"))
800
- assertEquals(listOf(1L, 3L), ev("[1, 2, 3, 4].filter((x, i) => i % 2 == 0)"))
801
- assertEquals(listOf("a", "a"), ev("[1, 2].map(() => 'a')"))
802
- assertEquals(listOf("small", "big"), ev("[1, 2].map(x => x > 1 ? 'big' : 'small')"))
803
- // a param shadows the outer name; the outer value is untouched
804
- val loc = mapOf("x" to 100L)
805
- assertEquals(listOf(2L, 3L), ev("[1, 2].map(x => x + 1)", loc))
806
- assertEquals(100L, ev("x", loc))
807
- assertEquals(listOf(null), ev("[null].map(x => x)", loc)) // a null param still masks the outer x
808
- assertEquals(listOf(3L), ev("[1].map(page => page + 2)")) // shadows state.page (bare name)
809
- assertEquals(1L, ev("page"))
810
- // arrows read locals, state and data of the surrounding scope
811
- assertEquals(listOf(3L, 6L), ev("[1, 2].map(n => n * factor)", mapOf("factor" to 3L)))
812
- assertEquals(listOf(2L, 3L), ev("[1, 2].map(n => n + page)"))
813
- assertEquals(listOf(false, true), ev("categories.map(c => c.id == category)"))
814
- assertEquals(listOf(0L, 2L), ev("categories.map(c => products.filter(p => p.categoryId == c.id).length)")) // nested arrows
815
- assertNull(ev("[1].find((a, b) => b == null)")) // find passes (item, index, array) like map
816
- assertEquals(listOf(listOf(7L)), ev("[7].map((a, b, arr) => arr)"))
817
- assertEquals(listOf(0L), ev("[7].map((a, b) => b)")) // map passes (item, index)
818
- assertEquals(6L, ev("(x) * 2", mapOf("x" to 3L))) // parenthesised id is not an arrow
819
- assertEquals("shadow", ev("[1].map(i => i).length == 1 ? 'shadow' : 'no'"))
820
- }
821
-
822
- @Test fun optionalChainingAndArrayLiterals() {
823
- // `?.` is tokenized and parsed as a null-safe member / index / call
824
- assertNull(ev("a?.b"))
825
- assertEquals("Hóa đơn\nđã lưu", ev("savedBill?.name"))
826
- assertEquals("i.png", ev("savedBill?.icon"))
827
- assertNull(ev("missing?.b?.c"))
828
- assertNull(ev("a?.b.c", mapOf("a" to mapOf("b" to null))))
829
- assertEquals("Xe máy", ev("categories?.[0]?.name"))
830
- assertEquals(3L, ev("products?.length"))
831
- assertEquals(listOf(1L, 2L), ev("[1, 2]?.slice()"))
832
- assertNull(ev("missing?.toUpperCase()"))
833
- assertEquals("ABC", ev("'abc'?.toUpperCase()"))
834
- assertEquals("x", ev("missing?.b ?? 'x'"))
835
- assertEquals(0.5, ev("c ?.5 : 1", mapOf("c" to true))) // `?.` before a digit is `?` + `.5`
836
- assertEquals(1L, ev("c?.5:1", mapOf("c" to false)))
837
- assertEquals(0.5, ev("c ? .5 : 1", mapOf("c" to true)))
838
- assertEquals("y", ev("c?'y':'n'", mapOf("c" to true)))
839
- // array literals
840
- assertEquals(listOf(1L, 2L, 3L), ev("[1, 2, 3]"))
841
- assertEquals(emptyList<Any?>(), ev("[]"))
842
- assertEquals(listOf(1L, "x", 2L, "car"), ev("[1, 'x', 1 + 1, category]"))
843
- assertEquals(listOf(listOf(1L), listOf(2L)), ev("[[1], [2]]"))
844
- assertEquals(3L, ev("[1, 2, 3].length"))
845
- assertEquals(2L, ev("[1, 2, 3][1]"))
846
- assertEquals(listOf("car", "bike"), ev("['car', 'bike']"))
847
- assertEquals(true, ev("['car', 'bike'].includes(category)"))
848
- assertEquals(listOf(null, 1L), ev("[missing, 1]"))
849
- // trailing commas are not supported (null)
850
- assertNull(ev("[1, 2,]"))
851
- }
852
-
853
- @Test fun interpolationWithSeveralBindingsAndValueTypes() {
854
- val sc = scope(mapOf(
855
- "c" to mapOf("name" to "Xe máy"), "n" to 3L, "d" to 2.0, "h" to 2.5, "flag" to true, "no" to false,
856
- "zero" to 0L, "items" to listOf(1L, 2L), "empty" to "",
857
- ))
858
- assertEquals("Xe máy - 3", resolveString("{c.name} - {n}", sc))
859
- assertEquals("a Xe máy b 3 c car", resolveString("a {c.name} b {n} c {category}", sc))
860
- assertEquals("Có 3 mục: 1,2", resolveString("Có {n} mục: {items}", sc))
861
- assertEquals("x true y false", resolveString("x {flag} y {no}", sc))
862
- assertEquals("x 0 y 2 z 2.5", resolveString("x {zero} y {d} z {h}", sc)) // 2.0 prints without ".0"
863
- assertEquals("[]", resolveString("[{empty}]", sc))
864
- assertEquals("3 mục", resolveString("{n} {n > 1 ? 'mục' : 'mục'}", sc))
865
- assertEquals("Tổng: 5", resolveString("Tổng: {n + 2}", sc))
866
- assertEquals("Giá: 3.50 đ", resolveString("Giá: {(n + 0.5).toFixed(2)} đ", sc))
867
- assertEquals("ab", resolveString("{empty}a{empty}b", sc))
868
- assertEquals("1 và ", resolveString("{page} và {missing}", sc))
869
- assertEquals("x y", resolveString("x {a b} y", sc)) // broken expr -> ""
870
- assertEquals("unterminated {n", resolveString("unterminated {n", sc))
871
- assertEquals("no braces } here", resolveString("no braces } here", sc))
872
- assertEquals("a b", resolveString("a {} b", sc))
873
- // whole-value bindings keep their type
874
- assertEquals(3L, resolveString("{n}", sc))
875
- assertEquals(listOf(1L, 2L), resolveString("{items}", sc))
876
- assertEquals(true, resolveString("{flag}", sc))
877
- assertEquals(true, resolveString(" {flag} ", sc)) // surrounding whitespace is trimmed for a whole binding
878
- assertNull(resolveString("{missing}", sc))
879
- assertNull(resolveString("{}", sc))
880
- }
881
-
882
- @Test fun nestedBracesAreNotAWholeBinding() {
883
- val sc = scope(mapOf("a" to "V"))
884
- assertNull(unwrapBinding("{{a}}"))
885
- assertNull(unwrapBinding("{a{b}}"))
886
- // the nested form is not a binding, but the inner `{a}` is still interpolated: "{{a}}" -> "{V}"
887
- assertEquals("{V}", resolveString("{{a}}", sc))
888
- assertEquals("x{V}y", resolveString("x{{a}}y", sc))
889
- // a whole string that merely looks like `{ ... }` is treated as a binding; non-expression text becomes null
890
- assertNull(resolveString("{ a: 1 }", sc))
891
- }
892
-
893
- @Test fun numbersPrintLikeJavaScript() {
894
- // expected strings produced by node v20 (`String(v)`)
895
- val cases = listOf(
896
- 1e21 to "1e+21", 1e-7 to "1e-7", 1e-6 to "0.000001", 123e-20 to "1.23e-18", 0.1 + 0.2 to "0.30000000000000004",
897
- 1.0 / 3 to "0.3333333333333333", 12345678.9 to "12345678.9", 9007199254740992.0 to "9007199254740992",
898
- 9.223372036854776E18 to "9223372036854776000", -1.5e-9 to "-1.5e-9", 100.0 to "100", 1.5e300 to "1.5e+300",
899
- 1e100 to "1e+100", 123456789012345680000.0 to "123456789012345680000", -0.0 to "0", 2.5 to "2.5",
900
- )
901
- for ((v, want) in cases) assertEquals(want, jsString(v))
902
- // shortest round-trip digits even where JDK 17's Double.toString is longer
903
- assertEquals("23123342411285750", jsString(23123342411285750.0))
904
- assertEquals("2595703589374552000", jsString(2595703589374552000.0))
905
- assertEquals("5e-324", jsString(5e-324))
906
- assertEquals("1e+21", jsString(999999999999999999999.0))
907
- assertEquals("1e+21x", resolveString("{n}x", scope(mapOf("n" to 1e21))))
908
- }
909
-
910
- // ---- derived data keys --------------------------------------------------------------------------------------
911
-
912
- @Test fun derivedValueFollowsStateChanges() {
913
- val st = mutableMapOf<String, Any?>("qty" to 1L)
914
- val sc = SduiScope(mapOf("price" to 10L, "total" to "{state.qty * price}", "label" to "{'Tổng ' + total}"), st)
915
- assertEquals(10L, sc.lookup("total"))
916
- assertEquals("Tổng 10", evalExpr("label", sc))
917
- st["qty"] = 3L
918
- assertEquals(30L, sc.lookup("total"))
919
- assertEquals(30L, evalExpr("data.total", sc))
920
- assertEquals("Tổng 30", resolveString("{label}", sc))
921
- assertEquals("= 30", resolveString("= {total}", sc))
922
- }
923
-
924
- @Test fun readingADerivedValueReadsTheUnderlyingState() {
925
- val st = mutableStateMapOf<String, Any?>("qty" to 1L)
926
- val sc = SduiScope(mapOf("price" to 10L, "total" to "{qty * price}"), st)
927
- val reads = ArrayList<Any>()
928
- Snapshot.observe(readObserver = { reads += it }) { assertEquals(10L, evalExpr("total", sc)) }
929
- assertTrue(reads.isNotEmpty()) // Compose recomposes the reader when qty changes
930
- st["qty"] = 2L
931
- assertEquals(20L, evalExpr("total", sc))
932
- }
933
-
934
- @Test fun derivedValueInRepeatCopiesSeesEachItem() {
935
- val base = SduiScope(mapOf("title" to "{item.name + ' #' + i}", "items" to listOf(mapOf("name" to "A"), mapOf("name" to "B"))), emptyMap())
936
- val got = (base.lookup("items") as List<*>).mapIndexed { i, it -> resolveString("{title}", base.with("item", it).with("i", i.toLong())) }
937
- assertEquals(listOf("A #0", "B #1"), got)
938
- assertEquals("null #null", base.lookup("title")) // outside the repeat the locals are missing (null)
939
- }
940
-
941
- @Test fun derivedValueIsEvaluatedOncePerResolution() {
942
- var calls = 0
943
- val counter: (List<Any?>) -> Any? = { calls++; 2L }
944
- val sc = SduiScope(mapOf("d" to "{f()}"), mapOf("f" to counter))
945
- assertEquals(6L, evalExpr("d + d + d", sc))
946
- assertEquals(1, calls)
947
- assertEquals(2L, evalExpr("d", sc)) // a new resolution evaluates again
948
- assertEquals(2, calls)
949
- }
950
-
951
- @Test fun dataViewEvaluatesDerivedKeysAndStillWorksAsAMap() {
952
- val sc = SduiScope(mapOf("a" to 1L, "b" to "{a + 1}", "fmt" to "{x => x + '!'}"), emptyMap())
953
- assertEquals(2L, evalExpr("data.b", sc))
954
- assertEquals(2L, evalExpr("data['b']", sc))
955
- assertEquals("ok!", evalExpr("data.fmt('ok')", sc))
956
- assertNull(evalExpr("data.nope", sc))
957
- val whole = evalExpr("data", sc) as Map<*, *>
958
- assertEquals(3, whole.size)
959
- assertEquals(2L, whole["b"])
960
- assertEquals(mapOf("a" to 1L, "b" to 2L), whole.filterKeys { it != "fmt" })
961
- assertEquals(true, evalExpr("data == data", sc))
962
- assertEquals(true, evalExpr("f(data)", SduiScope(mapOf("b" to "{1 + 1}"), mapOf("f" to { a: List<Any?> -> (a[0] as Map<*, *>)["b"] == 2L }))))
963
- }
964
-
965
- @Test fun derivedCyclesReadNullWithoutLooping() {
966
- val sc = SduiScope(mapOf("a" to "{b}", "b" to "{a}", "c" to "{c + 1}", "d" to "{a ?? 5}"), emptyMap())
967
- assertNull(sc.lookup("a"))
968
- assertNull(evalExpr("data.b", sc))
969
- assertEquals(1L, sc.lookup("c")) // the self reference reads null -> 0
970
- assertEquals(5L, sc.lookup("d"))
971
- assertNull(sc.lookup("a")) // nothing left marked as "evaluating"
972
- }
973
-
974
- @Test fun aFailingDerivedKeyIsLoggedAndFailsEveryRead() {
975
- val lines = ArrayList<String>()
976
- val sc = SduiScope(mapOf("bad" to "{x.(}", "uses" to "{bad ?? 'fallback'}"), emptyMap(), log = capturingLog(lines))
977
- repeat(3) { assertNull(evalExpr("bad", sc)) }
978
- assertEquals("fallback", evalExpr("uses", sc))
979
- assertEquals(listOf("expr failed in data.bad"), lines.map { it.substringAfter(": ") }.distinct())
980
- }
981
-
982
- @Test fun runawayRecursionFailsTheExpressionInsteadOfTheStack() {
983
- assertNull(ev("(g => g(g))(g => g(g))"))
984
- assertNull(evalExpr("f(1)", SduiScope(mapOf("f" to "{n => f(n)}"), emptyMap())))
985
- assertNull(ev("(".repeat(5000) + "1" + ")".repeat(5000)))
986
- assertNull(ev("!".repeat(5000) + "1"))
987
- assertEquals(1L, ev("(".repeat(50) + "1" + ")".repeat(50)))
988
- // printing `data` does not evaluate derived keys (one holding `data` would print itself forever)
989
- val sc = SduiScope(mapOf("x" to "{[data]}"), emptyMap())
990
- assertEquals("{x={[data]}}", str(evalExpr("data", sc)))
991
- }
992
-
993
- /** Runs [block] on a thread with a small stack (like a native one) and rethrows whatever it threw. */
994
- private fun <T> onSmallStack(block: () -> T): T {
995
- var result: Result<T>? = null
996
- val t = Thread(null, { result = runCatching(block) }, "small-stack", 256 * 1024)
997
- t.start(); t.join()
998
- return result!!.getOrThrow()
999
- }
1000
-
1001
- @Test fun nestingBudgetIsSharedAcrossChainedDerivedKeys() {
1002
- // 20 derived keys, each 60 levels deep and reading the previous one: 1200 levels in total, past the budget of 200
1003
- fun deep(inner: String, levels: Int = 60) = "{" + "-(".repeat(levels) + inner + ")".repeat(levels) + "}"
1004
- val d = LinkedHashMap<String, Any?>()
1005
- d["k0"] = deep("1")
1006
- for (i in 1 until 20) d["k$i"] = deep("k${i - 1}")
1007
- val lines = ArrayList<String>()
1008
- val sc = SduiScope(d, emptyMap(), log = capturingLog(lines))
1009
- val started = System.nanoTime()
1010
- assertNull(onSmallStack { evalExpr("k19", sc) })
1011
- assertTrue((System.nanoTime() - started) < 5_000_000_000L)
1012
- assertTrue(lines.any { it.endsWith("expr failed: k19") })
1013
- assertEquals(0, sc.cx.depth) // the budget is fully released afterwards
1014
- // one 60-level key fits (each level is 2 parse levels and 1 eval level); a short chain too: 3 keys x 20 levels.
1015
- // An even number of minus signs per key keeps the sign
1016
- assertEquals(1L, onSmallStack { evalExpr("k0", SduiScope(d, emptyMap())) })
1017
- val ok = LinkedHashMap<String, Any?>().apply { put("k0", deep("1", 20)); put("k1", deep("k0", 20)); put("k2", deep("k1", 20)) }
1018
- assertEquals(1L, onSmallStack { evalExpr("k2", SduiScope(ok, emptyMap())) })
1019
- // arrow calls share it too
1020
- assertNull(onSmallStack { evalExpr("f(1)", SduiScope(mapOf("f" to "{n => f(n)}"), emptyMap())) })
1021
- }
1022
-
1023
- @Test fun parsedExpressionsAreCachedPerScopeTree() {
1024
- val sc = SduiScope(mapOf("a" to 1L), emptyMap())
1025
- assertEquals(2L, evalExpr("a + 1", sc))
1026
- assertEquals(2L, evalExpr("a + 1", sc))
1027
- assertEquals(2L, evalExpr("a + 1", sc.with("x", 1L))) // with() copies share the cache
1028
- assertEquals(1, sc.cx.parses)
1029
- assertEquals(3L, evalExpr("a + 2", sc))
1030
- assertEquals(2, sc.cx.parses)
1031
- // bounded LRU: after 512 other expressions, "a + 1" was evicted ("a + 2" was used last before them, also evicted)
1032
- for (i in 0 until 512) evalExpr("a + $i * 0", sc)
1033
- val before = sc.cx.parses
1034
- evalExpr("a + 1", sc)
1035
- assertEquals(before + 1, sc.cx.parses)
1036
- evalExpr("a + 511 * 0", sc) // still cached
1037
- assertEquals(before + 1, sc.cx.parses)
1038
- // a failed parse is not cached and keeps failing
1039
- assertNull(evalExpr("a +", sc)); assertNull(evalExpr("a +", sc))
1040
- }
1041
-
1042
- @Test fun jsLiteralSyntax() {
1043
- // exponents
1044
- assertEquals(1e21, ev("1e21"))
1045
- assertEquals("1e+21", ev("'' + 1e21"))
1046
- assertEquals("1.5e-7", ev("'' + 1.5e-7"))
1047
- assertEquals(2000L, ev("2e3"))
1048
- assertEquals(2000L, ev("2E+3"))
1049
- assertEquals(5L, ev(".5e1"))
1050
- assertEquals(0.025, ev("2.5e-2"))
1051
- // escapes in string literals
1052
- assertEquals("it's", ev("""'it\'s'"""))
1053
- assertEquals("a\"b", ev(""""a\"b""""))
1054
- assertEquals("a\nb", ev("""'a\nb'"""))
1055
- assertEquals("\\", ev("""'\\'"""))
1056
- assertEquals(1L, ev("""'\\'.length"""))
1057
- assertEquals("AB\t", ev("""'\x41B\t'"""))
1058
- assertEquals("q", ev("""'\q'"""))
1059
- assertNull(ev("'unterminated"))
1060
- assertNull(ev("""'bad \x4'"""))
1061
- // unary plus is ToNumber
1062
- assertEquals(4L, ev("+'3' + 1"))
1063
- assertEquals(0L, ev("+''"))
1064
- assertEquals(1L, ev("+true"))
1065
- assertEquals(0L, ev("+null"))
1066
- assertEquals(0L, ev("+[]"))
1067
- assertEquals(-2L, ev("-+'2'"))
1068
- assertTrue((ev("+'x'") as Double).isNaN())
1069
- // NaN / Infinity / undefined
1070
- assertTrue((ev("NaN") as Double).isNaN())
1071
- assertEquals(false, ev("NaN === NaN"))
1072
- assertEquals("NaN", ev("'' + NaN"))
1073
- assertEquals(Double.POSITIVE_INFINITY, ev("Infinity"))
1074
- assertEquals(Double.NEGATIVE_INFINITY, ev("-Infinity"))
1075
- assertEquals(true, ev("1 / 0 === Infinity"))
1076
- assertEquals("-Infinity", ev("'' + -Infinity"))
1077
- assertNull(ev("undefined"))
1078
- assertEquals(1L, ev("undefined ?? 1"))
1079
- }
1080
-
1081
- @Test fun onlyCanonicalIndexStringsAddressElements() {
1082
- assertEquals("b", ev("l['1']", mapOf("l" to listOf("a", "b"))))
1083
- assertNull(ev("l['01']", mapOf("l" to listOf("a", "b"))))
1084
- assertNull(ev("l['+1']", mapOf("l" to listOf("a", "b"))))
1085
- assertNull(ev("s['01']", mapOf("s" to "ab")))
1086
- }
1087
-
1088
- // ---- Direct conversion tables: the internal helpers, asserted against real JavaScript results ----------------------
1089
- // The engine has one nullish value (null stands for undefined too); `undefined` rows below use null.
1090
-
1091
- private fun num(expected: Double, actual: Double, msg: String = "") {
1092
- assertEquals(msg, expected, actual, 0.0)
1093
- if (expected == 0.0) assertEquals("$msg sign of zero", 1 / expected, 1 / actual, 0.0)
1094
- }
1095
-
1096
- private val sameList = listOf(1L)
1097
- private val sameMap = mapOf("a" to 1L)
1098
-
1099
- @Test fun tblLooseEqualsPrimitives() {
1100
- val yes = listOf<Pair<Any?, Any?>>(
1101
- "" to 0L, "0" to 0L, "0" to false, "" to false, "1" to 1L, "1" to true, true to 1L, true to 1.0, false to 0L,
1102
- " 12 " to 12L, "1e3" to 1000L, "0x10" to 16L, 1L to 1.0, 0L to -0.0, "abc" to "abc",
1103
- null to null, true to true, Double.POSITIVE_INFINITY to "Infinity", 1L to 1.0f,
1104
- )
1105
- for ((a, b) in yes) {
1106
- assertTrue("$a == $b", looseEquals(a, b))
1107
- assertTrue("$b == $a", looseEquals(b, a))
1108
- }
1109
- val no = listOf<Pair<Any?, Any?>>(
1110
- null to 0L, null to false, null to "", null to "null", 0L to null, "abc" to Double.NaN, "a" to "b", "1" to "01",
1111
- "0" to "", true to 2L, true to "true", false to "false", "abc" to 0L, Double.NaN to Double.NaN, "NaN" to Double.NaN,
1112
- "1" to 2L, 1L to "1.5",
1113
- )
1114
- for ((a, b) in no) {
1115
- assertFalse("$a == $b", looseEquals(a, b))
1116
- assertFalse("$b == $a", looseEquals(b, a))
1117
- }
1118
- }
1119
-
1120
- @Test fun tblLooseEqualsObjects() {
1121
- assertTrue(looseEquals(sameList, sameList))
1122
- assertFalse(looseEquals(listOf(1L), listOf(1L))) // different references
1123
- assertTrue(looseEquals(emptyList<Any?>(), "")) // [] == ''
1124
- assertTrue(looseEquals(emptyList<Any?>(), 0L)) // [] == 0
1125
- assertTrue(looseEquals(emptyList<Any?>(), false)) // [] == false
1126
- assertTrue(looseEquals(listOf(5L), 5L))
1127
- assertTrue(looseEquals(listOf("5"), 5L))
1128
- assertTrue(looseEquals(listOf(1L, 2L), "1,2"))
1129
- assertFalse(looseEquals(listOf(1L, 2L), 1L))
1130
- assertFalse(looseEquals(emptyList<Any?>(), null))
1131
- assertTrue(looseEquals(sameMap, sameMap))
1132
- assertFalse(looseEquals(mapOf("a" to 1L), mapOf("a" to 1L)))
1133
- assertTrue(looseEquals(sameMap, "[object Object]"))
1134
- assertFalse(looseEquals(sameMap, 0L)) // NaN
1135
- assertFalse(looseEquals(sameMap, true)) // {} == true -> NaN == 1
1136
- }
1137
-
1138
- @Test fun tblStrictEquals() {
1139
- assertTrue(strictEquals(1L, 1.0)) // one number type
1140
- assertTrue(strictEquals(1.0, 1L))
1141
- assertTrue(strictEquals(0L, -0.0))
1142
- assertTrue(strictEquals(Long.MAX_VALUE, Long.MAX_VALUE))
1143
- assertFalse(strictEquals("1", 1L))
1144
- assertFalse(strictEquals(1L, "1"))
1145
- assertFalse(strictEquals(true, 1L))
1146
- assertFalse(strictEquals("true", true))
1147
- assertTrue(strictEquals(null, null))
1148
- assertFalse(strictEquals(null, 0L))
1149
- assertFalse(strictEquals(0L, null))
1150
- assertFalse(strictEquals(null, ""))
1151
- assertFalse(strictEquals(Double.NaN, Double.NaN))
1152
- assertFalse(strictEquals(Double.NaN, 0L))
1153
- assertTrue(strictEquals(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY))
1154
- assertFalse(strictEquals(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY))
1155
- assertTrue(strictEquals("é", "é"))
1156
- assertTrue(strictEquals(true, true))
1157
- assertFalse(strictEquals(true, false))
1158
- assertTrue(strictEquals(sameList, sameList))
1159
- assertFalse(strictEquals(listOf(1L), listOf(1L)))
1160
- assertFalse(strictEquals(mapOf("a" to 1L), mapOf("a" to 1L)))
1161
- }
1162
-
1163
- @Test fun tblToNumber() {
1164
- val cases = listOf<Pair<Any?, Double>>(
1165
- "" to 0.0, " " to 0.0, " 12 " to 12.0, "1e3" to 1000.0, "1E3" to 1000.0, "1e-3" to 0.001, "0x1f" to 31.0, "0X1F" to 31.0,
1166
- "0o17" to 15.0, "0b101" to 5.0, "+5" to 5.0, "-5" to -5.0, ".5" to 0.5, "5." to 5.0, "+.5e1" to 5.0,
1167
- true to 1.0, false to 0.0, null to 0.0, "Infinity" to Double.POSITIVE_INFINITY, "+Infinity" to Double.POSITIVE_INFINITY,
1168
- "-Infinity" to Double.NEGATIVE_INFINITY, "1e1000" to Double.POSITIVE_INFINITY, "-0" to -0.0, "\n\t 7 " to 7.0,
1169
- 3L to 3.0, 2.5 to 2.5, emptyList<Any?>() to 0.0, listOf("5") to 5.0, listOf(5L) to 5.0, listOf(" ") to 0.0,
1170
- )
1171
- for ((v, want) in cases) num(want, toNumber(v), "toNumber($v)")
1172
- val nan = listOf<Any?>(
1173
- "12px", "abc", "1 2", "1_000", "-0x1f", "0x", "0xg", "0b102", "0o8", "e3", ".", "+", "--1", "1e", "infinity", "Infinit",
1174
- "NaN", "1,5", listOf(1L, 2L), mapOf("a" to 1L), listOf("a"),
1175
- )
1176
- for (v in nan) assertTrue("toNumber($v)", toNumber(v).isNaN())
1177
- }
1178
-
1179
- @Test fun tblNumberToString() {
1180
- val cases = listOf(
1181
- 1.0 to "1", -1.0 to "-1", 0.0 to "0", -0.0 to "0", 0.5 to "0.5", 100.0 to "100", 123.456 to "123.456",
1182
- 0.1 + 0.2 to "0.30000000000000004", 0.1 * 3 to "0.30000000000000004", 1.0 / 3 to "0.3333333333333333", 2.0 / 3 to "0.6666666666666666",
1183
- 1e21 to "1e+21", 1e20 to "100000000000000000000", 123456789012345680000.0 to "123456789012345680000", 1.5e21 to "1.5e+21",
1184
- -1e21 to "-1e+21", 1e-6 to "0.000001", 1.5e-6 to "0.0000015", 1e-7 to "1e-7", 1.5e-7 to "1.5e-7", -1e-7 to "-1e-7",
1185
- 9007199254740992.0 to "9007199254740992", 9007199254740993.0 to "9007199254740992", 4503599627370495.5 to "4503599627370495.5",
1186
- Double.NaN to "NaN", Double.POSITIVE_INFINITY to "Infinity", Double.NEGATIVE_INFINITY to "-Infinity",
1187
- 1.7976931348623157e308 to "1.7976931348623157e+308", 5e-324 to "5e-324", 2.2250738585072014E-308 to "2.2250738585072014e-308",
1188
- 0.000123 to "0.000123", 1234567.891 to "1234567.891", 4.35 to "4.35", 1.005 to "1.005", 5e-7 to "5e-7", 123e18 to "123000000000000000000",
1189
- )
1190
- for ((d, want) in cases) assertEquals("numberToString($d)", want, numberToString(d))
1191
- // Long values print through jsString in plain decimal
1192
- assertEquals("9007199254740991", jsString(9007199254740991L))
1193
- assertEquals("-9007199254740991", jsString(-9007199254740991L))
1194
- assertEquals("0", jsString(0L))
1195
- assertEquals("9223372036854775807", jsString(Long.MAX_VALUE))
1196
- assertEquals("1e+21", jsString(1e21))
1197
- assertEquals("3", jsString(3.0))
1198
- assertEquals("1.5", jsString(1.5f))
1199
- }
1200
-
1201
- @Test fun tblJsString() {
1202
- assertEquals("null", jsString(null))
1203
- assertEquals("true", jsString(true))
1204
- assertEquals("1,2,3", jsString(listOf(1L, 2L, 3L)))
1205
- assertEquals("1,,3", jsString(listOf(1L, null, 3L)))
1206
- assertEquals("", jsString(emptyList<Any?>()))
1207
- assertEquals("1,2,3", jsString(listOf(listOf(1L, 2L), 3L))) // nested arrays flatten through ToString
1208
- assertEquals("[object Object]", jsString(sameMap))
1209
- assertEquals("", str(null)) // display form, not JS
1210
- assertEquals("{a=1}", str(sameMap))
1211
- }
1212
-
1213
- @Test fun tblJsTrim() {
1214
- assertEquals("x", jsTrim(" \t\n\r\u000b\u000c    

   x  "))
1215
- assertEquals("a b", jsTrim(" a b "))
1216
- assertEquals("", jsTrim("   "))
1217
- assertEquals("​x", jsTrim("​x")) // zero-width space is not whitespace in JS
1218
- assertEquals("x\u0085", jsTrim("x\u0085")) // NEL is not whitespace in JS
1219
- assertEquals("x᠎", jsTrim("x᠎")) // Mongolian vowel separator is not whitespace in JS
1220
- }
1221
-
1222
- @Test fun tblParseInt() {
1223
- val cases = listOf<Triple<Any?, Any?, Double>>(
1224
- Triple("12px", null, 12.0), Triple(" -3.5abc", null, -3.0), Triple("+7", null, 7.0), Triple("0x10", null, 16.0),
1225
- Triple("0X1f", null, 31.0), Triple("-0x10", null, -16.0), Triple("0x10", 16L, 16.0), Triple("0x10", 10L, 0.0),
1226
- Triple("ff", 16L, 255.0), Triple("FF", 16L, 255.0), Triple("z", 36L, 35.0), Triple("10", 2L, 2.0), Triple("102", 2L, 2.0),
1227
- Triple("12", 0L, 12.0), Triple("0b11", null, 0.0), Triple("010", null, 10.0), Triple(" 42 ", null, 42.0),
1228
- Triple("9007199254740993", null, 9007199254740992.0), Triple("1e3", null, 1.0), Triple(42L, null, 42.0),
1229
- Triple(3.9, null, 3.0), Triple("12", "16", 18.0), Triple("12", 16.5, 18.0), Triple("12", 4294967306L, 12.0),
1230
- Triple("0.00000001", null, 0.0), Triple(" 42", null, 42.0), Triple("-0", null, -0.0),
1231
- )
1232
- for ((v, r, want) in cases) num(want, jsParseInt(v, r), "parseInt($v, $r)")
1233
- val nan = listOf<Pair<Any?, Any?>>(
1234
- "" to null, " " to null, "abc" to null, "px12" to null, "-" to null, "0x" to null, "0xg" to null, null to null,
1235
- true to null, "10" to 1L, "10" to 37L, "10" to -1L, "9" to 8L, "." to null, ".5" to null,
1236
- )
1237
- for ((v, r) in nan) assertTrue("parseInt($v, $r)", jsParseInt(v, r).isNaN())
1238
- }
1239
-
1240
- @Test fun tblParseFloat() {
1241
- val cases = listOf<Pair<Any?, Double>>(
1242
- "12px" to 12.0, " -3.5abc" to -3.5, "3.14abc" to 3.14, ".5" to 0.5, "-.5" to -0.5, "5." to 5.0, "1e3x" to 1000.0,
1243
- "1e" to 1.0, "1e+" to 1.0, "1.2.3" to 1.2, "+.5e-1" to 0.05, "0x10" to 0.0, "Infinity" to Double.POSITIVE_INFINITY,
1244
- "-Infinityx" to Double.NEGATIVE_INFINITY, "+Infinity" to Double.POSITIVE_INFINITY, " 7 " to 7.0, "-0" to -0.0,
1245
- "1_000" to 1.0, 4L to 4.0, 2.5 to 2.5, listOf(3L, 4L) to 3.0, "00012" to 12.0, "1e1000" to Double.POSITIVE_INFINITY,
1246
- )
1247
- for ((v, want) in cases) num(want, jsParseFloat(v), "parseFloat($v)")
1248
- val nan = listOf<Any?>("", "abc", "-", ".", "e3", "infinity", "Inf", null, true, "NaN", "+-1", emptyList<Any?>())
1249
- for (v in nan) assertTrue("parseFloat($v)", jsParseFloat(v).isNaN())
1250
- }
1251
-
1252
- @Test fun tblParseThroughExpressions() {
1253
- assertEquals(12L, ev("parseInt('12px')"))
1254
- assertEquals(16L, ev("parseInt('0x10')"))
1255
- assertEquals(255L, ev("parseInt('ff', 16)"))
1256
- assertEquals(-3L, ev("parseInt(' -3.5abc')"))
1257
- assertTrue((ev("parseInt('')") as Double).isNaN())
1258
- assertTrue((ev("parseInt()") as Double).isNaN())
1259
- assertEquals(-3.5, ev("parseFloat(' -3.5abc')"))
1260
- assertEquals(1000L, ev("parseFloat('1e3x')"))
1261
- assertTrue((ev("parseFloat('')") as Double).isNaN())
1262
- assertEquals(Double.NEGATIVE_INFINITY, ev("parseFloat('-Infinity')"))
1263
- }
1264
-
1265
- @Test fun tblTruthy() {
1266
- val falsy = listOf<Any?>(0L, 0.0, -0.0, Double.NaN, "", null, false)
1267
- for (v in falsy) assertFalse("truthy($v)", truthy(v))
1268
- val truthyValues = listOf<Any?>(
1269
- "0", "false", " ", "null", "undefined", "NaN", 1L, -1L, 0.1, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY,
1270
- true, emptyList<Any?>(), emptyMap<String, Any?>(), listOf(null), listOf(0L), mapOf("a" to 0L),
1271
- )
1272
- for (v in truthyValues) assertTrue("truthy($v)", truthy(v))
1273
- // NOTE: differs from JS (0 and NaN are falsy for any numeric type); only Long / Double ever occur in a spec, so a
1274
- // stray Int / Float is treated as an object
1275
- assertTrue(truthy(0))
1276
- assertTrue(truthy(Float.NaN))
1277
- // the same table through expressions
1278
- assertEquals("y", ev("'0' ? 'y' : 'n'"))
1279
- assertEquals("y", ev("[] ? 'y' : 'n'"))
1280
- assertEquals("n", ev("NaN ? 'y' : 'n'"))
1281
- assertEquals(true, ev("!!' '"))
1282
- assertEquals(false, ev("!!0.0"))
1283
- }
1284
-
1285
- @Test fun tblToFixedEdgeCases() {
1286
- assertEquals("-2", toFixed(-1.5, 0)) // ties go away from zero
1287
- assertEquals("2", toFixed(1.5, 0))
1288
- assertEquals("-1", toFixed(-0.5, 0))
1289
- assertEquals("0.00", toFixed(0.004, 2))
1290
- assertEquals("8.35", toFixed(8.345, 2)) // 8.3450000000000006
1291
- assertEquals("10.23", toFixed(10.235, 2)) // 10.2349999999999994
1292
- assertEquals("1.01", toFixed(1.005 + 0.005, 2))
1293
- assertEquals("123.4560000000", toFixed(123.456, 10))
1294
- assertEquals("0.0000010", toFixed(0.000001, 7))
1295
- assertEquals("100000000000000000000.00", toFixed(1e20, 2))
1296
- assertEquals("1e+21", toFixed(1e21, 2))
1297
- assertEquals("-1e+21", toFixed(-1e21, 2))
1298
- assertEquals("0.00", toFixed(5e-324, 2))
1299
- assertEquals("9007199254740992", toFixed(9007199254740992.0, 0))
1300
- assertEquals("-Infinity", toFixed(Double.NEGATIVE_INFINITY, 1))
1301
- assertEquals("0.30000000000000004441", toFixed(0.1 + 0.2, 20))
1302
- assertEquals("2.5", ev("(2.5).toFixed(1)"))
1303
- assertEquals("-2", ev("(-1.5).toFixed(0)"))
1304
- assertEquals("0.30", ev("(0.1 + 0.2).toFixed(2)"))
1305
- }
1306
-
1307
- // ---- Lexer: JS number literal forms and string escapes -------------------------------------------------------
1308
-
1309
- @Test fun lexerTrailingDotAndDotExponent() {
1310
- assertEquals(1000L, ev("1.e3"))
1311
- assertEquals(1000L, ev("1.E3"))
1312
- assertEquals(1000L, ev("1.e+3"))
1313
- assertEquals(0.001, ev("1.e-3"))
1314
- assertEquals(1L, ev("1."))
1315
- assertEquals(3L, ev("1. + 2"))
1316
- assertEquals(6L, ev("2.*3"))
1317
- assertEquals(0L, ev("1.-1"))
1318
- assertEquals(1000L, ev("10.e2"))
1319
- assertEquals(true, ev("1.e3 === 1000"))
1320
- assertEquals(0.005, ev(".5e-2"))
1321
- assertEquals(0.5, ev(".5"))
1322
- assertEquals(listOf(1L, 2L), ev("[1., 2.]"))
1323
- assertEquals(1L, ev("true ? 1. : 2"))
1324
- assertEquals(1L, ev("true?1.:2"))
1325
- assertEquals(1L, ev("(1.)"))
1326
- assertEquals(3L, ev("1.5 + 1.5"))
1327
- assertEquals(1.5, ev("1.5"))
1328
- }
1329
-
1330
- @Test fun lexerNumbersDoNotBreakMemberAccessOrMethods() {
1331
- assertEquals(7L, ev("a.b", mapOf("a" to mapOf("b" to 7L))))
1332
- assertEquals(7L, ev("a.b1.c", mapOf("a" to mapOf("b1" to mapOf("c" to 7L)))))
1333
- assertEquals("x", ev("l.0.k", mapOf("l" to listOf(mapOf("k" to "x")))))
1334
- assertEquals("y", ev("l.1.k.z", mapOf("l" to listOf(mapOf("k" to "x"), mapOf("k" to mapOf("z" to "y"))))))
1335
- assertEquals(2L, ev("l.1", mapOf("l" to listOf(1L, 2L))))
1336
- assertEquals("b", ev("l[1]", mapOf("l" to listOf("a", "b"))))
1337
- assertEquals("1.00", ev("(1).toFixed(2)"))
1338
- assertEquals("1.0", ev("(1.).toFixed(1)"))
1339
- assertEquals("1.0", ev("1..toFixed(1)")) // optional in this engine, but it works as in JS
1340
- assertEquals("1.50", ev("1.5.toFixed(2)"))
1341
- assertEquals("1.50", ev("(1.5).toFixed(2)"))
1342
- assertEquals("1000.0", ev("1.e3.toFixed(1)"))
1343
- // NOTE: differs from JS (SyntaxError: `1.toFixed(2)` is rejected); the engine reads the dot as member access
1344
- assertEquals("1.00", ev("1.toFixed(2)"))
1345
- assertNull(ev("1.e"))
1346
- assertNull(ev("1.x"))
1347
- assertNull(ev("1..2"))
1348
- assertNull(ev("1.e3e3"))
1349
- }
1350
-
1351
- @Test fun lexerReadsOnlyAnIntegerSegmentAfterAMemberDot() {
1352
- val grid = listOf(listOf("a", "b"), listOf(mapOf("x" to "c"), "d"))
1353
- assertEquals("b", ev("l.0.1", mapOf("l" to grid)))
1354
- assertEquals("c", ev("l.1.0.x", mapOf("l" to grid)))
1355
- val wide = listOf((0..12).map { "v$it" })
1356
- assertEquals("v10", ev("l.0.10", mapOf("l" to wide)))
1357
- assertEquals("v10", ev("l[0][10]", mapOf("l" to wide)))
1358
- assertEquals(mapOf("x" to "c"), ev("l.1.0", mapOf("l" to grid)))
1359
- // numbers outside a member access are unchanged
1360
- assertEquals(1.5, ev("1.5"))
1361
- assertEquals(0.5, ev(".5"))
1362
- assertEquals(1000L, ev("1.e3"))
1363
- assertEquals("1.00", ev("(1).toFixed(2)"))
1364
- assertEquals("x", ev("a.b", mapOf("a" to mapOf("b" to "x"))))
1365
- assertEquals("x", ev("list.0.x", mapOf("list" to listOf(mapOf("x" to "x")))))
1366
- assertEquals(2.25, ev("l.0 + 0.25", mapOf("l" to listOf(2.0))))
1367
- }
1368
-
1369
- // `\u{...}` is not supported: inside a spec it could never be used (the `{` ends the {binding} early), so it is a bad escape
1370
- @Test fun lexerCodePointEscapeIsABadEscape() {
1371
- assertNull(ev("""'\u{1F600}'"""))
1372
- assertNull(ev("""'\u{41}'"""))
1373
- assertNull(ev("""'\u{}'"""))
1374
- // same failure as the other malformed escapes
1375
- assertNull(ev("""'\u004'"""))
1376
- assertNull(ev("""'\u'"""))
1377
- assertNull(ev("""'\x4'"""))
1378
- }
1379
-
1380
- @Test fun lexerFourDigitUnicodeAndHexEscapes() {
1381
- assertEquals("A", ev("""'\u0041'"""))
1382
- assertEquals("é", ev("""'\u00e9'"""))
1383
- assertEquals("é", ev("""'\u00E9'"""))
1384
- assertEquals("AB", ev("""'\u0041\u0042'"""))
1385
- assertEquals(2L, ev("""'\ud83d\ude00'.length""")) // a surrogate pair written as two escapes
1386
- assertEquals("😀", ev("""'\ud83d\ude00'"""))
1387
- assertEquals("A", ev("""'\x41'"""))
1388
- }
1389
-
1390
- @Test fun lexerExistingNumberAndEscapeFormsStillWork() {
1391
- assertEquals("A", ev("""'A'"""))
1392
- assertEquals("é", ev("""'é'"""))
1393
- assertEquals("AB\t", ev("""'\x41B\t'"""))
1394
- assertEquals("a\nb", ev("""'a\nb'"""))
1395
- assertEquals("😀", ev("""'😀'"""))
1396
- assertEquals("u{41}", ev("""'u{41}'""")) // no backslash: literal text
1397
- assertEquals("q", ev("""'\q'"""))
1398
- assertEquals(1000L, ev("1e3"))
1399
- assertEquals(1000L, ev("1E3"))
1400
- assertEquals(1L, ev("1e0"))
1401
- assertEquals(0.5, ev("0.5"))
1402
- assertEquals(0L, ev("0"))
1403
- assertEquals(12L, ev("12"))
1404
- assertEquals(0.025, ev("2.5e-2"))
1405
- assertEquals(5L, ev(".5e1"))
1406
- assertEquals(1.5, ev("1.5"))
1407
- assertEquals(2L, ev("1e"+"0 + 1"))
1408
- assertNull(ev("1e+"))
1409
- }
1410
- }
1411
- // AI-GENERATED END: unit tests for the SDUI expression evaluator