refactor extra code, duplicates, complexity

- refactor array equality check and add tests
- remove OperatingSystem.Unknown causing extra logic, return undefined instead
- refactor enum validation to share same logic
- refactor scripting language factories to share same logic
- refactor too many args in runCodeAsync
- refactor ScriptCode constructor to reduce complexity
- fix writing useless write to member object since another property write always override it

tests/unit/application/Common/EnumRangeTestRunner.ts

@@ -0,0 +1,54 @@
+import 'mocha';
+import { expect } from 'chai';
+import { EnumType } from '@/application/Common/Enum';
+
+export class EnumRangeTestRunner<TEnumValue extends EnumType> {
+    constructor(private readonly runner: (value: TEnumValue) => any) {
+    }
+    public testOutOfRangeThrows() {
+        it('throws when value is out of range', () => {
+            // arrange
+            const value = Number.MAX_SAFE_INTEGER as TEnumValue;
+            const expectedError = `enum value "${value}" is out of range`;
+            // act
+            const act = () => this.runner(value);
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+        return this;
+    }
+    public testUndefinedValueThrows() {
+        it('throws when value is undefined', () => {
+            // arrange
+            const value = undefined;
+            const expectedError = 'undefined enum value';
+            // act
+            const act = () => this.runner(value);
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+        return this;
+    }
+    public testInvalidValueThrows(invalidValue: TEnumValue, expectedError: string) {
+        it(`throws ${expectedError}`, () => {
+            // arrange
+            const value = invalidValue;
+            // act
+            const act = () => this.runner(value);
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+        return this;
+    }
+    public testValidValueDoesNotThrow(validValue: TEnumValue) {
+        it('throws when value is undefined', () => {
+            // arrange
+            const value = validValue;
+            // act
+            const act = () => this.runner(value);
+            // assert
+            expect(act).to.not.throw();
+        });
+        return this;
+    }
+}