Additional multitype tests.

Author: sstanovnik

pandas/tests/frame/test_indexing.py

@@ -2712,13 +2712,64 @@ def test_type_error_multiindex(self):
         result = dg['x', 0]
         assert_series_equal(result, expected)
 
-    def test_sparse_indexing_single_multitype(self):
-        from pandas import SparseDataFrame, SparseSeries
-        sdf = SparseDataFrame([[1, 2, 'a'], [4, 5, 'b']])
-        tm.assert_sp_series_equal(sdf.iloc[0],
-                                  SparseSeries([1, 2, 'a'], name=0))
-        tm.assert_sp_series_equal(sdf.iloc[1],
-                                  SparseSeries([4, 5, 'b'], name=1))
+
+class TestSparseDataFrameMultitype(tm.TestCase):
+    def setUp(self):
+        super(TestSparseDataFrameMultitype, self).setUp()
+        self.string_series = pd.SparseSeries(['a', 'b', 'c'])
+        self.int_series = pd.SparseSeries([1, 2, 3])
+        self.float_series = pd.SparseSeries([1.1, 1.2, 1.3])
+        self.object_series = pd.SparseSeries([[], {}, set()])
+        self.sdf = pd.SparseDataFrame({
+            'string': self.string_series,
+            'int': self.int_series,
+            'float': self.float_series,
+            'object': self.object_series,
+        })
+        self.cols = ['string', 'int', 'float', 'object']
+        self.sdf = self.sdf[self.cols]
+
+    def test_basic_dtypes(self):
+        for _, row in self.sdf.iterrows():
+            self.assertEqual(row.dtype, object)
+        tm.assert_sp_series_equal(self.sdf['string'], self.string_series,
+                                  check_names=False)
+        tm.assert_sp_series_equal(self.sdf['int'], self.int_series,
+                                  check_names=False)
+        tm.assert_sp_series_equal(self.sdf['float'], self.float_series,
+                                  check_names=False)
+        tm.assert_sp_series_equal(self.sdf['object'], self.object_series,
+                                  check_names=False)
+
+    def test_indexing_single(self):
+        tm.assert_sp_series_equal(self.sdf.iloc[0],
+                                  pd.SparseSeries(['a', 1, 1.1, []],
+                                                  index=self.cols),
+                                  check_names=False)
+        tm.assert_sp_series_equal(self.sdf.iloc[1],
+                                  pd.SparseSeries(['b', 2, 1.2, {}],
+                                                  index=self.cols),
+                                  check_names=False)
+        tm.assert_sp_series_equal(self.sdf.iloc[2],
+                                  pd.SparseSeries(['c', 3, 1.3, set()],
+                                                  index=self.cols),
+                                  check_names=False)
+
+    def test_indexing_multiple(self):
+        tm.assert_sp_frame_equal(self.sdf, self.sdf[:])
+        tm.assert_sp_frame_equal(self.sdf, self.sdf.loc[:])
+        tm.assert_sp_frame_equal(self.sdf.iloc[[1, 2]],
+                                 pd.SparseDataFrame({
+                                     'string': ['b', 'c'],
+                                     'int': [2, 3],
+                                     'float': [1.2, 1.3],
+                                     'object': [{}, set()]
+                                 }, index=[1, 2])[self.cols])
+        tm.assert_sp_frame_equal(self.sdf[['int', 'string']],
+                                 pd.SparseDataFrame({
+                                     'int': self.int_series,
+                                     'string': self.string_series,
+                                 }))
 
 
 class TestDataFrameIndexingDatetimeWithTZ(tm.TestCase, TestData):

pandas/tests/series/test_indexing.py

@@ -1856,3 +1856,29 @@ def test_multilevel_preserve_name(self):
         result2 = s.ix['foo']
         self.assertEqual(result.name, s.name)
         self.assertEqual(result2.name, s.name)
+
+
+class TestSparseSeriesMultitype(tm.TestCase):
+    def setUp(self):
+        super(TestSparseSeriesMultitype, self).setUp()
+        self.index = ['string', 'int', 'float', 'object']
+        self.ss = pd.SparseSeries(['a', 1, 1.1, []],
+                                  index=self.index)
+
+    def test_indexing_single(self):
+        for i, idx in enumerate(self.index):
+            self.assertEqual(self.ss.iloc[i], self.ss[idx])
+            self.assertEqual(type(self.ss.iloc[i]),
+                             type(self.ss[idx]))
+        self.assertEqual(self.ss['string'], 'a')
+        self.assertEqual(self.ss['int'], 1)
+        self.assertEqual(self.ss['float'], 1.1)
+        self.assertEqual(self.ss['object'], [])
+
+    def test_indexing_multiple(self):
+        tm.assert_sp_series_equal(self.ss.loc[['string', 'int']],
+                                  pd.SparseSeries(['a', 1],
+                                                  index=['string', 'int']))
+        tm.assert_sp_series_equal(self.ss.loc[['string', 'object']],
+                                  pd.SparseSeries(['a', []],
+                                                  index=['string', 'object']))