github-mig/ZoKrates
github-mig/ZoKrates
1
0
Fork 0
mirror of synced 2025-09-23 12:18:44 +00:00
Code Issues Projects Releases Wiki Activity

uncomment tests

Browse source
This commit is contained in:
dark64 2022-02-16 19:12:34 +01:00
parent a1f2cb397e
commit eaafb9792c
1 changed files with 133 additions and 133 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

266
zokrates_js/tests/tests.js
View file

@ -15,156 +15,156 @@ describe("tests", function () {
});
});
// describe("compilation", () => {
// it("should compile", () => {
// assert.doesNotThrow(() => {
// const artifacts = zokratesProvider.compile(
// "def main() -> field: return 42"
// );
// assert.ok(artifacts !== undefined);
// });
// });
describe("compilation", () => {
it("should compile", () => {
assert.doesNotThrow(() => {
const artifacts = zokratesProvider.compile(
"def main() -> field: return 42"
);
assert.ok(artifacts !== undefined);
});
});
// it("should throw on invalid code", () => {
// assert.throws(() => zokratesProvider.compile(":-)"));
// });
it("should throw on invalid code", () => {
assert.throws(() => zokratesProvider.compile(":-)"));
});
// it("should resolve stdlib module", () => {
// const stdlib = require("../stdlib.json");
// assert.doesNotThrow(() => {
// const code = `import "${
// Object.keys(stdlib)[0]
// }" as func\ndef main(): return`;
// zokratesProvider.compile(code);
// });
// });
it("should resolve stdlib module", () => {
const stdlib = require("../stdlib.json");
assert.doesNotThrow(() => {
const code = `import "${
Object.keys(stdlib)[0]
}" as func\ndef main(): return`;
zokratesProvider.compile(code);
});
});
// it("should resolve user module", () => {
// assert.doesNotThrow(() => {
// const code =
// 'import "test" as test\ndef main() -> field: return test()';
// const options = {
// resolveCallback: (_, path) => {
// return {
// source: "def main() -> (field): return 1",
// location: path,
// };
// },
// };
// zokratesProvider.compile(code, options);
// });
// });
it("should resolve user module", () => {
assert.doesNotThrow(() => {
const code =
'import "test" as test\ndef main() -> field: return test()';
const options = {
resolveCallback: (_, path) => {
return {
source: "def main() -> (field): return 1",
location: path,
};
},
};
zokratesProvider.compile(code, options);
});
});
// it("should throw on unresolved module", () => {
// assert.throws(() => {
// const code =
// 'import "test" as test\ndef main() -> field: return test()';
// zokratesProvider.compile(code);
// });
// });
// });
it("should throw on unresolved module", () => {
assert.throws(() => {
const code =
'import "test" as test\ndef main() -> field: return test()';
zokratesProvider.compile(code);
});
});
});
// describe("computation", () => {
// it("should compute with valid inputs", () => {
// assert.doesNotThrow(() => {
// const code = "def main(private field a) -> field: return a * a";
// const artifacts = zokratesProvider.compile(code);
describe("computation", () => {
it("should compute with valid inputs", () => {
assert.doesNotThrow(() => {
const code = "def main(private field a) -> field: return a * a";
const artifacts = zokratesProvider.compile(code);
// const result = zokratesProvider.computeWitness(artifacts, ["2"]);
// const output = JSON.parse(result.output);
// assert.deepEqual(output, ["4"]);
// });
// });
const result = zokratesProvider.computeWitness(artifacts, ["2"]);
const output = JSON.parse(result.output);
assert.deepEqual(output, ["4"]);
});
});
// it("should throw on invalid input count", () => {
// assert.throws(() => {
// const code = "def main(private field a) -> field: return a * a";
// const artifacts = zokratesProvider.compile(code);
// zokratesProvider.computeWitness(artifacts, ["1", "2"]);
// });
// });
it("should throw on invalid input count", () => {
assert.throws(() => {
const code = "def main(private field a) -> field: return a * a";
const artifacts = zokratesProvider.compile(code);
zokratesProvider.computeWitness(artifacts, ["1", "2"]);
});
});
// it("should throw on invalid input type", () => {
// assert.throws(() => {
// const code = "def main(private field a) -> field: return a * a";
// const artifacts = zokratesProvider.compile(code);
// zokratesProvider.computeWitness(artifacts, [true]);
// });
// });
// });
it("should throw on invalid input type", () => {
assert.throws(() => {
const code = "def main(private field a) -> field: return a * a";
const artifacts = zokratesProvider.compile(code);
zokratesProvider.computeWitness(artifacts, [true]);
});
});
});
// const runWithOptions = (options) => {
// let provider;
// let artifacts;
// let computationResult;
// let keypair;
// let proof;
const runWithOptions = (options) => {
let provider;
let artifacts;
let computationResult;
let keypair;
let proof;
// before((done) => {
// provider = zokratesProvider.withOptions(options);
// done();
// });
before((done) => {
provider = zokratesProvider.withOptions(options);
done();
});
// it("compile", () => {
// assert.doesNotThrow(() => {
// const code =
// "def main(private field a, field b) -> bool: return a * a == b";
// artifacts = provider.compile(code);
// });
// });
it("compile", () => {
assert.doesNotThrow(() => {
const code =
"def main(private field a, field b) -> bool: return a * a == b";
artifacts = provider.compile(code);
});
});
// it("compute witness", () => {
// assert.doesNotThrow(() => {
// computationResult = provider.computeWitness(artifacts, ["2", "4"]);
// });
// });
it("compute witness", () => {
assert.doesNotThrow(() => {
computationResult = provider.computeWitness(artifacts, ["2", "4"]);
});
});
// it("setup", () => {
// assert.doesNotThrow(() => {
// if (options.scheme === "marlin") {
// const srs = provider.universalSetup(4);
// keypair = provider.setupWithSrs(srs, artifacts.program);
// } else {
// keypair = provider.setup(artifacts.program);
// }
// });
// });
it("setup", () => {
assert.doesNotThrow(() => {
if (options.scheme === "marlin") {
const srs = provider.universalSetup(4);
keypair = provider.setupWithSrs(srs, artifacts.program);
} else {
keypair = provider.setup(artifacts.program);
}
});
});
// if (options.curve === "bn128" && ["g16", "gm17"].includes(options.scheme)) {
// it("export verifier", () => {
// assert.doesNotThrow(() => {
// let verifier = provider.exportSolidityVerifier(keypair.vk);
// assert.ok(verifier.includes("contract"));
// });
// });
// }
if (options.curve === "bn128" && ["g16", "gm17"].includes(options.scheme)) {
it("export verifier", () => {
assert.doesNotThrow(() => {
let verifier = provider.exportSolidityVerifier(keypair.vk);
assert.ok(verifier.includes("contract"));
});
});
}
// it("generate proof", () => {
// assert.doesNotThrow(() => {
// proof = provider.generateProof(
// artifacts.program,
// computationResult.witness,
// keypair.pk
// );
// assert.ok(proof !== undefined);
// assert.equal(proof.inputs.length, 2);
// });
// });
it("generate proof", () => {
assert.doesNotThrow(() => {
proof = provider.generateProof(
artifacts.program,
computationResult.witness,
keypair.pk
);
assert.ok(proof !== undefined);
assert.equal(proof.inputs.length, 2);
});
});
// it("verify", () => {
// assert.doesNotThrow(() => {
// assert(provider.verify(keypair.vk, proof) === true);
// });
// });
// };
it("verify", () => {
assert.doesNotThrow(() => {
assert(provider.verify(keypair.vk, proof) === true);
});
});
};
// for (const scheme of ["g16", "gm17", "marlin"]) {
// describe(scheme, () => {
// for (const curve of ["bn128", "bls12_381", "bls12_377", "bw6_761"]) {
// describe(curve, () => runWithOptions({ scheme, curve }));
// }
// });
// }
for (const scheme of ["g16", "gm17", "marlin"]) {
describe(scheme, () => {
for (const curve of ["bn128", "bls12_381", "bls12_377", "bw6_761"]) {
describe(curve, () => runWithOptions({ scheme, curve }));
}
});
}
const testRunner = (rootPath, testPath, test) => {
let entryPoint;