How to use indexForNaN method in fast-check-monorepo

Best JavaScript code snippet using fast-check-monorepo

double.spec.ts

Source:double.spec.ts

1import * as fc from 'fast-check';2import { double, DoubleConstraints } from '../../../src/arbitrary/double';3import {4  add64,5  ArrayInt64,6  isEqual64,7  substract64,8  Unit64,9} from '../../../src/arbitrary/_internals/helpers/ArrayInt64';10import {11  defaultDoubleRecordConstraints,12  doubleConstraints,13  float64raw,14  isStrictlySmaller,15} from './__test-helpers__/FloatingPointHelpers';16import { doubleToIndex, indexToDouble } from '../../../src/arbitrary/_internals/helpers/DoubleHelpers';17import { fakeArbitrary, fakeArbitraryStaticValue } from './__test-helpers__/ArbitraryHelpers';18import { fakeRandom } from './__test-helpers__/RandomHelpers';19import {20  assertProduceCorrectValues,21  assertShrinkProducesStrictlySmallerValue,22  assertProduceSameValueGivenSameSeed,23  assertProduceValuesShrinkableWithoutContext,24  assertShrinkProducesSameValueWithoutInitialContext,25} from './__test-helpers__/ArbitraryAssertions';26import * as ArrayInt64ArbitraryMock from '../../../src/arbitrary/_internals/ArrayInt64Arbitrary';27function beforeEachHook() {28  jest.resetModules();29  jest.restoreAllMocks();30}31beforeEach(beforeEachHook);32fc.configureGlobal({33  ...fc.readConfigureGlobal(),34  beforeEach: beforeEachHook,35});36describe('double', () => {37  it('should accept any valid range of floating point numbers (including infinity)', () => {38    fc.assert(39      fc.property(doubleConstraints(), (ct) => {40        // Arrange41        spyArrayInt64();42        // Act43        const arb = double(ct);44        // Assert45        expect(arb).toBeDefined();46      })47    );48  });49  it('should accept any constraits defining min (not-NaN) equal to max', () => {50    fc.assert(51      fc.property(52        float64raw(),53        fc.record({ noDefaultInfinity: fc.boolean(), noNaN: fc.boolean() }, { withDeletedKeys: true }),54        (f, otherCt) => {55          // Arrange56          fc.pre(!Number.isNaN(f));57          spyArrayInt64();58          // Act59          const arb = double({ ...otherCt, min: f, max: f });60          // Assert61          expect(arb).toBeDefined();62        }63      )64    );65  });66  it('should reject NaN if specified for min', () => {67    // Arrange68    const arrayInt64 = spyArrayInt64();69    // Act / Assert70    expect(() => double({ min: Number.NaN })).toThrowError();71    expect(arrayInt64).not.toHaveBeenCalled();72  });73  it('should reject NaN if specified for max', () => {74    // Arrange75    const arrayInt64 = spyArrayInt64();76    // Act / Assert77    expect(() => double({ max: Number.NaN })).toThrowError();78    expect(arrayInt64).not.toHaveBeenCalled();79  });80  it('should reject if specified min is strictly greater than max', () => {81    fc.assert(82      fc.property(float64raw(), float64raw(), (da, db) => {83        // Arrange84        fc.pre(!Number.isNaN(da));85        fc.pre(!Number.isNaN(db));86        fc.pre(!Object.is(da, db)); // Object.is can distinguish -0 from 0, while !== cannot87        const arrayInt64 = spyArrayInt64();88        const min = isStrictlySmaller(da, db) ? db : da;89        const max = isStrictlySmaller(da, db) ? da : db;90        // Act / Assert91        expect(() => double({ min, max })).toThrowError();92        expect(arrayInt64).not.toHaveBeenCalled();93      })94    );95  });96  it('should reject impossible noDefaultInfinity-based ranges', () => {97    // Arrange98    const arrayInt64 = spyArrayInt64();99    // Act / Assert100    expect(() => double({ min: Number.POSITIVE_INFINITY, noDefaultInfinity: true })).toThrowError();101    expect(() => double({ max: Number.NEGATIVE_INFINITY, noDefaultInfinity: true })).toThrowError();102    expect(arrayInt64).not.toHaveBeenCalled();103  });104  if (typeof BigInt !== 'undefined') {105    it('should properly convert integer value for index between min and max into its associated float value', () => {106      fc.assert(107        fc.property(108          fc.option(doubleConstraints(), { nil: undefined }),109          fc.bigUintN(64),110          fc.option(fc.integer({ min: 2 }), { nil: undefined }),111          (ct, mod, biasFactor) => {112            // Arrange113            const { instance: mrng } = fakeRandom();114            const { min, max } = minMaxForConstraints(ct || {});115            const minIndex = doubleToIndex(min);116            const maxIndex = doubleToIndex(max);117            const arbitraryGeneratedIndex = toIndex(118              (mod % (toBigInt(maxIndex) - toBigInt(minIndex) + BigInt(1))) + toBigInt(minIndex)119            );120            spyArrayInt64WithValue(() => arbitraryGeneratedIndex);121            // Act122            const arb = double(ct);123            const { value_: f } = arb.generate(mrng, biasFactor);124            // Assert125            expect(f).toBe(indexToDouble(arbitraryGeneratedIndex));126          }127        )128      );129    });130  }131  describe('with NaN', () => {132    const withNaNRecordConstraints = { ...defaultDoubleRecordConstraints, noNaN: fc.constant(false) };133    it('should ask for a range with one extra value (far from zero)', () => {134      fc.assert(135        fc.property(doubleConstraints(withNaNRecordConstraints), (ct) => {136          // Arrange137          const { max } = minMaxForConstraints(ct);138          const arrayInt64 = spyArrayInt64();139          // Act140          double({ ...ct, noNaN: true });141          double(ct);142          // Assert143          expect(arrayInt64).toHaveBeenCalledTimes(2);144          const constraintsNoNaN = arrayInt64.mock.calls[0];145          const constraintsWithNaN = arrayInt64.mock.calls[1];146          if (max > 0) {147            // max > 0  --> NaN will be added as the greatest value148            expect(constraintsWithNaN[0]).toEqual(constraintsNoNaN[0]);149            expect(constraintsWithNaN[1]).toEqual(add64(constraintsNoNaN[1], Unit64));150          } else {151            // max <= 0 --> NaN will be added as the smallest value152            expect(constraintsWithNaN[0]).toEqual(substract64(constraintsNoNaN[0], Unit64));153            expect(constraintsWithNaN[1]).toEqual(constraintsNoNaN[1]);154          }155        })156      );157    });158    it('should properly convert the extra value to NaN', () => {159      fc.assert(160        fc.property(161          doubleConstraints(withNaNRecordConstraints),162          fc.option(fc.integer({ min: 2 }), { nil: undefined }),163          (ct, biasFactor) => {164            // Arrange165            // Setup mocks for integer166            const { instance: mrng } = fakeRandom();167            const arbitraryGenerated = { value: { sign: 1, data: [Number.NaN, Number.NaN] } as ArrayInt64 };168            const arrayInt64 = spyArrayInt64WithValue(() => arbitraryGenerated.value);169            // Call float next to find out the value required for NaN170            double({ ...ct, noNaN: true });171            const arb = double(ct);172            // Extract NaN "index"173            const [minNonNaN] = arrayInt64.mock.calls[0];174            const [minNaN, maxNaN] = arrayInt64.mock.calls[1];175            const indexForNaN = !isEqual64(minNonNaN, minNaN) ? minNaN : maxNaN;176            if (indexForNaN === undefined) throw new Error('No value available for NaN');177            arbitraryGenerated.value = indexForNaN;178            // Act179            const { value_: f } = arb.generate(mrng, biasFactor);180            // Assert181            expect(f).toBe(Number.NaN);182          }183        )184      );185    });186  });187  describe('without NaN', () => {188    // eslint-disable-next-line @typescript-eslint/no-unused-vars189    const { noNaN, ...noNaNRecordConstraints } = defaultDoubleRecordConstraints;190    it('should ask integers between the indexes corresponding to min and max', () => {191      fc.assert(192        fc.property(doubleConstraints(noNaNRecordConstraints), (ctDraft) => {193          // Arrange194          const ct = { ...ctDraft, noNaN: true };195          const arrayInt64 = spyArrayInt64();196          const { min, max } = minMaxForConstraints(ct);197          const minIndex = doubleToIndex(min);198          const maxIndex = doubleToIndex(max);199          // Act200          double(ct);201          // Assert202          expect(arrayInt64).toHaveBeenCalledTimes(1);203          expect(arrayInt64).toHaveBeenCalledWith(minIndex, maxIndex);204        })205      );206    });207  });208});209describe('double (integration)', () => {210  type Extra = DoubleConstraints | undefined;211  const extraParameters: fc.Arbitrary<Extra> = fc.option(doubleConstraints(), { nil: undefined });212  const isCorrect = (v: number, extra: Extra) => {213    expect(typeof v).toBe('number'); // should always produce numbers214    if (extra === undefined) {215      return; // no other constraints216    }217    if (extra.noNaN) {218      expect(v).not.toBe(Number.NaN); // should not produce NaN if explicitely asked not too219    }220    if (extra.min !== undefined && !Number.isNaN(v)) {221      expect(v).toBeGreaterThanOrEqual(extra.min); // should always be greater than min when specified222    }223    if (extra.max !== undefined && !Number.isNaN(v)) {224      expect(v).toBeLessThanOrEqual(extra.max); // should always be smaller than max when specified225    }226    if (extra.noDefaultInfinity) {227      if (extra.min === undefined) {228        expect(v).not.toBe(Number.NEGATIVE_INFINITY); // should not produce -infinity when noInfinity and min unset229      }230      if (extra.max === undefined) {231        expect(v).not.toBe(Number.POSITIVE_INFINITY); // should not produce +infinity when noInfinity and max unset232      }233    }234  };235  const isStrictlySmaller = (fa: number, fb: number) =>236    Math.abs(fa) < Math.abs(fb) || //              Case 1: abs(a) < abs(b)237    (Object.is(fa, +0) && Object.is(fb, -0)) || // Case 2: +0 < -0  --> we shrink from -0 to +0238    (!Number.isNaN(fa) && Number.isNaN(fb)); //    Case 3: notNaN < NaN, NaN is one of the extreme values239  const doubleBuilder = (extra: Extra) => double(extra);240  it('should produce the same values given the same seed', () => {241    assertProduceSameValueGivenSameSeed(doubleBuilder, { extraParameters });242  });243  it('should only produce correct values', () => {244    assertProduceCorrectValues(doubleBuilder, isCorrect, { extraParameters });245  });246  it('should produce values seen as shrinkable without any context', () => {247    assertProduceValuesShrinkableWithoutContext(doubleBuilder, { extraParameters });248  });249  it('should be able to shrink to the same values without initial context', () => {250    assertShrinkProducesSameValueWithoutInitialContext(doubleBuilder, { extraParameters });251  });252  it('should preserve strictly smaller ordering in shrink', () => {253    assertShrinkProducesStrictlySmallerValue(doubleBuilder, isStrictlySmaller, { extraParameters });254  });255});256// Helpers257type Index = ReturnType<typeof doubleToIndex>;258function toIndex(raw: bigint | string): Index {259  const b = typeof raw === 'string' ? BigInt(raw) : raw;260  const pb = b < BigInt(0) ? -b : b;261  return { sign: b < BigInt(0) ? -1 : 1, data: [Number(pb >> BigInt(32)), Number(pb & BigInt(0xffffffff))] };262}263function toBigInt(index: Index): bigint {264  return BigInt(index.sign) * ((BigInt(index.data[0]) << BigInt(32)) + BigInt(index.data[1]));265}266function minMaxForConstraints(ct: DoubleConstraints) {267  const noDefaultInfinity = ct.noDefaultInfinity;268  const {269    min = noDefaultInfinity ? -Number.MAX_VALUE : Number.NEGATIVE_INFINITY,270    max = noDefaultInfinity ? Number.MAX_VALUE : Number.POSITIVE_INFINITY,271  } = ct;272  return { min, max };273}274function spyArrayInt64() {275  const { instance, map } = fakeArbitrary<ArrayInt64>();276  const { instance: mappedInstance } = fakeArbitrary();277  const arrayInt64 = jest.spyOn(ArrayInt64ArbitraryMock, 'arrayInt64');278  arrayInt64.mockReturnValue(instance);279  map.mockReturnValue(mappedInstance);280  return arrayInt64;281}282function spyArrayInt64WithValue(value: () => ArrayInt64) {283  const { instance } = fakeArbitraryStaticValue<ArrayInt64>(value);284  const integer = jest.spyOn(ArrayInt64ArbitraryMock, 'arrayInt64');285  integer.mockReturnValue(instance);286  return integer;...

float.spec.ts

Source:float.spec.ts

1import * as fc from 'fast-check';2import { float, FloatConstraints } from '../../../src/arbitrary/float';3import {4  floatConstraints,5  float32raw,6  isNotNaN32bits,7  float64raw,8  isStrictlySmaller,9  defaultFloatRecordConstraints,10  is32bits,11} from './__test-helpers__/FloatingPointHelpers';12import { floatToIndex, indexToFloat, MAX_VALUE_32 } from '../../../src/arbitrary/_internals/helpers/FloatHelpers';13import { fakeArbitrary, fakeArbitraryStaticValue } from './__test-helpers__/ArbitraryHelpers';14import { fakeRandom } from './__test-helpers__/RandomHelpers';15import {16  assertProduceCorrectValues,17  assertShrinkProducesStrictlySmallerValue,18  assertProduceSameValueGivenSameSeed,19  assertProduceValuesShrinkableWithoutContext,20  assertShrinkProducesSameValueWithoutInitialContext,21} from './__test-helpers__/ArbitraryAssertions';22import * as IntegerMock from '../../../src/arbitrary/integer';23function beforeEachHook() {24  jest.resetModules();25  jest.restoreAllMocks();26}27beforeEach(beforeEachHook);28fc.configureGlobal({29  ...fc.readConfigureGlobal(),30  beforeEach: beforeEachHook,31});32function minMaxForConstraints(ct: FloatConstraints) {33  const noDefaultInfinity = ct.noDefaultInfinity;34  const {35    min = noDefaultInfinity ? -MAX_VALUE_32 : Number.NEGATIVE_INFINITY,36    max = noDefaultInfinity ? MAX_VALUE_32 : Number.POSITIVE_INFINITY,37  } = ct;38  return { min, max };39}40describe('float', () => {41  it('should accept any valid range of 32-bit floating point numbers (including infinity)', () => {42    fc.assert(43      fc.property(floatConstraints(), (ct) => {44        // Arrange45        spyInteger();46        // Act47        const arb = float(ct);48        // Assert49        expect(arb).toBeDefined();50      })51    );52  });53  it('should accept any constraits defining min (32-bit float not-NaN) equal to max', () => {54    fc.assert(55      fc.property(56        float32raw(),57        fc.record({ noDefaultInfinity: fc.boolean(), noNaN: fc.boolean() }, { withDeletedKeys: true }),58        (f, otherCt) => {59          // Arrange60          fc.pre(isNotNaN32bits(f));61          spyInteger();62          // Act63          const arb = float({ ...otherCt, min: f, max: f });64          // Assert65          expect(arb).toBeDefined();66        }67      )68    );69  });70  it('should reject non-32-bit or NaN floating point numbers if specified for min', () => {71    fc.assert(72      fc.property(float64raw(), (f64) => {73        // Arrange74        fc.pre(!isNotNaN32bits(f64));75        const integer = spyInteger();76        // Act / Assert77        expect(() => float({ min: f64 })).toThrowError();78        expect(integer).not.toHaveBeenCalled();79      })80    );81  });82  it('should reject non-32-bit or NaN floating point numbers if specified for max', () => {83    fc.assert(84      fc.property(float64raw(), (f64) => {85        // Arrange86        fc.pre(!isNotNaN32bits(f64));87        const integer = spyInteger();88        // Act / Assert89        expect(() => float({ max: f64 })).toThrowError();90        expect(integer).not.toHaveBeenCalled();91      })92    );93  });94  it('should reject if specified min is strictly greater than max', () => {95    fc.assert(96      fc.property(float32raw(), float32raw(), (fa32, fb32) => {97        // Arrange98        fc.pre(isNotNaN32bits(fa32));99        fc.pre(isNotNaN32bits(fb32));100        fc.pre(!Object.is(fa32, fb32)); // Object.is can distinguish -0 from 0, while !== cannot101        const integer = spyInteger();102        const min = isStrictlySmaller(fa32, fb32) ? fb32 : fa32;103        const max = isStrictlySmaller(fa32, fb32) ? fa32 : fb32;104        // Act / Assert105        expect(() => float({ min, max })).toThrowError();106        expect(integer).not.toHaveBeenCalled();107      })108    );109  });110  it('should reject impossible noDefaultInfinity-based ranges', () => {111    // Arrange112    const integer = spyInteger();113    // Act / Assert114    expect(() => float({ min: Number.POSITIVE_INFINITY, noDefaultInfinity: true })).toThrowError();115    expect(() => float({ max: Number.NEGATIVE_INFINITY, noDefaultInfinity: true })).toThrowError();116    expect(integer).not.toHaveBeenCalled();117  });118  it('should properly convert integer value for index between min and max into its associated float value', () =>119    fc.assert(120      fc.property(121        fc.option(floatConstraints(), { nil: undefined }),122        fc.maxSafeNat(),123        fc.option(fc.integer({ min: 2 }), { nil: undefined }),124        (ct, mod, biasFactor) => {125          // Arrange126          const { instance: mrng } = fakeRandom();127          const { min, max } = minMaxForConstraints(ct || {});128          const minIndex = floatToIndex(min);129          const maxIndex = floatToIndex(max);130          const arbitraryGeneratedIndex = (mod % (maxIndex - minIndex + 1)) + minIndex;131          spyIntegerWithValue(() => arbitraryGeneratedIndex);132          // Act133          const arb = float(ct);134          const { value_: f } = arb.generate(mrng, biasFactor);135          // Assert136          expect(f).toBe(indexToFloat(arbitraryGeneratedIndex));137        }138      )139    ));140  describe('with NaN', () => {141    const withNaNRecordConstraints = { ...defaultFloatRecordConstraints, noNaN: fc.constant(false) };142    it('should ask for a range with one extra value (far from zero)', () => {143      fc.assert(144        fc.property(floatConstraints(withNaNRecordConstraints), (ct) => {145          // Arrange146          const { max } = minMaxForConstraints(ct);147          const integer = spyInteger();148          // Act149          float({ ...ct, noNaN: true });150          float(ct);151          // Assert152          expect(integer).toHaveBeenCalledTimes(2);153          const integerConstraintsNoNaN = integer.mock.calls[0][0]!;154          const integerConstraintsWithNaN = integer.mock.calls[1][0]!;155          if (max > 0) {156            // max > 0  --> NaN will be added as the greatest value157            expect(integerConstraintsWithNaN.min).toBe(integerConstraintsNoNaN.min);158            expect(integerConstraintsWithNaN.max).toBe(integerConstraintsNoNaN.max! + 1);159          } else {160            // max <= 0 --> NaN will be added as the smallest value161            expect(integerConstraintsWithNaN.min).toBe(integerConstraintsNoNaN.min! - 1);162            expect(integerConstraintsWithNaN.max).toBe(integerConstraintsNoNaN.max);163          }164        })165      );166    });167    it('should properly convert the extra value to NaN', () =>168      fc.assert(169        fc.property(170          floatConstraints(withNaNRecordConstraints),171          fc.option(fc.integer({ min: 2 }), { nil: undefined }),172          (ct, biasFactor) => {173            // Arrange174            // Setup mocks for integer175            const { instance: mrng } = fakeRandom();176            const arbitraryGenerated = { value: Number.NaN };177            const integer = spyIntegerWithValue(() => arbitraryGenerated.value);178            // Call float next to find out the value required for NaN179            float({ ...ct, noNaN: true });180            const arb = float(ct);181            // Extract NaN "index"182            const { min: minNonNaN } = integer.mock.calls[0][0]!;183            const { min: minNaN, max: maxNaN } = integer.mock.calls[1][0]!;184            const indexForNaN = minNonNaN !== minNaN ? minNaN : maxNaN;185            if (indexForNaN === undefined) throw new Error('No value available for NaN');186            arbitraryGenerated.value = indexForNaN;187            // Act188            const { value_: f } = arb.generate(mrng, biasFactor);189            // Assert190            expect(f).toBe(Number.NaN);191          }192        )193      ));194  });195  describe('without NaN', () => {196    // eslint-disable-next-line @typescript-eslint/no-unused-vars197    const { noNaN, ...noNaNRecordConstraints } = defaultFloatRecordConstraints;198    it('should ask integers between the indexes corresponding to min and max', () => {199      fc.assert(200        fc.property(floatConstraints(noNaNRecordConstraints), (ctDraft) => {201          // Arrange202          const ct = { ...ctDraft, noNaN: true };203          const integer = spyInteger();204          const { min, max } = minMaxForConstraints(ct);205          const minIndex = floatToIndex(min);206          const maxIndex = floatToIndex(max);207          // Act208          float(ct);209          // Assert210          expect(integer).toHaveBeenCalledTimes(1);211          expect(integer).toHaveBeenCalledWith({ min: minIndex, max: maxIndex });212        })213      );214    });215  });216});217describe('float (integration)', () => {218  type Extra = FloatConstraints | undefined;219  const extraParameters: fc.Arbitrary<Extra> = fc.option(floatConstraints(), { nil: undefined });220  const isCorrect = (v: number, extra: Extra) => {221    expect(typeof v).toBe('number'); // should always produce numbers222    expect(is32bits(v)).toBe(true); // should always produce 32-bit floats223    if (extra === undefined) {224      return; // no other constraints225    }226    if (extra.noNaN) {227      expect(v).not.toBe(Number.NaN); // should not produce NaN if explicitely asked not too228    }229    if (extra.min !== undefined && !Number.isNaN(v)) {230      expect(v).toBeGreaterThanOrEqual(extra.min); // should always be greater than min when specified231    }232    if (extra.max !== undefined && !Number.isNaN(v)) {233      expect(v).toBeLessThanOrEqual(extra.max); // should always be smaller than max when specified234    }235    if (extra.noDefaultInfinity) {236      if (extra.min === undefined) {237        expect(v).not.toBe(Number.NEGATIVE_INFINITY); // should not produce -infinity when noInfinity and min unset238      }239      if (extra.max === undefined) {240        expect(v).not.toBe(Number.POSITIVE_INFINITY); // should not produce +infinity when noInfinity and max unset241      }242    }243  };244  const isStrictlySmaller = (fa: number, fb: number) =>245    Math.abs(fa) < Math.abs(fb) || //              Case 1: abs(a) < abs(b)246    (Object.is(fa, +0) && Object.is(fb, -0)) || // Case 2: +0 < -0  --> we shrink from -0 to +0247    (!Number.isNaN(fa) && Number.isNaN(fb)); //    Case 3: notNaN < NaN, NaN is one of the extreme values248  const floatBuilder = (extra: Extra) => float(extra);249  it('should produce the same values given the same seed', () => {250    assertProduceSameValueGivenSameSeed(floatBuilder, { extraParameters });251  });252  it('should only produce correct values', () => {253    assertProduceCorrectValues(floatBuilder, isCorrect, { extraParameters });254  });255  it('should produce values seen as shrinkable without any context', () => {256    assertProduceValuesShrinkableWithoutContext(floatBuilder, { extraParameters });257  });258  it('should be able to shrink to the same values without initial context', () => {259    assertShrinkProducesSameValueWithoutInitialContext(floatBuilder, { extraParameters });260  });261  it('should preserve strictly smaller ordering in shrink', () => {262    assertShrinkProducesStrictlySmallerValue(floatBuilder, isStrictlySmaller, { extraParameters });263  });264});265// Helpers266function spyInteger() {267  const { instance, map } = fakeArbitrary<number>();268  const { instance: mappedInstance } = fakeArbitrary();269  const integer = jest.spyOn(IntegerMock, 'integer');270  integer.mockReturnValue(instance);271  map.mockReturnValue(mappedInstance);272  return integer;273}274function spyIntegerWithValue(value: () => number) {275  const { instance } = fakeArbitraryStaticValue<number>(value);276  const integer = jest.spyOn(IntegerMock, 'integer');277  integer.mockReturnValue(instance);278  return integer;...

Using AI Code Generation

1const { indexForNaN } = require('fast-check-monorepo');2console.log(indexForNaN([1, 2, 3, NaN, 5, 6, 7, 8, 9, 10]));3console.log(indexForNaN([1, 2, 3, NaN, 5, 6, 7, 8, 9, 10], 5));4console.log(indexForNaN([1, 2, 3, NaN, 5, 6, 7, 8, 9, 10], 5));5console.log(indexForNaN([1, 2, 3, NaN, 5, 6, 7, 8, 9, 10], 5));6console.log(indexForNaN([1, 2, 3, NaN, 5, 6, 7,

Using AI Code Generation

1const { indexForNaN } = require('fast-check');2console.log('indexForNaN', indexForNaN);3const { indexForNaN } = require('fast-check-monorepo');4console.log('indexForNaN', indexForNaN);5const { indexForNaN } = require('fast-check-monorepo');6console.log('indexForNaN', indexForNaN);7const { indexForNaN } = require('fast-check-monorepo');8console.log('indexForNaN', indexForNaN);9const { indexForNaN } = require('fast-check-monorepo');10console.log('indexForNaN', indexForNaN);11const { indexForNaN } = require('fast-check-monorepo');12console.log('indexForNaN', indexForNaN);13const { indexForNaN } = require('fast-check-monorepo');14console.log('indexForNaN', indexForNaN);15const { indexForNaN } = require('fast-check-monorepo');16console.log('indexForNaN', indexForNaN);17const { indexForNaN } = require('fast-check-monorepo');18console.log('indexForNaN', indexForNaN);19const { indexForNaN } = require('fast-check-monorepo');20console.log('indexForNaN', indexForNaN);21const { indexForNaN } = require('fast-check-monorepo');22console.log('indexForNaN', indexForNaN);23const { indexForNaN } = require('fast-check-monorepo');24console.log('indexForNaN', indexForNaN);25const { indexForNaN } = require('

Using AI Code Generation

1import * as fc from "fast-check";2import { indexForNaN } from "fast-check";3const index = indexForNaN([NaN, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);4console.log(index);5import * as fc from "fast-check";6import { indexForNaN } from "fast-check";7const index = indexForNaN([NaN, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);8console.log(index);9import * as fc from "fast-check";10import { indexForNaN } from "fast-check";11const index = indexForNaN([NaN, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);12console.log(index);13import * as fc from "fast-check";14import { indexForNaN } from "fast-check";15const index = indexForNaN([NaN, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);16console.log(index);17import * as fc from "fast-check";18import { indexForNaN } from "fast-check";19const index = indexForNaN([NaN, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);20console.log(index);

Using AI Code Generation

1const indexForNaN = require("fast-check-monorepo");2const arr = [1,2,3,4,5,NaN,7,8,9,10];3console.log(indexForNaN(arr));4const indexForNaN = require("fast-check-monorepo");5const arr = [1,2,3,4,5,6,7,8,9,10];6console.log(indexForNaN(arr));7const indexForNaN = require("fast-check-monorepo");8const arr = [1,2,3,4,5,6,7,8,9,10,NaN];9console.log(indexForNaN(arr));10const indexForNaN = require("fast-check-monorepo");11const arr = [1,2,3,4,5,6,7,8,9,10,NaN,NaN];12console.log(indexForNaN(arr));

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.