TST: split up pandas/tests/indexing/test_multiindex.py (#23912)

Author: simonjayhawkins

pandas/tests/indexing/multiindex/__init__.py

@@ -0,0 +1,32 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame, Index, MultiIndex
+from pandas.util import testing as tm
+
+
+@pytest.fixture
+def multiindex_dataframe_random_data():
+    """DataFrame with 2 level MultiIndex with random data"""
+    index = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux'], ['one', 'two',
+                                                              'three']],
+                       labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3],
+                               [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]],
+                       names=['first', 'second'])
+    return DataFrame(np.random.randn(10, 3), index=index,
+                     columns=Index(['A', 'B', 'C'], name='exp'))
+
+
+@pytest.fixture
+def multiindex_year_month_day_dataframe_random_data():
+    """DataFrame with 3 level MultiIndex (year, month, day) covering
+    first 100 business days from 2000-01-01 with random data"""
+    tm.N = 100
+    tdf = tm.makeTimeDataFrame()
+    ymd = tdf.groupby([lambda x: x.year, lambda x: x.month,
+                       lambda x: x.day]).sum()
+    # use Int64Index, to make sure things work
+    ymd.index.set_levels([lev.astype('i8') for lev in ymd.index.levels],
+                         inplace=True)
+    ymd.index.set_names(['year', 'month', 'day'], inplace=True)
+    return ymd

pandas/tests/indexing/multiindex/conftest.py

@@ -0,0 +1,22 @@
+from datetime import datetime
+
+import numpy as np
+
+from pandas import Index, Period, Series, period_range
+
+
+def test_multiindex_period_datetime():
+    # GH4861, using datetime in period of multiindex raises exception
+
+    idx1 = Index(['a', 'a', 'a', 'b', 'b'])
+    idx2 = period_range('2012-01', periods=len(idx1), freq='M')
+    s = Series(np.random.randn(len(idx1)), [idx1, idx2])
+
+    # try Period as index
+    expected = s.iloc[0]
+    result = s.loc['a', Period('2012-01')]
+    assert result == expected
+
+    # try datetime as index
+    result = s.loc['a', datetime(2012, 1, 1)]
+    assert result == expected

pandas/tests/indexing/multiindex/test_datetime.py

