@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.
- package/CLAUDE.md +1 -4
- package/compose/build.gradle.kts +1 -5
- package/compose/compose.podspec +1 -1
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/BottomTabBar.kt +12 -4
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/CurvedContainer.kt +11 -3
- package/gradle/libs.versions.toml +0 -2
- package/gradle.properties +1 -1
- package/ios/Navigation/BottomTab/BottomTabBar.swift +14 -4
- package/ios/native-kits.podspec +1 -1
- package/ios-demo/MoMoUIKitsDemo.podspec +1 -1
- package/ios-demo/Sources/MoMoUIKitsDemo/SampleDemos/BottomTabDemo.swift +16 -3
- package/package.json +1 -1
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiActionsTest.kt +0 -647
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiExprTest.kt +0 -1411
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiHostTest.kt +0 -130
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiKitArgsTest.kt +0 -524
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiKitNodesTest.kt +0 -559
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiRenderPlanTest.kt +0 -741
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiRenderReuseTest.kt +0 -221
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiRendererPropsTest.kt +0 -270
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiStylePlanTest.kt +0 -849
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiStyleTest.kt +0 -212
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiTrackingTest.kt +0 -239
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiViewTest.kt +0 -252
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiActions.kt +0 -154
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiExpr.kt +0 -1038
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiKitNodes.kt +0 -848
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiLog.kt +0 -47
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiModel.kt +0 -39
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiPropsRenderer.kt +0 -463
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiRenderer.kt +0 -1146
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiStyle.kt +0 -667
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiTracking.kt +0 -240
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiValidate.kt +0 -185
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiView.kt +0 -200
- package/scripts/sdui-visual/README.md +0 -64
- package/scripts/sdui-visual/diff.py +0 -65
- package/scripts/sdui-visual/drive.py +0 -234
- package/scripts/sdui-visual/plan.json +0 -713
- 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
|