How to use isStrictlySmallerArray method in fast-check-monorepo

Best JavaScript code snippet using fast-check-monorepo

commands.spec.ts

Source:commands.spec.ts

...200                // Run all commands of nextShrinkable201                simulateCommands(nextValue.value_);202                // Check nextShrinkable is strictly smaller than current one203                const nextItems = [...nextValue.value_].map((c) => +extractIdRegex.exec(c.toString())![1]);204                expect(isStrictlySmallerArray(nextItems, currentItems)).toBe(true);205                // Next is eligible for shrinking206                return nextValue;207              })208              .getNthOrLast(it.next().value);209          }210        }211      )212    );213  });214  it('should shrink the same way when based on replay data', () => {215    fc.assert(216      fc.property(217        fc.integer().noShrink(),218        fc.nat(100),...

array.spec.ts

Source:array.spec.ts

1import * as fc from 'fast-check';2import { array } from '../../../src/arbitrary/array';3import { FakeIntegerArbitrary, fakeArbitrary } from './__test-helpers__/ArbitraryHelpers';4import * as ArrayArbitraryMock from '../../../src/arbitrary/_internals/ArrayArbitrary';5import {6  assertProduceCorrectValues,7  assertProduceSameValueGivenSameSeed,8  assertProduceValuesShrinkableWithoutContext,9  assertShrinkProducesSameValueWithoutInitialContext,10  assertShrinkProducesStrictlySmallerValue,11} from './__test-helpers__/ArbitraryAssertions';12import { isStrictlySmallerArray } from './__test-helpers__/ArrayHelpers';13import { Value } from '../../../src/check/arbitrary/definition/Value';14import { buildShrinkTree, renderTree } from './__test-helpers__/ShrinkTree';15import { sizeRelatedGlobalConfigArb } from './__test-helpers__/SizeHelpers';16import { withConfiguredGlobal } from './__test-helpers__/GlobalSettingsHelpers';17function beforeEachHook() {18  jest.resetModules();19  jest.restoreAllMocks();20  fc.configureGlobal({ beforeEach: beforeEachHook });21}22beforeEach(beforeEachHook);23describe('array', () => {24  it('should instantiate ArrayArbitrary(arb, 0, ?, 0x7fffffff, n.a) for array(arb)', () => {25    fc.assert(26      fc.property(sizeRelatedGlobalConfigArb, (config) => {27        // Arrange28        const { instance: childInstance } = fakeArbitrary<unknown>();29        const { instance } = fakeArbitrary<unknown[]>();30        const ArrayArbitrary = jest.spyOn(ArrayArbitraryMock, 'ArrayArbitrary');31        ArrayArbitrary.mockImplementation(() => instance as ArrayArbitraryMock.ArrayArbitrary<unknown>);32        // Act33        const arb = withConfiguredGlobal(config, () => array(childInstance));34        // Assert35        expect(ArrayArbitrary).toHaveBeenCalledWith(36          childInstance,37          0,38          expect.any(Number),39          0x7fffffff,40          undefined,41          undefined,42          []43        );44        const receivedGeneratedMaxLength = ArrayArbitrary.mock.calls[0][2]; // Expecting the real value would check an implementation detail45        expect(receivedGeneratedMaxLength).toBeGreaterThan(0);46        expect(receivedGeneratedMaxLength).toBeLessThanOrEqual(2 ** 31 - 1);47        expect(Number.isInteger(receivedGeneratedMaxLength)).toBe(true);48        expect(arb).toBe(instance);49      })50    );51  });52  it('should instantiate ArrayArbitrary(arb, 0, ?, maxLength, n.a) for array(arb, {maxLength})', () => {53    fc.assert(54      fc.property(sizeRelatedGlobalConfigArb, fc.nat({ max: 2 ** 31 - 1 }), (config, maxLength) => {55        // Arrange56        const { instance: childInstance } = fakeArbitrary<unknown>();57        const { instance } = fakeArbitrary<unknown[]>();58        const ArrayArbitrary = jest.spyOn(ArrayArbitraryMock, 'ArrayArbitrary');59        ArrayArbitrary.mockImplementation(() => instance as ArrayArbitraryMock.ArrayArbitrary<unknown>);60        // Act61        const arb = withConfiguredGlobal(config, () => array(childInstance, { maxLength }));62        // Assert63        expect(ArrayArbitrary).toHaveBeenCalledWith(64          childInstance,65          0,66          expect.any(Number),67          maxLength,68          undefined,69          undefined,70          []71        );72        const receivedGeneratedMaxLength = ArrayArbitrary.mock.calls[0][2]; // Expecting the real value would check an implementation detail73        expect(receivedGeneratedMaxLength).toBeGreaterThanOrEqual(0);74        expect(receivedGeneratedMaxLength).toBeLessThanOrEqual(maxLength);75        expect(Number.isInteger(receivedGeneratedMaxLength)).toBe(true);76        if (config.defaultSizeToMaxWhenMaxSpecified) {77          expect(ArrayArbitrary).toHaveBeenCalledWith(childInstance, 0, maxLength, maxLength, undefined, undefined, []);78        }79        expect(arb).toBe(instance);80      })81    );82  });83  it('should instantiate ArrayArbitrary(arb, minLength, ?, 0x7fffffff, n.a) for array(arb, {minLength})', () => {84    fc.assert(85      fc.property(sizeRelatedGlobalConfigArb, fc.nat({ max: 2 ** 31 - 1 }), (config, minLength) => {86        // Arrange87        const { instance: childInstance } = fakeArbitrary<unknown>();88        const { instance } = fakeArbitrary<unknown[]>();89        const ArrayArbitrary = jest.spyOn(ArrayArbitraryMock, 'ArrayArbitrary');90        ArrayArbitrary.mockImplementation(() => instance as ArrayArbitraryMock.ArrayArbitrary<unknown>);91        // Act92        const arb = withConfiguredGlobal(config, () => array(childInstance, { minLength }));93        // Assert94        expect(ArrayArbitrary).toHaveBeenCalledWith(95          childInstance,96          minLength,97          expect.any(Number),98          0x7fffffff,99          undefined,100          undefined,101          []102        );103        const receivedGeneratedMaxLength = ArrayArbitrary.mock.calls[0][2]; // Expecting the real value would check an implementation detail104        if (minLength !== 2 ** 31 - 1) {105          expect(receivedGeneratedMaxLength).toBeGreaterThan(minLength);106          expect(receivedGeneratedMaxLength).toBeLessThanOrEqual(2 ** 31 - 1);107          expect(Number.isInteger(receivedGeneratedMaxLength)).toBe(true);108        } else {109          expect(receivedGeneratedMaxLength).toEqual(minLength);110        }111        expect(arb).toBe(instance);112      })113    );114  });115  it('should instantiate ArrayArbitrary(arb, minLength, ?, maxLength, n.a) for array(arb, {minLength,maxLength})', () => {116    fc.assert(117      fc.property(118        sizeRelatedGlobalConfigArb,119        fc.nat({ max: 2 ** 31 - 1 }),120        fc.nat({ max: 2 ** 31 - 1 }),121        (config, aLength, bLength) => {122          // Arrange123          const [minLength, maxLength] = aLength < bLength ? [aLength, bLength] : [bLength, aLength];124          const { instance: childInstance } = fakeArbitrary<unknown>();125          const { instance } = fakeArbitrary<unknown[]>();126          const ArrayArbitrary = jest.spyOn(ArrayArbitraryMock, 'ArrayArbitrary');127          ArrayArbitrary.mockImplementation(() => instance as ArrayArbitraryMock.ArrayArbitrary<unknown>);128          // Act129          const arb = withConfiguredGlobal(config, () => array(childInstance, { minLength, maxLength }));130          // Assert131          expect(ArrayArbitrary).toHaveBeenCalledWith(132            childInstance,133            minLength,134            expect.any(Number),135            maxLength,136            undefined,137            undefined,138            []139          );140          const receivedGeneratedMaxLength = ArrayArbitrary.mock.calls[0][2]; // Expecting the real value would check an implementation detail141          expect(receivedGeneratedMaxLength).toBeGreaterThanOrEqual(minLength);142          expect(receivedGeneratedMaxLength).toBeLessThanOrEqual(maxLength);143          expect(Number.isInteger(receivedGeneratedMaxLength)).toBe(true);144          if (config.defaultSizeToMaxWhenMaxSpecified) {145            expect(ArrayArbitrary).toHaveBeenCalledWith(146              childInstance,147              minLength,148              maxLength,149              maxLength,150              undefined,151              undefined,152              []153            );154          }155          expect(arb).toBe(instance);156        }157      )158    );159  });160  it('should instantiate ArrayArbitrary(arb, minLength, ?, maxLength, identifier) for array(arb, {minLength,maxLength, depthIdentifier})', () => {161    fc.assert(162      fc.property(163        sizeRelatedGlobalConfigArb,164        fc.nat({ max: 2 ** 31 - 1 }),165        fc.nat({ max: 2 ** 31 - 1 }),166        fc.string(),167        (config, aLength, bLength, depthIdentifier) => {168          // Arrange169          const [minLength, maxLength] = aLength < bLength ? [aLength, bLength] : [bLength, aLength];170          const { instance: childInstance } = fakeArbitrary<unknown>();171          const { instance } = fakeArbitrary<unknown[]>();172          const ArrayArbitrary = jest.spyOn(ArrayArbitraryMock, 'ArrayArbitrary');173          ArrayArbitrary.mockImplementation(() => instance as ArrayArbitraryMock.ArrayArbitrary<unknown>);174          // Act175          const arb = withConfiguredGlobal(config, () =>176            array(childInstance, { minLength, maxLength, depthIdentifier })177          );178          // Assert179          expect(ArrayArbitrary).toHaveBeenCalledWith(180            childInstance,181            minLength,182            expect.any(Number),183            maxLength,184            depthIdentifier,185            undefined,186            []187          );188          const receivedGeneratedMaxLength = ArrayArbitrary.mock.calls[0][2]; // Expecting the real value would check an implementation detail189          expect(receivedGeneratedMaxLength).toBeGreaterThanOrEqual(minLength);190          expect(receivedGeneratedMaxLength).toBeLessThanOrEqual(maxLength);191          expect(Number.isInteger(receivedGeneratedMaxLength)).toBe(true);192          if (config.defaultSizeToMaxWhenMaxSpecified) {193            expect(ArrayArbitrary).toHaveBeenCalledWith(194              childInstance,195              minLength,196              maxLength,197              maxLength,198              depthIdentifier,199              undefined,200              []201            );202          }203          expect(arb).toBe(instance);204        }205      )206    );207  });208  it('should throw when minimum length is greater than maximum one', () => {209    fc.assert(210      fc.property(211        sizeRelatedGlobalConfigArb,212        fc.nat({ max: 2 ** 31 - 1 }),213        fc.nat({ max: 2 ** 31 - 1 }),214        (config, aLength, bLength) => {215          // Arrange216          fc.pre(aLength !== bLength);217          const [minLength, maxLength] = aLength < bLength ? [bLength, aLength] : [aLength, bLength];218          const { instance: childInstance } = fakeArbitrary<unknown>();219          // Act / Assert220          expect(() =>221            withConfiguredGlobal(config, () => array(childInstance, { minLength, maxLength }))222          ).toThrowError();223        }224      )225    );226  });227});228describe('array (integration)', () => {229  type Extra = { minLength?: number; maxLength?: number };230  const extraParameters: fc.Arbitrary<Extra> = fc231    .tuple(fc.nat({ max: 5 }), fc.nat({ max: 30 }), fc.boolean(), fc.boolean())232    .map(([min, gap, withMin, withMax]) => ({233      minLength: withMin ? min : undefined,234      maxLength: withMax ? min + gap : undefined,235    }));236  const isCorrect = (value: number[], extra: Extra) => {237    if (extra.minLength !== undefined) {238      expect(value.length).toBeGreaterThanOrEqual(extra.minLength);239    }240    if (extra.maxLength !== undefined) {241      expect(value.length).toBeLessThanOrEqual(extra.maxLength);242    }243    for (const v of value) {244      expect(typeof v).toBe('number');245    }246  };247  const isStrictlySmaller = isStrictlySmallerArray;248  const arrayBuilder = (extra: Extra) => array(new FakeIntegerArbitrary(), extra);249  it('should produce the same values given the same seed', () => {250    assertProduceSameValueGivenSameSeed(arrayBuilder, { extraParameters });251  });252  it('should only produce correct values', () => {253    assertProduceCorrectValues(arrayBuilder, isCorrect, { extraParameters });254  });255  it('should produce values seen as shrinkable without any context', () => {256    assertProduceValuesShrinkableWithoutContext(arrayBuilder, { extraParameters });257  });258  it('should be able to shrink to the same values without initial context', () => {259    assertShrinkProducesSameValueWithoutInitialContext(arrayBuilder, { extraParameters });260  });261  it('should preserve strictly smaller ordering in shrink', () => {262    assertShrinkProducesStrictlySmallerValue(arrayBuilder, isStrictlySmaller, { extraParameters });263  });264  it.each`265    rawValue                 | minLength266    ${[2, 4, 8, 16, 32, 64]} | ${undefined}267    ${[2, 4, 8]}             | ${undefined}268    ${[2, 4, 8]}             | ${2}269    ${[2, 4, 8]}             | ${3}270  `('should be able to shrink $rawValue given constraints minLength:$minLength', ({ rawValue, minLength }) => {271    // Arrange272    const constraints = { minLength };273    const arb = array(new FakeIntegerArbitrary(0, 1000), constraints);274    const value = new Value(rawValue, undefined);275    // Act276    const renderedTree = renderTree(buildShrinkTree(arb, value, { numItems: 100 })).join('\n');277    // Assert278    expect(arb.canShrinkWithoutContext(rawValue)).toBe(true);279    expect(renderedTree).toMatchSnapshot();280  });...

ArrayHelpers.ts

Source:ArrayHelpers.ts

1export const isStrictlySmallerArray = (arr1: number[], arr2: number[]): boolean => {2  if (arr1.length > arr2.length) return false;3  if (arr1.length === arr2.length) {4    return arr1.every((v, idx) => arr1[idx] <= arr2[idx]) && arr1.find((v, idx) => arr1[idx] < arr2[idx]) != null;5  }6  for (let idx1 = 0, idx2 = 0; idx1 < arr1.length && idx2 < arr2.length; ++idx1, ++idx2) {7    while (idx2 < arr2.length && arr1[idx1] > arr2[idx2]) ++idx2;8    if (idx2 === arr2.length) return false;9  }10  return true;...

Using AI Code Generation

1const { isStrictlySmallerArray } = require('fast-check');2const array1 = [1, 2, 3];3const array2 = [1, 2, 3, 4];4const array3 = [1, 2, 3, 4];5const { isStrictlySmallerArray } = require('fast-check');6const array1 = [1, 2, 3];7const array2 = [1, 2, 3, 4];8const array3 = [1, 2, 3, 4];9const { isStrictlySmallerArray } = require('fast-check');10const array1 = [1, 2, 3];11const array2 = [1, 2, 3, 4];12const array3 = [1, 2, 3, 4];13const { isStrictlySmallerArray } = require('fast-check');14const array1 = [1, 2, 3];

Using AI Code Generation

1const fc = require("fast-check");2const { isStrictlySmallerArray } = require("fast-check/lib/check/arbitrary/definition/ArrayArbitrary.js");3const a1 = [1, 2, 3];4const a2 = [1, 2, 3, 4];5const a3 = [1, 2, 3, 5];6const a4 = [1, 2, 3, 5, 6];

Using AI Code Generation

1const {isStrictlySmallerArray} = require('fast-check-monorepo');2const array1 = [1,2];3const array2 = [1,2,3];4const array3 = [1,2,3,4];5const array4 = [1,2,3];6const array5 = [1];7const array6 = [1,2];8const array7 = [];9const array8 = [1];10const array9 = [];11const array10 = [];12const array11 = ["a","b"];13const array12 = ["a","b","c"];14const array13 = ["a","b"];15const array14 = ["a","b","c"];16const array15 = ["a","b","c"];17const array16 = ["a","b","c"];18const array17 = ["a","b"];19const array18 = ["a","b","c"];20const array19 = ["a","b"];21const array20 = ["a","b","c"];22const array21 = ["a","b","c"];23const array22 = ["a","b","c"];

Using AI Code Generation

1const fc = require('fast-check');2const {isStrictlySmallerArray} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');3const {isStrictlySmaller} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');4const {isStrictlySmallerArray} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');5const {isStrictlySmaller} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');6const {isStrictlySmallerArray} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');7const {isStrictlySmaller} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');8const {isStrictlySmallerArray} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');9const {isStrictlySmaller} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');10const {isStrictlySmallerArray} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');11const {isStrictlySmaller} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');12const {isStrictlySmallerArray} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');13const {isStrictlySmaller} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');14const {isStrictlySmallerArray} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');15const {isStrictlySmaller} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');16const {isStrictlySmallerArray} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');17const {isStrictlySmaller} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');18const {isStrictlySmallerArray} = require('fast-check-monorepo/packages/arbitrary-array/src/ArrayArbitrary.ts');19const {

Using AI Code Generation

1const fc = require("fast-check");2const arbs = require("fast-check-monorepo");3const array1 = [1, 2, 3, 4];4const array2 = [1, 2, 3, 4];5const array3 = [1, 2, 3, 4, 5];6const array4 = [1, 2, 3, 5];7const array5 = [1, 2, 3, 4, 5, 6];8const array6 = [1, 2, 3, 4, 6];9const array7 = [1, 2, 3, 4, 5, 6, 7];10const array8 = [1, 2, 3, 4, 5, 6, 8];11const array9 = [1, 2, 3, 4, 5, 6, 7, 8];12const array10 = [1, 2, 3, 4, 5, 6, 7, 9];13const array11 = [1, 2, 3, 4, 5, 6, 7, 8, 9];14const array12 = [1, 2, 3, 4, 5, 6, 7, 8, 10];15const array13 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];16const array14 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 11];17const array15 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.