feat: move constant configuration to javascript module

libraries/analysis-javascript/lib/constant/ConstantPool.ts

@@ -84,6 +84,10 @@ export class ConstantPool {
   }
 
   public getRandomNumeric(frequencyBased = false): number {
+    if (this._numericPool.size === 0) {
+      return undefined;
+    }
+
     if (frequencyBased) {
       let index = prng.nextDouble() * this._numericCount;
       for (const [value, frequency] of this._numericPool.entries()) {
@@ -100,6 +104,10 @@ export class ConstantPool {
   }
 
   public getRandomInteger(frequencyBased = false): number {
+    if (this._integerPool.size === 0) {
+      return undefined;
+    }
+
     if (frequencyBased) {
       let index = prng.nextDouble() * this._integerCount;
       for (const [value, frequency] of this._integerPool.entries()) {
@@ -116,6 +124,10 @@ export class ConstantPool {
   }
 
   public getRandomBigInt(frequencyBased = false): bigint {
+    if (this._bigIntPool.size === 0) {
+      return undefined;
+    }
+
     if (frequencyBased) {
       let index = prng.nextDouble() * this._bigIntCount;
       for (const [value, frequency] of this._bigIntPool.entries()) {
@@ -132,6 +144,10 @@ export class ConstantPool {
   }
 
   public getRandomString(frequencyBased = false): string {
+    if (this._stringPool.size === 0) {
+      return undefined;
+    }
+
     if (frequencyBased) {
       let index = prng.nextDouble() * this._stringCount;
       for (const [value, frequency] of this._stringPool.entries()) {

libraries/search-javascript/lib/testcase/sampling/JavaScriptRandomSampler.ts

@@ -57,9 +57,6 @@ import { IntegerStatement } from "../statements/primitive/IntegerStatement";
 
 export class JavaScriptRandomSampler extends JavaScriptTestCaseSampler {
   private _rootContext: RootContext;
-  private _constantPoolManager: ConstantPoolManager;
-  private _constantPoolEnabled: boolean;
-  private _constantPoolProbability: number;
 
   constructor(
     subject: JavaScriptSubject,
@@ -78,6 +75,9 @@ export class JavaScriptRandomSampler extends JavaScriptTestCaseSampler {
   ) {
     super(
       subject,
+      constantPoolManager,
+      constantPoolEnabled,
+      constantPoolProbability,
       typeInferenceMode,
       randomTypeProbability,
       incorporateExecutionInformation,
@@ -88,9 +88,6 @@ export class JavaScriptRandomSampler extends JavaScriptTestCaseSampler {
       deltaMutationProbability,
       exploreIllegalValues
     );
-    this._constantPoolManager = constantPoolManager;
-    this._constantPoolEnabled = constantPoolEnabled;
-    this._constantPoolProbability = constantPoolProbability;
   }
 
   /**
@@ -786,11 +783,13 @@ export class JavaScriptRandomSampler extends JavaScriptTestCaseSampler {
   ): StringStatement {
     let value: string;
     if (
-      prng.nextDouble() >= this._constantPoolProbability &&
-      this._constantPoolEnabled
+      this.constantPoolEnabled &&
+      prng.nextBoolean(this.constantPoolProbability)
     ) {
-      value = this._constantPoolManager.contextConstantPool.getRandomString();
-    } else {
+      value = this.constantPoolManager.contextConstantPool.getRandomString();
+    }
+
+    if (value === undefined) {
       const valueLength = prng.nextInt(0, maxlength - 1);
 
       for (let index = 0; index < valueLength; index++) {
@@ -830,11 +829,14 @@ export class JavaScriptRandomSampler extends JavaScriptTestCaseSampler {
     const min = -10;
 
     const value =
-      prng.nextDouble() >= this._constantPoolProbability &&
-      this._constantPoolEnabled
-        ? this._constantPoolManager.contextConstantPool.getRandomNumeric()
+      this.constantPoolEnabled && prng.nextBoolean(this.constantPoolProbability)
+        ? this.constantPoolManager.contextConstantPool.getRandomNumeric()
         : prng.nextDouble(min, max);
 
+    if (value === undefined) {
+      prng.nextDouble(min, max);
+    }
+
     return new NumericStatement(
       id,
       name,
@@ -850,11 +852,14 @@ export class JavaScriptRandomSampler extends JavaScriptTestCaseSampler {
     const min = -10;
 
     const value =
-      prng.nextDouble() >= this._constantPoolProbability &&
-      this._constantPoolEnabled
-        ? this._constantPoolManager.contextConstantPool.getRandomInteger()
+      this.constantPoolEnabled && prng.nextBoolean(this.constantPoolProbability)
+        ? this.constantPoolManager.contextConstantPool.getRandomInteger()
         : prng.nextInt(min, max);
 
+    if (value === undefined) {
+      prng.nextInt(min, max);
+    }
+
     return new IntegerStatement(
       id,
       name,

libraries/search-javascript/lib/testcase/sampling/JavaScriptTestCaseSampler.ts

@@ -36,13 +36,17 @@ import { ArrowFunctionStatement } from "../statements/complex/ArrowFunctionState
 import { ArrayStatement } from "../statements/complex/ArrayStatement";
 import { ObjectStatement } from "../statements/complex/ObjectStatement";
 import { IntegerStatement } from "../statements/primitive/IntegerStatement";
+import { ConstantPoolManager } from "@syntest/analysis-javascript";
 
 /**
  * JavaScriptRandomSampler class
  *
  * @author Dimitri Stallenberg
  */
 export abstract class JavaScriptTestCaseSampler extends EncodingSampler<JavaScriptTestCase> {
+  private _constantPoolManager: ConstantPoolManager;
+  private _constantPoolEnabled: boolean;
+  private _constantPoolProbability: number;
   private _typeInferenceMode: string;
   private _randomTypeProbability: number;
   private _incorporateExecutionInformation: boolean;
@@ -55,6 +59,9 @@ export abstract class JavaScriptTestCaseSampler extends EncodingSampler<JavaScri
 
   constructor(
     subject: JavaScriptSubject,
+    constantPoolManager: ConstantPoolManager,
+    constantPoolEnabled: boolean,
+    constantPoolProbability: number,
     typeInferenceMode: string,
     randomTypeProbability: number,
     incorporateExecutionInformation: boolean,
@@ -66,6 +73,9 @@ export abstract class JavaScriptTestCaseSampler extends EncodingSampler<JavaScri
     exploreIllegalValues: boolean
   ) {
     super(subject);
+    this._constantPoolManager = constantPoolManager;
+    this._constantPoolEnabled = constantPoolEnabled;
+    this._constantPoolProbability = constantPoolProbability;
     this._typeInferenceMode = typeInferenceMode;
     this._randomTypeProbability = randomTypeProbability;
     this._incorporateExecutionInformation = incorporateExecutionInformation;
@@ -151,6 +161,18 @@ export abstract class JavaScriptTestCaseSampler extends EncodingSampler<JavaScri
 
   abstract sampleUndefined(id: string, name: string): UndefinedStatement;
 
+  get constantPoolManager(): ConstantPoolManager {
+    return this._constantPoolManager;
+  }
+
+  get constantPoolEnabled(): boolean {
+    return this._constantPoolEnabled;
+  }
+
+  get constantPoolProbability(): number {
+    return this._constantPoolProbability;
+  }
+
   get typeInferenceMode(): string {
     return this._typeInferenceMode;
   }

tools/javascript/lib/JavaScriptLauncher.ts

@@ -119,6 +119,17 @@ export class JavaScriptLauncher extends Launcher {
     JavaScriptLauncher.LOGGER.info("Initialization started");
     const start = Date.now();
 
+    this.metricManager.recordProperty(
+      PropertyName.CONSTANT_POOL_ENABLED,
+      `${(<JavaScriptArguments>this.arguments_).constantPool.toString()}`
+    );
+    this.metricManager.recordProperty(
+      PropertyName.CONSTANT_POOL_PROBABILITY,
+      `${(<JavaScriptArguments>(
+        this.arguments_
+      )).constantPoolProbability.toString()}`
+    );
+
     this.storageManager.deleteTemporaryDirectories([
       [this.arguments_.testDirectory],
       [this.arguments_.logDirectory],
@@ -287,10 +298,13 @@ export class JavaScriptLauncher extends Launcher {
           "Sample Output Values",
           `${this.arguments_.sampleFunctionOutputAsArgument}`,
         ],
-        ["Use Constant Pool Values", `${this.arguments_.constantPool}`],
+        [
+          "Use Constant Pool Values",
+          `${(<JavaScriptArguments>this.arguments_).constantPool}`,
+        ],
         [
           "Use Constant Pool Probability",
-          `${this.arguments_.constantPoolProbability}`,
+          `${(<JavaScriptArguments>this.arguments_).constantPoolProbability}`,
         ],
       ],
       footers: ["", ""],
@@ -679,8 +693,8 @@ export class JavaScriptLauncher extends Launcher {
     const sampler = new JavaScriptRandomSampler(
       currentSubject,
       constantPoolManager,
-      this.arguments_.constantPool,
-      this.arguments_.constantPoolProbability,
+      (<JavaScriptArguments>this.arguments_).constantPool,
+      (<JavaScriptArguments>this.arguments_).constantPoolProbability,
       (<JavaScriptArguments>this.arguments_).typeInferenceMode,
       (<JavaScriptArguments>this.arguments_).randomTypeProbability,
       (<JavaScriptArguments>this.arguments_).incorporateExecutionInformation,

tools/javascript/lib/commands/test.ts

@@ -33,6 +33,7 @@ export function getTestCommand(
   const options = new Map<string, Yargs.Options>();
 
   const commandGroup = "Type Inference Options:";
+  const samplingGroup = "Sampling Options:";
 
   options.set("incorporate-execution-information", {
     alias: [],
@@ -62,6 +63,25 @@ export function getTestCommand(
     type: "number",
   });
 
+  options.set("constant-pool", {
+    alias: [],
+    default: false,
+    description: "Enable constant pool.",
+    group: samplingGroup,
+    hidden: false,
+    type: "boolean",
+  });
+
+  options.set("constant-pool-probability", {
+    alias: [],
+    default: 0.5,
+    description:
+      "Probability to sample from the constant pool instead creating random values",
+    group: samplingGroup,
+    hidden: false,
+    type: "number",
+  });
+
   return new Command(
     moduleManager,
     tool,
@@ -85,4 +105,6 @@ export type TestCommandOptions = {
   incorporateExecutionInformation: boolean;
   typeInferenceMode: string;
   randomTypeProbability: number;
+  constantPool: boolean;
+  constantPoolProbability: number;
 };