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

Copied to Clipboard!

How to use testArbitrary method in fast-check-monorepo

Best JavaScript code snippet using fast-check-monorepo

collections.js

Source:collections.js

1// Copyright 2011 the V8 project authors. All rights reserved.2// Redistribution and use in source and binary forms, with or without3// modification, are permitted provided that the following conditions are4// met:5//6//     * Redistributions of source code must retain the above copyright7//       notice, this list of conditions and the following disclaimer.8//     * Redistributions in binary form must reproduce the above9//       copyright notice, this list of conditions and the following10//       disclaimer in the documentation and/or other materials provided11//       with the distribution.12//     * Neither the name of Google Inc. nor the names of its13//       contributors may be used to endorse or promote products derived14//       from this software without specific prior written permission.15//16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.27// Flags: --harmony-collections --expose-gc28// Test valid getter and setter calls on Sets.29function TestValidSetCalls(m) {30  assertDoesNotThrow(function () { m.add(new Object) });31  assertDoesNotThrow(function () { m.has(new Object) });32  assertDoesNotThrow(function () { m.delete(new Object) });33}34TestValidSetCalls(new Set);35// Test valid getter and setter calls on Maps and WeakMaps36function TestValidMapCalls(m) {37  assertDoesNotThrow(function () { m.get(new Object) });38  assertDoesNotThrow(function () { m.set(new Object) });39  assertDoesNotThrow(function () { m.has(new Object) });40  assertDoesNotThrow(function () { m.delete(new Object) });41}42TestValidMapCalls(new Map);43TestValidMapCalls(new WeakMap);44// Test invalid getter and setter calls for WeakMap only45function TestInvalidCalls(m) {46  assertThrows(function () { m.get(undefined) }, TypeError);47  assertThrows(function () { m.set(undefined, 0) }, TypeError);48  assertThrows(function () { m.get(null) }, TypeError);49  assertThrows(function () { m.set(null, 0) }, TypeError);50  assertThrows(function () { m.get(0) }, TypeError);51  assertThrows(function () { m.set(0, 0) }, TypeError);52  assertThrows(function () { m.get('a-key') }, TypeError);53  assertThrows(function () { m.set('a-key', 0) }, TypeError);54}55TestInvalidCalls(new WeakMap);56// Test expected behavior for Sets57function TestSet(set, key) {58  assertFalse(set.has(key));59  set.add(key);60  assertTrue(set.has(key));61  set.delete(key);62  assertFalse(set.has(key));63}64function TestSetBehavior(set) {65  for (var i = 0; i < 20; i++) {66    TestSet(set, new Object);67    TestSet(set, i);68    TestSet(set, i / 100);69    TestSet(set, 'key-' + i);70  }71  var keys = [ +0, -0, +Infinity, -Infinity, true, false, null, undefined ];72  for (var i = 0; i < keys.length; i++) {73    TestSet(set, keys[i]);74  }75}76TestSetBehavior(new Set);77// Test expected mapping behavior for Maps and WeakMaps78function TestMapping(map, key, value) {79  map.set(key, value);80  assertSame(value, map.get(key));81}82function TestMapBehavior1(m) {83  TestMapping(m, new Object, 23);84  TestMapping(m, new Object, 'the-value');85  TestMapping(m, new Object, new Object);86}87TestMapBehavior1(new Map);88TestMapBehavior1(new WeakMap);89// Test expected mapping behavior for Maps only90function TestMapBehavior2(m) {91  for (var i = 0; i < 20; i++) {92    TestMapping(m, i, new Object);93    TestMapping(m, i / 10, new Object);94    TestMapping(m, 'key-' + i, new Object);95  }96  var keys = [ +0, -0, +Infinity, -Infinity, true, false, null, undefined ];97  for (var i = 0; i < keys.length; i++) {98    TestMapping(m, keys[i], new Object);99  }100}101TestMapBehavior2(new Map);102// Test expected querying behavior of Maps and WeakMaps103function TestQuery(m) {104  var key = new Object;105  TestMapping(m, key, 'to-be-present');106  assertTrue(m.has(key));107  assertFalse(m.has(new Object));108  TestMapping(m, key, undefined);109  assertFalse(m.has(key));110  assertFalse(m.has(new Object));111}112TestQuery(new Map);113TestQuery(new WeakMap);114// Test expected deletion behavior of Maps and WeakMaps115function TestDelete(m) {116  var key = new Object;117  TestMapping(m, key, 'to-be-deleted');118  assertTrue(m.delete(key));119  assertFalse(m.delete(key));120  assertFalse(m.delete(new Object));121  assertSame(m.get(key), undefined);122}123TestDelete(new Map);124TestDelete(new WeakMap);125// Test GC of Maps and WeakMaps with entry126function TestGC1(m) {127  var key = new Object;128  m.set(key, 'not-collected');129  gc();130  assertSame('not-collected', m.get(key));131}132TestGC1(new Map);133TestGC1(new WeakMap);134// Test GC of Maps and WeakMaps with chained entries135function TestGC2(m) {136  var head = new Object;137  for (key = head, i = 0; i < 10; i++, key = m.get(key)) {138    m.set(key, new Object);139  }140  gc();141  var count = 0;142  for (key = head; key != undefined; key = m.get(key)) {143    count++;144  }145  assertEquals(11, count);146}147TestGC2(new Map);148TestGC2(new WeakMap);149// Test property attribute [[Enumerable]]150function TestEnumerable(func) {151  function props(x) {152    var array = [];153    for (var p in x) array.push(p);154    return array.sort();155  }156  assertArrayEquals([], props(func));157  assertArrayEquals([], props(func.prototype));158  assertArrayEquals([], props(new func()));159}160TestEnumerable(Set);161TestEnumerable(Map);162TestEnumerable(WeakMap);163// Test arbitrary properties on Maps and WeakMaps164function TestArbitrary(m) {165  function TestProperty(map, property, value) {166    map[property] = value;167    assertEquals(value, map[property]);168  }169  for (var i = 0; i < 20; i++) {170    TestProperty(m, i, 'val' + i);171    TestProperty(m, 'foo' + i, 'bar' + i);172  }173  TestMapping(m, new Object, 'foobar');174}175TestArbitrary(new Map);176TestArbitrary(new WeakMap);177// Test direct constructor call178assertTrue(Set() instanceof Set);179assertTrue(Map() instanceof Map);180assertTrue(WeakMap() instanceof WeakMap);181// Test whether NaN values as keys are treated correctly.182var s = new Set;183assertFalse(s.has(NaN));184assertFalse(s.has(NaN + 1));185assertFalse(s.has(23));186s.add(NaN);187assertTrue(s.has(NaN));188assertTrue(s.has(NaN + 1));189assertFalse(s.has(23));190var m = new Map;191assertFalse(m.has(NaN));192assertFalse(m.has(NaN + 1));193assertFalse(m.has(23));194m.set(NaN, 'a-value');195assertTrue(m.has(NaN));196assertTrue(m.has(NaN + 1));197assertFalse(m.has(23));198// Test some common JavaScript idioms for Sets199var s = new Set;200assertTrue(s instanceof Set);201assertTrue(Set.prototype.add instanceof Function)202assertTrue(Set.prototype.has instanceof Function)203assertTrue(Set.prototype.delete instanceof Function)204// Test some common JavaScript idioms for Maps205var m = new Map;206assertTrue(m instanceof Map);207assertTrue(Map.prototype.set instanceof Function)208assertTrue(Map.prototype.get instanceof Function)209assertTrue(Map.prototype.has instanceof Function)210assertTrue(Map.prototype.delete instanceof Function)211// Test some common JavaScript idioms for WeakMaps212var m = new WeakMap;213assertTrue(m instanceof WeakMap);214assertTrue(WeakMap.prototype.set instanceof Function)215assertTrue(WeakMap.prototype.get instanceof Function)216assertTrue(WeakMap.prototype.has instanceof Function)217assertTrue(WeakMap.prototype.delete instanceof Function)218// Regression test for WeakMap prototype.219assertTrue(WeakMap.prototype.constructor === WeakMap)220assertTrue(Object.getPrototypeOf(WeakMap.prototype) === Object.prototype)221// Regression test for issue 1617: The prototype of the WeakMap constructor222// needs to be unique (i.e. different from the one of the Object constructor).223assertFalse(WeakMap.prototype === Object.prototype);224var o = Object.create({});225assertFalse("get" in o);226assertFalse("set" in o);227assertEquals(undefined, o.get);228assertEquals(undefined, o.set);229var o = Object.create({}, { myValue: {230  value: 10,231  enumerable: false,232  configurable: true,233  writable: true234}});235assertEquals(10, o.myValue);236// Regression test for issue 1884: Invoking any of the methods for Harmony237// maps, sets, or weak maps, with a wrong type of receiver should be throwing238// a proper TypeError.239var alwaysBogus = [ undefined, null, true, "x", 23, {} ];240var bogusReceiversTestSet = [241  { proto: Set.prototype,242    funcs: [ 'add', 'has', 'delete' ],243    receivers: alwaysBogus.concat([ new Map, new WeakMap ]),244  },245  { proto: Map.prototype,246    funcs: [ 'get', 'set', 'has', 'delete' ],247    receivers: alwaysBogus.concat([ new Set, new WeakMap ]),248  },249  { proto: WeakMap.prototype,250    funcs: [ 'get', 'set', 'has', 'delete' ],251    receivers: alwaysBogus.concat([ new Set, new Map ]),252  },253];254function TestBogusReceivers(testSet) {255  for (var i = 0; i < testSet.length; i++) {256    var proto = testSet[i].proto;257    var funcs = testSet[i].funcs;258    var receivers = testSet[i].receivers;259    for (var j = 0; j < funcs.length; j++) {260      var func = proto[funcs[j]];261      for (var k = 0; k < receivers.length; k++) {262        assertThrows(function () { func.call(receivers[k], {}) }, TypeError);263      }264    }265  }266}267TestBogusReceivers(bogusReceiversTestSet);268// Stress Test269// There is a proposed stress-test available at the es-discuss mailing list270// which cannot be reasonably automated.  Check it out by hand if you like:...

