How to use bigIntBuilder method in fast-check-monorepo

Best JavaScript code snippet using fast-check-monorepo

BigIntArbitrary.spec.ts

Source:BigIntArbitrary.spec.ts

1import * as fc from 'fast-check';2import { BigIntArbitrary } from '../../../../src/arbitrary/_internals/BigIntArbitrary';3import { Value } from '../../../../src/check/arbitrary/definition/Value';4import { fakeRandom } from '../__test-helpers__/RandomHelpers';5import {6  assertProduceValuesShrinkableWithoutContext,7  assertProduceCorrectValues,8  assertShrinkProducesSameValueWithoutInitialContext,9  assertShrinkProducesStrictlySmallerValue,10  assertProduceSameValueGivenSameSeed,11} from '../__test-helpers__/ArbitraryAssertions';12import { buildShrinkTree, renderTree, walkTree } from '../__test-helpers__/ShrinkTree';13import { Stream } from '../../../../src/stream/Stream';14import * as BiasNumericRangeMock from '../../../../src/arbitrary/_internals/helpers/BiasNumericRange';15import * as ShrinkBigIntMock from '../../../../src/arbitrary/_internals/helpers/ShrinkBigInt';16function beforeEachHook() {17  jest.resetModules();18  jest.restoreAllMocks();19  fc.configureGlobal({ beforeEach: beforeEachHook });20}21beforeEach(beforeEachHook);22describe('BigIntArbitrary', () => {23  if (typeof BigInt === 'undefined') {24    it('no test', () => {25      expect(true).toBe(true);26    });27    return;28  }29  describe('generate', () => {30    it('should never bias and generate the full range when biasFactor is not specified', () =>31      fc.assert(32        fc.property(fc.bigInt(), fc.bigInt(), fc.bigInt(), (a, b, c) => {33          // Arrange34          const [min, mid, max] = [a, b, c].sort((v1, v2) => Number(v1 - v2));35          const { instance: mrng, nextBigInt } = fakeRandom();36          nextBigInt.mockReturnValueOnce(mid);37          // Act38          const arb = new BigIntArbitrary(min, max);39          const out = arb.generate(mrng, undefined);40          // Assert41          expect(out.value).toBe(mid);42          expect(nextBigInt).toHaveBeenCalledTimes(1);43          expect(nextBigInt).toHaveBeenCalledWith(min, max);44        })45      ));46    it('should not always bias values (expect 1 times over biasFreq) and still generate full range when unbiased', () =>47      fc.assert(48        fc.property(fc.bigInt(), fc.bigInt(), fc.bigInt(), fc.maxSafeInteger(), (a, b, c, biasFactor) => {49          // Arrange50          const [min, mid, max] = [a, b, c].sort((v1, v2) => Number(v1 - v2));51          const { instance: mrng, nextInt, nextBigInt } = fakeRandom();52          nextInt.mockReturnValueOnce(2); // 1 means bias, all others are unbiased53          nextBigInt.mockReturnValueOnce(mid);54          // Act55          const arb = new BigIntArbitrary(min, max);56          const out = arb.generate(mrng, biasFactor);57          // Assert58          expect(out.value).toBe(mid);59          expect(nextInt).toHaveBeenCalledTimes(1);60          expect(nextInt).toHaveBeenCalledWith(1, biasFactor);61          expect(nextBigInt).toHaveBeenCalledTimes(1);62          expect(nextBigInt).toHaveBeenCalledWith(min, max);63        })64      ));65    it('should bias values (1 times over biasFreq) by using one of the ranges from biasNumericRange', () =>66      fc.assert(67        fc.property(68          fc.bigInt(),69          fc.bigInt(),70          fc.bigInt(),71          fc.maxSafeInteger(),72          fc.maxSafeInteger(),73          // Remark:74          // Following biasNumericRange is not fully identical to the onces that would be provided.75          // Range (in this stub) can be larger than the requested one. Not impacting from a unit-test point of view.76          fc.array(77            fc.tuple(fc.bigInt(), fc.bigInt()).map(([a, b]) => (a < b ? { min: a, max: b } : { min: b, max: a })),78            { minLength: 1 }79          ),80          (a, b, c, biasFactor, mod, ranges) => {81            // Arrange82            const [min, mid, max] = [a, b, c].sort((v1, v2) => Number(v1 - v2));83            const { instance: mrng, nextInt, nextBigInt } = fakeRandom();84            nextInt.mockReturnValueOnce(1); // 1 means bias85            if (ranges.length !== 1) {86              nextInt.mockImplementationOnce((min, max) => min + (mod % (max - min + 1)));87            }88            nextBigInt.mockReturnValueOnce(mid); // Remark: this value will most of the time be outside of requested range89            const biasNumericRange = jest.spyOn(90              BiasNumericRangeMock,91              'biasNumericRange'92            ) as unknown as jest.SpyInstance<{ min: bigint; max: bigint }[], [bigint, bigint, () => bigint]>;93            biasNumericRange.mockReturnValueOnce(ranges);94            // Act95            const arb = new BigIntArbitrary(min, max);96            const out = arb.generate(mrng, biasFactor);97            // Assert98            expect(out.value).toBe(mid);99            expect(biasNumericRange).toHaveBeenCalledTimes(1);100            expect(biasNumericRange).toHaveBeenCalledWith(min, max, expect.any(Function));101            if (ranges.length === 1) {102              expect(nextInt).toHaveBeenCalledTimes(1);103              expect(nextInt).toHaveBeenCalledWith(1, biasFactor);104              expect(nextBigInt).toHaveBeenCalledTimes(1);105              expect(nextBigInt).toHaveBeenCalledWith(ranges[0].min, ranges[0].max);106            } else {107              expect(nextInt).toHaveBeenCalledTimes(2);108              expect(nextInt).toHaveBeenCalledWith(1, biasFactor);109              const secondNextIntParams = nextInt.mock.calls[1];110              expect(secondNextIntParams[0]).toBeLessThan(0); // arbitrary is supposed to prefer the first entry111              expect(secondNextIntParams[1]).toBe(ranges.length - 2); // other entries do not have any special treatments112              // negative values for [0], positive value n means ranges[n+1]113              const secondNextIntResult = nextInt.mock.results[1].value;114              const selectedRange = secondNextIntResult < 0 ? 0 : secondNextIntResult + 1;115              expect(nextBigInt).toHaveBeenCalledWith(ranges[selectedRange].min, ranges[selectedRange].max);116            }117          }118        )119      ));120  });121  describe('canShrinkWithoutContext', () => {122    it('should always tells it can generate values included in the requested range', () =>123      fc.assert(124        fc.property(fc.bigInt(), fc.bigInt(), fc.bigInt(), (a, b, c) => {125          // Arrange126          const [min, mid, max] = [a, b, c].sort((v1, v2) => Number(v1 - v2));127          // Act128          const arb = new BigIntArbitrary(min, max);129          const out = arb.canShrinkWithoutContext(mid);130          // Assert131          expect(out).toBe(true);132        })133      ));134    it('should always reject values outside of the requested range', () =>135      fc.assert(136        fc.property(137          fc.bigInt(),138          fc.bigInt(),139          fc.bigInt(),140          fc.constantFrom(...(['lower', 'higher'] as const)),141          (a, b, c, position) => {142            // Arrange143            const s = [a, b, c].sort((v1, v2) => Number(v1 - v2));144            const [min, max, requested] = position === 'lower' ? [s[1], s[2], s[0]] : [s[0], s[1], s[2]];145            fc.pre(requested !== min && requested !== max);146            // Act147            const arb = new BigIntArbitrary(min, max);148            const out = arb.canShrinkWithoutContext(requested);149            // Assert150            expect(out).toBe(false);151          }152        )153      ));154    it.each`155      requested156      ${'1'}157      ${1}158      ${'1n'}159      ${1.5}160      ${-0}161      ${Number.NaN}162      ${''}163      ${{}}164    `('should always reject non bigint values like $requested', ({ requested }) => {165      // Arrange166      const min = BigInt(0);167      const max = BigInt(100);168      // Act169      const arb = new BigIntArbitrary(min, max);170      const out = arb.canShrinkWithoutContext(requested);171      // Assert172      expect(out).toBe(false);173    });174  });175  describe('shrink', () => {176    it('should always call shrink helper when no context provided', () =>177      fc.assert(178        fc.property(fc.bigInt(), fc.bigInt(), fc.bigInt(), (a, b, c) => {179          // Arrange180          const [min, mid, max] = [a, b, c].sort((v1, v2) => Number(v1 - v2));181          const expectedShrinks = Stream.nil<Value<bigint>>();182          const shrinkBigInt = jest.spyOn(ShrinkBigIntMock, 'shrinkBigInt');183          shrinkBigInt.mockReturnValueOnce(expectedShrinks);184          // Act185          const arb = new BigIntArbitrary(min, max);186          const shrinks = arb.shrink(mid, undefined);187          // Assert188          expect(shrinks).toBe(expectedShrinks);189          expect(shrinkBigInt).toHaveBeenCalledTimes(1);190          expect(shrinkBigInt).toHaveBeenCalledWith(mid, expect.any(BigInt), true);191        })192      ));193  });194});195describe('BigIntArbitrary (integration)', () => {196  if (typeof BigInt === 'undefined') {197    it('no test', () => {198      expect(true).toBe(true);199    });200    return;201  }202  type Extra = { min: bigint; max: bigint };203  const extraParameters: fc.Arbitrary<Extra> = fc204    .tuple(fc.bigInt(), fc.bigInt())205    .map(([a, b]) => (a < b ? { min: a, max: b } : { min: b, max: a }));206  const isCorrect = (value: bigint, extra: Extra) =>207    typeof value === 'bigint' && extra.min <= value && value <= extra.max;208  const isStrictlySmaller = (v1: bigint, v2: bigint) => {209    const absV1 = v1 < BigInt(0) ? -v1 : v1;210    const absV2 = v2 < BigInt(0) ? -v2 : v2;211    return absV1 < absV2;212  };213  const bigIntBuilder = (extra: Extra) => new BigIntArbitrary(extra.min, extra.max);214  it('should produce the same values given the same seed', () => {215    assertProduceSameValueGivenSameSeed(bigIntBuilder, { extraParameters });216  });217  it('should only produce correct values', () => {218    assertProduceCorrectValues(bigIntBuilder, isCorrect, { extraParameters });219  });220  it('should produce values seen as shrinkable without any context', () => {221    assertProduceValuesShrinkableWithoutContext(bigIntBuilder, { extraParameters });222  });223  it('should be able to shrink to the same values without initial context', () => {224    assertShrinkProducesSameValueWithoutInitialContext(bigIntBuilder, { extraParameters });225  });226  it('should shrink towards strictly smaller values', () => {227    assertShrinkProducesStrictlySmallerValue(bigIntBuilder, isStrictlySmaller, { extraParameters });228  });229  describe('shrink', () => {230    it('should build a mirrored version of the shrinking tree if we negate all the values', () =>231      fc.assert(232        fc.property(233          fc.bigInt(),234          fc.bigUint({ max: BigInt(20) }), // larger trees might be too wide235          fc.bigUint({ max: BigInt(20) }),236          (start, o1, o2) => {237            // Arrange238            const min = start;239            const [mid, max] = o1 < o2 ? [min + o1, min + o2] : [min + o2, min + o1];240            const arb = new BigIntArbitrary(min, max);241            const arbNegate = new BigIntArbitrary(-max, -min);242            // Act243            const source = new Value(mid, undefined);244            const sourceNegate = new Value(-mid, undefined);245            const tree = buildShrinkTree(arb, source);246            const treeNegate = buildShrinkTree(arbNegate, sourceNegate);247            const flat: bigint[] = [];248            const flatNegate: bigint[] = [];249            walkTree(tree, (v) => flat.push(v));250            walkTree(treeNegate, (v) => flatNegate.push(-v));251            // Assert252            expect(arb.canShrinkWithoutContext(source.value)).toBe(true);253            expect(arbNegate.canShrinkWithoutContext(sourceNegate.value)).toBe(true);254            expect(flatNegate).toEqual(flat);255          }256        )257      ));258    it('should build an offset version of the shrinking tree if we offset all the values (keep every value >=0)', () =>259      fc.assert(260        fc.property(261          fc.bigUint(),262          fc.bigUint({ max: BigInt(20) }), // larger trees might be too wide263          fc.bigUint({ max: BigInt(20) }),264          fc.bigUint(),265          (start, o1, o2, offset) => {266            // Arrange267            fc.pre(start + o1 + offset <= Number.MAX_SAFE_INTEGER);268            fc.pre(start + o2 + offset <= Number.MAX_SAFE_INTEGER);269            const min = start;270            const [mid, max] = o1 < o2 ? [min + o1, min + o2] : [min + o2, min + o1];271            const arb = new BigIntArbitrary(min, max);272            const arbOffset = new BigIntArbitrary(min + offset, max + offset);273            // Act274            const source = new Value(mid, undefined);275            const sourceOffset = new Value(mid + offset, undefined);276            const tree = buildShrinkTree(arb, source);277            const treeOffset = buildShrinkTree(arbOffset, sourceOffset);278            const flat: bigint[] = [];279            const flatOffset: bigint[] = [];280            walkTree(tree, (v) => flat.push(v));281            walkTree(treeOffset, (v) => flatOffset.push(v - offset));282            // Assert283            expect(arb.canShrinkWithoutContext(source.value)).toBe(true);284            expect(arbOffset.canShrinkWithoutContext(sourceOffset.value)).toBe(true);285            expect(flatOffset).toEqual(flat);286          }287        )288      ));289    it('should shrink strictly positive value for positive range including zero', () => {290      // Arrange291      const arb = new BigIntArbitrary(BigInt(0), BigInt(10));292      const source = new Value(BigInt(8), undefined);293      // Act294      const tree = buildShrinkTree(arb, source);295      const renderedTree = renderTree(tree).join('\n');296      // Assert297      expect(arb.canShrinkWithoutContext(source.value)).toBe(true);298      //   When there is no more option, the shrinker retry one time with the value299      //   current-1 to check if something that changed outside (another value not itself)300      //   may have changed the situation.301      expect(renderedTree).toMatchInlineSnapshot(`302          "8n303          â> 0n304          â> 4n305          |  â> 2n306          |  |  â> 1n307          |  |     â> 0n308          |  â> 3n309          |     â> 2n310          |        â> 0n311          |        â> 1n312          |           â> 0n313          â> 6n314          |  â> 5n315          |     â> 4n316          |        â> 0n317          |        â> 2n318          |        |  â> 1n319          |        |     â> 0n320          |        â> 3n321          |           â> 2n322          |              â> 0n323          |              â> 1n324          |                 â> 0n325          â> 7n326             â> 6n327                â> 0n328                â> 3n329                |  â> 2n330                |     â> 1n331                |        â> 0n332                â> 5n333                   â> 4n334                      â> 3n335                         â> 0n336                         â> 2n337                            â> 1n338                               â> 0n"339        `);340      // Remarks:341      // * When we shrink 5 in path 8 > 6 > 5342      //   we already now that 4 passed so we now that the smallest failing case343      //   to look for is >= 5344      // * Same thing when we shrink 6 in path 8 > 6345      // * When we shrink 7 in path 8 > 7346      //   we already now that 6 passed so we now that the smallest failing case347      //   to look for is >= 7348    });349    it('should shrink strictly positive value for range not including zero', () => {350      // Arrange351      const arb = new BigIntArbitrary(BigInt(10), BigInt(20));352      const source = new Value(BigInt(18), undefined);353      // Act354      const tree = buildShrinkTree(arb, source);355      const renderedTree = renderTree(tree).join('\n');356      // Assert357      expect(arb.canShrinkWithoutContext(source.value)).toBe(true);358      //   As the range [10, 20] and the value 18359      //   are just offset by +10 compared to the first case,360      //   the rendered tree will be offset by 10 too361      expect(renderedTree).toMatchInlineSnapshot(`362          "18n363          â> 10n364          â> 14n365          |  â> 12n366          |  |  â> 11n367          |  |     â> 10n368          |  â> 13n369          |     â> 12n370          |        â> 10n371          |        â> 11n372          |           â> 10n373          â> 16n374          |  â> 15n375          |     â> 14n376          |        â> 10n377          |        â> 12n378          |        |  â> 11n379          |        |     â> 10n380          |        â> 13n381          |           â> 12n382          |              â> 10n383          |              â> 11n384          |                 â> 10n385          â> 17n386             â> 16n387                â> 10n388                â> 13n389                |  â> 12n390                |     â> 11n391                |        â> 10n392                â> 15n393                   â> 14n394                      â> 13n395                         â> 10n396                         â> 12n397                            â> 11n398                               â> 10n"399        `);400    });401    it('should shrink strictly negative value for negative range including zero', () => {402      // Arrange403      const arb = new BigIntArbitrary(BigInt(-10), BigInt(0));404      const source = new Value(BigInt(-8), undefined);405      // Act406      const tree = buildShrinkTree(arb, source);407      const renderedTree = renderTree(tree).join('\n');408      // Assert409      expect(arb.canShrinkWithoutContext(source.value)).toBe(true);410      //   As the range [-10, 0] and the value -8411      //   are the opposite of first case, the rendered tree will be the same except412      //   it contains opposite values413      expect(renderedTree).toMatchInlineSnapshot(`414          "-8n415          â> 0n416          â> -4n417          |  â> -2n418          |  |  â> -1n419          |  |     â> 0n420          |  â> -3n421          |     â> -2n422          |        â> 0n423          |        â> -1n424          |           â> 0n425          â> -6n426          |  â> -5n427          |     â> -4n428          |        â> 0n429          |        â> -2n430          |        |  â> -1n431          |        |     â> 0n432          |        â> -3n433          |           â> -2n434          |              â> 0n435          |              â> -1n436          |                 â> 0n437          â> -7n438             â> -6n439                â> 0n440                â> -3n441                |  â> -2n442                |     â> -1n443                |        â> 0n444                â> -5n445                   â> -4n446                      â> -3n447                         â> 0n448                         â> -2n449                            â> -1n450                               â> 0n"451        `);452    });453  });...

utils.ts

Source:utils.ts

1import { getGroupedFields } from '@terascope/data-types';2import {3    DataTypeConfig, DataTypeFields, FieldType4} from '@terascope/types';5import { WritableData } from '../core';6import { Builder, BuilderOptions } from './Builder';7import { ListBuilder } from './ListBuilder';8import {9    AnyBuilder, BigIntBuilder, BooleanBuilder,10    DateBuilder, IntBuilder, FloatBuilder,11    GeoBoundaryBuilder, GeoJSONBuilder, GeoPointBuilder,12    IPBuilder, IPRangeBuilder,13    ObjectBuilder, StringBuilder, TupleBuilder14} from './types';15export function getBuildersForConfig<T extends Record<string, any> = Record<string, unknown>>(16    config: DataTypeConfig, size: number17): Map<(keyof T), Builder<unknown>> {18    const builders = new Map<keyof T, Builder<unknown>>();19    const groupedFieldEntries = Object.entries(getGroupedFields(config.fields));20    for (const [field, nested] of groupedFieldEntries) {21        let childConfig: DataTypeFields|undefined;22        nested.forEach((fullField) => {23            if (fullField === field) return;24            const nestedField = fullField.replace(`${field}.`, '');25            childConfig ??= {};26            childConfig[nestedField] = config.fields[fullField];27        });28        builders.set(field, Builder.make(new WritableData(size), {29            childConfig,30            config: config.fields[field],31            name: field,32        }));33    }34    return builders;35}36export function _newBuilder<T>(37    data: WritableData<any>,38    options: BuilderOptions,39): Builder<T> {40    const fieldType = options.config.type as FieldType;41    if (!(fieldType in FieldType)) {42        throw new Error(`Unsupported field type ${fieldType}`);43    }44    if (options.config.array) {45        return new ListBuilder(data, options) as Builder<any>;46    }47    return _newBuilderForType(data, options) as Builder<T>;48}49/**50 * Create primitive builder types, does not deal with array or object type fields51*/52function _newBuilderForType(53    data: WritableData<any>,54    options: BuilderOptions,55) {56    switch (options.config.type) {57        case FieldType.String:58        case FieldType.Text:59        case FieldType.Keyword:60        case FieldType.KeywordCaseInsensitive:61        case FieldType.KeywordTokens:62        case FieldType.KeywordTokensCaseInsensitive:63        case FieldType.KeywordPathAnalyzer:64        case FieldType.Domain:65        case FieldType.Hostname:66            return new StringBuilder(data, options);67        case FieldType.IP:68            return new IPBuilder(data, options);69        case FieldType.IPRange:70            return new IPRangeBuilder(data, options);71        case FieldType.Date:72            return new DateBuilder(data, options);73        case FieldType.Boolean:74            return new BooleanBuilder(data, options);75        case FieldType.Float:76        case FieldType.Number:77        case FieldType.Double:78            // Double can't supported entirely until we have BigFloat79            return new FloatBuilder(data, options);80        case FieldType.Byte:81        case FieldType.Short:82        case FieldType.Integer:83            return new IntBuilder(data, options);84        case FieldType.Long:85            return new BigIntBuilder(data, options);86        case FieldType.Boundary:87            return new GeoBoundaryBuilder(data, options);88        case FieldType.Geo:89        case FieldType.GeoPoint:90            return new GeoPointBuilder(data, options);91        case FieldType.GeoJSON:92            return new GeoJSONBuilder(data, options);93        case FieldType.Object:94            return new ObjectBuilder(data, options);95        case FieldType.Tuple:96            return new TupleBuilder(data, options);97        default:98            return new AnyBuilder(data, options);99    }...

index.ts

Source:index.ts

1export * from './AnyBuilder';2export * from './BigIntBuilder';3export * from './BooleanBuilder';4export * from './DateBuilder';5export * from './FloatBuilder';6export * from './GeoBoundaryBuilder';7export * from './GeoJSONBuilder';8export * from './GeoPointBuilder';9export * from './IntBuilder';10export * from './IPBuilder';11export * from './IPRangeBuilder';12export * from './ObjectBuilder';13export * from './StringBuilder';...

Using AI Code Generation

1const bigIntBuilder = require("fast-check").bigIntBuilder;2const bigIntArb = bigIntBuilder()3  .noShrink()4  .noBias()5  .noShrink()6  .noBias()7  .build();

Using AI Code Generation

1import { bigIntBuilder } from 'fast-check';2import { bigInt } from 'fast-check';3const arb = bigIntBuilder().noShrink().noBias().build();4import { bigInt } from 'fast-check';5const arb = bigInt();6import { bigInt } from 'fast-check';7const arb = bigInt();

Using AI Code Generation

1const { bigIntBuilder } = require('fast-check');2const bigInt = bigIntBuilder();3const { bigInt } = require('fast-check');4const { bigUint } = require('fast-check');5const { bigUintN } = require('fast-check');6const { oneof } = require('fast-check');7const { array } = require('fast-check');8const { record } = require('fast-check');9const { tuple } = require('fast-check');10const { constant } = require('fast-check');11const { dictionary } = require('fast-check');12const { set } = require('fast-check');13const { map } = require('fast-check');14const { subarray } = require('fast-check');15const { subarrayOf } = require('fast-check');16const { subarrayBy } = require('fast-check');17const { subarrayByOf } = require('fast-check');18const { shuffle } = require('fast-check');19const { sample } = require('fast-check');20const { sampleOne } = require('fast-check');21const { option } = require('fast-check');22const { nullable } = require('fast-check');23const { memo } = require('fast-check');24const { oneof as oneof2 } = require('fast-check');25const { string } = require('fast-check');26const { unicode } = require('fast-check');27const { unicodeJson } = require('fast-check');28const { char } = require('fast-check');29const { char16bits } = require('fast-check');30const { fullUnicode } = require('fast-check');31const { fullUnicodeJson } = require('fast-check');32const { fullUnicodeJsonObject } = require('fast-check');33const { fullUnicodeJsonArray } = require('fast-check');34const { fullUnicodeJsonString } = require('fast-check');35const { hexa } = require('fast-check');36const { base64 } = require('fast-check');37const { base64Json } = require('fast-check');38const { base64JsonObject } = require('fast-check');39const { base64JsonArray } = require('fast-check');40const { base64JsonString } = require('fast-check');41const { ascii } = require('fast-check');42const { asciiString } = require('fast-check');43const { asciiJsonObject } = require('fast-check');44const { asciiJsonArray } = require('fast-check');45const { asciiJsonString } = require('

Using AI Code Generation

1const { bigIntBuilder } = require('fast-check');2const bigInt = bigIntBuilder();3describe('bigInt', () => {4  it('should generate bigInt', () => {5    const arb = bigInt();6    const out = arb.generate();7    expect(out).toBeInstanceOf(BigInt);8  });9});10const { bigInt64ArrayBuilder } = require('fast-check');11const bigInt64Array = bigInt64ArrayBuilder();12describe('bigInt64Array', () => {13  it('should generate bigInt64Array', () => {14    const arb = bigInt64Array();15    const out = arb.generate();16    expect(out).toBeInstanceOf(BigInt64Array);17  });18});19const { bigUint64ArrayBuilder } = require('fast-check');20const bigUint64Array = bigUint64ArrayBuilder();21describe('bigUint64Array', () => {22  it('should generate bigUint64Array', () => {23    const arb = bigUint64Array();24    const out = arb.generate();25    expect(out).toBeInstanceOf(BigUint64Array);26  });27});28const { dateBuilder } = require('fast-check');29const date = dateBuilder();30describe('date', () => {31  it('should generate date', () => {32    const arb = date();33    const out = arb.generate();34    expect(out).toBeInstanceOf(Date);35  });36});37const { float32ArrayBuilder } = require('fast-check');38const float32Array = float32ArrayBuilder();39describe('float32Array', () => {40  it('should generate float32Array', () => {41    const arb = float32Array();42    const out = arb.generate();43    expect(out).toBeInstanceOf(Float32Array);44  });45});46const { float64ArrayBuilder } = require('fast-check');47const float64Array = float64ArrayBuilder();48describe('float64

Using AI Code Generation

1const { bigIntBuilder } = require('fast-check');2const { bigInt } = require('big-integer');3const { isBigInt } = require('util');4const { assert } = require('chai');5describe('bigIntBuilder', function() {6  it('should produce a bigInt', function() {7    const arb = bigIntBuilder();8    const value = arb.generate();9    assert(isBigInt(value), 'value should be a bigInt');10  });11});

Using AI Code Generation

1const bigIntBuilder = require('fast-check/build/types/arbitrary/bigIntArbitrary').bigIntBuilder;2const fc = require('fast-check');3const bigInt = bigIntBuilder(-1000, 1000);4fc.assert(fc.property(bigInt, (n) => {5  return n >= -1000 && n <= 1000;6}));7fc.check(fc.property(bigInt, (n) => {8  return n >= -1000 && n <= 1000;9}));10const bigIntBuilder = require('fast-check').bigIntBuilder;11const fc = require('fast-check');12const bigInt = bigIntBuilder(-1000, 1000);13fc.assert(fc.property(bigInt, (n) => {14  return n >= -1000 && n <= 1000;15}));16fc.check(fc.property(bigInt, (n) => {17  return n >= -1000 && n <= 1000;18}));19const bigIntBuilder = require('fast-check').bigIntBuilder;20const fc = require('fast-check');21const bigInt = bigIntBuilder(-1000, 1000);22fc.assert(fc.property(bigInt, (n) => {23  return n >= -1000 && n <= 1000;24}));25fc.check(fc.property(bigInt, (n) => {26  return n >= -1000 && n <= 1000;27}));28const bigIntBuilder = require('fast-check').bigIntBuilder;29const fc = require('fast-check');30const bigInt = bigIntBuilder(-1000, 1000);31fc.assert(fc.property(bigInt, (n) => {

Using AI Code Generation

1const bigIntBuilder = require('fast-check').bigIntBuilder;2const bigInt = bigIntBuilder();3console.log('bigInt', bigInt);4const bigInt100 = bigIntBuilder(0, 100);5console.log('bigInt100', bigInt100);6const bigInt100bias = bigIntBuilder(0, 100, 0.5);7console.log('bigInt100bias', bigInt100bias);8const bigInt100biasseed = bigIntBuilder(0, 100, 0.5, 1234);9console.log('bigInt100biasseed', bigInt100biasseed);10const bigInt100biasseed = bigIntBuilder(0, 100, 0.5, 1234);11console.log('bigInt100biasseed', bigInt100biasseed);12const bigInt100biasseed = bigIntBuilder(0, 100, 0.5, 1234);13console.log('bigInt100biasseed', bigInt100biasseed);14const bigInt100biasseed = bigIntBuilder(0, 100, 0.5, 1234);15console.log('bigInt100biasseed', bigInt100biasseed);16const bigInt100biasseed = bigIntBuilder(0, 100, 0.5, 1234);17console.log('bigInt100biasseed', bigInt100biasseed);

Using AI Code Generation

1const { bigIntBuilder } = require("fast-check");2const bigIntArb = bigIntBuilder();3const bigIntArb2 = bigIntBuilder(0, 100);4describe("test bigIntBuilder", () => {5  test("bigIntBuilder", () => {6    expect(bigIntArb).toBeDefined();7    expect(bigIntArb2).toBeDefined();8  });9});10    ✓ bigIntBuilder (1 ms)

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.