fast-check/lib/check/arbitrary/definition/Arbitrary.js

Property based testing framework for JavaScript (like QuickCheck)

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Arbitrary = void 0;
const Shrinkable_1 = require("./Shrinkable");
class Arbitrary {
    filter(refinement) {
        const arb = this;
        const refinementOnShrinkable = (s) => {
            return refinement(s.value);
        };
        return new (class extends Arbitrary {
            generate(mrng) {
                let g = arb.generate(mrng);
                while (!refinementOnShrinkable(g)) {
                    g = arb.generate(mrng);
                }
                return g.filter(refinement);
            }
            withBias(freq) {
                return arb.withBias(freq).filter(refinement);
            }
        })();
    }
    map(mapper) {
        const arb = this;
        return new (class extends Arbitrary {
            generate(mrng) {
                return arb.generate(mrng).map(mapper);
            }
            withBias(freq) {
                return arb.withBias(freq).map(mapper);
            }
        })();
    }
    static shrinkChain(mrng, src, dst, fmapper) {
        return new Shrinkable_1.Shrinkable(dst.value, () => src
            .shrink()
            .map((v) => Arbitrary.shrinkChain(mrng.clone(), v, fmapper(v.value).generate(mrng.clone()), fmapper))
            .join(dst.shrink()));
    }
    chain(fmapper) {
        const arb = this;
        return new (class extends Arbitrary {
            generate(mrng) {
                const clonedMrng = mrng.clone();
                const src = arb.generate(mrng);
                const dst = fmapper(src.value).generate(mrng);
                return Arbitrary.shrinkChain(clonedMrng, src, dst, fmapper);
            }
            withBias(freq) {
                return arb.withBias(freq).chain((t) => fmapper(t).withBias(freq));
            }
        })();
    }
    noShrink() {
        const arb = this;
        return new (class extends Arbitrary {
            generate(mrng) {
                return new Shrinkable_1.Shrinkable(arb.generate(mrng).value);
            }
            withBias(freq) {
                return arb.withBias(freq).noShrink();
            }
        })();
    }
    withBias(_freq) {
        return this;
    }
    noBias() {
        const arb = this;
        return new (class extends Arbitrary {
            generate(mrng) {
                return arb.generate(mrng);
            }
        })();
    }
}
exports.Arbitrary = Arbitrary;