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