def test_run_1(self):
     # should have the same output as test_run_2, but _do_multiprocessing() is a MagicMock
     in_a = Series([1, 2, 1, 1, 3, 1, 4, 5, 3, 2, 1])
     in_b = Series([1, 2, 1, 1, 3, 1, 4, 5, 3, 2, 1])
     in_c = Series([1, 2, 1, 1, 3, 1, 4, 5, 3, 2, 1])
     in_series = [in_a, in_b, in_c]
     expected = DataFrame(
         {
             0: Series({1: 5, 2: 2, 3: 2, 4: 1, 5: 1}),
             1: Series({1: 5, 2: 2, 3: 2, 4: 1, 5: 1}),
             2: Series({1: 5, 2: 2, 3: 2, 4: 1, 5: 1}),
             u"all": Series({1: 15, 2: 6, 3: 6, 4: 3, 5: 3}),
         }
     )
     exp = FrequencyExperimenter(in_series)
     exp._do_multiprocessing = mock.MagicMock()
     exp._do_multiprocessing.return_value = [
         (0, Series({1: 5, 2: 2, 3: 2, 4: 1, 5: 1})),
         (1, Series({1: 5, 2: 2, 3: 2, 4: 1, 5: 1})),
         (2, Series({1: 5, 2: 2, 3: 2, 4: 1, 5: 1})),
     ]
     actual = exp.run()
     exp._do_multiprocessing.assert_called_once_with(experimenter_func, [[(0, in_a)], [(1, in_b)], [(2, in_c)]])
     self.assertEqual(len(expected.columns), len(actual.columns))
     for i in expected.columns:
         self.assertSequenceEqual(list(expected.loc[:, i].index), list(actual.loc[:, i].index))
         self.assertSequenceEqual(list(expected.loc[:, i].values), list(actual.loc[:, i].values))
 def test_run_2(self):
     # should have the same output as test_run_1, but without the MagicMock
     in_a = Series([1, 2, 1, 1, 3, 1, 4, 5, 3, 2, 1])
     in_b = Series([1, 2, 1, 1, 3, 1, 4, 5, 3, 2, 1])
     in_c = Series([1, 2, 1, 1, 3, 1, 4, 5, 3, 2, 1])
     in_series = [in_a, in_b, in_c]
     expected = DataFrame(
         {
             0: Series({1: 5, 2: 2, 3: 2, 4: 1, 5: 1}),
             1: Series({1: 5, 2: 2, 3: 2, 4: 1, 5: 1}),
             2: Series({1: 5, 2: 2, 3: 2, 4: 1, 5: 1}),
             u"all": Series({1: 15, 2: 6, 3: 6, 4: 3, 5: 3}),
         }
     )
     exp = FrequencyExperimenter(in_series)
     actual = exp.run()
     self.assertEqual(len(expected.columns), len(actual.columns))
     for i in expected.columns:
         self.assertSequenceEqual(list(expected.loc[:, i].index), list(actual.loc[:, i].index))
         self.assertSequenceEqual(list(expected.loc[:, i].values), list(actual.loc[:, i].values))
 def test_run_4(self):
     # same as test_run_3, but input is a dict
     in_a = Series([1, 2, 1, 1, 3, 1, 4, 5, 3, 2, 1])
     in_b = Series([1, 2, 1, 1, 3, 1, 4, 5, 3, 2, 1, 4, 4, 3, 5, 1, 1, 1])
     in_c = Series([1, 2, 1, 1, 3, 1, 3, 2, 1])
     in_series = {u"hello": in_a, u"zello": in_b, u"jello": in_c}
     expected = DataFrame(
         {
             u"hello": Series({1: 5, 2: 2, 3: 2, 4: 1, 5: 1}),
             u"zello": Series({1: 8, 2: 2, 3: 3, 4: 3, 5: 2}),
             u"jello": Series({1: 5, 2: 2, 3: 2}),
             u"all": Series({1: 18, 2: 6, 3: 7, 4: 4, 5: 3}),
         }
     )
     exp = FrequencyExperimenter(in_series)
     actual = exp.run()
     # because numpy's NaN != NaN
     actual = actual.fillna(value=4000)
     expected = expected.fillna(value=4000)
     self.assertEqual(len(expected.columns), len(actual.columns))
     for i in expected.columns:
         self.assertSequenceEqual(list(expected.loc[:, i].index), list(actual.loc[:, i].index))
         self.assertSequenceEqual(list(expected.loc[:, i].values), list(actual.loc[:, i].values))
 def test_run_3(self):
     # more complicated arithmetic
     in_a = Series([1, 2, 1, 1, 3, 1, 4, 5, 3, 2, 1])
     in_b = Series([1, 2, 1, 1, 3, 1, 4, 5, 3, 2, 1, 4, 4, 3, 5, 1, 1, 1])
     in_c = Series([1, 2, 1, 1, 3, 1, 3, 2, 1])
     in_series = [in_a, in_b, in_c]
     expected = DataFrame(
         {
             0: Series({1: 5, 2: 2, 3: 2, 4: 1, 5: 1}),
             1: Series({1: 8, 2: 2, 3: 3, 4: 3, 5: 2}),
             2: Series({1: 5, 2: 2, 3: 2}),
             u"all": Series({1: 18, 2: 6, 3: 7, 4: 4, 5: 3}),
         }
     )
     exp = FrequencyExperimenter(in_series)
     actual = exp.run()
     # because numpy's NaN != NaN
     actual = actual.fillna(value=4000)
     expected = expected.fillna(value=4000)
     self.assertEqual(len(expected.columns), len(actual.columns))
     for i in expected.columns:
         self.assertSequenceEqual(list(expected.loc[:, i].index), list(actual.loc[:, i].index))
         self.assertSequenceEqual(list(expected.loc[:, i].values), list(actual.loc[:, i].values))