19070662183

Committed 04 Nov 2025 01:43PM UTC coverage: 92.654% (+0.3%) from 92.394%

Build # 19070662183

Build Type

push

github

Committed by

web-flow

Commit Message

Shape (#431)

Run Details

346 of 351 new or added lines in 13 files covered. (98.58%)

1 existing line in 1 file now uncovered.

8501 of 9175 relevant lines covered (92.65%)

0.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.57

/test/test_em_framework/test_parameter.py

""" """

import unittest
import unittest.mock as mock

import scipy as sp

from ema_workbench.em_framework import parameters


class RealParameterTestCase(unittest.TestCase):
    def test_instantiation(self):
        name = "test"
        resolution = [0, 1, 2]
        lower_bound = 0
        upper_bound = 2.1
        par = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)

        self.assertEqual(par.name, name)
        self.assertEqual(par.resolution, resolution)
        self.assertEqual(par.lower_bound, lower_bound)
        self.assertEqual(par.upper_bound, upper_bound)

        name = "test"
        resolution = [0, 1, 2]
        lower_bound = 2.1
        upper_bound = 0

        with self.assertRaises(ValueError):
            par = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)

        with self.assertRaises(ValueError):
            resolution = [-1, 0]
            par = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)

            resolution = [0, 1, 3]
            par = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)

    def test_comparison(self):
        name = "test"
        resolution = [0, 1, 2]
        lower_bound = 0
        upper_bound = 2.0
        par1 = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)
        par2 = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)

        self.assertTrue(par1 == par2)

        name = "test"
        par1 = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)

        name = "what"
        par2 = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)
        self.assertFalse(par1 == par2)

    def test_dist(self):
        name = "test"
        resolution = [0, 1, 2]
        lower_bound = 0
        upper_bound = 2.1
        par = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)

        self.assertEqual(par.dist.dist.name, "uniform")
        self.assertEqual(par.lower_bound, lower_bound)
        self.assertEqual(par.upper_bound, upper_bound)

    def test_from_dist(self):
        par = parameters.RealParameter.from_dist(
            "test",
            sp.stats.uniform(0, 1),
            resolution=[0, 1],  # @UndefinedVariable
        )

        self.assertEqual(par.name, "test")
        self.assertEqual(par.dist.dist.name, "uniform")
        self.assertEqual(par.lower_bound, 0)
        self.assertEqual(par.upper_bound, 1)
        self.assertEqual(par.resolution, [0, 1])

        with self.assertRaises(ValueError):
            parameters.RealParameter.from_dist(
                "test", sp.stats.randint(0, 1)
            )  # @UndefinedVariable
            parameters.RealParameter.from_dist(
                "test",
                sp.stats.uniform(0, 1),
                blaat=[0, 1],  # @UndefinedVariable
            )


