diff --git a/packages/enzyme-adapter-react-13/src/ReactThirteenAdapter.js b/packages/enzyme-adapter-react-13/src/ReactThirteenAdapter.js
index 9fa723aa3..0d7a7e2db 100644
--- a/packages/enzyme-adapter-react-13/src/ReactThirteenAdapter.js
+++ b/packages/enzyme-adapter-react-13/src/ReactThirteenAdapter.js
@@ -6,6 +6,7 @@ import ReactContext from 'react/lib/ReactContext';
 import values from 'object.values';
 import { EnzymeAdapter } from 'enzyme';
 import {
+  displayNameOfNode,
   propFromEvent,
   withSetStateAllowed,
   assertDomAvailable,
@@ -249,6 +250,10 @@ class ReactThirteenAdapter extends EnzymeAdapter {
     return React.createElement(node.type, propsWithKeysAndRef(node));
   }
 
+  displayNameOfNode(node) {
+    return displayNameOfNode(node);
+  }
+
   elementToNode(element) {
     return elementToTree(element);
   }
@@ -261,6 +266,10 @@ class ReactThirteenAdapter extends EnzymeAdapter {
     return React.isValidElement(element);
   }
 
+  isValidElementType(object) {
+    return typeof object === 'string' || typeof object === 'function';
+  }
+
   createElement(...args) {
     return React.createElement(...args);
   }
diff --git a/packages/enzyme-adapter-react-14/src/ReactFourteenAdapter.js b/packages/enzyme-adapter-react-14/src/ReactFourteenAdapter.js
index 802f599bd..d87e25f19 100644
--- a/packages/enzyme-adapter-react-14/src/ReactFourteenAdapter.js
+++ b/packages/enzyme-adapter-react-14/src/ReactFourteenAdapter.js
@@ -5,9 +5,10 @@ import ReactDOMServer from 'react-dom/server';
 // eslint-disable-next-line import/no-unresolved, import/extensions
 import TestUtils from 'react-addons-test-utils';
 import values from 'object.values';
-import { isElement } from 'react-is';
+import { isElement, isValidElementType } from 'react-is';
 import { EnzymeAdapter } from 'enzyme';
 import {
+  displayNameOfNode,
   elementToTree,
   mapNativeEventNames,
   propFromEvent,
@@ -229,10 +230,18 @@ class ReactFourteenAdapter extends EnzymeAdapter {
     return ReactDOM.findDOMNode(node.instance);
   }
 
+  displayNameOfNode(node) {
+    return displayNameOfNode(node);
+  }
+
   isValidElement(element) {
     return isElement(element);
   }
 
+  isValidElementType(object) {
+    return isValidElementType(object);
+  }
+
   createElement(...args) {
     return React.createElement(...args);
   }
diff --git a/packages/enzyme-adapter-react-15.4/src/ReactFifteenFourAdapter.js b/packages/enzyme-adapter-react-15.4/src/ReactFifteenFourAdapter.js
index e539b3600..472932d36 100644
--- a/packages/enzyme-adapter-react-15.4/src/ReactFifteenFourAdapter.js
+++ b/packages/enzyme-adapter-react-15.4/src/ReactFifteenFourAdapter.js
@@ -5,9 +5,10 @@ import ReactDOMServer from 'react-dom/server';
 // eslint-disable-next-line import/no-unresolved, import/extensions
 import TestUtils from 'react-addons-test-utils';
 import values from 'object.values';
-import { isElement } from 'react-is';
+import { isElement, isValidElementType } from 'react-is';
 import { EnzymeAdapter } from 'enzyme';
 import {
+  displayNameOfNode,
   elementToTree,
   mapNativeEventNames,
   propFromEvent,
@@ -262,10 +263,18 @@ class ReactFifteenFourAdapter extends EnzymeAdapter {
     return ReactDOM.findDOMNode(node.instance);
   }
 
+  displayNameOfNode(node) {
+    return displayNameOfNode(node);
+  }
+
   isValidElement(element) {
     return isElement(element);
   }
 
+  isValidElementType(object) {
+    return isValidElementType(object);
+  }
+
   createElement(...args) {
     return React.createElement(...args);
   }
diff --git a/packages/enzyme-adapter-react-15/src/ReactFifteenAdapter.js b/packages/enzyme-adapter-react-15/src/ReactFifteenAdapter.js
index 057f28938..db557717f 100644
--- a/packages/enzyme-adapter-react-15/src/ReactFifteenAdapter.js
+++ b/packages/enzyme-adapter-react-15/src/ReactFifteenAdapter.js
@@ -7,9 +7,10 @@ import TestUtils from 'react-dom/test-utils';
 // eslint-disable-next-line import/no-unresolved, import/extensions
 import ShallowRenderer from 'react-test-renderer/shallow';
 import values from 'object.values';
-import { isElement } from 'react-is';
+import { isElement, isValidElementType } from 'react-is';
 import { EnzymeAdapter } from 'enzyme';
 import {
+  displayNameOfNode,
   elementToTree,
   mapNativeEventNames,
   propFromEvent,
@@ -262,10 +263,18 @@ class ReactFifteenAdapter extends EnzymeAdapter {
     return ReactDOM.findDOMNode(node.instance);
   }
 
+  displayNameOfNode(node) {
+    return displayNameOfNode(node);
+  }
+
   isValidElement(element) {
     return isElement(element);
   }
 
+  isValidElementType(object) {
+    return isValidElementType(object);
+  }
+
   createElement(...args) {
     return React.createElement(...args);
   }
diff --git a/packages/enzyme-adapter-react-16/package.json b/packages/enzyme-adapter-react-16/package.json
index 55117fcfe..58d20ad76 100644
--- a/packages/enzyme-adapter-react-16/package.json
+++ b/packages/enzyme-adapter-react-16/package.json
@@ -35,6 +35,7 @@
   "license": "MIT",
   "dependencies": {
     "enzyme-adapter-utils": "^1.3.0",
+    "function.prototype.name": "^1.0.3",
     "object.assign": "^4.1.0",
     "object.values": "^1.0.4",
     "prop-types": "^15.6.0",
diff --git a/packages/enzyme-adapter-react-16/src/ReactSixteenAdapter.js b/packages/enzyme-adapter-react-16/src/ReactSixteenAdapter.js
index 2883d98c4..6b9576517 100644
--- a/packages/enzyme-adapter-react-16/src/ReactSixteenAdapter.js
+++ b/packages/enzyme-adapter-react-16/src/ReactSixteenAdapter.js
@@ -1,4 +1,5 @@
 /* eslint no-use-before-define: 0 */
+import functionName from 'function.prototype.name';
 import React from 'react';
 import ReactDOM from 'react-dom';
 // eslint-disable-next-line import/no-unresolved
@@ -7,9 +8,21 @@ import ReactDOMServer from 'react-dom/server';
 import ShallowRenderer from 'react-test-renderer/shallow';
 // eslint-disable-next-line import/no-unresolved
 import TestUtils from 'react-dom/test-utils';
-import { isElement } from 'react-is';
+import {
+  isElement,
+  isValidElementType,
+  AsyncMode,
+  Fragment,
+  ContextConsumer,
+  ContextProvider,
+  StrictMode,
+  ForwardRef,
+  Profiler,
+  Portal,
+} from 'react-is';
 import { EnzymeAdapter } from 'enzyme';
 import {
+  displayNameOfNode,
   elementToTree,
   nodeTypeFromType,
   mapNativeEventNames,
@@ -25,14 +38,14 @@ import { findCurrentFiberUsingSlowPath } from 'react-reconciler/reflection';
 
 const HostRoot = 3;
 const ClassComponent = 2;
-const Fragment = 10;
+const FragmentType = 10;
 const FunctionalComponent = 1;
 const HostPortal = 4;
 const HostComponent = 5;
 const HostText = 6;
 const Mode = 11;
-const ContextConsumer = 12;
-const ContextProvider = 13;
+const ContextConsumerType = 12;
+const ContextProviderType = 13;
 
 function nodeAndSiblingsArray(nodeWithSibling) {
   const array = [];
@@ -113,10 +126,10 @@ function toTree(vnode) {
     }
     case HostText: // 6
       return node.memoizedProps;
-    case Fragment: // 10
+    case FragmentType: // 10
     case Mode: // 11
-    case ContextProvider: // 13
-    case ContextConsumer: // 12
+    case ContextProviderType: // 13
+    case ContextConsumerType: // 12
       return childrenToTree(node.child);
     default:
       throw new Error(`Enzyme Internal Error: unknown node with tag ${node.tag}`);
@@ -337,10 +350,41 @@ class ReactSixteenAdapter extends EnzymeAdapter {
     return nodeToHostNode(node);
   }
 
+  displayNameOfNode(node) {
+    if (!node) return null;
+    const { type, $$typeof } = node;
+
+    switch (type || $$typeof) {
+      case AsyncMode: return 'AsyncMode';
+      case Fragment: return 'Fragment';
+      case StrictMode: return 'StrictMode';
+      case Profiler: return 'Profiler';
+      case Portal: return 'Portal';
+
+      default: {
+        const $$typeofType = type && type.$$typeof;
+
+        switch ($$typeofType) {
+          case ContextConsumer: return 'ContextConsumer';
+          case ContextProvider: return 'ContextProvider';
+          case ForwardRef: {
+            const name = type.render.displayName || functionName(type.render);
+            return name ? `ForwardRef(${name})` : 'ForwardRef';
+          }
+          default: return displayNameOfNode(node);
+        }
+      }
+    }
+  }
+
   isValidElement(element) {
     return isElement(element);
   }
 
+  isValidElementType(object) {
+    return isValidElementType(object);
+  }
+
   createElement(...args) {
     return React.createElement(...args);
   }
diff --git a/packages/enzyme-adapter-utils/package.json b/packages/enzyme-adapter-utils/package.json
index e200fee85..3860c2dc8 100644
--- a/packages/enzyme-adapter-utils/package.json
+++ b/packages/enzyme-adapter-utils/package.json
@@ -34,6 +34,7 @@
   "author": "Leland Richardson <leland.richardson@airbnb.com>",
   "license": "MIT",
   "dependencies": {
+    "function.prototype.name": "^1.0.3",
     "object.assign": "^4.1.0",
     "prop-types": "^15.6.0"
   },
diff --git a/packages/enzyme-adapter-utils/src/Utils.js b/packages/enzyme-adapter-utils/src/Utils.js
index cbd1c8348..6f3f77a72 100644
--- a/packages/enzyme-adapter-utils/src/Utils.js
+++ b/packages/enzyme-adapter-utils/src/Utils.js
@@ -1,3 +1,4 @@
+import functionName from 'function.prototype.name';
 import createMountWrapper from './createMountWrapper';
 import createRenderWrapper from './createRenderWrapper';
 
@@ -86,6 +87,16 @@ export function assertDomAvailable(feature) {
   }
 }
 
+export function displayNameOfNode(node) {
+  if (!node) return null;
+
+  const { type } = node;
+
+  if (!type) return null;
+
+  return type.displayName || (typeof type === 'function' ? functionName(type) : type.name || type);
+}
+
 export function nodeTypeFromType(type) {
   if (typeof type === 'string') {
     return 'host';
diff --git a/packages/enzyme-test-suite/package.json b/packages/enzyme-test-suite/package.json
index e05d1422c..1c20f200e 100644
--- a/packages/enzyme-test-suite/package.json
+++ b/packages/enzyme-test-suite/package.json
@@ -33,6 +33,7 @@
     "enzyme": "^3.3.0",
     "enzyme-adapter-utils": "^1.3.0",
     "jsdom": "^6.5.1",
+    "mocha-wrap": "^2.1.2",
     "object.assign": "^4.1.0",
     "prop-types": "^15.6.0",
     "semver": "^5.5.0",
diff --git a/packages/enzyme-test-suite/test/Adapter-spec.jsx b/packages/enzyme-test-suite/test/Adapter-spec.jsx
index c022b4de2..dacd6f051 100644
--- a/packages/enzyme-test-suite/test/Adapter-spec.jsx
+++ b/packages/enzyme-test-suite/test/Adapter-spec.jsx
@@ -6,7 +6,16 @@ import { configure, shallow } from 'enzyme';
 
 import './_helpers/setupAdapters';
 import Adapter from './_helpers/adapter';
-import { renderToString } from './_helpers/react-compat';
+import {
+  renderToString,
+  createContext,
+  createPortal,
+  forwardRef,
+  Fragment,
+  StrictMode,
+  AsyncMode,
+  Profiler,
+} from './_helpers/react-compat';
 import { is } from './_helpers/version';
 import { itIf, describeWithDOM } from './_helpers';
 
@@ -801,4 +810,100 @@ describe('Adapter', () => {
       },
     }));
   });
+
+  describe('determines valid element types', () => {
+    itIf(is('> 0.13'), 'supports stateless function components', () => {
+      const SFC = () => null;
+
+      expect(adapter.isValidElementType(SFC)).to.equal(true);
+    });
+
+    it('supports custom components', () => {
+      class Component extends React.Component {
+        render() { return null; }
+      }
+
+      expect(adapter.isValidElementType(Component)).to.equal(true);
+    });
+
+    it('supports HTML elements', () => {
+      expect(adapter.isValidElementType('div')).to.equal(true);
+    });
+
+    itIf(is('>= 16'), 'supports Portals', () => {
+      expect(adapter.isValidElementType(createPortal(<div />, { nodeType: 1 }))).to.equal(false);
+    });
+
+    itIf(is('>= 16.3'), 'supports Context', () => {
+      const Context = createContext({ });
+      expect(adapter.isValidElementType(Context.Consumer)).to.equal(true);
+      expect(adapter.isValidElementType(Context.Provider)).to.equal(true);
+    });
+
+    itIf(is('>= 16.3'), 'supports forward refs', () => {
+      expect(adapter.isValidElementType(forwardRef(() => null))).to.equal(true);
+    });
+  });
+
+  describe('provides node displayNames', () => {
+    const getDisplayName = el => adapter.displayNameOfNode(adapter.elementToNode(el));
+
+    itIf(is('> 0.13'), 'supports stateless function components', () => {
+      const SFC = () => null;
+
+      expect(getDisplayName(<SFC />)).to.equal('SFC');
+    });
+
+    it('supports custom components', () => {
+      class Component extends React.Component {
+        render() { return null; }
+      }
+      class Something extends React.Component {
+        render() { return null; }
+      }
+      Something.displayName = 'MyComponent';
+
+      expect(getDisplayName(<Component />)).to.equal('Component');
+      expect(getDisplayName(<Something />)).to.equal('MyComponent');
+    });
+
+    it('supports HTML elements', () => {
+      expect(getDisplayName(<div />)).to.equal('div');
+    });
+
+    itIf(is('>= 16.2'), 'supports Fragments', () => {
+      expect(getDisplayName(<Fragment />)).to.equal('Fragment');
+    });
+
+    itIf(is('>= 16'), 'supports Portals', () => {
+      expect(getDisplayName(createPortal(<div />, { nodeType: 1 }))).to.equal('Portal');
+    });
+
+    itIf(is('>= 16.3'), 'supports Context', () => {
+      const Context = createContext({});
+      expect(getDisplayName(<Context.Consumer />)).to.equal('ContextConsumer');
+      expect(getDisplayName(<Context.Provider />)).to.equal('ContextProvider');
+    });
+
+    itIf(is('>= 16.3'), 'supports forward refs', () => {
+      const ForwaredRef = forwardRef(() => null);
+      // eslint-disable-next-line prefer-arrow-callback
+      const NamedForwardedRef = forwardRef(function Named() { return null; });
+
+      expect(getDisplayName(<ForwaredRef />)).to.equal('ForwardRef');
+      expect(getDisplayName(<NamedForwardedRef />)).to.equal('ForwardRef(Named)');
+    });
+
+    itIf(is('>= 16.3'), 'supports StrictMode', () => {
+      expect(getDisplayName(<StrictMode />)).to.equal('StrictMode');
+    });
+
+    itIf(is('>= 16.3'), 'supports AsyncMode', () => {
+      expect(getDisplayName(<AsyncMode />)).to.equal('AsyncMode');
+    });
+
+    itIf(is('>= 16.4'), 'supports Profiler', () => {
+      expect(getDisplayName(<Profiler />)).to.equal('Profiler');
+    });
+  });
 });
diff --git a/packages/enzyme-test-suite/test/Debug-spec.jsx b/packages/enzyme-test-suite/test/Debug-spec.jsx
index d5c4498f1..5de2c84a6 100644
--- a/packages/enzyme-test-suite/test/Debug-spec.jsx
+++ b/packages/enzyme-test-suite/test/Debug-spec.jsx
@@ -1,5 +1,8 @@
 import { expect } from 'chai';
 import React from 'react';
+import wrap from 'mocha-wrap';
+import sinon from 'sinon';
+
 import { mount, shallow } from 'enzyme';
 import { get } from 'enzyme/build/configuration';
 import {
@@ -23,30 +26,56 @@ const { adapter } = get();
 const debugElement = element => debugNode(adapter.elementToNode(element));
 
 describe('debug', () => {
-  describe('typeName(node)', () => {
-    it('returns `.type` when not a function', () => {
-      const type = {};
-      expect(typeName({ type })).to.equal(type);
-    });
-
-    describe('when `.type` is a function', () => {
-      it('returns the function’s name', () => {
-        function Foo() {}
-        expect(typeName({ type: Foo })).to.equal('Foo');
+  wrap()
+    .withOverride(() => adapter, 'displayNameOfNode', () => undefined)
+    .describe('typeName(node)', () => {
+      it('returns `.type` when not a function', () => {
+        const type = {};
+        expect(typeName({ type })).to.equal(type);
       });
 
-      it('returns the function’s `.displayName` when present', () => {
-        function Foo() {}
-        Foo.displayName = 'Bar';
-        expect(typeName({ type: Foo })).to.equal('Bar');
+      describe('when `.type` is a function', () => {
+        it('returns the function’s name', () => {
+          function Foo() {}
+          expect(typeName({ type: Foo })).to.equal('Foo');
+        });
+
+        it('returns the function’s `.displayName` when present', () => {
+          function Foo() {}
+          Foo.displayName = 'Bar';
+          expect(typeName({ type: Foo })).to.equal('Bar');
+        });
+
+        it('returns "Component" when the function is anonymous', () => {
+          const anon = Object(() => {});
+          expect(typeName({ type: anon })).to.equal('Component');
+        });
       });
 
-      it('returns "Component" when the function is anonymous', () => {
-        const anon = Object(() => {});
-        expect(typeName({ type: anon })).to.equal('Component');
-      });
+      wrap()
+        .withOverride(() => adapter, 'displayNameOfNode', () => sinon.stub())
+        .describe('when the adapter has a `displayNameOfNode` function', () => {
+          it('calls it, and returns its return value', () => {
+            const stub = adapter.displayNameOfNode;
+            const sentinel = {};
+            stub.returns(sentinel);
+
+            const node = {};
+            expect(typeName(node)).to.equal(sentinel);
+
+            expect(stub).to.have.property('callCount', 1);
+            const { args } = stub.firstCall;
+            expect(args).to.eql([node]);
+          });
+
+          it('returns "Component" when `adapter.displayNameOfNode` returns something falsy', () => {
+            const stub = adapter.displayNameOfNode;
+            stub.returns('');
+
+            expect(typeName()).to.equal('Component');
+          });
+        });
     });
-  });
 
   describe('spaces(n)', () => {
     it('should return n spaces', () => {
diff --git a/packages/enzyme-test-suite/test/ReactWrapper-spec.jsx b/packages/enzyme-test-suite/test/ReactWrapper-spec.jsx
index 3998d91f9..d902bd494 100644
--- a/packages/enzyme-test-suite/test/ReactWrapper-spec.jsx
+++ b/packages/enzyme-test-suite/test/ReactWrapper-spec.jsx
@@ -3,12 +3,17 @@ import React from 'react';
 import PropTypes from 'prop-types';
 import { expect } from 'chai';
 import sinon from 'sinon';
+import wrap from 'mocha-wrap';
 import {
   mount,
   render,
   ReactWrapper,
 } from 'enzyme';
-import { ITERATOR_SYMBOL, sym } from 'enzyme/build/Utils';
+import {
+  ITERATOR_SYMBOL,
+  sym,
+  getAdapter,
+} from 'enzyme/build/Utils';
 
 import './_helpers/setupAdapters';
 import { createClass, createContext, createPortal } from './_helpers/react-compat';
@@ -431,508 +436,528 @@ describeWithDOM('mount', () => {
     });
   });
 
-  describe('.find(selector)', () => {
-    it('should find an element based on a class name', () => {
-      const wrapper = mount((
-        <div>
-          <input className="foo" />
-        </div>
-      ));
-      expect(wrapper.find('.foo').type()).to.equal('input');
-    });
-
-    it('should find an SVG element based on a class name', () => {
-      const wrapper = mount((
-        <div>
-          <svg className="foo" />
-        </div>
-      ));
-      expect(wrapper.find('.foo').type()).to.equal('svg');
-    });
-
-    it('should find an element based on a tag name', () => {
-      const wrapper = mount((
-        <div>
-          <input className="foo" />
-        </div>
-      ));
-      expect(wrapper.find('input').props().className).to.equal('foo');
-    });
-
-    it('should find an element based on a tag name and class name', () => {
-      const wrapper = mount((
-        <div>
-          <input className="foo" />
-          <div className="foo" />
-        </div>
-      ));
-      expect(wrapper.find('input.foo')).to.have.lengthOf(1);
-    });
-
-    it('should work on non-single nodes', () => {
-      const wrapper = mount((
-        <div className="a">
-          <div className="b">
-            <div className="c">Text</div>
-            <div className="c">Text</div>
-            <div className="c">Text</div>
-          </div>
-          <div className="b">
-            <div className="c">Text</div>
-            <div className="c">Text</div>
-            <div className="c">Text</div>
+  wrap()
+    .withOverride(() => getAdapter(), 'isValidElementType', () => undefined)
+    .describe('.find(selector)', () => {
+      it('should find an element based on a class name', () => {
+        const wrapper = mount((
+          <div>
+            <input className="foo" />
           </div>
-        </div>
-      ));
-      expect(wrapper.find('.a')).to.have.lengthOf(1);
-      expect(wrapper.find('.b')).to.have.lengthOf(2);
-      expect(wrapper.find('.b').find('.c')).to.have.lengthOf(6);
-    });
+        ));
+        expect(wrapper.find('.foo').type()).to.equal('input');
+      });
 
+      it('should find an SVG element based on a class name', () => {
+        const wrapper = mount((
+          <div>
+            <svg className="foo" />
+          </div>
+        ));
+        expect(wrapper.find('.foo').type()).to.equal('svg');
+      });
 
-    it('should find an element based on a tag name and id', () => {
-      const wrapper = mount((
-        <div>
-          <input id="foo" />
-        </div>
-      ));
-      expect(wrapper.find('input#foo')).to.have.lengthOf(1);
-    });
+      it('should find an element based on a tag name', () => {
+        const wrapper = mount((
+          <div>
+            <input className="foo" />
+          </div>
+        ));
+        expect(wrapper.find('input').props().className).to.equal('foo');
+      });
 
-    it('should find an element based on a tag name, id, and class name', () => {
-      const wrapper = mount((
-        <div>
-          <input id="foo" className="bar" />
-        </div>
-      ));
-      expect(wrapper.find('input#foo.bar')).to.have.lengthOf(1);
-    });
+      it('should find an element based on a tag name and class name', () => {
+        const wrapper = mount((
+          <div>
+            <input className="foo" />
+            <div className="foo" />
+          </div>
+        ));
+        expect(wrapper.find('input.foo')).to.have.lengthOf(1);
+      });
 
-    it('should find a component based on a constructor', () => {
-      class Foo extends React.Component {
-        render() { return <div />; }
-      }
-      const wrapper = mount((
-        <div>
-          <Foo className="foo" />
-        </div>
-      ));
-      expect(wrapper.find(Foo).type()).to.equal(Foo);
-    });
+      it('should work on non-single nodes', () => {
+        const wrapper = mount((
+          <div className="a">
+            <div className="b">
+              <div className="c">Text</div>
+              <div className="c">Text</div>
+              <div className="c">Text</div>
+            </div>
+            <div className="b">
+              <div className="c">Text</div>
+              <div className="c">Text</div>
+              <div className="c">Text</div>
+            </div>
+          </div>
+        ));
+        expect(wrapper.find('.a')).to.have.lengthOf(1);
+        expect(wrapper.find('.b')).to.have.lengthOf(2);
+        expect(wrapper.find('.b').find('.c')).to.have.lengthOf(6);
+      });
 
-    it('should find a component based on a component displayName', () => {
-      class Foo extends React.Component {
-        render() { return <div />; }
-      }
-      const wrapper = mount((
-        <div>
-          <Foo className="foo" />
-        </div>
-      ));
-      expect(wrapper.find('Foo').type()).to.equal(Foo);
-    });
 
-    describeIf(is('> 0.13'), 'stateless components', () => {
-      it('should find a stateless component based on a component displayName', () => {
-        const Foo = () => <div />;
+      it('should find an element based on a tag name and id', () => {
         const wrapper = mount((
           <div>
-            <Foo className="foo" />
+            <input id="foo" />
           </div>
         ));
-        expect(wrapper.find('Foo').type()).to.equal(Foo);
+        expect(wrapper.find('input#foo')).to.have.lengthOf(1);
       });
 
-      it('should find a stateless component based on a component displayName if rendered by function', () => {
-        const Foo = () => <div />;
-        const renderStatelessComponent = () => <Foo className="foo" />;
+      it('should find an element based on a tag name, id, and class name', () => {
         const wrapper = mount((
           <div>
-            {renderStatelessComponent()}
+            <input id="foo" className="bar" />
           </div>
         ));
-        expect(wrapper.find('Foo').type()).to.equal(Foo);
+        expect(wrapper.find('input#foo.bar')).to.have.lengthOf(1);
       });
-    });
-
-    it('should find component based on a react prop', () => {
-      const wrapper = mount((
-        <div>
-          <span htmlFor="foo" />
-          <div htmlFor="bar" />
-        </div>
-      ));
-
-      expect(wrapper.find('[htmlFor="foo"]')).to.have.lengthOf(1);
-      expect(wrapper.find('[htmlFor]')).to.have.lengthOf(2);
-    });
-
-    it('should error sensibly if any of the search props are undefined', () => {
-      const wrapper = mount((
-        <div>
-          <input type={undefined} />
-        </div>
-      ));
 
-      expect(() => wrapper.find({ type: undefined })).to.throw(
-        TypeError,
-        'Enzyme::Props can’t have `undefined` values. Try using ‘findWhere()’ instead.',
-      );
-    });
+      it('should find a component based on a constructor', () => {
+        class Foo extends React.Component {
+          render() { return <div />; }
+        }
+        const wrapper = mount((
+          <div>
+            <Foo className="foo" />
+          </div>
+        ));
+        expect(wrapper.find(Foo).type()).to.equal(Foo);
+      });
 
-    it('should compound tag and prop selector', () => {
-      const wrapper = mount((
-        <div>
-          <span htmlFor="foo" />
-        </div>
-      ));
+      wrap()
+        .withOverride(() => getAdapter(), 'isValidElementType', () => () => false)
+        .it('throws when an adapter’s `isValidElementType` lies', () => {
+          class Foo extends React.Component {
+            render() { return <div />; }
+          }
+          const wrapper = mount((
+            <div>
+              <Foo className="foo" />
+            </div>
+          ));
 
-      expect(wrapper.find('span[htmlFor="foo"]')).to.have.lengthOf(1);
-      expect(wrapper.find('span[htmlFor]')).to.have.lengthOf(1);
-    });
+          expect(() => wrapper.find(Foo)).to.throw(
+            TypeError,
+            'Enzyme::Selector expects a string, object, or valid element type (Component Constructor)',
+          );
+        });
 
-    it('works with an adjacent sibling selector', () => {
-      const a = 'some';
-      const b = 'text';
-      const wrapper = mount((
-        <div>
-          <div className="row">
-            {a}
-            {b}
-          </div>
-          <div className="row">
-            {a}
-            {b}
+      it('should find a component based on a component displayName', () => {
+        class Foo extends React.Component {
+          render() { return <div />; }
+        }
+        const wrapper = mount((
+          <div>
+            <Foo className="foo" />
           </div>
-        </div>
-      ));
-      expect(wrapper.find('.row')).to.have.lengthOf(2);
-      expect(wrapper.find('.row + .row')).to.have.lengthOf(1);
-    });
-
-    it('should throw for non-numeric attribute values without quotes', () => {
-      const wrapper = mount((
-        <div>
-          <input type="text" />
-          <input type="hidden" />
-          <input type="text" />
-        </div>
-      ));
-      expect(() => wrapper.find('[type=text]')).to.throw(
-        Error,
-        'Failed to parse selector: [type=text]',
-      );
-      expect(() => wrapper.find('[type=hidden]')).to.throw(
-        Error,
-        'Failed to parse selector: [type=hidden]',
-      );
-      expect(() => wrapper.find('[type="text"]')).to.not.throw(
-        Error,
-        'Failed to parse selector: [type="text"]',
-      );
-    });
+        ));
+        expect(wrapper.find('Foo').type()).to.equal(Foo);
+      });
 
-    it('should support data prop selectors', () => {
-      const wrapper = mount((
-        <div>
-          <span data-foo="bar" />
-          <span data-foo-123="bar2" />
-          <span data-123-foo="bar3" />
-          <span data-foo_bar="bar4" />
-        </div>
-      ));
+      describeIf(is('> 0.13'), 'stateless components', () => {
+        it('should find a stateless component based on a component displayName', () => {
+          const Foo = () => <div />;
+          const wrapper = mount((
+            <div>
+              <Foo className="foo" />
+            </div>
+          ));
+          expect(wrapper.find('Foo').type()).to.equal(Foo);
+        });
 
-      expect(wrapper.find('[data-foo="bar"]')).to.have.lengthOf(1);
-      expect(wrapper.find('[data-foo]')).to.have.lengthOf(1);
+        it('should find a stateless component based on a component displayName if rendered by function', () => {
+          const Foo = () => <div />;
+          const renderStatelessComponent = () => <Foo className="foo" />;
+          const wrapper = mount((
+            <div>
+              {renderStatelessComponent()}
+            </div>
+          ));
+          expect(wrapper.find('Foo').type()).to.equal(Foo);
+        });
+      });
 
-      expect(wrapper.find('[data-foo-123]')).to.have.lengthOf(1);
-      expect(wrapper.find('[data-foo-123="bar2"]')).to.have.lengthOf(1);
+      it('should find component based on a react prop', () => {
+        const wrapper = mount((
+          <div>
+            <span htmlFor="foo" />
+            <div htmlFor="bar" />
+          </div>
+        ));
 
-      expect(wrapper.find('[data-123-foo]')).to.have.lengthOf(1);
-      expect(wrapper.find('[data-123-foo="bar3"]')).to.have.lengthOf(1);
+        expect(wrapper.find('[htmlFor="foo"]')).to.have.lengthOf(1);
+        expect(wrapper.find('[htmlFor]')).to.have.lengthOf(2);
+      });
 
-      expect(wrapper.find('[data-foo_bar]')).to.have.lengthOf(1);
-      expect(wrapper.find('[data-foo_bar="bar4"]')).to.have.lengthOf(1);
-    });
+      it('should error sensibly if any of the search props are undefined', () => {
+        const wrapper = mount((
+          <div>
+            <input type={undefined} />
+          </div>
+        ));
 
-    it('should find components with multiple matching props', () => {
-      const onChange = () => ({});
-      const wrapper = mount((
-        <div>
-          <span htmlFor="foo" onChange={onChange} preserveAspectRatio="xMaxYMax" />
-        </div>
-      ));
+        expect(() => wrapper.find({ type: undefined })).to.throw(
+          TypeError,
+          'Enzyme::Props can’t have `undefined` values. Try using ‘findWhere()’ instead.',
+        );
+      });
 
-      expect(wrapper.find('span[htmlFor="foo"][onChange]')).to.have.lengthOf(1);
-      expect(wrapper.find('span[htmlFor="foo"][preserveAspectRatio="xMaxYMax"]')).to.have.lengthOf(1);
-    });
+      it('should compound tag and prop selector', () => {
+        const wrapper = mount((
+          <div>
+            <span htmlFor="foo" />
+          </div>
+        ));
 
-    it('should not find property when undefined', () => {
-      const wrapper = mount((
-        <div>
-          <span data-foo={undefined} />
-        </div>
-      ));
+        expect(wrapper.find('span[htmlFor="foo"]')).to.have.lengthOf(1);
+        expect(wrapper.find('span[htmlFor]')).to.have.lengthOf(1);
+      });
 
-      expect(wrapper.find('[data-foo]')).to.have.lengthOf(0);
-    });
+      it('works with an adjacent sibling selector', () => {
+        const a = 'some';
+        const b = 'text';
+        const wrapper = mount((
+          <div>
+            <div className="row">
+              {a}
+              {b}
+            </div>
+            <div className="row">
+              {a}
+              {b}
+            </div>
+          </div>
+        ));
+        expect(wrapper.find('.row')).to.have.lengthOf(2);
+        expect(wrapper.find('.row + .row')).to.have.lengthOf(1);
+      });
 
-    it('should support boolean and numeric values for matching props', () => {
-      const wrapper = mount((
-        <div>
-          <span value={1} />
-          <a value={false} />
-          <a value="false" />
-          <span value="true" />
-          <a value="1" />
-          <a value="2" />
-        </div>
-      ));
+      it('should throw for non-numeric attribute values without quotes', () => {
+        const wrapper = mount((
+          <div>
+            <input type="text" />
+            <input type="hidden" />
+            <input type="text" />
+          </div>
+        ));
+        expect(() => wrapper.find('[type=text]')).to.throw(
+          Error,
+          'Failed to parse selector: [type=text]',
+        );
+        expect(() => wrapper.find('[type=hidden]')).to.throw(
+          Error,
+          'Failed to parse selector: [type=hidden]',
+        );
+        expect(() => wrapper.find('[type="text"]')).to.not.throw(
+          Error,
+          'Failed to parse selector: [type="text"]',
+        );
+      });
 
-      expect(wrapper.find('span[value=1]')).to.have.lengthOf(1);
-      expect(wrapper.find('span[value=2]')).to.have.lengthOf(0);
-      expect(wrapper.find('a[value=false]')).to.have.lengthOf(1);
-      expect(wrapper.find('a[value=true]')).to.have.lengthOf(0);
-    });
+      it('should support data prop selectors', () => {
+        const wrapper = mount((
+          <div>
+            <span data-foo="bar" />
+            <span data-foo-123="bar2" />
+            <span data-123-foo="bar3" />
+            <span data-foo_bar="bar4" />
+          </div>
+        ));
 
-    it('should not find key or ref via property selector', () => {
-      class Foo extends React.Component {
-        render() {
-          const arrayOfComponents = [<div key="1" />, <div key="2" />];
+        expect(wrapper.find('[data-foo="bar"]')).to.have.lengthOf(1);
+        expect(wrapper.find('[data-foo]')).to.have.lengthOf(1);
 
-          return (
-            <div>
-              <div ref="foo" />
-              {arrayOfComponents}
-            </div>
-          );
-        }
-      }
+        expect(wrapper.find('[data-foo-123]')).to.have.lengthOf(1);
+        expect(wrapper.find('[data-foo-123="bar2"]')).to.have.lengthOf(1);
 
-      const wrapper = mount(<Foo />);
+        expect(wrapper.find('[data-123-foo]')).to.have.lengthOf(1);
+        expect(wrapper.find('[data-123-foo="bar3"]')).to.have.lengthOf(1);
 
-      expect(wrapper.find('div[ref="foo"]')).to.have.lengthOf(0);
-      expect(wrapper.find('div[key="1"]')).to.have.lengthOf(0);
-      expect(wrapper.find('[ref]')).to.have.lengthOf(0);
-      expect(wrapper.find('[key]')).to.have.lengthOf(0);
-    });
+        expect(wrapper.find('[data-foo_bar]')).to.have.lengthOf(1);
+        expect(wrapper.find('[data-foo_bar="bar4"]')).to.have.lengthOf(1);
+      });
 
-    it('should find multiple elements based on a class name', () => {
-      const wrapper = mount((
-        <div>
-          <input className="foo" />
-          <button type="button" className="foo" />
-        </div>
-      ));
-      expect(wrapper.find('.foo')).to.have.lengthOf(2);
-    });
+      it('should find components with multiple matching props', () => {
+        const onChange = () => ({});
+        const wrapper = mount((
+          <div>
+            <span htmlFor="foo" onChange={onChange} preserveAspectRatio="xMaxYMax" />
+          </div>
+        ));
 
-    it('should find multiple elements based on a tag name', () => {
-      const wrapper = mount((
-        <div>
-          <input className="foo" />
-          <input />
-          <button type="button" />
-        </div>
-      ));
-      expect(wrapper.find('input')).to.have.lengthOf(2);
-      expect(wrapper.find('button')).to.have.lengthOf(1);
-    });
+        expect(wrapper.find('span[htmlFor="foo"][onChange]')).to.have.lengthOf(1);
+        expect(wrapper.find('span[htmlFor="foo"][preserveAspectRatio="xMaxYMax"]')).to.have.lengthOf(1);
+      });
 
-    it('should find multiple elements based on a constructor', () => {
-      const wrapper = mount((
-        <div>
-          <input className="foo" />
-          <input />
-          <button type="button" />
-        </div>
-      ));
-      expect(wrapper.find('input')).to.have.lengthOf(2);
-      expect(wrapper.find('button')).to.have.lengthOf(1);
-    });
+      it('should not find property when undefined', () => {
+        const wrapper = mount((
+          <div>
+            <span data-foo={undefined} />
+          </div>
+        ));
 
-    it('should support object property selectors', () => {
-      const wrapper = mount((
-        <div>
-          <input data-test="ref" className="foo" type="text" />
-          <input data-test="ref" type="text" />
-          <button data-test="ref" data-prop={undefined} type="button" />
-          <span data-test="ref" data-prop={null} />
-          <div data-test="ref" data-prop={123} />
-          <input data-test="ref" data-prop={false} />
-          <a data-test="ref" data-prop />
-        </div>
-      ));
-      expect(wrapper.find({ a: 1 })).to.have.lengthOf(0);
-      expect(wrapper.find({ 'data-test': 'ref' })).to.have.lengthOf(7);
-      expect(wrapper.find({ className: 'foo' })).to.have.lengthOf(1);
-      expect(wrapper.find({ 'data-prop': null })).to.have.lengthOf(1);
-      expect(wrapper.find({ 'data-prop': 123 })).to.have.lengthOf(1);
-      expect(wrapper.find({ 'data-prop': false })).to.have.lengthOf(1);
-      expect(wrapper.find({ 'data-prop': true })).to.have.lengthOf(1);
-    });
+        expect(wrapper.find('[data-foo]')).to.have.lengthOf(0);
+      });
 
-    it('should support complex and nested object property selectors', () => {
-      const testFunction = () => ({});
-      const wrapper = mount((
-        <div>
-          <span data-more={[{ id: 1 }]} data-test="ref" data-prop onChange={testFunction} />
-          <a data-more={[{ id: 1 }]} data-test="ref" />
-          <div data-more={{ item: { id: 1 } }} data-test="ref" />
-          <input data-more={{ height: 20 }} data-test="ref" />
-        </div>
-      ));
-      expect(wrapper.find({ 'data-test': 'ref' })).to.have.lengthOf(4);
-      expect(wrapper.find({ 'data-more': { a: 1 } })).to.have.lengthOf(0);
-      expect(wrapper.find({ 'data-more': [{ id: 1 }] })).to.have.lengthOf(2);
-      expect(wrapper.find({ 'data-more': { item: { id: 1 } } })).to.have.lengthOf(1);
-      expect(wrapper.find({ 'data-more': { height: 20 } })).to.have.lengthOf(1);
-      expect(wrapper.find({
-        'data-more': [{ id: 1 }],
-        'data-test': 'ref',
-        'data-prop': true,
-        onChange: testFunction,
-      })).to.have.lengthOf(1);
-    });
-
-    it('should throw when given empty object, null, or an array', () => {
-      const wrapper = mount((
-        <div>
-          <input className="foo" type="text" />
-        </div>
-      ));
-      expect(() => wrapper.find({})).to.throw(
-        TypeError,
-        'Enzyme::Selector does not support an array, null, or empty object as a selector',
-      );
-      expect(() => wrapper.find([])).to.throw(
-        TypeError,
-        'Enzyme::Selector does not support an array, null, or empty object as a selector',
-      );
-      expect(() => wrapper.find(null)).to.throw(
-        TypeError,
-        'Enzyme::Selector does not support an array, null, or empty object as a selector',
-      );
-    });
+      it('should support boolean and numeric values for matching props', () => {
+        const wrapper = mount((
+          <div>
+            <span value={1} />
+            <a value={false} />
+            <a value="false" />
+            <span value="true" />
+            <a value="1" />
+            <a value="2" />
+          </div>
+        ));
 
-    it('Should query attributes with spaces in their values', () => {
-      const wrapper = mount((
-        <div>
-          <h1 data-foo="foo bar">Hello</h1>
-          <h1 data-foo="bar baz quz">World</h1>
-        </div>
-      ));
-      expect(wrapper.find('[data-foo]')).to.have.lengthOf(2);
-      expect(wrapper.find('[data-foo="foo bar"]')).to.have.lengthOf(1);
-      expect(wrapper.find('[data-foo="bar baz quz"]')).to.have.lengthOf(1);
-      expect(wrapper.find('[data-foo="bar baz"]')).to.have.lengthOf(0);
-      expect(wrapper.find('[data-foo="foo  bar"]')).to.have.lengthOf(0);
-      expect(wrapper.find('[data-foo="bar  baz quz"]')).to.have.lengthOf(0);
-    });
+        expect(wrapper.find('span[value=1]')).to.have.lengthOf(1);
+        expect(wrapper.find('span[value=2]')).to.have.lengthOf(0);
+        expect(wrapper.find('a[value=false]')).to.have.lengthOf(1);
+        expect(wrapper.find('a[value=true]')).to.have.lengthOf(0);
+      });
 
-    itIf(is('>= 16'), 'should find elements through portals', () => {
-      const containerDiv = global.document.createElement('div');
+      it('should not find key or ref via property selector', () => {
+        class Foo extends React.Component {
+          render() {
+            const arrayOfComponents = [<div key="1" />, <div key="2" />];
 
-      class FooPortal extends React.Component {
-        render() {
-          return createPortal(
-            this.props.children,
-            containerDiv,
-          );
+            return (
+              <div>
+                <div ref="foo" />
+                {arrayOfComponents}
+              </div>
+            );
+          }
         }
-      }
 
-      const wrapper = mount(<FooPortal><h1>Successful Portal!</h1></FooPortal>);
-      expect(wrapper.find('h1')).to.have.lengthOf(1);
-      expect(containerDiv.querySelectorAll('h1')).to.have.lengthOf(1);
-    });
+        const wrapper = mount(<Foo />);
 
-    describeIf(is('> 0.13'), 'stateless function components', () => {
-      it('should find a component based on a constructor', () => {
-        const Foo = () => <div />;
+        expect(wrapper.find('div[ref="foo"]')).to.have.lengthOf(0);
+        expect(wrapper.find('div[key="1"]')).to.have.lengthOf(0);
+        expect(wrapper.find('[ref]')).to.have.lengthOf(0);
+        expect(wrapper.find('[key]')).to.have.lengthOf(0);
+      });
+
+      it('should find multiple elements based on a class name', () => {
         const wrapper = mount((
           <div>
-            <Foo className="foo" />
+            <input className="foo" />
+            <button type="button" className="foo" />
           </div>
         ));
-        expect(wrapper.find(Foo).type()).to.equal(Foo);
+        expect(wrapper.find('.foo')).to.have.lengthOf(2);
       });
 
-      it('should find a component based on a component displayName', () => {
-        const Foo = () => <div />;
+      it('should find multiple elements based on a tag name', () => {
         const wrapper = mount((
           <div>
-            <Foo className="foo" />
+            <input className="foo" />
+            <input />
+            <button type="button" />
           </div>
         ));
-        expect(wrapper.find('Foo').type()).to.equal(Foo);
+        expect(wrapper.find('input')).to.have.lengthOf(2);
+        expect(wrapper.find('button')).to.have.lengthOf(1);
       });
 
-      it('should not find key via property selector', () => {
-        const Foo = () => {
-          const arrayOfComponents = [<div key="1" />, <div key="2" />];
-          return (
-            <div>
-              {arrayOfComponents}
-            </div>
-          );
-        };
+      it('should find multiple elements based on a constructor', () => {
+        const wrapper = mount((
+          <div>
+            <input className="foo" />
+            <input />
+            <button type="button" />
+          </div>
+        ));
+        expect(wrapper.find('input')).to.have.lengthOf(2);
+        expect(wrapper.find('button')).to.have.lengthOf(1);
+      });
 
-        const wrapper = mount(<Foo />);
+      it('should support object property selectors', () => {
+        const wrapper = mount((
+          <div>
+            <input data-test="ref" className="foo" type="text" />
+            <input data-test="ref" type="text" />
+            <button data-test="ref" data-prop={undefined} type="button" />
+            <span data-test="ref" data-prop={null} />
+            <div data-test="ref" data-prop={123} />
+            <input data-test="ref" data-prop={false} />
+            <a data-test="ref" data-prop />
+          </div>
+        ));
+        expect(wrapper.find({ a: 1 })).to.have.lengthOf(0);
+        expect(wrapper.find({ 'data-test': 'ref' })).to.have.lengthOf(7);
+        expect(wrapper.find({ className: 'foo' })).to.have.lengthOf(1);
+        expect(wrapper.find({ 'data-prop': null })).to.have.lengthOf(1);
+        expect(wrapper.find({ 'data-prop': 123 })).to.have.lengthOf(1);
+        expect(wrapper.find({ 'data-prop': false })).to.have.lengthOf(1);
+        expect(wrapper.find({ 'data-prop': true })).to.have.lengthOf(1);
+      });
 
-        expect(wrapper.find('div[key="1"]')).to.have.lengthOf(0);
-        expect(wrapper.find('[key]')).to.have.lengthOf(0);
+      it('should support complex and nested object property selectors', () => {
+        const testFunction = () => ({});
+        const wrapper = mount((
+          <div>
+            <span data-more={[{ id: 1 }]} data-test="ref" data-prop onChange={testFunction} />
+            <a data-more={[{ id: 1 }]} data-test="ref" />
+            <div data-more={{ item: { id: 1 } }} data-test="ref" />
+            <input data-more={{ height: 20 }} data-test="ref" />
+          </div>
+        ));
+        expect(wrapper.find({ 'data-test': 'ref' })).to.have.lengthOf(4);
+        expect(wrapper.find({ 'data-more': { a: 1 } })).to.have.lengthOf(0);
+        expect(wrapper.find({ 'data-more': [{ id: 1 }] })).to.have.lengthOf(2);
+        expect(wrapper.find({ 'data-more': { item: { id: 1 } } })).to.have.lengthOf(1);
+        expect(wrapper.find({ 'data-more': { height: 20 } })).to.have.lengthOf(1);
+        expect(wrapper.find({
+          'data-more': [{ id: 1 }],
+          'data-test': 'ref',
+          'data-prop': true,
+          onChange: testFunction,
+        })).to.have.lengthOf(1);
       });
-    });
 
-    describe('works with attribute selectors containing #', () => {
-      let wrapper;
-      beforeEach(() => {
-        wrapper = mount((
+      it('should throw when given empty object, null, or an array', () => {
+        const wrapper = mount((
           <div>
-            <a id="test" href="/page">Hello</a>
-            <a href="/page#anchor">World</a>
+            <input className="foo" type="text" />
           </div>
         ));
+        expect(() => wrapper.find({})).to.throw(
+          TypeError,
+          'Enzyme::Selector does not support an array, null, or empty object as a selector',
+        );
+        expect(() => wrapper.find([])).to.throw(
+          TypeError,
+          'Enzyme::Selector does not support an array, null, or empty object as a selector',
+        );
+        expect(() => wrapper.find(null)).to.throw(
+          TypeError,
+          'Enzyme::Selector does not support an array, null, or empty object as a selector',
+        );
       });
 
-      it('works with an ID', () => {
-        expect(wrapper.find('a#test')).to.have.lengthOf(1);
+      it('Should query attributes with spaces in their values', () => {
+        const wrapper = mount((
+          <div>
+            <h1 data-foo="foo bar">Hello</h1>
+            <h1 data-foo="bar baz quz">World</h1>
+          </div>
+        ));
+        expect(wrapper.find('[data-foo]')).to.have.lengthOf(2);
+        expect(wrapper.find('[data-foo="foo bar"]')).to.have.lengthOf(1);
+        expect(wrapper.find('[data-foo="bar baz quz"]')).to.have.lengthOf(1);
+        expect(wrapper.find('[data-foo="bar baz"]')).to.have.lengthOf(0);
+        expect(wrapper.find('[data-foo="foo  bar"]')).to.have.lengthOf(0);
+        expect(wrapper.find('[data-foo="bar  baz quz"]')).to.have.lengthOf(0);
       });
 
-      it('works with a normal attribute', () => {
-        expect(wrapper.find('a[href="/page"]')).to.have.lengthOf(1);
+      itIf(is('>= 16'), 'should find elements through portals', () => {
+        const containerDiv = global.document.createElement('div');
+
+        class FooPortal extends React.Component {
+          render() {
+            return createPortal(
+              this.props.children,
+              containerDiv,
+            );
+          }
+        }
+
+        const wrapper = mount(<FooPortal><h1>Successful Portal!</h1></FooPortal>);
+        expect(wrapper.find('h1')).to.have.lengthOf(1);
+        expect(containerDiv.querySelectorAll('h1')).to.have.lengthOf(1);
       });
 
-      it('works with an attribute with a #', () => {
-        expect(wrapper.find('a[href="/page#anchor"]')).to.have.lengthOf(1);
+      describeIf(is('> 0.13'), 'stateless function components', () => {
+        it('should find a component based on a constructor', () => {
+          const Foo = () => <div />;
+          const wrapper = mount((
+            <div>
+              <Foo className="foo" />
+            </div>
+          ));
+          expect(wrapper.find(Foo).type()).to.equal(Foo);
+        });
+
+        it('should find a component based on a component displayName', () => {
+          const Foo = () => <div />;
+          const wrapper = mount((
+            <div>
+              <Foo className="foo" />
+            </div>
+          ));
+          expect(wrapper.find('Foo').type()).to.equal(Foo);
+        });
+
+        it('should not find key via property selector', () => {
+          const Foo = () => {
+            const arrayOfComponents = [<div key="1" />, <div key="2" />];
+            return (
+              <div>
+                {arrayOfComponents}
+              </div>
+            );
+          };
+
+          const wrapper = mount(<Foo />);
+
+          expect(wrapper.find('div[key="1"]')).to.have.lengthOf(0);
+          expect(wrapper.find('[key]')).to.have.lengthOf(0);
+        });
       });
-    });
 
-    describe('works with data- attributes', () => {
-      class Foo extends React.Component {
-        render() {
-          return (
+      describe('works with attribute selectors containing #', () => {
+        let wrapper;
+        beforeEach(() => {
+          wrapper = mount((
             <div>
-              <i className="ficon ficon-12 some-icon" />
-              <span className="custom class">
-                <i className="ficon ficon-book ficon-24" data-custom-tag="bookIcon" />
-                <i className="ficon ficon-book ficon-24" data-custom-tag="bookIcon" />
-              </span>
+              <a id="test" href="/page">Hello</a>
+              <a href="/page#anchor">World</a>
             </div>
-          );
+          ));
+        });
+
+        it('works with an ID', () => {
+          expect(wrapper.find('a#test')).to.have.lengthOf(1);
+        });
+
+        it('works with a normal attribute', () => {
+          expect(wrapper.find('a[href="/page"]')).to.have.lengthOf(1);
+        });
+
+        it('works with an attribute with a #', () => {
+          expect(wrapper.find('a[href="/page#anchor"]')).to.have.lengthOf(1);
+        });
+      });
+
+      describe('works with data- attributes', () => {
+        class Foo extends React.Component {
+          render() {
+            return (
+              <div>
+                <i className="ficon ficon-12 some-icon" />
+                <span className="custom class">
+                  <i className="ficon ficon-book ficon-24" data-custom-tag="bookIcon" />
+                  <i className="ficon ficon-book ficon-24" data-custom-tag="bookIcon" />
+                </span>
+              </div>
+            );
+          }
         }
-      }
 
-      it('finds elements by data attribute', () => {
-        const wrapper = mount(<Foo />);
-        expect(wrapper.html()).to.contain('data-custom-tag="bookIcon"'); // sanity check
-        const elements = wrapper.find('[data-custom-tag="bookIcon"]');
-        expect(elements).to.have.lengthOf(2);
-        expect(elements.filter('i')).to.have.lengthOf(2);
+        it('finds elements by data attribute', () => {
+          const wrapper = mount(<Foo />);
+          expect(wrapper.html()).to.contain('data-custom-tag="bookIcon"'); // sanity check
+          const elements = wrapper.find('[data-custom-tag="bookIcon"]');
+          expect(elements).to.have.lengthOf(2);
+          expect(elements.filter('i')).to.have.lengthOf(2);
+        });
       });
     });
-  });
 
   describe('.findWhere(predicate)', () => {
     it('should return all elements for a truthy test', () => {
@@ -3992,88 +4017,111 @@ describeWithDOM('mount', () => {
     });
   });
 
-  describe('.name()', () => {
-    describe('node with displayName', () => {
-      it('should return the displayName of the node', () => {
-        class Foo extends React.Component {
-          render() { return <div />; }
-        }
-
-        Foo.displayName = 'CustomWrapper';
-
-        const wrapper = mount(<Foo />);
-        expect(wrapper.name()).to.equal('CustomWrapper');
-      });
-
-      describeIf(is('> 0.13'), 'stateless function components', () => {
-        it('should return the name of the node', () => {
-          function SFC() {
-            return <div />;
+  wrap()
+    .withOverride(() => getAdapter(), 'displayNameOfNode', () => undefined)
+    .describe('.name()', () => {
+      describe('node with displayName', () => {
+        it('should return the displayName of the node', () => {
+          class Foo extends React.Component {
+            render() { return <div />; }
           }
 
-          SFC.displayName = 'CustomWrapper';
+          Foo.displayName = 'CustomWrapper';
 
-          const wrapper = mount(<SFC />);
+          const wrapper = mount(<Foo />);
           expect(wrapper.name()).to.equal('CustomWrapper');
         });
-      });
 
-      describe('createClass', () => {
-        it('should return the name of the node', () => {
-          const Foo = createClass({
-            displayName: 'CustomWrapper',
-            render() {
+        describeIf(is('> 0.13'), 'stateless function components', () => {
+          it('should return the name of the node', () => {
+            function SFC() {
               return <div />;
-            },
-          });
+            }
 
-          const wrapper = mount(<Foo />);
-          expect(wrapper.name()).to.equal('CustomWrapper');
+            SFC.displayName = 'CustomWrapper';
+
+            const wrapper = mount(<SFC />);
+            expect(wrapper.name()).to.equal('CustomWrapper');
+          });
         });
-      });
-    });
 
-    describe('node without displayName', () => {
-      it('should return the name of the node', () => {
-        class Foo extends React.Component {
-          render() { return <div />; }
-        }
+        describe('createClass', () => {
+          it('should return the name of the node', () => {
+            const Foo = createClass({
+              displayName: 'CustomWrapper',
+              render() {
+                return <div />;
+              },
+            });
+
+            const wrapper = mount(<Foo />);
+            expect(wrapper.name()).to.equal('CustomWrapper');
+          });
+        });
 
-        const wrapper = mount(<Foo />);
-        expect(wrapper.name()).to.equal('Foo');
+        wrap()
+          .withOverride(() => getAdapter(), 'displayNameOfNode', () => sinon.stub())
+          .describe('adapter has `displayNameOfNode`', () => {
+            it('delegates to the adapter’s `displayNameOfNode`', () => {
+              class Foo extends React.Component {
+                render() { return <div />; }
+              }
+              const stub = getAdapter().displayNameOfNode;
+              const sentinel = {};
+              stub.returns(sentinel);
+
+              const wrapper = mount(<Foo />);
+
+              expect(wrapper.name()).to.equal(sentinel);
+
+              expect(stub).to.have.property('callCount', 1);
+              const { args } = stub.firstCall;
+              expect(args).to.eql([wrapper.getNodeInternal()]);
+            });
+          });
       });
 
-      describeIf(is('> 0.13'), 'stateless function components', () => {
+      describe('node without displayName', () => {
         it('should return the name of the node', () => {
-          function SFC() {
-            return <div />;
+          class Foo extends React.Component {
+            render() { return <div />; }
           }
 
-          const wrapper = mount(<SFC />);
-          expect(wrapper.name()).to.equal('SFC');
+          const wrapper = mount(<Foo />);
+          expect(wrapper.name()).to.equal('Foo');
+        });
+
+        describeIf(is('> 0.13'), 'stateless function components', () => {
+          it('should return the name of the node', () => {
+            function SFC() {
+              return <div />;
+            }
+
+            const wrapper = mount(<SFC />);
+            expect(wrapper.name()).to.equal('SFC');
+          });
         });
       });
-    });
 
-    describe('DOM node', () => {
-      it('should return the name of the node', () => {
-        const wrapper = mount(<div />);
-        expect(wrapper.name()).to.equal('div');
+      describe('DOM node', () => {
+        it('should return the name of the node', () => {
+          const wrapper = mount(<div />);
+          expect(wrapper.name()).to.equal('div');
+        });
       });
-    });
 
-    describe('.ref()', () => {
-      it('unavailable ref should return undefined', () => {
-        class WithoutRef extends React.Component {
-          render() { return <div />; }
-        }
-        const wrapper = mount(<WithoutRef />);
-        const ref = wrapper.ref('not-a-ref');
+      describe('.ref()', () => {
+        it('unavailable ref should return undefined', () => {
+          class WithoutRef extends React.Component {
+            render() { return <div />; }
+          }
+          const wrapper = mount(<WithoutRef />);
+          const ref = wrapper.ref('not-a-ref');
 
-        expect(ref).to.equal(undefined);
+          expect(ref).to.equal(undefined);
+        });
       });
     });
-  });
 
   describeIf(ITERATOR_SYMBOL, '@@iterator', () => {
     it('should be iterable', () => {
diff --git a/packages/enzyme-test-suite/test/ShallowWrapper-spec.jsx b/packages/enzyme-test-suite/test/ShallowWrapper-spec.jsx
index e8ca78ca6..1894b18ce 100644
--- a/packages/enzyme-test-suite/test/ShallowWrapper-spec.jsx
+++ b/packages/enzyme-test-suite/test/ShallowWrapper-spec.jsx
@@ -2,13 +2,19 @@ import React from 'react';
 import PropTypes from 'prop-types';
 import { expect } from 'chai';
 import sinon from 'sinon';
+import wrap from 'mocha-wrap';
 import {
   shallow,
   render,
   ShallowWrapper,
   mount,
 } from 'enzyme';
-import { ITERATOR_SYMBOL, withSetStateAllowed, sym } from 'enzyme/build/Utils';
+import {
+  ITERATOR_SYMBOL,
+  withSetStateAllowed,
+  sym,
+  getAdapter,
+} from 'enzyme/build/Utils';
 
 import './_helpers/setupAdapters';
 import { createClass, createContext } from './_helpers/react-compat';
@@ -494,469 +500,489 @@ describe('shallow', () => {
     });
   });
 
-  describe('.find(selector)', () => {
-    it('should be able to match the root DOM element', () => {
-      const wrapper = shallow(<div id="ttt" className="ttt">hello</div>);
-      expect(wrapper.find('#ttt')).to.have.lengthOf(1);
-      expect(wrapper.find('.ttt')).to.have.lengthOf(1);
-    });
-
-    it('should find an element based on a class name', () => {
-      const wrapper = shallow((
-        <div>
-          <input className="foo" />
-        </div>
-      ));
-      expect(wrapper.find('.foo').type()).to.equal('input');
-    });
+  wrap()
+    .withOverride(() => getAdapter(), 'isValidElementType', () => undefined)
+    .describe('.find(selector)', () => {
+      it('should be able to match the root DOM element', () => {
+        const wrapper = shallow(<div id="ttt" className="ttt">hello</div>);
+        expect(wrapper.find('#ttt')).to.have.lengthOf(1);
+        expect(wrapper.find('.ttt')).to.have.lengthOf(1);
+      });
 
-    it('should find an element that has dot in attribute', () => {
-      const wrapper = shallow((
-        <div>
-          <div data-baz="foo.bar" />
-        </div>
-      ));
+      it('should find an element based on a class name', () => {
+        const wrapper = shallow((
+          <div>
+            <input className="foo" />
+          </div>
+        ));
+        expect(wrapper.find('.foo').type()).to.equal('input');
+      });
 
-      const elements = wrapper.find('[data-baz="foo.bar"]');
-      expect(elements).to.have.lengthOf(1);
-    });
+      it('should find an element that has dot in attribute', () => {
+        const wrapper = shallow((
+          <div>
+            <div data-baz="foo.bar" />
+          </div>
+        ));
 
-    it('should find an element that with class and attribute', () => {
-      const wrapper = shallow((
-        <div>
-          <div data-baz="bar" className="classBar" />
-        </div>
-      ));
+        const elements = wrapper.find('[data-baz="foo.bar"]');
+        expect(elements).to.have.lengthOf(1);
+      });
 
-      const elements = wrapper.find('.classBar[data-baz="bar"]');
-      expect(elements).to.have.lengthOf(1);
-    });
+      it('should find an element that with class and attribute', () => {
+        const wrapper = shallow((
+          <div>
+            <div data-baz="bar" className="classBar" />
+          </div>
+        ));
 
-    it('should find an element that with multiple classes and one attribute', () => {
-      const wrapper = shallow((
-        <div>
-          <div data-baz="bar" className="classBar classFoo" />
-        </div>
-      ));
+        const elements = wrapper.find('.classBar[data-baz="bar"]');
+        expect(elements).to.have.lengthOf(1);
+      });
 
-      const elements = wrapper.find('.classBar.classFoo[data-baz="bar"]');
-      expect(elements).to.have.lengthOf(1);
-    });
+      it('should find an element that with multiple classes and one attribute', () => {
+        const wrapper = shallow((
+          <div>
+            <div data-baz="bar" className="classBar classFoo" />
+          </div>
+        ));
 
-    it('should find an element that with class and class with hyphen', () => {
-      const wrapper = shallow((
-        <div>
-          <div data-baz="bar" className="classBar class-Foo" />
-        </div>
-      ));
+        const elements = wrapper.find('.classBar.classFoo[data-baz="bar"]');
+        expect(elements).to.have.lengthOf(1);
+      });
 
-      const elements = wrapper.find('.classBar.class-Foo');
-      expect(elements).to.have.lengthOf(1);
-    });
+      it('should find an element that with class and class with hyphen', () => {
+        const wrapper = shallow((
+          <div>
+            <div data-baz="bar" className="classBar class-Foo" />
+          </div>
+        ));
 
-    it('should find an element based on a tag name and class name', () => {
-      const wrapper = shallow((
-        <div>
-          <input className="foo" />
-        </div>
-      ));
-      expect(wrapper.find('input.foo')).to.have.lengthOf(1);
-    });
+        const elements = wrapper.find('.classBar.class-Foo');
+        expect(elements).to.have.lengthOf(1);
+      });
 
-    it('should find an element based on a tag name and id', () => {
-      const wrapper = shallow((
-        <div>
-          <input id="foo" />
-        </div>
-      ));
-      expect(wrapper.find('input#foo')).to.have.lengthOf(1);
-    });
+      it('should find an element based on a tag name and class name', () => {
+        const wrapper = shallow((
+          <div>
+            <input className="foo" />
+          </div>
+        ));
+        expect(wrapper.find('input.foo')).to.have.lengthOf(1);
+      });
 
-    it('should find an element based on a tag name, id, and class name', () => {
-      const wrapper = shallow((
-        <div>
-          <input id="foo" className="bar" />
-        </div>
-      ));
-      expect(wrapper.find('input#foo.bar')).to.have.lengthOf(1);
-    });
+      it('should find an element based on a tag name and id', () => {
+        const wrapper = shallow((
+          <div>
+            <input id="foo" />
+          </div>
+        ));
+        expect(wrapper.find('input#foo')).to.have.lengthOf(1);
+      });
 
-    it('should find an element based on a tag name', () => {
-      const wrapper = shallow((
-        <div>
-          <input className="foo" />
-          <button className="bar">Button</button>
-          <textarea className="magic" />
-          <select className="reality" />
-        </div>
-      ));
-      expect(wrapper.find('input').props().className).to.equal('foo');
-      expect(wrapper.find('button').props().className).to.equal('bar');
-      expect(wrapper.find('textarea').props().className).to.equal('magic');
-      expect(wrapper.find('select').props().className).to.equal('reality');
-    });
+      it('should find an element based on a tag name, id, and class name', () => {
+        const wrapper = shallow((
+          <div>
+            <input id="foo" className="bar" />
+          </div>
+        ));
+        expect(wrapper.find('input#foo.bar')).to.have.lengthOf(1);
+      });
 
-    it('should find a component based on a constructor', () => {
-      class Foo extends React.Component {
-        render() { return <div />; }
-      }
-      const wrapper = shallow((
-        <div>
-          <Foo className="foo" />
-        </div>
-      ));
-      expect(wrapper.find(Foo).type()).to.equal(Foo);
-    });
+      it('should find an element based on a tag name', () => {
+        const wrapper = shallow((
+          <div>
+            <input className="foo" />
+            <button className="bar">Button</button>
+            <textarea className="magic" />
+            <select className="reality" />
+          </div>
+        ));
+        expect(wrapper.find('input').props().className).to.equal('foo');
+        expect(wrapper.find('button').props().className).to.equal('bar');
+        expect(wrapper.find('textarea').props().className).to.equal('magic');
+        expect(wrapper.find('select').props().className).to.equal('reality');
+      });
 
-    it('should find a component based on a display name', () => {
-      class Foo extends React.Component {
-        render() { return <div />; }
-      }
-      const wrapper = shallow((
-        <div>
-          <Foo className="foo" />
-        </div>
-      ));
-      expect(wrapper.find('Foo').type()).to.equal(Foo);
-    });
+      it('should find a component based on a constructor', () => {
+        class Foo extends React.Component {
+          render() { return <div />; }
+        }
+        const wrapper = shallow((
+          <div>
+            <Foo className="foo" />
+          </div>
+        ));
+        expect(wrapper.find(Foo).type()).to.equal(Foo);
+      });
 
-    it('should find multiple elements based on a class name', () => {
-      const wrapper = shallow((
-        <div>
-          <input className="foo" />
-          <button className="foo" />
-        </div>
-      ));
-      expect(wrapper.find('.foo')).to.have.lengthOf(2);
-    });
+      wrap()
+        .withOverride(() => getAdapter(), 'isValidElementType', () => () => false)
+        .it('throws when an adapter’s `isValidElementType` lies', () => {
+          class Foo extends React.Component {
+            render() { return <div />; }
+          }
+          const wrapper = shallow((
+            <div>
+              <Foo className="foo" />
+            </div>
+          ));
 
-    it('should find multiple elements based on a tag name', () => {
-      const wrapper = shallow((
-        <div>
-          <input className="foo" />
-          <input />
-          <button />
-        </div>
-      ));
-      expect(wrapper.find('input')).to.have.lengthOf(2);
-      expect(wrapper.find('button')).to.have.lengthOf(1);
-    });
+          expect(() => wrapper.find(Foo)).to.throw(
+            TypeError,
+            'Enzyme::Selector expects a string, object, or valid element type (Component Constructor)',
+          );
+        });
 
-    it('should work on non-single nodes', () => {
-      const wrapper = shallow((
-        <div className="a">
-          <div className="b">
-            <div className="c">Text</div>
-            <div className="c">Text</div>
-            <div className="c">Text</div>
-          </div>
-          <div className="b">
-            <div className="c">Text</div>
-            <div className="c">Text</div>
-            <div className="c">Text</div>
+      it('should find a component based on a component display name', () => {
+        class Foo extends React.Component {
+          render() { return <div />; }
+        }
+        const wrapper = shallow((
+          <div>
+            <Foo className="foo" />
           </div>
-        </div>
-      ));
-      expect(wrapper.find('.a')).to.have.lengthOf(1);
-      expect(wrapper.find('.b')).to.have.lengthOf(2);
-      expect(wrapper.find('.b').find('.c')).to.have.lengthOf(6);
-    });
-
-    it('should find component based on a react prop', () => {
-      const wrapper = shallow((
-        <div>
-          <span title="foo" />
-        </div>
-      ));
-
-      expect(wrapper.find('[title="foo"]')).to.have.lengthOf(1);
-      expect(wrapper.find('[title]')).to.have.lengthOf(1);
-    });
+        ));
+        expect(wrapper.find('Foo').type()).to.equal(Foo);
+      });
 
-    it('works with an adjacent sibling selector', () => {
-      const a = 'some';
-      const b = 'text';
-      const wrapper = shallow((
-        <div>
-          <div className="row">
-            {a}
-            {b}
+      it('should find multiple elements based on a class name', () => {
+        const wrapper = shallow((
+          <div>
+            <input className="foo" />
+            <button className="foo" />
           </div>
-          <div className="row">
-            {a}
-            {b}
+        ));
+        expect(wrapper.find('.foo')).to.have.lengthOf(2);
+      });
+
+      it('should find multiple elements based on a tag name', () => {
+        const wrapper = shallow((
+          <div>
+            <input className="foo" />
+            <input />
+            <button />
           </div>
-        </div>
-      ));
-      expect(wrapper.find('.row')).to.have.lengthOf(2);
-      expect(wrapper.find('.row + .row')).to.have.lengthOf(1);
-    });
+        ));
+        expect(wrapper.find('input')).to.have.lengthOf(2);
+        expect(wrapper.find('button')).to.have.lengthOf(1);
+      });
 
-    it('should throw for non-numeric attribute values without quotes', () => {
-      const wrapper = shallow((
-        <div>
-          <input type="text" />
-          <input type="hidden" />
-          <input type="text" />
-        </div>
-      ));
-      expect(() => wrapper.find('[type=text]')).to.throw(
-        Error,
-        'Failed to parse selector: [type=text]',
-      );
-      expect(() => wrapper.find('[type=hidden]')).to.throw(
-        Error,
-        'Failed to parse selector: [type=hidden]',
-      );
-      expect(() => wrapper.find('[type="text"]')).to.not.throw(
-        Error,
-        'Failed to parse selector: [type="text"]',
-      );
-    });
+      it('should work on non-single nodes', () => {
+        const wrapper = shallow((
+          <div className="a">
+            <div className="b">
+              <div className="c">Text</div>
+              <div className="c">Text</div>
+              <div className="c">Text</div>
+            </div>
+            <div className="b">
+              <div className="c">Text</div>
+              <div className="c">Text</div>
+              <div className="c">Text</div>
+            </div>
+          </div>
+        ));
+        expect(wrapper.find('.a')).to.have.lengthOf(1);
+        expect(wrapper.find('.b')).to.have.lengthOf(2);
+        expect(wrapper.find('.b').find('.c')).to.have.lengthOf(6);
+      });
 
-    it('should error sensibly if any of the search props are undefined', () => {
-      const wrapper = shallow((
-        <div>
-          <input type={undefined} />
-        </div>
-      ));
+      it('should find component based on a react prop', () => {
+        const wrapper = shallow((
+          <div>
+            <span title="foo" />
+          </div>
+        ));
 
-      expect(() => wrapper.find({ type: undefined })).to.throw(
-        TypeError,
-        'Enzyme::Props can’t have `undefined` values. Try using ‘findWhere()’ instead.',
-      );
-    });
+        expect(wrapper.find('[title="foo"]')).to.have.lengthOf(1);
+        expect(wrapper.find('[title]')).to.have.lengthOf(1);
+      });
 
-    it('should compound tag and prop selector', () => {
-      const wrapper = shallow((
-        <div>
-          <span preserveAspectRatio="xMaxYMax" />
-        </div>
-      ));
+      it('works with an adjacent sibling selector', () => {
+        const a = 'some';
+        const b = 'text';
+        const wrapper = shallow((
+          <div>
+            <div className="row">
+              {a}
+              {b}
+            </div>
+            <div className="row">
+              {a}
+              {b}
+            </div>
+          </div>
+        ));
+        expect(wrapper.find('.row')).to.have.lengthOf(2);
+        expect(wrapper.find('.row + .row')).to.have.lengthOf(1);
+      });
 
-      expect(wrapper.find('span[preserveAspectRatio="xMaxYMax"]')).to.have.lengthOf(1);
-      expect(wrapper.find('span[preserveAspectRatio]')).to.have.lengthOf(1);
-    });
+      it('should throw for non-numeric attribute values without quotes', () => {
+        const wrapper = shallow((
+          <div>
+            <input type="text" />
+            <input type="hidden" />
+            <input type="text" />
+          </div>
+        ));
+        expect(() => wrapper.find('[type=text]')).to.throw(
+          Error,
+          'Failed to parse selector: [type=text]',
+        );
+        expect(() => wrapper.find('[type=hidden]')).to.throw(
+          Error,
+          'Failed to parse selector: [type=hidden]',
+        );
+        expect(() => wrapper.find('[type="text"]')).to.not.throw(
+          Error,
+          'Failed to parse selector: [type="text"]',
+        );
+      });
 
-    it('should support data prop selectors', () => {
-      const wrapper = shallow((
-        <div>
-          <span data-foo="bar" />
-        </div>
-      ));
+      it('should error sensibly if any of the search props are undefined', () => {
+        const wrapper = shallow((
+          <div>
+            <input type={undefined} />
+          </div>
+        ));
 
-      expect(wrapper.find('[data-foo="bar"]')).to.have.lengthOf(1);
-      expect(wrapper.find('[data-foo]')).to.have.lengthOf(1);
-    });
+        expect(() => wrapper.find({ type: undefined })).to.throw(
+          TypeError,
+          'Enzyme::Props can’t have `undefined` values. Try using ‘findWhere()’ instead.',
+        );
+      });
 
-    it('should find components with multiple matching react props', () => {
-      function noop() {}
-      const wrapper = shallow((
-        <div>
-          <span htmlFor="foo" onChange={noop} preserveAspectRatio="xMaxYMax" />
-        </div>
-      ));
+      it('should compound tag and prop selector', () => {
+        const wrapper = shallow((
+          <div>
+            <span preserveAspectRatio="xMaxYMax" />
+          </div>
+        ));
 
-      expect(wrapper.find('span[htmlFor="foo"][onChange]')).to.have.lengthOf(1);
-      expect(wrapper.find('span[htmlFor="foo"][preserveAspectRatio="xMaxYMax"]')).to.have.lengthOf(1);
-      expect(wrapper.find('[htmlFor][preserveAspectRatio]')).to.have.lengthOf(1);
-    });
+        expect(wrapper.find('span[preserveAspectRatio="xMaxYMax"]')).to.have.lengthOf(1);
+        expect(wrapper.find('span[preserveAspectRatio]')).to.have.lengthOf(1);
+      });
 
-    it('should support boolean and numeric values for matching props', () => {
-      const wrapper = shallow((
-        <div>
-          <span value={1} />
-          <a value={false} />
-        </div>
-      ));
+      it('should support data prop selectors', () => {
+        const wrapper = shallow((
+          <div>
+            <span data-foo="bar" />
+          </div>
+        ));
 
-      expect(wrapper.find('span[value=1]')).to.have.lengthOf(1);
-      expect(wrapper.find('span[value=2]')).to.have.lengthOf(0);
-      expect(wrapper.find('a[value=false]')).to.have.lengthOf(1);
-      expect(wrapper.find('a[value=true]')).to.have.lengthOf(0);
-    });
+        expect(wrapper.find('[data-foo="bar"]')).to.have.lengthOf(1);
+        expect(wrapper.find('[data-foo]')).to.have.lengthOf(1);
+      });
 
-    it('should not find key or ref via property selector', () => {
-      const arrayOfComponents = [<div key="1" />, <div key="2" />];
+      it('should find components with multiple matching react props', () => {
+        function noop() {}
+        const wrapper = shallow((
+          <div>
+            <span htmlFor="foo" onChange={noop} preserveAspectRatio="xMaxYMax" />
+          </div>
+        ));
 
-      const wrapper = shallow((
-        <div>
-          <div ref="foo" />
-          {arrayOfComponents}
-        </div>
-      ));
+        expect(wrapper.find('span[htmlFor="foo"][onChange]')).to.have.lengthOf(1);
+        expect(wrapper.find('span[htmlFor="foo"][preserveAspectRatio="xMaxYMax"]')).to.have.lengthOf(1);
+        expect(wrapper.find('[htmlFor][preserveAspectRatio]')).to.have.lengthOf(1);
+      });
 
-      expect(wrapper.find('div[ref="foo"]')).to.have.lengthOf(0);
-      expect(wrapper.find('div[key="1"]')).to.have.lengthOf(0);
-      expect(wrapper.find('[ref]')).to.have.lengthOf(0);
-      expect(wrapper.find('[key]')).to.have.lengthOf(0);
-    });
+      it('should support boolean and numeric values for matching props', () => {
+        const wrapper = shallow((
+          <div>
+            <span value={1} />
+            <a value={false} />
+          </div>
+        ));
 
-    it('should find multiple elements based on a constructor', () => {
-      const wrapper = shallow((
-        <div>
-          <input className="foo" />
-          <input />
-          <button />
-        </div>
-      ));
-      expect(wrapper.find('input')).to.have.lengthOf(2);
-      expect(wrapper.find('button')).to.have.lengthOf(1);
-    });
+        expect(wrapper.find('span[value=1]')).to.have.lengthOf(1);
+        expect(wrapper.find('span[value=2]')).to.have.lengthOf(0);
+        expect(wrapper.find('a[value=false]')).to.have.lengthOf(1);
+        expect(wrapper.find('a[value=true]')).to.have.lengthOf(0);
+      });
 
-    it('should support object property selectors', () => {
-      const wrapper = shallow((
-        <div>
-          <input data-test="ref" className="foo" type="text" />
-          <input data-test="ref" type="text" />
-          <button data-test="ref" prop={undefined} />
-          <span data-test="ref" prop={null} />
-          <div data-test="ref" prop={123} />
-          <input data-test="ref" prop={false} />
-          <a data-test="ref" prop />
-        </div>
-      ));
-      expect(wrapper.find({ a: 1 })).to.have.lengthOf(0);
-      expect(wrapper.find({ 'data-test': 'ref' })).to.have.lengthOf(7);
-      expect(wrapper.find({ className: 'foo' })).to.have.lengthOf(1);
-      expect(wrapper.find({ prop: null })).to.have.lengthOf(1);
-      expect(wrapper.find({ prop: 123 })).to.have.lengthOf(1);
-      expect(wrapper.find({ prop: false })).to.have.lengthOf(1);
-      expect(wrapper.find({ prop: true })).to.have.lengthOf(1);
-    });
+      it('should not find key or ref via property selector', () => {
+        const arrayOfComponents = [<div key="1" />, <div key="2" />];
 
-    it('should support complex and nested object property selectors', () => {
-      const testFunction = () => ({});
-      const wrapper = shallow((
-        <div>
-          <span more={[{ id: 1 }]} data-test="ref" prop onChange={testFunction} />
-          <a more={[{ id: 1 }]} data-test="ref" />
-          <div more={{ item: { id: 1 } }} data-test="ref" />
-          <input style={{ height: 20 }} data-test="ref" />
-        </div>
-      ));
-      expect(wrapper.find({ 'data-test': 'ref' })).to.have.lengthOf(4);
-      expect(wrapper.find({ more: { a: 1 } })).to.have.lengthOf(0);
-      expect(wrapper.find({ more: [{ id: 1 }] })).to.have.lengthOf(2);
-      expect(wrapper.find({ more: { item: { id: 1 } } })).to.have.lengthOf(1);
-      expect(wrapper.find({ style: { height: 20 } })).to.have.lengthOf(1);
-      expect(wrapper.find({
-        more: [{ id: 1 }],
-        'data-test': 'ref',
-        prop: true,
-        onChange: testFunction,
-      })).to.have.lengthOf(1);
-    });
-
-    it('should throw when given empty object, null, or an array', () => {
-      const wrapper = shallow((
-        <div>
-          <input className="foo" type="text" />
-        </div>
-      ));
-      expect(() => wrapper.find({})).to.throw(
-        TypeError,
-        'Enzyme::Selector does not support an array, null, or empty object as a selector',
-      );
-      expect(() => wrapper.find([])).to.throw(
-        TypeError,
-        'Enzyme::Selector does not support an array, null, or empty object as a selector',
-      );
-      expect(() => wrapper.find(null)).to.throw(
-        TypeError,
-        'Enzyme::Selector does not support an array, null, or empty object as a selector',
-      );
-    });
+        const wrapper = shallow((
+          <div>
+            <div ref="foo" />
+            {arrayOfComponents}
+          </div>
+        ));
 
-    it('Should query attributes with spaces in their values', () => {
-      const wrapper = shallow((
-        <div>
-          <h1 data-foo="foo bar">Hello</h1>
-          <h1 data-foo="bar baz quz">World</h1>
-        </div>
-      ));
-      expect(wrapper.find('[data-foo]')).to.have.lengthOf(2);
-      expect(wrapper.find('[data-foo="foo bar"]')).to.have.lengthOf(1);
-      expect(wrapper.find('[data-foo="bar baz quz"]')).to.have.lengthOf(1);
-      expect(wrapper.find('[data-foo="bar baz"]')).to.have.lengthOf(0);
-      expect(wrapper.find('[data-foo="foo  bar"]')).to.have.lengthOf(0);
-      expect(wrapper.find('[data-foo="bar  baz quz"]')).to.have.lengthOf(0);
-    });
+        expect(wrapper.find('div[ref="foo"]')).to.have.lengthOf(0);
+        expect(wrapper.find('div[key="1"]')).to.have.lengthOf(0);
+        expect(wrapper.find('[ref]')).to.have.lengthOf(0);
+        expect(wrapper.find('[key]')).to.have.lengthOf(0);
+      });
 
-    describeIf(is('> 0.13'), 'stateless function components', () => {
-      it('should find a component based on a constructor', () => {
-        const Foo = () => (
-          <div />
-        );
+      it('should find multiple elements based on a constructor', () => {
         const wrapper = shallow((
           <div>
-            <Foo className="foo" />
+            <input className="foo" />
+            <input />
+            <button />
           </div>
         ));
-        expect(wrapper.find(Foo).type()).to.equal(Foo);
+        expect(wrapper.find('input')).to.have.lengthOf(2);
+        expect(wrapper.find('button')).to.have.lengthOf(1);
       });
 
-      it('should find a component based on a display name', () => {
-        const Foo = () => (
-          <div />
-        );
+      it('should support object property selectors', () => {
         const wrapper = shallow((
           <div>
-            <Foo className="foo" />
+            <input data-test="ref" className="foo" type="text" />
+            <input data-test="ref" type="text" />
+            <button data-test="ref" prop={undefined} />
+            <span data-test="ref" prop={null} />
+            <div data-test="ref" prop={123} />
+            <input data-test="ref" prop={false} />
+            <a data-test="ref" prop />
           </div>
         ));
-        expect(wrapper.find('Foo').type()).to.equal(Foo);
+        expect(wrapper.find({ a: 1 })).to.have.lengthOf(0);
+        expect(wrapper.find({ 'data-test': 'ref' })).to.have.lengthOf(7);
+        expect(wrapper.find({ className: 'foo' })).to.have.lengthOf(1);
+        expect(wrapper.find({ prop: null })).to.have.lengthOf(1);
+        expect(wrapper.find({ prop: 123 })).to.have.lengthOf(1);
+        expect(wrapper.find({ prop: false })).to.have.lengthOf(1);
+        expect(wrapper.find({ prop: true })).to.have.lengthOf(1);
       });
-    });
 
-    describe('works with attribute selectors containing #', () => {
-      let wrapper;
-      beforeEach(() => {
-        wrapper = shallow((
+      it('should support complex and nested object property selectors', () => {
+        const testFunction = () => ({});
+        const wrapper = shallow((
           <div>
-            <a id="test" href="/page">Hello</a>
-            <a href="/page#anchor">World</a>
+            <span more={[{ id: 1 }]} data-test="ref" prop onChange={testFunction} />
+            <a more={[{ id: 1 }]} data-test="ref" />
+            <div more={{ item: { id: 1 } }} data-test="ref" />
+            <input style={{ height: 20 }} data-test="ref" />
           </div>
         ));
+        expect(wrapper.find({ 'data-test': 'ref' })).to.have.lengthOf(4);
+        expect(wrapper.find({ more: { a: 1 } })).to.have.lengthOf(0);
+        expect(wrapper.find({ more: [{ id: 1 }] })).to.have.lengthOf(2);
+        expect(wrapper.find({ more: { item: { id: 1 } } })).to.have.lengthOf(1);
+        expect(wrapper.find({ style: { height: 20 } })).to.have.lengthOf(1);
+        expect(wrapper.find({
+          more: [{ id: 1 }],
+          'data-test': 'ref',
+          prop: true,
+          onChange: testFunction,
+        })).to.have.lengthOf(1);
       });
 
-      it('works with an ID', () => {
-        expect(wrapper.find('a#test')).to.have.lengthOf(1);
+      it('should throw when given empty object, null, or an array', () => {
+        const wrapper = shallow((
+          <div>
+            <input className="foo" type="text" />
+          </div>
+        ));
+        expect(() => wrapper.find({})).to.throw(
+          TypeError,
+          'Enzyme::Selector does not support an array, null, or empty object as a selector',
+        );
+        expect(() => wrapper.find([])).to.throw(
+          TypeError,
+          'Enzyme::Selector does not support an array, null, or empty object as a selector',
+        );
+        expect(() => wrapper.find(null)).to.throw(
+          TypeError,
+          'Enzyme::Selector does not support an array, null, or empty object as a selector',
+        );
       });
 
-      it('works with a normal attribute', () => {
-        expect(wrapper.find('a[href="/page"]')).to.have.lengthOf(1);
+      it('Should query attributes with spaces in their values', () => {
+        const wrapper = shallow((
+          <div>
+            <h1 data-foo="foo bar">Hello</h1>
+            <h1 data-foo="bar baz quz">World</h1>
+          </div>
+        ));
+        expect(wrapper.find('[data-foo]')).to.have.lengthOf(2);
+        expect(wrapper.find('[data-foo="foo bar"]')).to.have.lengthOf(1);
+        expect(wrapper.find('[data-foo="bar baz quz"]')).to.have.lengthOf(1);
+        expect(wrapper.find('[data-foo="bar baz"]')).to.have.lengthOf(0);
+        expect(wrapper.find('[data-foo="foo  bar"]')).to.have.lengthOf(0);
+        expect(wrapper.find('[data-foo="bar  baz quz"]')).to.have.lengthOf(0);
       });
 
-      it('works with an attribute with a #', () => {
-        expect(wrapper.find('a[href="/page#anchor"]')).to.have.lengthOf(1);
+      describeIf(is('> 0.13'), 'stateless function components', () => {
+        it('should find a component based on a constructor', () => {
+          const Foo = () => (
+            <div />
+          );
+          const wrapper = shallow((
+            <div>
+              <Foo className="foo" />
+            </div>
+          ));
+          expect(wrapper.find(Foo).type()).to.equal(Foo);
+        });
+
+        it('should find a component based on a display name', () => {
+          const Foo = () => (
+            <div />
+          );
+          const wrapper = shallow((
+            <div>
+              <Foo className="foo" />
+            </div>
+          ));
+          expect(wrapper.find('Foo').type()).to.equal(Foo);
+        });
       });
-    });
 
-    describe('works with data- attributes', () => {
-      class Foo extends React.Component {
-        render() {
-          return (
+      describe('works with attribute selectors containing #', () => {
+        let wrapper;
+        beforeEach(() => {
+          wrapper = shallow((
             <div>
-              <i className="ficon ficon-12 some-icon" />
-              <span className="custom class">
-                <i className="ficon ficon-book ficon-24" data-custom-tag="bookIcon" />
-                <i className="ficon ficon-book ficon-24" data-custom-tag="bookIcon" />
-              </span>
+              <a id="test" href="/page">Hello</a>
+              <a href="/page#anchor">World</a>
             </div>
-          );
+          ));
+        });
+
+        it('works with an ID', () => {
+          expect(wrapper.find('a#test')).to.have.lengthOf(1);
+        });
+
+        it('works with a normal attribute', () => {
+          expect(wrapper.find('a[href="/page"]')).to.have.lengthOf(1);
+        });
+
+        it('works with an attribute with a #', () => {
+          expect(wrapper.find('a[href="/page#anchor"]')).to.have.lengthOf(1);
+        });
+      });
+
+      describe('works with data- attributes', () => {
+        class Foo extends React.Component {
+          render() {
+            return (
+              <div>
+                <i className="ficon ficon-12 some-icon" />
+                <span className="custom class">
+                  <i className="ficon ficon-book ficon-24" data-custom-tag="bookIcon" />
+                  <i className="ficon ficon-book ficon-24" data-custom-tag="bookIcon" />
+                </span>
+              </div>
+            );
+          }
         }
-      }
 
-      it('finds elements by data attribute', () => {
-        const wrapper = shallow(<Foo />);
-        expect(wrapper.html()).to.contain('data-custom-tag="bookIcon"'); // sanity check
-        const elements = wrapper.find('[data-custom-tag="bookIcon"]');
-        expect(elements).to.have.lengthOf(2);
-        expect(elements.filter('i')).to.have.lengthOf(2);
+        it('finds elements by data attribute', () => {
+          const wrapper = shallow(<Foo />);
+          expect(wrapper.html()).to.contain('data-custom-tag="bookIcon"'); // sanity check
+          const elements = wrapper.find('[data-custom-tag="bookIcon"]');
+          expect(elements).to.have.lengthOf(2);
+          expect(elements.filter('i')).to.have.lengthOf(2);
+        });
       });
     });
-  });
 
   describe('.findWhere(predicate)', () => {
     it('should return all elements for a truthy test', () => {
@@ -4855,91 +4881,114 @@ describe('shallow', () => {
     });
   });
 
-  describe('.name()', () => {
-    describe('node with displayName', () => {
-      it('should return the displayName of the node', () => {
-        class Foo extends React.Component {
-          render() { return <div />; }
-        }
-
-        class Wrapper extends React.Component {
-          render() { return <Foo />; }
-        }
-
-        Foo.displayName = 'CustomWrapper';
-
-        const wrapper = shallow(<Wrapper />);
-        expect(wrapper.name()).to.equal('CustomWrapper');
-      });
+  wrap()
+    .withOverride(() => getAdapter(), 'displayNameOfNode', () => undefined)
+    .describe('.name()', () => {
+      describe('node with displayName', () => {
+        it('should return the displayName of the node', () => {
+          class Foo extends React.Component {
+            render() { return <div />; }
+          }
 
-      describeIf(is('> 0.13'), 'stateless function components', () => {
-        it('should return the name of the node', () => {
-          function SFC() {
-            return <div />;
+          class Wrapper extends React.Component {
+            render() { return <Foo />; }
           }
-          const Wrapper = () => <SFC />;
 
-          SFC.displayName = 'CustomWrapper';
+          Foo.displayName = 'CustomWrapper';
 
           const wrapper = shallow(<Wrapper />);
           expect(wrapper.name()).to.equal('CustomWrapper');
         });
-      });
 
-      describe('createClass', () => {
-        it('should return the name of the node', () => {
-          const Foo = createClass({
-            displayName: 'CustomWrapper',
-            render() {
+        describeIf(is('> 0.13'), 'stateless function components', () => {
+          it('should return the name of the node', () => {
+            function SFC() {
               return <div />;
-            },
-          });
-          const Wrapper = createClass({
-            render() {
-              return <Foo />;
-            },
+            }
+            const Wrapper = () => <SFC />;
+
+            SFC.displayName = 'CustomWrapper';
+
+            const wrapper = shallow(<Wrapper />);
+            expect(wrapper.name()).to.equal('CustomWrapper');
           });
+        });
 
-          const wrapper = shallow(<Wrapper />);
-          expect(wrapper.name()).to.equal('CustomWrapper');
+        describe('createClass', () => {
+          it('should return the name of the node', () => {
+            const Foo = createClass({
+              displayName: 'CustomWrapper',
+              render() {
+                return <div />;
+              },
+            });
+            const Wrapper = createClass({
+              render() {
+                return <Foo />;
+              },
+            });
+
+            const wrapper = shallow(<Wrapper />);
+            expect(wrapper.name()).to.equal('CustomWrapper');
+          });
         });
-      });
-    });
 
-    describe('node without displayName', () => {
-      it('should return the name of the node', () => {
-        class Foo extends React.Component {
-          render() { return <div />; }
-        }
+        wrap()
+          .withOverride(() => getAdapter(), 'displayNameOfNode', () => sinon.stub())
+          .describe('adapter has `displayNameOfNode`', () => {
+            it('delegates to the adapter’s `displayNameOfNode`', () => {
+              class Foo extends React.Component {
+                render() { return <div />; }
+              }
+              const stub = getAdapter().displayNameOfNode;
+              const sentinel = {};
+              stub.returns(sentinel);
 
-        class Wrapper extends React.Component {
-          render() { return <Foo />; }
-        }
+              const wrapper = shallow(<Foo />);
 
-        const wrapper = shallow(<Wrapper />);
-        expect(wrapper.name()).to.equal('Foo');
+              expect(wrapper.name()).to.equal(sentinel);
+
+              expect(stub).to.have.property('callCount', 1);
+              const { args } = stub.firstCall;
+              expect(args).to.eql([wrapper.getNodeInternal()]);
+            });
+          });
       });
 
-      describeIf(is('> 0.13'), 'stateless function components', () => {
+      describe('node without displayName', () => {
         it('should return the name of the node', () => {
-          function SFC() {
-            return <div />;
+          class Foo extends React.Component {
+            render() { return <div />; }
+          }
+
+          class Wrapper extends React.Component {
+            render() { return <Foo />; }
           }
-          const Wrapper = () => <SFC />;
 
           const wrapper = shallow(<Wrapper />);
-          expect(wrapper.name()).to.equal('SFC');
+          expect(wrapper.name()).to.equal('Foo');
+        });
+
+        describeIf(is('> 0.13'), 'stateless function components', () => {
+          it('should return the name of the node', () => {
+            function SFC() {
+              return <div />;
+            }
+            const Wrapper = () => <SFC />;
+
+            const wrapper = shallow(<Wrapper />);
+            expect(wrapper.name()).to.equal('SFC');
+          });
         });
       });
-    });
 
-    describe('DOM node', () => {
-      it('should return the name of the node', () => {
-        const wrapper = shallow(<div />);
-        expect(wrapper.name()).to.equal('div');
+      describe('DOM node', () => {
+        it('should return the name of the node', () => {
+          const wrapper = shallow(<div />);
+          expect(wrapper.name()).to.equal('div');
+        });
       });
     });
-  });
 
   describe('.dive()', () => {
     class RendersDOM extends React.Component {
diff --git a/packages/enzyme-test-suite/test/Utils-spec.jsx b/packages/enzyme-test-suite/test/Utils-spec.jsx
index f940a108e..01b962659 100644
--- a/packages/enzyme-test-suite/test/Utils-spec.jsx
+++ b/packages/enzyme-test-suite/test/Utils-spec.jsx
@@ -1,5 +1,7 @@
 import React from 'react';
 import { expect } from 'chai';
+import wrap from 'mocha-wrap';
+import sinon from 'sinon';
 import {
   childrenToSimplifiedArray,
   nodeEqual,
@@ -7,6 +9,7 @@ import {
   displayNameOfNode,
   spyMethod,
   nodeHasType,
+  getAdapter,
 } from 'enzyme/build/Utils';
 import {
   flatten,
@@ -616,56 +619,84 @@ describe('Utils', () => {
     });
   });
 
-  describe('nodeHasType', () => {
-    it('is `false` if either argument is falsy', () => {
-      expect(nodeHasType(null, {})).to.equal(false);
-      expect(nodeHasType({}, null)).to.equal(false);
-    });
-
-    it('is `false` if `node` has a falsy `type`', () => {
-      expect(nodeHasType({}, {})).to.equal(false);
-      expect(nodeHasType({ type: null }, {})).to.equal(false);
-      expect(nodeHasType({ type: false }, {})).to.equal(false);
-      expect(nodeHasType({ type: '' }, {})).to.equal(false);
-      expect(nodeHasType({ type: 0 }, {})).to.equal(false);
-    });
-
-    it('compares `node.type` to `type` when `node.type` is a non-empty string', () => {
-      expect(nodeHasType({ type: 'foo' }, 'foo')).to.equal(true);
-      expect(nodeHasType({ type: 'foo' }, 'bar')).to.equal(false);
-    });
+  wrap()
+    .withOverride(() => getAdapter(), 'displayNameOfNode', () => undefined)
+    .describe('nodeHasType', () => {
+      it('is `false` if either argument is falsy', () => {
+        expect(nodeHasType(null, {})).to.equal(false);
+        expect(nodeHasType({}, null)).to.equal(false);
+      });
 
-    describe('when only `node.type.displayName` matches `type`', () => {
-      const x = {};
-      it('is `true` when `node.type` is an object', () => {
-        expect(nodeHasType(
-          { type: { displayName: x } },
-          x,
-        )).to.equal(true);
+      it('is `false` if `node` has a falsy `type`', () => {
+        expect(nodeHasType({}, {})).to.equal(false);
+        expect(nodeHasType({ type: null }, {})).to.equal(false);
+        expect(nodeHasType({ type: false }, {})).to.equal(false);
+        expect(nodeHasType({ type: '' }, {})).to.equal(false);
+        expect(nodeHasType({ type: 0 }, {})).to.equal(false);
       });
 
-      it('is `true` when `node.type` is a function', () => {
-        expect(nodeHasType(
-          { type: Object.assign(() => {}, { displayName: x }) },
-          x,
-        )).to.equal(true);
+      it('compares `node.type` to `type` when `node.type` is a non-empty string', () => {
+        expect(nodeHasType({ type: 'foo' }, 'foo')).to.equal(true);
+        expect(nodeHasType({ type: 'foo' }, 'bar')).to.equal(false);
       });
-    });
 
-    describe('when only `node.type.name` matches `type`', () => {
-      const x = {};
-      it('is `true` when `node.type` is an object', () => {
-        expect(nodeHasType(
-          { type: { name: x } },
-          x,
-        )).to.equal(true);
+      describe('when only `node.type.displayName` matches `type`', () => {
+        const x = {};
+        it('is `true` when `node.type` is an object', () => {
+          expect(nodeHasType(
+            { type: { displayName: x } },
+            x,
+          )).to.equal(true);
+        });
+
+        it('is `true` when `node.type` is a function', () => {
+          expect(nodeHasType(
+            { type: Object.assign(() => {}, { displayName: x }) },
+            x,
+          )).to.equal(true);
+        });
       });
 
-      it('is `true` when `node.type` is a function', () => {
-        function namedType() {}
+      describe('when only `node.type.name` matches `type`', () => {
+        const x = {};
+        it('is `true` when `node.type` is an object', () => {
+          expect(nodeHasType(
+            { type: { name: x } },
+            x,
+          )).to.equal(true);
+        });
+
+        it('is `true` when `node.type` is a function', () => {
+          function namedType() {}
 
-        expect(nodeHasType({ type: namedType }, 'namedType')).to.equal(true);
+          expect(nodeHasType({ type: namedType }, 'namedType')).to.equal(true);
+        });
       });
+
+      wrap()
+        .withOverride(() => getAdapter(), 'displayNameOfNode', () => sinon.stub())
+        .describe('when the adapter has a `displayNameOfNode` function', () => {
+          it('is `true` when `displayNameOfNode` matches `type`', () => {
+            const stub = getAdapter().displayNameOfNode;
+            const sentinel = {};
+            stub.returns(sentinel);
+
+            const node = {};
+            expect(nodeHasType(node, sentinel)).to.equal(true);
+
+            expect(stub).to.have.property('callCount', 1);
+            const { args } = stub.firstCall;
+            expect(args).to.eql([node]);
+          });
+
+          it('is `false` when `displayNameOfNode` does not match `type`', () => {
+            const stub = getAdapter().displayNameOfNode;
+            const sentinel = {};
+            stub.returns(sentinel);
+
+            const node = {};
+            expect(nodeHasType(node, {})).to.equal(false);
+          });
+        });
     });
-  });
 });
diff --git a/packages/enzyme-test-suite/test/_helpers/react-compat.js b/packages/enzyme-test-suite/test/_helpers/react-compat.js
index a63fbc15a..ee59c1cd6 100644
--- a/packages/enzyme-test-suite/test/_helpers/react-compat.js
+++ b/packages/enzyme-test-suite/test/_helpers/react-compat.js
@@ -10,6 +10,11 @@ let createClass;
 let renderToString;
 let createPortal;
 let createContext;
+let forwardRef;
+let Fragment;
+let StrictMode;
+let AsyncMode;
+let Profiler;
 
 if (is('>=15.5 || ^16.0.0-alpha || ^16.3.0-alpha')) {
   // eslint-disable-next-line import/no-extraneous-dependencies
@@ -31,10 +36,32 @@ if (is('^16.0.0-alpha || ^16.3.0-alpha')) {
   createPortal = null;
 }
 
+if (is('^16.2.0-0')) {
+  ({ Fragment } = require('react'));
+} else {
+  Fragment = null;
+}
+
 if (is('^16.3.0-0')) {
-  ({ createContext } = require('react'));
+  ({
+    createContext,
+    forwardRef,
+    StrictMode,
+    unstable_AsyncMode: AsyncMode,
+  } = require('react'));
 } else {
   createContext = null;
+  forwardRef = null;
+  StrictMode = null;
+  AsyncMode = null;
+}
+
+if (is('^16.4.0-0')) {
+  ({
+    unstable_Profiler: Profiler,
+  } = require('react'));
+} else {
+  Profiler = null;
 }
 
 export {
@@ -42,4 +69,9 @@ export {
   renderToString,
   createPortal,
   createContext,
+  forwardRef,
+  Fragment,
+  StrictMode,
+  AsyncMode,
+  Profiler,
 };
diff --git a/packages/enzyme-test-suite/test/adapter-utils-spec.jsx b/packages/enzyme-test-suite/test/adapter-utils-spec.jsx
index d22870794..782325f04 100644
--- a/packages/enzyme-test-suite/test/adapter-utils-spec.jsx
+++ b/packages/enzyme-test-suite/test/adapter-utils-spec.jsx
@@ -1,5 +1,13 @@
+import React from 'react';
 import { expect } from 'chai';
-import { ensureKeyOrUndefined } from 'enzyme-adapter-utils';
+import {
+  displayNameOfNode,
+  ensureKeyOrUndefined,
+} from 'enzyme-adapter-utils';
+
+import './_helpers/setupAdapters';
+import { describeIf } from './_helpers';
+import { is } from './_helpers/version';
 
 describe('enzyme-adapter-utils', () => {
   describe('ensureKeyOrUndefined', () => {
@@ -19,4 +27,59 @@ describe('enzyme-adapter-utils', () => {
       });
     });
   });
+
+  describe('displayNameOfNode', () => {
+    describe('given a node with displayName', () => {
+      it('should return the displayName', () => {
+        class Foo extends React.Component {
+          render() { return <div />; }
+        }
+
+        Foo.displayName = 'CustomWrapper';
+
+        expect(displayNameOfNode(<Foo />)).to.equal('CustomWrapper');
+      });
+
+      describeIf(is('> 0.13'), 'stateless function components', () => {
+        it('should return the displayName', () => {
+          const Foo = () => <div />;
+          Foo.displayName = 'CustomWrapper';
+
+          expect(displayNameOfNode(<Foo />)).to.equal('CustomWrapper');
+        });
+      });
+    });
+
+    describe('given a node without displayName', () => {
+      it('should return the name', () => {
+        class Foo extends React.Component {
+          render() { return <div />; }
+        }
+
+        expect(displayNameOfNode(<Foo />)).to.equal('Foo');
+      });
+
+      it('should return the name even if it is falsy', () => {
+        const makeFoo = () => () => <div />;
+
+        const Foo = makeFoo();
+
+        expect(displayNameOfNode(<Foo />)).to.equal('');
+      });
+
+      describeIf(is('> 0.13'), 'stateless function components', () => {
+        it('should return the name', () => {
+          const Foo = () => <div />;
+
+          expect(displayNameOfNode(<Foo />)).to.equal('Foo');
+        });
+      });
+    });
+
+    describe('given a DOM node', () => {
+      it('should return the type', () => {
+        expect(displayNameOfNode(<div />)).to.equal('div');
+      });
+    });
+  });
 });
diff --git a/packages/enzyme/src/Debug.js b/packages/enzyme/src/Debug.js
index 0d5974e84..83d5bfa1f 100644
--- a/packages/enzyme/src/Debug.js
+++ b/packages/enzyme/src/Debug.js
@@ -12,10 +12,15 @@ import {
   propsOfNode,
   childrenOfNode,
 } from './RSTTraversal';
+import { getAdapter } from './Utils';
 
 const booleanValue = Function.bind.call(Function.call, Boolean.prototype.valueOf);
 
 export function typeName(node) {
+  const adapter = getAdapter();
+  if (adapter.displayNameOfNode) {
+    return getAdapter().displayNameOfNode(node) || 'Component';
+  }
   return typeof node.type === 'function'
     ? (node.type.displayName || functionName(node.type) || 'Component')
     : node.type;
diff --git a/packages/enzyme/src/ReactWrapper.js b/packages/enzyme/src/ReactWrapper.js
index 21a54a4ca..a61184149 100644
--- a/packages/enzyme/src/ReactWrapper.js
+++ b/packages/enzyme/src/ReactWrapper.js
@@ -731,7 +731,10 @@ class ReactWrapper {
    * @returns {String}
    */
   name() {
-    return this.single('name', n => displayNameOfNode(n));
+    const adapter = getAdapter(this[OPTIONS]);
+    return this.single('name', n => (
+      adapter.displayNameOfNode ? adapter.displayNameOfNode(n) : displayNameOfNode(n)
+    ));
   }
 
   /**
diff --git a/packages/enzyme/src/ShallowWrapper.js b/packages/enzyme/src/ShallowWrapper.js
index 77324b031..c6602a514 100644
--- a/packages/enzyme/src/ShallowWrapper.js
+++ b/packages/enzyme/src/ShallowWrapper.js
@@ -933,7 +933,10 @@ class ShallowWrapper {
    * @returns {String}
    */
   name() {
-    return this.single('name', n => displayNameOfNode(n));
+    const adapter = getAdapter(this[OPTIONS]);
+    return this.single('name', n => (
+      adapter.displayNameOfNode ? adapter.displayNameOfNode(n) : displayNameOfNode(n)
+    ));
   }
 
   /**
diff --git a/packages/enzyme/src/Utils.js b/packages/enzyme/src/Utils.js
index f53430995..3ec746cf8 100644
--- a/packages/enzyme/src/Utils.js
+++ b/packages/enzyme/src/Utils.js
@@ -61,6 +61,13 @@ export function typeOfNode(node) {
 
 export function nodeHasType(node, type) {
   if (!type || !node) return false;
+
+  const adapter = getAdapter();
+  if (adapter.displayNameOfNode) {
+    const displayName = adapter.displayNameOfNode(node);
+    return displayName === type;
+  }
+
   if (!node.type) return false;
   if (typeof node.type === 'string') return node.type === type;
   return (
diff --git a/packages/enzyme/src/selectors.js b/packages/enzyme/src/selectors.js
index 8cb98737f..096a6c69b 100644
--- a/packages/enzyme/src/selectors.js
+++ b/packages/enzyme/src/selectors.js
@@ -13,7 +13,7 @@ import {
   childrenOfNode,
   hasClassName,
 } from './RSTTraversal';
-import { nodeHasType, propsOfNode } from './Utils';
+import { getAdapter, nodeHasType, propsOfNode } from './Utils';
 // our CSS selector parser instance
 const parser = createParser();
 
@@ -239,8 +239,22 @@ function isComplexSelector(tokens) {
  * @param {Function|Object|String} selector
  */
 export function buildPredicate(selector) {
-  // If the selector is a function, check if the node's constructor matches
-  if (typeof selector === 'function') {
+  // If the selector is a string, parse it as a simple CSS selector
+  if (typeof selector === 'string') {
+    const tokens = safelyGenerateTokens(selector);
+    if (isComplexSelector(tokens)) {
+      throw new TypeError('This method does not support complex CSS selectors');
+    }
+    // Simple selectors only have a single selector token
+    return buildPredicateFromToken(tokens[0]);
+  }
+
+  // If the selector is an element type, check if the node's type matches
+  const adapter = getAdapter();
+  const isElementType = adapter.isValidElementType
+    ? adapter.isValidElementType(selector)
+    : typeof selector === 'function';
+  if (isElementType) {
     return node => node && node.type === selector;
   }
   // If the selector is an non-empty object, treat the keys/values as props
@@ -254,16 +268,8 @@ export function buildPredicate(selector) {
     }
     throw new TypeError('Enzyme::Selector does not support an array, null, or empty object as a selector');
   }
-  // If the selector is a string, parse it as a simple CSS selector
-  if (typeof selector === 'string') {
-    const tokens = safelyGenerateTokens(selector);
-    if (isComplexSelector(tokens)) {
-      throw new TypeError('This method does not support complex CSS selectors');
-    }
-    // Simple selectors only have a single selector token
-    return buildPredicateFromToken(tokens[0]);
-  }
-  throw new TypeError('Enzyme::Selector expects a string, object, or Component Constructor');
+
+  throw new TypeError('Enzyme::Selector expects a string, object, or valid element type (Component Constructor)');
 }
 
 /**