support arbitrary in structured types & support more primitive types

Author: rmgaray

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

@@ -79,6 +79,7 @@ async function main() {
     import {Address, Credential, CredKind, RewardAddress} from "./address";
     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);