How to use doubleConstraints method in fast-check-monorepo

Best JavaScript code snippet using fast-check-monorepo

double.spec.ts

Source:double.spec.ts

...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    }...

FloatingPointHelpers.ts

Source:FloatingPointHelpers.ts

...47  recordConstraints: Partial<typeof defaultFloatRecordConstraints> = defaultFloatRecordConstraints48): fc.Arbitrary<FloatConstraints> {49  return constraintsInternal(recordConstraints);50}51export function doubleConstraints(52  recordConstraints: Partial<typeof defaultDoubleRecordConstraints> = defaultDoubleRecordConstraints53): fc.Arbitrary<DoubleConstraints> {54  return constraintsInternal(recordConstraints);55}56export function isStrictlySmaller(fa: number, fb: number): boolean {57  if (fa === 0 && fb === 0) return 1 / fa < 1 / fb;58  return fa < fb;59}60export function is32bits(f64: number): boolean {61  return Object.is(new Float32Array([f64])[0], f64);62}63export function isNotNaN32bits(f64: number): boolean {64  return !Number.isNaN(f64) && is32bits(f64);65}...

inputs.ts

Source:inputs.ts

1import type * as fc from 'fast-check';2import { URI } from './index';3type FcStrInputs =4  {type: "hexa" | "base64" | "char" | "ascii" | "unicode" | "char16bits" | "fullUnicode" |5    "ipV4" | "ipV4Extended" | "ipV6" | "uuid" | "domain" | "webAuthority" |6    "webFragments" | "webQueryParameters" | "webSegment" | "emailAddress"} |7  {type: "webUrl"} & fc.WebUrlConstraints |8  {type: "uuidV", version: 1 | 2 | 3 | 4 | 5} |9  {type: "hexaString" | "base64String" | "string" | "asciiString" |10    "unicodeString" | "string16bits" | "fullUnicodeString"} & fc.StringSharedConstraints |11  {type: "json" | "unicodeJson"} & fc.JsonSharedConstraints |12  {type: "lorem"} & fc.LoremConstraints13type FcNumInputs =14  {type: "maxSafeInteger" | "maxSafeNat"} |15  {type: "integer"} & fc.IntegerConstraints |16  {type: "nat"} & fc.NatConstraints |17  {type: "float"} & fc.FloatConstraints |18  {type: "double"} & fc.DoubleConstraints //|19  // These return a different type. Determine whether to support `bigint`20  /*{type: "bigInt"} & fc.BigIntConstraints |21  {type: "bigUint"} & fc.BigUintConstraints |22  {type: "bigIntN" | "bigUintN", n: number}*/23type FCRec<A> = {baseCase: A}24declare module '@deriving-ts/core' {25  export interface Inputs<A> {26    [URI]: {27      str?: FcStrInputs,28      num?: FcNumInputs,29      date?: {min?: Date, max?: Date}30      recurse: FCRec<A>31      nullable?: {freq: number}32      array?: fc.ArrayConstraints33    }34  }...

Using AI Code Generation

1const { doubleConstraints } = require('fast-check');2const { doubleConstraints } = require('fast-check-monorepo');3const { doubleConstraints } = require('fast-check-monorepo');4const { doubleConstraints } = require('fast-check');5const { doubleConstraints } = require('fast-check-monorepo');6const { doubleConstraints } = require('fast-check');7const { doubleConstraints } = require('fast-check');8const { doubleConstraints } = require('fast-check');9const { doubleConstraints } = require('fast-check');10const { doubleConstraints } = require('fast-check');11const { doubleConstraints } = require('fast-check');12const { doubleConstraints } = require('fast-check');13const { doubleConstraints } = require('fast-check');14const { doubleConstraints } = require('fast-check');15const { doubleConstraints } = require('fast-check');16const { doubleConstraints } = require('fast-check');17const { doubleConstraints } = require('fast-check');18const { doubleConstraints } = require('fast-check');

Using AI Code Generation

