Added test for `IfStatement` variants distribution

dist/index.js

@@ -2335,8 +2335,8 @@ var Obfuscator = Obfuscator_1 = function () {
     return Obfuscator;
 }();
 Obfuscator.controlFlowTransformersList = [NodeTransformers_1.NodeTransformers.BlockStatementControlFlowTransformer, NodeTransformers_1.NodeTransformers.FunctionControlFlowTransformer];
-Obfuscator.deadCodeInjectionTransformersList = [NodeTransformers_1.NodeTransformers.DeadCodeInjectionTransformer];
 Obfuscator.convertingTransformersList = [NodeTransformers_1.NodeTransformers.MemberExpressionTransformer, NodeTransformers_1.NodeTransformers.MethodDefinitionTransformer, NodeTransformers_1.NodeTransformers.TemplateLiteralTransformer];
+Obfuscator.deadCodeInjectionTransformersList = [NodeTransformers_1.NodeTransformers.DeadCodeInjectionTransformer];
 Obfuscator.obfuscatingTransformersList = [NodeTransformers_1.NodeTransformers.CatchClauseTransformer, NodeTransformers_1.NodeTransformers.FunctionDeclarationTransformer, NodeTransformers_1.NodeTransformers.FunctionTransformer, NodeTransformers_1.NodeTransformers.LabeledStatementTransformer, NodeTransformers_1.NodeTransformers.LiteralTransformer, NodeTransformers_1.NodeTransformers.ObjectExpressionTransformer, NodeTransformers_1.NodeTransformers.VariableDeclarationTransformer];
 Obfuscator = Obfuscator_1 = tslib_1.__decorate([inversify_1.injectable(), tslib_1.__param(0, inversify_1.inject(ServiceIdentifiers_1.ServiceIdentifiers.IStackTraceAnalyzer)), tslib_1.__param(1, inversify_1.inject(ServiceIdentifiers_1.ServiceIdentifiers.IObfuscationEventEmitter)), tslib_1.__param(2, inversify_1.inject(ServiceIdentifiers_1.ServiceIdentifiers.TCustomNodeGroupStorage)), tslib_1.__param(3, inversify_1.inject(ServiceIdentifiers_1.ServiceIdentifiers.Factory__INodeTransformer)), tslib_1.__param(4, inversify_1.inject(ServiceIdentifiers_1.ServiceIdentifiers.IOptions)), tslib_1.__metadata("design:paramtypes", [Object, Object, Object, Function, Object])], Obfuscator);
 exports.Obfuscator = Obfuscator;

src/Obfuscator.ts

