In
`@mathematical_operations/src/main/java/com/testsigma/addons/web/MathematicalOperationsRestApi.java`
around lines 34 - 41, In execute(), after the empty-input validation that sets
result = Result.FAILED and calls setErrorMessage/logger, add an immediate return
of that result to prevent further execution; specifically update the execute()
method (where testData1, testData2, testData4 are checked) to return result
right after setting FAILED so the subsequent Double.parseDouble(...) calls
cannot run on empty strings.

In
`@mathematical_operations/src/main/java/com/testsigma/addons/web/MathematicalOperationsRestApi.java`
around lines 42 - 45, The parsing code for operatorString and numeric inputs
(operatorString, Double.parseDouble calls for testData1 and testData2, and the
testData4 handling) is unsafe: calling getValue().toString() can NPE, the regex
"[$,@,%,#]" incorrectly includes commas, and there is no NumberFormatException
handling. Fix by null-checking getValue() (or use Objects.toString(value, "") )
before toString(), replace the regex with a correct character class like
"[$@%#]" (or include comma if desired), and wrap parsing (Double.parseDouble /
Integer.parseInt) in try-catch to handle NumberFormatException and return a
controlled failure result; also simplify testData4 by removing redundant
String.valueOf(...) and using the null-safe string.

In
`@mathematical_operations/src/main/java/com/testsigma/addons/web/MathematicalOperationsRestApi.java`
around lines 77 - 78, In the "division" case inside
MathematicalOperationsRestApi (the switch handling a and b), add a guard that
checks if b == 0 before computing double division = a / b; and handle it by
returning or throwing a meaningful error (e.g., HTTP 400 /
IllegalArgumentException or setting the runtime variable to an error state)
instead of storing Infinity/NaN; ensure the error message references the
division-by-zero condition and avoid performing the division when b is zero so
the operation is reported as failed rather than successful.

In
`@mathematical_operations/src/main/java/com/testsigma/addons/web/MathematicalOperationsRestApi.java`
around lines 49 - 87, Normalize operatorString before the switch (e.g.,
operatorString = operatorString.trim().toLowerCase()) to handle
whitespace/capitalization, and add a default case to the switch that logs the
unsupported operator (using logger.error("Unsupported operator:
"+operatorString)), clears or does not set runTimeData, and prevents silent
success by throwing an IllegalArgumentException with a descriptive message (so
the method does not fall through returning success); update any callers if they
rely on exceptions for failure handling instead of setSuccessMessage.

In
`@mathematical_operations/src/main/java/com/testsigma/addons/web/MathematicalOperationsSalesforce.java`
at line 14, The code sets applicationType = ApplicationType.Salesforce, but
ApplicationType.Salesforce is not a valid enum member; change that assignment in
MathematicalOperationsSalesforce (the applicationType field/initializer) to one
of the supported enum constants (e.g., ApplicationType.WEB or
ApplicationType.MOBILE_WEB) that best matches the addon’s target environment,
ensuring you update any related metadata or comments to reflect the chosen
ApplicationType.

In
`@mathematical_operations/src/main/java/com/testsigma/addons/web/MathematicalOperationsSalesforce.java`
around lines 32 - 89, The execute() implementation in
MathematicalOperationsSalesforce is a duplicate of MathematicalOperationsRestApi
and must be consolidated into the base class (MathematicalOperationsWeb): move
the execute() method into MathematicalOperationsWeb and have subclasses only
keep their `@Action` annotations; while doing so fix the logic in execute():
validate empty inputs and return immediately on failure (use setErrorMessage and
return Result.FAILED), wrap parsing of testData1/testData2/testData4 in a
try/catch for NumberFormatException and set an error on catch, guard division by
zero before computing division, add a default case in the operator switch to set
failure if operator is unknown, replace the incorrect regex
replaceAll("[$,@,%,#]","") with a correct character-class like
replaceAll("[\\\\$@%#]", "") and remove System.out.println calls (use logger).
Ensure you reference and use the existing fields/methods (execute(),
testData1/testData2/testData4, operator, runTimeData, setErrorMessage,
setSuccessMessage, logger) so subclasses inherit the fixed behavior.

In
`@mathematical_operations/src/main/java/com/testsigma/addons/web/generators/RandomNumberGenerator.java`
around lines 24 - 25, The regex in RandomNumberGenerator that strips symbols
before parsing (used when computing minVal and maxVal) incorrectly includes
commas in the character class ("[$,@,%,#]") so commas are removed; update the
replaceAll pattern to the intended character set (e.g., "[$@%#]" to not strip
commas or "[$@%#,]" to strip commas) in both places where min.getValue() and
max.getValue() are parsed (variables minVal and maxVal) so parsing behaves
correctly.

In
`@mathematical_operations/src/main/java/com/testsigma/addons/web/generators/RandomNumberGenerator.java`
around lines 30 - 31, The RandomNumberGenerator computes a double "number" and
then truncates to int with (int) number and doesn't validate minVal/maxVal;
change the logic in the generator (e.g., where "number", "minVal", "maxVal", and
"decimals" are used) to first ensure minVal <= maxVal (either validate and throw
IllegalArgumentException or swap them), compute number as minVal + Math.random()
* (maxVal - minVal), then when decimals == 0 use Math.round(number) to correctly
round to the nearest integer instead of truncating, and for decimals > 0 keep
the formatted String.format approach using decimals.

In
`@mathematical_operations/src/main/java/com/testsigma/addons/web/generators/RandomNumberGenerator.java`
around lines 21 - 35, The generate() method in RandomNumberGenerator lacks
handling for NumberFormatException from Double.parseDouble and Integer.parseInt;
wrap the parsing and number-generation logic in a try-catch that catches
NumberFormatException (and optionally other Exceptions), validate that min, max,
and decimalPlaces values are non-null and numeric before parsing, and when a
parse fails throw or rethrow an Exception with a clear message identifying which
field (min, max, or decimalPlaces) was invalid and include the offending input
value; ensure the logger (logger.info / logger.error) records the error message
before propagating the exception so callers can diagnose bad inputs.