💥 Drop deprecated char16bits and string16bits (#5289)

dubzzz · web-flow · commit 134ccd15cbca · 2024-11-06T21:30:02.000Z
**Description**  The arbitraries `char16bits` and `string16bits` have been marked for deprecation since version 3.22.0. They are now being fully dropped. If you still want to rely on something behaving this way we recommend you to use the following constructs: ```js const char16bits = fc.nat({ max: 0xffff }).map((n) => String.fromCharCode(n)); const string16bits = fc.string({ unit: char16bits }); ```    **Checklist** — _Don't delete this checklist and make sure you do the following before opening the PR_ - [x] The name of my PR follows [gitmoji](https://gitmoji.dev/) specification - [x] My PR references one of several related issues (if any) - [x] New features or breaking changes must come with an associated Issue or Discussion - [x] My PR does not add any new dependency without an associated Issue or Discussion - [x] My PR includes bumps details, please run `yarn bump` and flag the impacts properly - [x] My PR adds relevant tests and they would have failed without my PR (when applicable)  **Advanced**  - [x] Category: 💥 Breaking change - [x] Impacts: Dropped arbitraries
diff --git a/packages/fast-check/src/arbitrary/char16bits.ts b/packages/fast-check/src/arbitrary/char16bits.ts
diff --git a/packages/fast-check/src/arbitrary/string16bits.ts b/packages/fast-check/src/arbitrary/string16bits.ts
diff --git a/packages/fast-check/src/fast-check-default.ts b/packages/fast-check/src/fast-check-default.ts
@@ -34,7 +34,6 @@ import { boolean } from './arbitrary/boolean';
 import type { FalsyContraints, FalsyValue } from './arbitrary/falsy';
 import { falsy } from './arbitrary/falsy';
 import { char } from './arbitrary/char';
-import { char16bits } from './arbitrary/char16bits';
 import { fullUnicode } from './arbitrary/fullUnicode';
 import { unicode } from './arbitrary/unicode';
 import { constant } from './arbitrary/constant';
@@ -108,7 +107,6 @@ import { base64String } from './arbitrary/base64String';
 import { fullUnicodeString } from './arbitrary/fullUnicodeString';
 import type { StringSharedConstraints, StringConstraints } from './arbitrary/string';
 import { string } from './arbitrary/string';
-import { string16bits } from './arbitrary/string16bits';
 import { unicodeString } from './arbitrary/unicodeString';
 import type { SubarrayConstraints } from './arbitrary/subarray';
 import { subarray } from './arbitrary/subarray';
@@ -355,12 +353,10 @@ export {
   bigInt,
   bigUint,
   char,
-  char16bits,
   unicode,
   fullUnicode,
   mixedCase,
   string,
-  string16bits,
   unicodeString,
   fullUnicodeString,
   base64String,
diff --git a/packages/fast-check/test/e2e/GenerateAllValues.spec.ts b/packages/fast-check/test/e2e/GenerateAllValues.spec.ts
@@ -31,9 +31,6 @@ describe(`Generate all values (seed: ${seed})`, () => {
   describe('fc.char()', () => {
     it('Should be able to produce any printable character', () => lookForMissing(fc.char(), 95));
   });
-  describe('fc.char16bits()', () => {
-    it('Should be able to produce any 16 bits character', () => lookForMissing(fc.char16bits(), 65536));
-  });
   describe('fc.unicode()', () => {
     const numCharacters = 65536 - (0xdfff - 0xd800 + 1);
     it('Should be able to produce any character from unicode (UCS-2 subset only)', () =>
diff --git a/packages/fast-check/test/e2e/NoRegression.spec.ts b/packages/fast-check/test/e2e/NoRegression.spec.ts
@@ -156,10 +156,6 @@ describe(`NoRegression`, () => {
       ),
     ).toThrowErrorMatchingSnapshot();
   });
-  // // Jest Snapshot seems not to support incomplete surrogate pair correctly
-  // it('string16bits', () => {
-  //   expect(runWithSanitizedStack(() => fc.assert(fc.property(fc.string16bits(), v => testFunc(v + v)), settings))).toThrowErrorMatchingSnapshot();
-  // });
   it('stringMatching', () => {
     expect(
       runWithSanitizedStack(() =>
diff --git a/packages/fast-check/test/e2e/Poisoning.spec.ts b/packages/fast-check/test/e2e/Poisoning.spec.ts
@@ -43,13 +43,11 @@ describe(`Poisoning (seed: ${seed})`, () => {
     // : Single character
     { name: 'char', arbitraryBuilder: () => fc.char() },
     { name: 'unicode', arbitraryBuilder: () => fc.unicode() },
-    { name: 'char16bits', arbitraryBuilder: () => fc.char16bits() },
     { name: 'fullUnicode', arbitraryBuilder: () => fc.fullUnicode() },
     // : Multiple characters
     { name: 'base64String', arbitraryBuilder: () => fc.base64String() },
     { name: 'string', arbitraryBuilder: () => fc.string() },
     { name: 'unicodeString', arbitraryBuilder: () => fc.unicodeString() },
-    { name: 'string16bits', arbitraryBuilder: () => fc.string16bits() },
     { name: 'fullUnicodeString', arbitraryBuilder: () => fc.fullUnicodeString() },
     { name: 'stringMatching', arbitraryBuilder: () => preBuiltStringMatching },
     // : More specific strings
diff --git a/packages/fast-check/test/e2e/arbitraries/StringArbitrary.spec.ts b/packages/fast-check/test/e2e/arbitraries/StringArbitrary.spec.ts
@@ -45,14 +45,4 @@ describe(`StringArbitrary (seed: ${seed})`, () => {
       );
     });
   });
-  describe('string16bits', () => {
-    it('Should be able to produce invalid UTF-16 strings', () => {
-      const out = fc.check(
-        fc.property(fc.string16bits(), (s: string) => encodeURIComponent(s) !== null),
-        { seed: seed },
-      );
-      expect(out.failed).toBe(true);
-      expect(out.counterexample).toEqual(['\ud800']);
-    });
-  });
 });
diff --git a/packages/fast-check/test/unit/arbitrary/_internals/mappers/CharsToString.spec.ts b/packages/fast-check/test/unit/arbitrary/_internals/mappers/CharsToString.spec.ts
@@ -19,7 +19,7 @@ describe('charsToStringUnmapper', () => {
 
   it('should be able to split any string mapped from chars into chars', () =>
     fc.assert(
-      fc.property(fc.array(fc.char16bits()), (data) => {
+      fc.property(fc.array(fc.nat({ max: 0xffff }).map((n) => String.fromCharCode(n))), (data) => {
         // Arrange
         const source = charsToStringMapper(data);
 
diff --git a/packages/fast-check/test/unit/arbitrary/_internals/mappers/IndexToCharString.spec.ts b/packages/fast-check/test/unit/arbitrary/_internals/mappers/IndexToCharString.spec.ts
@@ -33,9 +33,12 @@ describe('indexToCharStringUnmapper', () => {
 
   it('should accept any 1 char string (including half-surrogates)', () =>
     fc.assert(
-      fc.property(fc.char16bits(), (c) => {
-        // Arrange / Act / Assert
-        expect(indexToCharStringUnmapper(c)).toBe(c.charCodeAt(0));
-      }),
+      fc.property(
+        fc.nat({ max: 0xffff }).map((n) => String.fromCharCode(n)),
+        (c) => {
+          // Arrange / Act / Assert
+          expect(indexToCharStringUnmapper(c)).toBe(c.charCodeAt(0));
+        },
+      ),
     ));
 });
diff --git a/packages/fast-check/test/unit/arbitrary/char16bits.spec.ts b/packages/fast-check/test/unit/arbitrary/char16bits.spec.ts
diff --git a/packages/fast-check/test/unit/arbitrary/string16bits.spec.ts b/packages/fast-check/test/unit/arbitrary/string16bits.spec.ts
diff --git a/packages/fast-check/test/unit/utils/hash.spec.ts b/packages/fast-check/test/unit/utils/hash.spec.ts
@@ -12,15 +12,15 @@ describe('hash', () => {
       }),
     ));
   it('Should be able to compute hash even for invalid strings', () =>
-    fc.assert(fc.property(fc.char16bits(), (a) => typeof hash(a) === 'number')));
+    fc.assert(fc.property(string16bits, (a) => typeof hash(a) === 'number')));
   it('Should compute the same value as reference for strings of characters <0x80', () =>
     fc.assert(fc.property(string0x80, (s) => hash(s) === hashReference(s))));
   it('Should compute the same value as reference for strings of characters <0x800', () =>
     fc.assert(fc.property(string0x800, (s) => hash(s) === hashReference(s))));
   it('Should compute the same value as reference for any string', () =>
     fc.assert(fc.property(fc.fullUnicodeString(), (s) => hash(s) === hashReference(s))));
   it('Should compute the same value as reference for potentially invalid strings', () =>
-    fc.assert(fc.property(fc.char16bits(), (s) => hash(s) === hashReference(s))));
+    fc.assert(fc.property(string16bits, (s) => hash(s) === hashReference(s))));
   it('Should consider any invalid surrogate pair as <ef bf bd> or 0xfffd', () => {
     // This is the behaviour of the reference implementation based on Buffer.from (see below)
     // Buffer.from([0xef,0xbf,0xbd]).toString('utf8') === '\ufffd'
@@ -35,6 +35,9 @@ describe('hash', () => {
 
 // Helpers
 
+const char16bits = fc.nat({ max: 0xffff }).map((n) => String.fromCharCode(n));
+const string16bits = fc.string({ unit: char16bits });
+
 const char0x80 = fc.nat(0x79).map((n) => String.fromCharCode(n));
 const string0x80 = fc.string({ unit: char0x80 });
 
diff --git a/packages/fast-check/test/unit/utils/stringify.spec.ts b/packages/fast-check/test/unit/utils/stringify.spec.ts
@@ -53,8 +53,13 @@ const anythingEnableAll: fc.ObjectConstraints = {
 describe('stringify', () => {
   it('Should be able to stringify fc.anything()', () =>
     fc.assert(fc.property(fc.anything(anythingEnableAll), (a) => typeof stringify(a) === 'string')));
-  it('Should be able to stringify fc.char16bits() (ie. possibly invalid strings)', () =>
-    fc.assert(fc.property(fc.char16bits(), (a) => typeof stringify(a) === 'string')));
+  it('Should be able to stringify possibly invalid strings', () =>
+    fc.assert(
+      fc.property(
+        fc.string({ unit: fc.nat({ max: 0xffff }).map((n) => String.fromCharCode(n)) }),
+        (a) => typeof stringify(a) === 'string',
+      ),
+    ));
   it('Should be able to stringify bigint in object correctly', () =>
     fc.assert(fc.property(fc.bigInt(), (b) => stringify({ b }) === '{"b":' + b + 'n}')));
   it('Should be equivalent to JSON.stringify for JSON compliant objects', () =>
diff --git a/website/docs/core-blocks/arbitraries/primitives/char.md b/website/docs/core-blocks/arbitraries/primitives/char.md
@@ -44,26 +44,6 @@ fc.unicode();
 Resources: [API reference](https://fast-check.dev/api-reference/functions/unicode.html).  
 Available since 0.0.11.
 
-## char16bits
-
-One unicode character from BMP-plan (including part of surrogate pair) — _ie.: one character between `0x0000` (included) and `0xffff` (included)_.
-
-Generate any 16 bits character. Be aware the values within `0xd800` and `0xdfff` which constitutes the surrogate pair characters are also generated meaning that some generated characters might appear invalid regarding UCS-2 and UTF-16 encoding.
-
-**Signatures:**
-
-- `fc.char16bits()` — _deprecated since v3.22.0 (more details at [#5233](https://github.com/dubzzz/fast-check/pull/5233))_
-
-**Usages:**
-
-```js
-fc.char16bits();
-// Examples of generated values: "", "毒", "丬", "縻", "贑"…
-```
-
-Resources: [API reference](https://fast-check.dev/api-reference/functions/char16bits.html).  
-Available since 0.0.11.
-
 ## fullUnicode
 
 One unicode character — _ie.: one character between `0x0000` (included) and `0x10ffff` (included) but excluding surrogate pairs (between `0xd800` and `0xdfff`)_.
diff --git a/website/docs/core-blocks/arbitraries/primitives/string.md b/website/docs/core-blocks/arbitraries/primitives/string.md
