@divmain/jdm-asm 0.2.0

package/test-data/expressions/logical/logical-complex.json

@@ -0,0 +1,260 @@
+{
+  "nodes": [
+    {
+      "id": "request-node",
+      "type": "inputNode",
+      "position": {
+        "x": 180,
+        "y": 240
+      },
+      "name": "Request"
+    },
+    {
+      "id": "expression-node",
+      "type": "expressionNode",
+      "position": {
+        "x": 470,
+        "y": 240
+      },
+      "name": "expressionNode 1",
+      "content": {
+        "expressions": [
+          {
+            "id": "test1",
+            "key": "simpleAnd",
+            "value": "a and b"
+          },
+          {
+            "id": "test2",
+            "key": "simpleOr",
+            "value": "a or b"
+          },
+          {
+            "id": "test3",
+            "key": "andThenOr",
+            "value": "a and b or c"
+          },
+          {
+            "id": "test4",
+            "key": "orThenAnd",
+            "value": "a or b and c"
+          },
+          {
+            "id": "test5",
+            "key": "notThenOrAnd",
+            "value": "not a or b and c"
+          },
+          {
+            "id": "test6",
+            "key": "explicitGroupAndOr",
+            "value": "(a and b) or c"
+          },
+          {
+            "id": "test7",
+            "key": "explicitGroupOrAnd",
+            "value": "a or (b and c)"
+          },
+          {
+            "id": "test8",
+            "key": "explicitGroupOrAnd2",
+            "value": "(a or b) and c"
+          },
+          {
+            "id": "test9",
+            "key": "deepNesting1",
+            "value": "a and b or c and d"
+          },
+          {
+            "id": "test10",
+            "key": "deepNesting2",
+            "value": "a or b and c or d"
+          },
+          {
+            "id": "test11",
+            "key": "deepNesting3",
+            "value": "(a and b) or (c and d)"
+          },
+          {
+            "id": "test12",
+            "key": "deepNesting4",
+            "value": "(a or b) and (c or d)"
+          },
+          {
+            "id": "test13",
+            "key": "deepNestingWithNot",
+            "value": "not a and not b or c and d"
+          }
+        ]
+      }
+    },
+    {
+      "id": "output-node",
+      "type": "outputNode",
+      "position": {
+        "x": 780,
+        "y": 240
+      },
+      "name": "Response"
+    }
+  ],
+  "edges": [
+    {
+      "id": "edge1",
+      "sourceId": "request-node",
+      "type": "edge",
+      "targetId": "expression-node"
+    },
+    {
+      "id": "edge2",
+      "sourceId": "expression-node",
+      "type": "edge",
+      "targetId": "output-node"
+    }
+  ],
+  "tests": [
+    {
+      "description": "Test basic precedence: AND before OR",
+      "input": {
+        "a": true,
+        "b": false,
+        "c": false,
+        "d": false
+      },
+      "output": {
+        "simpleAnd": false,
+        "simpleOr": true,
+        "andThenOr": false,
+        "orThenAnd": true,
+        "notThenOrAnd": false,
+        "explicitGroupAndOr": false,
+        "explicitGroupOrAnd": true,
+        "explicitGroupOrAnd2": false,
+        "deepNesting1": false,
+        "deepNesting2": true,
+        "deepNesting3": false,
+        "deepNesting4": false,
+        "deepNestingWithNot": false
+      }
+    },
+    {
+      "description": "Test basic precedence: AND before OR",
+      "input": {
+        "a": false,
+        "b": true,
+        "c": false,
+        "d": false
+      },
+      "output": {
+        "simpleAnd": false,
+        "simpleOr": true,
+        "andThenOr": false,
+        "orThenAnd": false,
+        "notThenOrAnd": true,
+        "explicitGroupAndOr": false,
+        "explicitGroupOrAnd": false,
+        "explicitGroupOrAnd2": false,
+        "deepNesting1": false,
+        "deepNesting2": false,
+        "deepNesting3": false,
+        "deepNesting4": false,
+        "deepNestingWithNot": false
+      }
+    },
+    {
+      "description": "Test basic precedence: AND before OR",
+      "input": {
+        "a": false,
+        "b": false,
+        "c": true,
+        "d": false
+      },
+      "output": {
+        "simpleAnd": false,
+        "simpleOr": false,
+        "andThenOr": true,
+        "orThenAnd": false,
+        "notThenOrAnd": true,
+        "explicitGroupAndOr": true,
+        "explicitGroupOrAnd": false,
+        "explicitGroupOrAnd2": false,
+        "deepNesting1": false,
+        "deepNesting2": false,
+        "deepNesting3": false,
+        "deepNesting4": false,
+        "deepNestingWithNot": true
+      }
+    },
+    {
+      "description": "Test basic precedence: AND before OR",
+      "input": {
+        "a": true,
+        "b": true,
+        "c": false,
+        "d": false
+      },
+      "output": {
+        "simpleAnd": true,
+        "simpleOr": true,
+        "andThenOr": true,
+        "orThenAnd": true,
+        "notThenOrAnd": false,
+        "explicitGroupAndOr": true,
+        "explicitGroupOrAnd": true,
+        "explicitGroupOrAnd2": false,
+        "deepNesting1": true,
+        "deepNesting2": true,
+        "deepNesting3": true,
+        "deepNesting4": false,
+        "deepNestingWithNot": false
+      }
+    },
+    {
+      "description": "Test basic precedence: AND before OR",
+      "input": {
+        "a": false,
+        "b": true,
+        "c": true,
+        "d": false
+      },
+      "output": {
+        "simpleAnd": false,
+        "simpleOr": true,
+        "andThenOr": true,
+        "orThenAnd": true,
+        "notThenOrAnd": true,
+        "explicitGroupAndOr": true,
+        "explicitGroupOrAnd": true,
+        "explicitGroupOrAnd2": true,
+        "deepNesting1": false,
+        "deepNesting2": true,
+        "deepNesting3": false,
+        "deepNesting4": true,
+        "deepNestingWithNot": false
+      }
+    },
+    {
+      "description": "Test deeply nested expressions with all variables true",
+      "input": {
+        "a": true,
+        "b": true,
+        "c": true,
+        "d": true
+      },
+      "output": {
+        "simpleAnd": true,
+        "simpleOr": true,
+        "andThenOr": true,
+        "orThenAnd": true,
+        "notThenOrAnd": true,
+        "explicitGroupAndOr": true,
+        "explicitGroupOrAnd": true,
+        "explicitGroupOrAnd2": true,
+        "deepNesting1": true,
+        "deepNesting2": true,
+        "deepNesting3": true,
+        "deepNesting4": true,
+        "deepNestingWithNot": true
+      }
+    }
+  ]
+}

