Add fuzzy testing

conway-cddl/codegen/generators/array.ts

@@ -103,4 +103,26 @@ export class GenArray extends CodeGeneratorBase {
       `
     }
   }
+
+  generateArbitrary(prng: string): string {
+      return `
+        let [isDefinite, prng1] = prand.uniformIntDistribution(0, 1, prng);
+        let [len, prng_mut] = prand.uniformIntDistribution(0, 3, prng1);
+        ${this.item ?
+            `let ret = new ${this.name}([], isDefinite > 0);` :
+            `let items = new Uint32Array(len);`
+        }
+        for (let i = 0; i < len; i++) {
+          ${this.item ?
+              `ret.add(${this.itemJsType()}.arbitrary(prng_mut));` :
+              `items[i] = prand.unsafeUniformIntDistribution(0, 4294967295, prng_mut);`
+            }
+          prand.unsafeSkipN(prng_mut, 1);
+        }
+        ${this.item ?
+          `return ret;` :
+          `return new ${this.name}(items, isDefinite > 0);`
+        }
+      `;
+  }
 }

conway-cddl/codegen/generators/index.ts

@@ -37,6 +37,10 @@ export class CodeGeneratorBase {
     return contents != null ? contents(newName) : newName;
   }
 
+  arbitrary(seed: string): string {
+    return `${this.name}.arbitrary(${seed})`;
+  }
+
   deserialize(reader: string, path: string): string {
     return `${this.name}.deserialize(${reader}, ${path})`;
   }
@@ -124,6 +128,10 @@ export class CodeGeneratorBase {
     return "";
   }
 
+  generateArbitrary(_prng: string): string {
+    return `throw new Error("Not Implemented")`;
+  }
+
   generateDeserialize(_reader: string, _path: string): string {
     return `throw new Error("Not Implemented");`;
   }
@@ -217,6 +225,16 @@ export class CodeGeneratorBase {
         `;
     }
 
+    let arbitrary: string = `
+      ${this.renameMethod(
+        "arbitrary",
+        (arbitrary) => `
+      static ${arbitrary}(prng: RandomGenerator): ${this.name} {
+        ${this.generateArbitrary("prng")}
+      }`
+      )}
+    `
+
     return `
       ${this.generatePre()}
 
@@ -228,6 +246,7 @@ export class CodeGeneratorBase {
 
         ${deserialize}
         ${serialize}
+        ${arbitrary}
 
         ${this.options.genCSL ? this.generateCSLHelpers() : ""}
 

conway-cddl/codegen/generators/structured/index.ts

@@ -31,7 +31,32 @@ export class GenStructuredBase<
   }
 
   private fieldType(field: Field) {
-    return `${this.typeUtils.jsType(field.type)} ${field.optional || field.nullable ? "| undefined" : ""}`;
+    return `${this.fieldBaseType(field)}${field.optional || field.nullable ? " | undefined" : ""}`;
+  }
+
+  // this ignores undefined
+  private fieldBaseType(field: Field) {
+    return `${this.typeUtils.jsType(field.type)}`;
+  }
+
+  // necessary because primitive fields do not have an arbitrary method
+  private fieldArbitrary(field: Field, prng: string): string {
+    let primitives: Set<string> = new Set(["Uint8Array", "number", "boolean"]);
+    const fieldType: string = this.fieldBaseType(field);
+    if (primitives.has(fieldType) ) {
+      switch (fieldType) {
+        case "Uint8Array":
+          return `new Uint8Array(repeatRand(3, ${prng}, prand.uniformIntDistribution(0, 255))[0])`;
+        case "number":
+          return `prand.uniformIntDistribution(0, Number.MAX_SAFE_INTEGER, ${prng})[0]`;
+        case "boolean":
+          return `prand.unsafeUniformIntDistribution(0, 1, ${prng}) > 0`;
+        default:
+          throw new Error(`Unexpected primitive type ${fieldType}`);
+      }
+    } else {
+      return `${field.type}.arbitrary(${prng})`;
+    }
   }
 
   getFields(): Field[] {
@@ -54,21 +79,21 @@ export class GenStructuredBase<
         .map((x) => `${x.name}: ${this.fieldType(x)}`)
         .join(", ")}) {
         ${this.getFields()
-          .map((x) => `this._${x.name} = ${x.name};`)
-          .join("\n")}
+        .map((x) => `this._${x.name} = ${x.name};`)
+        .join("\n")}
       }
       ${this.renameMethod(
-        "new",
-        (new_) => `
+          "new",
+          (new_) => `
       static ${new_}(${this.getFields()
-        .map((x) => `${x.name}: ${this.fieldType(x)}`)
-        .join(", ")}) {
+              .map((x) => `${x.name}: ${this.fieldType(x)}`)
+              .join(", ")}) {
           return new ${this.name}(${this.getFields()
-            .map((x) => x.name)
-            .join(",")});
+              .map((x) => x.name)
+              .join(",")});
         }
       `
