Add more and unify tests for absent object cases

- Unify test data for nonexistence of an object/string and collection.
- Introduce more test through adding missing test data to existing tests.
- Improve logic for checking absence of values to match tests.
- Add missing tests for absent value validation.
- Update documentation to include shared test functionality.

src/application/ApplicationFactory.ts

@@ -13,7 +13,7 @@ export class ApplicationFactory implements IApplicationFactory {
 
   protected constructor(costlyGetter: ApplicationGetterType) {
     if (!costlyGetter) {
-      throw new Error('undefined getter');
+      throw new Error('missing getter');
     }
     this.getter = new AsyncLazy<IApplication>(() => Promise.resolve(costlyGetter()));
   }

src/application/Common/Array.ts

@@ -1,7 +1,7 @@
 // Compares to Array<T> objects for equality, ignoring order
 export function scrambledEqual<T>(array1: readonly T[], array2: readonly T[]) {
-  if (!array1) { throw new Error('undefined first array'); }
-  if (!array2) { throw new Error('undefined second array'); }
+  if (!array1) { throw new Error('missing first array'); }
+  if (!array2) { throw new Error('missing second array'); }
   const sortedArray1 = sort(array1);
   const sortedArray2 = sort(array2);
   return sequenceEqual(sortedArray1, sortedArray2);
@@ -12,8 +12,8 @@ export function scrambledEqual<T>(array1: readonly T[], array2: readonly T[]) {
 
 // Compares to Array<T> objects for equality in same order
 export function sequenceEqual<T>(array1: readonly T[], array2: readonly T[]) {
-  if (!array1) { throw new Error('undefined first array'); }
-  if (!array2) { throw new Error('undefined second array'); }
+  if (!array1) { throw new Error('missing first array'); }
+  if (!array2) { throw new Error('missing second array'); }
   if (array1.length !== array2.length) {
     return false;
   }

src/application/Common/Enum.ts

@@ -21,7 +21,7 @@ function parseEnumValue<T extends EnumType, TEnumValue extends EnumType>(
   enumVariable: EnumVariable<T, TEnumValue>,
 ): TEnumValue {
   if (!value) {
-    throw new Error(`undefined ${enumName}`);
+    throw new Error(`missing ${enumName}`);
   }
   if (typeof value !== 'string') {
     throw new Error(`unexpected type of ${enumName}: "${typeof value}"`);
@@ -54,8 +54,8 @@ export function assertInRange<T extends EnumType, TEnumValue extends EnumType>(
   value: TEnumValue,
   enumVariable: EnumVariable<T, TEnumValue>,
 ) {
-  if (value === undefined) {
-    throw new Error('undefined enum value');
+  if (value === undefined || value === null) {
+    throw new Error('absent enum value');
   }
   if (!(value in enumVariable)) {
     throw new RangeError(`enum value "${value}" is out of range`);

src/application/Common/ScriptingLanguage/ScriptingLanguageFactory.ts

@@ -20,7 +20,7 @@ export abstract class ScriptingLanguageFactory<T> implements IScriptingLanguageF
   protected registerGetter(language: ScriptingLanguage, getter: Getter<T>) {
     assertInRange(language, ScriptingLanguage);
     if (!getter) {
-      throw new Error('undefined getter');
+      throw new Error('missing getter');
     }
     if (this.getters.has(language)) {
       throw new Error(`${ScriptingLanguage[language]} is already registered`);

src/application/Context/ApplicationContext.ts

@@ -27,12 +27,12 @@ export class ApplicationContext implements IApplicationContext {
     initialContext: OperatingSystem,
   ) {
     validateApp(app);
-    assertInRange(initialContext, OperatingSystem);
     this.states = initializeStates(app);
     this.changeContext(initialContext);
   }
 
   public changeContext(os: OperatingSystem): void {
+    assertInRange(os, OperatingSystem);
     if (this.currentOs === os) {
       return;
     }
@@ -51,7 +51,7 @@ export class ApplicationContext implements IApplicationContext {
 
 function validateApp(app: IApplication) {
   if (!app) {
-    throw new Error('undefined app');
+    throw new Error('missing app');
   }
 }
 

src/application/Context/ApplicationContextFactory.ts

@@ -11,8 +11,8 @@ export async function buildContext(
   factory: IApplicationFactory = ApplicationFactory.Current,
   environment = Environment.CurrentEnvironment,
 ): Promise<IApplicationContext> {
-  if (!factory) { throw new Error('undefined factory'); }
-  if (!environment) { throw new Error('undefined environment'); }
+  if (!factory) { throw new Error('missing factory'); }
+  if (!environment) { throw new Error('missing environment'); }
   const app = await factory.getApp();
   const os = getInitialOs(app, environment);
   return new ApplicationContext(app, os);

src/application/Context/State/Code/ApplicationCode.ts

@@ -21,9 +21,9 @@ export class ApplicationCode implements IApplicationCode {
     private readonly scriptingDefinition: IScriptingDefinition,
     private readonly generator: IUserScriptGenerator = new UserScriptGenerator(),
   ) {
-    if (!userSelection) { throw new Error('userSelection is null or undefined'); }
-    if (!scriptingDefinition) { throw new Error('scriptingDefinition is null or undefined'); }
-    if (!generator) { throw new Error('generator is null or undefined'); }
+    if (!userSelection) { throw new Error('missing userSelection'); }
+    if (!scriptingDefinition) { throw new Error('missing scriptingDefinition'); }
+    if (!generator) { throw new Error('missing generator'); }
     this.setCode(userSelection.selectedScripts);
     userSelection.changed.on((scripts) => {
       this.setCode(scripts);

src/application/Context/State/Code/Generation/UserScriptGenerator.ts

@@ -17,8 +17,8 @@ export class UserScriptGenerator implements IUserScriptGenerator {
     selectedScripts: ReadonlyArray<SelectedScript>,
     scriptingDefinition: IScriptingDefinition,
   ): IUserScript {
-    if (!selectedScripts) { throw new Error('undefined scripts'); }
-    if (!scriptingDefinition) { throw new Error('undefined definition'); }
+    if (!selectedScripts) { throw new Error('missing scripts'); }
+    if (!scriptingDefinition) { throw new Error('missing definition'); }
     if (!selectedScripts.length) {
       return { code: '', scriptPositions: new Map<SelectedScript, ICodePosition>() };
     }

src/application/Environment/BrowserOs/DetectorBuilder.ts

@@ -27,7 +27,7 @@ export class DetectorBuilder {
 
   private detect(userAgent: string): OperatingSystem {
     if (!userAgent) {
-      throw new Error('User agent is null or undefined');
+      throw new Error('missing userAgent');
     }
     if (this.existingPartsInUserAgent.some((part) => !userAgent.includes(part))) {
       return undefined;

src/application/Parser/ApplicationParser.ts

@@ -32,10 +32,10 @@ const PreParsedCollections: readonly CollectionData [] = [
 ];
 
 function validateCollectionsData(collections: readonly CollectionData[]) {
-  if (!collections.length) {
-    throw new Error('no collection provided');
+  if (!collections || !collections.length) {
+    throw new Error('missing collections');
   }
   if (collections.some((collection) => !collection)) {
-    throw new Error('undefined collection provided');
+    throw new Error('missing collection provided');
   }
 }

src/application/Parser/CategoryCollectionParser.ts

@@ -29,7 +29,7 @@ export function parseCategoryCollection(
 
 function validate(content: CollectionData): void {
   if (!content) {
-    throw new Error('content is null or undefined');
+    throw new Error('missing content');
   }
   if (!content.actions || content.actions.length <= 0) {
     throw new Error('content does not define any action');

src/application/Parser/CategoryParser.ts

@@ -13,7 +13,7 @@ export function parseCategory(
   category: CategoryData,
   context: ICategoryCollectionParseContext,
 ): Category {
-  if (!context) { throw new Error('undefined context'); }
+  if (!context) { throw new Error('missing context'); }
   ensureValid(category);
   const children: ICategoryChildren = {
     subCategories: new Array<Category>(),
@@ -33,7 +33,7 @@ export function parseCategory(
 
 function ensureValid(category: CategoryData) {
   if (!category) {
-    throw Error('category is null or undefined');
+    throw Error('missing category');
   }
   if (!category.children || category.children.length === 0) {
     throw Error(`category has no children: "${category.category}"`);

src/application/Parser/DocumentationParser.ts

@@ -2,7 +2,7 @@ import { DocumentableData, DocumentationUrlsData } from 'js-yaml-loader!@/*';
 
 export function parseDocUrls(documentable: DocumentableData): ReadonlyArray<string> {
   if (!documentable) {
-    throw new Error('documentable is null or undefined');
+    throw new Error('missing documentable');
   }
   const { docs } = documentable;
   if (!docs || !docs.length) {

src/application/Parser/Script/CategoryCollectionParseContext.ts

@@ -17,7 +17,7 @@ export class CategoryCollectionParseContext implements ICategoryCollectionParseC
     scripting: IScriptingDefinition,
     syntaxFactory: ISyntaxFactory = new SyntaxFactory(),
   ) {
-    if (!scripting) { throw new Error('undefined scripting'); }
+    if (!scripting) { throw new Error('missing scripting'); }
     this.syntax = syntaxFactory.create(scripting.language);
     this.compiler = new ScriptCompiler(functionsData, this.syntax);
   }

src/application/Parser/Script/Compiler/Expressions/Expression/Expression.ts

@@ -8,23 +8,25 @@ import { ExpressionEvaluationContext, IExpressionEvaluationContext } from './Exp
 
 export type ExpressionEvaluator = (context: IExpressionEvaluationContext) => string;
 export class Expression implements IExpression {
+  public readonly parameters: IReadOnlyFunctionParameterCollection;
+
   constructor(
     public readonly position: ExpressionPosition,
     public readonly evaluator: ExpressionEvaluator,
-    public readonly parameters
-    : IReadOnlyFunctionParameterCollection = new FunctionParameterCollection(),
+    parameters?: IReadOnlyFunctionParameterCollection,
   ) {
     if (!position) {
-      throw new Error('undefined position');
+      throw new Error('missing position');
     }
     if (!evaluator) {
-      throw new Error('undefined evaluator');
+      throw new Error('missing evaluator');
     }
+    this.parameters = parameters ?? new FunctionParameterCollection();
   }
 
   public evaluate(context: IExpressionEvaluationContext): string {
     if (!context) {
-      throw new Error('undefined context');
+      throw new Error('missing context');
     }
     validateThatAllRequiredParametersAreSatisfied(this.parameters, context.args);
     const args = filterUnusedArguments(this.parameters, context.args);

src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionEvaluationContext.ts

@@ -13,7 +13,7 @@ export class ExpressionEvaluationContext implements IExpressionEvaluationContext
     public readonly pipelineCompiler: IPipelineCompiler = new PipelineCompiler(),
   ) {
     if (!args) {
-      throw new Error('undefined args, send empty collection instead');
+      throw new Error('missing args, send empty collection instead.');
     }
   }
 }

src/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler.ts

@@ -15,7 +15,7 @@ export class ExpressionsCompiler implements IExpressionsCompiler {
     args: IReadOnlyFunctionCallArgumentCollection,
   ): string {
     if (!args) {
-      throw new Error('undefined args, send empty collection instead');
+      throw new Error('missing args, send empty collection instead.');
     }
     if (!code) {
       return code;

src/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts

@@ -10,8 +10,11 @@ const Parsers = [
 
 export class CompositeExpressionParser implements IExpressionParser {
   public constructor(private readonly leafs: readonly IExpressionParser[] = Parsers) {
+    if (!leafs) {
+      throw new Error('missing leafs');
+    }
     if (leafs.some((leaf) => !leaf)) {
-      throw new Error('undefined leaf');
+      throw new Error('missing leaf');
     }
   }
 

src/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser.ts

@@ -16,7 +16,7 @@ export abstract class RegexParser implements IExpressionParser {
 
   private* findRegexExpressions(code: string): Iterable<IExpression> {
     if (!code) {
-      throw new Error('undefined code');
+      throw new Error('missing code');
     }
     const matches = code.matchAll(this.regex);
     for (const match of matches) {

src/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.ts

@@ -4,7 +4,10 @@ export class EscapeDoubleQuotes implements IPipe {
   public readonly name: string = 'escapeDoubleQuotes';
 
   public apply(raw: string): string {
-    return raw?.replaceAll('"', '"^""');
+    if (!raw) {
+      return raw;
+    }
+    return raw.replaceAll('"', '"^""');
     /* eslint-disable max-len */
     /*
       "^"" is the most robust and stable choice.

src/application/Parser/Script/Compiler/Expressions/Pipes/PipeFactory.ts

@@ -15,8 +15,11 @@ export class PipeFactory implements IPipeFactory {
   private readonly pipes = new Map<string, IPipe>();
 
   constructor(pipes: readonly IPipe[] = RegisteredPipes) {
+    if (!pipes) {
+      throw new Error('missing pipes');
+    }
     if (pipes.some((pipe) => !pipe)) {
-      throw new Error('undefined pipe in list');
+      throw new Error('missing pipe in list');
     }
     for (const pipe of pipes) {
       this.registerPipe(pipe);

src/application/Parser/Script/Compiler/Expressions/Pipes/PipelineCompiler.ts

@@ -23,8 +23,8 @@ function extractPipeNames(pipeline: string): string[] {
 }
 
 function ensureValidArguments(value: string, pipeline: string) {
-  if (!value) { throw new Error('undefined value'); }
-  if (!pipeline) { throw new Error('undefined pipeline'); }
+  if (!value) { throw new Error('missing value'); }
+  if (!pipeline) { throw new Error('missing pipeline'); }
   if (!pipeline.trimStart().startsWith('|')) {
     throw new Error('pipeline does not start with pipe');
   }

src/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument.ts

@@ -8,7 +8,7 @@ export class FunctionCallArgument implements IFunctionCallArgument {
   ) {
     ensureValidParameterName(parameterName);
     if (!argumentValue) {
-      throw new Error(`undefined argument value for "${parameterName}"`);
+      throw new Error(`missing argument value for "${parameterName}"`);
     }
   }
 }

src/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.ts

@@ -6,7 +6,7 @@ export class FunctionCallArgumentCollection implements IFunctionCallArgumentColl
 
   public addArgument(argument: IFunctionCallArgument): void {
     if (!argument) {
-      throw new Error('undefined argument');
+      throw new Error('missing argument');
     }
     if (this.hasArgument(argument.parameterName)) {
       throw new Error(`argument value for parameter ${argument.parameterName} is already provided`);
@@ -20,14 +20,14 @@ export class FunctionCallArgumentCollection implements IFunctionCallArgumentColl
 
   public hasArgument(parameterName: string): boolean {
     if (!parameterName) {
-      throw new Error('undefined parameter name');
+      throw new Error('missing parameter name');
     }
     return this.arguments.has(parameterName);
   }
 
   public getArgument(parameterName: string): IFunctionCallArgument {
     if (!parameterName) {
-      throw new Error('undefined parameter name');
+      throw new Error('missing parameter name');
     }
     const arg = this.arguments.get(parameterName);
     if (!arg) {

src/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler.ts

@@ -22,9 +22,9 @@ export class FunctionCallCompiler implements IFunctionCallCompiler {
     calls: IFunctionCall[],
     functions: ISharedFunctionCollection,
   ): ICompiledCode {
-    if (!functions) { throw new Error('undefined functions'); }
-    if (!calls) { throw new Error('undefined calls'); }
-    if (calls.some((f) => !f)) { throw new Error('undefined function call'); }
+    if (!functions) { throw new Error('missing functions'); }
+    if (!calls) { throw new Error('missing calls'); }
+    if (calls.some((f) => !f)) { throw new Error('missing function call'); }
     const context: ICompilationContext = {
       allFunctions: functions,
       callSequence: calls,

src/application/Parser/Script/Compiler/Function/Call/FunctionCall.ts

@@ -7,10 +7,10 @@ export class FunctionCall implements IFunctionCall {
     public readonly args: IReadOnlyFunctionCallArgumentCollection,
   ) {
     if (!functionName) {
-      throw new Error('empty function name in function call');
+      throw new Error('missing function name in function call');
     }
     if (!args) {
-      throw new Error('undefined args');
+      throw new Error('missing args');
     }
   }
 }

src/application/Parser/Script/Compiler/Function/Call/FunctionCallParser.ts

@@ -6,7 +6,7 @@ import { FunctionCall } from './FunctionCall';
 
 export function parseFunctionCalls(calls: FunctionCallsData): IFunctionCall[] {
   if (calls === undefined) {
-    throw new Error('undefined call data');
+    throw new Error('missing call data');
   }
   const sequence = getCallSequence(calls);
   return sequence.map((call) => parseFunctionCall(call));
@@ -24,7 +24,7 @@ function getCallSequence(calls: FunctionCallsData): FunctionCallData[] {
 
 function parseFunctionCall(call: FunctionCallData): IFunctionCall {
   if (!call) {
-    throw new Error('undefined function call');
+    throw new Error('missing call data');
   }
   const callArgs = parseArgs(call.parameters);
   return new FunctionCall(call.function, callArgs);

src/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection.ts

@@ -19,7 +19,7 @@ export class FunctionParameterCollection implements IFunctionParameterCollection
 
   private ensureValidParameter(parameter: IFunctionParameter) {
     if (!parameter) {
-      throw new Error('undefined parameter');
+      throw new Error('missing parameter');
     }
     if (this.includesName(parameter.name)) {
       throw new Error(`duplicate parameter name: "${parameter.name}"`);

src/application/Parser/Script/Compiler/Function/Shared/ParameterNameValidator.ts

@@ -1,6 +1,6 @@
 export function ensureValidParameterName(parameterName: string) {
   if (!parameterName) {
-    throw new Error('undefined parameter name');
+    throw new Error('missing parameter name');
   }
   if (!parameterName.match(/^[0-9a-zA-Z]+$/)) {
     throw new Error(`parameter name must be alphanumeric but it was "${parameterName}"`);

src/application/Parser/Script/Compiler/Function/SharedFunction.ts

@@ -9,11 +9,8 @@ export function createCallerFunction(
   parameters: IReadOnlyFunctionParameterCollection,
   callSequence: readonly IFunctionCall[],
 ): ISharedFunction {
-  if (!callSequence) {
-    throw new Error(`undefined call sequence in function "${name}"`);
-  }
-  if (!callSequence.length) {
-    throw new Error(`empty call sequence in function "${name}"`);
+  if (!callSequence || !callSequence.length) {
+    throw new Error(`missing call sequence in function "${name}"`);
   }
   return new SharedFunction(name, parameters, callSequence, FunctionBodyType.Calls);
 }
@@ -43,8 +40,8 @@ class SharedFunction implements ISharedFunction {
     content: IFunctionCode | readonly IFunctionCall[],
     bodyType: FunctionBodyType,
   ) {
-    if (!name) { throw new Error('undefined function name'); }
-    if (!parameters) { throw new Error('undefined parameters'); }
+    if (!name) { throw new Error('missing function name'); }
+    if (!parameters) { throw new Error('missing parameters'); }
     this.body = {
       type: bodyType,
       code: bodyType === FunctionBodyType.Code ? content as IFunctionCode : undefined,

src/application/Parser/Script/Compiler/Function/SharedFunctionCollection.ts

@@ -5,7 +5,7 @@ export class SharedFunctionCollection implements ISharedFunctionCollection {
   private readonly functionsByName = new Map<string, ISharedFunction>();
 
   public addFunction(func: ISharedFunction): void {
-    if (!func) { throw new Error('undefined function'); }
+    if (!func) { throw new Error('missing function'); }
     if (this.has(func.name)) {
       throw new Error(`function with name ${func.name} already exists`);
     }
@@ -13,7 +13,7 @@ export class SharedFunctionCollection implements ISharedFunctionCollection {
   }
 
   public getFunctionByName(name: string): ISharedFunction {
-    if (!name) { throw Error('undefined function name'); }
+    if (!name) { throw Error('missing function name'); }
     const func = this.functionsByName.get(name);
     if (!func) {
       throw new Error(`called function is not defined "${name}"`);

src/application/Parser/Script/Compiler/ScriptCompiler.ts

@@ -18,12 +18,12 @@ export class ScriptCompiler implements IScriptCompiler {
     private readonly callCompiler: IFunctionCallCompiler = FunctionCallCompiler.instance,
     sharedFunctionsParser: ISharedFunctionsParser = SharedFunctionsParser.instance,
   ) {
-    if (!syntax) { throw new Error('undefined syntax'); }
+    if (!syntax) { throw new Error('missing syntax'); }
     this.functions = sharedFunctionsParser.parseFunctions(functions);
   }
 
   public canCompile(script: ScriptData): boolean {
-    if (!script) { throw new Error('undefined script'); }
+    if (!script) { throw new Error('missing script'); }
     if (!script.call) {
       return false;
     }
@@ -31,7 +31,7 @@ export class ScriptCompiler implements IScriptCompiler {
   }
 
   public compile(script: ScriptData): IScriptCode {
-    if (!script) { throw new Error('undefined script'); }
+    if (!script) { throw new Error('missing script'); }
     try {
       const calls = parseFunctionCalls(script.call);
       const compiledCode = this.callCompiler.compileCall(calls, this.functions);

src/application/Parser/Script/ScriptParser.ts

@@ -13,7 +13,7 @@ export function parseScript(
   levelParser = createEnumParser(RecommendationLevel),
 ): Script {
   validateScript(data);
-  if (!context) { throw new Error('undefined context'); }
+  if (!context) { throw new Error('missing context'); }
   const script = new Script(
     /* name: */ data.name,
     /* code: */ parseCode(data, context),
@@ -51,7 +51,7 @@ function ensureNotBothCallAndCode(script: ScriptData) {
 
 function validateScript(script: ScriptData) {
   if (!script) {
-    throw new Error('undefined script');
+    throw new Error('missing script');
   }
   if (!script.code && !script.call) {
     throw new Error('must define either "call" or "code"');

src/application/Parser/ScriptingDefinition/CodeSubstituter.ts

@@ -16,8 +16,8 @@ export class CodeSubstituter implements ICodeSubstituter {
   }
 
   public substitute(code: string, info: IProjectInformation): string {
-    if (!code) { throw new Error('undefined code'); }
-    if (!info) { throw new Error('undefined info'); }
+    if (!code) { throw new Error('missing code'); }
+    if (!info) { throw new Error('missing info'); }
     const args = new FunctionCallArgumentCollection();
     const substitute = (name: string, value: string) => args
       .addArgument(new FunctionCallArgument(name, value));

src/application/Parser/ScriptingDefinition/ScriptingDefinitionParser.ts

@@ -18,8 +18,8 @@ export class ScriptingDefinitionParser {
     definition: ScriptingDefinitionData,
     info: IProjectInformation,
   ): IScriptingDefinition {
-    if (!info) { throw new Error('undefined info'); }
-    if (!definition) { throw new Error('undefined definition'); }
+    if (!info) { throw new Error('missing info'); }
+    if (!definition) { throw new Error('missing definition'); }
     const language = this.languageParser.parseEnum(definition.language, 'language');
     const startCode = this.codeSubstituter.substitute(definition.startCode, info);
     const endCode = this.codeSubstituter.substitute(definition.endCode, info);