Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use relativeSizeToSize method in fast-check-monorepo

Best JavaScript code snippet using fast-check-monorepo

MaxLengthFromMinLength.spec.ts

Source:MaxLengthFromMinLength.spec.ts

...81        fc.boolean(),82        (config, size, lengthA, lengthB, specifiedMaxLength) => {83          // Arrange84          const { baseSize: defaultSize = DefaultSize } = config;85          const equivalentSize = relativeSizeToSize(size, defaultSize);86          const [minLength, maxLength] = lengthA < lengthB ? [lengthA, lengthB] : [lengthB, lengthA];87          // Act88          const computedLength = withConfiguredGlobal(config, () =>89            maxGeneratedLengthFromSizeForArbitrary(size, minLength, maxLength, specifiedMaxLength)90          );91          const expectedLength = maxGeneratedLengthFromSizeForArbitrary(92            equivalentSize,93            minLength,94            maxLength,95            specifiedMaxLength96          );97          // Assert98          expect(computedLength).toBe(expectedLength);99        }100      )101    );102  });103  it('should behave as its resolved Size when in unspecified max mode', () => {104    fc.assert(105      fc.property(106        sizeRelatedGlobalConfigArb,107        fc.oneof(sizeArb, relativeSizeArb),108        fc.integer({ min: 0, max: MaxLengthUpperBound }),109        fc.integer({ min: 0, max: MaxLengthUpperBound }),110        (config, size, lengthA, lengthB) => {111          // Arrange112          const resolvedSize = withConfiguredGlobal(config, () => resolveSize(size));113          const [minLength, maxLength] = lengthA < lengthB ? [lengthA, lengthB] : [lengthB, lengthA];114          // Act115          const computedLength = withConfiguredGlobal(config, () =>116            maxGeneratedLengthFromSizeForArbitrary(size, minLength, maxLength, false)117          );118          const expectedLength = withConfiguredGlobal(config, () =>119            maxGeneratedLengthFromSizeForArbitrary(resolvedSize, minLength, maxLength, false)120          );121          // Assert122          expect(computedLength).toBe(expectedLength);123        }124      )125    );126  });127  it('should only consider the received maxLength when set to "max"', () => {128    fc.assert(129      fc.property(130        sizeRelatedGlobalConfigArb,131        fc.integer({ min: 0, max: MaxLengthUpperBound }),132        fc.integer({ min: 0, max: MaxLengthUpperBound }),133        fc.boolean(),134        (config, lengthA, lengthB, specifiedMaxLength) => {135          // Arrange136          const size = 'max';137          const [minLength, maxLength] = lengthA < lengthB ? [lengthA, lengthB] : [lengthB, lengthA];138          // Act139          const computedLength = withConfiguredGlobal(config, () =>140            maxGeneratedLengthFromSizeForArbitrary(size, minLength, maxLength, specifiedMaxLength)141          );142          // Assert143          expect(computedLength).toBe(maxLength);144        }145      )146    );147  });148  it('should ignore specifiedMaxLength whenever size specified', () => {149    fc.assert(150      fc.property(151        sizeRelatedGlobalConfigArb,152        sizeForArbitraryArb,153        fc.integer({ min: 0, max: MaxLengthUpperBound }),154        fc.integer({ min: 0, max: MaxLengthUpperBound }),155        (config, size, lengthA, lengthB) => {156          // Arrange157          const [minLength, maxLength] = lengthA < lengthB ? [lengthA, lengthB] : [lengthB, lengthA];158          // Act159          const computedLength = withConfiguredGlobal(config, () =>160            maxGeneratedLengthFromSizeForArbitrary(size, minLength, maxLength, false)161          );162          const expectedLength = withConfiguredGlobal(config, () =>163            maxGeneratedLengthFromSizeForArbitrary(size, minLength, maxLength, true)164          );165          // Assert166          expect(computedLength).toBe(expectedLength);167        }168      )169    );170  });171  it('should fallback to "max" whenever no size specified but maxLength specified when defaultSizeToMaxWhenMaxSpecified true or unset', () => {172    fc.assert(173      fc.property(174        sizeRelatedGlobalConfigArb,175        fc.integer({ min: 0, max: MaxLengthUpperBound }),176        fc.integer({ min: 0, max: MaxLengthUpperBound }),177        (incompleteConfig, lengthA, lengthB) => {178          // Arrange179          const config = { ...incompleteConfig, defaultSizeToMaxWhenMaxSpecified: true };180          const [minLength, maxLength] = lengthA < lengthB ? [lengthA, lengthB] : [lengthB, lengthA];181          // Act182          const computedLength = withConfiguredGlobal(config, () =>183            maxGeneratedLengthFromSizeForArbitrary(undefined, minLength, maxLength, true)184          );185          const expectedLength = withConfiguredGlobal(config, () =>186            maxGeneratedLengthFromSizeForArbitrary('max', minLength, maxLength, true)187          );188          // Assert189          expect(computedLength).toBe(expectedLength);190        }191      )192    );193  });194  it('should fallback to baseSize (or default) whenever no size specified and no maxLength specified', () => {195    fc.assert(196      fc.property(197        sizeRelatedGlobalConfigArb,198        fc.integer({ min: 0, max: MaxLengthUpperBound }),199        fc.integer({ min: 0, max: MaxLengthUpperBound }),200        (config, lengthA, lengthB) => {201          // Arrange202          const [minLength, maxLength] = lengthA < lengthB ? [lengthA, lengthB] : [lengthB, lengthA];203          const { baseSize: defaultSize = DefaultSize } = config;204          // Act205          const computedLength = withConfiguredGlobal(config, () =>206            maxGeneratedLengthFromSizeForArbitrary(undefined, minLength, maxLength, false)207          );208          const expectedLength = maxGeneratedLengthFromSizeForArbitrary(defaultSize, minLength, maxLength, false);209          // Assert210          expect(computedLength).toBe(expectedLength);211        }212      )213    );214  });215  it('should always return a length being between minLength and maxLength', () => {216    fc.assert(217      fc.property(218        sizeRelatedGlobalConfigArb,219        fc.option(sizeForArbitraryArb, { nil: undefined }),220        fc.integer({ min: 0, max: MaxLengthUpperBound }),221        fc.integer({ min: 0, max: MaxLengthUpperBound }),222        fc.boolean(),223        (config, size, lengthA, lengthB, specifiedMaxLength) => {224          // Arrange225          const [minLength, maxLength] = lengthA < lengthB ? [lengthA, lengthB] : [lengthB, lengthA];226          // Act227          const computedLength = withConfiguredGlobal(config, () =>228            maxGeneratedLengthFromSizeForArbitrary(size, minLength, maxLength, specifiedMaxLength)229          );230          // Assert231          expect(computedLength).toBeGreaterThanOrEqual(minLength);232          expect(computedLength).toBeLessThanOrEqual(maxLength);233        }234      )235    );236  });237});238describe('depthSizeFromSizeForArbitrary', () => {239  it('should only consider the received depthSize when set to a numeric value', () => {240    fc.assert(241      fc.property(242        sizeRelatedGlobalConfigArb,243        fc.double({ min: 0 }),244        fc.boolean(),245        (config, size, specifiedMaxDepth) => {246          // Arrange / Act247          const computedDepthBias = withConfiguredGlobal(config, () =>248            depthBiasFromSizeForArbitrary(size, specifiedMaxDepth)249          );250          // Assert251          expect(computedDepthBias).toBe(1 / size);252        }253      )254    );255  });256  it('should only consider the received size when set to Size', () => {257    fc.assert(258      fc.property(sizeRelatedGlobalConfigArb, sizeArb, fc.boolean(), (config, size, specifiedMaxDepth) => {259        // Arrange / Act260        const computedDepthBias = withConfiguredGlobal(config, () =>261          depthBiasFromSizeForArbitrary(size, specifiedMaxDepth)262        );263        const expectedDepthBias = { xsmall: 1, small: 1 / 2, medium: 1 / 4, large: 1 / 8, xlarge: 1 / 16 }[size];264        // Assert265        expect(computedDepthBias).toBe(expectedDepthBias);266      })267    );268  });269  it('should behave as its equivalent Size taking into account global settings when receiving a RelativeSize', () => {270    fc.assert(271      fc.property(sizeRelatedGlobalConfigArb, relativeSizeArb, fc.boolean(), (config, size, specifiedMaxDepth) => {272        // Arrange273        const { baseSize: defaultSize = DefaultSize } = config;274        const equivalentSize = relativeSizeToSize(size, defaultSize);275        // Act276        const computedDepthBias = withConfiguredGlobal(config, () =>277          depthBiasFromSizeForArbitrary(size, specifiedMaxDepth)278        );279        const expectedDepthBias = depthBiasFromSizeForArbitrary(equivalentSize, false);280        // Assert281        expect(computedDepthBias).toBe(expectedDepthBias);282      })283    );284  });285  it('should always return 0 if size is max whatever the global configuration', () => {286    fc.assert(287      fc.property(sizeRelatedGlobalConfigArb, fc.boolean(), (config, specifiedMaxDepth) => {288        // Arrange / Act289        const computedDepthBias = withConfiguredGlobal(config, () =>290          depthBiasFromSizeForArbitrary('max', specifiedMaxDepth)291        );292        // Assert293        expect(computedDepthBias).toBe(0);294      })295    );296  });297  it('should always return 0 if both specifiedMaxDepth and defaultSizeToMaxWhenMaxSpecified are true and size unset', () => {298    fc.assert(299      fc.property(sizeRelatedGlobalConfigArb, (config) => {300        // Arrange / Act301        const computedDepthBias = withConfiguredGlobal({ ...config, defaultSizeToMaxWhenMaxSpecified: true }, () =>302          depthBiasFromSizeForArbitrary(undefined, true)303        );304        // Assert305        expect(computedDepthBias).toBe(0);306      })307    );308  });309});310describe('relativeSizeToSize', () => {311  it('should offset by -4 when "-4"', () => {312    const relativeSize = '-4';313    expect(relativeSizeToSize(relativeSize, 'xsmall')).toBe('xsmall');314    expect(relativeSizeToSize(relativeSize, 'small')).toBe('xsmall');315    expect(relativeSizeToSize(relativeSize, 'medium')).toBe('xsmall');316    expect(relativeSizeToSize(relativeSize, 'large')).toBe('xsmall');317    expect(relativeSizeToSize(relativeSize, 'xlarge')).toBe('xsmall');318  });319  it('should offset by -1 when "-1"', () => {320    const relativeSize = '-1';321    expect(relativeSizeToSize(relativeSize, 'xsmall')).toBe('xsmall');322    expect(relativeSizeToSize(relativeSize, 'small')).toBe('xsmall');323    expect(relativeSizeToSize(relativeSize, 'medium')).toBe('small');324    expect(relativeSizeToSize(relativeSize, 'large')).toBe('medium');325    expect(relativeSizeToSize(relativeSize, 'xlarge')).toBe('large');326  });327  it('should not offset when "="', () => {328    const relativeSize = '=';329    expect(relativeSizeToSize(relativeSize, 'xsmall')).toBe('xsmall');330    expect(relativeSizeToSize(relativeSize, 'small')).toBe('small');331    expect(relativeSizeToSize(relativeSize, 'medium')).toBe('medium');332    expect(relativeSizeToSize(relativeSize, 'large')).toBe('large');333    expect(relativeSizeToSize(relativeSize, 'xlarge')).toBe('xlarge');334  });335  it('should offset by +1 when "+1"', () => {336    const relativeSize = '+1';337    expect(relativeSizeToSize(relativeSize, 'xsmall')).toBe('small');338    expect(relativeSizeToSize(relativeSize, 'small')).toBe('medium');339    expect(relativeSizeToSize(relativeSize, 'medium')).toBe('large');340    expect(relativeSizeToSize(relativeSize, 'large')).toBe('xlarge');341    expect(relativeSizeToSize(relativeSize, 'xlarge')).toBe('xlarge');342  });343  it('should offset by +4 when "+4"', () => {344    const relativeSize = '+4';345    expect(relativeSizeToSize(relativeSize, 'xsmall')).toBe('xlarge');346    expect(relativeSizeToSize(relativeSize, 'small')).toBe('xlarge');347    expect(relativeSizeToSize(relativeSize, 'medium')).toBe('xlarge');348    expect(relativeSizeToSize(relativeSize, 'large')).toBe('xlarge');349    expect(relativeSizeToSize(relativeSize, 'xlarge')).toBe('xlarge');350  });...

MaxLengthFromMinLength.ts

Source:MaxLengthFromMinLength.ts

...86/**87 * Transform a RelativeSize|Size into a Size88 * @internal89 */90export function relativeSizeToSize(size: Size | RelativeSize, defaultSize: Size): Size {91  const sizeInRelative = safeIndexOf(orderedRelativeSize, size as RelativeSize);92  if (sizeInRelative === -1) {93    return size as Size;94  }95  const defaultSizeInSize = safeIndexOf(orderedSize, defaultSize);96  if (defaultSizeInSize === -1) {97    throw new Error(`Unable to offset size based on the unknown defaulted one: ${defaultSize}`);98  }99  const resultingSizeInSize = defaultSizeInSize + sizeInRelative - 4;100  return resultingSizeInSize < 0101    ? orderedSize[0]102    : resultingSizeInSize >= orderedSize.length103    ? orderedSize[orderedSize.length - 1]104    : orderedSize[resultingSizeInSize];105}106/**107 * Compute `maxGeneratedLength` based on `minLength`, `maxLength` and `size`108 * @param size - Size defined by the caller on the arbitrary109 * @param minLength - Considered minimal length110 * @param maxLength - Considered maximal length111 * @param specifiedMaxLength - Whether or not the caller specified the max (true) or if it has been defaulted (false)112 * @internal113 */114export function maxGeneratedLengthFromSizeForArbitrary(115  size: SizeForArbitrary | undefined,116  minLength: number,117  maxLength: number,118  specifiedMaxLength: boolean119): number {120  const { baseSize: defaultSize = DefaultSize, defaultSizeToMaxWhenMaxSpecified } = readConfigureGlobal() || {};121  // Resulting size is:122  // - If size has been defined, we use it,123  // - Otherwise (size=undefined), we default it to:124  //   - If caller specified a maxLength and asked for defaultSizeToMaxWhenMaxSpecified, then 'max'125  //   - Otherwise, defaultSize126  const definedSize =127    size !== undefined ? size : specifiedMaxLength && defaultSizeToMaxWhenMaxSpecified ? 'max' : defaultSize;128  if (definedSize === 'max') {129    return maxLength;130  }131  const finalSize = relativeSizeToSize(definedSize, defaultSize);132  return safeMathMin(maxLengthFromMinLength(minLength, finalSize), maxLength);133}134/**135 * Compute `depthSize` based on `size`136 * @param size - Size or depthSize defined by the caller on the arbitrary137 * @param specifiedMaxDepth - Whether or not the caller specified a max depth138 * @internal139 */140export function depthBiasFromSizeForArbitrary(depthSizeOrSize: DepthSize, specifiedMaxDepth: boolean): number {141  if (typeof depthSizeOrSize === 'number') {142    return 1 / depthSizeOrSize;143  }144  const { baseSize: defaultSize = DefaultSize, defaultSizeToMaxWhenMaxSpecified } = readConfigureGlobal() || {};145  const definedSize =146    depthSizeOrSize !== undefined147      ? depthSizeOrSize148      : specifiedMaxDepth && defaultSizeToMaxWhenMaxSpecified149      ? 'max'150      : defaultSize;151  if (definedSize === 'max') {152    return 0; // 1 / +infinity153  }154  const finalSize = relativeSizeToSize(definedSize, defaultSize);155  switch (finalSize) {156    case 'xsmall':157      return 1;158    case 'small':159      return 0.5; // = 1/2160    case 'medium':161      return 0.25; // = 1/4162    case 'large':163      return 0.125; // = 1/8164    case 'xlarge':165      return 0.0625; // = 1/16166  }167}168/**169 * Resolve the size that should be used given the current context170 * @param size - Size defined by the caller on the arbitrary171 */172export function resolveSize(size: Exclude<SizeForArbitrary, 'max'> | undefined): Size {173  const { baseSize: defaultSize = DefaultSize } = readConfigureGlobal() || {};174  if (size === undefined) {175    return defaultSize;176  }177  return relativeSizeToSize(size, defaultSize);...

webUrl.ts

Source:webUrl.ts

...57  const c = constraints || {};58  const resolvedSize = resolveSize(c.size);59  const resolvedAuthoritySettingsSize =60    c.authoritySettings !== undefined && c.authoritySettings.size !== undefined61      ? relativeSizeToSize(c.authoritySettings.size, resolvedSize)62      : resolvedSize;63  // TODO - Move back to object spreading as soon as we bump support from es2017 to es2018+64  const resolvedAuthoritySettings = safeObjectAssign(safeObjectAssign({}, c.authoritySettings), {65    size: resolvedAuthoritySettingsSize,66  });67  const validSchemes = c.validSchemes || ['http', 'https'];68  const schemeArb = constantFrom(...validSchemes);69  const authorityArb = webAuthority(resolvedAuthoritySettings);70  const pathArb = buildUriPathArbitrary(resolvedSize);71  return tuple(72    schemeArb,73    authorityArb,74    pathArb,75    c.withQueryParameters === true ? option(webQueryParameters({ size: resolvedSize })) : constant(null),...

Using AI Code Generation

1var fc = require("fast-check");2var size = 100;3var relativeSize = 0.5;4var newSize = fc.relativeSizeToSize(relativeSize, size);5console.log(newSize);6var fc = require("fast-check");7var size = 100;8var newSize = 50;9var relativeSize = fc.sizeToRelativeSize(newSize, size);10console.log(relativeSize);11var fc = require("fast-check");12var seed = 42;13var path = "./test6.js";14fc.configureGlobal({ seed: seed, path: path });15console.log(fc.readConfigureGlobal());16var fc = require("fast-check");17console.log(fc.readConfigureGlobal());18var fc = require("fast-check");19var seed = 42;20var path = "./test8.js";21fc.configureGlobal({ seed: seed, path: path });22console.log(fc.readConfigureGlobal());23var fc = require("fast-check");24console.log(fc.readConfigureGlobal());25var fc = require("fast-check");26var seed = 42;27var path = "./test10.js";28fc.configureGlobal({ seed: seed, path: path });29console.log(fc.readConfigureGlobal());30var fc = require("fast-check");31console.log(fc.readConfigureGlobal());32var fc = require("fast-check");33var seed = 42;34var path = "./test12.js";35fc.configureGlobal({ seed: seed, path: path });36console.log(fc.readConfigureGlobal());37var fc = require("fast-check");38console.log(fc.readConfigureGlobal

Using AI Code Generation

1const fc = require('fast-check');2const FloatArbitrary = require('fast-check/lib/arbitrary/_internals/FloatArbitrary');3const floatArb = FloatArbitrary.float();4const floatArb1 = floatArb.relativeSizeToSize(0, 1);5fc.assert(fc.property(floatArb1, (x) => {6  console.log(x);7  return x >= 0 && x <= 1;8}));9const fc = require('fast-check');10const FloatArbitrary = require('fast-check/lib/arbitrary/_internals/FloatArbitrary');11const floatArb = FloatArbitrary.float();12const floatArb1 = floatArb.relativeSizeToSize(0, 1);13fc.assert(fc.property(floatArb1, (x) => {14  console.log(x);15  return x >= 0 && x <= 1;16}));17const fc = require('fast-check');18const FloatArbitrary = require('fast-check/lib/arbitrary/_internals/FloatArbitrary');19const floatArb = FloatArbitrary.float();20const floatArb1 = floatArb.relativeSizeToSize(0, 1);21fc.assert(fc.property(floatArb1, (x) => {22  console.log(x);23  return x >= 0 && x <= 1;24}));25const fc = require('fast-check');26const FloatArbitrary = require('fast-check/lib/arbitrary/_internals/FloatArbitrary');27const floatArb = FloatArbitrary.float();28const floatArb1 = floatArb.relativeSizeToSize(0, 1);

Using AI Code Generation

1const fc = require("fast-check");2const { relativeSizeToSize } = require("fast-check/lib/check/arbitrary/SizeArbitrary.js");3const size = relativeSizeToSize(10, 0, 10);4const fc = require("fast-check");5const { relativeSizeToSize } = require("fast-check/lib/check/arbitrary/SizeArbitrary.js");6const size = relativeSizeToSize(10, 10, 20);

Using AI Code Generation

1import { relativeSizeToSize } from 'fast-check';2const size = relativeSizeToSize(1, 100, 10);3console.log(size);4Fast-check: A Quick Introduction (Part 2)5Fast-check: A Quick Introduction (Part 3)6Fast-check: A Quick Introduction (Part 4)7Fast-check: A Quick Introduction (Part 5)8Fast-check: A Quick Introduction (Part 6)9Fast-check: A Quick Introduction (Part 7)10Fast-check: A Quick Introduction (Part 8)11Fast-check: A Quick Introduction (Part 9)12Fast-check: A Quick Introduction (Part 10)13Fast-check: A Quick Introduction (Part 11)14Fast-check: A Quick Introduction (Part 12)15Fast-check: A Quick Introduction (Part 13)16Fast-check: A Quick Introduction (Part 14)17Fast-check: A Quick Introduction (Part 15)18Fast-check: A Quick Introduction (Part 16)19Fast-check: A Quick Introduction (Part 17)20Fast-check: A Quick Introduction (Part 18)21Fast-check: A Quick Introduction (Part 19)22Fast-check: A Quick Introduction (Part 20)23Fast-check: A Quick Introduction (Part 21)24Fast-check: A Quick Introduction (Part 22)25Fast-check: A Quick Introduction (Part 23)26Fast-check: A Quick Introduction (Part 24)27Fast-check: A Quick Introduction (Part 25)28Fast-check: A Quick Introduction (Part 26)29Fast-check: A Quick Introduction (Part 27)30Fast-check: A Quick Introduction (Part 28)31Fast-check: A Quick Introduction (Part 29)32Fast-check: A Quick Introduction (Part 30)33Fast-check: A Quick Introduction (Part 31)34Fast-check: A Quick Introduction (Part 32)35Fast-check: A Quick Introduction (Part 33)36Fast-check: A Quick Introduction (Part 34)

Using AI Code Generation

1const fc = require('../lib/fast-check');2const { relativeSizeToSize } = require('../lib/check/arbitrary/definition/SizeArbitrary.js');3const { Size } = require('../lib/check/arbitrary/definition/SizeArbitrary.js');4const size = new Size(100);5console.log(relativeSizeToSize(size, 100));6console.log(relativeSizeToSize(size, 0));7console.log(relativeSizeToSize(size, -50));8console.log(relativeSizeToSize(size, 50));9console.log(relativeSizeToSize(size, 100));10console.log(relativeSizeToSize(size, 101));11console.log(relativeSizeToSize(size, 200));12console.log(relativeSizeToSize(size, 1000));

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.