diff --git a/pandas/core/categorical.py b/pandas/core/categorical.py
index c1e5904693d1c..af51c7f2e2dc1 100644
--- a/pandas/core/categorical.py
+++ b/pandas/core/categorical.py
@@ -550,8 +550,8 @@ def _validate_categories(cls, categories, fastpath=False):
             # we don't allow NaNs in the categories themselves
 
             if categories.hasnans:
-                # NaNs in cats deprecated in 0.17,
-                # remove in 0.18 or 0.19 GH 10748
+                # NaNs in cats deprecated in 0.17
+                # GH 10748
                 msg = ('\nSetting NaNs in `categories` is deprecated and '
                        'will be removed in a future version of pandas.')
                 warn(msg, FutureWarning, stacklevel=3)
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index 72efc47a3c744..b3b253f151541 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -2094,7 +2094,17 @@ def convert(self, values, nan_rep, encoding):
 
                 # we have a categorical
                 categories = self.metadata
-                self.data = Categorical.from_codes(self.data.ravel(),
+                codes = self.data.ravel()
+
+                # if we have stored a NaN in the categories
+                # then strip it; in theory we could have BOTH
+                # -1s in the codes and nulls :<
+                mask = isnull(categories)
+                if mask.any():
+                    categories = categories[~mask]
+                    codes[codes != -1] -= mask.astype(int).cumsum().values
+
+                self.data = Categorical.from_codes(codes,
                                                    categories=categories,
                                                    ordered=self.ordered)
 
@@ -3404,10 +3414,12 @@ def create_axes(self, axes, obj, validate=True, nan_rep=None,
                 if existing_table is not None:
                     indexer = len(self.non_index_axes)
                     exist_axis = existing_table.non_index_axes[indexer][1]
-                    if append_axis != exist_axis:
+                    if not array_equivalent(np.array(append_axis),
+                                            np.array(exist_axis)):
 
                         # ahah! -> reindex
-                        if sorted(append_axis) == sorted(exist_axis):
+                        if array_equivalent(np.array(sorted(append_axis)),
+                                            np.array(sorted(exist_axis))):
                             append_axis = exist_axis
 
                 # the non_index_axes info
diff --git a/pandas/tests/io/test_pytables.py b/pandas/tests/io/test_pytables.py
index 5592c564e51df..b476096d9c27c 100644
--- a/pandas/tests/io/test_pytables.py
+++ b/pandas/tests/io/test_pytables.py
@@ -1,11 +1,12 @@
 import pytest
 import sys
 import os
-import warnings
+from warnings import catch_warnings
 import tempfile
 from contextlib import contextmanager
 
 import datetime
+from datetime import timedelta
 import numpy as np
 
 import pandas
@@ -22,7 +23,7 @@
 from pandas.io.pytables import TableIterator
 from pandas.io.pytables import (HDFStore, get_store, Term, read_hdf,
                                 IncompatibilityWarning, PerformanceWarning,
-                                AttributeConflictWarning, DuplicateWarning,
+                                AttributeConflictWarning,
                                 PossibleDataLossError, ClosedFileError)
 
 from pandas.io import pytables as pytables
@@ -31,7 +32,6 @@
                                  assert_panel_equal,
                                  assert_frame_equal,
                                  assert_series_equal,
-                                 assert_produces_warning,
                                  set_timezone)
 from pandas import concat, Timestamp
 from pandas import compat
@@ -123,17 +123,6 @@ def _maybe_remove(store, key):
         pass
 
 
-@contextmanager
-def compat_assert_produces_warning(w):
-    """ don't produce a warning under PY3 """
-    if compat.PY3:
-        yield
-    else:
-        with tm.assert_produces_warning(expected_warning=w,
-                                        check_stacklevel=False):
-            yield
-
-
 class Base(tm.TestCase):
 
     @classmethod
@@ -151,8 +140,6 @@ def tearDownClass(cls):
         tm.set_testing_mode()
 
     def setUp(self):
-        warnings.filterwarnings(action='ignore', category=FutureWarning)
-
         self.path = 'tmp.__%s__.h5' % tm.rands(10)
 
     def tearDown(self):
@@ -420,9 +407,9 @@ def test_repr(self):
             df.loc[3:6, ['obj1']] = np.nan
             df = df._consolidate()._convert(datetime=True)
 
-            warnings.filterwarnings('ignore', category=PerformanceWarning)
-            store['df'] = df
-            warnings.filterwarnings('always', category=PerformanceWarning)
+            # PerformanceWarning
+            with catch_warnings(record=True):
+                store['df'] = df
 
             # make a random group in hdf space
             store._handle.create_group(store._handle.root, 'bah')
@@ -455,9 +442,9 @@ def test_contains(self):
             self.assertNotIn('bar', store)
 
             # GH 2694
-            warnings.filterwarnings(
-                'ignore', category=tables.NaturalNameWarning)
-            store['node())'] = tm.makeDataFrame()
+            # tables.NaturalNameWarning
+            with catch_warnings(record=True):
+                store['node())'] = tm.makeDataFrame()
             self.assertIn('node())', store)
 
     def test_versioning(self):
@@ -767,11 +754,8 @@ def test_put_mixed_type(self):
         with ensure_clean_store(self.path) as store:
             _maybe_remove(store, 'df')
 
-            # cannot use assert_produces_warning here for some reason
-            # a PendingDeprecationWarning is also raised?
-            warnings.filterwarnings('ignore', category=PerformanceWarning)
-            store.put('df', df)
-            warnings.filterwarnings('always', category=PerformanceWarning)
+            with catch_warnings(record=True):
+                store.put('df', df)
 
             expected = store.get('df')
             tm.assert_frame_equal(expected, df)
@@ -796,8 +780,8 @@ def test_append(self):
             tm.assert_frame_equal(store['df3'], df)
 
             # this is allowed by almost always don't want to do it
-            with tm.assert_produces_warning(
-                    expected_warning=tables.NaturalNameWarning):
+            # tables.NaturalNameWarning):
+            with catch_warnings(record=True):
                 _maybe_remove(store, '/df3 foo')
                 store.append('/df3 foo', df[:10])
                 store.append('/df3 foo', df[10:])
@@ -811,8 +795,7 @@ def test_append(self):
             assert_panel_equal(store['wp1'], wp)
 
             # ndim
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
+            with catch_warnings(record=True):
                 p4d = tm.makePanel4D()
                 _maybe_remove(store, 'p4d')
                 store.append('p4d', p4d.iloc[:, :, :10, :])
@@ -900,12 +883,12 @@ def test_append_series(self):
 
             # select on the values
             expected = ns[ns > 60]
-            result = store.select('ns', Term('foo>60'))
+            result = store.select('ns', 'foo>60')
             tm.assert_series_equal(result, expected)
 
             # select on the index and values
             expected = ns[(ns > 70) & (ns.index < 90)]
-            result = store.select('ns', [Term('foo>70'), Term('index<90')])
+            result = store.select('ns', 'foo>70 and index<90')
             tm.assert_series_equal(result, expected)
 
             # multi-index
@@ -1227,7 +1210,7 @@ def test_append_with_different_block_ordering(self):
     def test_ndim_indexables(self):
         # test using ndim tables in new ways
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             with ensure_clean_store(self.path) as store:
 
                 p4d = tm.makePanel4D()
@@ -1887,8 +1870,7 @@ def test_append_misc(self):
 
         with ensure_clean_store(self.path) as store:
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
+            with catch_warnings(record=True):
 
                 # unsuported data types for non-tables
                 p4d = tm.makePanel4D()
@@ -1929,7 +1911,7 @@ def check(obj, comparator):
         p = tm.makePanel()
         check(p, assert_panel_equal)
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             p4d = tm.makePanel4D()
             check(p4d, assert_panel4d_equal)
 
@@ -2057,8 +2039,8 @@ def test_table_values_dtypes_roundtrip(self):
             expected = Series({'float32': 2, 'float64': 1, 'int32': 1,
                                'bool': 1, 'int16': 1, 'int8': 1,
                                'int64': 1, 'object': 1, 'datetime64[ns]': 2})
-            result.sort()
-            expected.sort()
+            result = result.sort_index()
+            result = expected.sort_index()
             tm.assert_series_equal(result, expected)
 
     def test_table_mixed_dtypes(self):
@@ -2097,7 +2079,8 @@ def test_table_mixed_dtypes(self):
             store.append('p1_mixed', wp)
             assert_panel_equal(store.select('p1_mixed'), wp)
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
+
             # ndim
             wp = tm.makePanel4D()
             wp['obj1'] = 'foo'
@@ -2169,7 +2152,6 @@ def test_append_with_timedelta(self):
         # GH 3577
         # append timedelta
 
-        from datetime import timedelta
         df = DataFrame(dict(A=Timestamp('20130101'), B=[Timestamp(
             '20130101') + timedelta(days=i, seconds=10) for i in range(10)]))
         df['C'] = df['A'] - df['B']
@@ -2183,12 +2165,9 @@ def test_append_with_timedelta(self):
             result = store.select('df')
             assert_frame_equal(result, df)
 
-            result = store.select('df', Term("C<100000"))
+            result = store.select('df', "C<100000")
             assert_frame_equal(result, df)
 
-            result = store.select('df', Term("C", "<", -3 * 86400))
-            assert_frame_equal(result, df.iloc[3:])
-
             result = store.select('df', "C<'-3D'")
             assert_frame_equal(result, df.iloc[3:])
 
@@ -2431,7 +2410,7 @@ def test_invalid_terms(self):
 
         with ensure_clean_store(self.path) as store:
 
-            with compat_assert_produces_warning(FutureWarning):
+            with catch_warnings(record=True):
 
                 df = tm.makeTimeDataFrame()
                 df['string'] = 'foo'
@@ -2489,7 +2468,7 @@ def test_terms(self):
                                     0: tm.makeDataFrame(),
                                     1: tm.makeDataFrame()})
 
