smock 0.1.207 → 0.1.208

data/node_modules/webpack/node_modules/uglify-js/test/compress/dead-code.js

@@ -0,0 +1,89 @@
+dead_code_1: {
+    options = {
+        dead_code: true
+    };
+    input: {
+        function f() {
+            a();
+            b();
+            x = 10;
+            return;
+            if (x) {
+                y();
+            }
+        }
+    }
+    expect: {
+        function f() {
+            a();
+            b();
+            x = 10;
+            return;
+        }
+    }
+}
+
+dead_code_2_should_warn: {
+    options = {
+        dead_code: true
+    };
+    input: {
+        function f() {
+            g();
+            x = 10;
+            throw "foo";
+            // completely discarding the `if` would introduce some
+            // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
+            // we copy any declarations to the upper scope.
+            if (x) {
+                y();
+                var x;
+                function g(){};
+                // but nested declarations should not be kept.
+                (function(){
+                    var q;
+                    function y(){};
+                })();
+            }
+        }
+    }
+    expect: {
+        function f() {
+            g();
+            x = 10;
+            throw "foo";
+            var x;
+            function g(){};
+        }
+    }
+}
+
+dead_code_constant_boolean_should_warn_more: {
+    options = {
+        dead_code    : true,
+        loops        : true,
+        booleans     : true,
+        conditionals : true,
+        evaluate     : true
+    };
+    input: {
+        while (!((foo && bar) || (x + "0"))) {
+            console.log("unreachable");
+            var foo;
+            function bar() {}
+        }
+        for (var x = 10; x && (y || x) && (!typeof x); ++x) {
+            asdf();
+            foo();
+            var moo;
+        }
+    }
+    expect: {
+        var foo;
+        function bar() {}
+        // nothing for the while
+        // as for the for, it should keep:
+        var x = 10;
+        var moo;
+    }
+}

data/node_modules/webpack/node_modules/uglify-js/test/compress/debugger.js

@@ -0,0 +1,24 @@
+keep_debugger: {
+    options = {
+        drop_debugger: false
+    };
+    input: {
+        debugger;
+    }
+    expect: {
+        debugger;
+    }
+}
+
+drop_debugger: {
+    options = {
+        drop_debugger: true
+    };
+    input: {
+        debugger;
+        if (foo) debugger;
+    }
+    expect: {
+        if (foo);
+    }
+}

data/node_modules/webpack/node_modules/uglify-js/test/compress/drop-unused.js

@@ -0,0 +1,165 @@
+unused_funarg_1: {
+    options = { unused: true };
+    input: {
+        function f(a, b, c, d, e) {
+            return a + b;
+        }
+    }
+    expect: {
+        function f(a, b) {
+            return a + b;
+        }
+    }
+}
+
+unused_funarg_2: {
+    options = { unused: true };
+    input: {
+        function f(a, b, c, d, e) {
+            return a + c;
+        }
+    }
+    expect: {
+        function f(a, b, c) {
+            return a + c;
+        }
+    }
+}
+
+unused_nested_function: {
+    options = { unused: true };
+    input: {
+        function f(x, y) {
+            function g() {
+                something();
+            }
+            return x + y;
+        }
+    };
+    expect: {
+        function f(x, y) {
+            return x + y;
+        }
+    }
+}
+
+unused_circular_references_1: {
+    options = { unused: true };
+    input: {
+        function f(x, y) {
+            // circular reference
+            function g() {
+                return h();
+            }
+            function h() {
+                return g();
+            }
+            return x + y;
+        }
+    };
+    expect: {
+        function f(x, y) {
+            return x + y;
+        }
+    }
+}
+
+unused_circular_references_2: {
+    options = { unused: true };
+    input: {
+        function f(x, y) {
+            var foo = 1, bar = baz, baz = foo + bar, qwe = moo();
+            return x + y;
+        }
+    };
+    expect: {
+        function f(x, y) {
+            moo();              // keeps side effect
+            return x + y;
+        }
+    }
+}
+
+unused_circular_references_3: {
+    options = { unused: true };
+    input: {
+        function f(x, y) {
+            var g = function() { return h() };
+            var h = function() { return g() };
+            return x + y;
+        }
+    };
+    expect: {
+        function f(x, y) {
+            return x + y;
+        }
+    }
+}
+
+unused_keep_setter_arg: {
+    options = { unused: true };
+    input: {
+        var x = {
+            _foo: null,
+            set foo(val) {
+            },
+            get foo() {
+                return this._foo;
+            }
+        }
+    }
+    expect: {
+        var x = {
+            _foo: null,
+            set foo(val) {
+            },
+            get foo() {
+                return this._foo;
+            }
+        }
+    }
+}
+
+unused_var_in_catch: {
+    options = { unused: true };
+    input: {
+        function foo() {
+            try {
+                foo();
+            } catch(ex) {
+                var x = 10;
+            }
+        }
+    }
+    expect: {
+        function foo() {
+            try {
+                foo();
+            } catch(ex) {}
+        }
+    }
+}
+
+used_var_in_catch: {
+    options = { unused: true };
+    input: {
+        function foo() {
+            try {
+                foo();
+            } catch(ex) {
+                var x = 10;
+            }
+            return x;
+        }
+    }
+    expect: {
+        function foo() {
+            try {
+                foo();
+            } catch(ex) {
+                var x = 10;
+            }
+            return x;
+        }
+    }
+}

data/node_modules/webpack/node_modules/uglify-js/test/compress/issue-105.js

