improving unit tests

quapy/method/__init__.py

@@ -17,12 +17,35 @@ AGGREGATIVE_METHODS = {
     aggregative.MAX,
     aggregative.MS,
     aggregative.MS2,
+    aggregative.DMy,
     aggregative.KDEyML,
     aggregative.KDEyCS,
     aggregative.KDEyHD,
     aggregative.BayesianCC
 }
 
+BINARY_METHODS = {
+    aggregative.HDy,
+    aggregative.DyS,
+    aggregative.SMM,
+    aggregative.X,
+    aggregative.T50,
+    aggregative.MAX,
+    aggregative.MS,
+    aggregative.MS2,
+}
+
+MULTICLASS_METHODS = {
+    aggregative.CC,
+    aggregative.ACC,
+    aggregative.PCC,
+    aggregative.PACC,
+    aggregative.EMQ,
+    aggregative.KDEyML,
+    aggregative.KDEyCS,
+    aggregative.KDEyHD,
+    aggregative.BayesianCC
+}
 
 NON_AGGREGATIVE_METHODS = {
     non_aggregative.MaximumLikelihoodPrevalenceEstimation,

quapy/method/aggregative.py

@@ -1522,8 +1522,8 @@ AdjustedClassifyAndCount = ACC
 ProbabilisticClassifyAndCount = PCC
 ProbabilisticAdjustedClassifyAndCount = PACC
 ExpectationMaximizationQuantifier = EMQ
-DistributionMatchingY = DMy
 SLD = EMQ
+DistributionMatchingY = DMy
 HellingerDistanceY = HDy
 MedianSweep = MS
 MedianSweep2 = MS2

quapy/tests/test_evaluation.py

@@ -6,14 +6,17 @@ import quapy as qp
 from sklearn.linear_model import LogisticRegression
 from time import time
 
-from quapy.error import QUANTIFICATION_ERROR_SINGLE, QUANTIFICATION_ERROR, QUANTIFICATION_ERROR_NAMES, \
-    QUANTIFICATION_ERROR_SINGLE_NAMES
+from quapy.error import QUANTIFICATION_ERROR_SINGLE_NAMES
 from quapy.method.aggregative import EMQ, PCC
 from quapy.method.base import BaseQuantifier
 
 
 class EvalTestCase(unittest.TestCase):
+
     def test_eval_speedup(self):
+        """
+        Checks whether the speed-up heuristics used by qp.evaluation work, i.e., actually save time
+        """
 
         data = qp.datasets.fetch_reviews('hp', tfidf=True, min_df=10, pickle=True)
         train, test = data.training, data.test
@@ -55,8 +58,11 @@ class EvalTestCase(unittest.TestCase):
         self.assertEqual(tend_no_optim>(tend_optim/2), True)
 
     def test_evaluation_output(self):
+        """
+        Checks the evaluation functions return correct types for different error_metrics
+        """
 
-        data = qp.datasets.fetch_reviews('hp', tfidf=True, min_df=10, pickle=True)
+        data = qp.datasets.fetch_reviews('hp', tfidf=True, min_df=10, pickle=True).reduce(n_train=100, n_test=100)
         train, test = data.training, data.test
 
         qp.environ['SAMPLE_SIZE']=100
@@ -79,6 +85,5 @@ class EvalTestCase(unittest.TestCase):
             self.assertEqual(scores.mean(), score)
 
 
-
 if __name__ == '__main__':
     unittest.main()

quapy/tests/test_hierarchy.py

@@ -1,19 +1,54 @@
 import unittest
 from sklearn.linear_model import LogisticRegression
+
+from quapy.method import AGGREGATIVE_METHODS, BINARY_METHODS
 from quapy.method.aggregative import *
+import inspect
 
 
 class HierarchyTestCase(unittest.TestCase):
 
     def test_aggregative(self):
         lr = LogisticRegression()
-        for m in [CC(lr), PCC(lr), ACC(lr), PACC(lr)]:
-            self.assertEqual(isinstance(m, AggregativeQuantifier), True)
+        for m in AGGREGATIVE_METHODS:
+            self.assertEqual(isinstance(m(lr), AggregativeQuantifier), True)
+
+    def test_inspect_aggregative(self):
+
+        import quapy.method.aggregative as aggregative
+
+        members = inspect.getmembers(aggregative)
+        classes = set([cls for name, cls in members if inspect.isclass(cls)])
+        quantifiers = [cls for cls in classes if issubclass(cls, BaseQuantifier)]
+        quantifiers = [cls for cls in quantifiers if issubclass(cls, AggregativeQuantifier)]
+        quantifiers = [cls for cls in quantifiers if not inspect.isabstract(cls) ]
+
+        for cls in quantifiers:
+            self.assertIn(cls, AGGREGATIVE_METHODS)
 
     def test_binary(self):
         lr = LogisticRegression()
-        for m in [HDy(lr)]:
-            self.assertEqual(isinstance(m, BinaryQuantifier), True)
+        for m in BINARY_METHODS:
+            self.assertEqual(isinstance(m(lr), BinaryQuantifier), True)
+
+    def test_inspect_binary(self):
+
+        import quapy.method.base as base
+        import quapy.method.aggregative as aggregative
+        import quapy.method.non_aggregative as non_aggregative
+        import quapy.method.meta as meta
+
+        members = inspect.getmembers(base)
+        members+= inspect.getmembers(aggregative)
+        members += inspect.getmembers(non_aggregative)
+        members += inspect.getmembers(meta)
+        classes = set([cls for name, cls in members if inspect.isclass(cls)])
+        quantifiers = [cls for cls in classes if issubclass(cls, BaseQuantifier)]
+        quantifiers = [cls for cls in quantifiers if issubclass(cls, BinaryQuantifier)]
+        quantifiers = [cls for cls in quantifiers if not inspect.isabstract(cls) ]
+
+        for cls in quantifiers:
+            self.assertIn(cls, BINARY_METHODS)
 
     def test_probabilistic(self):
         lr = LogisticRegression()
@@ -27,3 +62,4 @@ class HierarchyTestCase(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
+