-            with compat_assert_produces_warning(FutureWarning):
+            with catch_warnings(record=True):
 
                 p4d = tm.makePanel4D()
                 store.put('p4d', p4d, format='table')
@@ -2498,39 +2477,23 @@ def test_terms(self):
             store.put('wpneg', wpneg, format='table')
 
             # panel
-            result = store.select('wp', [Term(
-                'major_axis<"20000108"'), Term("minor_axis=['A', 'B']")])
+            result = store.select(
+                'wp', "major_axis<'20000108' and minor_axis=['A', 'B']")
             expected = wp.truncate(after='20000108').reindex(minor=['A', 'B'])
             assert_panel_equal(result, expected)
 
-            # with deprecation
-            result = store.select('wp', [Term(
-                'major_axis', '<', "20000108"), Term("minor_axis=['A', 'B']")])
-            expected = wp.truncate(after='20000108').reindex(minor=['A', 'B'])
-            tm.assert_panel_equal(result, expected)
-
             # p4d
-            with compat_assert_produces_warning(FutureWarning):
+            with catch_warnings(record=True):
 
                 result = store.select('p4d',
-                                      [Term('major_axis<"20000108"'),
-                                       Term("minor_axis=['A', 'B']"),
-                                       Term("items=['ItemA', 'ItemB']")])
+                                      ("major_axis<'20000108' and "
+                                       "minor_axis=['A', 'B'] and "
+                                       "items=['ItemA', 'ItemB']"))
                 expected = p4d.truncate(after='20000108').reindex(
                     minor=['A', 'B'], items=['ItemA', 'ItemB'])
                 assert_panel4d_equal(result, expected)
 