@@ -0,0 +1,345 @@
+from warnings import catch_warnings, simplefilter
+
+import numpy as np
+import pytest
+
+from pandas.compat import lrange, range, u, zip
+
+import pandas as pd
+from pandas import DataFrame, Index, MultiIndex, Series, date_range
+import pandas.core.common as com
+from pandas.util import testing as tm
+
+
+@pytest.mark.filterwarnings("ignore:\\n.ix:DeprecationWarning")
+class TestMultiIndexGetItem(object):
+
+    def test_series_getitem_multiindex(self):
+
+        # GH 6018
+        # series regression getitem with a multi-index
+
+        s = Series([1, 2, 3])
+        s.index = MultiIndex.from_tuples([(0, 0), (1, 1), (2, 1)])
+
+        result = s[:, 0]
+        expected = Series([1], index=[0])
+        tm.assert_series_equal(result, expected)
+
+        result = s.loc[:, 1]
+        expected = Series([2, 3], index=[1, 2])
+        tm.assert_series_equal(result, expected)
+
+        # xs
+        result = s.xs(0, level=0)
+        expected = Series([1], index=[0])
+        tm.assert_series_equal(result, expected)
+
+        result = s.xs(1, level=1)
+        expected = Series([2, 3], index=[1, 2])
+        tm.assert_series_equal(result, expected)
+
+        # GH6258
+        dt = list(date_range('20130903', periods=3))
+        idx = MultiIndex.from_product([list('AB'), dt])
+        s = Series([1, 3, 4, 1, 3, 4], index=idx)
+
+        result = s.xs('20130903', level=1)
+        expected = Series([1, 1], index=list('AB'))
+        tm.assert_series_equal(result, expected)
+
+        # GH5684
+        idx = MultiIndex.from_tuples([('a', 'one'), ('a', 'two'), ('b', 'one'),
+                                      ('b', 'two')])
+        s = Series([1, 2, 3, 4], index=idx)
+        s.index.set_names(['L1', 'L2'], inplace=True)
+        result = s.xs('one', level='L2')
+        expected = Series([1, 3], index=['a', 'b'])
+        expected.index.set_names(['L1'], inplace=True)
+        tm.assert_series_equal(result, expected)
+
+    def test_getitem_duplicates_multiindex(self):
+        # GH 5725 the 'A' happens to be a valid Timestamp so the doesn't raise
+        # the appropriate error, only in PY3 of course!
+
+        index = MultiIndex(levels=[['D', 'B', 'C'],
+                                   [0, 26, 27, 37, 57, 67, 75, 82]],
+                           labels=[[0, 0, 0, 1, 2, 2, 2, 2, 2, 2],
+                                   [1, 3, 4, 6, 0, 2, 2, 3, 5, 7]],
+                           names=['tag', 'day'])
+        arr = np.random.randn(len(index), 1)
+        df = DataFrame(arr, index=index, columns=['val'])
+        result = df.val['D']
+        expected = Series(arr.ravel()[0:3], name='val', index=Index(
+            [26, 37, 57], name='day'))
+        tm.assert_series_equal(result, expected)
+
+        def f():
+            df.val['A']
+
+        pytest.raises(KeyError, f)
+
+        def f():
+            df.val['X']
+
+        pytest.raises(KeyError, f)
+
+        # A is treated as a special Timestamp
+        index = MultiIndex(levels=[['A', 'B', 'C'],
+                                   [0, 26, 27, 37, 57, 67, 75, 82]],
+                           labels=[[0, 0, 0, 1, 2, 2, 2, 2, 2, 2],
+                                   [1, 3, 4, 6, 0, 2, 2, 3, 5, 7]],
+                           names=['tag', 'day'])
+        df = DataFrame(arr, index=index, columns=['val'])
+        result = df.val['A']
+        expected = Series(arr.ravel()[0:3], name='val', index=Index(
+            [26, 37, 57], name='day'))
+        tm.assert_series_equal(result, expected)
+
+        def f():
+            df.val['X']
+
+        pytest.raises(KeyError, f)
+
+        # GH 7866
+        # multi-index slicing with missing indexers
+        idx = MultiIndex.from_product([['A', 'B', 'C'],
+                                       ['foo', 'bar', 'baz']],
+                                      names=['one', 'two'])
+        s = Series(np.arange(9, dtype='int64'), index=idx).sort_index()
+
+        exp_idx = MultiIndex.from_product([['A'], ['foo', 'bar', 'baz']],
+                                          names=['one', 'two'])
+        expected = Series(np.arange(3, dtype='int64'),
+                          index=exp_idx).sort_index()
+
+        result = s.loc[['A']]
+        tm.assert_series_equal(result, expected)
+        result = s.loc[['A', 'D']]
+        tm.assert_series_equal(result, expected)
+
+        # not any values found
+        pytest.raises(KeyError, lambda: s.loc[['D']])
+
+        # empty ok
+        result = s.loc[[]]
+        expected = s.iloc[[]]
+        tm.assert_series_equal(result, expected)
+
+        idx = pd.IndexSlice
+        expected = Series([0, 3, 6], index=MultiIndex.from_product(
+            [['A', 'B', 'C'], ['foo']], names=['one', 'two'])).sort_index()
+
+        result = s.loc[idx[:, ['foo']]]
+        tm.assert_series_equal(result, expected)
+        result = s.loc[idx[:, ['foo', 'bah']]]
+        tm.assert_series_equal(result, expected)
+
+        # GH 8737
+        # empty indexer
+        multi_index = MultiIndex.from_product((['foo', 'bar', 'baz'],
+                                               ['alpha', 'beta']))
+        df = DataFrame(
+            np.random.randn(5, 6), index=range(5), columns=multi_index)
+        df = df.sort_index(level=0, axis=1)
+
+        expected = DataFrame(index=range(5),
+                             columns=multi_index.reindex([])[0])
+        result1 = df.loc[:, ([], slice(None))]
+        result2 = df.loc[:, (['foo'], [])]
+        tm.assert_frame_equal(result1, expected)
+        tm.assert_frame_equal(result2, expected)
+
+        # regression from < 0.14.0
+        # GH 7914
+        df = DataFrame([[np.mean, np.median], ['mean', 'median']],
+                       columns=MultiIndex.from_tuples([('functs', 'mean'),
+                                                       ('functs', 'median')]),
+                       index=['function', 'name'])
+        result = df.loc['function', ('functs', 'mean')]
+        assert result == np.mean
+
+    def test_getitem_simple(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        df = frame.T
+
+        col = df['foo', 'one']
+        tm.assert_almost_equal(col.values, df.values[:, 0])
+        with pytest.raises(KeyError):
+            df[('foo', 'four')]
+        with pytest.raises(KeyError):
+            df['foobar']
+
+    def test_series_getitem(
+            self, multiindex_year_month_day_dataframe_random_data):
+        ymd = multiindex_year_month_day_dataframe_random_data
+        s = ymd['A']
+
+        result = s[2000, 3]
+
+        # TODO(wesm): unused?
+        # result2 = s.loc[2000, 3]
+
+        expected = s.reindex(s.index[42:65])
+        expected.index = expected.index.droplevel(0).droplevel(0)
+        tm.assert_series_equal(result, expected)
+
+        result = s[2000, 3, 10]
+        expected = s[49]
+        assert result == expected
+
+        # fancy
+        expected = s.reindex(s.index[49:51])
+        result = s.loc[[(2000, 3, 10), (2000, 3, 13)]]
+        tm.assert_series_equal(result, expected)
+
+        with catch_warnings(record=True):
+            simplefilter("ignore", DeprecationWarning)
+            result = s.ix[[(2000, 3, 10), (2000, 3, 13)]]
+        tm.assert_series_equal(result, expected)
+
+        # key error
+        pytest.raises(KeyError, s.__getitem__, (2000, 3, 4))
+
+    def test_series_getitem_corner(
+            self, multiindex_year_month_day_dataframe_random_data):
+        ymd = multiindex_year_month_day_dataframe_random_data
+        s = ymd['A']
+
+        # don't segfault, GH #495
+        # out of bounds access
+        pytest.raises(IndexError, s.__getitem__, len(ymd))
+
+        # generator
+        result = s[(x > 0 for x in s)]
+        expected = s[s > 0]
+        tm.assert_series_equal(result, expected)
+
+    def test_frame_getitem_multicolumn_empty_level(self):
+        f = DataFrame({'a': ['1', '2', '3'], 'b': ['2', '3', '4']})
+        f.columns = [['level1 item1', 'level1 item2'], ['', 'level2 item2'],
+                     ['level3 item1', 'level3 item2']]
+
+        result = f['level1 item1']
+        expected = DataFrame([['1'], ['2'], ['3']], index=f.index,
+                             columns=['level3 item1'])
+        tm.assert_frame_equal(result, expected)
+
+    def test_getitem_tuple_plus_slice(self):
+        # GH #671
+        df = DataFrame({'a': lrange(10),
+                        'b': lrange(10),
+                        'c': np.random.randn(10),
+                        'd': np.random.randn(10)})
+
+        idf = df.set_index(['a', 'b'])
+
+        result = idf.loc[(0, 0), :]
+        expected = idf.loc[0, 0]
+        expected2 = idf.xs((0, 0))
+        with catch_warnings(record=True):
+            simplefilter("ignore", DeprecationWarning)
+            expected3 = idf.ix[0, 0]
+
+        tm.assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected2)
+        tm.assert_series_equal(result, expected3)
+
+    def test_getitem_toplevel(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        df = frame.T
+
+        result = df['foo']
+        expected = df.reindex(columns=df.columns[:3])
+        expected.columns = expected.columns.droplevel(0)
+        tm.assert_frame_equal(result, expected)
+
+        result = df['bar']
+        result2 = df.loc[:, 'bar']
+
+        expected = df.reindex(columns=df.columns[3:5])
+        expected.columns = expected.columns.droplevel(0)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, result2)
+
+    def test_getitem_int(self, multiindex_dataframe_random_data):
+        levels = [[0, 1], [0, 1, 2]]
+        labels = [[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]]
+        index = MultiIndex(levels=levels, labels=labels)
+
+        frame = DataFrame(np.random.randn(6, 2), index=index)
+
+        result = frame.loc[1]
+        expected = frame[-3:]
+        expected.index = expected.index.droplevel(0)
+        tm.assert_frame_equal(result, expected)
+
+        # raises exception
+        pytest.raises(KeyError, frame.loc.__getitem__, 3)
+
+        # however this will work
+        frame = multiindex_dataframe_random_data
+        result = frame.iloc[2]
+        expected = frame.xs(frame.index[2])
+        tm.assert_series_equal(result, expected)
+
+    def test_frame_getitem_view(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        df = frame.T.copy()
+
+        # this works because we are modifying the underlying array
+        # really a no-no
+        df['foo'].values[:] = 0
+        assert (df['foo'].values == 0).all()
+
+        # but not if it's mixed-type
+        df['foo', 'four'] = 'foo'
+        df = df.sort_index(level=0, axis=1)
+
+        # this will work, but will raise/warn as its chained assignment
+        def f():
+            df['foo']['one'] = 2
+            return df
+
+        pytest.raises(com.SettingWithCopyError, f)
+
+        try:
+            df = f()
+        except ValueError:
+            pass
+        assert (df['foo', 'one'] == 0).all()
+
+    def test_getitem_lowerdim_corner(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        pytest.raises(KeyError, frame.loc.__getitem__,
+                      (('bar', 'three'), 'B'))
+
+        # in theory should be inserting in a sorted space????
+        frame.loc[('bar', 'three'), 'B'] = 0
+        assert frame.sort_index().loc[('bar', 'three'), 'B'] == 0
+
+    @pytest.mark.parametrize('unicode_strings', [True, False])
+    def test_mixed_depth_get(self, unicode_strings):
+        # If unicode_strings is True, the column labels in dataframe
+        # construction will use unicode strings in Python 2 (pull request
+        # #17099).
+
+        arrays = [['a', 'top', 'top', 'routine1', 'routine1', 'routine2'],
+                  ['', 'OD', 'OD', 'result1', 'result2', 'result1'],
+                  ['', 'wx', 'wy', '', '', '']]
+
+        if unicode_strings:
+            arrays = [[u(s) for s in arr] for arr in arrays]
+
+        tuples = sorted(zip(*arrays))
+        index = MultiIndex.from_tuples(tuples)
+        df = DataFrame(np.random.randn(4, 6), columns=index)
+
+        result = df['a']
+        expected = df['a', '', ''].rename('a')
+        tm.assert_series_equal(result, expected)
+
+        result = df['routine1', 'result1']
+        expected = df['routine1', 'result1', '']
+        expected = expected.rename(('routine1', 'result1'))
+        tm.assert_series_equal(result, expected)

pandas/tests/indexing/multiindex/test_getitem.py

@@ -0,0 +1,129 @@
+from warnings import catch_warnings
+
+import numpy as np
+import pytest
+
+from pandas import DataFrame, MultiIndex, Series
+from pandas.util import testing as tm
+
+
+@pytest.mark.filterwarnings("ignore:\\n.ix:DeprecationWarning")
+class TestMultiIndexIloc(object):
+
+    def test_iloc_getitem_multiindex2(self):
+        # TODO(wesm): fix this
+        pytest.skip('this test was being suppressed, '
+                    'needs to be fixed')
+
+        arr = np.random.randn(3, 3)
+        df = DataFrame(arr, columns=[[2, 2, 4], [6, 8, 10]],
+                       index=[[4, 4, 8], [8, 10, 12]])
+
+        rs = df.iloc[2]
+        xp = Series(arr[2], index=df.columns)
+        tm.assert_series_equal(rs, xp)
+
+        rs = df.iloc[:, 2]
+        xp = Series(arr[:, 2], index=df.index)
+        tm.assert_series_equal(rs, xp)
+
+        rs = df.iloc[2, 2]
+        xp = df.values[2, 2]
+        assert rs == xp
+
+        # for multiple items
+        # GH 5528
+        rs = df.iloc[[0, 1]]
+        xp = df.xs(4, drop_level=False)
+        tm.assert_frame_equal(rs, xp)
+
+        tup = zip(*[['a', 'a', 'b', 'b'], ['x', 'y', 'x', 'y']])
+        index = MultiIndex.from_tuples(tup)
+        df = DataFrame(np.random.randn(4, 4), index=index)
+        rs = df.iloc[[2, 3]]
+        xp = df.xs('b', drop_level=False)
+        tm.assert_frame_equal(rs, xp)
+
+    def test_iloc_getitem_multiindex(self):
+        mi_labels = DataFrame(np.random.randn(4, 3),
+                              columns=[['i', 'i', 'j'], ['A', 'A', 'B']],
+                              index=[['i', 'i', 'j', 'k'],
+                                     ['X', 'X', 'Y', 'Y']])
+
+        mi_int = DataFrame(np.random.randn(3, 3),
+                           columns=[[2, 2, 4], [6, 8, 10]],
+                           index=[[4, 4, 8], [8, 10, 12]])
+
+        # the first row
+        rs = mi_int.iloc[0]
+        with catch_warnings(record=True):
+            xp = mi_int.ix[4].ix[8]
+        tm.assert_series_equal(rs, xp, check_names=False)
+        assert rs.name == (4, 8)
+        assert xp.name == 8
+
+        # 2nd (last) columns
+        rs = mi_int.iloc[:, 2]
+        with catch_warnings(record=True):
+            xp = mi_int.ix[:, 2]
+        tm.assert_series_equal(rs, xp)
+
+        # corner column
+        rs = mi_int.iloc[2, 2]
+        with catch_warnings(record=True):
+            # First level is int - so use .loc rather than .ix (GH 21593)
+            xp = mi_int.loc[(8, 12), (4, 10)]
+        assert rs == xp
+
+        # this is basically regular indexing
+        rs = mi_labels.iloc[2, 2]
+        with catch_warnings(record=True):
+            xp = mi_labels.ix['j'].ix[:, 'j'].ix[0, 0]
+        assert rs == xp
+
+    def test_frame_getitem_setitem_slice(
+            self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        # getitem
+        result = frame.iloc[:4]
+        expected = frame[:4]
+        tm.assert_frame_equal(result, expected)
+
+        # setitem
+        cp = frame.copy()
+        cp.iloc[:4] = 0
+
+        assert (cp.values[:4] == 0).all()
+        assert (cp.values[4:] != 0).all()
+
+    def test_indexing_ambiguity_bug_1678(self):
+        columns = MultiIndex.from_tuples([('Ohio', 'Green'), ('Ohio', 'Red'), (
+            'Colorado', 'Green')])
+        index = MultiIndex.from_tuples([('a', 1), ('a', 2), ('b', 1), ('b', 2)
+                                        ])
+
+        frame = DataFrame(np.arange(12).reshape((4, 3)), index=index,
+                          columns=columns)
+
+        result = frame.iloc[:, 1]
+        exp = frame.loc[:, ('Ohio', 'Red')]
+        assert isinstance(result, Series)
+        tm.assert_series_equal(result, exp)
+
+    def test_iloc_mi(self):
+        # GH 13797
+        # Test if iloc can handle integer locations in MultiIndexed DataFrame
+
+        data = [['str00', 'str01'], ['str10', 'str11'], ['str20', 'srt21'],
+                ['str30', 'str31'], ['str40', 'str41']]
+
+        mi = MultiIndex.from_tuples(
+            [('CC', 'A'), ('CC', 'B'), ('CC', 'B'), ('BB', 'a'), ('BB', 'b')])
+
+        expected = DataFrame(data)
+        df_mi = DataFrame(data, index=mi)
+
+        result = DataFrame([[df_mi.iloc[r, c] for c in range(2)]
+                            for r in range(5)])
+
+        tm.assert_frame_equal(result, expected)

pandas/tests/indexing/multiindex/test_iloc.py

@@ -0,0 +1,27 @@
+from warnings import catch_warnings, simplefilter
+
+import pytest
+
+from pandas.compat import lrange
+
+
+@pytest.mark.filterwarnings("ignore:\\n.ix:DeprecationWarning")
+class TestMultiIndexIx(object):
+
+    def test_frame_setitem_ix(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        frame.loc[('bar', 'two'), 'B'] = 5
+        assert frame.loc[('bar', 'two'), 'B'] == 5
+
+        # with integer labels
+        df = frame.copy()
+        df.columns = lrange(3)
+        df.loc[('bar', 'two'), 1] = 7
+        assert df.loc[('bar', 'two'), 1] == 7
+
+        with catch_warnings(record=True):
+            simplefilter("ignore", DeprecationWarning)
+            df = frame.copy()
+            df.columns = lrange(3)
+            df.ix[('bar', 'two'), 1] = 7
+        assert df.loc[('bar', 'two'), 1] == 7

pandas/tests/indexing/multiindex/test_ix.py

@@ -0,0 +1,177 @@
+from warnings import catch_warnings
+
+import numpy as np
+import pytest
+
+from pandas import DataFrame, MultiIndex, Series
+from pandas.util import testing as tm
+
+
+@pytest.fixture
+def single_level_multiindex():
+    """single level MultiIndex"""
+    return MultiIndex(levels=[['foo', 'bar', 'baz', 'qux']],
+                      labels=[[0, 1, 2, 3]], names=['first'])
+
+
+@pytest.mark.filterwarnings("ignore:\\n.ix:DeprecationWarning")
+class TestMultiIndexLoc(object):
+
+    def test_loc_getitem_series(self):
+        # GH14730
+        # passing a series as a key with a MultiIndex
+        index = MultiIndex.from_product([[1, 2, 3], ['A', 'B', 'C']])
+        x = Series(index=index, data=range(9), dtype=np.float64)
+        y = Series([1, 3])
+        expected = Series(
+            data=[0, 1, 2, 6, 7, 8],
+            index=MultiIndex.from_product([[1, 3], ['A', 'B', 'C']]),
+            dtype=np.float64)
+        result = x.loc[y]
+        tm.assert_series_equal(result, expected)
+
+        result = x.loc[[1, 3]]
+        tm.assert_series_equal(result, expected)
+
+        # GH15424
+        y1 = Series([1, 3], index=[1, 2])
+        result = x.loc[y1]
+        tm.assert_series_equal(result, expected)
+
+        empty = Series(data=[], dtype=np.float64)
+        expected = Series([], index=MultiIndex(
+            levels=index.levels, labels=[[], []], dtype=np.float64))
+        result = x.loc[empty]
+        tm.assert_series_equal(result, expected)
+
+    def test_loc_getitem_array(self):
+        # GH15434
+        # passing an array as a key with a MultiIndex
+        index = MultiIndex.from_product([[1, 2, 3], ['A', 'B', 'C']])
+        x = Series(index=index, data=range(9), dtype=np.float64)
+        y = np.array([1, 3])
+        expected = Series(
+            data=[0, 1, 2, 6, 7, 8],
+            index=MultiIndex.from_product([[1, 3], ['A', 'B', 'C']]),
+            dtype=np.float64)
+        result = x.loc[y]
+        tm.assert_series_equal(result, expected)
+
+        # empty array:
+        empty = np.array([])
+        expected = Series([], index=MultiIndex(
+            levels=index.levels, labels=[[], []], dtype=np.float64))
+        result = x.loc[empty]
+        tm.assert_series_equal(result, expected)
+
+        # 0-dim array (scalar):
+        scalar = np.int64(1)
+        expected = Series(
+            data=[0, 1, 2],
+            index=['A', 'B', 'C'],
+            dtype=np.float64)
+        result = x.loc[scalar]
+        tm.assert_series_equal(result, expected)
+
+    def test_loc_multiindex(self):
+
+        mi_labels = DataFrame(np.random.randn(3, 3),
+                              columns=[['i', 'i', 'j'], ['A', 'A', 'B']],
+                              index=[['i', 'i', 'j'], ['X', 'X', 'Y']])
+
+        mi_int = DataFrame(np.random.randn(3, 3),
+                           columns=[[2, 2, 4], [6, 8, 10]],
+                           index=[[4, 4, 8], [8, 10, 12]])
+
+        # the first row
+        rs = mi_labels.loc['i']
+        with catch_warnings(record=True):
+            xp = mi_labels.ix['i']
+        tm.assert_frame_equal(rs, xp)
+
+        # 2nd (last) columns
+        rs = mi_labels.loc[:, 'j']
+        with catch_warnings(record=True):
+            xp = mi_labels.ix[:, 'j']
+        tm.assert_frame_equal(rs, xp)
+
+        # corner column
+        rs = mi_labels.loc['j'].loc[:, 'j']
+        with catch_warnings(record=True):
+            xp = mi_labels.ix['j'].ix[:, 'j']
+        tm.assert_frame_equal(rs, xp)
+
+        # with a tuple
+        rs = mi_labels.loc[('i', 'X')]
+        with catch_warnings(record=True):
+            xp = mi_labels.ix[('i', 'X')]
+        tm.assert_frame_equal(rs, xp)
+
+        rs = mi_int.loc[4]
+        with catch_warnings(record=True):
+            xp = mi_int.ix[4]
+        tm.assert_frame_equal(rs, xp)
+
+        # missing label
+        pytest.raises(KeyError, lambda: mi_int.loc[2])
+        with catch_warnings(record=True):
+            # GH 21593
+            pytest.raises(KeyError, lambda: mi_int.ix[2])
+
+    def test_loc_multiindex_indexer_none(self):
+
+        # GH6788
+        # multi-index indexer is None (meaning take all)
+        attributes = ['Attribute' + str(i) for i in range(1)]
+        attribute_values = ['Value' + str(i) for i in range(5)]
+
+        index = MultiIndex.from_product([attributes, attribute_values])
+        df = 0.1 * np.random.randn(10, 1 * 5) + 0.5
+        df = DataFrame(df, columns=index)
+        result = df[attributes]
+        tm.assert_frame_equal(result, df)
+
+        # GH 7349
+        # loc with a multi-index seems to be doing fallback
+        df = DataFrame(np.arange(12).reshape(-1, 1),
+                       index=MultiIndex.from_product([[1, 2, 3, 4],
+                                                      [1, 2, 3]]))
+
+        expected = df.loc[([1, 2], ), :]
+        result = df.loc[[1, 2]]
+        tm.assert_frame_equal(result, expected)
+
+    def test_loc_multiindex_incomplete(self):
+
+        # GH 7399
+        # incomplete indexers
+        s = Series(np.arange(15, dtype='int64'),
+                   MultiIndex.from_product([range(5), ['a', 'b', 'c']]))
+        expected = s.loc[:, 'a':'c']
+
+        result = s.loc[0:4, 'a':'c']
+        tm.assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
+
+        result = s.loc[:4, 'a':'c']
+        tm.assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
+
+        result = s.loc[0:, 'a':'c']
+        tm.assert_series_equal(result, expected)
+        tm.assert_series_equal(result, expected)
+
+        # GH 7400
+        # multiindexer gettitem with list of indexers skips wrong element
+        s = Series(np.arange(15, dtype='int64'),
+                   MultiIndex.from_product([range(5), ['a', 'b', 'c']]))
+        expected = s.iloc[[6, 7, 8, 12, 13, 14]]
+        result = s.loc[2:4:2, 'a':'c']
+        tm.assert_series_equal(result, expected)
+
+    def test_get_loc_single_level(self, single_level_multiindex):
+        single_level = single_level_multiindex
+        s = Series(np.random.randn(len(single_level)),
+                   index=single_level)
+        for k in single_level.values:
+            s[k]

pandas/tests/indexing/multiindex/test_loc.py

@@ -0,0 +1,71 @@
+
+import numpy as np
+import pytest
+
+import pandas._libs.index as _index
+from pandas.errors import PerformanceWarning
+
+import pandas as pd
+from pandas import DataFrame, MultiIndex, Series
+from pandas.util import testing as tm
+
+
+class TestMultiIndexBasic(object):
+
+    def test_multiindex_perf_warn(self):
+
+        df = DataFrame({'jim': [0, 0, 1, 1],
+                        'joe': ['x', 'x', 'z', 'y'],
+                        'jolie': np.random.rand(4)}).set_index(['jim', 'joe'])
+
+        with tm.assert_produces_warning(PerformanceWarning,
+                                        clear=[pd.core.index]):
+            df.loc[(1, 'z')]
+
+        df = df.iloc[[2, 1, 3, 0]]
+        with tm.assert_produces_warning(PerformanceWarning):
+            df.loc[(0, )]
+
+    def test_multiindex_contains_dropped(self):
+        # GH 19027
+        # test that dropped MultiIndex levels are not in the MultiIndex
+        # despite continuing to be in the MultiIndex's levels
+        idx = MultiIndex.from_product([[1, 2], [3, 4]])
+        assert 2 in idx
+        idx = idx.drop(2)
+
+        # drop implementation keeps 2 in the levels
+        assert 2 in idx.levels[0]
+        # but it should no longer be in the index itself
+        assert 2 not in idx
+
+        # also applies to strings
+        idx = MultiIndex.from_product([['a', 'b'], ['c', 'd']])
+        assert 'a' in idx
+        idx = idx.drop('a')
+        assert 'a' in idx.levels[0]
+        assert 'a' not in idx
+
+    @pytest.mark.parametrize("data, expected", [
+        (MultiIndex.from_product([(), ()]), True),
+        (MultiIndex.from_product([(1, 2), (3, 4)]), True),
+        (MultiIndex.from_product([('a', 'b'), (1, 2)]), False),
+    ])
+    def test_multiindex_is_homogeneous_type(self, data, expected):
+        assert data._is_homogeneous_type is expected
+
+    def test_indexing_over_hashtable_size_cutoff(self):
+        n = 10000
+
+        old_cutoff = _index._SIZE_CUTOFF
+        _index._SIZE_CUTOFF = 20000
+
+        s = Series(np.arange(n),
+                   MultiIndex.from_arrays((["a"] * n, np.arange(n))))
+
+        # hai it works!
+        assert s[("a", 5)] == 5
+        assert s[("a", 6)] == 6
+        assert s[("a", 7)] == 7
+
+        _index._SIZE_CUTOFF = old_cutoff

pandas/tests/indexing/multiindex/test_multiindex.py

@@ -0,0 +1,103 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame, MultiIndex, Panel, Series
+from pandas.util import testing as tm
+
+
+@pytest.mark.filterwarnings('ignore:\\nPanel:FutureWarning')
+class TestMultiIndexPanel(object):
+
+    def test_iloc_getitem_panel_multiindex(self):
+
+        # GH 7199
+        # Panel with multi-index
+        multi_index = MultiIndex.from_tuples([('ONE', 'one'),
+                                              ('TWO', 'two'),
+                                              ('THREE', 'three')],
+                                             names=['UPPER', 'lower'])
+
+        simple_index = [x[0] for x in multi_index]
+        wd1 = Panel(items=['First', 'Second'],
+                    major_axis=['a', 'b', 'c', 'd'],
+                    minor_axis=multi_index)
+
+        wd2 = Panel(items=['First', 'Second'],
+                    major_axis=['a', 'b', 'c', 'd'],
+                    minor_axis=simple_index)
+
+        expected1 = wd1['First'].iloc[[True, True, True, False], [0, 2]]
+        result1 = wd1.iloc[0, [True, True, True, False], [0, 2]]  # WRONG
+        tm.assert_frame_equal(result1, expected1)
+
+        expected2 = wd2['First'].iloc[[True, True, True, False], [0, 2]]
+        result2 = wd2.iloc[0, [True, True, True, False], [0, 2]]
+        tm.assert_frame_equal(result2, expected2)
+
+        expected1 = DataFrame(index=['a'], columns=multi_index,
+                              dtype='float64')
+        result1 = wd1.iloc[0, [0], [0, 1, 2]]
+        tm.assert_frame_equal(result1, expected1)
+
+        expected2 = DataFrame(index=['a'], columns=simple_index,
+                              dtype='float64')
+        result2 = wd2.iloc[0, [0], [0, 1, 2]]
+        tm.assert_frame_equal(result2, expected2)
+
+        # GH 7516
+        mi = MultiIndex.from_tuples([(0, 'x'), (1, 'y'), (2, 'z')])
+        p = Panel(np.arange(3 * 3 * 3, dtype='int64').reshape(3, 3, 3),
+                  items=['a', 'b', 'c'], major_axis=mi,
+                  minor_axis=['u', 'v', 'w'])
+        result = p.iloc[:, 1, 0]
+        expected = Series([3, 12, 21], index=['a', 'b', 'c'], name='u')
+        tm.assert_series_equal(result, expected)
+
+        result = p.loc[:, (1, 'y'), 'u']
+        tm.assert_series_equal(result, expected)
+
+    def test_panel_setitem_with_multiindex(self):
+
+        # 10360
+        # failing with a multi-index
+        arr = np.array([[[1, 2, 3], [0, 0, 0]],
+                        [[0, 0, 0], [0, 0, 0]]],
+                       dtype=np.float64)
+
+        # reg index
+        axes = dict(items=['A', 'B'], major_axis=[0, 1],
+                    minor_axis=['X', 'Y', 'Z'])
+        p1 = Panel(0., **axes)
+        p1.iloc[0, 0, :] = [1, 2, 3]
+        expected = Panel(arr, **axes)
+        tm.assert_panel_equal(p1, expected)
+
+        # multi-indexes
+        axes['items'] = MultiIndex.from_tuples(
+            [('A', 'a'), ('B', 'b')])
+        p2 = Panel(0., **axes)
+        p2.iloc[0, 0, :] = [1, 2, 3]
+        expected = Panel(arr, **axes)
+        tm.assert_panel_equal(p2, expected)
+
+        axes['major_axis'] = MultiIndex.from_tuples(
+            [('A', 1), ('A', 2)])
+        p3 = Panel(0., **axes)
+        p3.iloc[0, 0, :] = [1, 2, 3]
+        expected = Panel(arr, **axes)
+        tm.assert_panel_equal(p3, expected)
+
+        axes['minor_axis'] = MultiIndex.from_product(
+            [['X'], range(3)])
+        p4 = Panel(0., **axes)
+        p4.iloc[0, 0, :] = [1, 2, 3]
+        expected = Panel(arr, **axes)
+        tm.assert_panel_equal(p4, expected)
+
+        arr = np.array(
+            [[[1, 0, 0], [2, 0, 0]], [[0, 0, 0], [0, 0, 0]]],
+            dtype=np.float64)
+        p5 = Panel(0., **axes)
+        p5.iloc[0, :, 0] = [1, 2]
+        expected = Panel(arr, **axes)
+        tm.assert_panel_equal(p5, expected)

pandas/tests/indexing/multiindex/test_panel.py

@@ -0,0 +1,183 @@
+from warnings import catch_warnings, simplefilter
+
+import numpy as np
+import pytest
+
+from pandas import DataFrame, MultiIndex
+from pandas.util import testing as tm
+
+
+class TestMultiIndexPartial(object):
+
+    def test_getitem_partial_int(self):
+        # GH 12416
+        # with single item
+        l1 = [10, 20]
+        l2 = ['a', 'b']
+        df = DataFrame(index=range(2),
+                       columns=MultiIndex.from_product([l1, l2]))
+        expected = DataFrame(index=range(2),
+                             columns=l2)
+        result = df[20]
+        tm.assert_frame_equal(result, expected)
+
+        # with list
+        expected = DataFrame(index=range(2),
+                             columns=MultiIndex.from_product([l1[1:], l2]))
+        result = df[[20]]
+        tm.assert_frame_equal(result, expected)
+
+        # missing item:
+        with pytest.raises(KeyError, match='1'):
+            df[1]
+        with pytest.raises(KeyError, match=r"'\[1\] not in index'"):
+            df[[1]]
+
+    def test_series_slice_partial(self):
+        pass
+
+    def test_xs_partial(self, multiindex_dataframe_random_data,
+                        multiindex_year_month_day_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        ymd = multiindex_year_month_day_dataframe_random_data
+        result = frame.xs('foo')
+        result2 = frame.loc['foo']
+        expected = frame.T['foo'].T
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, result2)
+
+        result = ymd.xs((2000, 4))
+        expected = ymd.loc[2000, 4]
+        tm.assert_frame_equal(result, expected)
+
+        # ex from #1796
+        index = MultiIndex(levels=[['foo', 'bar'], ['one', 'two'], [-1, 1]],
+                           labels=[[0, 0, 0, 0, 1, 1, 1, 1],
+                                   [0, 0, 1, 1, 0, 0, 1, 1], [0, 1, 0, 1, 0, 1,
+                                                              0, 1]])
+        df = DataFrame(np.random.randn(8, 4), index=index,
+                       columns=list('abcd'))
+
+        result = df.xs(['foo', 'one'])
+        expected = df.loc['foo', 'one']
+        tm.assert_frame_equal(result, expected)
+
+    def test_getitem_partial(
+            self, multiindex_year_month_day_dataframe_random_data):
+        ymd = multiindex_year_month_day_dataframe_random_data
+        ymd = ymd.T
+        result = ymd[2000, 2]
+
+        expected = ymd.reindex(columns=ymd.columns[ymd.columns.labels[1] == 1])
+        expected.columns = expected.columns.droplevel(0).droplevel(0)
+        tm.assert_frame_equal(result, expected)
+
+    def test_fancy_slice_partial(
+            self, multiindex_dataframe_random_data,
+            multiindex_year_month_day_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        result = frame.loc['bar':'baz']
+        expected = frame[3:7]
+        tm.assert_frame_equal(result, expected)
+
+        ymd = multiindex_year_month_day_dataframe_random_data
+        result = ymd.loc[(2000, 2):(2000, 4)]
+        lev = ymd.index.labels[1]
+        expected = ymd[(lev >= 1) & (lev <= 3)]
+        tm.assert_frame_equal(result, expected)
+
+    def test_getitem_partial_column_select(self):
+        idx = MultiIndex(labels=[[0, 0, 0], [0, 1, 1], [1, 0, 1]],
+                         levels=[['a', 'b'], ['x', 'y'], ['p', 'q']])
+        df = DataFrame(np.random.rand(3, 2), index=idx)
+
+        result = df.loc[('a', 'y'), :]
+        expected = df.loc[('a', 'y')]
+        tm.assert_frame_equal(result, expected)
+
+        result = df.loc[('a', 'y'), [1, 0]]
+        expected = df.loc[('a', 'y')][[1, 0]]
+        tm.assert_frame_equal(result, expected)
+
+        with catch_warnings(record=True):
+            simplefilter("ignore", DeprecationWarning)
+            result = df.ix[('a', 'y'), [1, 0]]
+        tm.assert_frame_equal(result, expected)
+
+        pytest.raises(KeyError, df.loc.__getitem__,
+                      (('a', 'foo'), slice(None, None)))
+
+    def test_partial_set(
+            self, multiindex_year_month_day_dataframe_random_data):
+        # GH #397
+        ymd = multiindex_year_month_day_dataframe_random_data
+        df = ymd.copy()
+        exp = ymd.copy()
+        df.loc[2000, 4] = 0
+        exp.loc[2000, 4].values[:] = 0
+        tm.assert_frame_equal(df, exp)
+
+        df['A'].loc[2000, 4] = 1
+        exp['A'].loc[2000, 4].values[:] = 1
+        tm.assert_frame_equal(df, exp)
+
+        df.loc[2000] = 5
+        exp.loc[2000].values[:] = 5
+        tm.assert_frame_equal(df, exp)
+
+        # this works...for now
+        df['A'].iloc[14] = 5
+        assert df['A'][14] == 5
+
+    # ---------------------------------------------------------------------
+    # AMBIGUOUS CASES!
+
+    def test_partial_ix_missing(
+            self, multiindex_year_month_day_dataframe_random_data):
+        pytest.skip("skipping for now")
+
+        ymd = multiindex_year_month_day_dataframe_random_data
+        result = ymd.loc[2000, 0]
+        expected = ymd.loc[2000]['A']
+        tm.assert_series_equal(result, expected)
+
+        # need to put in some work here
+
+        # self.ymd.loc[2000, 0] = 0
+        # assert (self.ymd.loc[2000]['A'] == 0).all()
+
+        # Pretty sure the second (and maybe even the first) is already wrong.
+        pytest.raises(Exception, ymd.loc.__getitem__, (2000, 6))
+        pytest.raises(Exception, ymd.loc.__getitem__, (2000, 6), 0)
+
+    # ---------------------------------------------------------------------
+
+    def test_setitem_multiple_partial(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        expected = frame.copy()
+        result = frame.copy()
+        result.loc[['foo', 'bar']] = 0
+        expected.loc['foo'] = 0
+        expected.loc['bar'] = 0
+        tm.assert_frame_equal(result, expected)
+
+        expected = frame.copy()
+        result = frame.copy()
+        result.loc['foo':'bar'] = 0
+        expected.loc['foo'] = 0
+        expected.loc['bar'] = 0
+        tm.assert_frame_equal(result, expected)
+
+        expected = frame['A'].copy()
+        result = frame['A'].copy()
+        result.loc[['foo', 'bar']] = 0
+        expected.loc['foo'] = 0
+        expected.loc['bar'] = 0
+        tm.assert_series_equal(result, expected)
+
+        expected = frame['A'].copy()
+        result = frame['A'].copy()
+        result.loc['foo':'bar'] = 0
+        expected.loc['foo'] = 0
+        expected.loc['bar'] = 0
+        tm.assert_series_equal(result, expected)

pandas/tests/indexing/multiindex/test_partial.py

@@ -0,0 +1,42 @@
+from numpy.random import randn
+
+from pandas import DataFrame, MultiIndex, Series
+from pandas.util import testing as tm
+
+
+class TestMultiIndexSetOps(object):
+
+    def test_multiindex_symmetric_difference(self):
+        # GH 13490
+        idx = MultiIndex.from_product([['a', 'b'], ['A', 'B']],
+                                      names=['a', 'b'])
+        result = idx ^ idx
+        assert result.names == idx.names
+
+        idx2 = idx.copy().rename(['A', 'B'])
+        result = idx ^ idx2
+        assert result.names == [None, None]
+
+    def test_mixed_depth_insert(self):
+        arrays = [['a', 'top', 'top', 'routine1', 'routine1', 'routine2'],
+                  ['', 'OD', 'OD', 'result1', 'result2', 'result1'],
+                  ['', 'wx', 'wy', '', '', '']]
+
+        tuples = sorted(zip(*arrays))
+        index = MultiIndex.from_tuples(tuples)
+        df = DataFrame(randn(4, 6), columns=index)
+
+        result = df.copy()
+        expected = df.copy()
+        result['b'] = [1, 2, 3, 4]
+        expected['b', '', ''] = [1, 2, 3, 4]
+        tm.assert_frame_equal(result, expected)
+
+    def test_dataframe_insert_column_all_na(self):
+        # GH #1534
+        mix = MultiIndex.from_tuples([('1a', '2a'), ('1a', '2b'), ('1a', '2c')
+                                      ])
+        df = DataFrame([[1, 2], [3, 4], [5, 6]], index=mix)
+        s = Series({(1, 1): 1, (1, 2): 2})
+        df['new'] = s
+        assert df['new'].isna().all()

pandas/tests/indexing/multiindex/test_set_ops.py

@@ -0,0 +1,92 @@
+import numpy as np
+from numpy.random import randn
+
+from pandas.compat import lzip
+
+from pandas import DataFrame, MultiIndex, Series
+from pandas.util import testing as tm
+
+
+class TestMultiIndexSorted(object):
+    def test_getitem_multilevel_index_tuple_not_sorted(self):
+        index_columns = list("abc")
+        df = DataFrame([[0, 1, 0, "x"], [0, 0, 1, "y"]],
+                       columns=index_columns + ["data"])
+        df = df.set_index(index_columns)
+        query_index = df.index[:1]
+        rs = df.loc[query_index, "data"]
+
+        xp_idx = MultiIndex.from_tuples([(0, 1, 0)], names=['a', 'b', 'c'])
+        xp = Series(['x'], index=xp_idx, name='data')
+        tm.assert_series_equal(rs, xp)
+
+    def test_getitem_slice_not_sorted(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        df = frame.sort_index(level=1).T
+
+        # buglet with int typechecking
+        result = df.iloc[:, :np.int32(3)]
+        expected = df.reindex(columns=df.columns[:3])
+        tm.assert_frame_equal(result, expected)
+
+    def test_frame_getitem_not_sorted2(self):
+        # 13431
+        df = DataFrame({'col1': ['b', 'd', 'b', 'a'],
+                        'col2': [3, 1, 1, 2],
+                        'data': ['one', 'two', 'three', 'four']})
+
+        df2 = df.set_index(['col1', 'col2'])
+        df2_original = df2.copy()
+
+        df2.index.set_levels(['b', 'd', 'a'], level='col1', inplace=True)
+        df2.index.set_labels([0, 1, 0, 2], level='col1', inplace=True)
+        assert not df2.index.is_lexsorted()
+        assert not df2.index.is_monotonic
+
+        assert df2_original.index.equals(df2.index)
+        expected = df2.sort_index()
+        assert expected.index.is_lexsorted()
+        assert expected.index.is_monotonic
+
+        result = df2.sort_index(level=0)
+        assert result.index.is_lexsorted()
+        assert result.index.is_monotonic
+        tm.assert_frame_equal(result, expected)
+
+    def test_frame_getitem_not_sorted(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        df = frame.T
+        df['foo', 'four'] = 'foo'
+
+        arrays = [np.array(x) for x in zip(*df.columns.values)]
+
+        result = df['foo']
+        result2 = df.loc[:, 'foo']
+        expected = df.reindex(columns=df.columns[arrays[0] == 'foo'])
+        expected.columns = expected.columns.droplevel(0)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result2, expected)
+
+        df = df.T
+        result = df.xs('foo')
+        result2 = df.loc['foo']
+        expected = df.reindex(df.index[arrays[0] == 'foo'])
+        expected.index = expected.index.droplevel(0)
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result2, expected)
+
+    def test_series_getitem_not_sorted(self):
+        arrays = [['bar', 'bar', 'baz', 'baz', 'qux', 'qux', 'foo', 'foo'],
+                  ['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two']]
+        tuples = lzip(*arrays)
+        index = MultiIndex.from_tuples(tuples)
+        s = Series(randn(8), index=index)
+
+        arrays = [np.array(x) for x in zip(*index.values)]
+
+        result = s['qux']
+        result2 = s.loc['qux']
+        expected = s[arrays[0] == 'qux']
+        expected.index = expected.index.droplevel(0)
+        tm.assert_series_equal(result, expected)
+        tm.assert_series_equal(result2, expected)

pandas/tests/indexing/multiindex/test_setitem.py

@@ -0,0 +1,164 @@
+import numpy as np
+import pytest
+
+from pandas.compat import StringIO, lrange, product as cart_product
+
+from pandas import DataFrame, Index, MultiIndex, concat, read_csv
+import pandas.core.common as com
+from pandas.util import testing as tm
+
+
+class TestMultiIndexXs(object):
+
+    def test_xs_multiindex(self):
+
+        # GH2903
+        columns = MultiIndex.from_tuples(
+            [('a', 'foo'), ('a', 'bar'), ('b', 'hello'),
+             ('b', 'world')], names=['lvl0', 'lvl1'])
+        df = DataFrame(np.random.randn(4, 4), columns=columns)
+        df.sort_index(axis=1, inplace=True)
+        result = df.xs('a', level='lvl0', axis=1)
+        expected = df.iloc[:, 0:2].loc[:, 'a']
+        tm.assert_frame_equal(result, expected)
+
+        result = df.xs('foo', level='lvl1', axis=1)
+        expected = df.iloc[:, 1:2].copy()
+        expected.columns = expected.columns.droplevel('lvl1')
+        tm.assert_frame_equal(result, expected)
+
+    def test_xs(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        xs = frame.xs(('bar', 'two'))
+        xs2 = frame.loc[('bar', 'two')]
+
+        tm.assert_series_equal(xs, xs2)
+        tm.assert_almost_equal(xs.values, frame.values[4])
+
+        # GH 6574
+        # missing values in returned index should be preserrved
+        acc = [
+            ('a', 'abcde', 1),
+            ('b', 'bbcde', 2),
+            ('y', 'yzcde', 25),
+            ('z', 'xbcde', 24),
+            ('z', None, 26),
+            ('z', 'zbcde', 25),
+            ('z', 'ybcde', 26),
+        ]
+        df = DataFrame(acc,
+                       columns=['a1', 'a2', 'cnt']).set_index(['a1', 'a2'])
+        expected = DataFrame({'cnt': [24, 26, 25, 26]}, index=Index(
+            ['xbcde', np.nan, 'zbcde', 'ybcde'], name='a2'))
+
+        result = df.xs('z', level='a1')
+        tm.assert_frame_equal(result, expected)
+
+    def test_xs_with_duplicates(self, multiindex_dataframe_random_data):
+        # Issue #13719
+        frame = multiindex_dataframe_random_data
+        df_dup = concat([frame] * 2)
+        assert df_dup.index.is_unique is False
+        expected = concat([frame.xs('one', level='second')] * 2)
+        tm.assert_frame_equal(df_dup.xs('one', level='second'), expected)
+        tm.assert_frame_equal(df_dup.xs(['one'], level=['second']), expected)
+
+    def test_xs_level(self, multiindex_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        result = frame.xs('two', level='second')
+        expected = frame[frame.index.get_level_values(1) == 'two']
+        expected.index = expected.index.droplevel(1)
+
+        tm.assert_frame_equal(result, expected)
+
+        index = MultiIndex.from_tuples([('x', 'y', 'z'), ('a', 'b', 'c'), (
+            'p', 'q', 'r')])
+        df = DataFrame(np.random.randn(3, 5), index=index)
+        result = df.xs('c', level=2)
+        expected = df[1:2]
+        expected.index = expected.index.droplevel(2)
+        tm.assert_frame_equal(result, expected)
+
+        # this is a copy in 0.14
+        result = frame.xs('two', level='second')
+
+        # setting this will give a SettingWithCopyError
+        # as we are trying to write a view
+        def f(x):
+            x[:] = 10
+
+        pytest.raises(com.SettingWithCopyError, f, result)
+
+    def test_xs_level_multiple(self):
+        text = """                      A       B       C       D        E
+one two three   four
+a   b   10.0032 5    -0.5109 -2.3358 -0.4645  0.05076  0.3640
+a   q   20      4     0.4473  1.4152  0.2834  1.00661  0.1744
+x   q   30      3    -0.6662 -0.5243 -0.3580  0.89145  2.5838"""
+
+        df = read_csv(StringIO(text), sep=r'\s+', engine='python')
+
+        result = df.xs(('a', 4), level=['one', 'four'])
+        expected = df.xs('a').xs(4, level='four')
+        tm.assert_frame_equal(result, expected)
+
+        # this is a copy in 0.14
+        result = df.xs(('a', 4), level=['one', 'four'])
+
+        # setting this will give a SettingWithCopyError
+        # as we are trying to write a view
+        def f(x):
+            x[:] = 10
+
+        pytest.raises(com.SettingWithCopyError, f, result)
+
+        # GH2107
+        dates = lrange(20111201, 20111205)
+        ids = 'abcde'
+        idx = MultiIndex.from_tuples([x for x in cart_product(dates, ids)])
+        idx.names = ['date', 'secid']
+        df = DataFrame(np.random.randn(len(idx), 3), idx, ['X', 'Y', 'Z'])
+
+        rs = df.xs(20111201, level='date')
+        xp = df.loc[20111201, :]
+        tm.assert_frame_equal(rs, xp)
+
+    def test_xs_level0(self):
+        text = """                      A       B       C       D        E
+one two three   four
+a   b   10.0032 5    -0.5109 -2.3358 -0.4645  0.05076  0.3640
+a   q   20      4     0.4473  1.4152  0.2834  1.00661  0.1744
+x   q   30      3    -0.6662 -0.5243 -0.3580  0.89145  2.5838"""
+
+        df = read_csv(StringIO(text), sep=r'\s+', engine='python')
+
+        result = df.xs('a', level=0)
+        expected = df.xs('a')
+        assert len(result) == 2
+        tm.assert_frame_equal(result, expected)
+
+    def test_xs_level_series(self, multiindex_dataframe_random_data,
+                             multiindex_year_month_day_dataframe_random_data):
+        frame = multiindex_dataframe_random_data
+        ymd = multiindex_year_month_day_dataframe_random_data
+        s = frame['A']
+        result = s[:, 'two']
+        expected = frame.xs('two', level=1)['A']
+        tm.assert_series_equal(result, expected)
+
+        s = ymd['A']
+        result = s[2000, 5]
+        expected = ymd.loc[2000, 5]['A']
+        tm.assert_series_equal(result, expected)
+
+        # not implementing this for now
+
+        pytest.raises(TypeError, s.__getitem__, (2000, slice(3, 4)))
+
+        # result = s[2000, 3:4]
+        # lv =s.index.get_level_values(1)
+        # expected = s[(lv == 3) | (lv == 4)]
+        # expected.index = expected.index.droplevel(0)
+        # tm.assert_series_equal(result, expected)
+
+        # can do this though