class IntegerParameterTestCase(unittest.TestCase):
    def test_instantiation(self):
        name = "test"
        resolution = [0, 1, 2]
        lower_bound = 0
        upper_bound = 2
        par = parameters.IntegerParameter(name, lower_bound, upper_bound, resolution=resolution)

        self.assertEqual(par.name, name)
        self.assertEqual(par.resolution, resolution)
        self.assertEqual(par.lower_bound, lower_bound)
        self.assertEqual(par.upper_bound, upper_bound)

        name = "test"
        resolution = [0, 1, 2]
        lower_bound = 2
        upper_bound = 0

        with self.assertRaises(ValueError):
            par = parameters.IntegerParameter(
                name, lower_bound, upper_bound, resolution=resolution
            )

        with self.assertRaises(ValueError):
            resolution = [-1, 0]
            par = parameters.IntegerParameter(
                name, lower_bound, upper_bound, resolution=resolution
            )

            resolution = [0, 1, 3]
            par = parameters.IntegerParameter(
                name, lower_bound, upper_bound, resolution=resolution
            )

        with self.assertRaises(ValueError):
            par = parameters.IntegerParameter(name, lower_bound, 2.1, resolution=resolution)

            par = parameters.IntegerParameter(name, 0.0, 2, resolution=resolution)

        with self.assertRaises(ValueError):
            par = parameters.IntegerParameter(
                name, lower_bound, upper_bound, resolution=[0, 1.5, 2]
            )

    def test_dist(self):
        name = "test"
        resolution = [0, 1, 2]
        lower_bound = 0
        upper_bound = 2
        par = parameters.IntegerParameter(name, lower_bound, upper_bound, resolution=resolution)

        self.assertEqual(par.dist.dist.name, "randint")
        self.assertEqual(par.lower_bound, lower_bound)
        self.assertEqual(par.upper_bound, upper_bound)

    def test_from_dist(self):
        par = parameters.IntegerParameter.from_dist(
            "test",
            sp.stats.randint(0, 10),
            resolution=[0, 9],  # @UndefinedVariable
        )

        self.assertEqual(par.name, "test")
        self.assertEqual(par.dist.dist.name, "randint")
        self.assertEqual(par.lower_bound, 0)
        self.assertEqual(par.upper_bound, 9)
        self.assertEqual(par.resolution, [0, 9])

        with self.assertRaises(ValueError):
            parameters.IntegerParameter.from_dist(
                "test", sp.stats.uniform(0, 1)
            )  # @UndefinedVariable
            parameters.IntegerParameter.from_dist(
                "test",
                sp.stats.randint(0, 1),
                blaat=[0, 1],  # @UndefinedVariable
            )
            parameters.IntegerParameter.from_dist(
                "test",
                sp.stats.randint(0, 10),
                resolution=[0, 9],  # @UndefinedVariable
            )


class CategoricalParameterTestCase(unittest.TestCase):
    def test_instantiation(self):
        name = "test"
        values = ("a", "b")
        par = parameters.CategoricalParameter(name, values)

        self.assertEqual(par.name, name)
        self.assertEqual(par.resolution, [0, 1])
        self.assertEqual(par.lower_bound, 0)
        self.assertEqual(par.upper_bound, 1)

    def test_index_for_cat(self):
        name = "test"
        values = ("a", "b")
        par1 = parameters.CategoricalParameter(name, values)

        self.assertEqual(par1.index_for_cat("a"), 0)
        self.assertEqual(par1.index_for_cat("b"), 1)

        with self.assertRaises(ValueError):
            par1.index_for_cat("c")

    def test_cat_for_index(self):
        name = "test"
        values = ("a", "b")
        par1 = parameters.CategoricalParameter(name, values)

        self.assertEqual(par1.cat_for_index(0).name, "a")
        self.assertEqual(par1.cat_for_index(1).name, "b")

        with self.assertRaises(IndexError):
            par1.cat_for_index(3)

    def test_from_dist(self):
        pass


class ParametersTestCase(unittest.TestCase):
    @mock.patch("ema_workbench.em_framework.parameters.pd")
    def test_to_csv(self, mock_pandas):
        params = [
            parameters.RealParameter("a", 0.1, 1.5),
            parameters.IntegerParameter("b", 0, 10),
            parameters.CategoricalParameter("c", ["a", "b"]),
        ]

        parameters.parameters_to_csv(params, "a.csv")

        # TODO:: add assertions
        mock_pandas.DataFrame.from_dict.assert_called()


if __name__ == "__main__":
    unittest.main()