-            # back compat invalid terms
-            terms = [dict(field='major_axis', op='>', value='20121114'),
-                     [dict(field='major_axis', op='>', value='20121114')],
-                     ["minor_axis=['A','B']",
-                      dict(field='major_axis', op='>', value='20121114')]]
-            for t in terms:
-                with tm.assert_produces_warning(expected_warning=FutureWarning,
-                                                check_stacklevel=False):
-                    Term(t)
-
-            with compat_assert_produces_warning(FutureWarning):
+            with catch_warnings(record=True):
 
                 # valid terms
                 terms = [('major_axis=20121114'),
@@ -2581,13 +2544,13 @@ def test_term_compat(self):
                        minor_axis=['A', 'B', 'C', 'D'])
             store.append('wp', wp)
 
-            result = store.select('wp', [Term('major_axis>20000102'),
-                                         Term('minor_axis', '=', ['A', 'B'])])
+            result = store.select(
+                'wp', "major_axis>20000102 and minor_axis=['A', 'B']")
             expected = wp.loc[:, wp.major_axis >
                               Timestamp('20000102'), ['A', 'B']]
             assert_panel_equal(result, expected)
 
-            store.remove('wp', Term('major_axis>20000103'))
+            store.remove('wp', 'major_axis>20000103')
             result = store.select('wp')
             expected = wp.loc[:, wp.major_axis <= Timestamp('20000103'), :]
             assert_panel_equal(result, expected)
@@ -2601,25 +2564,23 @@ def test_term_compat(self):
 
             # stringified datetimes
             result = store.select(
-                'wp', [Term('major_axis', '>', datetime.datetime(2000, 1, 2))])
+                'wp', "major_axis>datetime.datetime(2000, 1, 2)")
             expected = wp.loc[:, wp.major_axis > Timestamp('20000102')]
             assert_panel_equal(result, expected)
 
             result = store.select(
-                'wp', [Term('major_axis', '>',
-                            datetime.datetime(2000, 1, 2, 0, 0))])
+                'wp', "major_axis>datetime.datetime(2000, 1, 2, 0, 0)")
             expected = wp.loc[:, wp.major_axis > Timestamp('20000102')]
             assert_panel_equal(result, expected)
 
             result = store.select(
-                'wp', [Term('major_axis', '=',
-                            [datetime.datetime(2000, 1, 2, 0, 0),
-                             datetime.datetime(2000, 1, 3, 0, 0)])])
+                'wp', ("major_axis=[datetime.datetime(2000, 1, 2, 0, 0), "
+                       "datetime.datetime(2000, 1, 3, 0, 0)]"))
             expected = wp.loc[:, [Timestamp('20000102'),
                                   Timestamp('20000103')]]
             assert_panel_equal(result, expected)
 
-            result = store.select('wp', [Term('minor_axis', '=', ['A', 'B'])])
+            result = store.select('wp', "minor_axis=['A', 'B']")
             expected = wp.loc[:, :, ['A', 'B']]
             assert_panel_equal(result, expected)
 
@@ -2630,8 +2591,7 @@ def test_backwards_compat_without_term_object(self):
                        major_axis=date_range('1/1/2000', periods=5),
                        minor_axis=['A', 'B', 'C', 'D'])
             store.append('wp', wp)
