diff --git a/.travis.yml b/.travis.yml
index 13ce0c2..a229e06 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -3,6 +3,7 @@ sudo: false
 node_js:
   - "0.10"
   - "0.12"
+  - "4.2"
   - "stable"
 script:
   - "npm test"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 958c2f6..11cac6f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,20 @@
+## [2.0.0](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v2.0.0) (2015-11-12)
+
+
+#### Features
+
+* [Babel 6.x support](https://github.com/power-assert-js/babel-plugin-espower/pull/5)
+
+
+#### Breaking Changes
+
+Babel6 is incompatible with Babel5. For Babel 5 or lower, you need to use the 1.x release of babel-plugin-espower.
+
+```
+$ npm install --save-dev babel-plugin-espower@1.1.0
+```
+
+
 ## [1.1.0](https://github.com/power-assert-js/babel-plugin-espower/releases/tag/v1.1.0) (2015-11-06)
 
 
diff --git a/README.md b/README.md
index 88c86fe..90217ac 100644
--- a/README.md
+++ b/README.md
@@ -11,6 +11,7 @@ Babel plugin for power-assert.
 
 DESCRIPTION
 ---------------------------------------
+
 `babel-plugin-espower` is a [Babel](http://babeljs.io/) plugin for [power-assert](http://github.com/power-assert-js/power-assert).
 
 `power-assert` provides descriptive assertion messages for your tests, like this.
@@ -46,20 +47,35 @@ $ npm install --save-dev babel-plugin-espower
 ```
 
 
-HOW TO USE
+CAUTION
 ---------------------------------------
 
-
-### via [Babel CLI](http://babeljs.io/docs/usage/cli/)
+Babel6 is incompatible with Babel5. For Babel 5 or lower, you need to use the 1.x release of babel-plugin-espower.
 
 ```
-$ $(npm bin)/babel --plugins babel-plugin-espower /path/to/test/some_test.js > /path/to/build/some_test.js
+$ npm install --save-dev babel-plugin-espower@1.1.0
 ```
 
-or shortly,
+
+HOW TO USE
+---------------------------------------
+
+
+### via [.babelrc](http://babeljs.io/docs/usage/babelrc/)
+
+```javascript
+{
+  "presets": [
+    ...
+  ],
+  "plugins": [
+    "babel-plugin-espower"
+  ]
+}
+```
 
 ```
-$ $(npm bin)/babel --plugins espower /path/to/test/some_test.js > /path/to/build/some_test.js
+$ babel /path/to/test/some_test.js > /path/to/build/some_test.js
 ```
 
 
@@ -69,6 +85,7 @@ $ $(npm bin)/babel --plugins espower /path/to/test/some_test.js > /path/to/build
 var babel = require('babel-core');
 var jsCode = fs.readFileSync('/path/to/test/some_test.js');
 var transformed = babel.transform(jsCode, {
+    presets: [...],
     plugins: ['babel-plugin-espower']
 });
 console.log(transformed.code);
@@ -78,10 +95,9 @@ console.log(transformed.code);
 ### via [Babel Require Hook](http://babeljs.io/docs/usage/require/)
 
 ```javascript
-require('babel/register')({
-    only: /test\/tobe_instrumented/,
-    plugins: ['babel-plugin-espower'],
-    extensions: ['.es6', '.js']
+require('babel-register')({
+    presets: [...],
+    plugins: ['babel-plugin-espower']
 });
 ```
 
@@ -100,14 +116,17 @@ var browserify = require('browserify');
 var babelify = require('babelify');
 var glob = require('glob'),
 browserify({ entries: glob.sync('./test/*_test.js'), debug: true })
-  .transform(babelify.configure({ plugins: ['babel-plugin-espower'] }))
+  .transform(babelify.configure({
+      presets: [...],
+      plugins: ['babel-plugin-espower']
+  }))
   .bundle()
   .on('error', function (err) { console.log('Error : ' + err.message); })
   .pipe(fs.createWriteStream('all_test.js'));
 ```
 
 ```
-$ $(npm bin)/browserify -d -e ./test/*_test.js -t [ babelify --plugins babel-plugin-espower ]
+$ $(npm bin)/browserify -d -e ./test/*_test.js -t [ babelify --presets ... --plugins babel-plugin-espower ]
 ```
 
 
@@ -121,6 +140,7 @@ gulp.task('build_test', function() {
     var files = glob.sync('./test/*_test.js');
     var b = browserify({entries: files, debug: true});
     b.transform(babelify.configure({
+        presets: [...],
         plugins: ['babel-plugin-espower']
     }));
     return b.bundle()
@@ -145,7 +165,12 @@ module.exports = function(config) {
     browserify: {
       debug: true,
       transform: [
-        ['babelify', {plugins: ['babel-plugin-espower']}]
+        [
+          'babelify', {
+            presets: [...],
+            plugins: ['babel-plugin-espower']
+          }
+        ]
       ]
     },
     // ...
@@ -156,7 +181,7 @@ EXAMPLE
 ---------------------------------------
 
 
-For given test file `demo_test.js` below,
+For given test file `test/demo_test.js` below,
 
 ```javascript
 import assert from 'power-assert';
@@ -184,16 +209,19 @@ describe('ES6 demo', () => {
 });
 ```
 
-Run `babel` with `--plugins espower` to transform tests.
+prepare `babel_hook.js` to transform tests.
 
-```
-$ $(npm bin)/babel --plugins espower /path/to/test/demo_test.js > /path/to/build/demo_test.js
+```javascript
+require('babel-register')({
+    presets: [...],  // presets of your choice
+    plugins: ['babel-plugin-espower']
+});
 ```
 
-Then run. You will see the power-assert output appears.
+Run `mocha` with `--require` option. You will see the power-assert output appears.
 
 ```
-$ $(npm bin)/mocha /path/to/build/demo_test.js
+$ $(npm bin)/mocha --require ./babel_hook test/demo_test.js
 
   ES6 demo
     1) Destructuring and TemplateLiteral
@@ -222,7 +250,7 @@ $ $(npm bin)/mocha /path/to/build/demo_test.js
   -bob and alice
   +alice and bob
 
-      at Context.<anonymous> (build/demo_test.js:19:28)
+      at Context.<anonymous> (test/demo_test.js:19:28)
 
   2) ES6 demo ArrowFunctionExpression and SpreadElement:
 
@@ -239,7 +267,7 @@ $ $(npm bin)/mocha /path/to/build/demo_test.js
   [number] seven
   => 7
 
-      at Context.<anonymous> (build/demo_test.js:29:28)
+      at Context.<anonymous> (test/demo_test.js:29:28)
 
   3) ES6 demo Enhanced Object Literals:
      AssertionError:   # test/demo_test.js:17
@@ -251,7 +279,7 @@ $ $(npm bin)/mocha /path/to/build/demo_test.js
                    |      "bobby's greet"
                    Object{name:"bobby","bobby's greet":"Hello, I'm bobby"}
 
-      at Context.<anonymous> (build/demo_test.js:40:29)
+      at Context.<anonymous> (test/demo_test.js:40:29)
 ```
 
 
@@ -267,6 +295,7 @@ var babel = require('babel-core');
 var createEspowerPlugin = require('babel-plugin-espower/create');
 var jsCode = fs.readFileSync('/path/to/test/some_test.js');
 var transformed = babel.transform(jsCode, {
+    presets: [...],
     plugins: [
         createEspowerPlugin(babel, {
             patterns: [
@@ -284,8 +313,8 @@ or via [Require Hook](http://babeljs.io/docs/usage/require/).
 
 ```javascript
 var createEspowerPlugin = require('babel-plugin-espower/create');
-require('babel/register')({
-    only: /test\/tobe_instrumented/,
+require('babel-register')({
+    presets: [...],
     plugins: [
         createEspowerPlugin(babel, {
             patterns: [
@@ -294,8 +323,7 @@ require('babel/register')({
                 'assert.near(actual, expected, delta, [message])'
             ]
         })
-    ],
-    extensions: ['.es6', '.js']
+    ]
 });
 ```
 
diff --git a/create.js b/create.js
index dbd056a..eaa1685 100644
--- a/create.js
+++ b/create.js
@@ -3,5 +3,5 @@
 var createEspowerVisitor = require('./lib/create-espower-visitor');
 
 module.exports = function createEspowerPlugin (babel, options) {
-    return new babel.Transformer('babel-plugin-espower', createEspowerVisitor(babel, options));
+    return createEspowerVisitor(babel, options);
 };
diff --git a/lib/babel-assertion-visitor.js b/lib/babel-assertion-visitor.js
new file mode 100644
index 0000000..db5ec72
--- /dev/null
+++ b/lib/babel-assertion-visitor.js
@@ -0,0 +1,71 @@
+'use strict';
+
+var espower = require('espower');
+var inherits = require('util').inherits;
+var babelgen = require('babel-generator');
+var define = require('define-properties');
+var toBeCaptured = require('./to-be-captured');
+var toBeSkipped = require('./to-be-skipped');
+
+function BabelAssertionVisitor (babel, matcher, esPath, enclosingFunc, options) {
+    espower.AssertionVisitor.call(this, matcher, esPath, enclosingFunc, options);
+    this.babel = babel;
+}
+inherits(BabelAssertionVisitor, espower.AssertionVisitor);
+
+BabelAssertionVisitor.prototype.generateCanonicalCode = function (node) {
+    var gen = new babelgen.CodeGenerator(node, { concise: true });
+    return gen.generate().code;
+};
+
+BabelAssertionVisitor.prototype.isArgumentModified = function () {
+    return !!this.argumentModified;
+};
+
+BabelAssertionVisitor.prototype.captureArgument = function (node) {
+    var t = this.babel.types;
+    var props = {
+        content: this.canonicalCode,
+        filepath: this.filepath,
+        line: this.lineNum
+    };
+    if (this.withinAsync) {
+        props.async = true;
+    }
+    if (this.withinGenerator) {
+        props.generator = true;
+    }
+    var newNode = t.callExpression(
+        t.memberExpression(this.powerAssertCalleeObject, t.identifier('_expr')),
+        [
+            node,
+            t.valueToNode(props)
+        ]
+    );
+    define(newNode, { _generatedByEspower: true });
+    return newNode;
+};
+
+BabelAssertionVisitor.prototype.captureNode = function (target, path) {
+    var t = this.babel.types;
+    this.argumentModified = true;
+    var relativeEsPath = path.slice(this.assertionPath.length).join('/');
+    var newNode = t.callExpression(
+        t.memberExpression(this.powerAssertCalleeObject, t.identifier('_capt')),
+        [
+            target,
+            t.valueToNode(relativeEsPath)
+        ]);
+    define(newNode, { _generatedByEspower: true });
+    return newNode;
+};
+
+BabelAssertionVisitor.prototype.toBeSkipped = function (currentNode, parentNode, currentKey) {
+    return toBeSkipped(this.babel.types, currentNode, parentNode, currentKey);
+};
+
+BabelAssertionVisitor.prototype.toBeCaptured = function (currentNode, parentNode, currentKey) {
+    return toBeCaptured(this.babel.types, currentNode, parentNode, currentKey);
+};
+
+module.exports = BabelAssertionVisitor;
diff --git a/lib/create-espower-visitor.js b/lib/create-espower-visitor.js
index 2f27fa6..f35658e 100644
--- a/lib/create-espower-visitor.js
+++ b/lib/create-espower-visitor.js
@@ -4,24 +4,29 @@ var espower = require('espower');
 var escallmatch = require('escallmatch');
 var extend = require('xtend');
 var find = require('array-find');
+var BabelAssertionVisitor = require('./babel-assertion-visitor');
 
-function enterNodePath (nodePath, currentNode, parentNode, scope, file, matchers, esTreePath, options) {
+function enterNodePath (nodePath, pluginPass, matchers, esTreePath, options, babel) {
     var treePath;
     var currentKey = nodePath.key;
+    var currentNode = nodePath.node;
+    var parentNode = nodePath.parent;
+    var file = pluginPass.file;
     var assertionVisitor = file.get('espowerAssertionVisitor');
+    var types = babel.types;
     if (assertionVisitor) {
-        if (assertionVisitor.toBeSkipped(currentNode, parentNode, currentKey)) {
+        if (currentNode._generatedByEspower || assertionVisitor.toBeSkipped(currentNode, parentNode, currentKey)) {
             // skipping this Node
             // MEMO: exit() will not be called when skip() is called
             nodePath.skip();
             return;
         }
-        if (!assertionVisitor.isCapturingArgument() && !isCalleeOfParentCallExpression(parentNode, currentKey)) {
+        if (!assertionVisitor.isCapturingArgument() && !isCalleeOfParentCallExpression(types, parentNode, currentKey)) {
             // entering argument
             treePath = esTreePath(nodePath);
             assertionVisitor.enterArgument(currentNode, parentNode, treePath);
         }
-    } else if (currentNode.type === 'CallExpression') {
+    } else if (types.isCallExpression(currentNode)) {
         var matcher = find(matchers, function (m) { return m.test(currentNode); });
         if (matcher) {
             // entering assertion
@@ -31,17 +36,20 @@ function enterNodePath (nodePath, currentNode, parentNode, scope, file, matchers
             }, options);
             treePath = esTreePath(nodePath);
             var enclosingFunction = esTreePath.findEnclosingFunction(nodePath);
-            assertionVisitor = new espower.AssertionVisitor(matcher, treePath, enclosingFunction, espowerOptions);
+            assertionVisitor = new BabelAssertionVisitor(babel, matcher, treePath, enclosingFunction, espowerOptions);
             assertionVisitor.enter(currentNode, parentNode);
             file.set('espowerAssertionVisitor', assertionVisitor);
         }
     }
 }
 
-function exitNodePath (nodePath, currentNode, parentNode, scope, file, esTreePath, options) {
+function exitNodePath (nodePath, pluginPass, esTreePath, options, babel) {
     var currentKey = nodePath.key;
+    var currentNode = nodePath.node;
+    var parentNode = nodePath.parent;
     var resultTree = currentNode;
     var isTreeModified = false;
+    var file = pluginPass.file;
     var assertionVisitor = file.get('espowerAssertionVisitor');
     if (!assertionVisitor) {
         return;
@@ -50,7 +58,7 @@ function exitNodePath (nodePath, currentNode, parentNode, scope, file, esTreePat
     if (assertionVisitor.isLeavingAssertion(treePath)) {
         // leaving assertion
         assertionVisitor.leave(currentNode, parentNode);
-        delete file.data.espowerAssertionVisitor;
+        file.delete('espowerAssertionVisitor');
         return;
     }
     if (!assertionVisitor.isCapturingArgument()) {
@@ -61,19 +69,18 @@ function exitNodePath (nodePath, currentNode, parentNode, scope, file, esTreePat
         resultTree = assertionVisitor.captureNode(currentNode, treePath);
         isTreeModified = true;
     }
-    if (assertionVisitor.isLeavingArgument(treePath)) {
-        // capturing whole argument
+    if (assertionVisitor.isLeavingArgument(treePath) && assertionVisitor.isArgumentModified()) {
+        // capturing whole argument on leaving argument
         resultTree = assertionVisitor.leaveArgument(resultTree);
         isTreeModified = true;
     }
     if (isTreeModified) {
         nodePath.replaceWith(resultTree);
-        nodePath.skip();
     }
 }
 
-function isCalleeOfParentCallExpression(parentNode, currentKey) {
-    return parentNode.type === 'CallExpression' && currentKey === 'callee';
+function isCalleeOfParentCallExpression(types, parentNode, currentKey) {
+    return types.isCallExpression(parentNode) && currentKey === 'callee';
 }
 
 module.exports = function createEspowerVisitor (babel, options) {
@@ -83,15 +90,22 @@ module.exports = function createEspowerVisitor (babel, options) {
         sourceRoot: process.cwd()
     }, options);
     var matchers = opts.patterns.map(function (pattern) { return escallmatch(pattern, opts); });
-    return Object.keys(babel.types.VISITOR_KEYS).reduce(function (handlers, nodeType) {
+    var visitor = Object.keys(babel.types.VISITOR_KEYS).reduce(function (handlers, nodeType) {
         handlers[nodeType] = {
-            enter: function (currentNode, parentNode, scope, file) {
-                enterNodePath(this, currentNode, parentNode, scope, file, matchers, esTreePath, opts);
+            enter: function (nodePath, pluginPass) {
+                enterNodePath(nodePath, pluginPass, matchers, esTreePath, opts, babel);
             },
-            exit: function (currentNode, parentNode, scope, file) {
-                exitNodePath(this, currentNode, parentNode, scope, file, esTreePath, opts);
+            exit: function (nodePath, pluginPass) {
+                exitNodePath(nodePath, pluginPass, esTreePath, opts, babel);
             }
         };
         return handlers;
     }, {});
+    return {
+        visitor: {
+            Program: function (path, state) {
+                path.traverse(visitor, state);
+            }
+        }
+    };
 };
diff --git a/lib/to-be-captured.js b/lib/to-be-captured.js
new file mode 100644
index 0000000..1a61fbd
--- /dev/null
+++ b/lib/to-be-captured.js
@@ -0,0 +1,45 @@
+'use strict';
+
+var typesToBeCaptured = [
+    'Identifier',
+    'BinaryExpression',
+    'MemberExpression',
+    'CallExpression',
+    'UnaryExpression',
+    'LogicalExpression',
+    'ArrayExpression',
+    'ObjectExpression',
+    'TemplateLiteral',
+    'YieldExpression',
+    'AwaitExpression',
+    'NewExpression',
+    'AssignmentExpression',
+    'UpdateExpression',
+    'TaggedTemplateExpression'
+];
+
+function isCaputuringTargetType (types, currentNode) {
+    return typesToBeCaptured.some(function (nodeType) {
+        return types['is' + nodeType](currentNode);
+    });
+}
+
+function isCalleeOfParent(types, parentNode, currentKey) {
+    return (types.isCallExpression(parentNode) || types.isNewExpression(parentNode)) && currentKey === 'callee';
+}
+
+function isChildOfTaggedTemplateExpression(types, parentNode) {
+    return types.isTaggedTemplateExpression(parentNode);
+}
+
+function isYieldOrAwaitArgument(types, parentNode, currentKey) {
+    // capture the yielded/await result, not the promise
+    return (types.isYieldExpression(parentNode) || types.isAwaitExpression(parentNode)) && currentKey === 'argument';
+}
+
+module.exports = function toBeCaptured (types, currentNode, parentNode, currentKey) {
+    return isCaputuringTargetType(types, currentNode) &&
+        !isYieldOrAwaitArgument(types, parentNode, currentKey) &&
+        !isCalleeOfParent(types, parentNode, currentKey) &&
+        !isChildOfTaggedTemplateExpression(types, parentNode);
+};
diff --git a/lib/to-be-skipped.js b/lib/to-be-skipped.js
new file mode 100644
index 0000000..2655fcc
--- /dev/null
+++ b/lib/to-be-skipped.js
@@ -0,0 +1,82 @@
+'use strict';
+
+var typesNotToBeSkippedDuringCapturing = [
+    'Identifier',
+    'BinaryExpression',
+    'MemberExpression',
+    'CallExpression',
+    'UnaryExpression',
+    'LogicalExpression',
+    'ArrayExpression',
+    'ObjectExpression',
+    'TemplateLiteral',
+    'YieldExpression',
+    'AwaitExpression',
+    'NewExpression',
+    'AssignmentExpression',
+    'UpdateExpression',
+    'TaggedTemplateExpression',
+    'ConditionalExpression',
+    'SpreadElement',
+    'Property'
+];
+
+function isTypeNotToBeSkippedDuringCapturing (types, node) {
+    return typesNotToBeSkippedDuringCapturing.some(function (nodeType) {
+        return types['is' + nodeType](node);
+    });
+}
+
+function isLeftHandSideOfAssignment(types, parentNode, currentKey) {
+    // Do not instrument left due to 'Invalid left-hand side in assignment'
+    return types.isAssignmentExpression(parentNode) && currentKey === 'left';
+}
+
+function isChildOfObjectLiteral (types, parentNode) {
+    return types.isObjectProperty(parentNode) ||
+        types.isObjectMethod(parentNode) ||
+        types.isSpreadProperty(parentNode);
+}
+
+function isObjectLiteralKey (types, parentNode, currentKey) {
+    return isChildOfObjectLiteral(types, parentNode) && currentKey === 'key';
+}
+
+function isObjectLiteralValue (types, parentNode, currentKey) {
+    return isChildOfObjectLiteral(types, parentNode) && currentKey === 'value';
+}
+
+function isNonComputedObjectLiteralKey(types, parentNode, currentKey) {
+    // Do not instrument non-computed Object literal key
+    return isObjectLiteralKey(types, parentNode, currentKey) && !parentNode.computed;
+}
+
+function isShorthandedValueOfObjectLiteral(types, parentNode, currentKey) {
+    // Do not instrument shorthanded Object literal value
+    return isObjectLiteralValue(types, parentNode, currentKey) && parentNode.shorthand;
+}
+
+function isUpdateExpression(types, parentNode) {
+    // Just wrap UpdateExpression, not digging in.
+    return types.isUpdateExpression(parentNode);
+}
+
+function isCallExpressionWithNonComputedMemberExpression(types, currentNode, parentNode, currentKey) {
+    // Do not instrument non-computed property of MemberExpression within CallExpression.
+    return types.isIdentifier(currentNode) && types.isMemberExpression(parentNode) && !parentNode.computed && currentKey === 'property';
+}
+
+function isTypeOfOrDeleteUnaryExpression(types, currentNode, parentNode, currentKey) {
+    // 'typeof Identifier' or 'delete Identifier' is not instrumented
+    return types.isIdentifier(currentNode) && types.isUnaryExpression(parentNode) && (parentNode.operator === 'typeof' || parentNode.operator === 'delete') && currentKey === 'argument';
+}
+
+module.exports = function toBeSkipped (types, currentNode, parentNode, currentKey) {
+    return !isTypeNotToBeSkippedDuringCapturing(types, currentNode) ||
+        isLeftHandSideOfAssignment(types, parentNode, currentKey) ||
+        isNonComputedObjectLiteralKey(types, parentNode, currentKey) ||
+        isShorthandedValueOfObjectLiteral(types, parentNode, currentKey) ||
+        isUpdateExpression(types, parentNode) ||
+        isCallExpressionWithNonComputedMemberExpression(types, currentNode, parentNode, currentKey) ||
+        isTypeOfOrDeleteUnaryExpression(types, currentNode, parentNode, currentKey);
+};
diff --git a/package.json b/package.json
index c041b0f..c46261d 100644
--- a/package.json
+++ b/package.json
@@ -16,12 +16,16 @@
   ],
   "dependencies": {
     "array-find": "^1.0.0",
+    "babel-generator": "^6.1.0",
+    "define-properties": "^1.1.2",
     "escallmatch": "^1.4.2",
     "espower": "^1.2.1",
     "xtend": "^4.0.0"
   },
   "devDependencies": {
-    "babel": "^5.2.0",
+    "babel-core": "^6.1.0",
+    "babel-preset-es2015": "^6.1.2",
+    "babel-preset-stage-3": "^6.1.2",
     "mocha": "^2.2.4"
   },
   "directories": {
@@ -54,6 +58,6 @@
     "url": "http://github.com/power-assert-js/babel-plugin-espower.git"
   },
   "scripts": {
-    "test": "mocha"
+    "test": "mocha --timeout 0"
   }
 }
diff --git a/test/fixtures-with-presets-test.js b/test/fixtures-with-presets-test.js
new file mode 100644
index 0000000..af00c31
--- /dev/null
+++ b/test/fixtures-with-presets-test.js
@@ -0,0 +1,55 @@
+var assert = require('assert');
+var fs = require('fs');
+var path = require('path');
+var babel = require('babel-core');
+var extend = require('xtend');
+
+function testTransform (fixtureName, extraSuffix, extraOptions) {
+    it(fixtureName, function () {
+        var suffix = extraSuffix ? '-' + extraSuffix : '';
+        var fixtureFilepath = path.resolve(__dirname, 'fixtures', fixtureName, 'fixture.js');
+        var expectedFilepath = path.resolve(__dirname, 'fixtures', fixtureName, 'expected' + suffix + '.js');
+        var actualFilepath = path.resolve(__dirname, 'fixtures', fixtureName, 'actual' + suffix + '.js');
+        var result = babel.transformFileSync(fixtureFilepath, extend({
+            presets: [
+                'es2015',
+                'stage-3'
+            ],
+            plugins: [
+                '../index'
+            ]
+        }, extraOptions));
+        var actual = result.code + '\n';
+        var expected = fs.readFileSync(expectedFilepath, 'utf8');
+        if (actual != expected) {
+            fs.writeFileSync(actualFilepath, actual);
+        }
+        assert.equal(actual, expected);
+    });
+}
+
+describe('babel-plugin-espower with presets', function () {
+    testTransform('NonTarget');
+    testTransform('Literal', 'presets-es2015');
+    testTransform('Identifier');
+    testTransform('BinaryExpression');
+    testTransform('UnaryExpression', 'presets-es2015');
+    testTransform('LogicalExpression');
+    testTransform('MemberExpression');
+    testTransform('CallExpression');
+    testTransform('AssignmentExpression', 'presets-es2015');
+    testTransform('ArrayExpression', 'presets-es2015');
+    testTransform('UpdateExpression');
+    testTransform('ConditionalExpression', 'presets-es2015');
+    testTransform('ObjectExpression');
+    testTransform('NewExpression');
+    testTransform('FunctionExpression');
+    testTransform('TemplateLiteral', 'presets-es2015');
+    testTransform('TaggedTemplateExpression', 'presets-es2015');
+    testTransform('ArrowFunctionExpression', 'presets-es2015');
+    testTransform('ClassExpression', 'presets-es2015');
+    testTransform('SpreadElement', 'presets-es2015');
+    testTransform('Property', 'presets-es2015');
+    testTransform('YieldExpression', 'presets-es2015');
+    testTransform('AwaitExpression', 'presets-stage-3');
+});
diff --git a/test/fixtures/ArrayExpression/expected-presets-es2015.js b/test/fixtures/ArrayExpression/expected-presets-es2015.js
new file mode 100644
index 0000000..13a53ca
--- /dev/null
+++ b/test/fixtures/ArrayExpression/expected-presets-es2015.js
@@ -0,0 +1,25 @@
+'use strict';
+
+function _typeof(obj) { return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj; }
+
+assert(assert._expr(assert._capt([assert._capt(foo, 'arguments/0/elements/0'), assert._capt(bar, 'arguments/0/elements/1')], 'arguments/0'), {
+  content: 'assert([foo, bar])',
+  filepath: 'test/fixtures/ArrayExpression/fixture.js',
+  line: 3
+}));
+
+assert(assert._expr(assert._capt(assert._capt(_typeof(assert._capt([assert._capt([assert._capt(assert._capt(foo, 'arguments/0/left/argument/elements/0/elements/0/object').bar, 'arguments/0/left/argument/elements/0/elements/0'), assert._capt(baz(assert._capt(moo, 'arguments/0/left/argument/elements/0/elements/1/arguments/0')), 'arguments/0/left/argument/elements/0/elements/1')], 'arguments/0/left/argument/elements/0'), assert._capt(+assert._capt(fourStr, 'arguments/0/left/argument/elements/1/argument'), 'arguments/0/left/argument/elements/1')], 'arguments/0/left/argument')), 'arguments/0/left') === 'number', 'arguments/0'), {
+  content: 'assert(typeof [[foo.bar, baz(moo)], +fourStr] === \'number\')',
+  filepath: 'test/fixtures/ArrayExpression/fixture.js',
+  line: 5
+}));
+
+assert.notDeepEqual(assert._expr(assert._capt([assert._capt(foo, 'arguments/0/elements/0'), assert._capt(bar, 'arguments/0/elements/1')], 'arguments/0'), {
+  content: 'assert.notDeepEqual([foo, bar], [hoge, fuga, piyo])',
+  filepath: 'test/fixtures/ArrayExpression/fixture.js',
+  line: 7
+}), assert._expr(assert._capt([assert._capt(hoge, 'arguments/1/elements/0'), assert._capt(fuga, 'arguments/1/elements/1'), assert._capt(piyo, 'arguments/1/elements/2')], 'arguments/1'), {
+  content: 'assert.notDeepEqual([foo, bar], [hoge, fuga, piyo])',
+  filepath: 'test/fixtures/ArrayExpression/fixture.js',
+  line: 7
+}));
diff --git a/test/fixtures/ArrayExpression/expected.js b/test/fixtures/ArrayExpression/expected.js
index f0a2a05..1573538 100644
--- a/test/fixtures/ArrayExpression/expected.js
+++ b/test/fixtures/ArrayExpression/expected.js
@@ -1,23 +1,23 @@
 'use strict';
 
 assert(assert._expr(assert._capt([assert._capt(foo, 'arguments/0/elements/0'), assert._capt(bar, 'arguments/0/elements/1')], 'arguments/0'), {
-  content: 'assert([foo,bar])',
+  content: 'assert([foo, bar])',
   filepath: 'test/fixtures/ArrayExpression/fixture.js',
   line: 3
 }));
 
 assert(assert._expr(assert._capt(assert._capt(typeof assert._capt([assert._capt([assert._capt(assert._capt(foo, 'arguments/0/left/argument/elements/0/elements/0/object').bar, 'arguments/0/left/argument/elements/0/elements/0'), assert._capt(baz(assert._capt(moo, 'arguments/0/left/argument/elements/0/elements/1/arguments/0')), 'arguments/0/left/argument/elements/0/elements/1')], 'arguments/0/left/argument/elements/0'), assert._capt(+assert._capt(fourStr, 'arguments/0/left/argument/elements/1/argument'), 'arguments/0/left/argument/elements/1')], 'arguments/0/left/argument'), 'arguments/0/left') === 'number', 'arguments/0'), {
-  content: 'assert(typeof [[foo.bar,baz(moo)],+fourStr] === \'number\')',
+  content: 'assert(typeof [[foo.bar, baz(moo)], +fourStr] === \'number\')',
   filepath: 'test/fixtures/ArrayExpression/fixture.js',
   line: 5
 }));
 
 assert.notDeepEqual(assert._expr(assert._capt([assert._capt(foo, 'arguments/0/elements/0'), assert._capt(bar, 'arguments/0/elements/1')], 'arguments/0'), {
-  content: 'assert.notDeepEqual([foo,bar], [hoge,fuga,piyo])',
+  content: 'assert.notDeepEqual([foo, bar], [hoge, fuga, piyo])',
   filepath: 'test/fixtures/ArrayExpression/fixture.js',
   line: 7
 }), assert._expr(assert._capt([assert._capt(hoge, 'arguments/1/elements/0'), assert._capt(fuga, 'arguments/1/elements/1'), assert._capt(piyo, 'arguments/1/elements/2')], 'arguments/1'), {
-  content: 'assert.notDeepEqual([foo,bar], [hoge,fuga,piyo])',
+  content: 'assert.notDeepEqual([foo, bar], [hoge, fuga, piyo])',
   filepath: 'test/fixtures/ArrayExpression/fixture.js',
   line: 7
 }));
diff --git a/test/fixtures/ArrowFunctionExpression/expected-presets-es2015.js b/test/fixtures/ArrowFunctionExpression/expected-presets-es2015.js
new file mode 100644
index 0000000..56cfa31
--- /dev/null
+++ b/test/fixtures/ArrowFunctionExpression/expected-presets-es2015.js
@@ -0,0 +1,21 @@
+'use strict';
+
+assert(function (v) {
+  return v + 1;
+});
+
+assert(function (v, i) {
+  return v + i;
+});
+
+assert(function (v) {
+  return { even: v, odd: v + 1 };
+});
+
+assert(assert._expr(assert._capt(assert._capt(seven, 'arguments/0/left') === assert._capt((function (v, i) {
+  return v + i;
+})(assert._capt(four, 'arguments/0/right/arguments/0'), assert._capt(five, 'arguments/0/right/arguments/1')), 'arguments/0/right'), 'arguments/0'), {
+  content: 'assert(seven === ((v, i) => v + i)(four, five))',
+  filepath: 'test/fixtures/ArrowFunctionExpression/fixture.js',
+  line: 9
+}));
diff --git a/test/fixtures/ArrowFunctionExpression/expected.js b/test/fixtures/ArrowFunctionExpression/expected.js
index 56cfa31..b4b18d5 100644
--- a/test/fixtures/ArrowFunctionExpression/expected.js
+++ b/test/fixtures/ArrowFunctionExpression/expected.js
@@ -1,20 +1,12 @@
 'use strict';
 
-assert(function (v) {
-  return v + 1;
-});
+assert(v => v + 1);
 
-assert(function (v, i) {
-  return v + i;
-});
+assert((v, i) => v + i);
 
-assert(function (v) {
-  return { even: v, odd: v + 1 };
-});
+assert(v => ({ even: v, odd: v + 1 }));
 
-assert(assert._expr(assert._capt(assert._capt(seven, 'arguments/0/left') === assert._capt((function (v, i) {
-  return v + i;
-})(assert._capt(four, 'arguments/0/right/arguments/0'), assert._capt(five, 'arguments/0/right/arguments/1')), 'arguments/0/right'), 'arguments/0'), {
+assert(assert._expr(assert._capt(assert._capt(seven, 'arguments/0/left') === assert._capt(((v, i) => v + i)(assert._capt(four, 'arguments/0/right/arguments/0'), assert._capt(five, 'arguments/0/right/arguments/1')), 'arguments/0/right'), 'arguments/0'), {
   content: 'assert(seven === ((v, i) => v + i)(four, five))',
   filepath: 'test/fixtures/ArrowFunctionExpression/fixture.js',
   line: 9
diff --git a/test/fixtures/AssignmentExpression/expected-presets-es2015.js b/test/fixtures/AssignmentExpression/expected-presets-es2015.js
new file mode 100644
index 0000000..dd1eb72
--- /dev/null
+++ b/test/fixtures/AssignmentExpression/expected-presets-es2015.js
@@ -0,0 +1,45 @@
+'use strict';
+
+var _assert$_capt, _assert$_capt2, _assert$_capt3, _assert$_capt4;
+
+var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; })();
+
+assert(assert._expr(assert._capt(counter += 1, 'arguments/0'), {
+  content: 'assert(counter += 1)',
+  filepath: 'test/fixtures/AssignmentExpression/fixture.js',
+  line: 3
+}));
+
+assert(assert._expr(assert._capt(dog.age += 1, 'arguments/0'), {
+  content: 'assert(dog.age += 1)',
+  filepath: 'test/fixtures/AssignmentExpression/fixture.js',
+  line: 5
+}));
+
+assert(assert._expr(assert._capt(dog.age += 1, 'arguments/0'), {
+  content: 'assert(dog.age += 1)',
+  filepath: 'test/fixtures/AssignmentExpression/fixture.js',
+  line: 7
+}));
+
+assert.strictEqual(assert._expr(assert._capt(dog.age += 1, 'arguments/0'), {
+  content: 'assert.strictEqual(dog.age += 1, three)',
+  filepath: 'test/fixtures/AssignmentExpression/fixture.js',
+  line: 9
+}), assert._expr(assert._capt(three, 'arguments/1'), {
+  content: 'assert.strictEqual(dog.age += 1, three)',
+  filepath: 'test/fixtures/AssignmentExpression/fixture.js',
+  line: 9
+}));
+
+assert(assert._expr(assert._capt((_assert$_capt = assert._capt([3], 'arguments/0/right'), _assert$_capt2 = _slicedToArray(_assert$_capt, 1), x = _assert$_capt2[0], _assert$_capt), 'arguments/0'), {
+  content: 'assert([x] = [3])',
+  filepath: 'test/fixtures/AssignmentExpression/fixture.js',
+  line: 11
+}));
+
+assert(assert._expr(assert._capt((_assert$_capt3 = assert._capt([assert._capt(foo, 'arguments/0/right/elements/0')], 'arguments/0/right'), _assert$_capt4 = _slicedToArray(_assert$_capt3, 1), x = _assert$_capt4[0], _assert$_capt3), 'arguments/0'), {
+  content: 'assert([x] = [foo])',
+  filepath: 'test/fixtures/AssignmentExpression/fixture.js',
+  line: 13
+}));
diff --git a/test/fixtures/AssignmentExpression/expected.js b/test/fixtures/AssignmentExpression/expected.js
index 86190c3..1928d07 100644
--- a/test/fixtures/AssignmentExpression/expected.js
+++ b/test/fixtures/AssignmentExpression/expected.js
@@ -1,9 +1,5 @@
 'use strict';
 
-var _assert$_capt, _assert$_capt2, _assert$_capt3, _assert$_capt32;
-
-var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();
-
 assert(assert._expr(assert._capt(counter += 1, 'arguments/0'), {
   content: 'assert(counter += 1)',
   filepath: 'test/fixtures/AssignmentExpression/fixture.js',
@@ -32,13 +28,13 @@ assert.strictEqual(assert._expr(assert._capt(dog.age += 1, 'arguments/0'), {
   line: 9
 }));
 
-assert(assert._expr(assert._capt((_assert$_capt = assert._capt([3], 'arguments/0/right'), _assert$_capt2 = _slicedToArray(_assert$_capt, 1), x = _assert$_capt2[0], _assert$_capt), 'arguments/0'), {
+assert(assert._expr(assert._capt([x] = assert._capt([3], 'arguments/0/right'), 'arguments/0'), {
   content: 'assert([x] = [3])',
   filepath: 'test/fixtures/AssignmentExpression/fixture.js',
   line: 11
 }));
 
-assert(assert._expr(assert._capt((_assert$_capt3 = assert._capt([assert._capt(foo, 'arguments/0/right/elements/0')], 'arguments/0/right'), _assert$_capt32 = _slicedToArray(_assert$_capt3, 1), x = _assert$_capt32[0], _assert$_capt3), 'arguments/0'), {
+assert(assert._expr(assert._capt([x] = assert._capt([assert._capt(foo, 'arguments/0/right/elements/0')], 'arguments/0/right'), 'arguments/0'), {
   content: 'assert([x] = [foo])',
   filepath: 'test/fixtures/AssignmentExpression/fixture.js',
   line: 13
diff --git a/test/fixtures/AwaitExpression/expected-presets-stage-3.js b/test/fixtures/AwaitExpression/expected-presets-stage-3.js
new file mode 100644
index 0000000..82a4267
--- /dev/null
+++ b/test/fixtures/AwaitExpression/expected-presets-stage-3.js
@@ -0,0 +1,46 @@
+'use strict';
+
+var myAsync = (function () {
+  var ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(a) {
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.t0 = assert;
+            _context.t1 = assert;
+            _context.t2 = assert;
+            _context.next = 5;
+            return a;
+
+          case 5:
+            _context.t3 = _context.sent;
+            _context.t4 = _context.t2._capt.call(_context.t2, _context.t3, 'arguments/0/left');
+            _context.t5 = _context.t4 === 3;
+            _context.t6 = _context.t1._capt.call(_context.t1, _context.t5, 'arguments/0');
+            _context.t7 = {
+              content: 'assert(await a === 3)',
+              filepath: 'test/fixtures/AwaitExpression/fixture.js',
+              line: 4,
+              async: true
+            };
+            _context.t8 = _context.t0._expr.call(_context.t0, _context.t6, _context.t7);
+            assert(_context.t8);
+
+          case 12:
+          case 'end':
+            return _context.stop();
+        }
+      }
+    }, _callee, this);
+  }));
+
+  return function myAsync(_x) {
+    return ref.apply(this, arguments);
+  };
+})();
+
+// function notAsync(a){
+//   assert((await (a)) === 3);
+// }
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { var callNext = step.bind(null, "next"); var callThrow = step.bind(null, "throw"); function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(callNext, callThrow); } } callNext(); }); }; }
diff --git a/test/fixtures/AwaitExpression/expected.js b/test/fixtures/AwaitExpression/expected.js
deleted file mode 100644
index 265ab46..0000000
--- a/test/fixtures/AwaitExpression/expected.js
+++ /dev/null
@@ -1,40 +0,0 @@
-'use strict';
-
-function myAsync(a) {
-  return regeneratorRuntime.async(function myAsync$(context$1$0) {
-    while (1) switch (context$1$0.prev = context$1$0.next) {
-      case 0:
-        context$1$0.t0 = assert;
-        context$1$0.t1 = assert;
-        context$1$0.t2 = assert;
-        context$1$0.next = 5;
-        return regeneratorRuntime.awrap(a);
-
-      case 5:
-        context$1$0.t3 = context$1$0.sent;
-        context$1$0.t4 = context$1$0.t2._capt.call(context$1$0.t2, context$1$0.t3, 'arguments/0/left');
-        context$1$0.t5 = context$1$0.t4 === 3;
-        context$1$0.t6 = context$1$0.t1._capt.call(context$1$0.t1, context$1$0.t5, 'arguments/0');
-        context$1$0.t7 = {
-          async: true,
-          content: 'assert((await a) === 3)',
-          filepath: 'test/fixtures/AwaitExpression/fixture.js',
-          line: 4
-        };
-        context$1$0.t8 = context$1$0.t0._expr.call(context$1$0.t0, context$1$0.t6, context$1$0.t7);
-        assert(context$1$0.t8);
-
-      case 12:
-      case 'end':
-        return context$1$0.stop();
-    }
-  }, null, this);
-}
-
-function notAsync(a) {
-  assert(assert._expr(assert._capt(assert._capt(await(assert._capt(a, 'arguments/0/left/arguments/0')), 'arguments/0/left') === 3, 'arguments/0'), {
-    content: 'assert(await(a) === 3)',
-    filepath: 'test/fixtures/AwaitExpression/fixture.js',
-    line: 8
-  }));
-}
diff --git a/test/fixtures/AwaitExpression/fixture.js b/test/fixtures/AwaitExpression/fixture.js
index 379b497..2f96747 100644
--- a/test/fixtures/AwaitExpression/fixture.js
+++ b/test/fixtures/AwaitExpression/fixture.js
@@ -4,6 +4,6 @@ async function myAsync(a){
   assert((await (a)) === 3);
 }
 
-function notAsync(a){
-  assert((await (a)) === 3);
-}
+// function notAsync(a){
+//   assert((await (a)) === 3);
+// }
diff --git a/test/fixtures/ClassExpression/expected-presets-es2015.js b/test/fixtures/ClassExpression/expected-presets-es2015.js
new file mode 100644
index 0000000..09bd278
--- /dev/null
+++ b/test/fixtures/ClassExpression/expected-presets-es2015.js
@@ -0,0 +1,20 @@
+'use strict';
+
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+assert((function () {
+  function Me() {
+    _classCallCheck(this, Me);
+  }
+
+  _createClass(Me, [{
+    key: 'getClassName',
+    value: function getClassName() {
+      return foo + Me.name;
+    }
+  }]);
+
+  return Me;
+})());
diff --git a/test/fixtures/ClassExpression/expected.js b/test/fixtures/ClassExpression/expected.js
index 13c66fb..e674682 100644
--- a/test/fixtures/ClassExpression/expected.js
+++ b/test/fixtures/ClassExpression/expected.js
@@ -1,20 +1,7 @@
 'use strict';
 
-var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-assert((function () {
-  function Me() {
-    _classCallCheck(this, Me);
+assert(class Me {
+  getClassName() {
+    return foo + Me.name;
   }
-
-  _createClass(Me, [{
-    key: 'getClassName',
-    value: function getClassName() {
-      return foo + Me.name;
-    }
-  }]);
-
-  return Me;
-})());
+});
diff --git a/test/fixtures/ConditionalExpression/expected-presets-es2015.js b/test/fixtures/ConditionalExpression/expected-presets-es2015.js
new file mode 100644
index 0000000..2770549
--- /dev/null
+++ b/test/fixtures/ConditionalExpression/expected-presets-es2015.js
@@ -0,0 +1,31 @@
+'use strict';
+
+function _typeof(obj) { return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj; }
+
+assert(assert._expr(assert._capt(foo, 'arguments/0/test') ? assert._capt(bar, 'arguments/0/consequent') : assert._capt(baz, 'arguments/0/alternate'), {
+  content: 'assert(foo ? bar : baz)',
+  filepath: 'test/fixtures/ConditionalExpression/fixture.js',
+  line: 3
+}));
+
+assert(assert._expr(assert._capt(falsy, 'arguments/0/test') ? assert._capt(truthy, 'arguments/0/consequent') : assert._capt(truthy, 'arguments/0/alternate/test') ? assert._capt(anotherFalsy, 'arguments/0/alternate/consequent') : assert._capt(truthy, 'arguments/0/alternate/alternate'), {
+  content: 'assert(falsy ? truthy : truthy ? anotherFalsy : truthy)',
+  filepath: 'test/fixtures/ConditionalExpression/fixture.js',
+  line: 5
+}));
+
+assert(assert._expr(assert._capt(foo(), 'arguments/0/test') ? assert._capt(assert._capt(bar, 'arguments/0/consequent/object').baz, 'arguments/0/consequent') : assert._capt(typeof goo === 'undefined' ? 'undefined' : _typeof(goo), 'arguments/0/alternate'), {
+  content: 'assert(foo() ? bar.baz : typeof goo)',
+  filepath: 'test/fixtures/ConditionalExpression/fixture.js',
+  line: 7
+}));
+
+assert.equal(assert._expr(assert._capt(foo, 'arguments/0/test') ? assert._capt(bar, 'arguments/0/consequent') : assert._capt(baz, 'arguments/0/alternate'), {
+  content: 'assert.equal(foo ? bar : baz, falsy ? truthy : truthy ? anotherFalsy : truthy)',
+  filepath: 'test/fixtures/ConditionalExpression/fixture.js',
+  line: 9
+}), assert._expr(assert._capt(falsy, 'arguments/1/test') ? assert._capt(truthy, 'arguments/1/consequent') : assert._capt(truthy, 'arguments/1/alternate/test') ? assert._capt(anotherFalsy, 'arguments/1/alternate/consequent') : assert._capt(truthy, 'arguments/1/alternate/alternate'), {
+  content: 'assert.equal(foo ? bar : baz, falsy ? truthy : truthy ? anotherFalsy : truthy)',
+  filepath: 'test/fixtures/ConditionalExpression/fixture.js',
+  line: 9
+}));
diff --git a/test/fixtures/FunctionExpression/expected.js b/test/fixtures/FunctionExpression/expected.js
index 9facf34..92a3b79 100644
--- a/test/fixtures/FunctionExpression/expected.js
+++ b/test/fixtures/FunctionExpression/expected.js
@@ -7,7 +7,7 @@ assert(function (a, b) {
 assert(assert._expr(assert._capt(assert._capt(baz, 'arguments/0/left') === assert._capt((function (a, b) {
   return a + b;
 })(assert._capt(foo, 'arguments/0/right/arguments/0'), assert._capt(bar, 'arguments/0/right/arguments/1')), 'arguments/0/right'), 'arguments/0'), {
-  content: 'assert(baz === function (a, b) {return a + b;}(foo, bar))',
+  content: 'assert(baz === (function (a, b) { return a + b; })(foo, bar))',
   filepath: 'test/fixtures/FunctionExpression/fixture.js',
   line: 5
 }));
diff --git a/test/fixtures/Literal/expected-presets-es2015.js b/test/fixtures/Literal/expected-presets-es2015.js
new file mode 100644
index 0000000..d587e3c
--- /dev/null
+++ b/test/fixtures/Literal/expected-presets-es2015.js
@@ -0,0 +1,39 @@
+'use strict';
+
+assert(false);
+
+assert(0);
+
+assert.equal(1, 0);
+
+assert(false, 'message');
+
+assert(false, messageStr);
+
+assert.equal(assert._expr(assert._capt(foo, 'arguments/0'), {
+  content: 'assert.equal(foo, \'bar\', \'msg\')',
+  filepath: 'test/fixtures/Literal/fixture.js',
+  line: 13
+}), 'bar', 'msg');
+
+assert(assert._expr(assert._capt(/^not/.exec(assert._capt(str, 'arguments/0/arguments/0')), 'arguments/0'), {
+  content: 'assert(/^not/.exec(str))',
+  filepath: 'test/fixtures/Literal/fixture.js',
+  line: 15
+}));
+
+assert(assert._expr(assert._capt(assert._capt(fuga, 'arguments/0/left') !== 'ふが', 'arguments/0'), {
+  content: 'assert(fuga !== \'ふが\')',
+  filepath: 'test/fixtures/Literal/fixture.js',
+  line: 17
+}));
+
+assert(assert._expr(assert._capt('ほげ' !== 'ふが', 'arguments/0'), {
+  content: 'assert(\'ほげ\' !== \'ふが\')',
+  filepath: 'test/fixtures/Literal/fixture.js',
+  line: 19
+}));
+
+assert(503);
+
+assert(503);
diff --git a/test/fixtures/Literal/expected.js b/test/fixtures/Literal/expected.js
index d587e3c..21e5870 100644
--- a/test/fixtures/Literal/expected.js
+++ b/test/fixtures/Literal/expected.js
@@ -34,6 +34,6 @@ assert(assert._expr(assert._capt('ほげ' !== 'ふが', 'arguments/0'), {
   line: 19
 }));
 
-assert(503);
+assert(0b111110111);
 
-assert(503);
+assert(0o767);
diff --git a/test/fixtures/ObjectExpression/expected.js b/test/fixtures/ObjectExpression/expected.js
index 62fc3fd..5190a59 100644
--- a/test/fixtures/ObjectExpression/expected.js
+++ b/test/fixtures/ObjectExpression/expected.js
@@ -1,23 +1,23 @@
 'use strict';
 
 assert(assert._expr(assert._capt({ foo: assert._capt(bar, 'arguments/0/properties/0/value'), hoge: assert._capt(fuga, 'arguments/0/properties/1/value') }, 'arguments/0'), {
-  content: 'assert({foo: bar,hoge: fuga})',
+  content: 'assert({ foo: bar, hoge: fuga })',
   filepath: 'test/fixtures/ObjectExpression/fixture.js',
   line: 3
 }));
 
 assert(assert._expr(assert._capt(!assert._capt({ foo: assert._capt(assert._capt(bar, 'arguments/0/argument/properties/0/value/object').baz, 'arguments/0/argument/properties/0/value'), name: assert._capt(nameOf(assert._capt({ firstName: assert._capt(first, 'arguments/0/argument/properties/1/value/arguments/0/properties/0/value'), lastName: assert._capt(last, 'arguments/0/argument/properties/1/value/arguments/0/properties/1/value') }, 'arguments/0/argument/properties/1/value/arguments/0')), 'arguments/0/argument/properties/1/value') }, 'arguments/0/argument'), 'arguments/0'), {
-  content: 'assert(!{foo: bar.baz,name: nameOf({firstName: first,lastName: last})})',
+  content: 'assert(!{ foo: bar.baz, name: nameOf({ firstName: first, lastName: last }) })',
   filepath: 'test/fixtures/ObjectExpression/fixture.js',
   line: 5
 }));
 
 assert.deepEqual(assert._expr(assert._capt({ foo: assert._capt(bar, 'arguments/0/properties/0/value'), hoge: assert._capt(fuga, 'arguments/0/properties/1/value') }, 'arguments/0'), {
-  content: 'assert.deepEqual({foo: bar,hoge: fuga}, {hoge: fuga,foo: bar})',
+  content: 'assert.deepEqual({ foo: bar, hoge: fuga }, { hoge: fuga, foo: bar })',
   filepath: 'test/fixtures/ObjectExpression/fixture.js',
   line: 7
 }), assert._expr(assert._capt({ hoge: assert._capt(fuga, 'arguments/1/properties/0/value'), foo: assert._capt(bar, 'arguments/1/properties/1/value') }, 'arguments/1'), {
-  content: 'assert.deepEqual({foo: bar,hoge: fuga}, {hoge: fuga,foo: bar})',
+  content: 'assert.deepEqual({ foo: bar, hoge: fuga }, { hoge: fuga, foo: bar })',
   filepath: 'test/fixtures/ObjectExpression/fixture.js',
   line: 7
 }));
diff --git a/test/fixtures/Property/expected-presets-es2015.js b/test/fixtures/Property/expected-presets-es2015.js
new file mode 100644
index 0000000..f54b07e
--- /dev/null
+++ b/test/fixtures/Property/expected-presets-es2015.js
@@ -0,0 +1,35 @@
+'use strict';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+assert(assert._expr(assert._capt(_defineProperty({}, assert._capt(num, 'arguments/0/properties/0/key'), assert._capt(foo, 'arguments/0/properties/0/value')), 'arguments/0'), {
+  content: 'assert({ [num]: foo })',
+  filepath: 'test/fixtures/Property/fixture.js',
+  line: 3
+}));
+
+assert(assert._expr(assert._capt(_defineProperty({}, assert._capt('prop_' + assert._capt((function () {
+  return bar();
+})(), 'arguments/0/properties/0/key/right'), 'arguments/0/properties/0/key'), 42), 'arguments/0'), {
+  content: 'assert({ [\'prop_\' + (() => bar())()]: 42 })',
+  filepath: 'test/fixtures/Property/fixture.js',
+  line: 5
+}));
+
+assert(assert._expr(assert._capt(_defineProperty({}, assert._capt('prop_' + assert._capt(generate(assert._capt(seed, 'arguments/0/properties/0/key/expressions/0/arguments/0')), 'arguments/0/properties/0/key/expressions/0'), 'arguments/0/properties/0/key'), assert._capt(foo, 'arguments/0/properties/0/value')), 'arguments/0'), {
+  content: 'assert({ [`prop_${ generate(seed) }`]: foo })',
+  filepath: 'test/fixtures/Property/fixture.js',
+  line: 7
+}));
+
+assert(assert._expr(assert._capt({ foo: foo }, 'arguments/0'), {
+  content: 'assert({ foo })',
+  filepath: 'test/fixtures/Property/fixture.js',
+  line: 9
+}));
+
+assert(assert._expr(assert._capt({ foo: foo, bar: assert._capt(baz, 'arguments/0/properties/1/value') }, 'arguments/0'), {
+  content: 'assert({ foo, bar: baz })',
+  filepath: 'test/fixtures/Property/fixture.js',
+  line: 11
+}));
diff --git a/test/fixtures/Property/expected.js b/test/fixtures/Property/expected.js
index 38e46d9..370ce23 100644
--- a/test/fixtures/Property/expected.js
+++ b/test/fixtures/Property/expected.js
@@ -1,35 +1,31 @@
 'use strict';
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-assert(assert._expr(assert._capt(_defineProperty({}, assert._capt(num, 'arguments/0/properties/0/key'), assert._capt(foo, 'arguments/0/properties/0/value')), 'arguments/0'), {
+assert(assert._expr(assert._capt({ [assert._capt(num, 'arguments/0/properties/0/key')]: assert._capt(foo, 'arguments/0/properties/0/value') }, 'arguments/0'), {
   content: 'assert({ [num]: foo })',
   filepath: 'test/fixtures/Property/fixture.js',
   line: 3
 }));
 
-assert(assert._expr(assert._capt(_defineProperty({}, assert._capt('prop_' + assert._capt((function () {
-  return bar();
-})(), 'arguments/0/properties/0/key/right'), 'arguments/0/properties/0/key'), 42), 'arguments/0'), {
+assert(assert._expr(assert._capt({ [assert._capt('prop_' + assert._capt((() => bar())(), 'arguments/0/properties/0/key/right'), 'arguments/0/properties/0/key')]: 42 }, 'arguments/0'), {
   content: 'assert({ [\'prop_\' + (() => bar())()]: 42 })',
   filepath: 'test/fixtures/Property/fixture.js',
   line: 5
 }));
 
-assert(assert._expr(assert._capt(_defineProperty({}, assert._capt('prop_' + assert._capt(generate(assert._capt(seed, 'arguments/0/properties/0/key/expressions/0/arguments/0')), 'arguments/0/properties/0/key/expressions/0'), 'arguments/0/properties/0/key'), assert._capt(foo, 'arguments/0/properties/0/value')), 'arguments/0'), {
+assert(assert._expr(assert._capt({ [assert._capt(`prop_${ assert._capt(generate(assert._capt(seed, 'arguments/0/properties/0/key/expressions/0/arguments/0')), 'arguments/0/properties/0/key/expressions/0') }`, 'arguments/0/properties/0/key')]: assert._capt(foo, 'arguments/0/properties/0/value') }, 'arguments/0'), {
   content: 'assert({ [`prop_${ generate(seed) }`]: foo })',
   filepath: 'test/fixtures/Property/fixture.js',
   line: 7
 }));
 
-assert(assert._expr(assert._capt({ foo: foo }, 'arguments/0'), {
+assert(assert._expr(assert._capt({ foo }, 'arguments/0'), {
   content: 'assert({ foo })',
   filepath: 'test/fixtures/Property/fixture.js',
   line: 9
 }));
 
-assert(assert._expr(assert._capt({ foo: foo, bar: assert._capt(baz, 'arguments/0/properties/1/value') }, 'arguments/0'), {
-  content: 'assert({foo,bar: baz})',
+assert(assert._expr(assert._capt({ foo, bar: assert._capt(baz, 'arguments/0/properties/1/value') }, 'arguments/0'), {
+  content: 'assert({ foo, bar: baz })',
   filepath: 'test/fixtures/Property/fixture.js',
   line: 11
 }));
diff --git a/test/fixtures/SpreadElement/expected-presets-es2015.js b/test/fixtures/SpreadElement/expected-presets-es2015.js
new file mode 100644
index 0000000..902d47a
--- /dev/null
+++ b/test/fixtures/SpreadElement/expected-presets-es2015.js
@@ -0,0 +1,21 @@
+'use strict';
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+assert(assert._expr(assert._capt(hello.apply(undefined, _toConsumableArray(assert._capt(names, 'arguments/0/arguments/0/argument'))), 'arguments/0'), {
+  content: 'assert(hello(...names))',
+  filepath: 'test/fixtures/SpreadElement/fixture.js',
+  line: 3
+}));
+
+assert(assert._expr(assert._capt(assert._capt([assert._capt(head, 'arguments/0/object/elements/0')].concat(_toConsumableArray(assert._capt(tail, 'arguments/0/object/elements/1/argument'))), 'arguments/0/object').length, 'arguments/0'), {
+  content: 'assert([head, ...tail].length)',
+  filepath: 'test/fixtures/SpreadElement/fixture.js',
+  line: 5
+}));
+
+assert(assert._expr(assert._capt(f.apply(undefined, [assert._capt(head, 'arguments/0/arguments/0')].concat(_toConsumableArray(assert._capt(iter(), 'arguments/0/arguments/1/argument')), _toConsumableArray(assert._capt([assert._capt(foo, 'arguments/0/arguments/2/argument/elements/0'), assert._capt(bar, 'arguments/0/arguments/2/argument/elements/1')], 'arguments/0/arguments/2/argument')))), 'arguments/0'), {
+  content: 'assert(f(head, ...iter(), ...[foo, bar]))',
+  filepath: 'test/fixtures/SpreadElement/fixture.js',
+  line: 7
+}));
diff --git a/test/fixtures/SpreadElement/expected.js b/test/fixtures/SpreadElement/expected.js
index d4fab5f..7e25ffe 100644
--- a/test/fixtures/SpreadElement/expected.js
+++ b/test/fixtures/SpreadElement/expected.js
@@ -1,21 +1,19 @@
 'use strict';
 
-function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
-
-assert(assert._expr(assert._capt(hello.apply(undefined, _toConsumableArray(assert._capt(names, 'arguments/0/arguments/0/argument'))), 'arguments/0'), {
+assert(assert._expr(assert._capt(hello(...assert._capt(names, 'arguments/0/arguments/0/argument')), 'arguments/0'), {
   content: 'assert(hello(...names))',
   filepath: 'test/fixtures/SpreadElement/fixture.js',
   line: 3
 }));
 
-assert(assert._expr(assert._capt(assert._capt([assert._capt(head, 'arguments/0/object/elements/0')].concat(_toConsumableArray(assert._capt(tail, 'arguments/0/object/elements/1/argument'))), 'arguments/0/object').length, 'arguments/0'), {
-  content: 'assert([head,...tail].length)',
+assert(assert._expr(assert._capt(assert._capt([assert._capt(head, 'arguments/0/object/elements/0'), ...assert._capt(tail, 'arguments/0/object/elements/1/argument')], 'arguments/0/object').length, 'arguments/0'), {
+  content: 'assert([head, ...tail].length)',
   filepath: 'test/fixtures/SpreadElement/fixture.js',
   line: 5
 }));
 
-assert(assert._expr(assert._capt(f.apply(undefined, [assert._capt(head, 'arguments/0/arguments/0')].concat(_toConsumableArray(assert._capt(iter(), 'arguments/0/arguments/1/argument')), _toConsumableArray(assert._capt([assert._capt(foo, 'arguments/0/arguments/2/argument/elements/0'), assert._capt(bar, 'arguments/0/arguments/2/argument/elements/1')], 'arguments/0/arguments/2/argument')))), 'arguments/0'), {
-  content: 'assert(f(head, ...iter(), ...[foo,bar]))',
+assert(assert._expr(assert._capt(f(assert._capt(head, 'arguments/0/arguments/0'), ...assert._capt(iter(), 'arguments/0/arguments/1/argument'), ...assert._capt([assert._capt(foo, 'arguments/0/arguments/2/argument/elements/0'), assert._capt(bar, 'arguments/0/arguments/2/argument/elements/1')], 'arguments/0/arguments/2/argument')), 'arguments/0'), {
+  content: 'assert(f(head, ...iter(), ...[foo, bar]))',
   filepath: 'test/fixtures/SpreadElement/fixture.js',
   line: 7
 }));
diff --git a/test/fixtures/TaggedTemplateExpression/expected-presets-es2015.js b/test/fixtures/TaggedTemplateExpression/expected-presets-es2015.js
new file mode 100644
index 0000000..136392a
--- /dev/null
+++ b/test/fixtures/TaggedTemplateExpression/expected-presets-es2015.js
@@ -0,0 +1,25 @@
+'use strict';
+
+var _templateObject = _taggedTemplateLiteral(['a', ''], ['a', '']),
+    _templateObject2 = _taggedTemplateLiteral(['a', 'b', 'c', ''], ['a', 'b', 'c', '']),
+    _templateObject3 = _taggedTemplateLiteral(['driver ', ', navigator ', ''], ['driver ', ', navigator ', '']);
+
+function _taggedTemplateLiteral(strings, raw) { return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+assert(assert._expr(assert._capt(fn(_templateObject, 1), 'arguments/0'), {
+  content: 'assert(fn`a${ 1 }`)',
+  filepath: 'test/fixtures/TaggedTemplateExpression/fixture.js',
+  line: 3
+}));
+
+assert(assert._expr(assert._capt(fn(_templateObject2, assert._capt(foo, 'arguments/0/quasi/expressions/0'), assert._capt(bar, 'arguments/0/quasi/expressions/1'), assert._capt(baz, 'arguments/0/quasi/expressions/2')), 'arguments/0'), {
+  content: 'assert(fn`a${ foo }b${ bar }c${ baz }`)',
+  filepath: 'test/fixtures/TaggedTemplateExpression/fixture.js',
+  line: 5
+}));
+
+assert(assert._expr(assert._capt(fn(_templateObject3, assert._capt(assert._capt(bob, 'arguments/0/quasi/expressions/0/object').name, 'arguments/0/quasi/expressions/0'), assert._capt(assert._capt(alice, 'arguments/0/quasi/expressions/1/callee/object').getName(), 'arguments/0/quasi/expressions/1')), 'arguments/0'), {
+  content: 'assert(fn`driver ${ bob.name }, navigator ${ alice.getName() }`)',
+  filepath: 'test/fixtures/TaggedTemplateExpression/fixture.js',
+  line: 7
+}));
diff --git a/test/fixtures/TaggedTemplateExpression/expected.js b/test/fixtures/TaggedTemplateExpression/expected.js
index 136392a..3fcc1f3 100644
--- a/test/fixtures/TaggedTemplateExpression/expected.js
+++ b/test/fixtures/TaggedTemplateExpression/expected.js
@@ -1,24 +1,18 @@
 'use strict';
 
-var _templateObject = _taggedTemplateLiteral(['a', ''], ['a', '']),
-    _templateObject2 = _taggedTemplateLiteral(['a', 'b', 'c', ''], ['a', 'b', 'c', '']),
-    _templateObject3 = _taggedTemplateLiteral(['driver ', ', navigator ', ''], ['driver ', ', navigator ', '']);
-
-function _taggedTemplateLiteral(strings, raw) { return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
-
-assert(assert._expr(assert._capt(fn(_templateObject, 1), 'arguments/0'), {
+assert(assert._expr(assert._capt(fn`a${ 1 }`, 'arguments/0'), {
   content: 'assert(fn`a${ 1 }`)',
   filepath: 'test/fixtures/TaggedTemplateExpression/fixture.js',
   line: 3
 }));
 
-assert(assert._expr(assert._capt(fn(_templateObject2, assert._capt(foo, 'arguments/0/quasi/expressions/0'), assert._capt(bar, 'arguments/0/quasi/expressions/1'), assert._capt(baz, 'arguments/0/quasi/expressions/2')), 'arguments/0'), {
+assert(assert._expr(assert._capt(fn`a${ assert._capt(foo, 'arguments/0/quasi/expressions/0') }b${ assert._capt(bar, 'arguments/0/quasi/expressions/1') }c${ assert._capt(baz, 'arguments/0/quasi/expressions/2') }`, 'arguments/0'), {
   content: 'assert(fn`a${ foo }b${ bar }c${ baz }`)',
   filepath: 'test/fixtures/TaggedTemplateExpression/fixture.js',
   line: 5
 }));
 
-assert(assert._expr(assert._capt(fn(_templateObject3, assert._capt(assert._capt(bob, 'arguments/0/quasi/expressions/0/object').name, 'arguments/0/quasi/expressions/0'), assert._capt(assert._capt(alice, 'arguments/0/quasi/expressions/1/callee/object').getName(), 'arguments/0/quasi/expressions/1')), 'arguments/0'), {
+assert(assert._expr(assert._capt(fn`driver ${ assert._capt(assert._capt(bob, 'arguments/0/quasi/expressions/0/object').name, 'arguments/0/quasi/expressions/0') }, navigator ${ assert._capt(assert._capt(alice, 'arguments/0/quasi/expressions/1/callee/object').getName(), 'arguments/0/quasi/expressions/1') }`, 'arguments/0'), {
   content: 'assert(fn`driver ${ bob.name }, navigator ${ alice.getName() }`)',
   filepath: 'test/fixtures/TaggedTemplateExpression/fixture.js',
   line: 7
diff --git a/test/fixtures/TemplateLiteral/expected-presets-es2015.js b/test/fixtures/TemplateLiteral/expected-presets-es2015.js
new file mode 100644
index 0000000..689b757
--- /dev/null
+++ b/test/fixtures/TemplateLiteral/expected-presets-es2015.js
@@ -0,0 +1,19 @@
+'use strict';
+
+assert(assert._expr(assert._capt('Hello', 'arguments/0'), {
+  content: 'assert(`Hello`)',
+  filepath: 'test/fixtures/TemplateLiteral/fixture.js',
+  line: 3
+}));
+
+assert(assert._expr(assert._capt('Hello, ' + assert._capt(nickname, 'arguments/0/expressions/0'), 'arguments/0'), {
+  content: 'assert(`Hello, ${ nickname }`)',
+  filepath: 'test/fixtures/TemplateLiteral/fixture.js',
+  line: 5
+}));
+
+assert(assert._expr(assert._capt('Hello, ' + assert._capt(assert._capt(user, 'arguments/0/expressions/0/object').nickname, 'arguments/0/expressions/0'), 'arguments/0'), {
+  content: 'assert(`Hello, ${ user.nickname }`)',
+  filepath: 'test/fixtures/TemplateLiteral/fixture.js',
+  line: 7
+}));
diff --git a/test/fixtures/TemplateLiteral/expected.js b/test/fixtures/TemplateLiteral/expected.js
index 689b757..dadd135 100644
--- a/test/fixtures/TemplateLiteral/expected.js
+++ b/test/fixtures/TemplateLiteral/expected.js
@@ -1,18 +1,18 @@
 'use strict';
 
-assert(assert._expr(assert._capt('Hello', 'arguments/0'), {
+assert(assert._expr(assert._capt(`Hello`, 'arguments/0'), {
   content: 'assert(`Hello`)',
   filepath: 'test/fixtures/TemplateLiteral/fixture.js',
   line: 3
 }));
 
-assert(assert._expr(assert._capt('Hello, ' + assert._capt(nickname, 'arguments/0/expressions/0'), 'arguments/0'), {
+assert(assert._expr(assert._capt(`Hello, ${ assert._capt(nickname, 'arguments/0/expressions/0') }`, 'arguments/0'), {
   content: 'assert(`Hello, ${ nickname }`)',
   filepath: 'test/fixtures/TemplateLiteral/fixture.js',
   line: 5
 }));
 
-assert(assert._expr(assert._capt('Hello, ' + assert._capt(assert._capt(user, 'arguments/0/expressions/0/object').nickname, 'arguments/0/expressions/0'), 'arguments/0'), {
+assert(assert._expr(assert._capt(`Hello, ${ assert._capt(assert._capt(user, 'arguments/0/expressions/0/object').nickname, 'arguments/0/expressions/0') }`, 'arguments/0'), {
   content: 'assert(`Hello, ${ user.nickname }`)',
   filepath: 'test/fixtures/TemplateLiteral/fixture.js',
   line: 7
diff --git a/test/fixtures/UnaryExpression/expected-presets-es2015.js b/test/fixtures/UnaryExpression/expected-presets-es2015.js
new file mode 100644
index 0000000..2748fd9
--- /dev/null
+++ b/test/fixtures/UnaryExpression/expected-presets-es2015.js
@@ -0,0 +1,49 @@
+'use strict';
+
+function _typeof(obj) { return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj; }
+
+assert(assert._expr(assert._capt(!assert._capt(truth, 'arguments/0/argument'), 'arguments/0'), {
+  content: 'assert(!truth)',
+  filepath: 'test/fixtures/UnaryExpression/fixture.js',
+  line: 3
+}));
+
+assert(assert._expr(assert._capt(!assert._capt(!assert._capt(some, 'arguments/0/argument/argument'), 'arguments/0/argument'), 'arguments/0'), {
+  content: 'assert(!!some)',
+  filepath: 'test/fixtures/UnaryExpression/fixture.js',
+  line: 5
+}));
+
+assert(assert._expr(assert._capt(!assert._capt(!assert._capt(assert._capt(foo, 'arguments/0/argument/argument/object').bar, 'arguments/0/argument/argument'), 'arguments/0/argument'), 'arguments/0'), {
+  content: 'assert(!!foo.bar)',
+  filepath: 'test/fixtures/UnaryExpression/fixture.js',
+  line: 7
+}));
+
+assert(assert._expr(assert._capt(delete assert._capt(assert._capt(foo, 'arguments/0/argument/object').bar, 'arguments/0/argument'), 'arguments/0'), {
+  content: 'assert(delete foo.bar)',
+  filepath: 'test/fixtures/UnaryExpression/fixture.js',
+  line: 9
+}));
+
+assert(assert._expr(assert._capt(assert._capt(typeof foo === 'undefined' ? 'undefined' : _typeof(foo), 'arguments/0/left') !== 'undefined', 'arguments/0'), {
+  content: 'assert(typeof foo !== \'undefined\')',
+  filepath: 'test/fixtures/UnaryExpression/fixture.js',
+  line: 11
+}));
+
+assert(assert._expr(assert._capt(assert._capt(_typeof(assert._capt(assert._capt(foo, 'arguments/0/left/argument/object').bar, 'arguments/0/left/argument')), 'arguments/0/left') !== 'undefined', 'arguments/0'), {
+  content: 'assert(typeof foo.bar !== \'undefined\')',
+  filepath: 'test/fixtures/UnaryExpression/fixture.js',
+  line: 13
+}));
+
+assert.strictEqual(assert._expr(assert._capt(typeof foo === 'undefined' ? 'undefined' : _typeof(foo), 'arguments/0'), {
+  content: 'assert.strictEqual(typeof foo, typeof bar)',
+  filepath: 'test/fixtures/UnaryExpression/fixture.js',
+  line: 15
+}), assert._expr(assert._capt(typeof bar === 'undefined' ? 'undefined' : _typeof(bar), 'arguments/1'), {
+  content: 'assert.strictEqual(typeof foo, typeof bar)',
+  filepath: 'test/fixtures/UnaryExpression/fixture.js',
+  line: 15
+}));
diff --git a/test/fixtures/YieldExpression/expected-presets-es2015.js b/test/fixtures/YieldExpression/expected-presets-es2015.js
new file mode 100644
index 0000000..c5f0fe3
--- /dev/null
+++ b/test/fixtures/YieldExpression/expected-presets-es2015.js
@@ -0,0 +1,38 @@
+'use strict';
+
+var _marked = [gen].map(regeneratorRuntime.mark);
+
+function gen(a) {
+  return regeneratorRuntime.wrap(function gen$(_context) {
+    while (1) switch (_context.prev = _context.next) {
+      case 0:
+        _context.t0 = assert;
+        _context.t1 = assert;
+        _context.t2 = assert;
+        _context.next = 5;
+        return a;
+
+      case 5:
+        _context.t3 = _context.sent;
+        _context.t4 = _context.t2._capt.call(_context.t2, _context.t3, 'arguments/0/left');
+        _context.t5 = _context.t4 === 3;
+        _context.t6 = _context.t1._capt.call(_context.t1, _context.t5, 'arguments/0');
+        _context.t7 = {
+          content: 'assert((yield a) === 3)',
+          filepath: 'test/fixtures/YieldExpression/fixture.js',
+          line: 4,
+          generator: true
+        };
+        _context.t8 = _context.t0._expr.call(_context.t0, _context.t6, _context.t7);
+        assert(_context.t8);
+
+      case 12:
+      case 'end':
+        return _context.stop();
+    }
+  }, _marked[0], this);
+}
+
+// function notGen(a){
+//   assert((yield (a)) === 3);
+// }
diff --git a/test/fixtures/YieldExpression/expected.js b/test/fixtures/YieldExpression/expected.js
index 341664f..2a6d967 100644
--- a/test/fixtures/YieldExpression/expected.js
+++ b/test/fixtures/YieldExpression/expected.js
@@ -1,41 +1,14 @@
 'use strict';
 
-var marked0$0 = [gen].map(regeneratorRuntime.mark);
-function gen(a) {
-  return regeneratorRuntime.wrap(function gen$(context$1$0) {
-    while (1) switch (context$1$0.prev = context$1$0.next) {
-      case 0:
-        context$1$0.t0 = assert;
-        context$1$0.t1 = assert;
-        context$1$0.t2 = assert;
-        context$1$0.next = 5;
-        return a;
-
-      case 5:
-        context$1$0.t3 = context$1$0.sent;
-        context$1$0.t4 = context$1$0.t2._capt.call(context$1$0.t2, context$1$0.t3, 'arguments/0/left');
-        context$1$0.t5 = context$1$0.t4 === 3;
-        context$1$0.t6 = context$1$0.t1._capt.call(context$1$0.t1, context$1$0.t5, 'arguments/0');
-        context$1$0.t7 = {
-          content: 'assert((yield a) === 3)',
-          filepath: 'test/fixtures/YieldExpression/fixture.js',
-          generator: true,
-          line: 4
-        };
-        context$1$0.t8 = context$1$0.t0._expr.call(context$1$0.t0, context$1$0.t6, context$1$0.t7);
-        assert(context$1$0.t8);
-
-      case 12:
-      case 'end':
-        return context$1$0.stop();
-    }
-  }, marked0$0[0], this);
-}
-
-function notGen(a) {
-  assert(assert._expr(assert._capt(assert._capt(yield(assert._capt(a, 'arguments/0/left/arguments/0')), 'arguments/0/left') === 3, 'arguments/0'), {
-    content: 'assert(yield(a) === 3)',
+function* gen(a) {
+  assert(assert._expr(assert._capt(assert._capt((yield a), 'arguments/0/left') === 3, 'arguments/0'), {
+    content: 'assert((yield a) === 3)',
     filepath: 'test/fixtures/YieldExpression/fixture.js',
-    line: 8
+    line: 4,
+    generator: true
   }));
 }
+
+// function notGen(a){
+//   assert((yield (a)) === 3);
+// }
diff --git a/test/fixtures/YieldExpression/fixture.js b/test/fixtures/YieldExpression/fixture.js
index 4102ff2..d57df18 100644
--- a/test/fixtures/YieldExpression/fixture.js
+++ b/test/fixtures/YieldExpression/fixture.js
@@ -4,6 +4,6 @@ function *gen(a){
   assert((yield (a)) === 3);
 }
 
-function notGen(a){
-  assert((yield (a)) === 3);
-}
+// function notGen(a){
+//   assert((yield (a)) === 3);
+// }
diff --git a/test/fixtures/inputSourceMap/expected.js b/test/fixtures/inputSourceMap/expected.js
index 5b08c08..a73d9f3 100644
--- a/test/fixtures/inputSourceMap/expected.js
+++ b/test/fixtures/inputSourceMap/expected.js
@@ -1,5 +1,3 @@
-"use strict";
-
 var Person, assert;
 
 assert = require('power-assert');
diff --git a/test/test.js b/test/test.js
index 2453637..b0fecf1 100644
--- a/test/test.js
+++ b/test/test.js
@@ -1,7 +1,7 @@
 var assert = require('assert');
 var fs = require('fs');
 var path = require('path');
-var babel = require('babel');
+var babel = require('babel-core');
 var extend = require('xtend');
 var createEspowerPlugin = require('../create');
 
@@ -45,7 +45,6 @@ describe('babel-plugin-espower', function () {
     testTransform('SpreadElement');
     testTransform('Property');
     testTransform('YieldExpression');
-    testTransform('AwaitExpression');
     testTransform('inputSourceMap', {
         plugins: [
             createEspowerPlugin(babel, {