Generating data that depends on other data?

[bertrand-caron]

Let's say I am trying to test a method that works on arrays. To do so, I want to generate random arrays, and then generate random valid indices within that array. I have tried the following, which produces indices outside the bounds of the array.

import fc from "fast-check"

const arrayArbitrary = fc.array(fc.nat({ max: 100 }), { minLength: 2 })
// Arbitrary to generate a random index of the above array
const randomArrayIndexArbitrary = arrayArbitrary.chain((array) =>
  fc.integer({ min: 0, max: array.length - 1 }),
)

it("Can generate indices within the array bounds", () => {
  fc.assert(
    fc.property(
      arrayArbitrary,
      randomArrayIndexArbitrary,
      randomArrayIndexArbitrary,
      (array, i1, i2) => {
        expect(i1).toBeLessThan(array.length)
        expect(i2).toBeLessThan(array.length)
      },
    ),
  )
})

Am I missing something?

I could easily filter the values with fc.pre(...) but that seems like a hack.

[dubzzz]

Actually your code is chaining arrays not corresponding to the variable array. If you want i1 and i2 to be made of indices from that instance you could rewrite it that way:

import fc from "fast-check"

const arrayArbitrary = fc.array(fc.nat({ max: 100 }), { minLength: 2 })

it("Can generate indices within the array bounds", () => {
  fc.assert(
    fc.property(
      arrayArbitrary.chain((array) => fc.record({
        array: fc.constant(array), // edited after comment
        i1: fc.integer({ min: 0, max: array.length - 1 }),
        i2: fc.integer({ min: 0, max: array.length - 1 }),
      })),
      ({array, i1, i2}) => {
        expect(i1).toBeLessThan(array.length)
        expect(i2).toBeLessThan(array.length)
      },
    ),
  )
})

[dubzzz]

Another technique would be to write something like:

import fc from "fast-check"

const arrayArbitrary = fc.array(fc.nat({ max: 100 }), { minLength: 2 })

it("Can generate indices within the array bounds", () => {
  fc.assert(
    fc.property(
      arrayArbitrary,
      fc.nat(),
      fc.nat(),
      (array, i1Raw, i2Raw) => {
        const i1 = i1Raw % array.length;
        const i2 = i2Raw % array.length;
        expect(i1).toBeLessThan(array.length)
        expect(i2).toBeLessThan(array.length)
      },
    ),
  )
})

I just delayed the computation of index for later.

[bertrand-caron]

Thanks, that is extremely useful! I personally prefer Option 1, but can you comment on the performance implications of both solutions?

[bertrand-caron]

Actually, for Option 1, did you mean to use array: fc.constant(array) instead of array like this?

TS wouldn't let me return the array.

import fc from "fast-check"

const arrayArbitrary = fc.array(fc.nat({ max: 100 }), { minLength: 2 })

it("Can generate indices within the array bounds", () => {
  fc.assert(
    fc.property(
      arrayArbitrary.chain((array) => fc.record({
        array: fc.constant(array),
        i1: fc.integer({ min: 0, max: array.length - 1 }),
        i2: fc.integer({ min: 0, max: array.length - 1 }),
      })),
      ({array, i1, i2}) => {
        expect(i1).toBeLessThan(array.length)
        expect(i2).toBeLessThan(array.length)
      },
    ),
  )
})

[gruhn]

A problem with chain is that it yields sub-optimal shrinking. So the general advice is to avoid it when possible. Here is another chain-less approach, that you might like better. You can generate the items before and after the index separately and then derive the actual index:

  fc.assert(
    fc.property(
      fc.array(fc.nat()),
      fc.nat(),
      fc.array(fc.nat()),
      (itemsBefore, itemThatTheIndexPointsTo, itemsAfter) => {
          const randomArray = [ ...itemsBefore, itemThatTheIndexPointsTo, ...itemsAfter ]
          const randomIndex = itemsBefore.length
          // ...
      },
    ),
  )