-            with assert_produces_warning(expected_warning=FutureWarning,
-                                         check_stacklevel=False):
+            with catch_warnings(record=True):
                 result = store.select('wp', [('major_axis>20000102'),
                                              ('minor_axis', '=', ['A', 'B'])])
             expected = wp.loc[:,
@@ -2652,24 +2612,21 @@ def test_backwards_compat_without_term_object(self):
             store.append('wp', wp)
 
             # stringified datetimes
-            with assert_produces_warning(expected_warning=FutureWarning,
-                                         check_stacklevel=False):
+            with catch_warnings(record=True):
                 result = store.select('wp',
                                       [('major_axis',
                                         '>',
                                         datetime.datetime(2000, 1, 2))])
             expected = wp.loc[:, wp.major_axis > Timestamp('20000102')]
             assert_panel_equal(result, expected)
-            with assert_produces_warning(expected_warning=FutureWarning,
-                                         check_stacklevel=False):
+            with catch_warnings(record=True):
                 result = store.select('wp',
                                       [('major_axis',
                                         '>',
                                         datetime.datetime(2000, 1, 2, 0, 0))])
             expected = wp.loc[:, wp.major_axis > Timestamp('20000102')]
             assert_panel_equal(result, expected)
-            with assert_produces_warning(expected_warning=FutureWarning,
-                                         check_stacklevel=False):
+            with catch_warnings(record=True):
                 result = store.select('wp',
                                       [('major_axis',
                                         '=',
@@ -2768,9 +2725,7 @@ def test_tuple_index(self):
         data = np.random.randn(30).reshape((3, 10))
         DF = DataFrame(data, index=idx, columns=col)
 
-        expected_warning = Warning if PY35 else PerformanceWarning
-        with tm.assert_produces_warning(expected_warning=expected_warning,
-                                        check_stacklevel=False):
+        with catch_warnings(record=True):
             self._check_roundtrip(DF, tm.assert_frame_equal)
 
     def test_index_types(self):
@@ -2782,30 +2737,23 @@ def test_index_types(self):
                                                    check_index_type=True,
                                                    check_series_type=True)
 
-        # nose has a deprecation warning in 3.5
-        expected_warning = Warning if PY35 else PerformanceWarning
-        with tm.assert_produces_warning(expected_warning=expected_warning,
-                                        check_stacklevel=False):
+        with catch_warnings(record=True):
             ser = Series(values, [0, 'y'])
             self._check_roundtrip(ser, func)
 
-        with tm.assert_produces_warning(expected_warning=expected_warning,
-                                        check_stacklevel=False):
+        with catch_warnings(record=True):
             ser = Series(values, [datetime.datetime.today(), 0])
             self._check_roundtrip(ser, func)
 
-        with tm.assert_produces_warning(expected_warning=expected_warning,
-                                        check_stacklevel=False):
+        with catch_warnings(record=True):
             ser = Series(values, ['y', 0])
             self._check_roundtrip(ser, func)
 
-        with tm.assert_produces_warning(expected_warning=expected_warning,
-                                        check_stacklevel=False):
+        with catch_warnings(record=True):
             ser = Series(values, [datetime.date.today(), 'a'])
             self._check_roundtrip(ser, func)
 
-        with tm.assert_produces_warning(expected_warning=expected_warning,
-                                        check_stacklevel=False):
+        with catch_warnings(record=True):
             ser = Series(values, [1.23, 'b'])
             self._check_roundtrip(ser, func)
 
@@ -3053,7 +3001,7 @@ def test_wide_table_dups(self):
             store.put('panel', wp, format='table')
             store.put('panel', wp, format='table', append=True)
 
-            with tm.assert_produces_warning(expected_warning=DuplicateWarning):
+            with catch_warnings(record=True):
                 recons = store['panel']
 
             assert_panel_equal(recons, wp)
@@ -3647,6 +3595,7 @@ def test_retain_index_attributes(self):
 
     def test_retain_index_attributes2(self):
         with ensure_clean_path(self.path) as path:
+
             expected_warning = Warning if PY35 else AttributeConflictWarning
             with tm.assert_produces_warning(expected_warning=expected_warning,
                                             check_stacklevel=False):
@@ -3804,15 +3753,10 @@ def test_frame_select_complex2(self):
 
             hist.to_hdf(hh, 'df', mode='w', format='table')
 
-            expected = read_hdf(hh, 'df', where=Term('l1', '=', [2, 3, 4]))
-
-            # list like
-            result = read_hdf(hh, 'df', where=Term(
-                'l1', '=', selection.index.tolist()))
-            assert_frame_equal(result, expected)
-            l = selection.index.tolist()  # noqa
+            expected = read_hdf(hh, 'df', where="l1=[2, 3, 4]")
 
             # sccope with list like
+            l = selection.index.tolist()  # noqa
             store = HDFStore(hh)
             result = store.select('df', where='l1=l')
             assert_frame_equal(result, expected)
@@ -3881,12 +3825,12 @@ def test_string_select(self):
 
             store.append('df', df, data_columns=['x'])
 
-            result = store.select('df', Term('x=none'))
+            result = store.select('df', 'x=none')
             expected = df[df.x == 'none']
             assert_frame_equal(result, expected)
 
             try:
-                result = store.select('df', Term('x!=none'))
+                result = store.select('df', 'x!=none')
                 expected = df[df.x != 'none']
                 assert_frame_equal(result, expected)
             except Exception as detail:
@@ -3898,7 +3842,7 @@ def test_string_select(self):
             df2.loc[df2.x == '', 'x'] = np.nan
 
             store.append('df2', df2, data_columns=['x'])
-            result = store.select('df2', Term('x!=none'))
+            result = store.select('df2', 'x!=none')
             expected = df2[isnull(df2.x)]
             assert_frame_equal(result, expected)
 
@@ -3908,11 +3852,11 @@ def test_string_select(self):
 
             store.append('df3', df, data_columns=['int'])
 
-            result = store.select('df3', Term('int=2'))
+            result = store.select('df3', 'int=2')
             expected = df[df.int == 2]
             assert_frame_equal(result, expected)
 
-            result = store.select('df3', Term('int!=2'))
+            result = store.select('df3', 'int!=2')
             expected = df[df.int != 2]
             assert_frame_equal(result, expected)
 
@@ -4178,8 +4122,8 @@ def test_select_as_multiple(self):
             tm.assert_frame_equal(result, expected)
 
             # multiple (diff selector)
-            result = store.select_as_multiple(['df1', 'df2'], where=[Term(
-                'index>df2.index[4]')], selector='df2')
+            result = store.select_as_multiple(
+                ['df1', 'df2'], where='index>df2.index[4]', selector='df2')
             expected = concat([df1, df2], axis=1)
             expected = expected[5:]
             tm.assert_frame_equal(result, expected)
@@ -4221,13 +4165,13 @@ def test_start_stop_table(self):
             store.append('df', df)
 
             result = store.select(
-                'df', [Term("columns=['A']")], start=0, stop=5)
+                'df', "columns=['A']", start=0, stop=5)
             expected = df.loc[0:4, ['A']]
             tm.assert_frame_equal(result, expected)
 
             # out of range
             result = store.select(
-                'df', [Term("columns=['A']")], start=30, stop=40)
+                'df', "columns=['A']", start=30, stop=40)
             self.assertTrue(len(result) == 0)
             expected = df.loc[30:40, ['A']]
             tm.assert_frame_equal(result, expected)
@@ -4287,11 +4231,11 @@ def test_select_filter_corner(self):
         with ensure_clean_store(self.path) as store:
             store.put('frame', df, format='table')
 
-            crit = Term('columns=df.columns[:75]')
+            crit = 'columns=df.columns[:75]'
             result = store.select('frame', [crit])
             tm.assert_frame_equal(result, df.loc[:, df.columns[:75]])
 
-            crit = Term('columns=df.columns[:75:2]')
+            crit = 'columns=df.columns[:75:2]'
             result = store.select('frame', [crit])
             tm.assert_frame_equal(result, df.loc[:, df.columns[:75:2]])
 
@@ -4470,16 +4414,16 @@ def test_legacy_table_read(self):
             with tm.assert_produces_warning(
                     expected_warning=IncompatibilityWarning):
                 self.assertRaises(
-                    Exception, store.select, 'wp1', Term('minor_axis=B'))
+                    Exception, store.select, 'wp1', 'minor_axis=B')
 
                 df2 = store.select('df2')