main.js

Source:main.js

1// @ts-check2var assert = require('assert');3var fc = require('fast-check');4function testArbitrary(arb) {5  // should not crash if running a succesful property6  fc.assert(7    fc.property(arb, function () {8      return true;9    })10  );11  // should be able to detect failing runs and report them correctly12  // should be able to shrink with no crash13  var successfulAssert = true;14  try {15    var runId = 0;16    fc.assert(17      fc.property(arb, function () {18        return runId++ % 3 === 0;19      })20    );21    successfulAssert = false;22  } catch (e) {23    successfulAssert = successfulAssert && e.constructor.name === 'Error';24    successfulAssert = successfulAssert && e.message.indexOf('Property failed after') === 0;25  }26  assert.ok(successfulAssert, 'Assert failed with an unexpected failure');27  // should be able to replay a failing case28  var runId = 0;29  var details = fc.check(30    fc.property(arb, function () {31      return runId++ % 3 === 0;32    })33  );34  var replay = fc.sample(arb, { seed: details.seed, path: details.counterexamplePath });35  assert.deepEqual(replay[0], details.counterexample[0]);36  // should be able to retrieve statistics37  var stats = [];38  fc.statistics(39    arb,40    function (data) {41      return String(String(data).length);42    },43    {44      logger: function (l) {45        stats.push(l);46      },47    }48  );49  assert.notEqual(stats.length, 0);50}51testArbitrary(fc.nat());52testArbitrary(fc.subarray([1, 42, 360]));53testArbitrary(fc.array(fc.nat()));54testArbitrary(fc.json());55testArbitrary(fc.string());56testArbitrary(fc.fullUnicodeString());57testArbitrary(fc.lorem());58testArbitrary(fc.uuid());59testArbitrary(fc.oneof(fc.nat(), fc.double()));60testArbitrary(fc.oneof({ weight: 1, arbitrary: fc.nat() }, { weight: 2, arbitrary: fc.double() }));61testArbitrary(fc.maxSafeInteger());62testArbitrary(fc.float({ noNaN: true })); // NaN is not properly recognize with assert.deepEqual63testArbitrary(fc.double({ noNaN: true }));64testArbitrary(fc.emailAddress());65testArbitrary(fc.webUrl());66testArbitrary(fc.int8Array());67testArbitrary(fc.int16Array());68testArbitrary(fc.int32Array());69testArbitrary(fc.float32Array());70testArbitrary(fc.float64Array());71testArbitrary(72  fc.mapToConstant(73    {74      num: 26,75      build: function (v) {76        return String.fromCharCode(v + 0x61);77      },78    },79    {80      num: 10,81      build: function (v) {82        return String.fromCharCode(v + 0x30);83      },84    }85  )86);87testArbitrary(88  fc.letrec(function (tie) {89    return {90      tree: fc.oneof({ depthSize: 'small' }, tie('leaf'), tie('node')),91      node: fc.tuple(tie('tree'), tie('tree')),92      leaf: fc.nat(),93    };94  }).tree95);96testArbitrary(97  (function () {98    const tree = fc.memo(function (n) {99      return fc.oneof(node(n), leaf());100    });101    const node = fc.memo(function (n) {102      if (n <= 1) return fc.record({ left: leaf(), right: leaf() });103      return fc.record({ left: tree(), right: tree() });104    });105    const leaf = fc.nat;106    return tree();107  })()108);109(function testGlobalParameters() {110  // Initial global parameters...

