Help biasing infinite stream of integers towards small values

[dball]

Hey, I'm writing a fast check to assert invariants of a graphql queries that implement the relay pagination spec. In so doing, I create an infinite stream of integers that will be the sizes of the pages I select as I walk the paginated collection. The max size of the generator is specified as the max allowed page size, which is good, I would like to sometimes sample that part of the domain, but the test corpus is often much smaller, which results in a single page request much of the time.

I think I'd like to bias my numbers towards smaller values, which has been the default behavior of other quick checkers I've used, but that doesn't seem to be the case for fc/integer. I see there is support for bias in the generators, but it's not clear how to control it. I might have expected an option on the fc/integer, the fc/asyncProperty, or within the params of fc/assert, but I don't see anything obvious. Any guidance or tips would be appreciated.

  const pageSizes = fc.infiniteStream(fc.nat({ max }));
  await fc.assert(
    fc.asyncProperty(pageSizes, async (pageSizes) => {
      await doAssertRelayPaginationInvariants(entity, client, pageSizes);
    }),
    fcParams,
  );

[dubzzz]

Hey,

Actually today the combination of fc.infiniteStream and fc.nat can be considered as biased as it generates much more small numbers than what it should if the values was taken fully randomly:

But the problem is that there is, at the moment, no bias all the values of this stream. In other words, in the current version of fast-check, while values produced by the generators of natural number can be biased from time to time, they are:

1. Never biased for some streams
2. Not biased for all entries

In the current versions the trick I'd suggest is to do something like:

fc.oneof(
  fc.infiniteStream(fc.nat({max: 10})),
  fc.infiniteStream(fc.nat())
)

[dubzzz]

You may also use something like:

const fc = require('fast-check')

class ExtremeBias extends fc.Arbitrary {
  constructor(arb) {
    super();
    this.arb = arb;
  }
  generate(mrng, biasFactor) {
    const appliedBiasFactor = biasFactor !== undefined && mrng.nextInt(1, biasFactor) === 1;
    if (appliedBiasFactor) {
      return this.arb.generate(mrng, 1); // always biased
    }
    return this.arb.generate(mrng, biasFactor);
  }
  canShrinkWithoutContext(value) {
    return this.arb.canShrinkWithoutContext(value);
  }
  shrink(value, context) {
    return this.arb.shrink(value, context);
  }
}
const extremeBiased = new ExtremeBias(fc.infiniteStream(fc.nat()));

fc.sample(extremeBiased, {numRuns: 10})
  .map(s => [...s.take(10)])

The only point to note is that bias for nat means: the smallest values but also the highest ones.

So while it produces some fully biased streams, bias does not mean close to 0 for nat.

You can see three categories of streams with that option:

• fully biased streams: all values are biased (yellow)
• partially biased streams: some values are (green)
• never biased streams: no bias on values (blue)

The more run you launch the higher the chance of green and blue.

[dball]

Thanks for the prompt and comprehensive reply! I had considered the multiple oneof option, though I don't love the fact that the split is then 50/50, it'd be nice to assign weights to the various options thereof.

I may wind up writing my own arbitrary along one of these lines. I appreciate your guidance!

[dubzzz]

oneof accepts weight if needed!

fc.oneof(
  fc.infiniteStream(fc.nat({max: 10})), // default to weight=1, can be overridden by using the same as the line below
  {arbitrary: fc.infiniteStream(fc.nat()), weight: 10}
)