-                result = store.select('df2', Term('index>df2.index[2]'))
+                result = store.select('df2', 'index>df2.index[2]')
                 expected = df2[df2.index > df2.index[2]]
                 assert_frame_equal(expected, result)
 
     def test_legacy_0_10_read(self):
         # legacy from 0.10
-        with compat_assert_produces_warning(FutureWarning):
+        with catch_warnings(record=True):
             path = tm.get_data_path('legacy_hdf/legacy_0.10.h5')
             with ensure_clean_store(path, mode='r') as store:
                 str(store)
@@ -4503,7 +4447,7 @@ def test_legacy_0_11_read(self):
 
     def test_copy(self):
 
-        with compat_assert_produces_warning(FutureWarning):
+        with catch_warnings(record=True):
 
             def do_copy(f=None, new_f=None, keys=None,
                         propindexes=True, **kwargs):
@@ -4645,7 +4589,8 @@ def test_unicode_index(self):
 
         unicode_values = [u('\u03c3'), u('\u03c3\u03c3')]
 
-        with compat_assert_produces_warning(PerformanceWarning):
+        # PerformanceWarning
+        with catch_warnings(record=True):
             s = Series(np.random.randn(len(unicode_values)), unicode_values)
             self._check_roundtrip(s, tm.assert_series_equal)
 
@@ -4913,15 +4858,19 @@ def test_to_hdf_with_object_column_names(self):
                 with self.assertRaises(
                         ValueError, msg=("cannot have non-object label "
                                          "DataIndexableCol")):
-                    df.to_hdf(path, 'df', format='table', data_columns=True)
+                    with catch_warnings(record=True):
+                        df.to_hdf(path, 'df',
+                                  format='table',
+                                  data_columns=True)
 
         for index in types_should_run:
             df = DataFrame(np.random.randn(10, 2), columns=index(2))
             with ensure_clean_path(self.path) as path:
-                df.to_hdf(path, 'df', format='table', data_columns=True)
-                result = pd.read_hdf(
-                    path, 'df', where="index = [{0}]".format(df.index[0]))
-                assert(len(result))
+                with catch_warnings(record=True):
+                    df.to_hdf(path, 'df', format='table', data_columns=True)
+                    result = pd.read_hdf(
+                        path, 'df', where="index = [{0}]".format(df.index[0]))
+                    assert(len(result))
 
     def test_read_hdf_open_store(self):
         # GH10330
@@ -5186,7 +5135,7 @@ def test_complex_mixed_table(self):
 
         with ensure_clean_store(self.path) as store:
             store.append('df', df, data_columns=['A', 'B'])
-            result = store.select('df', where=Term('A>2'))
+            result = store.select('df', where='A>2')
             assert_frame_equal(df.loc[df.A > 2], result)
 
         with ensure_clean_path(self.path) as path:
@@ -5215,7 +5164,7 @@ def test_complex_across_dimensions(self):
         df = DataFrame({'A': s, 'B': s})
         p = Panel({'One': df, 'Two': df})
 
-        with compat_assert_produces_warning(FutureWarning):
+        with catch_warnings(record=True):
             p4d = pd.Panel4D({'i': p, 'ii': p})
 
             objs = [df, p, p4d]
@@ -5299,7 +5248,7 @@ def test_append_with_timezones_dateutil(self):
 
             # select with tz aware
             expected = df[df.A >= df.A[3]]
-            result = store.select('df_tz', where=Term('A>=df.A[3]'))
+            result = store.select('df_tz', where='A>=df.A[3]')
             self._compare_with_tz(result, expected)
 
             # ensure we include dates in DST and STD time here.
@@ -5370,7 +5319,7 @@ def test_append_with_timezones_pytz(self):
 
             # select with tz aware
             self._compare_with_tz(store.select(
-                'df_tz', where=Term('A>=df.A[3]')), df[df.A >= df.A[3]])
+                'df_tz', where='A>=df.A[3]'), df[df.A >= df.A[3]])
 
             _maybe_remove(store, 'df_tz')
             # ensure we include dates in DST and STD time here.
diff --git a/pandas/tests/test_panel.py b/pandas/tests/test_panel.py
index 373f590cbf9eb..ab0322abbcf06 100644
--- a/pandas/tests/test_panel.py
+++ b/pandas/tests/test_panel.py
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 # pylint: disable=W0612,E1101
 
+from warnings import catch_warnings
 from datetime import datetime
 
 import operator
@@ -1272,7 +1273,7 @@ def test_apply_slabs(self):
         f = lambda x: ((x.T - x.mean(1)) / x.std(1)).T
 
         # make sure that we don't trigger any warnings
-        with tm.assert_produces_warning(False):
+        with catch_warnings(record=True):
             result = self.panel.apply(f, axis=['items', 'major_axis'])
             expected = Panel(dict([(ax, f(self.panel.loc[:, :, ax]))
                                    for ax in self.panel.minor_axis]))
diff --git a/pandas/tests/test_panel4d.py b/pandas/tests/test_panel4d.py
index 2491bac2a7f19..c0511581cd299 100644
--- a/pandas/tests/test_panel4d.py
+++ b/pandas/tests/test_panel4d.py
@@ -3,7 +3,7 @@
 from pandas.compat import range, lrange
 import operator
 import pytest
-
+from warnings import catch_warnings
 import numpy as np
 
 from pandas.types.common import is_float_dtype