@@ -37,17 +37,17 @@ export class Obfuscator implements IObfuscator {
     /**
      * @type {NodeTransformers[]}
      */
-    private static readonly deadCodeInjectionTransformersList: NodeTransformers[] = [
-        NodeTransformers.DeadCodeInjectionTransformer
+    private static readonly convertingTransformersList: NodeTransformers[] = [
+        NodeTransformers.MemberExpressionTransformer,
+        NodeTransformers.MethodDefinitionTransformer,
+        NodeTransformers.TemplateLiteralTransformer
     ];
 
     /**
      * @type {NodeTransformers[]}
      */
-    private static readonly convertingTransformersList: NodeTransformers[] = [
-        NodeTransformers.MemberExpressionTransformer,
-        NodeTransformers.MethodDefinitionTransformer,
-        NodeTransformers.TemplateLiteralTransformer
+    private static readonly deadCodeInjectionTransformersList: NodeTransformers[] = [
+        NodeTransformers.DeadCodeInjectionTransformer
     ];
 
     /**

test/dev/dev.ts

@@ -6,35 +6,31 @@ import { NO_CUSTOM_NODES_PRESET } from '../../src/options/presets/NoCustomNodes'
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-            (function(){
-    if (true) {
-        var foo = function () {
-            console.log('abc');
-        };
-        var bar = function () {
-            console.log('def');
-        };
-        var baz = function () {
-            console.log('ghi');
-        };
-        var bark = function () {
-            console.log('jkl');
-        };
-
-        for (var i = 0; i < 1; i++) {
-            continue;
-        }
-
-        for (var i = 0; i < 1; i++) {
-            break;
-        }
-
-        foo();
-        bar();
-        baz();
-        bark();
-    }
-})();
+        (function(){
+            if (true) {
+                var foo = function () {
+                    console.log('abc');
+                };
+                var bar = function () {
+                    alert('def');
+                };
+                var baz = function () {
+                    alert('ghi');
+                };
+                var bark = function () {
+                    alert('jkl');
+                };
+                var hawk = function () {
+                    alert('mno');
+                };
+            
+                foo();
+                bar();
+                baz();
+                bark();
+                hawk();
+            }
+        })();
         `,
         {
             ...NO_CUSTOM_NODES_PRESET,

test/functional-tests/node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer.spec.ts

@@ -131,5 +131,84 @@ describe('DeadCodeInjectionTransformer', () => {
                 assert.equal(loopMatches.length, 2);
             });
         });
+
+        describe('variant #5 - chance of `IfStatement` variant', () => {
+            const samplesCount: number = 1000;
+            const delta: number = 0.1;
+            const expectedValue: number = 0.25;
+
+            const ifMatch: string = `if *\\(!!\\[\\]\\) *\\{`;
+            const functionMatch: string = `var *${variableMatch} *= *function *\\(\\) *\\{`;
+
+            const match1: string = `` +
+                `if *\\(${variableMatch}\\('${hexMatch}'\\) *=== *${variableMatch}\\('${hexMatch}'\\)\\) *\\{` +
+                    `console.*` +
+                `\\} *else *\\{` +
+                    `${variableMatch}.*` +
+                `\\}` +
+            ``;
+            const match2: string = `` +
+                `if *\\(${variableMatch}\\('${hexMatch}'\\) *!== *${variableMatch}\\('${hexMatch}'\\)\\) *\\{` +
+                    `console.*` +
+                `\\} *else *\\{` +
+                    `${variableMatch}.*` +
+                `\\}` +
+            ``;
+            const match3: string = `` +
+                `if *\\(${variableMatch}\\('${hexMatch}'\\) *=== *${variableMatch}\\('${hexMatch}'\\)\\) *\\{` +
+                    `${variableMatch}.*` +
+                `\\} *else *\\{` +
+                    `console.*` +
+                `\\}` +
+            ``;
+            const match4: string = `` +
+                `if *\\(${variableMatch}\\('${hexMatch}'\\) *!== *${variableMatch}\\('${hexMatch}'\\)\\) *\\{` +
+                    `${variableMatch}.*` +
+                `\\} *else *\\{` +
+                    `console.*` +
+                `\\}` +
+            ``;
+
+            const regExp1: RegExp = new RegExp(`${ifMatch}${functionMatch}${match1}`);
+            const regExp2: RegExp = new RegExp(`${ifMatch}${functionMatch}${match2}`);
+            const regExp3: RegExp = new RegExp(`${ifMatch}${functionMatch}${match3}`);
+            const regExp4: RegExp = new RegExp(`${ifMatch}${functionMatch}${match4}`);
+
+            let count1: number = 0;
+            let count2: number = 0;
+            let count3: number = 0;
+            let count4: number = 0;
+
+            for (let i = 0; i < samplesCount; i++) {
+                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    readFileAsString(__dirname + '/fixtures/if-statement-variants-distribution.js'),
+                    {
+                        ...NO_CUSTOM_NODES_PRESET,
+                        deadCodeInjection: true,
+                        deadCodeInjectionThreshold: 1,
+                        stringArray: true,
+                        stringArrayThreshold: 1
+                    }
+                );
+                const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+
+                if (regExp1.test(obfuscatedCode)) {
+                    count1++;
+                } else if (regExp2.test(obfuscatedCode)) {
+                    count2++;
+                } else if (regExp3.test(obfuscatedCode)) {
+                    count3++;
+                } else if (regExp4.test(obfuscatedCode)) {
+                    count4++;
+                }
+            }
+
+            it('each of four `IfStatement` variant should have distribution close to `0.25`', () => {
+                assert.closeTo(count1 / samplesCount, expectedValue, delta);
+                assert.closeTo(count2 / samplesCount, expectedValue, delta);
+                assert.closeTo(count3 / samplesCount, expectedValue, delta);
+                assert.closeTo(count4 / samplesCount, expectedValue, delta);
+            });
+        });
     });
 });

test/functional-tests/node-transformers/dead-code-injection-transformers/fixtures/if-statement-variants-distribution.js

@@ -0,0 +1,25 @@
+(function(){
+    if (true) {
+        var foo = function () {
+            console.log('abc');
+        };
+        var bar = function () {
+            alert('def');
+        };
+        var baz = function () {
+            alert('ghi');
+        };
+        var bark = function () {
+            alert('jkl');
+        };
+        var hawk = function () {
+            alert('mno');
+        };
+
+        foo();
+        bar();
+        baz();
+        bark();
+        hawk();
+    }
+})();