def test_parse_original_results_file(self):
        res = StatsResults()
        _parse_original_results_file('/foobarbaz123', Anosim(), 'Treatment',
                                     res)
        self.assertTrue(res.isEmpty())

        _parse_original_results_file('/foobarbaz123', Anosim(), 'Treatment',
                                     res, 42)
        self.assertTrue(res.isEmpty())
    def test_parse_shuffled_results_files(self):
        res = StatsResults()
        _parse_shuffled_results_files('/foobarbaz123', Adonis(), 'Treatment',
                                     res, 10)
        self.assertTrue(res.isEmpty())

        _parse_shuffled_results_files('/foobarbaz123', Anosim(), 'Treatment',
                                     res, 20, 88)
        self.assertTrue(res.isEmpty())
Beispiel #3
0
class StatsResultsTests(TestCase):
    """Tests for the util.StatsResults class."""

    def setUp(self):
        """Define some sample data that will be used by the tests."""
        self.sr1 = StatsResults()

    def test_addResult(self):
        """Adding effect size and p-value works correctly on valid input."""
        self.sr1.addResult(0.5, 0.01)
        self.sr1.addResult(0.5, 0.001)
        self.assertFloatEqual(self.sr1.effect_size, 0.5)
        self.assertFloatEqual(self.sr1.p_values, [0.01, 0.001])

    def test_addResult_invalid_input(self):
        """Adding invalid input raises error."""
        # Effect sizes don't match.
        self.sr1.addResult(0.5, 0.01)
        self.assertRaises(ValueError, self.sr1.addResult, 0.6, 0.001)
        self.assertFloatEqual(self.sr1.effect_size, 0.5)
        self.assertFloatEqual(self.sr1.p_values, [0.01])

        # Invalid p-value range.
        self.sr1 = StatsResults()
        self.assertRaises(ValueError, self.sr1.addResult, 0.5, 1.1)
        self.assertTrue(self.sr1.effect_size is None)
        self.assertEqual(self.sr1.p_values, [])

        self.sr1.addResult(0.5, 0.01)
        self.sr1.addResult(0.5, 0.02)
        self.assertRaises(ValueError, self.sr1.addResult, 0.5, 1.1)
        self.assertRaises(ValueError, self.sr1.addResult, 0.5, -0.2)
        self.assertFloatEqual(self.sr1.effect_size, 0.5)
        self.assertFloatEqual(self.sr1.p_values, [0.01, 0.02])

    def test_isEmpty(self):
        """Test checking if results are empty or not."""
        self.assertTrue(self.sr1.isEmpty())

        self.sr1.addResult(0.5, 0.01)
        self.assertFalse(self.sr1.isEmpty())

    def test_str(self):
        """Test __str__ method."""
        # Empty results.
        obs = str(self.sr1)
        self.assertEqual(obs, 'Empty results')

        # Populated results.
        self.sr1.addResult(0.5, 0.01)
        self.sr1.addResult(0.5, 0.05)
        obs = str(self.sr1)
        self.assertEqual(obs, '0.50; ***, **')

    def test_check_p_value(self):
        """Raises error on invalid p-value."""
        self.sr1._check_p_value(0.0)
        self.sr1._check_p_value(0.5)
        self.sr1._check_p_value(1.0)

        self.assertRaises(ValueError, self.sr1._check_p_value, 1.5)
        self.assertRaises(ValueError, self.sr1._check_p_value, -1.5)

    def test_format_p_value_as_asterisk(self):
        """Test formatting a p-value to indicate statistical significance."""
        obs = self.sr1._format_p_value_as_asterisk(1.0)
        self.assertEqual(obs, 'x')

        obs = self.sr1._format_p_value_as_asterisk(0.09)
        self.assertEqual(obs, '*')

        obs = self.sr1._format_p_value_as_asterisk(0.045)
        self.assertEqual(obs, '**')

        obs = self.sr1._format_p_value_as_asterisk(0.01)
        self.assertEqual(obs, '***')

        obs = self.sr1._format_p_value_as_asterisk(0.0005)
        self.assertEqual(obs, '****')

    def test_format_p_value_as_asterisk_invalid_input(self):
        """Test supplying an invalid p-value results in error being thrown."""
        self.assertRaises(TypeError, self.sr1._format_p_value_as_asterisk, 1)
        self.assertRaises(TypeError, self.sr1._format_p_value_as_asterisk,
                          "0.05")
        self.assertRaises(TypeError, self.sr1._format_p_value_as_asterisk,
                          [0.05])

        self.assertRaises(ValueError, self.sr1._format_p_value_as_asterisk,
                          1.1)
        self.assertRaises(ValueError, self.sr1._format_p_value_as_asterisk,
                          -0.042)