Fix IProperty relies on runId not freq

dubzzz · May 10, 2018 · cde38cd · cde38cd
1 parent 886a19a
commit cde38cd
Show file tree

Hide file tree

Showing 8 changed files with 28 additions and 20 deletions.
diff --git a/src/check/property/AsyncProperty.generic.ts b/src/check/property/AsyncProperty.generic.ts
@@ -11,8 +11,8 @@ import IProperty from './IProperty';
 export class AsyncProperty<Ts> implements IProperty<Ts> {
   constructor(readonly arb: Arbitrary<Ts>, readonly predicate: (t: Ts) => Promise<boolean | void>) {}
   isAsync = () => true;
-  generate(mrng: Random, freq?: number): Shrinkable<Ts> {
-    return freq != null ? this.arb.withBias(freq).generate(mrng) : this.arb.generate(mrng);
+  generate(mrng: Random, runId?: number): Shrinkable<Ts> {
+    return runId != null ? this.arb.withBias(runId + 2).generate(mrng) : this.arb.generate(mrng);
   }
   async run(v: Ts): Promise<string | null> {
     try {

diff --git a/src/check/property/IProperty.ts b/src/check/property/IProperty.ts
@@ -20,7 +20,7 @@ export default interface IProperty<Ts> {
    * Generate values of type Ts
    *
    * @param mrng Random number generator
-   * @param runId Id of the generation, starting at 0
+   * @param runId Id of the generation, starting at 0 - if set the generation might be biased
    */
   generate(mrng: Random, runId?: number): Shrinkable<Ts>;
   /**

diff --git a/src/check/property/Property.generic.ts b/src/check/property/Property.generic.ts
@@ -12,8 +12,8 @@ import IProperty from './IProperty';
 export class Property<Ts> implements IProperty<Ts> {
   constructor(readonly arb: Arbitrary<Ts>, readonly predicate: (t: Ts) => boolean | void) {}
   isAsync = () => false;
-  generate(mrng: Random, freq?: number): Shrinkable<Ts> {
-    return freq != null ? this.arb.withBias(freq).generate(mrng) : this.arb.generate(mrng);
+  generate(mrng: Random, runId?: number): Shrinkable<Ts> {
+    return runId != null ? this.arb.withBias(runId + 2).generate(mrng) : this.arb.generate(mrng);
   }
   run(v: Ts): string | null {
     try {

diff --git a/src/check/property/TimeoutProperty.ts b/src/check/property/TimeoutProperty.ts
@@ -15,8 +15,8 @@ const timeoutAfter = async (timeMs: number) =>
 export class TimeoutProperty<Ts> implements IProperty<Ts> {
   constructor(readonly property: IProperty<Ts>, readonly timeMs: number) {}
   isAsync = () => true;
-  generate(mrng: Random, freq?: number): Shrinkable<Ts> {
-    return this.property.generate(mrng, freq);
+  generate(mrng: Random, runId?: number): Shrinkable<Ts> {
+    return this.property.generate(mrng, runId);
   }
   async run(v: Ts): Promise<string | null> {
     return Promise.race([this.property.run(v), timeoutAfter(this.timeMs)]);

diff --git a/src/check/property/UnbiasedProperty.ts b/src/check/property/UnbiasedProperty.ts
@@ -7,6 +7,6 @@ import IProperty from './IProperty';
 export class UnbiasedProperty<Ts> implements IProperty<Ts> {
   constructor(readonly property: IProperty<Ts>) {}
   isAsync = () => this.property.isAsync();
-  generate = (mrng: Random, freq?: number) => this.property.generate(mrng);
+  generate = (mrng: Random, runId?: number) => this.property.generate(mrng);
   run = (v: Ts) => this.property.run(v);
 }
diff --git a/test/unit/check/property/AsyncProperty.spec.ts b/test/unit/check/property/AsyncProperty.spec.ts
@@ -96,7 +96,10 @@ describe('AsyncProperty', () => {
         generate(): Shrinkable<number> {
           return new Shrinkable(69);
         }
-        withBias(): Arbitrary<number> {
+        withBias(freq: number): Arbitrary<number> {
+          if (typeof freq !== 'number' || freq < 2) {
+            throw new Error(`freq atribute must always be superior or equal to 2, got: ${freq}`);
+          }
           return new class extends Arbitrary<number> {
             generate(): Shrinkable<number> {
               return new Shrinkable(42);
@@ -106,6 +109,7 @@ describe('AsyncProperty', () => {
       }(),
       async () => {}
     );
+    assert.equal(p.generate(stubRng.mutable.nocall(), 0).value, 42);
     assert.equal(p.generate(stubRng.mutable.nocall(), 2).value, 42);
   });
 });
diff --git a/test/unit/check/property/Property.spec.ts b/test/unit/check/property/Property.spec.ts
@@ -106,7 +106,10 @@ describe('Property', () => {
         generate(): Shrinkable<number> {
           return new Shrinkable(69);
         }
-        withBias(): Arbitrary<number> {
+        withBias(freq: number): Arbitrary<number> {
+          if (typeof freq !== 'number' || freq < 2) {
+            throw new Error(`freq atribute must always be superior or equal to 2, got: ${freq}`);
+          }
           return new class extends Arbitrary<number> {
             generate(): Shrinkable<number> {
               return new Shrinkable(42);
@@ -116,6 +119,7 @@ describe('Property', () => {
       }(),
       () => {}
     );
+    assert.equal(p.generate(stubRng.mutable.nocall(), 0).value, 42);
     assert.equal(p.generate(stubRng.mutable.nocall(), 2).value, 42);
   });
 });
diff --git a/test/unit/check/property/UnbiasedProperty.spec.ts b/test/unit/check/property/UnbiasedProperty.spec.ts
@@ -9,11 +9,11 @@ import * as stubRng from '../../stubs/generators';
 
 describe('UnbiasedProperty', () => {
   it('Should forward parameters correctly (asynchronous property)', () => {
-    let calledWithFreq: number | undefined = undefined;
+    let calledWithRunId: number | undefined = undefined;
     const pAsync = new class implements IProperty<number> {
       isAsync = () => true;
-      generate = (mrng: any, freq?: number) => {
-        calledWithFreq = freq;
+      generate = (mrng: any, runId?: number) => {
+        calledWithRunId = runId;
         return new Shrinkable(42);
       };
       run = (v: number) => 'pAsync:' + v;
@@ -23,17 +23,17 @@ describe('UnbiasedProperty', () => {
 
     assert.equal(unbiasedAsyncProp.isAsync(), true);
     assert.equal(unbiasedAsyncProp.generate(stubRng.mutable.nocall()).value, 42);
-    assert.strictEqual(calledWithFreq, undefined);
+    assert.strictEqual(calledWithRunId, undefined);
     assert.equal(unbiasedAsyncProp.generate(stubRng.mutable.nocall(), 52).value, 42);
-    assert.strictEqual(calledWithFreq, undefined);
+    assert.strictEqual(calledWithRunId, undefined);
     assert.equal(unbiasedAsyncProp.run(47), 'pAsync:47');
   });
   it('Should forward parameters correctly (synchronous property)', () => {
-    let calledWithFreq: number | undefined = undefined;
+    let calledWithRunId: number | undefined = undefined;
     const pSync = new class implements IProperty<number> {
       isAsync = () => false;
-      generate = (mrng: any, freq?: number) => {
-        calledWithFreq = freq;
+      generate = (mrng: any, runId?: number) => {
+        calledWithRunId = runId;
         return new Shrinkable(48);
       };
       run = (v: number) => 'pSync:' + v;
@@ -43,9 +43,9 @@ describe('UnbiasedProperty', () => {
 
     assert.equal(unbiasedSyncProp.isAsync(), false);
     assert.equal(unbiasedSyncProp.generate(stubRng.mutable.nocall()).value, 48);
-    assert.strictEqual(calledWithFreq, undefined);
+    assert.strictEqual(calledWithRunId, undefined);
     assert.equal(unbiasedSyncProp.generate(stubRng.mutable.nocall(), 52).value, 48);
-    assert.strictEqual(calledWithFreq, undefined);
+    assert.strictEqual(calledWithRunId, undefined);
     assert.equal(unbiasedSyncProp.run(29), 'pSync:29');
   });
 });