First approach to for a toggable printableStringConsumer

Author: 434b

packages/core/FuzzedDataProvider.test.ts

@@ -946,8 +946,8 @@ describe("FuzzedDataProvider checks", () => {
 		expect(strings).toContain("t ame");
 	});
 	it("verifyPrintableString", () => {
-		const data = new FuzzedDataProvider(Buffer.from(Data), true);
-		const consumedStrAsArr = [...data.consumeString(1024)];
+		const data = new FuzzedDataProvider(Buffer.from(Data));
+		const consumedStrAsArr = [...data.consumeString(1024, "ascii", true)];
 		consumedStrAsArr.forEach((c) => {
 			const charAsNum = c.charCodeAt(0);
 			expect(charAsNum >= 32 && charAsNum <= 126).toBeTruthy();

packages/core/FuzzedDataProvider.ts

@@ -24,7 +24,6 @@
 export class FuzzedDataProvider {
 	private readonly data: Buffer;
 	private dataPtr = -1;
-	private readonly enforcePrintable: boolean = false;
 	/** The number of remaining bytes that can be consumed from the fuzzer input data. */
 	_remainingBytes = 0;
 
@@ -35,12 +34,9 @@ export class FuzzedDataProvider {
 
 	/**
 	 * @param data - a buffer containing the fuzzer input
-	 * @param printable - a boolean, which defaults to false that indicates whether consumed strings
-	 * should be forced to contain only valid printable characters
 	 */
-	constructor(data: Buffer, enforcePrintable: boolean | undefined = false) {
+	constructor(data: Buffer) {
 		this.data = data;
-		this.enforcePrintable = enforcePrintable;
 		if (data.length > 0) {
 			this.dataPtr = 0;
 			this._remainingBytes = data.length;
@@ -376,17 +372,20 @@ export class FuzzedDataProvider {
 	 * is not sufficiently long.
 	 * @param maxLength the maximum length of the string
 	 * @param encoding the encoding of the string
+	 * @param printable - a boolean, which defaults to false that indicates whether consumed strings
+	 * should be forced to contain only valid printable characters
 	 * @returns a `string` of length between 0 and `maxLength` (inclusive)
 	 */
 	consumeString(
 		maxLength: number,
-		encoding: BufferEncoding | undefined = "ascii"
+		encoding: BufferEncoding | undefined = "ascii",
+		printable: boolean | undefined = false
 	): string {
 		if (maxLength < 0) throw new Error("maxLength must be non-negative");
 		let result;
 		const arrayLength = Math.min(maxLength, this._remainingBytes);
 
-		if (this.enforcePrintable) {
+		if (printable) {
 			result = this.bufToPrintableString(
 				this.data,
 				this.dataPtr,
@@ -438,32 +437,35 @@ export class FuzzedDataProvider {
 	 * high enough. Limitations are that there are collisions such that, e.g.:
 	 * the conversion of values: `0x1`, `0x42`, and `0xa2` all yield the character `B`.
 	 * @param buf - Buffer that contains arbitrary values
-	 * @param lb - lower bound at which processing of the provided `Buffer` shall begin
-	 * @param ub - upper bound, analogous to the lower bound
+	 * @param min - lower bound at which processing of the provided `Buffer` shall begin
+	 * @param max - upper bound, analogous to the lower bound
 	 * @param encoding - a valid `BufferEncoding`.
 	 * @returns a string that was sanitized and only contains printable characters
 	 */
 	bufToPrintableString(
 		buf: Buffer,
-		lb: number,
-		ub: number,
+		min: number,
+		max: number,
 		encoding: BufferEncoding
 	): string {
-		for (let i = lb; i < ub; i++) {
+		for (let i = min; i < max; i++) {
 			buf[i] = this.toAscii(buf[i]);
 		}
-		return buf.subarray(lb, ub).toString(encoding);
+		return buf.subarray(min, max).toString(encoding);
 	}
 
 	/**
 	 * Consumes the remaining bytes of the fuzzer input as a string.
 	 * @param encoding - the encoding of the string
+	 * @param printable - a boolean, which defaults to false that indicates whether consumed strings
+	 * should be forced to contain only valid printable characters
 	 * @returns a string constructed from the remaining bytes of the fuzzer input using the given encoding
 	 */
 	consumeRemainingAsString(
-		encoding: BufferEncoding | undefined = "ascii"
+		encoding: BufferEncoding | undefined = "ascii",
+		printable: boolean | undefined = false
 	): string {
-		return this.consumeString(this._remainingBytes, encoding);
+		return this.consumeString(this._remainingBytes, encoding, printable);
 	}
 
 	/**
@@ -473,16 +475,19 @@ export class FuzzedDataProvider {
 	 * @param maxArrayLength the maximum length of the array
 	 * @param maxStringLength the maximum length of the strings
 	 * @param encoding the encoding of the strings
+	 * @param printable - a boolean, which defaults to false that indicates whether consumed strings
+	 * should be forced to contain only valid printable characters
 	 * @returns an array containing strings constructed from the remaining bytes of the fuzzer input using the given encoding
 	 */
 	consumeStringArray(
 		maxArrayLength: number,
 		maxStringLength: number,
-		encoding: BufferEncoding | undefined = "ascii"
+		encoding: BufferEncoding | undefined = "ascii",
+		printable: boolean | undefined = false
 	) {
 		const strs = [];
 		while (strs.length < maxArrayLength && this.remainingBytes > 0) {
-			const str = this.consumeString(maxStringLength, encoding);
+			const str = this.consumeString(maxStringLength, encoding, printable);
 			if (str) {
 				strs.push(str);
 			}