ByoungSooPark/modeling-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4b6166dc4f66730809c65a5ecdd810a110de9054
modeling-app/rust/kcl-lib/tests/double_map_fn/ast.snap

234 lines
6.0 KiB
Plaintext
Raw Normal View History

KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
---
source: kcl/src/simulation_tests.rs
description: Result of parsing double_map_fn.kcl
---
{
"Ok": {
"body": [
{
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"declaration": {
"end": 34,
"id": {
"end": 12,
"name": "increment",
"start": 3,
"type": "Identifier"
},
"init": {
"body": {
"body": [
{
"argument": {
"end": 32,
"left": {
"end": 28,
"name": "i",
Make = and => optional in function declarations (#4577) * Make `=` and `=>` optional in function declarations And requires `:` for return types Signed-off-by: Nick Cameron <nrc@ncameron.org> * Tests Signed-off-by: Nick Cameron <nrc@ncameron.org> * Format types in function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> * Require in anon function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-27 15:46:58 +13:00
"start": 27,
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"type": "Identifier",
"type": "Identifier"
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
},
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"operator": "+",
"right": {
"end": 32,
"raw": "1",
"start": 31,
"type": "Literal",
"type": "Literal",
Parse units on numeric literals and keep them in the AST (#5061) * Code changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * test changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Frontend changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Refactor asNum Co-authored-by: Jonathan Tran <jonnytran@gmail.com> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Jonathan Tran <jonnytran@gmail.com>
2025-01-22 08:29:30 +13:00
"value": {
"value": 1.0,
"suffix": "None"
}
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
},
"start": 27,
"type": "BinaryExpression",
"type": "BinaryExpression"
},
"end": 32,
"start": 20,
"type": "ReturnStatement",
"type": "ReturnStatement"
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
}
],
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"end": 34,
"start": 16
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
},
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"end": 34,
"params": [
{
"type": "Parameter",
"identifier": {
"end": 14,
"name": "i",
"start": 13,
"type": "Identifier"
}
}
],
"start": 12,
"type": "FunctionExpression",
"type": "FunctionExpression"
},
"start": 3,
"type": "VariableDeclarator"
},
Make = and => optional in function declarations (#4577) * Make `=` and `=>` optional in function declarations And requires `:` for return types Signed-off-by: Nick Cameron <nrc@ncameron.org> * Tests Signed-off-by: Nick Cameron <nrc@ncameron.org> * Format types in function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> * Require in anon function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-27 15:46:58 +13:00
"end": 34,
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
"kind": "fn",
"start": 0,
"type": "VariableDeclaration",
"type": "VariableDeclaration"
},
{
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"declaration": {
"end": 47,
"id": {
"end": 38,
"name": "xs",
"start": 36,
"type": "Identifier"
},
"init": {
Make = and => optional in function declarations (#4577) * Make `=` and `=>` optional in function declarations And requires `:` for return types Signed-off-by: Nick Cameron <nrc@ncameron.org> * Tests Signed-off-by: Nick Cameron <nrc@ncameron.org> * Format types in function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> * Require in anon function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-27 15:46:58 +13:00
"end": 47,
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"endElement": {
"end": 46,
"raw": "2",
"start": 45,
"type": "Literal",
"type": "Literal",
Parse units on numeric literals and keep them in the AST (#5061) * Code changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * test changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Frontend changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Refactor asNum Co-authored-by: Jonathan Tran <jonnytran@gmail.com> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Jonathan Tran <jonnytran@gmail.com>
2025-01-22 08:29:30 +13:00
"value": {
"value": 2.0,
"suffix": "None"
}
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
},
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"endInclusive": true,
"start": 41,
"startElement": {
"end": 43,
"raw": "0",
"start": 42,
"type": "Literal",
"type": "Literal",
Parse units on numeric literals and keep them in the AST (#5061) * Code changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * test changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Frontend changes Signed-off-by: Nick Cameron <nrc@ncameron.org> * Refactor asNum Co-authored-by: Jonathan Tran <jonnytran@gmail.com> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Jonathan Tran <jonnytran@gmail.com>
2025-01-22 08:29:30 +13:00
"value": {
"value": 0.0,
"suffix": "None"
}
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
},
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"type": "ArrayRangeExpression",
"type": "ArrayRangeExpression"
},
"start": 36,
"type": "VariableDeclarator"
},
Make = and => optional in function declarations (#4577) * Make `=` and `=>` optional in function declarations And requires `:` for return types Signed-off-by: Nick Cameron <nrc@ncameron.org> * Tests Signed-off-by: Nick Cameron <nrc@ncameron.org> * Format types in function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> * Require in anon function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-27 15:46:58 +13:00
"end": 47,
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
"kind": "const",
Make = and => optional in function declarations (#4577) * Make `=` and `=>` optional in function declarations And requires `:` for return types Signed-off-by: Nick Cameron <nrc@ncameron.org> * Tests Signed-off-by: Nick Cameron <nrc@ncameron.org> * Format types in function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> * Require in anon function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-27 15:46:58 +13:00
"start": 36,
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
"type": "VariableDeclaration",
"type": "VariableDeclaration"
},
{
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"declaration": {
"end": 101,
"id": {
"end": 50,
"name": "ys",
"start": 48,
"type": "Identifier"
},
"init": {
"body": [
{
"end": 55,
"name": "xs",
"start": 53,
"type": "Identifier",
"type": "Identifier"
},
{
"arguments": [
{
"end": 66,
"start": 65,
"type": "PipeSubstitution",
"type": "PipeSubstitution"
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
},
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
{
"end": 77,
"name": "increment",
"start": 68,
"type": "Identifier",
"type": "Identifier"
}
],
"callee": {
"end": 64,
"name": "map",
Make = and => optional in function declarations (#4577) * Make `=` and `=>` optional in function declarations And requires `:` for return types Signed-off-by: Nick Cameron <nrc@ncameron.org> * Tests Signed-off-by: Nick Cameron <nrc@ncameron.org> * Format types in function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> * Require in anon function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-27 15:46:58 +13:00
"start": 61,
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"type": "Identifier"
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
},
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"end": 78,
"start": 61,
"type": "CallExpression",
"type": "CallExpression"
},
{
"arguments": [
{
"end": 89,
"start": 88,
"type": "PipeSubstitution",
"type": "PipeSubstitution"
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
},
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
{
"end": 100,
"name": "increment",
"start": 91,
"type": "Identifier",
"type": "Identifier"
}
],
"callee": {
"end": 87,
"name": "map",
Make = and => optional in function declarations (#4577) * Make `=` and `=>` optional in function declarations And requires `:` for return types Signed-off-by: Nick Cameron <nrc@ncameron.org> * Tests Signed-off-by: Nick Cameron <nrc@ncameron.org> * Format types in function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> * Require in anon function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-27 15:46:58 +13:00
"start": 84,
Module/import upgrades (#4677) * Parse more import syntax Signed-off-by: Nick Cameron <nrc@ncameron.org> * Remove unnecessary Vec from VariableDeclaration Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor out an execution module Signed-off-by: Nick Cameron <nrc@ncameron.org> * imports: constants, globs, export import Signed-off-by: Nick Cameron <nrc@ncameron.org> * test fixups Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-12-07 07:16:04 +13:00
"type": "Identifier"
},
"end": 101,
"start": 84,
"type": "CallExpression",
"type": "CallExpression"
}
],
"end": 101,
"start": 53,
"type": "PipeExpression",
"type": "PipeExpression"
},
"start": 48,
"type": "VariableDeclarator"
},
Make = and => optional in function declarations (#4577) * Make `=` and `=>` optional in function declarations And requires `:` for return types Signed-off-by: Nick Cameron <nrc@ncameron.org> * Tests Signed-off-by: Nick Cameron <nrc@ncameron.org> * Format types in function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> * Require in anon function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-27 15:46:58 +13:00
"end": 101,
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
"kind": "const",
Make = and => optional in function declarations (#4577) * Make `=` and `=>` optional in function declarations And requires `:` for return types Signed-off-by: Nick Cameron <nrc@ncameron.org> * Tests Signed-off-by: Nick Cameron <nrc@ncameron.org> * Format types in function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> * Require in anon function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-27 15:46:58 +13:00
"start": 48,
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
"type": "VariableDeclaration",
"type": "VariableDeclaration"
}
],
Make = and => optional in function declarations (#4577) * Make `=` and `=>` optional in function declarations And requires `:` for return types Signed-off-by: Nick Cameron <nrc@ncameron.org> * Tests Signed-off-by: Nick Cameron <nrc@ncameron.org> * Format types in function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> * Require in anon function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-27 15:46:58 +13:00
"end": 102,
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
"nonCodeMeta": {
"nonCodeNodes": {
"0": [
{
Make = and => optional in function declarations (#4577) * Make `=` and `=>` optional in function declarations And requires `:` for return types Signed-off-by: Nick Cameron <nrc@ncameron.org> * Tests Signed-off-by: Nick Cameron <nrc@ncameron.org> * Format types in function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> * Require in anon function decls Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
2024-11-27 15:46:58 +13:00
"end": 36,
"start": 34,
KCL: More simulation tests (#4359) Demonstrate simulation tests where we don't care about visuals, e.g. the double-map test. The `just new-sim-test` now accepts an optional argument, `render_to_png` which can be either "true" or "false" (defaults to "true"). Tests like double_map that don't render anything can use false, rather than rendering an empty PNG with nothing in it. This means the [tests under `no_visuals/`](https://github.com/KittyCAD/modeling-app/tree/v0.26.2/src/wasm-lib/tests/executor/inputs/no_visuals) can be entirely replaced by simulation tests. This is much better! For example, I moved `double_map.kcl` from a no_visuals test to a simulation test. Here's the file: ``` fn increment = (i) => { return i + 1 } xs = [0..2] ys = xs |> map(%, increment) |> map(%, increment) ``` Previously the `no_visuals` test just checked that the program ran successfully without panicking. Now the simulation test lets you see the value of `xs` and `ys` and immediately see they're correct. If our map logic changes (for example, we have an off-by-one error and don't apply the `map` to the last element) it'll show up in the program memory snapshot.
2024-10-31 11:43:14 -05:00
"type": "NonCodeNode",
"value": {
"type": "newLine"
}
}
]
},
"startNodes": []
},
"start": 0
}
}
Reference in New Issue Copy Permalink