@@ -129,17 +129,21 @@ def skipna_wrapper(x):
             def wrapper(x):
                 return alternative(np.asarray(x))
 
-            for i in range(obj.ndim):
-                result = f(axis=i, skipna=False)
-                assert_panel_equal(result, obj.apply(wrapper, axis=i))
+            with catch_warnings(record=True):
+                for i in range(obj.ndim):
+                    result = f(axis=i, skipna=False)
+                    expected = obj.apply(wrapper, axis=i)
+                    assert_panel_equal(result, expected)
         else:
             skipna_wrapper = alternative
             wrapper = alternative
 
-        for i in range(obj.ndim):
-            result = f(axis=i)
-            if not tm._incompat_bottleneck_version(name):
-                assert_panel_equal(result, obj.apply(skipna_wrapper, axis=i))
+        with catch_warnings(record=True):
+            for i in range(obj.ndim):
+                result = f(axis=i)
+                if not tm._incompat_bottleneck_version(name):
+                    expected = obj.apply(skipna_wrapper, axis=i)
+                    assert_panel_equal(result, expected)
 
         self.assertRaises(Exception, f, axis=obj.ndim)
 
@@ -161,32 +165,33 @@ def test_get_axis(self):
         assert(self.panel4d._get_axis(3) is self.panel4d.minor_axis)
 
     def test_set_axis(self):
-        new_labels = Index(np.arange(len(self.panel4d.labels)))
+        with catch_warnings(record=True):
+            new_labels = Index(np.arange(len(self.panel4d.labels)))
 
-        # TODO: unused?
-        # new_items = Index(np.arange(len(self.panel4d.items)))
+            # TODO: unused?
+            # new_items = Index(np.arange(len(self.panel4d.items)))
 
-        new_major = Index(np.arange(len(self.panel4d.major_axis)))
-        new_minor = Index(np.arange(len(self.panel4d.minor_axis)))
+            new_major = Index(np.arange(len(self.panel4d.major_axis)))
+            new_minor = Index(np.arange(len(self.panel4d.minor_axis)))
 
-        # ensure propagate to potentially prior-cached items too
+            # ensure propagate to potentially prior-cached items too
 
-        # TODO: unused?
-        # label = self.panel4d['l1']
+            # TODO: unused?
+            # label = self.panel4d['l1']
 
-        self.panel4d.labels = new_labels
+            self.panel4d.labels = new_labels
 
-        if hasattr(self.panel4d, '_item_cache'):
-            self.assertNotIn('l1', self.panel4d._item_cache)
-        self.assertIs(self.panel4d.labels, new_labels)
+            if hasattr(self.panel4d, '_item_cache'):
+                self.assertNotIn('l1', self.panel4d._item_cache)
+            self.assertIs(self.panel4d.labels, new_labels)
 
-        self.panel4d.major_axis = new_major
-        self.assertIs(self.panel4d[0].major_axis, new_major)
-        self.assertIs(self.panel4d.major_axis, new_major)
+            self.panel4d.major_axis = new_major
+            self.assertIs(self.panel4d[0].major_axis, new_major)
+            self.assertIs(self.panel4d.major_axis, new_major)
 
-        self.panel4d.minor_axis = new_minor
-        self.assertIs(self.panel4d[0].minor_axis, new_minor)
-        self.assertIs(self.panel4d.minor_axis, new_minor)
+            self.panel4d.minor_axis = new_minor
+            self.assertIs(self.panel4d[0].minor_axis, new_minor)
+            self.assertIs(self.panel4d.minor_axis, new_minor)
 
     def test_get_axis_number(self):
         self.assertEqual(self.panel4d._get_axis_number('labels'), 0)