@@ -0,0 +1,25 @@
+typeof_eq_undefined: {
+    options = {
+        comparisons: true
+    };
+    input: { a = typeof b.c != "undefined" }
+    expect: { a = "undefined" != typeof b.c }
+}
+
+typeof_eq_undefined_unsafe: {
+    options = {
+        comparisons: true,
+        unsafe: true
+    };
+    input: { a = typeof b.c != "undefined" }
+    expect: { a = void 0 !== b.c }
+}
+
+typeof_eq_undefined_unsafe2: {
+    options = {
+        comparisons: true,
+        unsafe: true
+    };
+    input: { a = "undefined" != typeof b.c }
+    expect: { a = void 0 !== b.c }
+}

data/node_modules/webpack/node_modules/uglify-js/test/compress/issue-12.js

@@ -0,0 +1,11 @@
+keep_name_of_getter: {
+    options = { unused: true };
+    input: { a = { get foo () {} } }
+    expect: { a = { get foo () {} } }
+}
+
+keep_name_of_setter: {
+    options = { unused: true };
+    input: { a = { set foo () {} } }
+    expect: { a = { set foo () {} } }
+}

data/node_modules/webpack/node_modules/uglify-js/test/compress/issue-126.js

@@ -0,0 +1,24 @@
+concatenate_rhs_strings: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        foo(bar() + 123 + "Hello" + "World");
+        foo(bar() + (123 + "Hello") + "World");
+        foo((bar() + 123) + "Hello" + "World");
+        foo(bar() + 123 + "Hello" + "World" + ("Foo" + "Bar"));
+        foo("Foo" + "Bar" + bar() + 123 + "Hello" + "World" + ("Foo" + "Bar"));
+        foo("Hello" + bar() + 123 + "World");
+        foo(bar() + 'Foo' + (10 + parseInt('10')));
+    }
+    expect: {
+        foo(bar() + 123 + "HelloWorld");
+        foo(bar() + "123HelloWorld");
+        foo((bar() + 123) + "HelloWorld");
+        foo(bar() + 123 + "HelloWorldFooBar");
+        foo("FooBar" + bar() + "123HelloWorldFooBar");
+        foo("Hello" + bar() + "123World");
+        foo(bar() + 'Foo' + (10 + parseInt('10')));
+    }
+}

data/node_modules/webpack/node_modules/uglify-js/test/compress/issue-143.js

@@ -0,0 +1,48 @@
+/**
+ * There was an incorrect sort behaviour documented in issue #143:
+ * (x = f(…)) <= x → x >= (x = f(…))
+ *
+ * For example, let the equation be:
+ * (a = parseInt('100')) <= a
+ *
+ * If a was an integer and has the value of 99,
+ * (a = parseInt('100')) <= a → 100 <= 100 → true
+ *
+ * When transformed incorrectly:
+ * a >= (a = parseInt('100')) → 99 >= 100 → false
+ */
+
+tranformation_sort_order_equal: {
+    options = {
+        comparisons: true,
+    };
+
+    input: { (a = parseInt('100')) == a }
+    expect: { (a = parseInt('100')) == a }
+}
+
+tranformation_sort_order_unequal: {
+    options = {
+        comparisons: true,
+    };
+
+    input: { (a = parseInt('100')) != a }
+    expect: { (a = parseInt('100')) != a }
+}
+
+tranformation_sort_order_lesser_or_equal: {
+    options = {
+        comparisons: true,
+    };
+
+    input: { (a = parseInt('100')) <= a }
+    expect: { (a = parseInt('100')) <= a }
+}
+tranformation_sort_order_greater_or_equal: {
+    options = {
+        comparisons: true,
+    };
+
+    input: { (a = parseInt('100')) >= a }
+    expect: { (a = parseInt('100')) >= a }
+}

data/node_modules/webpack/node_modules/uglify-js/test/compress/issue-22.js

@@ -0,0 +1,17 @@
+return_with_no_value_in_if_body: {
+    options = { conditionals: true };
+    input: {
+        function foo(bar) {
+            if (bar) {
+                return;
+            } else {
+                return 1;
+            }
+        }
+    }
+    expect: {
+        function foo (bar) {
+            return bar ? void 0 : 1;
+        }
+    }
+}

data/node_modules/webpack/node_modules/uglify-js/test/compress/issue-267.js

@@ -0,0 +1,11 @@
+issue_267: {
+    options = { comparisons: true };
+    input: {
+        x = a % b / b * c * 2;
+        x = a % b * 2
+    }
+    expect: {
+        x = a % b / b * c * 2;
+        x = a % b * 2;
+    }
+}

data/node_modules/webpack/node_modules/uglify-js/test/compress/issue-269.js

@@ -0,0 +1,66 @@
+issue_269_1: {
+	options = {unsafe: true};
+	input: {
+		f(
+			String(x),
+			Number(x),
+			Boolean(x),
+
+			String(),
+			Number(),
+			Boolean()
+		);
+	}
+	expect: {
+		f(
+			x + '', +x, !!x,
+			'', 0, false
+		);
+	}
+}
+
+issue_269_dangers: {
+	options = {unsafe: true};
+	input: {
+		f(
+			String(x, x),
+			Number(x, x),
+			Boolean(x, x)
+		);
+	}
+	expect: {
+		f(String(x, x), Number(x, x), Boolean(x, x));
+	}
+}
+
+issue_269_in_scope: {
+	options = {unsafe: true};
+	input: {
+		var String, Number, Boolean;
+		f(
+			String(x),
+			Number(x, x),
+			Boolean(x)
+		);
+	}
+	expect: {
+		var String, Number, Boolean;
+		f(String(x), Number(x, x), Boolean(x));
+	}
+}
+
+strings_concat: {
+	options = {unsafe: true};
+	input: {
+		f(
+			String(x + 'str'),
+			String('str' + x)
+		);
+	}
+	expect: {
+		f(
+			x + 'str',
+			'str' + x
+		);
+	}
+}