-      )}
+        )}
     `;
   }
 
@@ -96,6 +121,35 @@ export class GenStructuredBase<
       .join("\n");
   }
 
+  generateArbitrary(prng: string): string {
+    const generateField = (f: Field) => {
+      if (f.optional) {
+        return `
+            let ${f.name}: ${this.fieldType(f)};
+            const ${f.name}_defined = prand.unsafeUniformIntDistribution(0, 1, ${prng});
+            if (${f.name}_defined) {
+              ${f.name} = ${this.fieldArbitrary(f, prng)};
+              prand.unsafeSkipN(${prng}, 1);
+            } else {
+              ${f.name} = undefined;
+            }
+          `
+      } else {
+        return `
+            let ${f.name}: ${this.fieldType(f)};
+            ${f.name} = ${this.fieldArbitrary(f, prng)};
+            prand.unsafeSkipN(${prng}, 1);
+          `
+      }
+
+    }
+    return `
+      ${this.getFields().map(generateField).join('\n')}   
+
+      return new ${this.name}(${this.getFields().map((f) => f.name)});
+    `
+  }
+
   generateExtraMethods(): string {
     return this.generateAccessors();
   }

conway-cddl/codegen/main.ts

@@ -85,6 +85,9 @@ async function main() {
         // @ts-expect-error: Assigning Node.js webcrypto to globalThis.crypto
         globalThis.crypto = webcrypto;
     }
+    import { RandomGenerator } from 'pure-rand';
+    import prand from 'pure-rand';
+    import { repeatRand } from './lib/prand_utils';
 
     function $$UN(id: string, ...args: any): any {
       throw ("Undefined function: " + id);

conway-cddl/yaml/custom/bignum.yaml

@@ -6,6 +6,8 @@ BigNum:
     value:
       min: 0n
       max: BigNum._maxU64()
+  methods:
+    arbitrary: null
   extra_methods: |
     // Lifted from: https://doc.rust-lang.org/std/primitive.u64.html#associatedconstant.MAX
     static _maxU64(): bigint {
@@ -71,6 +73,11 @@ BigNum:
       return this.toJsValue() < rhs_value.toJsValue();
     }
 
+    static arbitrary(prng: RandomGenerator): BigNum {
+      const n: bigint = prand.uniformBigIntDistribution(0n, BigNum._maxU64(), prng)[0]
+      return new BigNum(n);
+    }
+
     static max_value(): BigNum {
       return new BigNum(BigNum._maxU64());
     }

package.json

@@ -9,7 +9,7 @@
   ],
   "scripts": {
     "test": "npm run test-serialization ; npm run test-api",
-    "test-serialization": "NODE_OPTIONS=--experimental-vm-modules jest tests/serialization/serialization.test.ts",
+    "test-serialization": "NODE_OPTIONS=--experimental-vm-modules jest tests/serialization/serialization.test.ts --coverage --collectCoverageFrom=\"src/**/*.ts\"",
     "test-serialization-dev": "NODE_OPTIONS=--experimental-vm-modules jest tests/serialization/serialization_dev.test.ts",
     "test-api": "npm run generate-cdl-definitions ; NODE_OPTIONS=--experimental-vm-modules jest tests/api/api.test.ts",
     "test-implementation": "NODE_OPTIONS=--experimental-vm-modules jest fees hash min_output_ada private_key bip32-ed25519",
@@ -67,6 +67,7 @@
     "@noble/hashes": "^1.5.0",
     "bech32": "^2.0.0",
     "base58-js": "^2.0.0",
-    "tweetnacl": "^1.0.3"
+    "tweetnacl": "^1.0.3",
+    "pure-rand": "^6.1.0"
   }
 }