package/test-data/expressions/logical/logical-not.json

@@ -0,0 +1,111 @@
+{
+  "nodes": [
+    {
+      "id": "request-node",
+      "type": "inputNode",
+      "position": {
+        "x": 180,
+        "y": 240
+      },
+      "name": "Request"
+    },
+    {
+      "id": "expression-node",
+      "type": "expressionNode",
+      "position": {
+        "x": 470,
+        "y": 240
+      },
+      "name": "expressionNode 1",
+      "content": {
+        "expressions": [
+          {
+            "id": "not1",
+            "key": "notTrue",
+            "value": "not true"
+          },
+          {
+            "id": "not2",
+            "key": "notFalse",
+            "value": "not false"
+          },
+          {
+            "id": "not3",
+            "key": "notComparison",
+            "value": "not(x > 5)"
+          },
+          {
+            "id": "not4",
+            "key": "notAnd",
+            "value": "not a and b"
+          },
+          {
+            "id": "not5",
+            "key": "doubleNot",
+            "value": "not not a"
+          },
+          {
+            "id": "not6",
+            "key": "notOr",
+            "value": "not(a or b)"
+          }
+        ]
+      }
+    },
+    {
+      "id": "output-node",
+      "type": "outputNode",
+      "position": {
+        "x": 780,
+        "y": 240
+      },
+      "name": "Response"
+    }
+  ],
+  "edges": [
+    {
+      "id": "edge1",
+      "sourceId": "request-node",
+      "type": "edge",
+      "targetId": "expression-node"
+    },
+    {
+      "id": "edge2",
+      "sourceId": "expression-node",
+      "type": "edge",
+      "targetId": "output-node"
+    }
+  ],
+  "tests": [
+    {
+      "input": {
+        "a": true,
+        "b": false,
+        "x": 7
+      },
+      "output": {
+        "notTrue": false,
+        "notFalse": true,
+        "notComparison": false,
+        "notAnd": false,
+        "doubleNot": true,
+        "notOr": false
+      }
+    },
+    {
+      "input": {
+        "a": false,
+        "b": true,
+        "x": 3
+      },
+      "output": {
+        "notTrue": false,
+        "notFalse": true,
+        "notComparison": true,
+        "notAnd": true,
+        "doubleNot": false,
+        "notOr": false
+      }
+    }
+  ]
+}

package/test-data/expressions/logical/logical-or.json