connection-state.test.js

Source:connection-state.test.js

...10    it('should return false for SUSPENDED, LOST', function testFalse() {11      expect(ConnectionState.SUSPENDED.isConnected()).to.be.false;12      expect(ConnectionState.LOST.isConnected()).to.be.false;13    });14    it('should return correct value for arbitrary state', function testArbitrary() {15      expect(ConnectionState(-1, true).isConnected()).to.be.true;16      expect(ConnectionState(-2, false).isConnected()).to.be.false;17    });18  });19  describe('#toString()', function toStringTestSuite() {20    it('should return string representation', function testUsualCase() {21      expect(ConnectionState.CONNECTED.toString()).to.equal('CONNECTED[0]');22      expect(String(ConnectionState.CONNECTED)).to.equal('CONNECTED[0]');23    });24    it('should return correct value for arbitrary state', function testArbitrary() {25      expect(ConnectionState(-1, 'WHATEVER', true).toString()).to.equal('WHATEVER[-1]');26      expect(String(ConnectionState(-1, 'WHATEVER', true))).to.equal('WHATEVER[-1]');27    });28  });29  describe('#valueOf', function valueOfTestSuite() {30    it('should return state numeric Id', function testUsualCase() {31      expect(ConnectionState.CONNECTED.valueOf()).to.be.a('number');32    });33    it('should return correct value for arbitrary state', function testArbitrary() {34      expect(ConnectionState(-1, true).valueOf()).to.equal(-1);35    });36  });...

Using AI Code Generation

1const fc = require('fast-check');2fc.assert(3  fc.property(fc.integer(), fc.integer(), (a, b) => {4    return a + b > a;5  })6);7fc.assert(8  fc.property(fc.integer(), fc.integer(), (a, b) => {9    return a + b > a;10  }),11  { verbose: true }12);13fc.assert(14  fc.property(fc.integer(), fc.integer(), (a, b) => {15    return a + b > a;16  }),17  { seed: 42 }18);19fc.assert(20  fc.property(fc.integer(), fc.integer(), (a, b) => {21    return a + b > a;22  }),23  { numRuns: 1000 }24);25fc.assert(26  fc.property(fc.integer(), fc.integer(), (a, b) => {27    return a + b > a;28  }),29  { endOnFailure: true }30);31fc.assert(32  fc.property(fc.integer(), fc.integer(), (a, b) => {33    return a + b > a;34  }),35  { endOnFailure: false }36);37fc.assert(38  fc.property(fc.integer(), fc.integer(), (a, b) => {39    return a + b > a;40  }),41  { asyncReporter: true }42);43fc.assert(44  fc.property(fc.integer(), fc.integer(), (a, b) => {45    return a + b > a;46  }),47  { asyncReporter: false }48);49fc.assert(50  fc.property(fc.integer(), fc.integer(), (a, b) => {51    return a + b > a;52  }),53  { asyncReporter: true },54  { verbose: true }55);56fc.assert(57  fc.property(fc.integer(), fc.integer(), (a, b) => {58    return a + b > a;59  }),60  { asyncReporter: true },61  { seed: 42 }62);63fc.assert(64  fc.property(fc.integer(), fc.integer(), (a, b) => {65    return a + b > a;66  }),67  { asyncReporter: true },68  { numRuns: 1000 }69);70fc.assert(71  fc.property(fc.integer(), fc.integer(), (a, b) => {72    return a + b > a;73  }),74  { asyncReporter: true },75  { endOnFailure: true }76);77fc.assert(78  fc.property(fc.integer(), fc.integer(), (a, b) => {

Using AI Code Generation

1import * as fc from 'fast-check';2fc.testArbitrary(fc.integer(), (value) => {3  console.log(value);4});5import * as fc from 'fast-check';6fc.testArbitrary(fc.integer(), (value) => {7  console.log(value);8});

Using AI Code Generation

1const { testArbitrary } = require("fast-check");2testArbitrary(3  fc.array(fc.integer()),4  (data) => {5    console.log(data);6    return true;7  },8  { numRuns: 5 }9);10const { testArbitrary } = require("fast-check");11testArbitrary(12  fc.array(fc.integer()),13  (data) => {14    console.log(data);15    return true;16  },17  { numRuns: 5 }18);19const { testArbitrary } = require("fast-check");20testArbitrary(21  fc.array(fc.integer()),22  (data) => {23    console.log(data);24    return true;25  },26  { numRuns: 5 }27);28const { testArbitrary } = require("fast-check");29testArbitrary(30  fc.array(fc.integer()),31  (data) => {32    console.log(data);33    return true;34  },35  { numRuns: 5 }36);37const { testArbitrary } = require("fast-check");38testArbitrary(39  fc.array(fc.integer()),40  (data) => {41    console.log(data);42    return true;43  },44  { numRuns: 5 }45);46const { testArbitrary } = require("fast-check");47testArbitrary(48  fc.array(fc.integer()),49  (data) => {50    console.log(data);51    return true;52  },53  { numRuns: 5 }54);55const { testArbitrary } = require("fast-check");56testArbitrary(57  fc.array(fc.integer()),58  (data) => {59    console.log(data);60    return true;61  },62  { numRuns: 5 }63);64const { testArbitrary } = require

Using AI Code Generation

1const fc = require('fast-check');2const testArbitrary = require('fast-check/lib/check/arbitrary/TestArbitrary');3const { TestRunner } = require('fast-check/lib/check/runner/TestRunner');4const { TestCommand } = require('fast-check/lib/check/runner/TestCommand');5fc.configureGlobal({ numRuns: 1000 });6let testArb = testArbitrary();7let runner = new TestRunner();8let command = new TestCommand(runner);9fc.check(testArb, command);10export function testArbitrary(): fc.Arbitrary<fc.IProperty<any>> {11  return fc.constantFrom(12    () => true,13    () => false,14    () => {15      throw new Error('Error');16    }17  );18}19export function check<Ts>(

Using AI Code Generation

1const { testArbitrary } = require('fast-check');2const { test3 } = require('./test3.js');3const { test4 } = require('./test4.js');4testArbitrary(test3, { numRuns: 100 });5testArbitrary(test4, { numRuns: 100 });6const { testArbitrary } = require('fast-check');7const { test3 } = require('./test3.js');8const { test4 } = require('./test4.js');9testArbitrary(test3, { numRuns: 100 });10testArbitrary(test4, { numRuns: 100 });

Using AI Code Generation

1const fc = require('fast-check');2fc.testArbitrary(fc.nat(), (n) => n >= 0);3const fc = require('fast-check');4fc.testArbitrary(fc.nat(), (n) => n >= 0);5const fc = require('fast-check');6fc.testArbitrary(fc.nat(), (n) => n >= 0);7const fc = require('fast-check');8fc.testArbitrary(fc.nat(), (n) => n >= 0);9const fc = require('fast-check');10fc.testArbitrary(fc.nat(), (n) => n >= 0);11const fc = require('fast-check');12fc.testArbitrary(fc.nat(), (n) => n >= 0);13const fc = require('fast-check');14fc.testArbitrary(fc.nat(), (n) => n >= 0);15const fc = require('fast-check');16fc.testArbitrary(fc.nat(), (n) => n >= 0);17const fc = require('fast-check');18fc.testArbitrary(fc.nat(), (n) => n >= 0);19const fc = require('fast-check');20fc.testArbitrary(fc.nat(), (n) => n >= 0);

Using AI Code Generation

1const fc = require('fast-check');2const testArbitrary = fc.testArbitrary;3const assert = require('assert');4testArbitrary('test3', gen, (v) => {5    assert(v >= 0 && v <= 100);6});7const fc = require('fast-check');8const testArbitrary = fc.testArbitrary;9const assert = require('assert');10testArbitrary('test4', gen, (v) => {11    assert(v >= 0 && v <= 100);12});13const fc = require('fast-check');14const testArbitrary = fc.testArbitrary;15const assert = require('assert');16testArbitrary('test5', gen, (v) => {17    assert(v >= 0 && v <= 100);18});19const fc = require('fast-check');20const testArbitrary = fc.testArbitrary;21const assert = require('assert');22testArbitrary('test6', gen, (v) => {23    assert(v >= 0 && v <= 100);24});25const fc = require('fast-check');26const testArbitrary = fc.testArbitrary;27const assert = require('assert');28testArbitrary('test7', gen, (v) => {29    assert(v >= 0 && v <= 100);30});31const fc = require('fast-check');

Using AI Code Generation

1const { testArbitrary } = require('fast-check');2const testArbitrary = testArbitrary(3        return x >= 0;4    }5);6testArbitrary.then((result) => {7    console.log(result);8});9{ numRuns: 10, numSkips: 0, numShrinks: 0, seed: 0, endOnFailure: false, path: null, endOnTimeout: false, timeout: 1000, endOnFirstFailure: false, verbose: false, numRuns: 10, numSkips: 0, numShrinks: 0, seed: 0, endOnFailure: false, path: null, endOnTimeout: false, timeout: 1000, endOnFirstFailure: false, verbose: false, numRuns: 10, numSkips: 0, numShrinks: 0, seed: 0, endOnFailure: false, path: null, endOnTimeout: false, timeout: 1000, endOnFirstFailure: false, verbose: false, numRuns: 10, numSkips: 0, numShrinks: 0, seed: 0, endOnFailure: false, path: null, endOnTimeout: false, timeout: 1000, endOnFirstFailure: false, verbose: false, numRuns: 10, numSkips: 0, numShrinks: 0, seed: 0, endOnFailure: false, path: null, endOnTimeout: false, timeout: 1000, endOnFirstFailure: false, verbose: false, numRuns: 10, numSkips: 0, numShrinks: 0, seed: 0, endOnFailure: false, path: null, endOnTimeout: false, timeout: 1000, endOnFirstFailure: false, verbose: false, numRuns: 10, numSkips: 0, numShrinks: 0, seed: 0, endOnFailure: false, path: null, endOnTimeout: false, timeout

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.