@momo-kits/native-kits 0.169.13-beta.2 → 0.169.13-beta.3-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 +4 -1
- package/build.gradle.kts +11 -0
- package/compose/build.gradle.kts +202 -0
- package/compose/compose.podspec +47 -0
- package/compose/src/androidMain/kotlin/vn/momo/kits/const/HostFont.android.kt +19 -0
- package/compose/src/androidMain/kotlin/vn/momo/kits/navigation/ScrollToTop.android.kt +6 -0
- package/compose/src/androidMain/kotlin/vn/momo/kits/platform/BackGesture.android.kt +12 -0
- package/compose/src/androidMain/kotlin/vn/momo/kits/platform/OsFontScale.android.kt +7 -0
- package/compose/src/androidMain/kotlin/vn/momo/kits/platform/Platform.android.kt +154 -0
- package/compose/src/androidMain/kotlin/vn/momo/kits/platform/ReduceMotion.android.kt +17 -0
- package/compose/src/androidMain/kotlin/vn/momo/kits/platform/ReservedRegions.android.kt +6 -0
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiActionsTest.kt +647 -0
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiExprTest.kt +1411 -0
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiHostTest.kt +130 -0
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiKitArgsTest.kt +524 -0
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiKitNodesTest.kt +559 -0
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiRenderPlanTest.kt +741 -0
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiRenderReuseTest.kt +221 -0
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiRendererPropsTest.kt +270 -0
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiStylePlanTest.kt +849 -0
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiStyleTest.kt +212 -0
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiTrackingTest.kt +239 -0
- package/compose/src/androidUnitTest/kotlin/vn/momo/kits/sdui/SduiViewTest.kt +252 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/application/Context.kt +110 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/application/DesignSystemKits.kt +61 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/application/LiteScreen.kt +1067 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/application/Localize.kt +268 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/application/WidgetContainer.kt +56 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Avatar.kt +157 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Badge.kt +81 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/BadgeDot.kt +32 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/BadgeRibbon.kt +338 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/BaselineView.kt +175 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Button.kt +354 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Carousel.kt +115 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/CheckBox.kt +89 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Chip.kt +130 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Collapse.kt +209 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/CupertinoOverscroll.kt +482 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Divider.kt +49 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Icon.kt +86 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/IconButton.kt +125 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Image.kt +224 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Information.kt +137 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Input.kt +473 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/InputDropDown.kt +113 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/InputMoney.kt +262 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/InputOTP.kt +237 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/InputPhoneNumber.kt +228 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/InputSearch.kt +280 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/InputTextArea.kt +183 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/LazyColumnWithBouncing.kt +342 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Loader.kt +108 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/PaginationDot.kt +56 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/PaginationNumber.kt +40 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/PaginationScroll.kt +82 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/PaginationWhiteDot.kt +39 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/PopupNotify.kt +362 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/PopupPromotion.kt +108 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/ProgressInfo.kt +304 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Radio.kt +59 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Rating.kt +87 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/ScaleSizeScope.kt +21 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Skeleton.kt +88 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Slider.kt +308 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Stepper.kt +218 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Steps.kt +456 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/SuggestAction.kt +122 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Swipe.kt +205 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Switch.kt +89 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/TabView.kt +542 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Tag.kt +86 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Text.kt +175 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Title.kt +201 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Tooltip.kt +498 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/TrustBanner.kt +176 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/Uploader.kt +182 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/datetimepicker/DateTimePicker.kt +193 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/datetimepicker/DateTimePickerTypes.kt +29 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/datetimepicker/DateTimePickerUtils.kt +208 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/components/datetimepicker/WheelPicker.kt +180 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/const/Colors.kt +325 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/const/HostFont.kt +12 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/const/Radius.kt +12 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/const/Spacing.kt +16 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/const/Theme.kt +194 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/const/Typography.kt +291 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/layout/Card.kt +54 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/layout/HeaderLayout.kt +71 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/layout/Item.kt +50 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/layout/ModalLayout.kt +184 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/layout/ScreenLayout.kt +315 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/layout/Section.kt +41 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/modifier/AutomationId.kt +54 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/modifier/Clickable.kt +66 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/modifier/Conditional.kt +11 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/modifier/DeprecatedModifier.kt +104 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/modifier/Shadow.kt +48 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/modifier/Size.kt +51 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/BottomSheet.kt +397 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/HostBackGestureBridge.kt +58 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/ModalScreen.kt +153 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/Navigation.kt +118 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/NavigationContainer.kt +206 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/Navigator.kt +421 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/ScrollToTop.kt +8 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/StackScreen.kt +750 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/StackTransition.kt +152 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/SwipeBackHaptic.kt +35 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/BottomTab.kt +242 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/BottomTabBar.kt +398 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/CurvedContainer.kt +103 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/DuoBarCompression.kt +93 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/DuoTabBar.kt +208 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/bottomtab/TabBarMetrics.kt +133 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/component/FloatingButton.kt +167 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/component/Header.kt +446 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/component/HeaderBackground.kt +105 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/component/HeaderJourney.kt +106 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/component/HeaderLocation.kt +74 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/component/HeaderRight.kt +400 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/component/HeaderTitle.kt +39 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/component/HeaderUser.kt +363 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/component/SideBar.kt +197 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/component/SnackBar.kt +133 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/tracking/ScreenTracker.kt +127 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/platform/BackGesture.kt +12 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/platform/ComposeLottieAnimation.kt +114 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/platform/OsFontScale.kt +7 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/platform/Platform.kt +76 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/platform/ReduceMotion.kt +7 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/platform/ReservedRegions.kt +21 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiActions.kt +154 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiExpr.kt +1038 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiKitNodes.kt +848 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiLog.kt +47 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiModel.kt +39 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiPropsRenderer.kt +463 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiRenderer.kt +1146 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiStyle.kt +667 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiTracking.kt +240 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiValidate.kt +185 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/sdui/SduiView.kt +200 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/utils/Icons.kt +1329 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/utils/Resources.kt +55 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/utils/Tracking.kt +15 -0
- package/compose/src/commonMain/kotlin/vn/momo/kits/utils/Utils.kt +117 -0
- package/compose/src/iosMain/kotlin/vn/momo/kits/const/HostFont.ios.kt +42 -0
- package/compose/src/iosMain/kotlin/vn/momo/kits/navigation/HostBackGesture.ios.kt +45 -0
- package/compose/src/iosMain/kotlin/vn/momo/kits/navigation/ScrollToTop.ios.kt +32 -0
- package/compose/src/iosMain/kotlin/vn/momo/kits/platform/BackGesture.ios.kt +38 -0
- package/compose/src/iosMain/kotlin/vn/momo/kits/platform/OsFontScale.ios.kt +65 -0
- package/compose/src/iosMain/kotlin/vn/momo/kits/platform/Platform.ios.kt +217 -0
- package/compose/src/iosMain/kotlin/vn/momo/kits/platform/ReduceMotion.ios.kt +48 -0
- package/compose/src/iosMain/kotlin/vn/momo/kits/platform/ReservedRegions.ios.kt +143 -0
- package/gradle/libs.versions.toml +69 -0
- package/gradle/wrapper/gradle-wrapper.jar +0 -0
- package/gradle/wrapper/gradle-wrapper.properties +8 -0
- package/gradle.properties +24 -0
- package/gradlew +252 -0
- package/gradlew.bat +94 -0
- package/ios/Navigation/BottomTab/BottomTabBar.swift +4 -14
- package/ios/native-kits.podspec +1 -1
- package/ios-demo/MoMoUIKitsDemo.podspec +1 -1
- package/ios-demo/README.md +120 -0
- package/ios-demo/Sources/MoMoUIKitsDemo/SampleDemos/BottomTabDemo.swift +3 -16
- package/package.json +1 -1
- package/scripts/sdui-visual/README.md +64 -0
- package/scripts/sdui-visual/diff.py +65 -0
- package/scripts/sdui-visual/drive.py +234 -0
- package/scripts/sdui-visual/plan.json +713 -0
- package/scripts/sdui-visual/run.sh +92 -0
- package/settings.gradle.kts +64 -0
|
@@ -0,0 +1,1411 @@
|
|
|
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
|