@@ -0,0 +1,123 @@
+{
+  "nodes": [
+    {
+      "id": "request-node",
+      "type": "inputNode",
+      "position": {
+        "x": 180,
+        "y": 240
+      },
+      "name": "Request"
+    },
+    {
+      "id": "expression-node",
+      "type": "expressionNode",
+      "position": {
+        "x": 470,
+        "y": 240
+      },
+      "name": "expressionNode 1",
+      "content": {
+        "expressions": [
+          {
+            "id": "or1",
+            "key": "trueOrTrue",
+            "value": "true or true"
+          },
+          {
+            "id": "or2",
+            "key": "trueOrFalse",
+            "value": "true or false"
+          },
+          {
+            "id": "or3",
+            "key": "falseOrTrue",
+            "value": "false or true"
+          },
+          {
+            "id": "or4",
+            "key": "falseOrFalse",
+            "value": "false or false"
+          },
+          {
+            "id": "or5",
+            "key": "numericOr1",
+            "value": "5 < 3 or 8 > 10"
+          },
+          {
+            "id": "or6",
+            "key": "numericOr2",
+            "value": "x < 5 or x > 10"
+          },
+          {
+            "id": "or8",
+            "key": "complexOr",
+            "value": "x < 0 or y < 0 or x > 100 or y > 100"
+          },
+           {
+            "id": "or9",
+            "key": "precedenceOrAnd",
+            "value": "(x > 0 or y > 0) and (x < 100 and y < 100)"
+          }
+        ]
+      }
+    },
+    {
+      "id": "output-node",
+      "type": "outputNode",
+      "position": {
+        "x": 780,
+        "y": 240
+      },
+      "name": "Response"
+    }
+  ],
+  "edges": [
+    {
+      "id": "edge1",
+      "sourceId": "request-node",
+      "type": "edge",
+      "targetId": "expression-node"
+    },
+    {
+      "id": "edge2",
+      "sourceId": "expression-node",
+      "type": "edge",
+      "targetId": "output-node"
+    }
+  ],
+  "tests": [
+    {
+      "input": {
+        "x": 7,
+        "y": 50
+      },
+      "output": {
+        "trueOrTrue": true,
+        "trueOrFalse": true,
+        "falseOrTrue": true,
+        "falseOrFalse": false,
+        "numericOr1": false,
+        "numericOr2": false,
+        "complexOr": false,
+        "precedenceOrAnd": true
+      }
+    },
+    {
+      "input": {
+        "x": 12,
+        "y": 150
+      },
+      "output": {
+        "trueOrTrue": true,
+        "trueOrFalse": true,
+        "falseOrTrue": true,
+        "falseOrFalse": false,
+        "numericOr1": false,
+        "numericOr2": true,
+        "complexOr": true,
+        "precedenceOrAnd": false
+      }
+    }
+  ]
+}

package/test-data/expressions/string/string-comparison.json

@@ -0,0 +1,128 @@
+{
+  "nodes": [
+    {
+      "id": "request-node",
+      "type": "inputNode",
+      "position": {
+        "x": 180,
+        "y": 240
+      },
+      "name": "Request"
+    },
+    {
+      "id": "expression-node",
+      "type": "expressionNode",
+      "position": {
+        "x": 470,
+        "y": 240
+      },
+      "name": "expressionNode 1",
+      "content": {
+        "expressions": [
+          {
+            "id": "cmp1",
+            "key": "lessThanTrue",
+            "value": "\"apple\" < \"banana\""
+          },
+          {
+            "id": "cmp2",
+            "key": "lessThanFalse",
+            "value": "\"zebra\" < \"apple\""
+          },
+          {
+            "id": "cmp3",
+            "key": "greaterThanTrue",
+            "value": "\"zebra\" > \"apple\""
+          },
+          {
+            "id": "cmp4",
+            "key": "greaterThanFalse",
+            "value": "\"apple\" > \"banana\""
+          },
+          {
+            "id": "cmp5",
+            "key": "lessEqualTrue",
+            "value": "\"abc\" <= \"abc\""
+          },
+          {
+            "id": "cmp6",
+            "key": "lessEqualFalse",
+            "value": "\"abc\" <= \"aba\""
+          },
+          {
+            "id": "cmp7",
+            "key": "greaterEqualTrue",
+            "value": "\"abc\" >= \"abc\""
+          },
+          {
+            "id": "cmp8",
+            "key": "greaterEqualFalse",
+            "value": "\"abc\" >= \"abd\""
+          },
+          {
+            "id": "cmp9",
+            "key": "caseSensitive1",
+            "value": "\"Apple\" < \"apple\""
+          },
+          {
+            "id": "cmp10",
+            "key": "caseSensitive2",
+            "value": "\"ZEBRA\" > \"apple\""
+          },
+          {
+            "id": "cmp11",
+            "key": "prefixComparison",
+            "value": "\"app\" < \"apple\""
+          },
+          {
+            "id": "cmp12",
+            "key": "numbersAsStrings",
+            "value": "\"100\" < \"99\""
+          }
+        ]
+      }
+    },
+    {
+      "id": "output-node",
+      "type": "outputNode",
+      "position": {
+        "x": 780,
+        "y": 240
+      },
+      "name": "Response"
+    }
+  ],
+  "edges": [
+    {
+      "id": "edge1",
+      "sourceId": "request-node",
+      "type": "edge",
+      "targetId": "expression-node"
+    },
+    {
+      "id": "edge2",
+      "sourceId": "expression-node",
+      "type": "edge",
+      "targetId": "output-node"
+    }
+  ],
+  "tests": [
+    {
+      "input": {},
+      "output": {
+        "lessThanTrue": true,
+        "lessThanFalse": false,
+        "greaterThanTrue": true,
+        "greaterThanFalse": false,
+        "lessEqualTrue": true,
+        "lessEqualFalse": false,
+        "greaterEqualTrue": true,
+        "greaterEqualFalse": false,
+        "caseSensitive1": true,
+        "caseSensitive2": false,
+        "prefixComparison": true,
+        "numbersAsStrings": true
+      }
+    }
+  ]
+}