1import { doubleConstraints } from 'fast-check-monorepo';2import { doubleConstraints } from 'fast-check-monorepo';3import { doubleConstraints } from 'fast-check-monorepo';4import { doubleConstraints } from 'fast-check-monorepo';5import { doubleConstraints } from 'fast-check-monorepo';6import { doubleConstraints } from 'fast-check-monorepo';7import { doubleConstraints } from 'fast-check-monorepo';8import { doubleConstraints } from 'fast-check-monorepo';9import { doubleConstraints } from 'fast-check-monorepo';10import { doubleConstraints } from 'fast-check-monorepo';11import { doubleConstraints } from 'fast-check-monorepo';12import { doubleConstraints } from 'fast-check-monorepo';13import { doubleConstraints } from 'fast-check-monorepo';14import { doubleConstraints } from 'fast-check-monorepo';15import { doubleConstraints } from 'fast-check-monorepo';16import { doubleConstraints } from 'fast-check-monorepo';17import { doubleConstraints } from 'fast-check-monorepo';18import { doubleConstraints } from 'fast-check-monorepo';19import { doubleConstraints } from 'fast-check-monorepo';20import { doubleConstraints } from 'fast-check-monorepo';

Using AI Code Generation

1const fc = require('fast-check')2const { doubleConstraints } = require('fast-check-monorepo')3const arbitrary = fc.integer(0, 100)4fc.assert(5  doubleConstraints(arbitrary, (a, b) => {6  })

Using AI Code Generation

1const fc = require('fast-check');2const doubleConstraints = (a, b) => {3  return a === b / 2;4};5const double = fc.double();6  .tuple(double, double)7  .filter(doubleConstraints);8fc.assert(9  fc.property(doubleArb, ([a, b]) => {10    return doubleConstraints(a, b);11  })12);13const fc = require('fast-check');14const doubleConstraints = (a, b) => {15  return a === b / 2;16};17const double = fc.double();18  .tuple(double, double)19  .filter(doubleConstraints);20fc.assert(21  fc.property(doubleArb, ([a, b]) => {22    return doubleConstraints(a, b);23  })24);25const fc = require('fast-check');

Using AI Code Generation

1const fc = require("fast-check");2const { doubleConstraints } = require("fast-check-monorepo");3fc.assert(4  fc.property(5    doubleConstraints({6      a: fc.integer(0, 100),7      b: fc.integer(0, 100),8    }),9    (obj) => {10      console.log(obj);11      return true;12    }13);14{ a: 1, b: 1 }15{ a: 2, b: 2 }16{ a: 3, b: 3 }17{ a: 4, b: 4 }18{ a: 5, b: 5 }19{ a: 6, b: 6 }20{ a: 7, b: 7 }21{ a: 8, b: 8 }22{ a: 9, b: 9 }23{ a: 10, b: 10 }24{ a: 11, b: 11 }25{ a: 12, b: 12 }26{ a: 13, b: 13 }27{ a: 14, b: 14 }28{ a: 15, b: 15 }29{ a: 16, b: 16 }30{ a: 17, b: 17 }31{ a: 18, b: 18 }32{ a: 19, b: 19 }33{ a: 20, b: 20 }34{ a: 21, b: 21 }35{ a: 22, b: 22 }36{ a: 23, b: 23 }37{ a: 24, b: 24 }38{ a: 25, b: 25 }39{ a: 26, b: 26 }40{ a: 27, b: 27 }41{ a: 28, b: 28 }42{ a: 29, b: 29 }43{ a: 30, b: 30 }44{ a: 31, b: 31 }45{ a: 32, b: 32 }46{ a: 33, b: 33 }47{ a: 34, b: 34 }48{ a: 35

Using AI Code Generation

1import * as fc from 'fast-check';2const arb = fc.double({ next: true });3const arb2 = fc.double({ next: true, constraints: [0.1, 0.2] });4const arb3 = fc.double({ next: true, constraints: [0.1, 0.2] });5const arb4 = fc.double({ next: true, constraints: [0.1, 0.2] });6const arb5 = fc.double({ next: true, constraints: [0.1, 0.2] });7const arb6 = fc.double({ next: true, constraints: [0.1, 0.2] });8const arb7 = fc.double({ next: true, constraints: [0.1, 0.2] });9const arb8 = fc.double({ next: true, constraints: [0.1, 0.2] });10const arb9 = fc.double({ next: true, constraints: [0.1, 0.2] });11const arb10 = fc.double({ next: true, constraints: [0.1, 0.2] });12const arb11 = fc.double({ next: true, constraints: [0.1, 0.2] });13const arb12 = fc.double({ next: true, constraints: [0.1, 0.2] });14const arb13 = fc.double({ next: true, constraints: [0.1, 0.2] });15const arb14 = fc.double({ next: true, constraints: [0.1,

Using AI Code Generation

1const fc = require('fast-check');2const doubleConstraints = (a, b) => a + b >= 0;3const prop = (a, b) => doubleConstraints(a, b);4const prop2 = (a, b) => a + b >= 0;5const arb = fc.integer();6const prop3 = (a, b) => a + b >= 0;7const arb2 = fc.integer();8const arb3 = fc.integer();9const prop4 = (a, b) => a + b >= 0;10const arb4 = fc.integer();11fc.assert(12  fc.property(fc.integer(), fc.integer(), (a, b) => {13    return doubleConstraints(a, b);14  })15);16fc.assert(17  fc.property(fc.integer(), fc.integer(), (a, b) => {18    return a + b >= 0;19  })20);21fc.assert(22  fc.property(fc.integer(), fc.integer(), (a, b) => {23    return doubleConstraints(a, b);24  })25);26fc.assert(27  fc.property(fc.integer(), fc.integer(), (a, b) => {28    return a + b >= 0;29  })30);31fc.assert(32  fc.property(fc.integer(), fc.integer(), (a, b) => {33    return doubleConstraints(a, b);34  })35);36fc.assert(37  fc.property(fc.integer(), fc.integer(), (a, b) => {38    return a + b >= 0;39  })40);41fc.assert(42  fc.property(fc.integer(), fc.integer(), (a, b) => {43    return doubleConstraints(a, b);44  })45);46fc.assert(47  fc.property(fc.integer(), fc.integer(), (a, b) => {48    return a + b >= 0;49  })50);51fc.assert(52  fc.property(fc.integer(), fc.integer(), (a, b) => {53    return doubleConstraints(a, b);54  })55);56fc.assert(57  fc.property(fc.integer(), fc.integer(), (a, b) => {58    return a + b >= 0;59  })60);61fc.assert(62  fc.property(fc.integer(), fc.integer(), (a,

Using AI Code Generation

1const fc = require('fast-check');2const assert = require('assert');3const doubleConstraints = (a, b) => {4  return a + a === b;5};6  .integer()7  .chain(a => fc.tuple(fc.constant(a), fc.integer().filter(b => doubleConstraints(a, b))));8fc.assert(9  fc.property(doubleConstraintsArb, ([a, b]) => {10    assert.strictEqual(b, a + a);11  })12);13✓ should hold for all arbitraries (4ms)14✓ should hold for all generated values (4ms)15Ran 2 tests for 1 property in 7ms (skipped 0 tests)

Using AI Code Generation

1const fc = require('fast-check');2const doubleConstraints = (a, b) => {3    return a * 2 === b;4}5const doubleArb = fc.integer().map(x => x * 2);6fc.assert(7    fc.property(doubleArb, doubleArb, doubleConstraints)8);

Using AI Code Generation

1const { doubleConstraints } = require('fast-check');2const { double } = require('./test2.js');3const doubleConstraints = doubleConstraints({4        (input, output) => {5            return output > input;6        },7        (input, output) => {8            return output % 2 === 0;9        },10        (input, output) => {11            return output % 3 === 0;12        },13});14doubleConstraints(double);

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.