source: orange/Orange/testing/unit/tests/test_table.py @ 11699:6643b6da98d4

Revision 11699:6643b6da98d4, 9.4 KB checked in by Ales Erjavec <ales.erjavec@…>, 7 months ago (diff)

Added tests for Orange.data.Table constructors.

Line 
1# -*- coding: utf-8 -*-
2""" Orange.data.Table related unit-tests
3"""
4
5
6try:
7    import unittest2 as unittest
8except:
9    import unittest
10from Orange.testing import testing
11
12import Orange
13import cPickle
14import tempfile
15import gc
16
17
18def native(table):
19    table = table.native()
20    for i in range(len(table)):
21        table[i] = [v.native() for v in table[i].native()]
22    return table
23
24
25def names_iter():
26    for name in testing.ALL_DATASETS:
27        yield name.replace(" ", "_").replace("-", "_"), (name,)
28
29
30@testing.data_driven(data_iter=names_iter())
31class TestLoading(unittest.TestCase):
32
33    @testing.test_on_data
34    def test_load_on(self, name):
35        """ Test the loading of the data set
36        """
37        table = Orange.data.Table(name)
38        self.assertIsNotNone(getattr(table, "attributeLoadStatus"),
39                             "No attributeLoadStatus")
40
41    @testing.test_on_data
42    def test_pickling_on(self, name):
43        """ Test data table pickling.
44        """
45        table = Orange.data.Table(name)
46        s = cPickle.dumps(table)
47        table_clone = cPickle.loads(s)
48
49        self.assertSequenceEqual(list(table.domain),
50                                 list(table_clone.domain))
51        self.assertEqual(native(table), native(table_clone),
52                         "Native representation is not equal!")
53
54
55@testing.datasets_driven
56class TestSaving(unittest.TestCase):
57    @testing.test_on_data
58    def test_R_on(self, name):
59        data = Orange.data.Table(name)
60        with tempfile.NamedTemporaryFile(suffix=".R") as f:
61            data.save(f.name)
62
63#    @testing.test_on_data
64#    def test_toC50(self, name):
65#        data = Orange.data.Table(name)
66
67    @testing.test_on_datasets(datasets=testing.CLASSIFICATION_DATASETS + \
68                              testing.REGRESSION_DATASETS)
69    def test_arff_on(self, data):
70        with tempfile.NamedTemporaryFile(suffix=".arff") as f:
71            data.save(f.name)
72            f.flush()
73            data_arff = Orange.data.Table(f.name)
74
75    @testing.test_on_datasets(datasets=testing.CLASSIFICATION_DATASETS + \
76                              testing.REGRESSION_DATASETS)
77    def test_svm_on(self, data):
78        with tempfile.NamedTemporaryFile(suffix=".svm") as f:
79            data.save(f.name)
80            f.flush()
81            data_svm = Orange.data.Table(f.name)
82
83    @testing.test_on_datasets
84    def test_csv_on(self, data):
85        with tempfile.NamedTemporaryFile(suffix=".csv") as f:
86            Orange.data.io.save_csv(f, data, dialect="excel-tab")
87            f.flush()
88            f.seek(0)
89            Orange.data.io.load_csv(f, has_header=True,
90                                    has_types=True, has_annotations=True)
91
92
93@testing.datasets_driven
94class TestUnicodeFilenames(unittest.TestCase):
95
96    @testing.test_on_data
97    def test_tab_on(self, name):
98        """ Test the loading and saving to/from unicode (utf-8) filenames.
99        """
100        table = Orange.data.Table(name)
101        with tempfile.NamedTemporaryFile(suffix=u"ü-š-ç.tab") as f:
102            table.save(f.name)
103            f.flush()
104            table1 = Orange.data.Table(f.name)
105
106    @testing.test_on_datasets(datasets=testing.CLASSIFICATION_DATASETS + \
107                              testing.REGRESSION_DATASETS)
108    def test_txt_on(self, name):
109        """ Test the loading and saving to/from unicode (utf-8) filenames.
110        """
111        table = Orange.data.Table(name)
112        with tempfile.NamedTemporaryFile(suffix=u"ü-š-ç.txt") as f:
113            table.save(f.name)
114            f.flush()
115            table1 = Orange.data.Table(f.name)
116
117    @testing.test_on_datasets(datasets=testing.CLASSIFICATION_DATASETS + \
118                              testing.REGRESSION_DATASETS)
119    def test_arff_on(self, name):
120        """ Test the loading and saving to/from unicode (utf-8) filenames.
121        """
122        table = Orange.data.Table(name)
123        with tempfile.NamedTemporaryFile(suffix=u"ü-š-ç.arff") as f:
124            table.save(f.name)
125            f.flush()
126            table1 = Orange.data.Table(f.name)
127
128    def test_basket(self):
129        """ Test the loading and saving to/from unicode (utf-8) filenames.
130        """
131        table = Orange.data.Table("inquisition.basket")
132        with tempfile.NamedTemporaryFile(suffix=u"ü-š-ç.basket") as f:
133            table.save(f.name)
134            f.flush()
135            table1 = Orange.data.Table(f.name)
136
137
138@testing.datasets_driven
139class TestHashing(unittest.TestCase):
140
141    @testing.test_on_data
142    def test_uniqueness(self, name):
143        """ Test the uniqueness of hashes. This is probabilistic,
144        but if we hit a collision in one of documentation datasets,
145        then it's time to open a bottle of Champagne ...
146        """
147        table = Orange.data.Table(name)
148        self.assertEquals(len(set(table)), len(set(hash(i) for i in table)))
149
150    @testing.test_on_data
151    def test_repetitiveness(self, name):
152        """ Test whether a data instance gets the same hash twice.
153        """
154        table = Orange.data.Table(name)
155        a = [hash(i) for i in table]
156        # Copy and reverse the table prior to hashing - just to hopefully
157        # make more bugs stand out.
158        b = list(reversed([hash(i) for i in
159                           reversed(Orange.data.Table(table))]))
160
161        self.assertEquals(a, b)
162
163
164class TestDataOwnership(unittest.TestCase):
165    def test_clone(self):
166        """Test that `clone` method returns a table with it's own copy
167        of the data.
168
169        """
170        iris = Orange.data.Table("iris")
171        clone = iris.clone()
172
173        self.assertTrue(iris.owns_instances and clone.owns_instances)
174        self.assertTrue(all(e1.reference() != e2.reference()
175                            for e1, e2 in zip(iris, clone)))
176
177        clone[0][0] = -1
178        self.assertTrue(iris[0][0] != clone[0][0])
179
180        del clone
181        gc.collect()
182
183    def test_reference(self):
184        iris = Orange.data.Table("iris")
185
186        ref = Orange.data.Table(iris, True)
187
188        self.assertTrue(iris.owns_instances)
189        self.assertFalse(ref.owns_instances)
190
191        self.assertTrue(all(e1.reference() == e2.reference()
192                            for e1, e2 in zip(iris, ref)))
193
194        ref[0][0] = -1
195        self.assertEqual(iris[0][0], -1)
196
197        with self.assertRaises(TypeError):
198            ref.append(
199                Orange.data.Instance(ref.domain,
200                                     [0, 0, 0, 0, "Iris-setosa"])
201            )
202
203        del ref
204        gc.collect()
205
206
207class TestConstructor(unittest.TestCase):
208    def test_from_list(self):
209        A = [[0., 1., 2.],
210             [3., 4., 5.],
211             [6., 7., 8.]]
212
213        domain = Orange.data.Domain(
214            [Orange.feature.Continuous("F%i" % i)
215             for i in range(1, 4)],
216            None
217        )
218
219        data = Orange.data.Table(domain, A)
220
221        self.assertEqual(native(data), A)
222
223        lenses = Orange.data.Table("lenses")
224        domain = lenses.domain
225
226        A = [[0, 1, 0, 1, 0],
227             [2, 0, 1, 0, 2]]
228
229        data = Orange.data.Table(domain, A)
230
231        self.assertEqual(
232            A,
233            [[int(v) for v in row] for row in data]
234        )
235
236        A[0][0] = 4
237        with self.assertRaises(ValueError):
238            data = Orange.data.Table(domain, A)
239
240        A[0][0] = -1
241        with self.assertRaises(ValueError):
242            data = Orange.data.Table(domain, A)
243
244    def test_from_array(self):
245        """Test Table construction from numpy arrays.
246        """
247        from numpy import array, arange
248
249        A = arange(9).reshape(3, 3)
250        data = Orange.data.Table(A)
251
252        self.assertTrue(all(isinstance(f, Orange.feature.Continuous)
253                            for f in data.domain))
254        self.assertEqual(data.domain.class_var, None)
255
256        self.assertEqual(native(data), A.tolist())
257
258        lenses = Orange.data.Table("lenses")
259        domain = lenses.domain
260
261        A = [[0, 1, 0, 1, 0],
262             [2, 0, 1, 0, 2]]
263
264        data = Orange.data.Table(domain, array(A))
265
266        self.assertEqual(
267            A,
268            [[int(v) for v in row] for row in data]
269        )
270
271        A[0][0] = 4
272        with self.assertRaises(ValueError):
273            data = Orange.data.Table(domain, array(A))
274
275        A[0][0] = -1
276        with self.assertRaises(ValueError):
277            data = Orange.data.Table(domain, array(A))
278
279    def test_from_masked_array(self):
280        """Test Table construction from numpy masked arrays.
281        """
282        from numpy.ma import masked_array, masked, arange
283
284        A = arange(9).reshape(3, 3)
285        A[1, 1] = masked
286
287        data = Orange.data.Table(A)
288
289        self.assertTrue(all(isinstance(f, Orange.feature.Continuous)
290                            for f in data.domain))
291        self.assertEqual(data.domain.class_var, None)
292
293        self.assertTrue(data[1][1].isSpecial())
294
295        lenses = Orange.data.Table("lenses")
296        domain = lenses.domain
297
298        A = masked_array([[0, 1, 0, 1, 0],
299                          [2, 0, 1, 0, 2]])
300
301        data = Orange.data.Table(domain, A)
302
303        self.assertEqual(
304            A.tolist(),
305            [[int(v) for v in row] for row in data]
306        )
307
308        A[0, 0] = 4
309        with self.assertRaises(ValueError):
310            data = Orange.data.Table(domain, A)
311
312        A[0, 0] = -1
313        with self.assertRaises(ValueError):
314            data = Orange.data.Table(domain, A)
315
316        A[0, 0] = masked
317        data = Orange.data.Table(domain, A)
318
319        self.assertTrue(data[0][0].isSpecial())
320
321
322if __name__ == "__main__":
323    unittest.main()
Note: See TracBrowser for help on using the repository browser.