testeranto 0.200.1 → 0.202.0

package/testeranto/bundles/node/core/example/Calculator.test.mjs

@@ -0,0 +1,503 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  assert
+} from "../chunk-VXVF7WFO.mjs";
+import {
+  Node_default
+} from "../chunk-RIM6RECA.mjs";
+
+// example/Calculator.test.specification.ts
+var specification = (Suite, Given, When, Then) => {
+  return [
+    Suite.Default("Testing Calculator operations", {
+      // Basic number input
+      testEmptyDisplay: Given.Default(
+        ["pressing nothing, the display is empty"],
+        [],
+        [Then.result("")]
+      ),
+      testSingleDigit: Given.Default(
+        ["entering a number puts it on the display"],
+        [When.press("2")],
+        [Then.result("2")]
+      ),
+      testMultipleDigits: Given.Default(
+        ["entering multiple digits concatenates them"],
+        [When.press("2"), When.press("2")],
+        [Then.result("22")]
+      ),
+      testLargeNumber: Given.Default(
+        ["entering a large number works correctly"],
+        [When.press("1"), When.press("2"), When.press("3"), When.press("4"), When.press("5")],
+        [Then.result("12345")]
+      ),
+      // Basic operations
+      testAdditionExpression: Given.Default(
+        ["addition expression is displayed correctly"],
+        [When.press("2"), When.press("+"), When.press("3")],
+        [Then.result("2+3")]
+      ),
+      testIncompleteAddition: Given.Default(
+        ["incomplete addition expression is displayed correctly"],
+        [When.press("2"), When.press("+")],
+        [Then.result("2+")]
+      ),
+      testSubtractionExpression: Given.Default(
+        ["subtraction expression is displayed correctly"],
+        [When.press("7"), When.press("-"), When.press("3")],
+        [Then.result("7-3")]
+      ),
+      testMultiplicationExpression: Given.Default(
+        ["multiplication expression is displayed correctly"],
+        [When.press("4"), When.press("*"), When.press("5")],
+        [Then.result("4*5")]
+      ),
+      testDivisionExpression: Given.Default(
+        ["division expression is displayed correctly"],
+        [When.press("8"), When.press("/"), When.press("2")],
+        [Then.result("8/2")]
+      ),
+      // Complex expressions
+      testMixedOperations: Given.Default(
+        ["mixed operations are displayed correctly"],
+        [When.press("2"), When.press("+"), When.press("3"), When.press("*"), When.press("4")],
+        [Then.result("2+3*4")]
+      ),
+      testLongExpression: Given.Default(
+        ["long complex expression is displayed correctly"],
+        [
+          When.press("1"),
+          When.press("+"),
+          When.press("2"),
+          When.press("*"),
+          When.press("3"),
+          When.press("-"),
+          When.press("4"),
+          When.press("/"),
+          When.press("5")
+        ],
+        [Then.result("1+2*3-4/5")]
+      ),
+      // Calculation tests
+      testSimpleAddition: Given.Default(
+        ["simple addition calculation"],
+        [
+          When.press("2"),
+          When.press("3"),
+          When.press("+"),
+          When.press("4"),
+          When.press("5"),
+          When.enter()
+        ],
+        [Then.result("68")]
+      ),
+      testSimpleSubtraction: Given.Default(
+        ["simple subtraction calculation"],
+        [
+          When.press("9"),
+          When.press("5"),
+          When.press("-"),
+          When.press("3"),
+          When.press("2"),
+          When.enter()
+        ],
+        [Then.result("63")]
+      ),
+      testSimpleMultiplication: Given.Default(
+        ["simple multiplication calculation"],
+        [
+          When.press("6"),
+          When.press("*"),
+          When.press("7"),
+          When.enter()
+        ],
+        [Then.result("42")]
+      ),
+      testSimpleDivision: Given.Default(
+        ["simple division calculation"],
+        [
+          When.press("8"),
+          When.press("4"),
+          When.press("/"),
+          When.press("2"),
+          When.enter()
+        ],
+        [Then.result("42")]
+      ),
+      // Edge cases
+      testClearOperation: Given.Default(
+        ["clear operation resets the display"],
+        [
+          When.press("1"),
+          When.press("2"),
+          When.press("3"),
+          When.press("C"),
+          When.press("4")
+        ],
+        [Then.result("4")]
+      ),
+      testStartingWithOperator: Given.Default(
+        ["starting with operator should work"],
+        [When.press("+"), When.press("5")],
+        [Then.result("+5")]
+      ),
+      testMultipleOperators: Given.Default(
+        ["multiple operators in sequence"],
+        [When.press("5"), When.press("+"), When.press("-"), When.press("3")],
+        [Then.result("5+-3")]
+      ),
+      // Decimal numbers
+      testDecimalInput: Given.Default(
+        ["decimal number input"],
+        [When.press("3"), When.press("."), When.press("1"), When.press("4")],
+        [Then.result("3.14")]
+      ),
+      testDecimalCalculation: Given.Default(
+        ["decimal calculation"],
+        [
+          When.press("3"),
+          When.press("."),
+          When.press("1"),
+          When.press("+"),
+          When.press("1"),
+          When.press("."),
+          When.press("8"),
+          When.press("6"),
+          When.enter()
+        ],
+        [Then.result("4.96")]
+      ),
+      // Complex calculations
+      testOrderOfOperations: Given.Default(
+        ["order of operations is respected"],
+        [
+          When.press("2"),
+          When.press("+"),
+          When.press("3"),
+          When.press("*"),
+          When.press("4"),
+          When.enter()
+        ],
+        [Then.result("14")]
+      ),
+      testParenthesesExpression: Given.Default(
+        ["parentheses in expression"],
+        [
+          When.press("("),
+          When.press("2"),
+          When.press("+"),
+          When.press("3"),
+          When.press(")"),
+          When.press("*"),
+          When.press("4"),
+          When.enter()
+        ],
+        [Then.result("20")]
+      ),
+      // Error cases
+      testDivisionByZero: Given.Default(
+        ["division by zero shows error"],
+        [
+          When.press("5"),
+          When.press("/"),
+          When.press("0"),
+          When.enter()
+        ],
+        [Then.result("Error")]
+      ),
+      testInvalidExpression: Given.Default(
+        ["invalid expression shows error"],
+        [
+          When.press("2"),
+          When.press("+"),
+          When.press("+"),
+          When.press("3"),
+          When.enter()
+        ],
+        [Then.result("Error")]
+      ),
+      // Memory functions
+      testMemoryStoreRecall: Given.Default(
+        ["memory store and recall"],
+        [
+          When.press("1"),
+          When.press("2"),
+          When.press("3"),
+          When.press("MS"),
+          When.press("C"),
+          When.press("MR")
+        ],
+        [Then.result("123")]
+      ),
+      testMemoryClear: Given.Default(
+        ["memory clear"],
+        [
+          When.press("4"),
+          When.press("5"),
+          When.press("6"),
+          When.press("MS"),
+          When.press("MC"),
+          When.press("MR")
+        ],
+        [Then.result("0")]
+      ),
+      testMemoryAddition: Given.Default(
+        ["memory addition"],
+        [
+          When.press("1"),
+          When.press("0"),
+          When.press("M+"),
+          When.press("2"),
+          When.press("0"),
+          When.press("M+"),
+          When.press("MR")
+        ],
+        [Then.result("30")]
+      )
+    })
+  ];
+};
+
+// example/Calculator.ts
+var Calculator = class {
+  constructor() {
+    this.display = "";
+    this.values = {};
+    this.id = Math.random();
+  }
+  // Add a unique ID to track instances
+  press(button) {
+    console.log(" ---- PRESS ---");
+    console.log(
+      `[CALCULATOR ${this.id}] Pressing: ${button}, current display: '${this.display}'`
+    );
+    this.display = this.display + button;
+    console.log(`[CALCULATOR ${this.id}] New display is: '${this.display}'`);
+    return this;
+  }
+  enter() {
+    try {
+      const result = eval(this.display);
+      this.display = result.toString();
+    } catch (error) {
+      this.display = "Error";
+    }
+  }
+  // Memory functions
+  memoryStore() {
+    this.setValue("memory", parseFloat(this.display) || 0);
+    this.clear();
+  }
+  memoryRecall() {
+    const memoryValue = this.getValue("memory") || 0;
+    this.display = memoryValue.toString();
+  }
+  memoryClear() {
+    this.setValue("memory", 0);
+  }
+  memoryAdd() {
+    const currentValue = parseFloat(this.display) || 0;
+    const memoryValue = this.getValue("memory") || 0;
+    this.setValue("memory", memoryValue + currentValue);
+    this.clear();
+  }
+  // Handle special buttons
+  handleSpecialButton(button) {
+    switch (button) {
+      case "C":
+        this.clear();
+        return true;
+      case "MS":
+        this.memoryStore();
+        return true;
+      case "MR":
+        this.memoryRecall();
+        return true;
+      case "MC":
+        this.memoryClear();
+        return true;
+      case "M+":
+        this.memoryAdd();
+        return true;
+      default:
+        return false;
+    }
+  }
+  press(button) {
+    console.log(" ---- PRESS ---");
+    console.log(
+      `[CALCULATOR ${this.id}] Pressing: ${button}, current display: '${this.display}'`
+    );
+    if (this.handleSpecialButton(button)) {
+      return this;
+    }
+    this.display = this.display + button;
+    console.log(`[CALCULATOR ${this.id}] New display is: '${this.display}'`);
+    return this;
+  }
+  getDisplay() {
+    console.log(`[CALCULATOR ${this.id}] getDisplay: '${this.display}'`);
+    return this.display;
+  }
+  clear() {
+    this.display = "";
+  }
+  // Keep these methods for backward compatibility if needed
+  add(a, b) {
+    return a + b;
+  }
+  subtract(a, b) {
+    return a - b;
+  }
+  multiply(a, b) {
+    return a * b;
+  }
+  divide(a, b) {
+    if (b === 0) {
+      throw new Error("Cannot divide by zero");
+    }
+    return a / b;
+  }
+  setValue(identifier, value) {
+    this.values[identifier] = value;
+  }
+  getValue(identifier) {
+    return this.values[identifier] ?? null;
+  }
+};
+
+// example/Calculator.test.implementation.ts
+var implementation = {
+  suites: {
+    Default: "Default test suite for Calculator"
+  },
+  givens: {
+    Default: () => {
+      const calc = new Calculator();
+      console.log(
+        "[IMPLEMENTATION] Default given, display:",
+        calc.getDisplay()
+      );
+      return calc;
+    }
+  },
+  whens: {
+    press: (button) => (calculator) => {
+      console.log("[IMPLEMENTATION] press called with button:", button);
+      console.log(
+        "[IMPLEMENTATION] calculator before press:",
+        calculator.getDisplay()
+      );
+      const result2 = calculator.press(button);
+      console.log(
+        "[IMPLEMENTATION] calculator after press:",
+        result2.getDisplay()
+      );
+      return result2;
+    },
+    enter: () => (calculator) => {
+      console.log("[IMPLEMENTATION] enter called");
+      console.log(
+        "[IMPLEMENTATION] calculator before enter:",
+        calculator.getDisplay()
+      );
+      calculator.enter();
+      console.log(
+        "[IMPLEMENTATION] calculator after enter:",
+        calculator.getDisplay()
+      );
+      return calculator;
+    },
+    // Memory operations
+    memoryStore: () => (calculator) => {
+      console.log("[IMPLEMENTATION] memoryStore called");
+      calculator.memoryStore();
+      return calculator;
+    },
+    memoryRecall: () => (calculator) => {
+      console.log("[IMPLEMENTATION] memoryRecall called");
+      calculator.memoryRecall();
+      return calculator;
+    },
+    memoryClear: () => (calculator) => {
+      console.log("[IMPLEMENTATION] memoryClear called");
+      calculator.memoryClear();
+      return calculator;
+    },
+    memoryAdd: () => (calculator) => {
+      console.log("[IMPLEMENTATION] memoryAdd called");
+      calculator.memoryAdd();
+      return calculator;
+    }
+  },
+  thens: {
+    result: (expected) => (calculator) => {
+      assert.equal(calculator.getDisplay(), expected);
+    }
+  }
+};
+
+// example/Calculator.test.adapter.ts
+var adapter = {
+  beforeAll: async (input, testResource, pm) => {
+    console.log("[ADAPTER] beforeAll called with input:", input);
+    return input;
+  },
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    console.log("[ADAPTER] beforeEach called with subject:", subject);
+    const result2 = await initializer();
+    console.log("[ADAPTER] beforeEach result:", result2);
+    console.log("[ADAPTER] display:", result2.getDisplay());
+    return result2;
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    console.log("[ADAPTER] andWhen called");
+    console.log("[ADAPTER] store display:", store.getDisplay());
+    try {
+      console.log("[ADAPTER] Calling whenCB which should return a function");
+      const transform = whenCB;
+      console.log("[ADAPTER] Transform function:", transform);
+      const result2 = transform(store);
+      console.log("[ADAPTER] Result display:", result2.getDisplay());
+      if (!(result2 instanceof Calculator)) {
+        throw new Error(`Expected Calculator instance, got ${typeof result2}`);
+      }
+      return result2;
+    } catch (e) {
+      console.error("[ADAPTER] Error in andWhen:", e);
+      throw e;
+    }
+  },
+  butThen: async (store, thenCB, testResource, pm) => {
+    console.log("[ADAPTER] butThen called with store:", store);
+    try {
+      thenCB(store);
+      const display = store.getDisplay();
+      console.log("[ADAPTER] butThen returning selection:", display);
+      return display;
+    } catch (e) {
+      console.error("[ADAPTER] Error in butThen:", e);
+      throw e;
+    }
+  },
+  afterEach: async (store, key, pm) => {
+    return store;
+  },
+  afterAll: async (store, pm) => {
+    return store;
+  },
+  assertThis: (actual) => {
+    return actual;
+  }
+};
+
+// example/Calculator.test.ts
+var Calculator_test_default = Node_default(
+  Calculator,
+  specification,
+  implementation,
+  adapter
+);
+export {
+  Calculator_test_default as default
+};