test(mersenne): add tests for value ranges

src/internal/mersenne.ts

@@ -73,7 +73,7 @@ import type { Randomizer } from '../randomizer';
  *
  * @internal
  */
-class MersenneTwister19937 {
+export class MersenneTwister19937 {
   private readonly N = 624;
   private readonly M = 397;
   private readonly MATRIX_A = 0x9908b0df; // constant vector a

test/faker.spec.ts

@@ -113,14 +113,14 @@ describe('faker', () => {
       faker.seed(1);
 
       const actual = faker.animal.cat();
-      expect(actual).toBe('Korat');
+      expect(actual).toMatchInlineSnapshot('"Korat"');
     });
 
     it('seed(number[])', () => {
       faker.seed([1, 2, 3]);
 
       const actual = faker.animal.cat();
-      expect(actual).toBe('Oriental');
+      expect(actual).toMatchInlineSnapshot('"Oriental"');
     });
   });
 

test/internal/__snapshots__/mersenne.spec.ts.snap

@@ -0,0 +1,13 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`generateMersenne32Randomizer() > seed: [42,1,2] > should return deterministic value for next() 1`] = `0.8562037434894592`;
+
+exports[`generateMersenne32Randomizer() > seed: [1211,1,2] > should return deterministic value for next() 1`] = `0.8916433283593506`;
+
+exports[`generateMersenne32Randomizer() > seed: [1337,1,2] > should return deterministic value for next() 1`] = `0.17990487208589911`;
+
+exports[`generateMersenne32Randomizer() > seed: 42 > should return deterministic value for next() 1`] = `0.37454011430963874`;
+
+exports[`generateMersenne32Randomizer() > seed: 1211 > should return deterministic value for next() 1`] = `0.9285201537422836`;
+
+exports[`generateMersenne32Randomizer() > seed: 1337 > should return deterministic value for next() 1`] = `0.2620246761944145`;

test/internal/mersenne-test-utils.ts

@@ -0,0 +1,15 @@
+// Moved to a separate file to avoid importing the tests
+
+/**
+ * The maximum value that can be returned by `MersenneTwister19937.genrandReal2()`.
+ */
+export const TWISTER_32CO_MAX_VALUE = 0.9999999997671694;
+/**
+ * The maximum value that can be returned by `MersenneTwister19937.genrandRes53()`.
+ */
+export const TWISTER_53CO_MAX_VALUE = 0.9999999999999999;
+// Re-exported because the value might change in the future
+/**
+ * The maximum value that can be returned by `next()`.
+ */
+export const MERSENNE_MAX_VALUE = TWISTER_32CO_MAX_VALUE;

test/internal/mersenne.spec.ts

@@ -0,0 +1,127 @@
+import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import {
+  generateMersenne32Randomizer,
+  MersenneTwister19937,
+} from '../../src/internal/mersenne';
+import type { Randomizer } from '../../src/randomizer';
+import { seededRuns } from '../support/seededRuns';
+import { times } from '../support/times';
+import {
+  MERSENNE_MAX_VALUE,
+  TWISTER_32CO_MAX_VALUE,
+  TWISTER_53CO_MAX_VALUE,
+} from './mersenne-test-utils';
+
+const NON_SEEDED_BASED_RUN = 25;
+
+function newTwister(
+  seed: number = Math.random() * Number.MAX_SAFE_INTEGER
+): MersenneTwister19937 {
+  const twister = new MersenneTwister19937();
+  twister.initGenrand(seed);
+  return twister;
+}
+
+describe('MersenneTwister19937', () => {
+  describe('genrandInt32()', () => {
+    it('should be able to return 0', () => {
+      const twister = newTwister(257678572);
+
+      // There is no single value seed that can produce 0 in the first call
+      for (let i = 0; i < 5; i++) {
+        twister.genrandInt32();
+      }
+
+      const actual = twister.genrandInt32();
+      expect(actual).toBe(0);
+    });
+
+    it('should be able to return 2^32-1', () => {
+      const twister = newTwister(2855577693);
+      const actual = twister.genrandInt32();
+      expect(actual).toBe(2 ** 32 - 1);
+    });
+  });
+
+  describe('genrandReal2()', () => {
+    it('should be able to return 0', () => {
+      const twister = newTwister();
+      twister.genrandInt32 = () => 0;
+      const actual = twister.genrandReal2();
+      expect(actual).toBe(0);
+    });
+
+    it('should be able to return almost 1', () => {
+      const twister = newTwister();
+      twister.genrandInt32 = () => 2 ** 32 - 1;
+      const actual = twister.genrandReal2();
+      expect(actual).toBe(TWISTER_32CO_MAX_VALUE);
+    });
+  });
+
+  describe('genrandRes53()', () => {
+    it('should be able to return 0', () => {
+      const twister = newTwister();
+      twister.genrandInt32 = () => 0;
+      const actual = twister.genrandRes53();
+      expect(actual).toBe(0);
+    });
+
+    it('should be able to return almost 1', () => {
+      const twister = newTwister();
+      twister.genrandInt32 = () => 2 ** 32 - 1;
+      const actual = twister.genrandRes53();
+      expect(actual).toBe(TWISTER_53CO_MAX_VALUE);
+    });
+  });
+});
+
+describe('generateMersenne32Randomizer()', () => {
+  const randomizer: Randomizer = generateMersenne32Randomizer();
+
+  it('should return a result matching the interface', () => {
+    expect(randomizer).toBeDefined();
+    expect(randomizer).toBeTypeOf('object');
+    expect(randomizer.next).toBeTypeOf('function');
+    expect(randomizer.seed).toBeTypeOf('function');
+  });
+
+  describe.each(
+    [...seededRuns, ...seededRuns.map((v) => [v, 1, 2])].map((v) => [v])
+  )('seed: %j', (seed) => {
+    beforeEach(() => {
+      randomizer.seed(seed);
+    });
+
+    it('should return deterministic value for next()', () => {
+      const actual = randomizer.next();
+
+      expect(actual).toMatchSnapshot();
+    });
+  });
+
+  function randomSeed(): number {
+    return Math.ceil(Math.random() * 1_000_000_000);
+  }
+
+  // Create and log-back the seed for debug purposes
+  describe.each(
+    times(NON_SEEDED_BASED_RUN).flatMap(() => [
+      [randomSeed()],
+      [[randomSeed(), randomSeed()]],
+    ])
+  )('random seeded tests %j', (seed) => {
+    beforeAll(() => {
+      randomizer.seed(seed);
+    });
+
+    describe('next', () => {
+      it('should return random number from interval [0, 1)', () => {
+        const actual = randomizer.next();
+
+        expect(actual).toBeGreaterThanOrEqual(0);
+        expect(actual).toBeLessThanOrEqual(MERSENNE_MAX_VALUE);
+      });
+    });
+  });
+});