@@ -201,7 +206,7 @@ def test_get_axis_name(self):
         self.assertEqual(self.panel4d._get_axis_name(3), 'minor_axis')
 
     def test_arith(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             self._test_op(self.panel4d, operator.add)
             self._test_op(self.panel4d, operator.sub)
             self._test_op(self.panel4d, operator.mul)
@@ -233,16 +238,16 @@ def test_iteritems(self):
                          len(self.panel4d.labels))
 
     def test_combinePanel4d(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             result = self.panel4d.add(self.panel4d)
             self.assert_panel4d_equal(result, self.panel4d * 2)
 
     def test_neg(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             self.assert_panel4d_equal(-self.panel4d, self.panel4d * -1)
 
     def test_select(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
 
             p = self.panel4d
 
@@ -283,7 +288,7 @@ def test_get_value(self):
 
     def test_abs(self):
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             result = self.panel4d.abs()
             expected = np.abs(self.panel4d)
             self.assert_panel4d_equal(result, expected)
@@ -306,7 +311,7 @@ def test_getitem(self):
 
     def test_delitem_and_pop(self):
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             expected = self.panel4d['l2']
             result = self.panel4d.pop('l2')
             assert_panel_equal(expected, result)
@@ -351,40 +356,38 @@ def test_delitem_and_pop(self):
             assert_panel_equal(panel4dc[0], panel4d[0])
 
     def test_setitem(self):
-        # LongPanel with one item
-        # lp = self.panel.filter(['ItemA', 'ItemB']).to_frame()
-        # self.assertRaises(Exception, self.panel.__setitem__,
-        #                  'ItemE', lp)
+        with catch_warnings(record=True):
 
-        # Panel
-        p = Panel(dict(
-            ItemA=self.panel4d['l1']['ItemA'][2:].filter(items=['A', 'B'])))
-        self.panel4d['l4'] = p
-        self.panel4d['l5'] = p
+            # Panel
+            p = Panel(dict(
+                ItemA=self.panel4d['l1']['ItemA'][2:].filter(
+                    items=['A', 'B'])))
+            self.panel4d['l4'] = p
+            self.panel4d['l5'] = p
 
-        p2 = self.panel4d['l4']
+            p2 = self.panel4d['l4']
 
-        assert_panel_equal(p, p2.reindex(items=p.items,
-                                         major_axis=p.major_axis,
-                                         minor_axis=p.minor_axis))
+            assert_panel_equal(p, p2.reindex(items=p.items,
+                                             major_axis=p.major_axis,
+                                             minor_axis=p.minor_axis))
 
-        # scalar
-        self.panel4d['lG'] = 1
-        self.panel4d['lE'] = True
-        self.assertEqual(self.panel4d['lG'].values.dtype, np.int64)
-        self.assertEqual(self.panel4d['lE'].values.dtype, np.bool_)
+            # scalar
+            self.panel4d['lG'] = 1
+            self.panel4d['lE'] = True
+            self.assertEqual(self.panel4d['lG'].values.dtype, np.int64)
+            self.assertEqual(self.panel4d['lE'].values.dtype, np.bool_)
 
-        # object dtype
-        self.panel4d['lQ'] = 'foo'
-        self.assertEqual(self.panel4d['lQ'].values.dtype, np.object_)
+            # object dtype
+            self.panel4d['lQ'] = 'foo'
+            self.assertEqual(self.panel4d['lQ'].values.dtype, np.object_)
 
-        # boolean dtype
-        self.panel4d['lP'] = self.panel4d['l1'] > 0
-        self.assertEqual(self.panel4d['lP'].values.dtype, np.bool_)
+            # boolean dtype
+            self.panel4d['lP'] = self.panel4d['l1'] > 0
+            self.assertEqual(self.panel4d['lP'].values.dtype, np.bool_)
 
     def test_setitem_by_indexer(self):
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
 
             # Panel
             panel4dc = self.panel4d.copy()
@@ -419,7 +422,7 @@ def func():
 
     def test_setitem_by_indexer_mixed_type(self):
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             # GH 8702
             self.panel4d['foo'] = 'bar'
 
@@ -433,7 +436,7 @@ def test_setitem_by_indexer_mixed_type(self):
             self.assertTrue((panel4dc.iloc[2].values == 'foo').all())
 
     def test_comparisons(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             p1 = tm.makePanel4D()
             p2 = tm.makePanel4D()
 
@@ -467,7 +470,8 @@ def test_major_xs(self):
         ref = self.panel4d['l1']['ItemA']
 
         idx = self.panel4d.major_axis[5]
-        xs = self.panel4d.major_xs(idx)
+        with catch_warnings(record=True):
+            xs = self.panel4d.major_xs(idx)
 
         assert_series_equal(xs['l1'].T['ItemA'],
                             ref.xs(idx), check_names=False)
@@ -478,15 +482,17 @@ def test_major_xs(self):
 
     def test_major_xs_mixed(self):
         self.panel4d['l4'] = 'foo'
-        xs = self.panel4d.major_xs(self.panel4d.major_axis[0])
+        with catch_warnings(record=True):
+            xs = self.panel4d.major_xs(self.panel4d.major_axis[0])
         self.assertEqual(xs['l1']['A'].dtype, np.float64)
         self.assertEqual(xs['l4']['A'].dtype, np.object_)
 
     def test_minor_xs(self):
         ref = self.panel4d['l1']['ItemA']
 
-        idx = self.panel4d.minor_axis[1]
-        xs = self.panel4d.minor_xs(idx)
+        with catch_warnings(record=True):
+            idx = self.panel4d.minor_axis[1]
+            xs = self.panel4d.minor_xs(idx)
 
         assert_series_equal(xs['l1'].T['ItemA'], ref[idx], check_names=False)
 
@@ -496,7 +502,8 @@ def test_minor_xs(self):
     def test_minor_xs_mixed(self):
         self.panel4d['l4'] = 'foo'
 
-        xs = self.panel4d.minor_xs('D')
+        with catch_warnings(record=True):
+            xs = self.panel4d.minor_xs('D')
         self.assertEqual(xs['l1'].T['ItemA'].dtype, np.float64)
         self.assertEqual(xs['l4'].T['ItemA'].dtype, np.object_)
 
@@ -512,11 +519,12 @@ def test_xs(self):
 
         # mixed-type
         self.panel4d['strings'] = 'foo'
-        result = self.panel4d.xs('D', axis=3)
+        with catch_warnings(record=True):
+            result = self.panel4d.xs('D', axis=3)
         self.assertIsNotNone(result.is_copy)
 
     def test_getitem_fancy_labels(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             panel4d = self.panel4d
 
             labels = panel4d.labels[[1, 0]]
@@ -572,7 +580,7 @@ def test_get_value(self):
 
     def test_set_value(self):
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
 
             for label in self.panel4d.labels:
                 for item in self.panel4d.items:
@@ -603,13 +611,13 @@ def assert_panel4d_equal(cls, x, y):
         assert_panel4d_equal(x, y)
 
     def setUp(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             self.panel4d = tm.makePanel4D(nper=8)
             add_nans(self.panel4d)
 
     def test_constructor(self):
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             panel4d = Panel4D(self.panel4d._data)
             self.assertIs(panel4d._data, self.panel4d._data)
 
@@ -649,7 +657,7 @@ def test_constructor(self):
             assert_panel4d_equal(panel4d, expected)
 
     def test_constructor_cast(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             zero_filled = self.panel4d.fillna(0)
 
             casted = Panel4D(zero_filled._data, dtype=int)
@@ -671,7 +679,7 @@ def test_constructor_cast(self):
             self.assertRaises(ValueError, Panel, data, dtype=float)
 
     def test_consolidate(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             self.assertTrue(self.panel4d._data.is_consolidated())
 
             self.panel4d['foo'] = 1.
@@ -681,7 +689,7 @@ def test_consolidate(self):
             self.assertTrue(panel4d._data.is_consolidated())
 
     def test_ctor_dict(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             l1 = self.panel4d['l1']
             l2 = self.panel4d['l2']
 
@@ -694,7 +702,7 @@ def test_ctor_dict(self):
                                                 :, :]['ItemB'])
 
     def test_constructor_dict_mixed(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             data = dict((k, v.values) for k, v in self.panel4d.iteritems())
             result = Panel4D(data)
 
@@ -721,7 +729,7 @@ def test_constructor_dict_mixed(self):
             self.assertRaises(Exception, Panel4D, data)
 
     def test_constructor_resize(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             data = self.panel4d._data
             labels = self.panel4d.labels[:-1]
             items = self.panel4d.items[:-1]
@@ -747,16 +755,19 @@ def test_constructor_resize(self):
             assert_panel4d_equal(result, expected)
 
     def test_conform(self):
+        with catch_warnings(record=True):
 
-        p = self.panel4d['l1'].filter(items=['ItemA', 'ItemB'])
-        conformed = self.panel4d.conform(p)
+            p = self.panel4d['l1'].filter(items=['ItemA', 'ItemB'])
+            conformed = self.panel4d.conform(p)
 
-        tm.assert_index_equal(conformed.items, self.panel4d.labels)
-        tm.assert_index_equal(conformed.major_axis, self.panel4d.major_axis)
-        tm.assert_index_equal(conformed.minor_axis, self.panel4d.minor_axis)
+            tm.assert_index_equal(conformed.items, self.panel4d.labels)
+            tm.assert_index_equal(conformed.major_axis,
+                                  self.panel4d.major_axis)
+            tm.assert_index_equal(conformed.minor_axis,
+                                  self.panel4d.minor_axis)
 
     def test_reindex(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             ref = self.panel4d['l2']
 
             # labels
@@ -810,14 +821,14 @@ def test_reindex(self):
             self.assertTrue(result is self.panel4d)
 
     def test_not_hashable(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             p4D_empty = Panel4D()
             self.assertRaises(TypeError, hash, p4D_empty)
             self.assertRaises(TypeError, hash, self.panel4d)
 
     def test_reindex_like(self):
         # reindex_like
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             smaller = self.panel4d.reindex(labels=self.panel4d.labels[:-1],
                                            items=self.panel4d.items[:-1],
                                            major=self.panel4d.major_axis[:-1],
@@ -826,7 +837,7 @@ def test_reindex_like(self):
             assert_panel4d_equal(smaller, smaller_like)
 
     def test_sort_index(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             import random
 
             rlabels = list(self.panel4d.labels)
@@ -844,7 +855,7 @@ def test_sort_index(self):
 
     def test_fillna(self):
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             self.assertFalse(np.isfinite(self.panel4d.values).all())
             filled = self.panel4d.fillna(0)
             self.assertTrue(np.isfinite(filled.values).all())
@@ -853,7 +864,7 @@ def test_fillna(self):
                               self.panel4d.fillna, method='pad')
 
     def test_swapaxes(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             result = self.panel4d.swapaxes('labels', 'items')
             self.assertIs(result.items, self.panel4d.labels)
 
@@ -880,7 +891,7 @@ def test_swapaxes(self):
 
     def test_update(self):
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             p4d = Panel4D([[[[1.5, np.nan, 3.],
                              [1.5, np.nan, 3.],
                              [1.5, np.nan, 3.],
@@ -913,12 +924,12 @@ def test_dtypes(self):
         assert_series_equal(result, expected)
 
     def test_repr_empty(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             empty = Panel4D()
             repr(empty)
 
     def test_rename(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
 
             mapper = {'l1': 'foo',
                       'l2': 'bar',
diff --git a/pandas/tests/test_panelnd.py b/pandas/tests/test_panelnd.py
index 6a578d85d3ee3..7ecc773cd7bea 100644
--- a/pandas/tests/test_panelnd.py
+++ b/pandas/tests/test_panelnd.py
@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+from warnings import catch_warnings
 from pandas.core import panelnd
 from pandas.core.panel import Panel
 
@@ -13,7 +14,7 @@ def setUp(self):
 
     def test_4d_construction(self):
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
 
             # create a 4D
             Panel4D = panelnd.create_nd_panel_factory(
@@ -29,7 +30,7 @@ def test_4d_construction(self):
 
     def test_4d_construction_alt(self):
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
 
             # create a 4D
             Panel4D = panelnd.create_nd_panel_factory(
@@ -61,7 +62,7 @@ def test_4d_construction_error(self):
 
     def test_5d_construction(self):
 
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
 
             # create a 4D
             Panel4D = panelnd.create_nd_panel_factory(
diff --git a/pandas/tests/tools/test_concat.py b/pandas/tests/tools/test_concat.py
index 392036a99a297..c41924a7987bd 100644
--- a/pandas/tests/tools/test_concat.py
+++ b/pandas/tests/tools/test_concat.py
@@ -1,3 +1,4 @@
+from warnings import catch_warnings
 import numpy as np
 from numpy.random import randn
 
@@ -1373,7 +1374,7 @@ def df():
         concat([panel1, panel3], axis=1, verify_integrity=True)
 
     def test_panel4d_concat(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             p4d = tm.makePanel4D()
 
             p1 = p4d.iloc[:, :, :5, :]
@@ -1389,7 +1390,7 @@ def test_panel4d_concat(self):
             tm.assert_panel4d_equal(result, p4d)
 
     def test_panel4d_concat_mixed_type(self):
-        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        with catch_warnings(record=True):
             p4d = tm.makePanel4D()
 
             # if things are a bit misbehaved