@doenet/doenetml 0.6.0-alpha1

package/cypress/e2e/answerValidation/functionanswers.cy.js

@@ -0,0 +1,314 @@
+import { cesc } from "../../../../src/utils/url";
+
+describe("Function answer validation tests", function () {
+  beforeEach(() => {
+    cy.clearIndexedDB();
+    cy.visit("/src/Tools/cypressTest/");
+  });
+
+  it("simple function of input", () => {
+    cy.window().then(async (win) => {
+      win.postMessage(
+        {
+          doenetML: `
+  <function name="f">cos(2*pi*x)</function>
+  
+  <p>Enter a number close to an integer:
+  <answer>
+    <mathinput name="x" />
+    <award credit="$$f($(x.immediateValue{isResponse}))">
+      <when>true</when>
+    </award>
+  </answer>
+  </p>
+    `,
+        },
+        "*",
+      );
+    });
+
+    let partialCredit005 = Math.cos(2 * Math.PI * 0.05);
+    let partialCredit01 = Math.cos(2 * Math.PI * 0.1);
+    let partialCredit015 = Math.cos(2 * Math.PI * 0.15);
+    let partialCredit02 = Math.cos(2 * Math.PI * 0.2);
+    let partialCredit005Percent = Math.round(
+      Math.cos(2 * Math.PI * 0.05) * 100,
+    );
+    let partialCredit01Percent = Math.round(Math.cos(2 * Math.PI * 0.1) * 100);
+    let partialCredit015Percent = Math.round(
+      Math.cos(2 * Math.PI * 0.15) * 100,
+    );
+    let partialCredit02Percent = Math.round(Math.cos(2 * Math.PI * 0.2) * 100);
+
+    cy.get(cesc("#\\/x_submit")).should("be.visible");
+
+    cy.log("Submit empty answer");
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_incorrect")).should("be.visible");
+
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).eq(0);
+    });
+
+    cy.log("Submit correct answers");
+    cy.get(cesc("#\\/x") + " textarea").type("7", { force: true });
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_correct")).should("be.visible");
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).eq(1);
+    });
+    cy.get(cesc("#\\/x") + " textarea").type("{end}{backspace}0", {
+      force: true,
+    });
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_correct")).should("be.visible");
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).eq(1);
+    });
+    cy.get(cesc("#\\/x") + " textarea").type("{end}{backspace}-14", {
+      force: true,
+    });
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_correct")).should("be.visible");
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).eq(1);
+    });
+    cy.get(cesc("#\\/x") + " textarea").type(
+      "{ctrl+home}{shift+end}{backspace}33",
+      { force: true },
+    );
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_correct")).should("be.visible");
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).eq(1);
+    });
+    cy.get(cesc("#\\/x") + " textarea").type(
+      "{ctrl+home}{shift+end}{backspace}-102351",
+      { force: true },
+    );
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_correct")).should("be.visible");
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).eq(1);
+    });
+
+    cy.log("Submit incorrect answers");
+    cy.get(cesc("#\\/x") + " textarea").type(
+      "{ctrl+home}{shift+end}{backspace}9.5",
+      { force: true },
+    );
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_incorrect")).should("be.visible");
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).eq(0);
+    });
+    cy.get(cesc("#\\/x") + " textarea").type(
+      "{ctrl+home}{shift+end}{backspace}x^2",
+      { force: true },
+    );
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_incorrect")).should("be.visible");
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).eq(0);
+    });
+    cy.get(cesc("#\\/x") + " textarea").type(
+      "{ctrl+home}{shift+end}{backspace}-253.3",
+      { force: true },
+    );
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_incorrect")).should("be.visible");
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).eq(0);
+    });
+    cy.get(cesc("#\\/x") + " textarea").type(
+      "{ctrl+home}{shift+end}{backspace}23.6",
+      { force: true },
+    );
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_incorrect")).should("be.visible");
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).eq(0);
+    });
+
+    cy.log("Submit partially correct answers");
+    cy.get(cesc("#\\/x") + " textarea").type(
+      "{ctrl+home}{shift+end}{backspace}11.9",
+      { force: true },
+    );
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_partial")).should(
+      "have.text",
+      `${partialCredit01Percent} %`,
+    );
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).closeTo(
+        partialCredit01,
+        1e-12,
+      );
+    });
+    cy.get(cesc("#\\/x") + " textarea").type(
+      "{ctrl+home}{shift+end}{backspace}73.15",
+      { force: true },
+    );
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_partial")).should(
+      "have.text",
+      `${partialCredit015Percent} %`,
+    );
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).closeTo(
+        partialCredit015,
+        1e-12,
+      );
+    });
+    cy.get(cesc("#\\/x") + " textarea").type(
+      "{ctrl+home}{shift+end}{backspace}-103.8",
+      { force: true },
+    );
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_partial")).should(
+      "have.text",
+      `${partialCredit02Percent} %`,
+    );
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).closeTo(
+        partialCredit02,
+        1e-12,
+      );
+    });
+    cy.get(cesc("#\\/x") + " textarea").type(
+      "{ctrl+home}{shift+end}{backspace}-0.05",
+      { force: true },
+    );
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_partial")).should(
+      "have.text",
+      `${partialCredit005Percent} %`,
+    );
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).closeTo(
+        partialCredit005,
+        1e-12,
+      );
+    });
+  });
+
+  it("function with parameters", () => {
+    cy.window().then(async (win) => {
+      win.postMessage(
+        {
+          doenetML: `
+
+  <p>Offset: <mathinput name="offset" prefill="0"/></p>
+  <p>Period: <mathinput name="period" prefill="1"/></p>
+  <p>Magnitude <mathinput name="magnitude" prefill="1"/></p>
+  <function name="f">$magnitude cos(2*pi*(x-$offset)/$period)</function>
+  <p>Enter a number:
+  <answer>
+    <mathinput name="x" />
+    <award credit="$$f($(x.immediateValue{isResponse}))">
+      <when>true</when>
+    </award>
+  </answer>
+  </p>
+    `,
+        },
+        "*",
+      );
+    });
+
+    // let offsets = [0, Math.E,];
+    let offsets = [Math.E];
+    let periods = [2, Math.PI / 2];
+    let magnitudes = [0.5, 2];
+
+    let partialCredit = (o, p, m, x) =>
+      Math.max(0, Math.min(1, m * Math.cos((2 * Math.PI * (x - o)) / p)));
+    let partialCreditPercent = (o, p, m, x) =>
+      Math.round(partialCredit(o, p, m, x) * 100);
+
+    let numberAnswers = [Math.E, 0, 2 / 3, -Math.PI / 2, -252351.9];
+
+    cy.get(cesc("#\\/x_submit")).should("be.visible");
+
+    cy.log("Submit empty answer");
+    cy.get(cesc("#\\/x_submit")).click();
+    cy.get(cesc("#\\/x_incorrect")).should("be.visible");
+
+    cy.window().then(async (win) => {
+      let stateVariables = await win.returnAllStateVariables1();
+      expect(stateVariables["/_answer1"].stateValues.creditAchieved).eq(0);
+    });
+
+    for (let offset of offsets) {
+      cy.get(cesc("#\\/offset") + " textarea").type(
+        `{ctrl+home}{shift+end}{backspace}${offset}{enter}`,
+        { force: true, delay: 0 },
+      );
+      for (let period of periods) {
+        cy.get(cesc("#\\/period") + " textarea").type(
+          `{ctrl+home}{shift+end}{backspace}${period}{enter}`,
+          { force: true, delay: 0 },
+        );
+        for (let magnitude of magnitudes) {
+          cy.get(cesc("#\\/magnitude") + " textarea").type(
+            `{ctrl+home}{shift+end}{backspace}${magnitude}{enter}`,
+            { force: true, delay: 0 },
+          );
+
+          let maximals = [offset, offset + 2 * period, offset - 7 * period];
+          let minimals = [
+            offset + 1.5 * period,
+            offset + 5.5 * period,
+            offset - 7.5 * period,
+          ];
+
+          cy.log("Submit answers");
+          for (let ans of [...maximals, ...minimals, ...numberAnswers]) {
+            cy.get(cesc("#\\/x") + " textarea").type(
+              `{ctrl+home}{shift+end}{backspace}${ans}`,
+              { force: true, delay: 0 },
+            );
+            cy.get(cesc("#\\/x_submit")).click();
+
+            let credit = partialCredit(offset, period, magnitude, ans);
+            if (credit === 1) {
+              cy.get(cesc("#\\/x_correct")).should("be.visible");
+            } else if (credit === 0) {
+              cy.get(cesc("#\\/x_incorrect")).should("be.visible");
+            } else {
+              let percent = partialCreditPercent(
+                offset,
+                period,
+                magnitude,
+                ans,
+              );
+              cy.get(cesc("#\\/x_partial")).should("have.text", `${percent} %`);
+
+              cy.window().then(async (win) => {
+                let stateVariables = await win.returnAllStateVariables1();
+                expect(
+                  stateVariables["/_answer1"].stateValues.creditAchieved,
+                ).closeTo(credit, 1e-8);
+              });
+            }
+          }
+        }
+      }
+    }
+  });
+});

package/cypress/e2e/answerValidation/matchingpatterns.cy.js

@@ -0,0 +1,287 @@
+import { cesc } from "../../../../src/utils/url";
+
+describe("matching patterns answer tests", function () {
+  beforeEach(() => {
+    cy.clearIndexedDB();
+    cy.visit("/src/Tools/cypressTest/");
+  });
+
+  it("enter any quadratic", () => {
+    cy.window().then(async (win) => {
+      win.postMessage(
+        {
+          doenetML: `
+    <p><text>a</text></p>
+    <setup>
+      <math name="pattern1">()$var^2+()$var+()</math>
+      <math name="pattern2">()$var^2+()</math>
+    </setup>
+
+    <p><mathinput name="var" /></p>
+    <p>Enter a quadratic expression in the variable <math name="var2" copysource="var" />:
+    <answer name="ans">
+      <mathinput name="resp" />
+      <award><when>
+        <matchesPattern name="excludeX1" pattern="$pattern1" excludeMatches="$var" allowImplicitIdentities>
+          $resp
+        </matchesPattern>
+        or
+        <matchesPattern name="excludeX2" pattern="$pattern2" excludeMatches="$var" allowImplicitIdentities>
+          $resp
+        </matchesPattern>
+      </when></award>
+      <considerAsResponses>
+        <conditionalContent maximumNumberToShow="1">
+          <case condition="$excludeX1">$excludeX1.patternMatches[1]{assignNamesSkip="1"} $excludeX1.patternMatches[2]{assignNamesSkip="1"} $excludeX1.patternMatch3{assignNamesSkip="1"}</case>
+          <case condition="$excludeX2">$excludeX2.patternMatches[1]{assignNamesSkip="1"} <math>0</math> $excludeX2.patternMatch2</case>
+        </conditionalContent>
+      </considerAsResponses>
+    </answer>
+    </p>
+
+    <p name="p_sub">Submitted answer: $ans.submittedResponse</p>
+    <p name="p_quad">Quadratic coeff: $ans.submittedResponse2</p>
+    <p name="p_lin">Linear coeff: $ans.submittedResponse3</p>
+    <p name="p_const">Constant term: $ans.submittedResponse4</p>
+    
+
+    `,
+        },
+        "*",
+      );
+    });
+
+    cy.get(cesc("#\\/_text1")).should("have.text", "a");
+
+    let desiredResults = {
+      x: {
+        "": {
+          correct: false,
+          response: ["\uff3f", "\uff3f"],
+        },
+        "x^2": {
+          correct: true,
+          response: [["^", "x", 2], "x2"],
+          matches: [
+            [1, "1"],
+            [0, "0"],
+            [0, "0"],
+          ],
+        },
+        "x^2{rightArrow}+1": {
+          correct: true,
+          response: [["+", ["^", "x", 2], 1], "x2+1"],
+          matches: [
+            [1, "1"],
+            [0, "0"],
+            [1, "1"],
+          ],
+        },
+        "x^2{rightArrow}+x": {
+          correct: true,
+          response: [["+", ["^", "x", 2], "x"], "x2+x"],
+          matches: [
+            [1, "1"],
+            [1, "1"],
+            [0, "0"],
+          ],
+        },
+        "x^2{rightArrow}+x+x": {
+          correct: false,
+          response: [["+", ["^", "x", 2], "x", "x"], "x2+x+x"],
+        },
+        "x^2{rightArrow}+c": {
+          correct: true,
+          response: [["+", ["^", "x", 2], "c"], "x2+c"],
+          matches: [
+            [1, "1"],
+            [0, "0"],
+            ["c", "c"],
+          ],
+        },
+        "xx^2{rightArrow}+c": {
+          correct: false,
+          response: [["+", ["*", "x", ["^", "x", 2]], "c"], "xx2+c"],
+        },
+        "x^2{rightArrow}+x+c+d": {
+          correct: true,
+          response: [["+", ["^", "x", 2], "x", "c", "d"], "x2+x+c+d"],
+          matches: [
+            [1, "1"],
+            [1, "1"],
+            [["+", "c", "d"], "c+d"],
+          ],
+        },
+        "ax^2{rightArrow}+bx+c": {
+          correct: true,
+          response: [
+            ["+", ["*", "a", ["^", "x", 2]], ["*", "b", "x"], "c"],
+            "ax2+bx+c",
+          ],
+          matches: [
+            ["a", "a"],
+            ["b", "b"],
+            ["c", "c"],
+          ],
+        },
+        "ay^2{rightArrow}+by+c": {
+          correct: false,
+          response: [
+            ["+", ["*", "a", ["^", "y", 2]], ["*", "b", "y"], "c"],
+            "ay2+by+c",
+          ],
+        },
+        "sqrt2{rightArrow}x^2{rightArrow}+5/8{rightArrow}x+e^y": {
+          correct: true,
+          response: [
+            [
+              "+",
+              ["*", ["apply", "sqrt", 2], ["^", "x", 2]],
+              ["*", ["/", 5, 8], "x"],
+              ["^", "e", "y"],
+            ],
+            "√2x2+(58)x+ey",
+          ],
+          matches: [
+            [["apply", "sqrt", 2], "√2"],
+            [["/", 5, 8], "58"],
+            [["^", "e", "y"], "ey"],
+          ],
+        },
+      },
+      y: {
+        "ay^2{rightArrow}+by+c": {
+          correct: true,
+          response: [
+            ["+", ["*", "a", ["^", "y", 2]], ["*", "b", "y"], "c"],
+            "ay2+by+c",
+          ],
+          matches: [
+            ["a", "a"],
+            ["b", "b"],
+            ["c", "c"],
+          ],
+        },
+        "piy^2{rightArrow}x^2{rightArrow}+e^x{rightArrow}y+x+x": {
+          correct: true,
+          response: [
+            [
+              "+",
+              ["*", "pi", ["^", "y", 2], ["^", "x", 2]],
+              ["*", ["^", "e", "x"], "y"],
+              "x",
+              "x",
+            ],
+            "πy2x2+exy+x+x",
+          ],
+          matches: [
+            [["*", "pi", ["^", "x", 2]], "πx2"],
+            [["^", "e", "x"], "ex"],
+            [["+", "x", "x"], "x+x"],
+          ],
+        },
+        "4y^2{rightArrow}-9y-2": {
+          correct: true,
+          response: [
+            ["+", ["*", 4, ["^", "y", 2]], ["-", ["*", 9, "y"]], -2],
+            "4y2−9y−2",
+          ],
+          matches: [
+            [4, "4"],
+            [["-", 9], "−9"],
+            [-2, "−2"],
+          ],
+        },
+        "4y^2{rightArrow}+3x+5": {
+          correct: true,
+          response: [
+            ["+", ["*", 4, ["^", "y", 2]], ["*", 3, "x"], 5],
+            "4y2+3x+5",
+          ],
+          matches: [
+            [4, "4"],
+            [0, "0"],
+            [["+", ["*", 3, "x"], 5], "3x+5"],
+          ],
+        },
+      },
+    };
+
+    cy.get(cesc("#\\/var2") + " .mjx-mrow").should("contain.text", "\uff3f");
+
+    for (let varName in desiredResults) {
+      cy.log(`setting variable to ${varName}`);
+      cy.get(cesc("#\\/var") + " textarea").type(
+        `{end}{backspace}${varName}{enter}`,
+        { force: true },
+      );
+      cy.get(cesc("#\\/var2") + " .mjx-mrow").should("contain.text", varName);
+
+      let resultsForVar = desiredResults[varName];
+      for (let expr in resultsForVar) {
+        cy.log(`trying ${expr} for variable ${varName}`);
+
+        cy.get(cesc("#\\/resp") + " textarea").type(
+          `{ctrl+home}{ctrl+shift+end}{backspace}${expr}{enter}`,
+          { force: true },
+        );
+
+        let res = resultsForVar[expr];
+
+        if (res.correct) {
+          cy.get(cesc("#\\/resp_correct")).should("be.visible");
+          cy.get(cesc("#\\/p_sub") + " .mjx-mrow")
+            .eq(0)
+            .should("have.text", res.response[1]);
+          cy.get(cesc("#\\/p_quad") + " .mjx-mrow")
+            .eq(0)
+            .should("have.text", res.matches[0][1]);
+          cy.get(cesc("#\\/p_lin") + " .mjx-mrow")
+            .eq(0)
+            .should("have.text", res.matches[1][1]);
+          cy.get(cesc("#\\/p_const") + " .mjx-mrow")
+            .eq(0)
+            .should("have.text", res.matches[2][1]);
+          cy.window().then(async (win) => {
+            let stateVariables = await win.returnAllStateVariables1();
+            expect(stateVariables["/ans"].stateValues.submittedResponse1).eqls(
+              res.response[0],
+            );
+            expect(stateVariables["/ans"].stateValues.submittedResponse2).eqls(
+              res.matches[0][0],
+            );
+            expect(stateVariables["/ans"].stateValues.submittedResponse3).eqls(
+              res.matches[1][0],
+            );
+            expect(stateVariables["/ans"].stateValues.submittedResponse4).eqls(
+              res.matches[2][0],
+            );
+          });
+        } else {
+          cy.get(cesc("#\\/resp_incorrect")).should("be.visible");
+          cy.get(cesc("#\\/p_sub") + " .mjx-mrow")
+            .eq(0)
+            .should("have.text", res.response[1]);
+          cy.get(cesc("#\\/p_quad") + " .mjx-mrow").should("not.exist");
+          cy.get(cesc("#\\/p_lin") + " .mjx-mrow").should("not.exist");
+          cy.get(cesc("#\\/p_const") + " .mjx-mrow").should("not.exist");
+          cy.window().then(async (win) => {
+            let stateVariables = await win.returnAllStateVariables1();
+            expect(stateVariables["/ans"].stateValues.submittedResponse1).eqls(
+              res.response[0],
+            );
+            expect(stateVariables["/ans"].stateValues.submittedResponse2).eq(
+              undefined,
+            );
+            expect(stateVariables["/ans"].stateValues.submittedResponse3).eq(
+              undefined,
+            );
+            expect(stateVariables["/ans"].stateValues.submittedResponse4).eq(
+              undefined,
+            );
+          });
+        }
+      }
+    }
+  });
+});