diff --git a/packages/material-ui-lab/src/ToggleButton/ToggleButton.test.js b/packages/material-ui-lab/src/ToggleButton/ToggleButton.test.js
index 07a1e2ec07dce9..0312756c0e38fa 100644
--- a/packages/material-ui-lab/src/ToggleButton/ToggleButton.test.js
+++ b/packages/material-ui-lab/src/ToggleButton/ToggleButton.test.js
@@ -22,6 +22,10 @@ describe('<ToggleButton />', () => {
     classes = getClasses(<ToggleButton value="classes">Hello World</ToggleButton>);
   });
 
+  after(() => {
+    mount.cleanUp();
+  });
+
   it('does forward refs', () => {
     testRef(<ToggleButton value="classes">Hello World</ToggleButton>, mount);
   });
diff --git a/packages/material-ui-lab/src/ToggleButtonGroup/ToggleButtonGroup.test.js b/packages/material-ui-lab/src/ToggleButtonGroup/ToggleButtonGroup.test.js
index 2ea1e6cf896576..c45be141e16b85 100644
--- a/packages/material-ui-lab/src/ToggleButtonGroup/ToggleButtonGroup.test.js
+++ b/packages/material-ui-lab/src/ToggleButtonGroup/ToggleButtonGroup.test.js
@@ -23,6 +23,10 @@ describe('<ToggleButtonGroup />', () => {
     );
   });
 
+  after(() => {
+    mount.cleanUp();
+  });
+
   function findToggleButton(wrapper, value) {
     return wrapper
       .find(ToggleButton)
diff --git a/packages/material-ui/src/AppBar/AppBar.test.js b/packages/material-ui/src/AppBar/AppBar.test.js
index 14aeed85046ea2..d131f4268b2e1a 100644
--- a/packages/material-ui/src/AppBar/AppBar.test.js
+++ b/packages/material-ui/src/AppBar/AppBar.test.js
@@ -1,22 +1,37 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import AppBar from './AppBar';
+import Paper from '../Paper';
 
 describe('<AppBar />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<AppBar>Hello World</AppBar>);
   });
 
-  it('should render a Paper component', () => {
-    const wrapper = shallow(<AppBar>Hello World</AppBar>);
-    assert.strictEqual(wrapper.props().elevation, 4);
+  after(() => {
+    mount.cleanUp();
   });
 
+  describeConformance(<AppBar>Conformance?</AppBar>, () => ({
+    classes,
+    inheritComponent: Paper,
+    mount,
+    refInstanceof: window.HTMLElement,
+    testComponentPropWith: false,
+  }));
+
   it('should render with the root class and primary', () => {
     const wrapper = shallow(<AppBar>Hello World</AppBar>);
     assert.strictEqual(wrapper.hasClass(classes.root), true);
@@ -24,13 +39,6 @@ describe('<AppBar />', () => {
     assert.strictEqual(wrapper.hasClass(classes.colorSecondary), false);
   });
 
-  it('should render the custom className and the appBar class', () => {
-    const wrapper = shallow(<AppBar className="test-class-name">Hello World</AppBar>);
-    assert.strictEqual(wrapper.is('.test-class-name'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-    assert.strictEqual(wrapper.hasClass(classes.colorPrimary), true);
-  });
-
   it('should render a primary app bar', () => {
     const wrapper = shallow(<AppBar color="primary">Hello World</AppBar>);
     assert.strictEqual(wrapper.hasClass(classes.root), true);
diff --git a/packages/material-ui/src/Avatar/Avatar.test.js b/packages/material-ui/src/Avatar/Avatar.test.js
index 8bc00d9866b51f..2b83725f73f737 100644
--- a/packages/material-ui/src/Avatar/Avatar.test.js
+++ b/packages/material-ui/src/Avatar/Avatar.test.js
@@ -1,18 +1,37 @@
 import React from 'react';
 import { assert } from 'chai';
 import CancelIcon from '../internal/svg-icons/Cancel';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Avatar from './Avatar';
 
 describe('<Avatar />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<Avatar />);
   });
 
+  after(() => {
+    mount.cleanUp();
+  });
+
+  describeConformance(<Avatar />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: 'span',
+  }));
+
   describe('image avatar', () => {
     it('should render a div containing an img', () => {
       const wrapper = shallow(
diff --git a/packages/material-ui/src/Badge/Badge.test.js b/packages/material-ui/src/Badge/Badge.test.js
index 89ed1ef2d2bd24..895ec9cf79c503 100644
--- a/packages/material-ui/src/Badge/Badge.test.js
+++ b/packages/material-ui/src/Badge/Badge.test.js
@@ -1,17 +1,41 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Badge from './Badge';
 
 describe('<Badge />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<Badge badgeContent={1}>Hello World</Badge>);
   });
 
+  after(() => {
+    mount.cleanUp();
+  });
+
+  describeConformance(
+    <Badge>
+      <div />
+    </Badge>,
+    () => ({
+      classes,
+      inheritComponent: 'span',
+      mount,
+      refInstanceof: window.HTMLSpanElement,
+      testComponentPropWith: 'div',
+    }),
+  );
+
   const testChildren = <div className="unique">Hello World</div>;
 
   it('renders children and badgeContent', () => {
diff --git a/packages/material-ui/src/BottomNavigation/BottomNavigation.test.js b/packages/material-ui/src/BottomNavigation/BottomNavigation.test.js
index 53a7b06c1ba974..129ed50ba8de51 100755
--- a/packages/material-ui/src/BottomNavigation/BottomNavigation.test.js
+++ b/packages/material-ui/src/BottomNavigation/BottomNavigation.test.js
@@ -1,7 +1,12 @@
 import React from 'react';
 import { assert } from 'chai';
 import { spy } from 'sinon';
-import { createShallow, createMount, getClasses } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  createMount,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import BottomNavigationAction from '../BottomNavigationAction';
 import Icon from '../Icon';
 import BottomNavigation from './BottomNavigation';
@@ -26,6 +31,19 @@ describe('<BottomNavigation />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(
+    <BottomNavigation>
+      <BottomNavigationAction label="One" />
+    </BottomNavigation>,
+    () => ({
+      classes,
+      inheritComponent: 'div',
+      mount,
+      refInstanceof: window.HTMLDivElement,
+      testComponentPropWith: 'span',
+    }),
+  );
+
   it('renders with a null child', () => {
     const wrapper = shallow(
       <BottomNavigation showLabels value={0}>
@@ -37,26 +55,6 @@ describe('<BottomNavigation />', () => {
     assert.strictEqual(wrapper.find(BottomNavigationAction).length, 2);
   });
 
-  it('should render with the root class', () => {
-    const wrapper = shallow(
-      <BottomNavigation showLabels value={0}>
-        <BottomNavigationAction icon={icon} />
-      </BottomNavigation>,
-    );
-    assert.strictEqual(wrapper.name(), 'div');
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
-
-  it('should render with the user and root classes', () => {
-    const wrapper = shallow(
-      <BottomNavigation showLabels value={0} className="woofBottomNavigation">
-        <BottomNavigationAction icon={icon} />
-      </BottomNavigation>,
-    );
-    assert.strictEqual(wrapper.hasClass('woofBottomNavigation'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
-
   it('should pass selected prop to children', () => {
     const wrapper = shallow(
       <BottomNavigation showLabels value={1}>
diff --git a/packages/material-ui/src/BottomNavigationAction/BottomNavigationAction.test.js b/packages/material-ui/src/BottomNavigationAction/BottomNavigationAction.test.js
index f78228b7e271ac..f02989e9b39263 100644
--- a/packages/material-ui/src/BottomNavigationAction/BottomNavigationAction.test.js
+++ b/packages/material-ui/src/BottomNavigationAction/BottomNavigationAction.test.js
@@ -1,7 +1,12 @@
 import React from 'react';
 import { assert } from 'chai';
 import { spy } from 'sinon';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  describeConformance,
+  findOutermostIntrinsic,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import ButtonBase from '../ButtonBase';
 import Icon from '../Icon';
 import BottomNavigationAction from './BottomNavigationAction';
@@ -16,21 +21,17 @@ describe('<BottomNavigationAction />', () => {
     classes = getClasses(<BottomNavigationAction />);
   });
 
-  it('should render a ButtonBase', () => {
-    const wrapper = mount(<BottomNavigationAction icon={icon} />);
-    const root = wrapper.find(`.${classes.root}`).first();
-    assert.strictEqual(root.exists(), true);
-    assert.strictEqual(root.type(), ButtonBase);
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should render with the user and root classes', () => {
-    const wrapper = mount(
-      <BottomNavigationAction className="woofBottomNavigationAction" icon={icon} />,
-    );
-    const root = wrapper.find(`.${classes.root}.woofBottomNavigationAction`).first();
-    assert.strictEqual(root.exists(), true);
-    assert.strictEqual(root.hasClass('woofBottomNavigationAction'), true);
-  });
+  describeConformance(<BottomNavigationAction />, () => ({
+    classes,
+    inheritComponent: ButtonBase,
+    mount,
+    refInstanceof: window.HTMLButtonElement,
+    testComponentPropWith: false,
+  }));
 
   it('should render with the selected and root classes', () => {
     const wrapper = mount(<BottomNavigationAction icon={icon} selected />);
diff --git a/packages/material-ui/src/Breadcrumbs/Breadcrumbs.test.js b/packages/material-ui/src/Breadcrumbs/Breadcrumbs.test.js
index b6ba59bc365e50..45cd9310bfe852 100644
--- a/packages/material-ui/src/Breadcrumbs/Breadcrumbs.test.js
+++ b/packages/material-ui/src/Breadcrumbs/Breadcrumbs.test.js
@@ -1,6 +1,6 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createMount, getClasses, findOutermostIntrinsic } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import Breadcrumbs from './Breadcrumbs';
 import BreadcrumbSeparator from './BreadcrumbSeparator';
 import BreadcrumbCollapsed from './BreadcrumbCollapsed';
@@ -23,33 +23,13 @@ describe('<Breadcrumbs />', () => {
     mount.cleanUp();
   });
 
-  it('should render a <nav> element', () => {
-    const wrapper = mount(
-      <Breadcrumbs>
-        <span>Hello World</span>
-      </Breadcrumbs>,
-    );
-    assert.strictEqual(findOutermostIntrinsic(wrapper).type(), 'nav');
-  });
-
-  it('should render the root class', () => {
-    const wrapper = mount(
-      <Breadcrumbs className="test-class-name">
-        <span>Hello World</span>
-      </Breadcrumbs>,
-    );
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.root), true);
-  });
-
-  it('should render the custom className and the root class', () => {
-    const wrapper = mount(
-      <Breadcrumbs className="test-class-name">
-        <span>Hello World</span>
-      </Breadcrumbs>,
-    );
-    assert.strictEqual(findOutermostIntrinsic(wrapper).is('.test-class-name'), true);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.root), true);
-  });
+  describeConformance(<Breadcrumbs>Conformance?</Breadcrumbs>, () => ({
+    classes,
+    inheritComponent: 'nav',
+    mount,
+    refInstanceof: window.HTMLElement,
+    testComponentPropWith: 'div',
+  }));
 
   it('should render seperators', () => {
     const wrapper = mount(
diff --git a/packages/material-ui/src/Button/Button.test.js b/packages/material-ui/src/Button/Button.test.js
index fc7ea29cd6abf0..04c23c98c0ddfe 100644
--- a/packages/material-ui/src/Button/Button.test.js
+++ b/packages/material-ui/src/Button/Button.test.js
@@ -1,27 +1,41 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, createRender, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  createRender,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Button from './Button';
 import ButtonBase from '../ButtonBase';
 import Icon from '../Icon';
 
 describe('<Button />', () => {
+  let mount;
   let shallow;
   let render;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     render = createRender();
     classes = getClasses(<Button>Hello World</Button>);
   });
 
-  it('should render a <ButtonBase> element', () => {
-    const wrapper = shallow(<Button>Hello World</Button>);
-    assert.strictEqual(wrapper.type(), ButtonBase);
-    assert.strictEqual(wrapper.props().type, 'button');
+  after(() => {
+    mount.cleanUp();
   });
 
+  describeConformance(<Button>Conformance?</Button>, () => ({
+    classes,
+    inheritComponent: ButtonBase,
+    mount,
+    refInstanceof: window.HTMLButtonElement,
+    testComponentPropWith: false,
+  }));
+
   it('should render with the root & text classes but no others', () => {
     const wrapper = shallow(<Button>Hello World</Button>);
     assert.strictEqual(wrapper.hasClass(classes.root), true);
@@ -38,12 +52,6 @@ describe('<Button />', () => {
     assert.strictEqual(wrapper.hasClass(classes.sizeLarge), false);
   });
 
-  it('should render the custom className and the root class', () => {
-    const wrapper = shallow(<Button className="test-class-name">Hello World</Button>);
-    assert.strictEqual(wrapper.is('.test-class-name'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
-
   it('should render a text primary button', () => {
     const wrapper = shallow(<Button color="primary">Hello World</Button>);
     assert.strictEqual(wrapper.hasClass(classes.root), true);
diff --git a/packages/material-ui/src/ButtonBase/ButtonBase.test.js b/packages/material-ui/src/ButtonBase/ButtonBase.test.js
index f7dde6307fbb04..be02f0c5104e72 100644
--- a/packages/material-ui/src/ButtonBase/ButtonBase.test.js
+++ b/packages/material-ui/src/ButtonBase/ButtonBase.test.js
@@ -4,7 +4,13 @@ import { assert } from 'chai';
 import PropTypes from 'prop-types';
 import { spy, useFakeTimers } from 'sinon';
 import rerender from 'test/utils/rerender';
-import { createShallow, createMount, getClasses, unwrap } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  createMount,
+  describeConformance,
+  getClasses,
+  unwrap,
+} from '@material-ui/core/test-utils';
 import TouchRipple from './TouchRipple';
 import ButtonBase from './ButtonBase';
 
@@ -25,14 +31,15 @@ describe('<ButtonBase />', () => {
     mount.cleanUp();
   });
 
-  describe('root node', () => {
-    it('should render a button with type="button" by default', () => {
-      const wrapper = mount(<ButtonBase>Hello</ButtonBase>);
-      const button = wrapper.find('button');
-      assert.strictEqual(button.exists(), true);
-      assert.strictEqual(button.text(), 'Hello');
-    });
+  describeConformance(<ButtonBase />, () => ({
+    classes,
+    inheritComponent: 'button',
+    mount,
+    refInstanceof: window.HTMLButtonElement,
+    testComponentPropWith: 'a',
+  }));
 
+  describe('root node', () => {
     it('should change the button type', () => {
       const wrapper = mount(<ButtonBase type="submit">Hello</ButtonBase>);
       const button = wrapper.find('button');
@@ -46,18 +53,6 @@ describe('<ButtonBase />', () => {
       assert.strictEqual(checkbox.props().tabIndex, '0');
     });
 
-    it('should spread props on button', () => {
-      const wrapper = shallow(<ButtonBase data-test="hello">Hello</ButtonBase>);
-      assert.strictEqual(wrapper.props()['data-test'], 'hello');
-    });
-
-    it('should render the custom className and the root class', () => {
-      const wrapper = mount(<ButtonBase className="test-class-name" />);
-      const button = wrapper.find('button');
-      assert.strictEqual(button.hasClass('test-class-name'), true);
-      assert.strictEqual(button.hasClass(classes.root), true);
-    });
-
     it('should not apply role="button" if type="button"', () => {
       const wrapper = mount(<ButtonBase>Hello</ButtonBase>);
       const button = wrapper.find('button');
diff --git a/packages/material-ui/src/Card/Card.test.js b/packages/material-ui/src/Card/Card.test.js
index 6ba2d5161d66a8..03b1d7a442db57 100644
--- a/packages/material-ui/src/Card/Card.test.js
+++ b/packages/material-ui/src/Card/Card.test.js
@@ -1,37 +1,32 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import Card from './Card';
 import Paper from '../Paper';
 
 describe('<Card />', () => {
-  let shallow;
+  let mount;
   let classes;
 
   before(() => {
-    shallow = createShallow({ dive: true });
+    mount = createMount();
     classes = getClasses(<Card />);
   });
 
-  it('should render Paper with the root class', () => {
-    const wrapper = shallow(<Card />);
-    assert.strictEqual(wrapper.type(), Paper);
-    assert.strictEqual(wrapper.props().elevation, 1);
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should have the root and custom class', () => {
-    const wrapper = shallow(<Card className="card" />);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-    assert.strictEqual(wrapper.hasClass('card'), true);
-  });
-
-  it('should render Paper with 8dp', () => {
-    const wrapper = shallow(<Card raised />);
-    assert.strictEqual(wrapper.props().elevation, 8);
-  });
+  describeConformance(<Card />, () => ({
+    classes,
+    inheritComponent: Paper,
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 
-  it('should spread custom props on the root node', () => {
-    const wrapper = shallow(<Card data-my-prop="woofCard" />);
-    assert.strictEqual(wrapper.props()['data-my-prop'], 'woofCard');
+  it('when raised should render Paper with 8dp', () => {
+    const wrapper = mount(<Card raised />);
+    assert.strictEqual(wrapper.find(Paper).props().elevation, 8);
   });
 });
diff --git a/packages/material-ui/src/CardActionArea/CardActionArea.test.js b/packages/material-ui/src/CardActionArea/CardActionArea.test.js
index 54e02a3942ec40..a665045ef10081 100644
--- a/packages/material-ui/src/CardActionArea/CardActionArea.test.js
+++ b/packages/material-ui/src/CardActionArea/CardActionArea.test.js
@@ -1,22 +1,26 @@
 import React from 'react';
-import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import ButtonBase from '../ButtonBase';
 import CardActionArea from './CardActionArea';
 
 describe('<CardActionArea />', () => {
-  let shallow;
+  let mount;
   let classes;
 
   before(() => {
-    shallow = createShallow({ dive: true });
+    mount = createMount();
     classes = getClasses(<CardActionArea />);
   });
 
-  it('should render a ButtonBase with custom class', () => {
-    const wrapper = shallow(<CardActionArea className="cardActionArea" />);
-    assert.strictEqual(wrapper.type(), ButtonBase);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-    assert.strictEqual(wrapper.hasClass('cardActionArea'), true);
+  after(() => {
+    mount.cleanUp();
   });
+
+  describeConformance(<CardActionArea />, () => ({
+    classes,
+    inheritComponent: ButtonBase,
+    mount,
+    refInstanceof: window.HTMLButtonElement,
+    testComponentPropWith: false,
+  }));
 });
diff --git a/packages/material-ui/src/CardActions/CardActions.test.js b/packages/material-ui/src/CardActions/CardActions.test.js
index 91d7dbfa772b24..28f97a5d516ab7 100644
--- a/packages/material-ui/src/CardActions/CardActions.test.js
+++ b/packages/material-ui/src/CardActions/CardActions.test.js
@@ -1,24 +1,36 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import CardActions from './CardActions';
 
 describe('<CardActions />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<CardActions />);
   });
 
-  it('should render a div with the root and custom class', () => {
-    const wrapper = shallow(<CardActions className="cardActions" />);
-    assert.strictEqual(wrapper.name(), 'div');
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-    assert.strictEqual(wrapper.hasClass('cardActions'), true);
+  after(() => {
+    mount.cleanUp();
   });
 
+  describeConformance(<CardActions />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
+
   it('should pass the action class to children', () => {
     const child3 = false;
     const wrapper = shallow(
@@ -33,15 +45,17 @@ describe('<CardActions />', () => {
     assert.strictEqual(wrapper.find('#child2').hasClass(classes.action), true);
   });
 
-  it('should not pass the action class to children', () => {
-    const wrapper = shallow(
-      <CardActions disableActionSpacing>
-        <div id="child1" />
-        <div id="child2" />
-      </CardActions>,
-    );
+  describe('prop: disableActionSpacing', () => {
+    it('does not pass the action class to the children', () => {
+      const wrapper = shallow(
+        <CardActions disableActionSpacing>
+          <div id="child1" />
+          <div id="child2" />
+        </CardActions>,
+      );
 
-    assert.strictEqual(wrapper.find('#child1').hasClass(classes.action), false);
-    assert.strictEqual(wrapper.find('#child2').hasClass(classes.action), false);
+      assert.strictEqual(wrapper.find('#child1').hasClass(classes.action), false);
+      assert.strictEqual(wrapper.find('#child2').hasClass(classes.action), false);
+    });
   });
 });
diff --git a/packages/material-ui/src/CardContent/CardContent.test.js b/packages/material-ui/src/CardContent/CardContent.test.js
index 1dadb72002bf24..658841fe5c4911 100644
--- a/packages/material-ui/src/CardContent/CardContent.test.js
+++ b/packages/material-ui/src/CardContent/CardContent.test.js
@@ -1,20 +1,25 @@
 import React from 'react';
-import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import CardContent from './CardContent';
 
 describe('<CardContent />', () => {
-  let shallow;
+  let mount;
   let classes;
 
   before(() => {
-    shallow = createShallow({ untilSelector: 'CardContent' });
+    mount = createMount();
     classes = getClasses(<CardContent />);
   });
 
-  it('should render a div with the root class', () => {
-    const wrapper = shallow(<CardContent />);
-    assert.strictEqual(wrapper.name(), 'div');
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
+  after(() => {
+    mount.cleanUp();
   });
+
+  describeConformance(<CardContent />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: 'span',
+  }));
 });
diff --git a/packages/material-ui/src/CardHeader/CardHeader.test.js b/packages/material-ui/src/CardHeader/CardHeader.test.js
index ef50c50049f43a..2488e388f54671 100644
--- a/packages/material-ui/src/CardHeader/CardHeader.test.js
+++ b/packages/material-ui/src/CardHeader/CardHeader.test.js
@@ -1,53 +1,36 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import CardHeader from './CardHeader';
 import Typography from '../Typography';
 
 describe('<CardHeader />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ untilSelector: 'div' });
     classes = getClasses(<CardHeader />);
   });
 
-  it('should render CardContent', () => {
-    const wrapper = shallow(<CardHeader />);
-    assert.strictEqual(wrapper.name(), 'div');
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should have the root class', () => {
-    const wrapper = shallow(<CardHeader />);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
-
-  describe('with custom styles', () => {
-    let wrapper;
-    let extraClasses;
-
-    beforeEach(() => {
-      extraClasses = { title: 'foo', subheader: 'bar' };
-      wrapper = shallow(
-        <CardHeader
-          title="Title"
-          subheader="Subheader"
-          classes={{ title: extraClasses.title, subheader: extraClasses.subheader }}
-        />,
-      ).childAt(0);
-    });
-
-    it('should render with the title class', () => {
-      const title = wrapper.childAt(0);
-      assert.strictEqual(title.hasClass(extraClasses.title), true);
-    });
-
-    it('should render with the subheader class', () => {
-      const subheader = wrapper.childAt(1);
-      assert.strictEqual(subheader.hasClass(extraClasses.subheader), true);
-    });
-  });
+  describeConformance(<CardHeader />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: 'span',
+  }));
 
   describe('without an avatar', () => {
     let wrapper;
diff --git a/packages/material-ui/src/CardMedia/CardMedia.test.js b/packages/material-ui/src/CardMedia/CardMedia.test.js
index 5dc0723ca9d2fc..37840b83ff8b03 100644
--- a/packages/material-ui/src/CardMedia/CardMedia.test.js
+++ b/packages/material-ui/src/CardMedia/CardMedia.test.js
@@ -1,37 +1,41 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import CardMedia from './CardMedia';
 
 describe('<CardMedia />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ untilSelector: 'CardMedia' });
     classes = getClasses(<CardMedia image="/foo.jpg" />);
   });
 
-  it('should have the root and custom class', () => {
-    const wrapper = shallow(<CardMedia className="woofCardMedia" image="/foo.jpg" />);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-    assert.strictEqual(wrapper.hasClass('woofCardMedia'), true);
+  after(() => {
+    mount.cleanUp();
   });
 
+  describeConformance(<CardMedia image="/foo.jpg" />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: 'span',
+  }));
+
   it('should have the backgroundImage specified', () => {
     const wrapper = shallow(<CardMedia image="/foo.jpg" />);
     assert.strictEqual(wrapper.props().style.backgroundImage, 'url("/foo.jpg")');
   });
 
-  it('should spread custom props on the root node', () => {
-    const wrapper = shallow(<CardMedia image="/foo.jpg" data-my-prop="woofCardMedia" />);
-    assert.strictEqual(
-      wrapper.prop('data-my-prop'),
-      'woofCardMedia',
-      'custom prop should be woofCardMedia',
-    );
-  });
-
   it('should have backgroundImage specified even though custom styles got passed', () => {
     const wrapper = shallow(<CardMedia image="/foo.jpg" style={{ height: 200 }} />);
     assert.strictEqual(wrapper.props().style.backgroundImage, 'url("/foo.jpg")');
diff --git a/packages/material-ui/src/Checkbox/Checkbox.test.js b/packages/material-ui/src/Checkbox/Checkbox.test.js
index 7669d9fdd2bcf3..812627776f7666 100644
--- a/packages/material-ui/src/Checkbox/Checkbox.test.js
+++ b/packages/material-ui/src/Checkbox/Checkbox.test.js
@@ -1,17 +1,14 @@
 import React from 'react';
 import { assert } from 'chai';
 import IndeterminateCheckBoxIcon from '../internal/svg-icons/IndeterminateCheckBox';
-import { createShallow, getClasses, createMount } from '@material-ui/core/test-utils';
-import SwitchBase from '../internal/SwitchBase';
+import { describeConformance, getClasses, createMount } from '@material-ui/core/test-utils';
 import Checkbox from './Checkbox';
 
 describe('<Checkbox />', () => {
-  let shallow;
   let classes;
   let mount;
 
   before(() => {
-    shallow = createShallow({ dive: true });
     classes = getClasses(<Checkbox />);
     mount = createMount();
   });
@@ -20,21 +17,20 @@ describe('<Checkbox />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(<Checkbox checked />, () => ({
+    classes,
+    inheritComponent: 'span',
+    mount,
+    refInstanceof: window.HTMLSpanElement,
+    testComponentPropWith: false,
+  }));
+
   it('should have the classes required for Checkbox', () => {
     assert.strictEqual(typeof classes.root, 'string');
     assert.strictEqual(typeof classes.checked, 'string');
     assert.strictEqual(typeof classes.disabled, 'string');
   });
 
-  it('should render a div with a SwitchBase', () => {
-    const wrapper = shallow(<Checkbox />);
-    assert.strictEqual(wrapper.type(), SwitchBase);
-  });
-
-  it('should mount without issue', () => {
-    mount(<Checkbox checked />);
-  });
-
   describe('prop: indeterminate', () => {
     it('should render an indeterminate icon', () => {
       const wrapper = mount(<Checkbox indeterminate />);
diff --git a/packages/material-ui/src/Chip/Chip.test.js b/packages/material-ui/src/Chip/Chip.test.js
index f6f2d2b8163a56..51a83650021ae0 100644
--- a/packages/material-ui/src/Chip/Chip.test.js
+++ b/packages/material-ui/src/Chip/Chip.test.js
@@ -3,7 +3,7 @@ import { assert } from 'chai';
 import { spy } from 'sinon';
 import CheckBox from '../internal/svg-icons/CheckBox';
 import CancelIcon from '../internal/svg-icons/Cancel';
-import { createMount, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import Avatar from '../Avatar';
 import Chip from './Chip';
 
@@ -20,20 +20,24 @@ describe('<Chip />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(<Chip />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: 'span',
+  }));
+
   describe('text only', () => {
     it('should render a div containing a label', () => {
-      const wrapper = mount(
-        <Chip className="my-Chip" data-my-prop="woofChip" label="My text Chip" />,
-      );
-      const chip = wrapper.find('.my-Chip').hostNodes();
+      const wrapper = mount(<Chip label="My text Chip" />);
+      const chip = wrapper.find(`.${classes.root}`).hostNodes();
       const label = chip.find(`.${classes.label}`).hostNodes();
 
       assert.strictEqual(chip.type(), 'div');
       assert.strictEqual(label.type(), 'span');
       assert.strictEqual(label.text(), 'My text Chip');
       assert.strictEqual(chip.hasClass(classes.root), true);
-      assert.strictEqual(chip.hasClass('my-Chip'), true);
-      assert.strictEqual(chip.props()['data-my-prop'], 'woofChip');
       assert.strictEqual(chip.props().tabIndex, undefined);
 
       assert.strictEqual(chip.hasClass(classes.root), true);
@@ -71,10 +75,8 @@ describe('<Chip />', () => {
 
     before(() => {
       handleClick = () => {};
-      wrapper = mount(
-        <Chip className="my-Chip" data-my-prop="woofChip" label="My Chip" onClick={handleClick} />,
-      );
-      chip = wrapper.find('.my-Chip').hostNodes();
+      wrapper = mount(<Chip label="My Chip" onClick={handleClick} />);
+      chip = wrapper.find(`.${classes.root}`).hostNodes();
     });
 
     it('should render a div containing a label', () => {
@@ -86,13 +88,6 @@ describe('<Chip />', () => {
       assert.strictEqual(label.text(), 'My Chip');
     });
 
-    it('should merge user classes & spread custom props to the root node', () => {
-      assert.strictEqual(chip.hasClass(classes.root), true);
-      assert.strictEqual(chip.hasClass('my-Chip'), true);
-      assert.strictEqual(chip.props()['data-my-prop'], 'woofChip');
-      assert.strictEqual(chip.props().onClick, handleClick);
-    });
-
     it('should have a tabIndex prop', () => {
       assert.strictEqual(chip.props().tabIndex, 0);
     });
diff --git a/packages/material-ui/src/CircularProgress/CircularProgress.test.js b/packages/material-ui/src/CircularProgress/CircularProgress.test.js
index 7978af0b3a5cc1..ac08857af69ff2 100644
--- a/packages/material-ui/src/CircularProgress/CircularProgress.test.js
+++ b/packages/material-ui/src/CircularProgress/CircularProgress.test.js
@@ -1,22 +1,36 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import CircularProgress from './CircularProgress';
 
 describe('<CircularProgress />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<CircularProgress />);
   });
 
-  it('should render a div with the root class', () => {
-    const wrapper = shallow(<CircularProgress />);
-    assert.strictEqual(wrapper.name(), 'div');
+  after(() => {
+    mount.cleanUp();
   });
 
+  describeConformance(<CircularProgress />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
+
   it('should render with the primary color by default', () => {
     const wrapper = shallow(<CircularProgress />);
     assert.strictEqual(wrapper.hasClass(classes.colorPrimary), true);
@@ -32,13 +46,6 @@ describe('<CircularProgress />', () => {
     assert.strictEqual(wrapper.hasClass(classes.colorSecondary), true);
   });
 
-  it('should render with the user and root classes', () => {
-    const wrapper = shallow(<CircularProgress className="woofCircularProgress" />);
-    assert.strictEqual(wrapper.hasClass('woofCircularProgress'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-    assert.strictEqual(wrapper.props().role, 'progressbar');
-  });
-
   it('should contain an SVG with the svg class, and a circle with the circle class', () => {
     const wrapper = shallow(<CircularProgress />);
     const svg = wrapper.childAt(0);
diff --git a/packages/material-ui/src/Dialog/Dialog.test.js b/packages/material-ui/src/Dialog/Dialog.test.js
index 93c8bb2955c7f3..72bffea422b360 100644
--- a/packages/material-ui/src/Dialog/Dialog.test.js
+++ b/packages/material-ui/src/Dialog/Dialog.test.js
@@ -1,7 +1,7 @@
 import React from 'react';
 import { assert } from 'chai';
 import { spy } from 'sinon';
-import { createMount, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import Paper from '../Paper';
 import Fade from '../Fade';
 import Modal from '../Modal';
@@ -33,10 +33,18 @@ describe('<Dialog />', () => {
     mount.cleanUp();
   });
 
-  it('should render a Modal', () => {
-    const wrapper = mount(<Dialog {...defaultProps}>foo</Dialog>);
-    assert.strictEqual(wrapper.find(Modal).exists(), true);
-  });
+  describeConformance(
+    <Dialog {...defaultProps} open>
+      foo
+    </Dialog>,
+    () => ({
+      classes,
+      inheritComponent: Modal,
+      mount,
+      refInstanceof: window.HTMLDivElement,
+      testComponentPropWith: false,
+    }),
+  );
 
   it('should render a Modal with TransitionComponent', () => {
     const Transition = () => <div tabIndex={-1} />;
@@ -83,16 +91,6 @@ describe('<Dialog />', () => {
     assert.strictEqual(modal.props()['data-my-prop'], 'woofDialog');
   });
 
-  it('should render with the user classes on the root node', () => {
-    const wrapper = mount(
-      <Dialog {...defaultProps} className="woofDialog">
-        foo
-      </Dialog>,
-    );
-    const modal = wrapper.find(Modal);
-    assert.strictEqual(modal.hasClass('woofDialog'), true);
-  });
-
   it('should fade down and make the transition appear on first mount', () => {
     const wrapper = mount(
       <Dialog {...defaultProps} open>
diff --git a/packages/material-ui/src/DialogActions/DialogActions.test.js b/packages/material-ui/src/DialogActions/DialogActions.test.js
index bc944d0ab5a049..d4fc3c823a1829 100644
--- a/packages/material-ui/src/DialogActions/DialogActions.test.js
+++ b/packages/material-ui/src/DialogActions/DialogActions.test.js
@@ -1,6 +1,5 @@
 import React from 'react';
-import { assert } from 'chai';
-import { createMount, getClasses, findOutermostIntrinsic } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import DialogActions from './DialogActions';
 
 describe('<DialogActions />', () => {
@@ -12,22 +11,15 @@ describe('<DialogActions />', () => {
     classes = getClasses(<DialogActions />);
   });
 
-  it('should render a div', () => {
-    const wrapper = mount(<DialogActions />);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).name(), 'div');
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should spread custom props on the root node', () => {
-    const wrapper = mount(<DialogActions data-my-prop="woofDialogActions" />);
-    assert.strictEqual(
-      findOutermostIntrinsic(wrapper).props()['data-my-prop'],
-      'woofDialogActions',
-    );
-  });
-
-  it('should render with the user and root classes', () => {
-    const wrapper = mount(<DialogActions className="woofDialogActions" />);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass('woofDialogActions'), true);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.root), true);
-  });
+  describeConformance(<DialogActions />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 });
diff --git a/packages/material-ui/src/DialogContent/DialogContent.test.js b/packages/material-ui/src/DialogContent/DialogContent.test.js
index f6be6e427b5526..c163ffc8e1bd8e 100644
--- a/packages/material-ui/src/DialogContent/DialogContent.test.js
+++ b/packages/material-ui/src/DialogContent/DialogContent.test.js
@@ -1,36 +1,35 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import DialogContent from './DialogContent';
 
 describe('<DialogContent />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<DialogContent />);
   });
 
-  it('should render a div', () => {
-    const wrapper = shallow(<DialogContent />);
-    assert.strictEqual(wrapper.name(), 'div');
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should spread custom props on the root node', () => {
-    const wrapper = shallow(<DialogContent data-my-prop="woofDialogContent" />);
-    assert.strictEqual(
-      wrapper.props()['data-my-prop'],
-      'woofDialogContent',
-      'custom prop should be woofDialogContent',
-    );
-  });
-
-  it('should render with the user and root classes', () => {
-    const wrapper = shallow(<DialogContent className="woofDialogContent" />);
-    assert.strictEqual(wrapper.hasClass('woofDialogContent'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
+  describeConformance(<DialogContent />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 
   it('should render children', () => {
     const children = <p />;
diff --git a/packages/material-ui/src/DialogTitle/DialogTitle.test.js b/packages/material-ui/src/DialogTitle/DialogTitle.test.js
index eb81d79576c14d..2fa595250032f2 100644
--- a/packages/material-ui/src/DialogTitle/DialogTitle.test.js
+++ b/packages/material-ui/src/DialogTitle/DialogTitle.test.js
@@ -1,36 +1,35 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import DialogTitle from './DialogTitle';
 
 describe('<DialogTitle />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<DialogTitle>foo</DialogTitle>);
   });
 
-  it('should render a div', () => {
-    const wrapper = shallow(<DialogTitle>foo</DialogTitle>);
-    assert.strictEqual(wrapper.name(), 'div');
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should spread custom props on the root node', () => {
-    const wrapper = shallow(<DialogTitle data-my-prop="woofDialogTitle">foo</DialogTitle>);
-    assert.strictEqual(
-      wrapper.props()['data-my-prop'],
-      'woofDialogTitle',
-      'custom prop should be woofDialogTitle',
-    );
-  });
-
-  it('should render with the user and root classes', () => {
-    const wrapper = shallow(<DialogTitle className="woofDialogTitle">foo</DialogTitle>);
-    assert.strictEqual(wrapper.hasClass('woofDialogTitle'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
+  describeConformance(<DialogTitle>foo</DialogTitle>, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 
   it('should render JSX children', () => {
     const children = <p className="test">Hello</p>;
diff --git a/packages/material-ui/src/Divider/Divider.test.js b/packages/material-ui/src/Divider/Divider.test.js
index 97b1fdfff9e06d..f5eae326875dd6 100644
--- a/packages/material-ui/src/Divider/Divider.test.js
+++ b/packages/material-ui/src/Divider/Divider.test.js
@@ -1,26 +1,35 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Divider from './Divider';
 
 describe('<Divider />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<Divider />);
   });
 
-  it('should render a hr', () => {
-    const wrapper = shallow(<Divider />);
-    assert.strictEqual(wrapper.name(), 'hr');
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should render with the root and default class', () => {
-    const wrapper = shallow(<Divider />);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
+  describeConformance(<Divider />, () => ({
+    classes,
+    inheritComponent: 'hr',
+    mount,
+    refInstanceof: window.HTMLHRElement,
+    testComponentPropWith: 'div',
+  }));
 
   it('should set the absolute class', () => {
     const wrapper = shallow(<Divider absolute />);
diff --git a/packages/material-ui/src/Drawer/Drawer.test.js b/packages/material-ui/src/Drawer/Drawer.test.js
index 11bfd2b9598b94..99e485c865ff44 100644
--- a/packages/material-ui/src/Drawer/Drawer.test.js
+++ b/packages/material-ui/src/Drawer/Drawer.test.js
@@ -1,6 +1,11 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  describeConformance,
+  findOutermostIntrinsic,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Slide from '../Slide';
 import createMuiTheme from '../styles/createMuiTheme';
 import Paper from '../Paper';
@@ -24,6 +29,19 @@ describe('<Drawer />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(
+    <Drawer open>
+      <div />
+    </Drawer>,
+    () => ({
+      classes,
+      inheritComponent: Modal,
+      mount,
+      refInstanceof: window.HTMLDivElement,
+      testComponentPropWith: false,
+    }),
+  );
+
   describe('prop: variant=temporary', () => {
     it('should render a Modal', () => {
       const wrapper = mount(
diff --git a/packages/material-ui/src/ExpansionPanel/ExpansionPanel.test.js b/packages/material-ui/src/ExpansionPanel/ExpansionPanel.test.js
index 4c5ea3413b004c..525595de35d2b7 100644
--- a/packages/material-ui/src/ExpansionPanel/ExpansionPanel.test.js
+++ b/packages/material-ui/src/ExpansionPanel/ExpansionPanel.test.js
@@ -2,7 +2,12 @@ import React from 'react';
 import PropTypes from 'prop-types';
 import { assert } from 'chai';
 import { spy } from 'sinon';
-import { createMount, getClasses, findOutermostIntrinsic } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  describeConformance,
+  getClasses,
+  findOutermostIntrinsic,
+} from '@material-ui/core/test-utils';
 import consoleErrorMock from 'test/utils/consoleErrorMock';
 import Paper from '../Paper';
 import ExpansionPanel from './ExpansionPanel';
@@ -22,6 +27,14 @@ describe('<ExpansionPanel />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(<ExpansionPanel>{minimalChildren}</ExpansionPanel>, () => ({
+    classes,
+    inheritComponent: Paper,
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
+
   it('should render and not be controlled', () => {
     const wrapper = mount(<ExpansionPanel>{minimalChildren}</ExpansionPanel>);
     const root = wrapper.find(`.${classes.root}`).first();
@@ -37,15 +50,6 @@ describe('<ExpansionPanel />', () => {
     assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.expanded), true);
   });
 
-  it('should render the custom className and the root class', () => {
-    const wrapper = mount(
-      <ExpansionPanel className="test-class-name">{minimalChildren}</ExpansionPanel>,
-    );
-    const root = findOutermostIntrinsic(wrapper);
-    assert.strictEqual(root.hasClass('test-class-name'), true);
-    assert.strictEqual(root.hasClass(classes.root), true);
-  });
-
   it('should render the summary and collapse elements', () => {
     const wrapper = mount(
       <ExpansionPanel>
diff --git a/packages/material-ui/src/ExpansionPanelActions/ExpansionPanelActions.test.js b/packages/material-ui/src/ExpansionPanelActions/ExpansionPanelActions.test.js
index 478ef21d232b15..d1998a055b1f00 100644
--- a/packages/material-ui/src/ExpansionPanelActions/ExpansionPanelActions.test.js
+++ b/packages/material-ui/src/ExpansionPanelActions/ExpansionPanelActions.test.js
@@ -1,36 +1,35 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import ExpansionPanelActions from './ExpansionPanelActions';
 
 describe('<ExpansionPanelActions />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<ExpansionPanelActions>foo</ExpansionPanelActions>);
   });
 
-  it('should render a div', () => {
-    const wrapper = shallow(<ExpansionPanelActions>foo</ExpansionPanelActions>);
-    assert.strictEqual(wrapper.name(), 'div');
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should spread custom props on the root node', () => {
-    const wrapper = shallow(
-      <ExpansionPanelActions data-my-prop="woofExpansionPanelActions">foo</ExpansionPanelActions>,
-    );
-    assert.strictEqual(wrapper.props()['data-my-prop'], 'woofExpansionPanelActions');
-  });
-
-  it('should render with the user and root classes', () => {
-    const wrapper = shallow(
-      <ExpansionPanelActions className="woofExpansionPanelActions">foo</ExpansionPanelActions>,
-    );
-    assert.strictEqual(wrapper.hasClass('woofExpansionPanelActions'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
+  describeConformance(<ExpansionPanelActions>Conformance</ExpansionPanelActions>, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 
   it('should render children with the button class wrapped in a div with the action class', () => {
     const wrapper = shallow(
diff --git a/packages/material-ui/src/ExpansionPanelDetails/ExpansionPanelDetails.test.js b/packages/material-ui/src/ExpansionPanelDetails/ExpansionPanelDetails.test.js
index abaae993fde3e8..5f192d62943f27 100644
--- a/packages/material-ui/src/ExpansionPanelDetails/ExpansionPanelDetails.test.js
+++ b/packages/material-ui/src/ExpansionPanelDetails/ExpansionPanelDetails.test.js
@@ -1,26 +1,36 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import ExpansionPanelDetails from './ExpansionPanelDetails';
 
 describe('<ExpansionPanelDetails />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<ExpansionPanelDetails>foo</ExpansionPanelDetails>);
   });
 
-  it('should render a div', () => {
-    const wrapper = shallow(
-      <ExpansionPanelDetails className="woofExpansionPanelDetails">foo</ExpansionPanelDetails>,
-    );
-    assert.strictEqual(wrapper.name(), 'div');
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-    assert.strictEqual(wrapper.hasClass('woofExpansionPanelDetails'), true);
+  after(() => {
+    mount.cleanUp();
   });
 
+  describeConformance(<ExpansionPanelDetails>Conformance</ExpansionPanelDetails>, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
+
   it('should render a children element', () => {
     const wrapper = shallow(
       <ExpansionPanelDetails>
diff --git a/packages/material-ui/src/ExpansionPanelSummary/ExpansionPanelSummary.test.js b/packages/material-ui/src/ExpansionPanelSummary/ExpansionPanelSummary.test.js
index 8de1cb00b0e620..f04f57c51cfdf8 100644
--- a/packages/material-ui/src/ExpansionPanelSummary/ExpansionPanelSummary.test.js
+++ b/packages/material-ui/src/ExpansionPanelSummary/ExpansionPanelSummary.test.js
@@ -3,9 +3,9 @@ import { assert } from 'chai';
 import { spy } from 'sinon';
 import {
   createMount,
+  describeConformance,
   findOutermostIntrinsic,
   getClasses,
-  testRef,
 } from '@material-ui/core/test-utils';
 import ExpansionPanelSummary from './ExpansionPanelSummary';
 import ButtonBase from '../ButtonBase';
@@ -27,17 +27,13 @@ describe('<ExpansionPanelSummary />', () => {
     mount.cleanUp();
   });
 
-  it('does forward refs', () => {
-    testRef(<ExpansionPanelSummary />, mount);
-  });
-
-  it('should render with the user and root classes', () => {
-    const root = findOutermostIntrinsic(
-      mount(<ExpansionPanelSummary className="woofExpansionPanelSummary" />),
-    );
-    assert.strictEqual(root.hasClass(classes.root), true);
-    assert.strictEqual(root.hasClass('woofExpansionPanelSummary'), true);
-  });
+  describeConformance(<ExpansionPanelSummary />, () => ({
+    classes,
+    inheritComponent: ButtonBase,
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 
   it('should render with the content', () => {
     const wrapper = mount(<ExpansionPanelSummary>The Summary</ExpansionPanelSummary>);
diff --git a/packages/material-ui/src/Fab/Fab.test.js b/packages/material-ui/src/Fab/Fab.test.js
index 74ea27b4c586c0..35771b2a191648 100644
--- a/packages/material-ui/src/Fab/Fab.test.js
+++ b/packages/material-ui/src/Fab/Fab.test.js
@@ -1,27 +1,41 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, createRender, getClasses } from '../test-utils';
+import {
+  createMount,
+  createShallow,
+  createRender,
+  describeConformance,
+  getClasses,
+} from '../test-utils';
 import Fab from './Fab';
 import ButtonBase from '../ButtonBase';
 import Icon from '../Icon';
 
 describe('<Fab />', () => {
+  let mount;
   let shallow;
   let render;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     render = createRender();
     classes = getClasses(<Fab>Fab</Fab>);
   });
 
-  it('should render a <ButtonBase> element', () => {
-    const wrapper = shallow(<Fab>Fab</Fab>);
-    assert.strictEqual(wrapper.type(), ButtonBase);
-    assert.strictEqual(wrapper.props().type, 'button');
+  after(() => {
+    mount.cleanUp();
   });
 
+  describeConformance(<Fab>Conformance?</Fab>, () => ({
+    classes,
+    inheritComponent: ButtonBase,
+    mount,
+    refInstanceof: window.HTMLButtonElement,
+    testComponentPropWith: false,
+  }));
+
   it('should render with the root class but no others', () => {
     const wrapper = shallow(<Fab>Fab</Fab>);
     assert.strictEqual(wrapper.hasClass(classes.root), true);
@@ -37,12 +51,6 @@ describe('<Fab />', () => {
     assert.strictEqual(wrapper.hasClass(classes.sizeMedium), false);
   });
 
-  it('should render the custom className and the root class', () => {
-    const wrapper = shallow(<Fab className="test-class-name">Fab</Fab>);
-    assert.strictEqual(wrapper.is('.test-class-name'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
-
   it('should render an extended floating action button', () => {
     const wrapper = shallow(<Fab variant="extended">Fab</Fab>);
     assert.strictEqual(wrapper.hasClass(classes.root), true);
diff --git a/packages/material-ui/src/FormControl/FormControl.test.js b/packages/material-ui/src/FormControl/FormControl.test.js
index 37b9a56821d3f4..59f12124e3c820 100644
--- a/packages/material-ui/src/FormControl/FormControl.test.js
+++ b/packages/material-ui/src/FormControl/FormControl.test.js
@@ -1,6 +1,11 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  describeConformance,
+  findOutermostIntrinsic,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Input from '../Input';
 import Select from '../Select';
 import FormControl from './FormControl';
@@ -27,15 +32,15 @@ describe('<FormControl />', () => {
     mount.cleanUp();
   });
 
-  describe('initial state', () => {
-    it('should render a div with the root and user classes', () => {
-      const wrapper = mount(<FormControl className="woofFormControl" />);
-
-      assert.strictEqual(wrapper.getDOMNode().nodeName, 'DIV');
-      assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.root), true);
-      assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass('woofFormControl'), true);
-    });
+  describeConformance(<FormControl />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: 'fieldset',
+  }));
 
+  describe('initial state', () => {
     it('should have no margin', () => {
       const wrapper = mount(<FormControl />);
 
diff --git a/packages/material-ui/src/FormControlLabel/FormControlLabel.test.js b/packages/material-ui/src/FormControlLabel/FormControlLabel.test.js
index 51e2455d5a84f6..192bb5f7d9fd28 100644
--- a/packages/material-ui/src/FormControlLabel/FormControlLabel.test.js
+++ b/packages/material-ui/src/FormControlLabel/FormControlLabel.test.js
@@ -1,7 +1,12 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import { assert } from 'chai';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  describeConformance,
+  findOutermostIntrinsic,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Checkbox from '../Checkbox';
 import FormControlLabel from './FormControlLabel';
 import FormControlContext from '../FormControl/FormControlContext';
@@ -19,6 +24,14 @@ describe('<FormControlLabel />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(<FormControlLabel label="Pizza" control={<Checkbox />} />, () => ({
+    classes,
+    inheritComponent: 'label',
+    mount,
+    refInstanceof: window.HTMLLabelElement,
+    testComponentPropWith: false,
+  }));
+
   it('should render the label text inside an additional element', () => {
     const wrapper = findOutermostIntrinsic(
       mount(<FormControlLabel label="Pizza" control={<div />} />),
@@ -76,11 +89,6 @@ describe('<FormControlLabel />', () => {
     });
   });
 
-  it('should mount without issue', () => {
-    const wrapper = mount(<FormControlLabel label="Pizza" control={<Checkbox />} />);
-    assert.strictEqual(wrapper.type(), FormControlLabel);
-  });
-
   describe('with muiFormControl context', () => {
     let wrapper;
 
diff --git a/packages/material-ui/src/FormGroup/FormGroup.test.js b/packages/material-ui/src/FormGroup/FormGroup.test.js
index 6e1a3e30a2627e..57195a3296285e 100644
--- a/packages/material-ui/src/FormGroup/FormGroup.test.js
+++ b/packages/material-ui/src/FormGroup/FormGroup.test.js
@@ -1,25 +1,36 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import FormGroup from './FormGroup';
 
 describe('<FormGroup />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<FormGroup />);
   });
 
-  it('should render a div with the root and user classes', () => {
-    const wrapper = shallow(<FormGroup className="woofFormGroup" />);
-
-    assert.strictEqual(wrapper.name(), 'div');
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-    assert.strictEqual(wrapper.hasClass('woofFormGroup'), true);
+  after(() => {
+    mount.cleanUp();
   });
 
+  describeConformance(<FormGroup />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
+
   it('should render a div with a div child', () => {
     const wrapper = shallow(
       <FormGroup>
diff --git a/packages/material-ui/src/FormHelperText/FormHelperText.test.js b/packages/material-ui/src/FormHelperText/FormHelperText.test.js
index 3546df5861c224..66a81758e7719f 100644
--- a/packages/material-ui/src/FormHelperText/FormHelperText.test.js
+++ b/packages/material-ui/src/FormHelperText/FormHelperText.test.js
@@ -1,7 +1,12 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import { assert } from 'chai';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  describeConformance,
+  findOutermostIntrinsic,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import FormHelperText from './FormHelperText';
 import FormControlContext from '../FormControl/FormControlContext';
 
@@ -14,19 +19,17 @@ describe('<FormHelperText />', () => {
     classes = getClasses(<FormHelperText />);
   });
 
-  it('should render a <p />', () => {
-    const wrapper = findOutermostIntrinsic(mount(<FormHelperText className="woofHelperText" />));
-    assert.strictEqual(wrapper.name(), 'p');
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-    assert.strictEqual(wrapper.hasClass('woofHelperText'), true);
+  after(() => {
+    mount.cleanUp();
   });
 
-  describe('prop: component', () => {
-    it('should render the prop component', () => {
-      const wrapper = findOutermostIntrinsic(mount(<FormHelperText component="div" />));
-      assert.strictEqual(wrapper.name(), 'div');
-    });
-  });
+  describeConformance(<FormHelperText />, () => ({
+    classes,
+    inheritComponent: 'p',
+    mount,
+    refInstanceof: window.HTMLParagraphElement,
+    testComponentPropWith: 'div',
+  }));
 
   describe('prop: error', () => {
     it('should have an error class', () => {
diff --git a/packages/material-ui/src/FormLabel/FormLabel.test.js b/packages/material-ui/src/FormLabel/FormLabel.test.js
index 14d992103a2244..1e2046a6c57d4f 100644
--- a/packages/material-ui/src/FormLabel/FormLabel.test.js
+++ b/packages/material-ui/src/FormLabel/FormLabel.test.js
@@ -1,7 +1,12 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import { assert } from 'chai';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  describeConformance,
+  findOutermostIntrinsic,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import FormLabel from './FormLabel';
 import FormControlContext from '../FormControl/FormControlContext';
 
@@ -14,13 +19,18 @@ describe('<FormLabel />', () => {
     classes = getClasses(<FormLabel />);
   });
 
-  it('should render a <label />', () => {
-    const wrapper = findOutermostIntrinsic(mount(<FormLabel className="woofFormLabel" />));
-    assert.strictEqual(wrapper.name(), 'label');
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-    assert.strictEqual(wrapper.hasClass('woofFormLabel'), true);
+  after(() => {
+    mount.cleanUp();
   });
 
+  describeConformance(<FormLabel />, () => ({
+    classes,
+    inheritComponent: 'label',
+    mount,
+    refInstanceof: window.HTMLLabelElement,
+    testComponentPropWith: 'div',
+  }));
+
   describe('prop: required', () => {
     it('should show an asterisk if required is set', () => {
       const wrapper = mount(<FormLabel required />);
diff --git a/packages/material-ui/src/GridList/GridList.test.js b/packages/material-ui/src/GridList/GridList.test.js
index 21f3dbbaa4a4d6..2e19e3b90d2ea9 100644
--- a/packages/material-ui/src/GridList/GridList.test.js
+++ b/packages/material-ui/src/GridList/GridList.test.js
@@ -1,6 +1,11 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import GridList from './GridList';
 
 const tilesData = [
@@ -17,29 +22,32 @@ const tilesData = [
 ];
 
 describe('<GridList />', () => {
+  let classes;
+  let mount;
   let shallow;
 
   before(() => {
+    classes = getClasses(<GridList />);
+    mount = createMount();
     shallow = createShallow({ dive: true });
   });
 
-  it('should render a ul', () => {
-    const wrapper = shallow(
-      <GridList>
-        <br />
-      </GridList>,
-    );
-    assert.strictEqual(wrapper.name(), 'ul');
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should accept a component property', () => {
-    const wrapper = shallow(
-      <GridList component="li">
-        <br />
-      </GridList>,
-    );
-    assert.strictEqual(wrapper.name(), 'li');
-  });
+  describeConformance(
+    <GridList>
+      <div />
+    </GridList>,
+    () => ({
+      classes,
+      inheritComponent: 'ul',
+      mount,
+      refInstanceof: window.HTMLUListElement,
+      testComponentPropWith: 'li',
+    }),
+  );
 
   it('should render children and change cellHeight', () => {
     const cellHeight = 250;
diff --git a/packages/material-ui/src/GridListTile/GridListTile.test.js b/packages/material-ui/src/GridListTile/GridListTile.test.js
index deecf72b6765a1..73c6bcea779442 100644
--- a/packages/material-ui/src/GridListTile/GridListTile.test.js
+++ b/packages/material-ui/src/GridListTile/GridListTile.test.js
@@ -1,7 +1,7 @@
 import React from 'react';
 import { assert } from 'chai';
 import { spy, useFakeTimers } from 'sinon';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import { act } from 'react-dom/test-utils';
 import { setRef } from '../utils/reactHelpers';
 import GridListTile from './GridListTile';
@@ -19,32 +19,20 @@ describe('<GridListTile />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(<GridListTile />, () => ({
+    classes,
+    inheritComponent: 'li',
+    mount,
+    refInstanceof: window.HTMLLIElement,
+    testComponentPropWith: 'div',
+  }));
+
   const tileData = {
     img: 'images/grid-list/00-52-29-429_640.jpg',
     title: 'Breakfast',
     author: 'jill111',
   };
 
-  it('should render a li', () => {
-    const wrapper = mount(
-      <GridListTile>
-        <img src={tileData.img} alt="foo" />
-      </GridListTile>,
-    );
-    assert.strictEqual(findOutermostIntrinsic(wrapper).type(), 'li');
-  });
-
-  describe('prop: component', () => {
-    it('controls the root host node', () => {
-      const wrapper = mount(
-        <GridListTile component="div">
-          <img src={tileData.img} alt="foo" />
-        </GridListTile>,
-      );
-      assert.strictEqual(findOutermostIntrinsic(wrapper).type(), 'div');
-    });
-  });
-
   describe('prop: children', () => {
     it('should render children by default', () => {
       const children = <img src={tileData.img} alt="foo" />;
@@ -60,15 +48,6 @@ describe('<GridListTile />', () => {
     });
   });
 
-  describe('prop: className', () => {
-    it('should renders className', () => {
-      const children = <img src={tileData.img} alt="foo" />;
-      const wrapper = mount(<GridListTile className="foo">{children}</GridListTile>);
-
-      assert.strictEqual(wrapper.hasClass('foo'), true);
-    });
-  });
-
   function mountMockImage(imgEl) {
     const Image = React.forwardRef((props, ref) => {
       return (
diff --git a/packages/material-ui/src/GridListTileBar/GridListTileBar.test.js b/packages/material-ui/src/GridListTileBar/GridListTileBar.test.js
index 4608181bc3ecc6..643ccd7162f923 100644
--- a/packages/material-ui/src/GridListTileBar/GridListTileBar.test.js
+++ b/packages/material-ui/src/GridListTileBar/GridListTileBar.test.js
@@ -1,15 +1,36 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import GridListTileBar from './GridListTileBar';
 
 describe('<GridListTileBar />', () => {
+  let classes;
+  let mount;
   let shallow;
 
   before(() => {
+    classes = getClasses(<GridListTileBar title="classes" />);
+    mount = createMount();
     shallow = createShallow({ dive: true });
   });
 
+  after(() => {
+    mount.cleanUp();
+  });
+
+  describeConformance(<GridListTileBar title="conform?" />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
+
   const tileData = {
     img: 'images/grid-list/00-52-29-429_640.jpg',
     title: 'Breakfast',
diff --git a/packages/material-ui/src/Icon/Icon.test.js b/packages/material-ui/src/Icon/Icon.test.js
index 15754373f3cc85..c955b26021bc52 100644
--- a/packages/material-ui/src/Icon/Icon.test.js
+++ b/packages/material-ui/src/Icon/Icon.test.js
@@ -1,39 +1,42 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Icon from './Icon';
 
 describe('<Icon />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<Icon />);
   });
 
-  it('renders children by default', () => {
-    const wrapper = shallow(<Icon>account_circle</Icon>);
-    assert.strictEqual(wrapper.contains('account_circle'), true);
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should render an span with root class', () => {
-    const wrapper = shallow(<Icon>account_circle</Icon>);
-    assert.strictEqual(wrapper.name(), 'span');
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
+  describeConformance(<Icon>account_circle</Icon>, () => ({
+    classes,
+    inheritComponent: 'span',
+    mount,
+    refInstanceof: window.HTMLSpanElement,
+    testComponentPropWith: 'div',
+  }));
 
-  it('should spread props on span', () => {
-    const wrapper = shallow(<Icon data-test="hello">account_circle</Icon>);
-    assert.strictEqual(wrapper.props()['data-test'], 'hello');
+  it('renders children by default', () => {
+    const wrapper = shallow(<Icon>account_circle</Icon>);
+    assert.strictEqual(wrapper.contains('account_circle'), true);
   });
 
   describe('optional classes', () => {
-    it('should render with the user class', () => {
-      const wrapper = shallow(<Icon className="meow">account_circle</Icon>);
-      assert.strictEqual(wrapper.hasClass('meow'), true);
-    });
-
     it('should render with the secondary color', () => {
       const wrapper = shallow(<Icon color="secondary">account_circle</Icon>);
       assert.strictEqual(wrapper.hasClass(classes.colorSecondary), true);
diff --git a/packages/material-ui/src/IconButton/IconButton.test.js b/packages/material-ui/src/IconButton/IconButton.test.js
index f8c083e620ab1c..4496b31badf5ab 100644
--- a/packages/material-ui/src/IconButton/IconButton.test.js
+++ b/packages/material-ui/src/IconButton/IconButton.test.js
@@ -1,11 +1,10 @@
 import React from 'react';
-import ReactDOM from 'react-dom';
-import { spy } from 'sinon';
 import { assert } from 'chai';
 import PropTypes from 'prop-types';
 import {
   createShallow,
   createMount,
+  describeConformance,
   getClasses,
   findOutermostIntrinsic,
 } from '@material-ui/core/test-utils';
@@ -29,10 +28,13 @@ describe('<IconButton />', () => {
     mount.cleanUp();
   });
 
-  it('should render a ButtonBase', () => {
-    const wrapper = shallow(<IconButton>book</IconButton>);
-    assert.strictEqual(wrapper.type(), ButtonBase);
-  });
+  describeConformance(<IconButton>book</IconButton>, () => ({
+    classes,
+    inheritComponent: ButtonBase,
+    mount,
+    refInstanceof: window.HTMLButtonElement,
+    testComponentPropWith: false,
+  }));
 
   it('should render an inner label span (bloody safari)', () => {
     const wrapper = shallow(<IconButton>book</IconButton>);
@@ -69,22 +71,6 @@ describe('<IconButton />', () => {
     assert.strictEqual(wrapper.props().disableRipple, true);
   });
 
-  it('should spread props on ButtonBase', () => {
-    const wrapper = shallow(
-      <IconButton data-test="hello" disableRipple>
-        book
-      </IconButton>,
-    );
-    assert.strictEqual(wrapper.props()['data-test'], 'hello');
-    assert.strictEqual(wrapper.props().disableRipple, true);
-  });
-
-  it('should render with the user and root classes', () => {
-    const wrapper = shallow(<IconButton className="woofIconButton">book</IconButton>);
-    assert.strictEqual(wrapper.hasClass('woofIconButton'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
-
   it('should pass centerRipple={true} to ButtonBase', () => {
     const wrapper = shallow(<IconButton>book</IconButton>);
     assert.strictEqual(wrapper.props().centerRipple, true);
@@ -126,22 +112,6 @@ describe('<IconButton />', () => {
     });
   });
 
-  describe('prop: ref', () => {
-    it('should give a reference on the native button', () => {
-      function IconButtonRef(props) {
-        return <IconButton ref={props.rootRef} />;
-      }
-      IconButtonRef.propTypes = {
-        rootRef: PropTypes.func.isRequired,
-      };
-
-      const ref = spy();
-      mount(<IconButtonRef rootRef={ref} />);
-      assert.strictEqual(ref.callCount, 1);
-      assert.strictEqual(ReactDOM.findDOMNode(ref.args[0][0]).type, 'button');
-    });
-  });
-
   describe('Firefox onClick', () => {
     beforeEach(() => {
       consoleErrorMock.spy();
diff --git a/packages/material-ui/src/InputAdornment/InputAdornment.test.js b/packages/material-ui/src/InputAdornment/InputAdornment.test.js
index a5c3e6973742ec..cbee081d1dd73e 100644
--- a/packages/material-ui/src/InputAdornment/InputAdornment.test.js
+++ b/packages/material-ui/src/InputAdornment/InputAdornment.test.js
@@ -1,6 +1,11 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createMount, getClasses, findOutermostIntrinsic } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  getClasses,
+  describeConformance,
+  findOutermostIntrinsic,
+} from '@material-ui/core/test-utils';
 import consoleErrorMock from 'test/utils/consoleErrorMock';
 import Typography from '../Typography';
 import InputAdornment from './InputAdornment';
@@ -21,21 +26,13 @@ describe('<InputAdornment />', () => {
     mount.cleanUp();
   });
 
-  it('should render a div', () => {
-    const wrapper = mount(<InputAdornment position="start">foo</InputAdornment>);
-    const adornment = findOutermostIntrinsic(wrapper);
-    assert.strictEqual(adornment.name(), 'div');
-  });
-
-  it('should render given component', () => {
-    const wrapper = mount(
-      <InputAdornment component="span" position="start">
-        foo
-      </InputAdornment>,
-    );
-    const adornment = findOutermostIntrinsic(wrapper);
-    assert.strictEqual(adornment.name(), 'span');
-  });
+  describeConformance(<InputAdornment position="start">foo</InputAdornment>, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: 'span',
+  }));
 
   it('should wrap text children in a Typography', () => {
     const wrapper = mount(<InputAdornment position="start">foo</InputAdornment>);
diff --git a/packages/material-ui/src/InputBase/InputBase.test.js b/packages/material-ui/src/InputBase/InputBase.test.js
index 15952cad2a13eb..1a0076f60d30e9 100644
--- a/packages/material-ui/src/InputBase/InputBase.test.js
+++ b/packages/material-ui/src/InputBase/InputBase.test.js
@@ -4,6 +4,7 @@ import { assert } from 'chai';
 import { spy } from 'sinon';
 import {
   createMount,
+  describeConformance,
   findOutermostIntrinsic,
   getClasses,
   unwrap,
@@ -33,11 +34,13 @@ describe('<InputBase />', () => {
     mount.cleanUp();
   });
 
-  it('should render a <div />', () => {
-    const wrapper = mount(<InputBase />);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).name(), 'div');
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.root), true);
-  });
+  describeConformance(<InputBase />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 
   it('should render an <input /> inside the div', () => {
     const wrapper = mount(<InputBase />);
diff --git a/packages/material-ui/src/InputLabel/InputLabel.test.js b/packages/material-ui/src/InputLabel/InputLabel.test.js
index 8775c3ff295a33..68b378a8c93bae 100644
--- a/packages/material-ui/src/InputLabel/InputLabel.test.js
+++ b/packages/material-ui/src/InputLabel/InputLabel.test.js
@@ -1,9 +1,15 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import { assert } from 'chai';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  describeConformance,
+  findOutermostIntrinsic,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import FormControlContext from '../FormControl/FormControlContext';
 import InputLabel from './InputLabel';
+import FormLabel from '../FormLabel';
 
 describe('<InputLabel />', () => {
   let mount;
@@ -18,15 +24,21 @@ describe('<InputLabel />', () => {
     mount.cleanUp();
   });
 
-  it('should render a FormLabel', () => {
+  describeConformance(<InputLabel>Foo</InputLabel>, () => ({
+    classes,
+    inheritComponent: FormLabel,
+    mount,
+    refInstanceof: window.HTMLLabelElement,
+    testComponentPropWith: false,
+  }));
+
+  it('should render a label with text', () => {
     const wrapper = mount(<InputLabel>Foo</InputLabel>);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).type(), 'label');
-    assert.strictEqual(wrapper.text(), 'Foo');
+    assert.strictEqual(wrapper.find('label').text(), 'Foo');
   });
 
-  it('should have the root and animated classes by default', () => {
+  it('should have the animated class by default', () => {
     const wrapper = mount(<InputLabel>Foo</InputLabel>);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.root), true);
     assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.animated), true);
   });
 
diff --git a/packages/material-ui/src/LinearProgress/LinearProgress.test.js b/packages/material-ui/src/LinearProgress/LinearProgress.test.js
index 5986232e8f6f6f..4d278b78484dd5 100644
--- a/packages/material-ui/src/LinearProgress/LinearProgress.test.js
+++ b/packages/material-ui/src/LinearProgress/LinearProgress.test.js
@@ -1,29 +1,36 @@
 import React from 'react';
 import { assert } from 'chai';
 import consoleErrorMock from 'test/utils/consoleErrorMock';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import LinearProgress from './LinearProgress';
 
 describe('<LinearProgress />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<LinearProgress />);
   });
 
-  it('should render a div with the root class', () => {
-    const wrapper = shallow(<LinearProgress />);
-    assert.strictEqual(wrapper.name(), 'div');
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should render with the user and root classes', () => {
-    const wrapper = shallow(<LinearProgress className="woofLinearProgress" />);
-    assert.strictEqual(wrapper.hasClass('woofLinearProgress'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
+  describeConformance(<LinearProgress />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 
   it('should render indeterminate variant by default', () => {
     const wrapper = shallow(<LinearProgress />);
diff --git a/packages/material-ui/src/Link/Link.test.js b/packages/material-ui/src/Link/Link.test.js
index 007b26340dc00d..bae03ca89164c1 100644
--- a/packages/material-ui/src/Link/Link.test.js
+++ b/packages/material-ui/src/Link/Link.test.js
@@ -1,43 +1,42 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Link from './Link';
 import Typography from '../Typography';
 
 describe('<Link />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<Link href="/">Home</Link>);
   });
 
-  it('should render a <Typography> element', () => {
-    const wrapper = shallow(<Link href="/">Home</Link>);
-    assert.strictEqual(wrapper.type(), Typography);
+  after(() => {
+    mount.cleanUp();
   });
 
+  describeConformance(<Link href="/">Home</Link>, () => ({
+    classes,
+    inheritComponent: Typography,
+    mount,
+    refInstanceof: window.HTMLAnchorElement,
+    testComponentPropWith: false,
+  }));
+
   it('should render children', () => {
     const wrapper = shallow(<Link href="/">Home</Link>);
     assert.strictEqual(wrapper.contains('Home'), true);
   });
 
-  it('should render with the root class', () => {
-    const wrapper = shallow(<Link href="/">Home</Link>);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
-
-  it('should render the custom className and the root class', () => {
-    const wrapper = shallow(
-      <Link href="/" className="test-class-name">
-        Test
-      </Link>,
-    );
-    assert.strictEqual(wrapper.is('.test-class-name'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
-
   it('should pass props to the <Typography> component', () => {
     const wrapper = shallow(
       <Link href="/" color="primary">
diff --git a/packages/material-ui/src/List/List.test.js b/packages/material-ui/src/List/List.test.js
index b423da9a98adf2..26165bb2d8cee8 100644
--- a/packages/material-ui/src/List/List.test.js
+++ b/packages/material-ui/src/List/List.test.js
@@ -2,9 +2,9 @@ import React from 'react';
 import { assert } from 'chai';
 import {
   createMount,
+  describeConformance,
   findOutermostIntrinsic,
   getClasses,
-  testRef,
 } from '@material-ui/core/test-utils';
 import ListSubheader from '../ListSubheader';
 import List from './List';
@@ -23,21 +23,16 @@ describe('<List />', () => {
     mount.cleanUp();
   });
 
-  it('renders a ul by default', () => {
-    const wrapper = mount(<List />);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).type(), 'ul');
-  });
-
-  it('can render a div', () => {
-    const wrapper = mount(<List component="div" />);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).type(), 'div');
-  });
+  describeConformance(<List />, () => ({
+    classes,
+    inheritComponent: 'ul',
+    mount,
+    refInstanceof: window.HTMLUListElement,
+  }));
 
-  it('should render with the user, root and padding classes', () => {
+  it('should render with padding classes', () => {
     const wrapper = mount(<List className="woofList" />);
     const root = wrapper.find('ul');
-    assert.strictEqual(root.hasClass('woofList'), true);
-    assert.strictEqual(root.hasClass(classes.root), true);
     assert.strictEqual(root.hasClass(classes.padding), true);
   });
 
@@ -46,10 +41,6 @@ describe('<List />', () => {
     assert.strictEqual(wrapper.find('ul').hasClass(classes.padding), false);
   });
 
-  it('does forward refs', () => {
-    testRef(<List />, mount);
-  });
-
   describe('prop: subheader', () => {
     it('should render with subheader class', () => {
       const wrapper = mount(<List subheader={<ListSubheader>Title</ListSubheader>} />);
diff --git a/packages/material-ui/src/ListItem/ListItem.test.js b/packages/material-ui/src/ListItem/ListItem.test.js
index cd91fd8045747f..41928fb4b4f5ba 100644
--- a/packages/material-ui/src/ListItem/ListItem.test.js
+++ b/packages/material-ui/src/ListItem/ListItem.test.js
@@ -1,7 +1,12 @@
 import React from 'react';
 import { assert } from 'chai';
 import PropTypes from 'prop-types';
-import { getClasses, createMount, findOutermostIntrinsic } from '@material-ui/core/test-utils';
+import {
+  getClasses,
+  createMount,
+  describeConformance,
+  findOutermostIntrinsic,
+} from '@material-ui/core/test-utils';
 import consoleErrorMock from 'test/utils/consoleErrorMock';
 import ListItemText from '../ListItemText';
 import ListItemSecondaryAction from '../ListItemSecondaryAction';
@@ -24,36 +29,28 @@ describe('<ListItem />', () => {
     mount.cleanUp();
   });
 
-  it('should render a div', () => {
-    const wrapper = mount(<ListItem component="div" />);
-    const listItem = wrapper.getDOMNode();
-    assert.strictEqual(listItem.nodeName, 'DIV');
-  });
-
-  it('should render a li', () => {
-    const wrapper = mount(<ListItem />);
-    const listItem = wrapper.getDOMNode();
-    assert.strictEqual(listItem.nodeName, 'LI');
-  });
+  describeConformance(<ListItem />, () => ({
+    classes,
+    inheritComponent: 'li',
+    mount,
+    refInstanceof: window.HTMLLIElement,
+  }));
 
-  it('should render with the user, root and gutters classes', () => {
+  it('should render with gutters classes', () => {
     const wrapper = mount(<ListItem className="woofListItem" />);
-    const listItem = findOutermostIntrinsic(wrapper);
-    assert.strictEqual(listItem.hasClass('woofListItem'), true);
-    assert.strictEqual(listItem.hasClass(classes.root), true);
+    const listItem = wrapper.find('li');
     assert.strictEqual(listItem.hasClass(classes.gutters), true);
   });
 
   it('should render with the selected class', () => {
     const wrapper = mount(<ListItem selected />);
-    const listItem = findOutermostIntrinsic(wrapper);
+    const listItem = wrapper.find('li');
     assert.strictEqual(listItem.hasClass(classes.selected), true);
   });
 
   it('should disable the gutters', () => {
     const wrapper = mount(<ListItem disableGutters />);
-    const listItem = findOutermostIntrinsic(wrapper);
-    assert.strictEqual(listItem.hasClass(classes.root), true);
+    const listItem = wrapper.find('li');
     assert.strictEqual(listItem.hasClass(classes.gutters), false);
   });
 
@@ -78,18 +75,6 @@ describe('<ListItem />', () => {
     });
   });
 
-  describe('prop: component', () => {
-    it('should change the component to a', () => {
-      const wrapper = mount(<ListItem button component="a" />);
-      assert.strictEqual(wrapper.getDOMNode().nodeName, 'A');
-    });
-
-    it('should change the component to li', () => {
-      const wrapper = mount(<ListItem button component="li" />);
-      assert.strictEqual(wrapper.getDOMNode().nodeName, 'LI');
-    });
-  });
-
   describe('context: dense', () => {
     it('should forward the context', () => {
       let context = null;
diff --git a/packages/material-ui/src/ListItemIcon/ListItemIcon.test.js b/packages/material-ui/src/ListItemIcon/ListItemIcon.test.js
index 08debf8c3284d6..539e0552c52f11 100644
--- a/packages/material-ui/src/ListItemIcon/ListItemIcon.test.js
+++ b/packages/material-ui/src/ListItemIcon/ListItemIcon.test.js
@@ -1,13 +1,20 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import ListItemIcon from './ListItemIcon';
 
 describe('<ListItemIcon />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(
       <ListItemIcon>
@@ -16,6 +23,23 @@ describe('<ListItemIcon />', () => {
     );
   });
 
+  after(() => {
+    mount.cleanUp();
+  });
+
+  describeConformance(
+    <ListItemIcon>
+      <div />
+    </ListItemIcon>,
+    () => ({
+      classes,
+      inheritComponent: 'div',
+      mount,
+      refInstanceof: window.HTMLDivElement,
+      testComponentPropWith: false,
+    }),
+  );
+
   it('should render a span inside a div', () => {
     const wrapper = shallow(
       <ListItemIcon>
@@ -25,16 +49,4 @@ describe('<ListItemIcon />', () => {
     assert.strictEqual(wrapper.name(), 'div');
     assert.strictEqual(wrapper.children().name(), 'span');
   });
-
-  it('should render a div with the user and root classes, but not the children classes', () => {
-    const wrapper = shallow(
-      <ListItemIcon className="foo">
-        <span className="bar" />
-      </ListItemIcon>,
-    );
-    assert.strictEqual(wrapper.hasClass('foo'), true);
-    assert.strictEqual(wrapper.hasClass('bar'), false);
-    assert.strictEqual(wrapper.children().hasClass('bar'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
 });
diff --git a/packages/material-ui/src/ListItemSecondaryAction/ListItemSecondaryAction.test.js b/packages/material-ui/src/ListItemSecondaryAction/ListItemSecondaryAction.test.js
index 47ddd93a6646e7..9b3e5e66b6c783 100644
--- a/packages/material-ui/src/ListItemSecondaryAction/ListItemSecondaryAction.test.js
+++ b/packages/material-ui/src/ListItemSecondaryAction/ListItemSecondaryAction.test.js
@@ -1,26 +1,25 @@
 import React from 'react';
-import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import ListItemSecondaryAction from './ListItemSecondaryAction';
 
 describe('<ListItemSecondaryAction />', () => {
-  let shallow;
+  let mount;
   let classes;
 
   before(() => {
-    shallow = createShallow({ untilSelector: 'ListItemSecondaryAction' });
+    mount = createMount();
     classes = getClasses(<ListItemSecondaryAction />);
   });
 
-  it('should render a div', () => {
-    const wrapper = shallow(<ListItemSecondaryAction />);
-    assert.strictEqual(wrapper.name(), 'div');
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should render with the user and root classes', () => {
-    const wrapper = shallow(<ListItemSecondaryAction className="woofListItemSecondaryAction" />);
-    assert.strictEqual(wrapper.hasClass('woofListItemSecondaryAction'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
+  describeConformance(<ListItemSecondaryAction />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 });
diff --git a/packages/material-ui/src/ListItemText/ListItemText.test.js b/packages/material-ui/src/ListItemText/ListItemText.test.js
index 044f4254e34a51..0d8e5d9d85b744 100644
--- a/packages/material-ui/src/ListItemText/ListItemText.test.js
+++ b/packages/material-ui/src/ListItemText/ListItemText.test.js
@@ -1,6 +1,11 @@
 import React from 'react';
 import { assert } from 'chai';
-import { getClasses, createMount, findOutermostIntrinsic } from '@material-ui/core/test-utils';
+import {
+  getClasses,
+  createMount,
+  describeConformance,
+  findOutermostIntrinsic,
+} from '@material-ui/core/test-utils';
 import Typography from '../Typography';
 import ListItemText from './ListItemText';
 
@@ -17,19 +22,13 @@ describe('<ListItemText />', () => {
     mount.cleanUp();
   });
 
-  it('should render a div', () => {
-    const wrapper = mount(<ListItemText />);
-    const listItemText = findOutermostIntrinsic(wrapper);
-    assert.strictEqual(listItemText.name(), 'div');
-    assert.strictEqual(listItemText.hasClass(classes.root), true);
-  });
-
-  it('should render with the user and root classes', () => {
-    const wrapper = mount(<ListItemText className="woofListItemText" />);
-    const listItemText = findOutermostIntrinsic(wrapper);
-    assert.strictEqual(listItemText.hasClass('woofListItemText'), true);
-    assert.strictEqual(listItemText.hasClass(classes.root), true);
-  });
+  describeConformance(<ListItemText />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 
   it('should render with inset class', () => {
     const wrapper = mount(<ListItemText inset />);
diff --git a/packages/material-ui/src/ListSubheader/ListSubheader.test.js b/packages/material-ui/src/ListSubheader/ListSubheader.test.js
index 80e180d217cd9f..79ab288c128645 100644
--- a/packages/material-ui/src/ListSubheader/ListSubheader.test.js
+++ b/packages/material-ui/src/ListSubheader/ListSubheader.test.js
@@ -1,27 +1,34 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import ListSubheader from './ListSubheader';
 
 describe('<ListSubheader />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<ListSubheader />);
   });
 
-  it('should render a li', () => {
-    const wrapper = shallow(<ListSubheader />);
-    assert.strictEqual(wrapper.name(), 'li');
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should render with the user and root classes', () => {
-    const wrapper = shallow(<ListSubheader className="woofListSubheader" />);
-    assert.strictEqual(wrapper.hasClass('woofListSubheader'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
+  describeConformance(<ListSubheader />, () => ({
+    classes,
+    inheritComponent: 'li',
+    mount,
+    refInstanceof: window.HTMLLIElement,
+  }));
 
   it('should display primary color', () => {
     const wrapper = shallow(<ListSubheader color="primary" />);
diff --git a/packages/material-ui/src/MenuItem/MenuItem.test.js b/packages/material-ui/src/MenuItem/MenuItem.test.js
index b60920ce039aec..42cc803422a922 100644
--- a/packages/material-ui/src/MenuItem/MenuItem.test.js
+++ b/packages/material-ui/src/MenuItem/MenuItem.test.js
@@ -1,7 +1,12 @@
 import React from 'react';
 import { assert } from 'chai';
 import { spy } from 'sinon';
-import { createShallow, getClasses, createMount } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  getClasses,
+  createMount,
+  describeConformance,
+} from '@material-ui/core/test-utils';
 import ListItem from '../ListItem';
 import ListItemSecondaryAction from '../ListItemSecondaryAction';
 import MenuItem from './MenuItem';
@@ -21,17 +26,19 @@ describe('<MenuItem />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(<MenuItem />, () => ({
+    classes,
+    inheritComponent: ListItem,
+    mount,
+    refInstanceof: window.HTMLLIElement,
+    testComponentPropWith: 'a',
+  }));
+
   it('should render a button ListItem with with ripple', () => {
     const wrapper = shallow(<MenuItem />);
     assert.strictEqual(wrapper.type(), ListItem);
-    assert.strictEqual(wrapper.props().button, true);
-    assert.strictEqual(wrapper.props().disableRipple, undefined);
-  });
-
-  it('should render with the user and root classes', () => {
-    const wrapper = shallow(<MenuItem className="woofMenuItem" />);
-    assert.strictEqual(wrapper.hasClass('woofMenuItem'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
+    assert.strictEqual(wrapper.find(ListItem).props().button, true);
+    assert.strictEqual(wrapper.find(ListItem).props().disableRipple, undefined);
   });
 
   it('should render with the selected class', () => {
@@ -84,15 +91,6 @@ describe('<MenuItem />', () => {
     });
   });
 
-  describe('prop: component', () => {
-    it('should be able to override the rendered component', () => {
-      const wrapper = shallow(<MenuItem component="a" />);
-
-      assert.strictEqual(wrapper.props().component, 'a');
-      assert.strictEqual(wrapper.props().disableRipple, undefined);
-    });
-  });
-
   describe('mount', () => {
     it('should not fail with a li > li error message', () => {
       const wrapper1 = mount(
diff --git a/packages/material-ui/src/MobileStepper/MobileStepper.test.js b/packages/material-ui/src/MobileStepper/MobileStepper.test.js
index 0323bd08f77bf9..92a9ed2fb7ad2f 100644
--- a/packages/material-ui/src/MobileStepper/MobileStepper.test.js
+++ b/packages/material-ui/src/MobileStepper/MobileStepper.test.js
@@ -1,6 +1,11 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import KeyboardArrowLeft from '../internal/svg-icons/KeyboardArrowLeft';
 import KeyboardArrowRight from '../internal/svg-icons/KeyboardArrowRight';
 import Paper from '../Paper';
@@ -9,6 +14,7 @@ import LinearProgress from '../LinearProgress';
 import MobileStepper from './MobileStepper';
 
 describe('<MobileStepper />', () => {
+  let mount;
   let shallow;
   let classes;
   const defaultProps = {
@@ -28,25 +34,26 @@ describe('<MobileStepper />', () => {
   };
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<MobileStepper {...defaultProps} />);
   });
 
-  it('should render a Paper component', () => {
-    const wrapper = shallow(<MobileStepper {...defaultProps} />);
-    assert.strictEqual(wrapper.type(), Paper);
-    assert.strictEqual(wrapper.props().elevation, 0);
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should render with the root class', () => {
-    const wrapper = shallow(<MobileStepper {...defaultProps} />);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
+  describeConformance(<MobileStepper {...defaultProps} />, () => ({
+    classes,
+    inheritComponent: Paper,
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 
-  it('should render the custom className and the root class', () => {
-    const wrapper = shallow(<MobileStepper className="test-class-name" {...defaultProps} />);
-    assert.strictEqual(wrapper.is('.test-class-name'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
+  it('should render a Paper with 0 elevation', () => {
+    const wrapper = mount(<MobileStepper {...defaultProps} />);
+    assert.strictEqual(wrapper.find(Paper).props().elevation, 0);
   });
 
   it('should render with the bottom class if position prop is set to bottom', () => {
diff --git a/packages/material-ui/src/Modal/Modal.test.js b/packages/material-ui/src/Modal/Modal.test.js
index e496f09cf5e9f3..1720563e523353 100644
--- a/packages/material-ui/src/Modal/Modal.test.js
+++ b/packages/material-ui/src/Modal/Modal.test.js
@@ -3,7 +3,12 @@ import { assert } from 'chai';
 import { spy, stub } from 'sinon';
 import PropTypes from 'prop-types';
 import consoleErrorMock from 'test/utils/consoleErrorMock';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  findOutermostIntrinsic,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Fade from '../Fade';
 import Portal from '../Portal';
 import Backdrop from '../Backdrop';
@@ -32,6 +37,19 @@ describe('<Modal />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(
+    <Modal open>
+      <div />
+    </Modal>,
+    () => ({
+      classes,
+      inheritComponent: 'div',
+      mount,
+      refInstanceof: window.HTMLDivElement,
+      testComponentPropWith: false,
+    }),
+  );
+
   describe('prop: open', () => {
     it('should not render the children by default', () => {
       const wrapper = mount(
diff --git a/packages/material-ui/src/Paper/Paper.test.js b/packages/material-ui/src/Paper/Paper.test.js
index a01f1cf3eebeaa..04b248a6ab289f 100644
--- a/packages/material-ui/src/Paper/Paper.test.js
+++ b/packages/material-ui/src/Paper/Paper.test.js
@@ -1,6 +1,11 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createMount, createShallow, getClasses, testRef } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Paper from './Paper';
 
 describe('<Paper />', () => {
@@ -18,20 +23,24 @@ describe('<Paper />', () => {
     mount.cleanUp();
   });
 
-  it('should render a div', () => {
-    const wrapper = shallow(<Paper>Hello World</Paper>);
-    assert.strictEqual(wrapper.name(), 'div');
-  });
+  describeConformance(<Paper />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: 'header',
+  }));
 
-  it('should render with the root class, default depth class', () => {
-    const wrapper = shallow(<Paper>Hello World</Paper>);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-    assert.strictEqual(wrapper.hasClass(classes.rounded), true);
-  });
+  describe('prop: square', () => {
+    it('can disable the rounded class', () => {
+      const wrapper = mount(<Paper square>Hello World</Paper>);
+      assert.strictEqual(wrapper.find(`.${classes.root}`).some(`.${classes.rounded}`), false);
+    });
 
-  it('should disable the rounded class', () => {
-    const wrapper = shallow(<Paper square>Hello World</Paper>);
-    assert.strictEqual(wrapper.hasClass(classes.rounded), false);
+    it('adds a rounded class to the root when omitted', () => {
+      const wrapper = mount(<Paper>Hello World</Paper>);
+      assert.strictEqual(wrapper.find(`.${classes.root}`).every(`.${classes.rounded}`), true);
+    });
   });
 
   it('should set the elevation elevation class', () => {
@@ -54,15 +63,4 @@ describe('<Paper />', () => {
       'should have the 2 elevation class',
     );
   });
-
-  it('does forward refs', () => {
-    testRef(<Paper />, mount);
-  });
-
-  describe('prop: component', () => {
-    it('should render a header', () => {
-      const wrapper = shallow(<Paper component="header">Hello World</Paper>);
-      assert.strictEqual(wrapper.name(), 'header');
-    });
-  });
 });
diff --git a/packages/material-ui/src/Radio/Radio.test.js b/packages/material-ui/src/Radio/Radio.test.js
index 0f6bdaac0f84fb..1aaca1e7d2ed27 100644
--- a/packages/material-ui/src/Radio/Radio.test.js
+++ b/packages/material-ui/src/Radio/Radio.test.js
@@ -2,7 +2,12 @@ import React from 'react';
 import { assert } from 'chai';
 import RadioButtonCheckedIcon from '../internal/svg-icons/RadioButtonChecked';
 import RadioButtonUncheckedIcon from '../internal/svg-icons/RadioButtonUnchecked';
-import { getClasses, createShallow, createMount } from '@material-ui/core/test-utils';
+import {
+  getClasses,
+  createShallow,
+  createMount,
+  describeConformance,
+} from '@material-ui/core/test-utils';
 import SwitchBase from '../internal/SwitchBase';
 import Radio from './Radio';
 
@@ -21,6 +26,14 @@ describe('<Radio />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(<Radio />, () => ({
+    classes,
+    inheritComponent: 'span',
+    mount,
+    refInstanceof: window.HTMLSpanElement,
+    testComponentPropWith: false,
+  }));
+
   describe('styleSheet', () => {
     it('should have the classes required for SwitchBase', () => {
       assert.strictEqual(typeof classes.root, 'string');
diff --git a/packages/material-ui/src/Snackbar/Snackbar.test.js b/packages/material-ui/src/Snackbar/Snackbar.test.js
index 12c1368f7df77f..01659025013873 100644
--- a/packages/material-ui/src/Snackbar/Snackbar.test.js
+++ b/packages/material-ui/src/Snackbar/Snackbar.test.js
@@ -1,7 +1,7 @@
 import React from 'react';
 import { assert } from 'chai';
 import { spy, useFakeTimers } from 'sinon';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import Snackbar from './Snackbar';
 import Slide from '../Slide';
 
@@ -18,16 +18,13 @@ describe('<Snackbar />', () => {
     mount.cleanUp();
   });
 
-  it('should render a ClickAwayListener with classes', () => {
-    const wrapper = mount(<Snackbar open message="message" />);
-    assert.strictEqual(wrapper.find('ClickAwayListener').exists(), true);
-    assert.strictEqual(
-      findOutermostIntrinsic(wrapper).hasClass(classes.root),
-      true,
-      'should have the root class',
-    );
-    assert.strictEqual(wrapper.find(Slide).exists(), true, 'should use a Slide by default');
-  });
+  describeConformance(<Snackbar open message="message" />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 
   describe('prop: onClose', () => {
     it('should be call when clicking away', () => {
@@ -384,7 +381,12 @@ describe('<Snackbar />', () => {
   });
 
   describe('prop: TransitionComponent', () => {
-    it('should render a Snackbar with TransitionComponent', () => {
+    it('should use a Slide by default', () => {
+      const wrapper = mount(<Snackbar open message="message" />);
+      assert.strictEqual(wrapper.find(Slide).exists(), true, 'should use a Slide by default');
+    });
+
+    it('accepts a different component that handles the transition', () => {
       const Transition = () => <div className="cloned-element-class" />;
       const wrapper = mount(<Snackbar open TransitionComponent={Transition} />);
       assert.strictEqual(wrapper.find(Transition).exists(), true);
diff --git a/packages/material-ui/src/SnackbarContent/SnackbarContent.test.js b/packages/material-ui/src/SnackbarContent/SnackbarContent.test.js
index 05e1dfa89c186c..84657f8de02430 100644
--- a/packages/material-ui/src/SnackbarContent/SnackbarContent.test.js
+++ b/packages/material-ui/src/SnackbarContent/SnackbarContent.test.js
@@ -1,23 +1,37 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  createMount,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
+import Paper from '../Paper';
 import SnackbarContent from './SnackbarContent';
 
 describe('<SnackbarContent />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ untilSelector: 'withStyles(Paper)' });
     classes = getClasses(<SnackbarContent message="message" />);
   });
 
-  it('should render a Paper with classes', () => {
-    const wrapper = shallow(<SnackbarContent message="message" />);
-    assert.strictEqual(wrapper.name(), 'div');
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
+  after(() => {
+    mount.cleanUp();
   });
 
+  describeConformance(<SnackbarContent message="conform?" />, () => ({
+    classes,
+    inheritComponent: Paper,
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
+
   describe('prop: action', () => {
     it('should render the action', () => {
       const action = <span>action</span>;
diff --git a/packages/material-ui/src/Step/Step.test.js b/packages/material-ui/src/Step/Step.test.js
index 42b7561c89a47f..7d4e48b2138281 100644
--- a/packages/material-ui/src/Step/Step.test.js
+++ b/packages/material-ui/src/Step/Step.test.js
@@ -1,13 +1,20 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, createMount } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  createMount,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Step from './Step';
 
 describe('<Step />', () => {
+  let classes;
   let shallow;
   let mount;
 
   before(() => {
+    classes = getClasses(<Step />);
     shallow = createShallow({ dive: true });
     mount = createMount();
   });
@@ -16,6 +23,14 @@ describe('<Step />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(<Step />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
+
   it('merges styles and other props into the root node', () => {
     const wrapper = shallow(
       <Step
diff --git a/packages/material-ui/src/StepButton/StepButton.test.js b/packages/material-ui/src/StepButton/StepButton.test.js
index 9a16c6574626e2..9e1da4aa6f0d2d 100644
--- a/packages/material-ui/src/StepButton/StepButton.test.js
+++ b/packages/material-ui/src/StepButton/StepButton.test.js
@@ -1,17 +1,24 @@
 import React from 'react';
 import { assert } from 'chai';
 import { spy } from 'sinon';
-import { createShallow, createMount } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  createMount,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import StepButton from './StepButton';
 import StepLabel from '../StepLabel';
 import ButtonBase from '../ButtonBase';
 
 describe('<StepButton />', () => {
+  let classes;
   let shallow;
   let mount;
   const defaultProps = { orientation: 'horizontal' };
 
   before(() => {
+    classes = getClasses(<StepButton />);
     shallow = createShallow({ dive: true });
     mount = createMount();
   });
@@ -20,27 +27,17 @@ describe('<StepButton />', () => {
     mount.cleanUp();
   });
 
-  it('merges user className into the root node', () => {
-    const wrapper = shallow(
-      <StepButton className="foo" {...defaultProps}>
-        Hello
-      </StepButton>,
-    );
+  describeConformance(<StepButton {...defaultProps} />, () => ({
+    classes,
+    inheritComponent: ButtonBase,
+    mount,
+    refInstanceof: window.HTMLButtonElement,
+    testComponentPropWith: false,
+  }));
 
-    assert.include(wrapper.props().className, 'foo');
-  });
-
-  it('should render an ButtonBase with a StepLabel', () => {
-    const wrapper = shallow(<StepButton {...defaultProps}>Step One</StepButton>);
-    assert.strictEqual(wrapper.type(), ButtonBase);
-    const stepLabel = wrapper.find(StepLabel);
-    assert.strictEqual(stepLabel.length, 1);
-    assert.strictEqual(stepLabel.props().children, 'Step One');
-  });
-
-  it('should pass props to StepLabel', () => {
+  it('passes active, completed, disabled to StepLabel', () => {
     const wrapper = shallow(
-      <StepButton active completed disabled label="Step One" {...defaultProps}>
+      <StepButton active completed disabled {...defaultProps}>
         Step One
       </StepButton>,
     );
@@ -48,6 +45,7 @@ describe('<StepButton />', () => {
     assert.strictEqual(stepLabel.props().active, true);
     assert.strictEqual(stepLabel.props().completed, true);
     assert.strictEqual(stepLabel.props().disabled, true);
+    assert.strictEqual(stepLabel.props().children, 'Step One');
   });
 
   it('should pass props to a provided StepLabel', () => {
@@ -62,7 +60,7 @@ describe('<StepButton />', () => {
     assert.strictEqual(stepLabel.props().disabled, true);
   });
 
-  it("should pass disabled prop to a StepLabel's Button", () => {
+  it('should pass disabled prop to the ButtonBase', () => {
     const wrapper = shallow(
       <StepButton disabled {...defaultProps}>
         Step One
diff --git a/packages/material-ui/src/StepConnector/StepConnector.test.js b/packages/material-ui/src/StepConnector/StepConnector.test.js
index eef50a2155ff58..1af38d5fc2c36f 100644
--- a/packages/material-ui/src/StepConnector/StepConnector.test.js
+++ b/packages/material-ui/src/StepConnector/StepConnector.test.js
@@ -1,6 +1,11 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, createMount, getClasses } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  createMount,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import StepConnector from './StepConnector';
 
 describe('<StepConnector />', () => {
@@ -18,6 +23,14 @@ describe('<StepConnector />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(<StepConnector />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
+
   describe('rendering', () => {
     it('renders a div containing a span', () => {
       const wrapper = shallow(<StepConnector orientation="horizontal" />);
diff --git a/packages/material-ui/src/StepContent/StepContent.test.js b/packages/material-ui/src/StepContent/StepContent.test.js
index ceae3199f913f4..f48a689c77f6d5 100644
--- a/packages/material-ui/src/StepContent/StepContent.test.js
+++ b/packages/material-ui/src/StepContent/StepContent.test.js
@@ -1,10 +1,16 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, createMount } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  createMount,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Collapse from '../Collapse';
 import StepContent from './StepContent';
 
 describe('<StepContent />', () => {
+  let classes;
   let shallow;
   let mount;
   const defaultProps = {
@@ -12,6 +18,7 @@ describe('<StepContent />', () => {
   };
 
   before(() => {
+    classes = getClasses(<StepContent />);
     shallow = createShallow({ dive: true });
     mount = createMount();
   });
@@ -20,16 +27,18 @@ describe('<StepContent />', () => {
     mount.cleanUp();
   });
 
-  it('renders a div', () => {
-    const wrapper = shallow(<StepContent {...defaultProps}>Here is the content</StepContent>);
-    assert.strictEqual(wrapper.type(), 'div');
-  });
+  describeConformance(<StepContent {...defaultProps} />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
 
   it('merges styles and other props into the root node', () => {
     const wrapper = shallow(
       <StepContent
         style={{ paddingRight: 200, color: 'purple', border: '1px solid tomato' }}
-        data-role="Tabpanel"
         {...defaultProps}
       >
         Lorem ipsum
@@ -39,7 +48,6 @@ describe('<StepContent />', () => {
     assert.strictEqual(props.style.paddingRight, 200);
     assert.strictEqual(props.style.color, 'purple');
     assert.strictEqual(props.style.border, '1px solid tomato');
-    assert.strictEqual(props['data-role'], 'Tabpanel');
   });
 
   it('renders children inside an Collapse component', () => {
diff --git a/packages/material-ui/src/StepLabel/StepLabel.test.js b/packages/material-ui/src/StepLabel/StepLabel.test.js
index f2a963526ec1b9..50e45c3b38dd19 100644
--- a/packages/material-ui/src/StepLabel/StepLabel.test.js
+++ b/packages/material-ui/src/StepLabel/StepLabel.test.js
@@ -1,6 +1,11 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, createMount, getClasses } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  createMount,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Typography from '../Typography';
 import StepIcon from '../StepIcon';
 import StepLabel from './StepLabel';
@@ -20,12 +25,19 @@ describe('<StepLabel />', () => {
     mount.cleanUp();
   });
 
-  it('merges styles and other props into the root node', () => {
+  describeConformance(<StepLabel />, () => ({
+    classes,
+    inheritComponent: 'span',
+    mount,
+    refInstanceof: window.HTMLSpanElement,
+    testComponentPropWith: false,
+  }));
+
+  it('merges styles into the root node', () => {
     const wrapper = shallow(
       <StepLabel
         orientation="horizontal"
         style={{ paddingRight: 200, color: 'purple', border: '1px solid tomato' }}
-        data-myProp="hello"
       >
         My Label
       </StepLabel>,
@@ -34,7 +46,6 @@ describe('<StepLabel />', () => {
     assert.strictEqual(props.style.paddingRight, 200);
     assert.strictEqual(props.style.color, 'purple');
     assert.strictEqual(props.style.border, '1px solid tomato');
-    assert.strictEqual(props['data-myProp'], 'hello');
   });
 
   describe('label content', () => {
@@ -166,23 +177,6 @@ describe('<StepLabel />', () => {
     });
   });
 
-  describe('prop: classes', () => {
-    it('should set iconContainer', () => {
-      const wrapper = shallow(
-        <StepLabel classes={{ iconContainer: 'my-custom-class' }} icon={1}>
-          Step One
-        </StepLabel>,
-      );
-      assert.include(
-        wrapper
-          .find('span')
-          .at(1)
-          .props().className,
-        'my-custom-class',
-      );
-    });
-  });
-
   describe('prop: optional = Optional Text', () => {
     it('creates a <Typography> component with text "Optional Text"', () => {
       const wrapper = shallow(
diff --git a/packages/material-ui/src/Stepper/Stepper.test.js b/packages/material-ui/src/Stepper/Stepper.test.js
index 603e8f0343314c..00f7370f4c912a 100644
--- a/packages/material-ui/src/Stepper/Stepper.test.js
+++ b/packages/material-ui/src/Stepper/Stepper.test.js
@@ -1,7 +1,12 @@
 import React from 'react';
 import { assert } from 'chai';
 import CheckCircle from '../internal/svg-icons/CheckCircle';
-import { createShallow, createMount } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  createMount,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Paper from '../Paper';
 import Step from '../Step';
 import StepLabel from '../StepLabel';
@@ -10,10 +15,12 @@ import StepContent from '../StepContent';
 import Stepper from './Stepper';
 
 describe('<Stepper />', () => {
+  let classes;
   let shallow;
   let mount;
 
   before(() => {
+    classes = getClasses(<Stepper />);
     shallow = createShallow({ dive: true });
     mount = createMount();
   });
@@ -22,24 +29,26 @@ describe('<Stepper />', () => {
     mount.cleanUp();
   });
 
-  it('merges user className into the root node', () => {
-    const wrapper = shallow(
-      <Stepper className="foo">
-        <Step />
-      </Stepper>,
-    );
-
-    assert.include(wrapper.props().className, 'foo');
-  });
-
-  it('should render a Paper component', () => {
-    const wrapper = shallow(
+  describeConformance(
+    <Stepper>
+      <Step />
+    </Stepper>,
+    () => ({
+      classes,
+      inheritComponent: Paper,
+      mount,
+      refInstanceof: window.HTMLDivElement,
+      testComponentPropWith: false,
+    }),
+  );
+
+  it('has no elevation by default', () => {
+    const wrapper = mount(
       <Stepper>
         <Step />
       </Stepper>,
     );
-    assert.strictEqual(wrapper.type(), Paper);
-    assert.strictEqual(wrapper.props().elevation, 0, 'should have no elevation');
+    assert.strictEqual(wrapper.find(Paper).props().elevation, 0, 'should have no elevation');
   });
 
   describe('rendering children', () => {
diff --git a/packages/material-ui/src/SvgIcon/SvgIcon.test.js b/packages/material-ui/src/SvgIcon/SvgIcon.test.js
index e1a608b20abaa6..0a80d59fd98ff4 100644
--- a/packages/material-ui/src/SvgIcon/SvgIcon.test.js
+++ b/packages/material-ui/src/SvgIcon/SvgIcon.test.js
@@ -1,6 +1,11 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, createMount, getClasses } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  createMount,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import SvgIcon from './SvgIcon';
 
 describe('<SvgIcon />', () => {
@@ -20,27 +25,36 @@ describe('<SvgIcon />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(
+    <SvgIcon>
+      <path />
+    </SvgIcon>,
+    () => ({
+      classes,
+      inheritComponent: 'svg',
+      mount,
+      refInstanceof: window.SVGSVGElement,
+      testComponentPropWith: props => (
+        <svg {...props}>
+          <defs>
+            <linearGradient id="gradient1">
+              <stop offset="20%" stopColor="#39F" />
+              <stop offset="90%" stopColor="#F3F" />
+            </linearGradient>
+          </defs>
+          {/* eslint-disable-next-line react/prop-types */}
+          {props.children}
+        </svg>
+      ),
+    }),
+  );
+
   it('renders children by default', () => {
     const wrapper = shallow(<SvgIcon>{path}</SvgIcon>);
     assert.strictEqual(wrapper.contains(path), true);
     assert.strictEqual(wrapper.props()['aria-hidden'], 'true');
   });
 
-  it('should render an svg', () => {
-    const wrapper = shallow(<SvgIcon>book</SvgIcon>);
-    assert.strictEqual(wrapper.name(), 'svg');
-  });
-
-  it('should spread props on svg', () => {
-    const wrapper = shallow(
-      <SvgIcon data-test="hello" viewBox="0 0 32 32">
-        {path}
-      </SvgIcon>,
-    );
-    assert.strictEqual(wrapper.props()['data-test'], 'hello');
-    assert.strictEqual(wrapper.props().viewBox, '0 0 32 32');
-  });
-
   describe('prop: titleAccess', () => {
     it('should be able to make an icon accessible', () => {
       const wrapper = shallow(
@@ -87,27 +101,4 @@ describe('<SvgIcon />', () => {
       assert.strictEqual(wrapper.hasClass(classes.fontSizeInherit), true);
     });
   });
-
-  describe('prop: component', () => {
-    it('should render component before path', () => {
-      const wrapper = mount(
-        <SvgIcon
-          component={props => (
-            <svg {...props}>
-              <defs>
-                <linearGradient id="gradient1">
-                  <stop offset="20%" stopColor="#39F" />
-                  <stop offset="90%" stopColor="#F3F" />
-                </linearGradient>
-              </defs>
-              {props.children}
-            </svg>
-          )}
-        >
-          {path}
-        </SvgIcon>,
-      );
-      assert.strictEqual(wrapper.find('defs').length, 1);
-    });
-  });
 });
diff --git a/packages/material-ui/src/Tab/Tab.test.js b/packages/material-ui/src/Tab/Tab.test.js
index 0f84d5b8752163..0d4da8cee41b45 100644
--- a/packages/material-ui/src/Tab/Tab.test.js
+++ b/packages/material-ui/src/Tab/Tab.test.js
@@ -4,6 +4,7 @@ import { spy } from 'sinon';
 import {
   createShallow,
   createMount,
+  describeConformance,
   getClasses,
   findOutermostIntrinsic,
 } from '@material-ui/core/test-utils';
@@ -27,25 +28,13 @@ describe('<Tab />', () => {
     mount.cleanUp();
   });
 
-  it('should render with the root class', () => {
-    const wrapper = mount(<Tab textColor="inherit" />);
-    const root = wrapper.find(`.${classes.root}`).first();
-    assert.strictEqual(root.exists(), true);
-    assert.strictEqual(root.type(), ButtonBase);
-  });
-
-  describe('prop: className', () => {
-    it('should render with the user and root classes', () => {
-      const wrapper = mount(<Tab textColor="inherit" className="woofTab" />);
-      assert.strictEqual(
-        wrapper
-          .find(`.${classes.root}`)
-          .first()
-          .hasClass('woofTab'),
-        true,
-      );
-    });
-  });
+  describeConformance(<Tab textColor="inherit" />, () => ({
+    classes,
+    inheritComponent: ButtonBase,
+    mount,
+    refInstanceof: window.HTMLButtonElement,
+    testComponentPropWith: false,
+  }));
 
   describe('prop: selected', () => {
     it('should render with the selected and root classes', () => {
diff --git a/packages/material-ui/src/Table/Table.test.js b/packages/material-ui/src/Table/Table.test.js
index 802ecf1c01a090..f493df88fb7786 100644
--- a/packages/material-ui/src/Table/Table.test.js
+++ b/packages/material-ui/src/Table/Table.test.js
@@ -1,8 +1,9 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import Table from './Table';
 import TableContext from './TableContext';
+import findOutermostIntrinsic from '../test-utils/findOutermostIntrinsic';
 
 describe('<Table />', () => {
   let mount;
@@ -13,41 +14,29 @@ describe('<Table />', () => {
     classes = getClasses(<Table>foo</Table>);
   });
 
-  it('should render a table', () => {
-    const wrapper = mount(
-      <Table>
-        <tbody />
-      </Table>,
-    );
-    assert.strictEqual(wrapper.getDOMNode().nodeName, 'TABLE');
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should render a div', () => {
-    const wrapper = mount(<Table component="div">foo</Table>);
-    assert.strictEqual(wrapper.getDOMNode().nodeName, 'DIV');
-  });
-
-  it('should spread custom props on the root node', () => {
-    const wrapper = mount(
-      <Table data-my-prop="woofTable">
-        <tbody />
-      </Table>,
-    );
-    assert.strictEqual(
-      wrapper.props()['data-my-prop'],
-      'woofTable',
-      'custom prop should be woofTable',
-    );
-  });
+  describeConformance(
+    <Table>
+      <tbody />
+    </Table>,
+    () => ({
+      classes,
+      inheritComponent: 'table',
+      mount,
+      refInstanceof: window.HTMLTableElement,
+      // can't test another component with tbody as a child
+      testComponentPropWith: 'table',
+    }),
+  );
 
-  it('should render with the user and root classes', () => {
-    const wrapper = mount(
-      <Table className="woofTable">
-        <tbody />
-      </Table>,
-    );
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass('woofTable'), true);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.root), true);
+  describe('prop: component', () => {
+    it('can render a different component', () => {
+      const wrapper = mount(<Table component="div">foo</Table>);
+      assert.strictEqual(findOutermostIntrinsic(wrapper).type(), 'div');
+    });
   });
 
   it('should render children', () => {
@@ -59,6 +48,7 @@ describe('<Table />', () => {
   it('should define table in the child context', () => {
     let context;
 
+    // TODO test integration with TableCell
     mount(
       <Table>
         <TableContext.Consumer>
diff --git a/packages/material-ui/src/TableBody/TableBody.test.js b/packages/material-ui/src/TableBody/TableBody.test.js
index 3852142f85c69e..8221088b34e1cd 100644
--- a/packages/material-ui/src/TableBody/TableBody.test.js
+++ b/packages/material-ui/src/TableBody/TableBody.test.js
@@ -1,6 +1,6 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import TableBody from './TableBody';
 import Tablelvl2Context from '../Table/Tablelvl2Context';
 
@@ -10,12 +10,11 @@ describe('<TableBody />', () => {
 
   function mountInTable(node) {
     const wrapper = mount(<table>{node}</table>);
-    return wrapper.childAt(0);
+    return wrapper.find('table').childAt(0);
   }
 
   before(() => {
     mount = createMount();
-
     classes = getClasses(<TableBody />);
   });
 
@@ -23,21 +22,14 @@ describe('<TableBody />', () => {
     mount.cleanUp();
   });
 
-  it('should render a tbody', () => {
-    const wrapper = mountInTable(<TableBody />);
-    assert.strictEqual(wrapper.getDOMNode().nodeName, 'TBODY');
-  });
-
-  it('should render a div', () => {
-    const wrapper = mount(<TableBody component="div">foo</TableBody>);
-    assert.strictEqual(wrapper.getDOMNode().nodeName, 'DIV');
-  });
-
-  it('should render with the user and root class', () => {
-    const wrapper = mountInTable(<TableBody className="woofTableBody" />);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass('woofTableBody'), true);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.root), true);
-  });
+  describeConformance(<TableBody />, () => ({
+    classes,
+    inheritComponent: 'tbody',
+    mount: mountInTable,
+    refInstanceof: window.HTMLTableSectionElement,
+    // can't test with custom `component` with `mountInTable`
+    testComponentPropWith: 'tbody',
+  }));
 
   it('should render children', () => {
     const children = <tr className="test" />;
@@ -47,6 +39,7 @@ describe('<TableBody />', () => {
 
   it('should define table.body in the child context', () => {
     let context;
+    // TODO test integration with TableCell
     mountInTable(
       <TableBody>
         <Tablelvl2Context.Consumer>
diff --git a/packages/material-ui/src/TableCell/TableCell.test.js b/packages/material-ui/src/TableCell/TableCell.test.js
index f8338177a29e53..e3d404ee763062 100644
--- a/packages/material-ui/src/TableCell/TableCell.test.js
+++ b/packages/material-ui/src/TableCell/TableCell.test.js
@@ -1,6 +1,11 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createMount, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  describeConformance,
+  findOutermostIntrinsic,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import TableCell from './TableCell';
 
 describe('<TableCell />', () => {
@@ -14,10 +19,7 @@ describe('<TableCell />', () => {
         </tbody>
       </table>,
     );
-    return wrapper
-      .childAt(0)
-      .childAt(0)
-      .childAt(0);
+    return wrapper.find('tr').childAt(0);
   }
 
   before(() => {
@@ -25,50 +27,39 @@ describe('<TableCell />', () => {
     classes = getClasses(<TableCell />);
   });
 
-  it('should render a td', () => {
-    const wrapper = mountInTable(<TableCell />);
-    assert.strictEqual(wrapper.getDOMNode().nodeName, 'TD');
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should spread custom props on the root node', () => {
-    const wrapper = mountInTable(<TableCell data-my-prop="woofTableCell" />);
-    assert.strictEqual(
-      wrapper.find('td').props()['data-my-prop'],
-      'woofTableCell',
-      'custom prop should be woofTableCell',
-    );
-  });
+  describeConformance(<TableCell />, () => ({
+    classes,
+    inheritComponent: 'td',
+    mount: mountInTable,
+    refInstanceof: window.HTMLTableCellElement,
+    // invalid nesting otherwise
+    testComponentPropWith: 'td',
+  }));
 
-  it('should render with the user, root and padding classes', () => {
-    const wrapper = mountInTable(<TableCell className="woofTableCell" />);
-    assert.strictEqual(wrapper.find('td').hasClass('woofTableCell'), true);
-    assert.strictEqual(wrapper.find('td').hasClass(classes.root), true);
-    assert.strictEqual(wrapper.find('td').hasClass(classes.paddingDefault), false);
-  });
+  describe('prop: padding', () => {
+    it('doesn not have a class for padding by default', () => {
+      const wrapper = mountInTable(<TableCell padding="default" />);
+      assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.paddingDefault), false);
+    });
 
-  it('should render with the user, root and without the padding classes', () => {
-    const wrapper = mountInTable(<TableCell className="woofTableCell" padding="none" />);
-    assert.strictEqual(wrapper.find('td').hasClass('woofTableCell'), true);
-    assert.strictEqual(wrapper.find('td').hasClass(classes.root), true);
-    assert.strictEqual(
-      wrapper.find('td').hasClass(classes.paddingDefault),
-      false,
-      'should not have the padding class',
-    );
-  });
+    it('has a class when `none`', () => {
+      const wrapper = mountInTable(<TableCell className="woofTableCell" padding="none" />);
+      assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.paddingNone), true);
+    });
 
-  it('should render with the user, root, padding, and checkbox classes', () => {
-    const wrapper = mountInTable(<TableCell className="woofTableCell" padding="checkbox" />);
-    assert.strictEqual(wrapper.find('td').hasClass('woofTableCell'), true);
-    assert.strictEqual(wrapper.find('td').hasClass(classes.root), true);
-    assert.strictEqual(wrapper.find('td').hasClass(classes.paddingCheckbox), true);
+    it('has a class when `checkbox`', () => {
+      const wrapper = mountInTable(<TableCell className="woofTableCell" padding="checkbox" />);
+      assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.paddingCheckbox), true);
+    });
   });
 
-  it('should render with the user, root, padding, and small classes', () => {
+  it('has a class when `size="small"`', () => {
     const wrapper = mountInTable(<TableCell className="woofTableCell" size="small" />);
-    assert.strictEqual(wrapper.find('td').hasClass('woofTableCell'), true);
-    assert.strictEqual(wrapper.find('td').hasClass(classes.root), true);
-    assert.strictEqual(wrapper.find('td').hasClass(classes.sizeSmall), true);
+    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.sizeSmall), true);
   });
 
   it('should render children', () => {
@@ -77,12 +68,6 @@ describe('<TableCell />', () => {
     assert.strictEqual(wrapper.contains(children), true);
   });
 
-  it('should render a div when custom component prop is used', () => {
-    const wrapper = mount(<TableCell component="div" />);
-    assert.strictEqual(wrapper.getDOMNode().nodeName, 'DIV');
-    assert.strictEqual(wrapper.find('div').hasClass(classes.root), true);
-  });
-
   it('should render aria-sort="ascending" when prop sortDirection="asc" provided', () => {
     const wrapper = mountInTable(<TableCell sortDirection="asc" />);
     assert.strictEqual(wrapper.find('td').props()['aria-sort'], 'ascending');
diff --git a/packages/material-ui/src/TableFooter/TableFooter.test.js b/packages/material-ui/src/TableFooter/TableFooter.test.js
index 0590b3a45259bc..ec56936ea1d22e 100644
--- a/packages/material-ui/src/TableFooter/TableFooter.test.js
+++ b/packages/material-ui/src/TableFooter/TableFooter.test.js
@@ -1,6 +1,6 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import TableFooter from './TableFooter';
 import Tablelvl2Context from '../Table/Tablelvl2Context';
 
@@ -10,7 +10,7 @@ describe('<TableFooter />', () => {
 
   function mountInTable(node) {
     const wrapper = mount(<table>{node}</table>);
-    return wrapper.childAt(0);
+    return wrapper.find('table').childAt(0);
   }
 
   before(() => {
@@ -22,21 +22,13 @@ describe('<TableFooter />', () => {
     mount.cleanUp();
   });
 
-  it('should render a tfoot', () => {
-    const wrapper = mountInTable(<TableFooter />);
-    assert.strictEqual(wrapper.getDOMNode().nodeName, 'TFOOT');
-  });
-
-  it('should render a div', () => {
-    const wrapper = mount(<TableFooter component="div" />);
-    assert.strictEqual(wrapper.getDOMNode().nodeName, 'DIV');
-  });
-
-  it('should render with the user and root class', () => {
-    const wrapper = mountInTable(<TableFooter className="woofTableHead" />);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass('woofTableHead'), true);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.root), true);
-  });
+  describeConformance(<TableFooter />, () => ({
+    classes,
+    inheritComponent: 'tfoot',
+    mount: mountInTable,
+    refInstanceof: window.HTMLTableSectionElement,
+    testComponentPropWith: 'thead',
+  }));
 
   it('should render children', () => {
     const children = <tr className="test" />;
@@ -46,6 +38,7 @@ describe('<TableFooter />', () => {
 
   it('should define table.footer in the child context', () => {
     let context;
+    // TODO test integration with TableCell
     mountInTable(
       <TableFooter>
         <Tablelvl2Context.Consumer>
diff --git a/packages/material-ui/src/TableHead/TableHead.test.js b/packages/material-ui/src/TableHead/TableHead.test.js
index e8aa7ae5083688..03b90f2b3710ec 100644
--- a/packages/material-ui/src/TableHead/TableHead.test.js
+++ b/packages/material-ui/src/TableHead/TableHead.test.js
@@ -1,6 +1,6 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createMount, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import TableHead from './TableHead';
 import Tablelvl2Context from '../Table/Tablelvl2Context';
 
@@ -9,7 +9,7 @@ describe('<TableHead />', () => {
   let classes;
   function mountInTable(node) {
     const wrapper = mount(<table>{node}</table>);
-    return wrapper.childAt(0);
+    return wrapper.find('table');
   }
 
   before(() => {
@@ -21,21 +21,13 @@ describe('<TableHead />', () => {
     mount.cleanUp();
   });
 
-  it('should render a thead', () => {
-    const wrapper = mountInTable(<TableHead />);
-    assert.strictEqual(wrapper.getDOMNode().nodeName, 'THEAD');
-  });
-
-  it('should render a div', () => {
-    const wrapper = mount(<TableHead component="div">foo</TableHead>);
-    assert.strictEqual(wrapper.getDOMNode().nodeName, 'DIV');
-  });
-
-  it('should render with the user and root class', () => {
-    const wrapper = mountInTable(<TableHead className="woofTableHead" />);
-    assert.strictEqual(wrapper.find('thead').hasClass('woofTableHead'), true);
-    assert.strictEqual(wrapper.find('thead').hasClass(classes.root), true);
-  });
+  describeConformance(<TableHead />, () => ({
+    classes,
+    inheritComponent: 'thead',
+    mount: mountInTable,
+    refInstanceof: window.HTMLTableSectionElement,
+    testComponentPropWith: 'tbody',
+  }));
 
   it('should render children', () => {
     const children = <tr className="test" />;
@@ -45,6 +37,7 @@ describe('<TableHead />', () => {
 
   it('should define table.head in the child context', () => {
     let context;
+    // TODO: test integration with TableCell
     mountInTable(
       <TableHead>
         <Tablelvl2Context.Consumer>
diff --git a/packages/material-ui/src/TableRow/TableRow.test.js b/packages/material-ui/src/TableRow/TableRow.test.js
index 32a69b14295cfb..1e3bab5e3b1bf3 100644
--- a/packages/material-ui/src/TableRow/TableRow.test.js
+++ b/packages/material-ui/src/TableRow/TableRow.test.js
@@ -1,6 +1,6 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createMount, findOutermostIntrinsic, getClasses } from '@material-ui/core/test-utils';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import TableRow from './TableRow';
 
 describe('<TableRow />', () => {
@@ -12,7 +12,7 @@ describe('<TableRow />', () => {
         <tbody>{node}</tbody>
       </table>,
     );
-    return wrapper.childAt(0).childAt(0);
+    return wrapper.find('tbody').childAt(0);
   }
 
   before(() => {
@@ -24,26 +24,13 @@ describe('<TableRow />', () => {
     mount.cleanUp();
   });
 
-  it('should render a tr', () => {
-    const wrapper = mountInTable(<TableRow />);
-    assert.strictEqual(wrapper.getDOMNode().nodeName, 'TR');
-  });
-
-  it('should render a div', () => {
-    const wrapper = mount(<TableRow component="div" />);
-    assert.strictEqual(wrapper.getDOMNode().nodeName, 'DIV');
-  });
-
-  it('should spread custom props on the root node', () => {
-    const wrapper = mountInTable(<TableRow data-my-prop="woofTableRow" />);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).props()['data-my-prop'], 'woofTableRow');
-  });
-
-  it('should render with the user and root classes', () => {
-    const wrapper = mountInTable(<TableRow className="woofTableRow" />);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass('woofTableRow'), true);
-    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.root), true);
-  });
+  describeConformance(<TableRow />, () => ({
+    classes,
+    inheritComponent: 'tr',
+    mount: mountInTable,
+    refInstanceof: window.HTMLTableRowElement,
+    testComponentPropWith: 'tr',
+  }));
 
   it('should render children', () => {
     const children = <td className="test" />;
diff --git a/packages/material-ui/src/TableSortLabel/TableSortLabel.test.js b/packages/material-ui/src/TableSortLabel/TableSortLabel.test.js
index 25105d72983520..78c8dda57f4334 100644
--- a/packages/material-ui/src/TableSortLabel/TableSortLabel.test.js
+++ b/packages/material-ui/src/TableSortLabel/TableSortLabel.test.js
@@ -1,7 +1,13 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, createMount, getClasses } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  createMount,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import TableSortLabel from './TableSortLabel';
+import ButtonBase from '../ButtonBase';
 import Sort from '@material-ui/icons/Sort';
 
 describe('<TableSortLabel />', () => {
@@ -19,10 +25,13 @@ describe('<TableSortLabel />', () => {
     mount.cleanUp();
   });
 
-  it('should render TableSortLabel', () => {
-    const wrapper = shallow(<TableSortLabel />);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-  });
+  describeConformance(<TableSortLabel />, () => ({
+    classes,
+    inheritComponent: ButtonBase,
+    mount,
+    refInstanceof: window.HTMLSpanElement,
+    testComponentPropWith: false,
+  }));
 
   it('should set the active class when active', () => {
     const activeFlag = true;
@@ -90,10 +99,4 @@ describe('<TableSortLabel />', () => {
       assert.strictEqual(iconChildren.length, 1);
     });
   });
-
-  describe('mount', () => {
-    it('should mount without error', () => {
-      mount(<TableSortLabel />);
-    });
-  });
 });
diff --git a/packages/material-ui/src/Tabs/Tabs.test.js b/packages/material-ui/src/Tabs/Tabs.test.js
index e7d900588a23b5..e32b619431cc33 100644
--- a/packages/material-ui/src/Tabs/Tabs.test.js
+++ b/packages/material-ui/src/Tabs/Tabs.test.js
@@ -6,7 +6,7 @@ import consoleErrorMock from 'test/utils/consoleErrorMock';
 import {
   createMount,
   createRender,
-  findOutermostIntrinsic,
+  describeConformance,
   getClasses,
 } from '@material-ui/core/test-utils';
 import Tab from '../Tab';
@@ -61,17 +61,12 @@ describe('<Tabs />', () => {
     mount.cleanUp();
   });
 
-  it('should render with the root class', () => {
-    const wrapper = mount(
-      <Tabs width="md" onChange={noop} value={0}>
-        <Tab />
-        <Tab />
-      </Tabs>,
-    );
-    const root = findOutermostIntrinsic(wrapper);
-    assert.strictEqual(root.type(), 'div');
-    assert.strictEqual(root.hasClass(classes.root), true);
-  });
+  describeConformance(<Tabs onChange={noop} value={0} />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+  }));
 
   describe('warnings', () => {
     before(() => {
@@ -118,20 +113,6 @@ describe('<Tabs />', () => {
     });
   });
 
-  describe('prop: className', () => {
-    it('should render with the user and root classes', () => {
-      const wrapper = mount(
-        <Tabs width="md" onChange={noop} value={0} className="woofTabs">
-          <Tab />
-          <Tab />
-        </Tabs>,
-      );
-      const root = findOutermostIntrinsic(wrapper);
-      assert.strictEqual(root.hasClass('woofTabs'), true);
-      assert.strictEqual(root.hasClass(classes.root), true);
-    });
-  });
-
   describe('prop: centered', () => {
     it('should render with the centered class', () => {
       const wrapper = mount(
diff --git a/packages/material-ui/src/TextField/TextField.test.js b/packages/material-ui/src/TextField/TextField.test.js
index 7ee41b29e5fcde..d6994bc0d82ba5 100644
--- a/packages/material-ui/src/TextField/TextField.test.js
+++ b/packages/material-ui/src/TextField/TextField.test.js
@@ -1,15 +1,17 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createMount } from '@material-ui/core/test-utils';
-import Input from '../Input';
+import { createMount, describeConformance, getClasses } from '@material-ui/core/test-utils';
 import FormControl from '../FormControl';
+import Input from '../Input';
 import OutlinedInput from '../OutlinedInput';
 import TextField from './TextField';
 
 describe('<TextField />', () => {
+  let classes;
   let mount;
 
   before(() => {
+    classes = getClasses(<TextField />);
     mount = createMount();
   });
 
@@ -17,6 +19,14 @@ describe('<TextField />', () => {
     mount.cleanUp();
   });
 
+  describeConformance(<TextField />, () => ({
+    classes,
+    inheritComponent: FormControl,
+    mount,
+    refInstanceof: window.HTMLDivElement,
+    testComponentPropWith: false,
+  }));
+
   describe('mount', () => {
     let wrapper;
 
@@ -25,18 +35,6 @@ describe('<TextField />', () => {
     });
 
     describe('structure', () => {
-      it('should be a FormControl', () => {
-        wrapper.setProps({ className: 'foo' });
-        const formControl = wrapper.find(FormControl);
-        assert.strictEqual(formControl.exists(), true);
-        assert.strictEqual(formControl.hasClass('foo'), true);
-      });
-
-      it('should pass margin to the FormControl', () => {
-        wrapper.setProps({ margin: 'normal' });
-        assert.strictEqual(wrapper.find(FormControl).props().margin, 'normal');
-      });
-
       it('should have an input as the only child', () => {
         assert.strictEqual(wrapper.find(Input).length, 1);
       });
diff --git a/packages/material-ui/src/Toolbar/Toolbar.test.js b/packages/material-ui/src/Toolbar/Toolbar.test.js
index 9cdf44ed3c541f..f9e4d91bf7685b 100644
--- a/packages/material-ui/src/Toolbar/Toolbar.test.js
+++ b/packages/material-ui/src/Toolbar/Toolbar.test.js
@@ -1,38 +1,48 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createMount,
+  createShallow,
+  describeConformance,
+  findOutermostIntrinsic,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Toolbar from './Toolbar';
 
 describe('<Toolbar />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<Toolbar>foo</Toolbar>);
   });
 
-  it('should render a div', () => {
-    const wrapper = shallow(<Toolbar>foo</Toolbar>);
-    assert.strictEqual(wrapper.name(), 'div');
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should render with the user, root and gutters classes', () => {
-    const wrapper = shallow(<Toolbar className="woofToolbar">foo</Toolbar>);
-    assert.strictEqual(wrapper.hasClass('woofToolbar'), true);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
-    assert.strictEqual(wrapper.hasClass(classes.gutters), true);
+  describeConformance(<Toolbar />, () => ({
+    classes,
+    inheritComponent: 'div',
+    mount,
+    refInstanceof: window.HTMLDivElement,
+  }));
+
+  it('should render with gutters class', () => {
+    const wrapper = mount(<Toolbar className="woofToolbar">foo</Toolbar>);
+    assert.strictEqual(findOutermostIntrinsic(wrapper).hasClass(classes.gutters), true);
   });
 
-  it('should disable the gutters', () => {
+  it('can disable the gutters', () => {
     const wrapper = shallow(<Toolbar disableGutters>foo</Toolbar>);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
     assert.strictEqual(wrapper.hasClass(classes.gutters), false);
   });
 
-  it('should condense itself', () => {
+  it('can condense itself', () => {
     const wrapper = shallow(<Toolbar variant="dense">foo</Toolbar>);
-    assert.strictEqual(wrapper.hasClass(classes.root), true);
     assert.strictEqual(wrapper.hasClass(classes.dense), true);
   });
 });
diff --git a/packages/material-ui/src/Typography/Typography.test.js b/packages/material-ui/src/Typography/Typography.test.js
index 131bcd4bc110e0..eae2fdfc697ad9 100644
--- a/packages/material-ui/src/Typography/Typography.test.js
+++ b/packages/material-ui/src/Typography/Typography.test.js
@@ -1,25 +1,38 @@
 import React from 'react';
 import { assert } from 'chai';
-import { createShallow, getClasses } from '@material-ui/core/test-utils';
+import {
+  createShallow,
+  createMount,
+  describeConformance,
+  getClasses,
+} from '@material-ui/core/test-utils';
 import Typography from './Typography';
 
 describe('<Typography />', () => {
+  let mount;
   let shallow;
   let classes;
 
   before(() => {
+    mount = createMount();
     shallow = createShallow({ dive: true });
     classes = getClasses(<Typography />);
   });
 
-  it('should render the text', () => {
-    const wrapper = shallow(<Typography>Hello</Typography>);
-    assert.strictEqual(wrapper.childAt(0).equals('Hello'), true);
+  after(() => {
+    mount.cleanUp();
   });
 
-  it('should spread props', () => {
-    const wrapper = shallow(<Typography data-test="hello">Hello</Typography>);
-    assert.strictEqual(wrapper.props()['data-test'], 'hello');
+  describeConformance(<Typography />, () => ({
+    classes,
+    inheritComponent: 'p',
+    mount,
+    refInstanceof: window.HTMLParagraphElement,
+  }));
+
+  it('should render the text', () => {
+    const wrapper = shallow(<Typography>Hello</Typography>);
+    assert.strictEqual(wrapper.text(), 'Hello');
   });
 
   it('should render body2 root by default', () => {
@@ -28,12 +41,6 @@ describe('<Typography />', () => {
     assert.strictEqual(wrapper.hasClass(classes.root), true);
   });
 
-  it('should merge user classes', () => {
-    const wrapper = shallow(<Typography className="woofTypography">Hello</Typography>);
-    assert.strictEqual(wrapper.hasClass(classes.body2), true);
-    assert.strictEqual(wrapper.hasClass('woofTypography'), true);
-  });
-
   it('should center text', () => {
     const wrapper = shallow(
       <Typography align="center" className="woofTypography">
diff --git a/packages/material-ui/src/test-utils/describeConformance.js b/packages/material-ui/src/test-utils/describeConformance.js
new file mode 100644
index 00000000000000..8ca3526b1b5af0
--- /dev/null
+++ b/packages/material-ui/src/test-utils/describeConformance.js
@@ -0,0 +1,141 @@
+import { assert } from 'chai';
+import React from 'react';
+import testRef from './testRef';
+
+/**
+ * Glossary
+ * - root component:
+ *   - has the `root` class
+ *   - excess props are spread to this component
+ *   - has the type of `inheritComponent`
+ */
+
+function findRootComponent(wrapper, { classes, component }) {
+  /**
+   * We look for the component that is `inheritComponent` and `.rootClassName`
+   * Using find().find().first() is not equivalent since `find` searches deep
+   */
+  return wrapper.find(component).filter(`.${classes.root}`);
+}
+
+function randomStringValue() {
+  return Math.random()
+    .toString(36)
+    .slice(2);
+}
+
+/**
+ * Material-UI components have a `className` prop. The `className` is applied to
+ * the root component.
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+function testClassName(element, getOptions) {
+  it('applies the className to the root component', () => {
+    const { classes, inheritComponent, mount } = getOptions();
+    const className = randomStringValue();
+
+    const wrapper = mount(React.cloneElement(element, { className }));
+    const root = findRootComponent(wrapper, { classes, component: inheritComponent });
+
+    assert.strictEqual(root.hasClass(className), true, 'does have a custom `className`');
+  });
+}
+
+/**
+ * Material-UI components have a `component` prop that allows rendering a different
+ * Component from @inheritComponent
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+function testComponentProp(element, getOptions) {
+  const { testComponentPropWith } = getOptions();
+
+  describe('prop: component', () => {
+    if (testComponentPropWith !== false) {
+      it('can render another root component with the `component` prop', () => {
+        const { classes, mount, testComponentPropWith: component = 'em' } = getOptions();
+
+        const wrapper = mount(React.cloneElement(element, { component }));
+
+        assert.strictEqual(findRootComponent(wrapper, { classes, component }).exists(), true);
+      });
+    }
+  });
+}
+
+/**
+ * Material-UI components can spread additional props to a documented component.
+ * It's set via @inheritComponent in the source.
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+function testPropsSpread(element, getOptions) {
+  it(`does spread props to the root component`, () => {
+    // type def in ConformanceOptions
+    const { classes, inheritComponent, mount } = getOptions();
+    const testProp = 'data-test-props-spread';
+    const value = randomStringValue();
+
+    const wrapper = mount(React.cloneElement(element, { [testProp]: value }));
+    const root = findRootComponent(wrapper, { classes, component: inheritComponent });
+
+    assert.strictEqual(root.props()[testProp], value);
+  });
+}
+
+/**
+ * Tests that the `ref` of a component will return the correct instance
+ *
+ * This is determined by a given constructor i.e. a React.Component or HTMLElement for
+ * components that forward their ref and attach it to a host component.
+ *
+ * @param {React.ReactElement} element
+ * @param {() => ConformanceOptions} getOptions
+ */
+function describeRef(element, getOptions) {
+  describe('ref', () => {
+    it(`attaches the ref`, () => {
+      // type def in ConformanceOptions
+      const { mount, refInstanceof } = getOptions();
+
+      testRef(element, mount, current => assert.instanceOf(current, refInstanceof));
+    });
+  });
+}
+
+const fullSuite = {
+  class: testClassName,
+  componentProp: testComponentProp,
+  propsSpread: testPropsSpread,
+  refForwarding: describeRef,
+};
+
+/**
+ * @typedef {Object} ConformanceOptions
+ * @property {string} classes - `classes` of the component provided by `@material-ui/styles`
+ * @property {string} inheritComponent - The element type that receives spread props.
+ * @property {function} mount - Should be a return value from createMount
+ * @property {boolean} refInstanceof - `ref` will be an instanceof this constructor.
+ * @property {string?} testComponentPropWith - The host component that should be rendered instead.
+ */
+
+/**
+ * Tests various aspects of a component that should be equal across Material-UI
+ * components.
+ *
+ * @param {React.ReactElement} minimalElement - the component with it's minimal required props
+ * @param {() => ConformanceOptions} getOptions
+ *
+ */
+export default function describeConformance(minimalElement, getOptions) {
+  describe('Material-UI component API', () => {
+    Object.keys(fullSuite).forEach(testKey => {
+      const test = fullSuite[testKey];
+      test(minimalElement, getOptions);
+    });
+  });
+}
diff --git a/packages/material-ui/src/test-utils/index.js b/packages/material-ui/src/test-utils/index.js
index 46bb1fdbc9cfab..a8f13c32852f99 100644
--- a/packages/material-ui/src/test-utils/index.js
+++ b/packages/material-ui/src/test-utils/index.js
@@ -1,6 +1,7 @@
 export { default as createShallow } from './createShallow';
 export { default as createMount } from './createMount';
 export { default as createRender } from './createRender';
+export { default as describeConformance } from './describeConformance';
 export { default as findOutermostIntrinsic, wrapsIntrinsicElement } from './findOutermostIntrinsic';
 export { default as getClasses } from './getClasses';
 export { default as testRef } from './testRef';