1	""" """
2
3	import unittest	1✔
4	import unittest.mock as mock	1✔
5
6	import scipy as sp	1✔
7
8	from ema_workbench.em_framework import parameters	1✔
9
10
11	class RealParameterTestCase(unittest.TestCase):	1✔
12	def test_instantiation(self):	1✔
13	name = "test"	1✔
14	resolution = [0, 1, 2]	1✔
15	lower_bound = 0	1✔
16	upper_bound = 2.1	1✔
17	par = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)	1✔
18
19	self.assertEqual(par.name, name)	1✔
20	self.assertEqual(par.resolution, resolution)	1✔
21	self.assertEqual(par.lower_bound, lower_bound)	1✔
22	self.assertEqual(par.upper_bound, upper_bound)	1✔
23
24	name = "test"	1✔
25	resolution = [0, 1, 2]	1✔
26	lower_bound = 2.1	1✔
27	upper_bound = 0	1✔
28
29	with self.assertRaises(ValueError):	1✔
30	par = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)	1✔
31
32	with self.assertRaises(ValueError):	1✔
33	resolution = [-1, 0]	1✔
34	par = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)	1✔
35
36	resolution = [0, 1, 3]	×
NEW 37	par = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)	×
38
39	def test_comparison(self):	1✔
40	name = "test"	1✔
41	resolution = [0, 1, 2]	1✔
42	lower_bound = 0	1✔
43	upper_bound = 2.0	1✔
44	par1 = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)	1✔
45	par2 = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)	1✔
46
47	self.assertTrue(par1 == par2)	1✔
48
49	name = "test"	1✔
50	par1 = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)	1✔
51
52	name = "what"	1✔
53	par2 = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)	1✔
54	self.assertFalse(par1 == par2)	1✔
55
56	def test_dist(self):	1✔
57	name = "test"	1✔
58	resolution = [0, 1, 2]	1✔
59	lower_bound = 0	1✔
60	upper_bound = 2.1	1✔
61	par = parameters.RealParameter(name, lower_bound, upper_bound, resolution=resolution)	1✔
62
63	self.assertEqual(par.dist.dist.name, "uniform")	1✔
64	self.assertEqual(par.lower_bound, lower_bound)	1✔
65	self.assertEqual(par.upper_bound, upper_bound)	1✔
66
67	def test_from_dist(self):	1✔
68	par = parameters.RealParameter.from_dist(	1✔
69	"test",
70	sp.stats.uniform(0, 1),
71	resolution=[0, 1], # @UndefinedVariable
72	)
73
74	self.assertEqual(par.name, "test")	1✔
75	self.assertEqual(par.dist.dist.name, "uniform")	1✔
76	self.assertEqual(par.lower_bound, 0)	1✔
77	self.assertEqual(par.upper_bound, 1)	1✔
78	self.assertEqual(par.resolution, [0, 1])	1✔
79
80	with self.assertRaises(ValueError):	1✔
81	parameters.RealParameter.from_dist(	1✔
82	"test", sp.stats.randint(0, 1)
83	) # @UndefinedVariable
84	parameters.RealParameter.from_dist(	×
85	"test",
86	sp.stats.uniform(0, 1),
87	blaat=[0, 1], # @UndefinedVariable
88	)
89
90
91	class IntegerParameterTestCase(unittest.TestCase):	1✔
92	def test_instantiation(self):	1✔
93	name = "test"	1✔
94	resolution = [0, 1, 2]	1✔
95	lower_bound = 0	1✔
96	upper_bound = 2	1✔
97	par = parameters.IntegerParameter(name, lower_bound, upper_bound, resolution=resolution)	1✔
98
99	self.assertEqual(par.name, name)	1✔
100	self.assertEqual(par.resolution, resolution)	1✔
101	self.assertEqual(par.lower_bound, lower_bound)	1✔
102	self.assertEqual(par.upper_bound, upper_bound)	1✔
103
104	name = "test"	1✔
105	resolution = [0, 1, 2]	1✔
106	lower_bound = 2	1✔
107	upper_bound = 0	1✔
108
109	with self.assertRaises(ValueError):	1✔
110	par = parameters.IntegerParameter(	1✔
111	name, lower_bound, upper_bound, resolution=resolution
112	)
113
114	with self.assertRaises(ValueError):	1✔
115	resolution = [-1, 0]	1✔
116	par = parameters.IntegerParameter(	1✔
117	name, lower_bound, upper_bound, resolution=resolution
118	)
119
120	resolution = [0, 1, 3]	×
121	par = parameters.IntegerParameter(	×
122	name, lower_bound, upper_bound, resolution=resolution
123	)
124
125	with self.assertRaises(ValueError):	1✔
126	par = parameters.IntegerParameter(name, lower_bound, 2.1, resolution=resolution)	1✔
127
NEW 128	par = parameters.IntegerParameter(name, 0.0, 2, resolution=resolution)	×
129
130	with self.assertRaises(ValueError):	1✔
131	par = parameters.IntegerParameter(	1✔
132	name, lower_bound, upper_bound, resolution=[0, 1.5, 2]
133	)
134
135	def test_dist(self):	1✔
136	name = "test"	1✔
137	resolution = [0, 1, 2]	1✔
138	lower_bound = 0	1✔
139	upper_bound = 2	1✔
140	par = parameters.IntegerParameter(name, lower_bound, upper_bound, resolution=resolution)	1✔
141
142	self.assertEqual(par.dist.dist.name, "randint")	1✔
143	self.assertEqual(par.lower_bound, lower_bound)	1✔
144	self.assertEqual(par.upper_bound, upper_bound)	1✔
145
146	def test_from_dist(self):	1✔
147	par = parameters.IntegerParameter.from_dist(	1✔
148	"test",
149	sp.stats.randint(0, 10),
150	resolution=[0, 9], # @UndefinedVariable
151	)
152
153	self.assertEqual(par.name, "test")	1✔
154	self.assertEqual(par.dist.dist.name, "randint")	1✔
155	self.assertEqual(par.lower_bound, 0)	1✔
156	self.assertEqual(par.upper_bound, 9)	1✔
157	self.assertEqual(par.resolution, [0, 9])	1✔
158
159	with self.assertRaises(ValueError):	1✔
160	parameters.IntegerParameter.from_dist(	1✔
161	"test", sp.stats.uniform(0, 1)
162	) # @UndefinedVariable
163	parameters.IntegerParameter.from_dist(	×
164	"test",
165	sp.stats.randint(0, 1),
166	blaat=[0, 1], # @UndefinedVariable
167	)
168	parameters.IntegerParameter.from_dist(	×
169	"test",
170	sp.stats.randint(0, 10),
171	resolution=[0, 9], # @UndefinedVariable
172	)
173
174
175	class CategoricalParameterTestCase(unittest.TestCase):	1✔
176	def test_instantiation(self):	1✔
177	name = "test"	1✔
178	values = ("a", "b")	1✔
179	par = parameters.CategoricalParameter(name, values)	1✔
180
181	self.assertEqual(par.name, name)	1✔
182	self.assertEqual(par.resolution, [0, 1])	1✔
183	self.assertEqual(par.lower_bound, 0)	1✔
184	self.assertEqual(par.upper_bound, 1)	1✔
185
186	def test_index_for_cat(self):	1✔
187	name = "test"	1✔
188	values = ("a", "b")	1✔
189	par1 = parameters.CategoricalParameter(name, values)	1✔
190
191	self.assertEqual(par1.index_for_cat("a"), 0)	1✔
192	self.assertEqual(par1.index_for_cat("b"), 1)	1✔
193
194	with self.assertRaises(ValueError):	1✔
195	par1.index_for_cat("c")	1✔
196
197	def test_cat_for_index(self):	1✔
198	name = "test"	1✔
199	values = ("a", "b")	1✔
200	par1 = parameters.CategoricalParameter(name, values)	1✔
201
202	self.assertEqual(par1.cat_for_index(0).name, "a")	1✔
203	self.assertEqual(par1.cat_for_index(1).name, "b")	1✔
204
205	with self.assertRaises(IndexError):	1✔
206	par1.cat_for_index(3)	1✔
207
208	def test_from_dist(self):	1✔
209	pass	1✔
210
211
212	class ParametersTestCase(unittest.TestCase):	1✔
213	@mock.patch("ema_workbench.em_framework.parameters.pd")	1✔
214	def test_to_csv(self, mock_pandas):	1✔
215	params = [	1✔
216	parameters.RealParameter("a", 0.1, 1.5),
217	parameters.IntegerParameter("b", 0, 10),
218	parameters.CategoricalParameter("c", ["a", "b"]),
219	]
220
221	parameters.parameters_to_csv(params, "a.csv")	1✔
222
223	# TODO:: add assertions
224	mock_pandas.DataFrame.from_dict.assert_called()	1✔
225
226
227	if __name__ == "__main__":	1✔
228	unittest.main()	×

quaquel / EMAworkbench / 19070662183

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous