TST: misc test coverage

Author: wesm

pandas/core/frame.py

@@ -749,8 +749,10 @@ def dot(self, other):
         """
         if isinstance(other, (Series, DataFrame)):
             common = self.columns.union(other.index)
-            if len(common) > len(self.columns) or len(common) > len(other.index):
+            if (len(common) > len(self.columns) or
+                len(common) > len(other.index)):
                 raise ValueError('matrices are not aligned')
+
             left = self.reindex(columns=common, copy=False)
             right = other.reindex(index=common, copy=False)
             lvals = left.values
@@ -775,7 +777,7 @@ def dot(self, other):
                 return DataFrame(result, index=left.index)
             else:
                 return Series(result, index=left.index)
-        else:
+        else:  # pragma: no cover
             raise TypeError('unsupported type: %s' % type(other))
 
     #----------------------------------------------------------------------
@@ -2086,10 +2088,7 @@ def xs(self, key, axis=0, level=None, copy=True):
             if isinstance(loc, np.ndarray):
                 if loc.dtype == np.bool_:
                     inds, = loc.nonzero()
-                    if len(inds) == 1:
-                        loc = inds[0]
-                    else:
-                        return self.take(inds, axis=axis)
+                    return self.take(inds, axis=axis)
                 else:
                     return self.take(loc, axis=axis)
 
@@ -3946,8 +3945,8 @@ def _apply_broadcast(self, func, axis):
             target = self
         elif axis == 1:
             target = self.T
-        else:
-            raise ValueError('Axis must be 0 or 1, got %s' % str(axis))
+        else:  # pragma: no cover
+            raise ValueError('Axis must be 0 or 1, got %s' % axis)
 
         result_values = np.empty_like(target.values)
         columns = target.columns
@@ -4563,8 +4562,7 @@ def _reduce(self, op, axis=0, skipna=True, numeric_only=None,
                 elif filter_type == 'bool':
                     data = self._get_bool_data()
                 else:
-                    raise ValueError('Invalid filter_type %s ' %
-                                     str(filter_type))
+                    raise NotImplementedError
                 result = f(data.values)
                 labels = data._get_agg_axis(axis)
         else:
@@ -4574,8 +4572,7 @@ def _reduce(self, op, axis=0, skipna=True, numeric_only=None,
                 elif filter_type == 'bool':
                     data = self._get_bool_data()
                 else:
-                    raise ValueError('Invalid filter_type %s ' %
-                                     str(filter_type))
+                    raise NotImplementedError
                 values = data.values
                 labels = data._get_agg_axis(axis)
             else:
@@ -4589,7 +4586,7 @@ def _reduce(self, op, axis=0, skipna=True, numeric_only=None,
                 elif filter_type == 'bool' and notnull(result).all():
                     result = result.astype(np.bool_)
                 else:
-                    raise ValueError('Invalid dtype %s ' % str(filter_type))
+                    raise NotImplementedError
 
             except (ValueError, TypeError):
                 pass
@@ -4950,8 +4947,7 @@ def group_agg(values, bounds, f):
         result = np.empty((len(bounds), K), dtype=float)
 
     testagg = f(values[:min(1, len(values))])
-    if isinstance(testagg, np.ndarray) and testagg.ndim == 2:
-        raise Exception('Passed function does not aggregate!')
+    assert(not (isinstance(testagg, np.ndarray) and testagg.ndim == 2))
 
     for i, left_bound in enumerate(bounds):
         if i == len(bounds) - 1:
@@ -5132,13 +5128,9 @@ def _to_arrays(data, columns, coerce_float=False):
 def _list_to_arrays(data, columns, coerce_float=False):
     if len(data) > 0 and isinstance(data[0], tuple):
         content = list(lib.to_object_array_tuples(data).T)
-    elif len(data) > 0:
+    else:
         # list of lists
         content = list(lib.to_object_array(data).T)
-    else:
-        if columns is None:
-            columns = []
-        return {}, columns
     return _convert_object_array(content, columns,
                                  coerce_float=coerce_float)
 

pandas/core/panel.py

@@ -1339,7 +1339,7 @@ def join(self, other, how='left', lsuffix='', rsuffix=''):
                           join_axes=join_axes, verify_integrity=True)
 
     def update(self, other, join='left', overwrite=True, filter_func=None,
-                     raise_conflict=False):
+               raise_conflict=False):
         """
         Modify Panel in place using non-NA values from passed
         Panel, or object coercible to Panel. Aligns on items

pandas/tests/test_format.py

@@ -791,6 +791,10 @@ def test_dict_entries(self):
         val = df.to_string()
         self.assertTrue("{'a': 1, 'b': 2}" in val)
 
+    def test_to_latex(self):
+        # it works!
+        self.frame.to_latex()
+
 class TestSeriesFormatting(unittest.TestCase):
 
     def setUp(self):

pandas/tests/test_frame.py

@@ -1554,6 +1554,16 @@ def test_set_index2(self):
         xp.index.names = [None, 'A', 'B']
         assert_frame_equal(result, xp)
 
+        # append to existing multiindex
+        rdf = df.set_index(['A'], append=True)
+        rdf = rdf.set_index(['B', 'C'], append=True)
+        expected = df.set_index(['A', 'B', 'C'], append=True)
+        assert_frame_equal(rdf, expected)
+
+        # Series
+        result = df.set_index(df.C)
+        self.assertEqual(result.index.name, 'C')
+
     def test_set_index_nonuniq(self):
         df = DataFrame({'A' : ['foo', 'foo', 'foo', 'bar', 'bar'],
                         'B' : ['one', 'two', 'three', 'one', 'two'],
@@ -3059,6 +3069,16 @@ def test_arith_flex_frame(self):
         result = self.frame[:0].add(self.frame)
         assert_frame_equal(result, self.frame * np.nan)
 
+    def test_arith_mixed(self):
+
+        left = DataFrame({'A': ['a', 'b', 'c'],
+                          'B': [1, 2, 3]})
+
+        result = left + left
+        expected = DataFrame({'A': ['aa', 'bb', 'cc'],
+                              'B': [2, 4, 6]})
+        assert_frame_equal(result, expected)
+
     def test_bool_flex_frame(self):
         data = np.random.randn(5, 3)
         other_data = np.random.randn(5, 3)
@@ -4791,6 +4811,13 @@ def test_xs_corner(self):
         expected = Series([])
         assert_series_equal(result, expected)
 
+    def test_xs_duplicates(self):
+        df = DataFrame(randn(5, 2), index=['b', 'b', 'c', 'b', 'a'])
+
+        cross = df.xs('c')
+        exp = df.irow(2)
+        assert_series_equal(cross, exp)
+
     def test_pivot(self):
         data = {
             'index' : ['A', 'B', 'C', 'C', 'B', 'A'],
@@ -7184,6 +7211,12 @@ def test_dot(self):
         # it works
         result = A.dot(b)
 
+        # unaligned
+        df = DataFrame(randn(3, 4), index=[1, 2, 3], columns=range(4))
+        df2 = DataFrame(randn(5, 3), index=range(5), columns=[1, 2, 3])
+
+        self.assertRaises(ValueError, df.dot, df2)
+
     def test_idxmin(self):
         frame = self.frame
         frame.ix[5:10] = np.nan

pandas/tests/test_panel.py

@@ -1015,6 +1015,13 @@ def test_to_frame(self):
         # names
         self.assertEqual(unfiltered.index.names, ['major', 'minor'])
 
+        # unsorted, round trip
+        df = self.panel.to_frame(filter_observations=False)
+        unsorted = df.take(np.random.permutation(len(df)))
+        foo
+        pan = unsorted.to_panel()
+        assert_panel_equal(pan, self.panel)
+
         # preserve original index names
         df = DataFrame(np.random.randn(6, 2),
                        index=[['a', 'a', 'b', 'b', 'c', 'c'],