test/modules/date.spec.ts

@@ -801,22 +801,22 @@ describe('date', () => {
       faker.setDefaultRefDate(() => new Date(Date.UTC(2020, 0, 1)));
       faker.seed(20200101);
       const date = faker.date.past();
-      expect(date).toEqual(new Date('2019-02-25T21:52:41.824Z'));
+      expect(date).toMatchInlineSnapshot('2019-02-25T21:52:41.824Z');
 
       faker.seed(20200101);
       const date2 = faker.date.past();
-      expect(date2).toEqual(new Date('2019-02-25T21:52:41.824Z'));
+      expect(date2).toMatchInlineSnapshot('2019-02-25T21:52:41.824Z');
     });
 
     it('should use the refDateSource when refDate is not provided (with value)', () => {
       faker.setDefaultRefDate(Date.UTC(2020, 0, 1));
       faker.seed(20200101);
       const date = faker.date.past();
-      expect(date).toEqual(new Date('2019-02-25T21:52:41.824Z'));
+      expect(date).toMatchInlineSnapshot('2019-02-25T21:52:41.824Z');
 
       faker.seed(20200101);
       const date2 = faker.date.past();
-      expect(date2).toEqual(new Date('2019-02-25T21:52:41.824Z'));
+      expect(date2).toMatchInlineSnapshot('2019-02-25T21:52:41.824Z');
     });
   });
 });

test/modules/helpers.spec.ts

@@ -811,14 +811,6 @@ describe('helpers', () => {
           expect(unique).not.toContainDuplicates();
           expect(unique).toHaveLength(2);
         });
-
-        it('works as expected when seeded', () => {
-          const input = ['a', 'a', 'a', 'a', 'a', 'f', 'g', 'h', 'i', 'j'];
-          const length = 5;
-          faker.seed(100);
-          const unique = faker.helpers.uniqueArray(input, length);
-          expect(unique).toStrictEqual(['g', 'a', 'i', 'f', 'j']);
-        });
       });
 
       describe('mustache()', () => {
@@ -1253,6 +1245,24 @@ Try adjusting maxTime or maxRetries parameters for faker.helpers.unique().`)
     }
   );
 
+  describe('uniqueArray()', () => {
+    it('works as expected when seeded', () => {
+      const input = ['a', 'a', 'a', 'a', 'a', 'f', 'g', 'h', 'i', 'j'];
+      const length = 5;
+      faker.seed(100);
+      const unique = faker.helpers.uniqueArray(input, length);
+      expect(unique).toMatchInlineSnapshot(`
+        [
+          "g",
+          "a",
+          "i",
+          "f",
+          "j",
+        ]
+      `);
+    });
+  });
+
   // This test can be only executed once, because the unique function has a global state.
   // See: https://github.com/faker-js/faker/issues/371
   describe('global unique()', () => {

test/modules/number.spec.ts

@@ -1,6 +1,7 @@
 import validator from 'validator';
 import { describe, expect, it } from 'vitest';
-import { faker, FakerError } from '../../src';
+import { faker, FakerError, SimpleFaker } from '../../src';
+import { MERSENNE_MAX_VALUE } from '../internal/mersenne-test-utils';
 import { seededTests } from './../support/seededRuns';
 
 describe('number', () => {
@@ -507,4 +508,37 @@ describe('number', () => {
       });
     });
   });
+
+  describe('value range tests', () => {
+    const customFaker = new SimpleFaker();
+    // @ts-expect-error: access private member field
+    const randomizer = customFaker._randomizer;
+    describe('int', () => {
+      it('should be able to return 0', () => {
+        randomizer.next = () => 0;
+        const actual = customFaker.number.int();
+        expect(actual).toBe(0);
+      });
+
+      it.todo('should be able to return MAX_SAFE_INTEGER', () => {
+        randomizer.next = () => MERSENNE_MAX_VALUE;
+        const actual = customFaker.number.int();
+        expect(actual).toBe(Number.MAX_SAFE_INTEGER);
+      });
+    });
+
+    describe('float', () => {
+      it('should be able to return 0', () => {
+        randomizer.next = () => 0;
+        const actual = customFaker.number.float();
+        expect(actual).toBe(0);
+      });
+
+      it('should be able to return almost 1', () => {
+        randomizer.next = () => MERSENNE_MAX_VALUE;
+        const actual = customFaker.number.float();
+        expect(actual).toBe(MERSENNE_MAX_VALUE);
+      });
+    });
+  });
 });