MutaFix run: boltons-008

tests/test_statsutils.py::test_pearson_type_covers_kappa_ge_zero
tests/test_statsutils.py::test_pearson_type_zero_denominator

E   assert 3 == 4
E    +  where 3 = <boltons.statsutils.Stats object at 0x0000023B7E5D4140>.pearson_type
E    +    where <boltons.statsutils.Stats object at 0x0000023B7E5D4140> = Stats([8, 4, 4, 4, 5, 1, ...])

E   assert 1 == 3
E    +  where 1 = <boltons.statsutils.Stats object at 0x0000023B7E5D5D30>.pearson_type

1. boltons/statsutils.py::Stats._calc_pearson_type call depth - · Ochiai 1.00 (failing 2, passing 0)
2. boltons/statsutils.py::Stats.__init__ call depth 1 · Ochiai 0.63 (failing 2, passing 3)
3. boltons/statsutils.py::_StatsProperty.__get__ call depth 2 · Ochiai 0.63 (failing 2, passing 3)
4. boltons/statsutils.py::Stats._calc_mean call depth - · Ochiai 0.50 (failing 1, passing 1)
5. boltons/statsutils.py::Stats._calc_variance call depth - · Ochiai 0.50 (failing 1, passing 1)
6. boltons/statsutils.py::Stats._calc_std_dev call depth - · Ochiai 0.50 (failing 1, passing 1)
7. boltons/statsutils.py::Stats._calc_skewness call depth - · Ochiai 0.50 (failing 1, passing 1)
8. boltons/statsutils.py::Stats._calc_kurtosis call depth - · Ochiai 0.50 (failing 1, passing 1)
9. boltons/statsutils.py::Stats._get_pow_diffs call depth - · Ochiai 0.50 (failing 1, passing 1)
10. boltons/statsutils.py::_get_conv_func.<locals>.stats_helper call depth - · Ochiai 0.41 (failing 1, passing 2)
11. boltons/statsutils.py::Stats.__len__ call depth 1 · Ochiai 0.00 (failing 0, passing 0)
12. boltons/statsutils.py::Stats.__iter__ call depth 1 · Ochiai 0.00 (failing 0, passing 0)
13. boltons/ioutils.py::SpooledIOBase.len call depth 2 · Ochiai 0.00 (failing 0, passing 0)
14. boltons/ioutils.py::SpooledBytesIO.len call depth 2 · Ochiai 0.00 (failing 0, passing 0)
15. boltons/ioutils.py::SpooledStringIO.len call depth 2 · Ochiai 0.00 (failing 0, passing 0)
16. boltons/statsutils.py::_StatsProperty.__init__ call depth 2 · Ochiai 0.00 (failing 0, passing 0)
17. boltons/iterutils.py::partition call depth 3 · Ochiai 0.00 (failing 0, passing 0)
18. boltons/ioutils.py::MultiFileReader.seek call depth 3 · Ochiai 0.00 (failing 0, passing 0)
19. boltons/iterutils.py::partition.<locals>._make_key_func call depth 3 · Ochiai 0.00 (failing 0, passing 0)
20. boltons/ioutils.py::MultiFileReader.read call depth 3 · Ochiai 0.00 (failing 0, passing 0)

We have two failing tests:

1. test_pearson_type_covers_kappa_ge_zero expects pearson_type 4 for [8,4,4,4,5,1,6,5] but got 3.
2. test_pearson_type_zero_denominator expects pearson_type 3 for some input (not shown) but got 1.

Looking at the code, we see that the function `_calc_pearson_type` computes several quantities and then branches.

For the first test, we got 3 instead of 4. According to the code, returning 3 happens when `round(c2, precision) == 0` (line 466-467). So for the first dataset, c2 rounded to the given precision is 0, leading to Gamma (type 3). But we expect type 4 (Type IV).

For the second test, we got 1 instead of 3. Returning 1 happens in two places: when k<0 (line 473-474) or when c0==0 and c2<0 (line 469-471). Since we expected 3 (Gamma) but got 1, it means that the condition for Gamma (round(c2, precision)==0) was not met and we fell into the else branch and then either k<0 or (c0==0 and c2<0) returned 1.

Let's examine the second test name: "test_pearson_type_zero_denominator". This suggests that the denominator in the calculation of k (which is 4*c0*c2) is zero. Indeed, in the code we have a branch for when c0==0 (lines 469-471). So if c0 is zero, we return 1 or 6 depending on the sign of c2. The test expects 3 (Gamma) but we are returning 1, meaning that in the zero denominator case, we are taking the branch for c0==0 and returning 1 (because c2<0). However, the test expects Gamma (type 3). This indicates that when the denominator is zero, we shoul

We have two failing tests:

1. test_pearson_type_covers_kappa_ge_zero expects pearson_type==4 for [8,4,4,4,5,1,6,5] but got 3.
2. test_pearson_type_zero_denominator expects pearson_type==3 for some input (likely when denominator becomes zero) but got 1.

Looking at the provided code for _calc_pearson_type, we note:

- For the first case, the function returned 3 (Gamma) instead of 4 (Type IV).
- For the second case, the function returned 1 (Beta) instead of 3 (Gamma).

Let's analyze the conditions:

The function computes:
  beta1 = skewness^2
  beta2 = kurtosis
  c0 = 4*beta2 - 3*beta1
  c1 = skewness*(beta2+3)
  c2 = (2+beta2) - 3*beta1 - 6   [Note: there's a typo? Actually, it's written as ((2 + beta2)) - (3 * beta1) - 6]

Then:
  if round(c1, precision) == 0: ... (handles symmetric cases)
  elif round(c2, precision) == 0: return 3 (Gamma)
  else: ... (then checks c0, then k)

In the first failing test, we got 3, meaning it went into the `elif round(c2, precision) == 0:` branch and returned 3 (Gamma). But we expected 4 (Type IV). So for the data [8,4,4,4,5,1,6,5], the condition `round(c2, precision) == 0` was true, but it should not have been (or we should have gone to the else branch and then returned 4).

In the second failing test, we got 1 (Beta) but expected 3 (Gamma). That means it did not go into the `round(c2, precision)==0` branch, but instead went into the else branch and then returned 1 (Beta). So for that data, we expected to hit the Gamma condition (return 3) bu