modeling-app/rust/kcl-lib/tests/property_of_object/input.kcl

// This tests evaluating properties of objects.


obj = { foo = 1, bar = 0 }

// Test: the property is a literal.


one_a = obj["foo"]

assertLessThanOrEq(one_a, 1, "Literal property lookup")
assertGreaterThanOrEq(one_a, 1, "Literal property lookup")

// Test: the property is a variable,
// which must be evaluated before looking it up.


p = "foo"
one_b = obj[p]

assertLessThanOrEq(one_b, 1, "Computed property lookup")
assertGreaterThanOrEq(one_b, 1, "Computed property lookup")

// Test: multiple literal properties.


obj2 = { inner = obj }

one_c = obj2.inner["foo"]

assertLessThanOrEq(one_c, 1, "Literal property lookup")
assertGreaterThanOrEq(one_c, 1, "Literal property lookup")

// Test: multiple properties, mix of literal and computed.


one_d = obj2.inner[p]

assertLessThanOrEq(one_d, 1, "Computed property lookup")
assertGreaterThanOrEq(one_d, 1, "Computed property lookup")
Easy KCL tests with no engine/visuals (#3282) This new test framework, `no_visuals`, is for testing KCL programs via asserts, not via twenty-twenty visual tests. This is useful for unit-testing small fragments of KCL. It's easy! All you need to do is: - Write a KCL file - Save it under `tests/executor/inputs/no_visuals/foo.kcl` - Open `no_visuals.rs` and add `gen_test!(foo);` 2024-08-05 21:44:49 -05:00			`// This tests evaluating properties of objects.`

Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts. 2024-11-04 20:34:22 -06:00
Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org> 2024-11-25 09:21:55 +13:00			`obj = { foo = 1, bar = 0 }`
Easy KCL tests with no engine/visuals (#3282) This new test framework, `no_visuals`, is for testing KCL programs via asserts, not via twenty-twenty visual tests. This is useful for unit-testing small fragments of KCL. It's easy! All you need to do is: - Write a KCL file - Save it under `tests/executor/inputs/no_visuals/foo.kcl` - Open `no_visuals.rs` and add `gen_test!(foo);` 2024-08-05 21:44:49 -05:00
			`// Test: the property is a literal.`


Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts. 2024-11-04 20:34:22 -06:00			`one_a = obj["foo"]`

			`assertLessThanOrEq(one_a, 1, "Literal property lookup")`
Easy KCL tests with no engine/visuals (#3282) This new test framework, `no_visuals`, is for testing KCL programs via asserts, not via twenty-twenty visual tests. This is useful for unit-testing small fragments of KCL. It's easy! All you need to do is: - Write a KCL file - Save it under `tests/executor/inputs/no_visuals/foo.kcl` - Open `no_visuals.rs` and add `gen_test!(foo);` 2024-08-05 21:44:49 -05:00			`assertGreaterThanOrEq(one_a, 1, "Literal property lookup")`

			`// Test: the property is a variable,`
			`// which must be evaluated before looking it up.`


Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts. 2024-11-04 20:34:22 -06:00			`p = "foo"`
			`one_b = obj[p]`

			`assertLessThanOrEq(one_b, 1, "Computed property lookup")`
Easy KCL tests with no engine/visuals (#3282) This new test framework, `no_visuals`, is for testing KCL programs via asserts, not via twenty-twenty visual tests. This is useful for unit-testing small fragments of KCL. It's easy! All you need to do is: - Write a KCL file - Save it under `tests/executor/inputs/no_visuals/foo.kcl` - Open `no_visuals.rs` and add `gen_test!(foo);` 2024-08-05 21:44:49 -05:00			`assertGreaterThanOrEq(one_b, 1, "Computed property lookup")`

			`// Test: multiple literal properties.`


Support `=` in record initialisation (#4519) Signed-off-by: Nick Cameron <nrc@ncameron.org> 2024-11-25 09:21:55 +13:00			`obj2 = { inner = obj }`
Easy KCL tests with no engine/visuals (#3282) This new test framework, `no_visuals`, is for testing KCL programs via asserts, not via twenty-twenty visual tests. This is useful for unit-testing small fragments of KCL. It's easy! All you need to do is: - Write a KCL file - Save it under `tests/executor/inputs/no_visuals/foo.kcl` - Open `no_visuals.rs` and add `gen_test!(foo);` 2024-08-05 21:44:49 -05:00
Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts. 2024-11-04 20:34:22 -06:00			`one_c = obj2.inner["foo"]`

			`assertLessThanOrEq(one_c, 1, "Literal property lookup")`
Easy KCL tests with no engine/visuals (#3282) This new test framework, `no_visuals`, is for testing KCL programs via asserts, not via twenty-twenty visual tests. This is useful for unit-testing small fragments of KCL. It's easy! All you need to do is: - Write a KCL file - Save it under `tests/executor/inputs/no_visuals/foo.kcl` - Open `no_visuals.rs` and add `gen_test!(foo);` 2024-08-05 21:44:49 -05:00			`assertGreaterThanOrEq(one_c, 1, "Literal property lookup")`

			`// Test: multiple properties, mix of literal and computed.`


Move tests from no_visuals into simulation tests (#4367) Now you can properly inspect program memory for the no_visuals tests, instead of relying on a lot of KCL asserts. 2024-11-04 20:34:22 -06:00			`one_d = obj2.inner[p]`

			`assertLessThanOrEq(one_d, 1, "Computed property lookup")`
Easy KCL tests with no engine/visuals (#3282) This new test framework, `no_visuals`, is for testing KCL programs via asserts, not via twenty-twenty visual tests. This is useful for unit-testing small fragments of KCL. It's easy! All you need to do is: - Write a KCL file - Save it under `tests/executor/inputs/no_visuals/foo.kcl` - Open `no_visuals.rs` and add `gen_test!(foo);` 2024-08-05 21:44:49 -05:00			`assertGreaterThanOrEq(one_d, 1, "Computed property lookup")`