class RepetitionPulseTemplateSerializationTests(unittest.TestCase):

    def setUp(self) -> None:
        self.serializer = DummySerializer(deserialize_callback=lambda x: x['name'])
        self.body = DummyPulseTemplate()

    def test_get_serialization_data_constant(self) -> None:
        repetition_count = 3
        template = RepetitionPulseTemplate(self.body, repetition_count)
        expected_data = dict(
            type=self.serializer.get_type_identifier(template),
            body=str(id(self.body)),
            repetition_count=repetition_count
        )
        data = template.get_serialization_data(self.serializer)
        self.assertEqual(expected_data, data)

    def test_get_serialization_data_declaration(self) -> None:
        repetition_count = ParameterDeclaration('foo')
        template = RepetitionPulseTemplate(self.body, repetition_count)
        expected_data = dict(
            type=self.serializer.get_type_identifier(template),
            body=str(id(self.body)),
            repetition_count=str(id(repetition_count))
        )
        data = template.get_serialization_data(self.serializer)
        self.assertEqual(expected_data, data)

    def test_deserialize_constant(self) -> None:
        repetition_count = 3
        data = dict(
            repetition_count=repetition_count,
            body=dict(name=str(id(self.body))),
            identifier='foo'
        )
        # prepare dependencies for deserialization
        self.serializer.subelements[str(id(self.body))] = self.body
        # deserialize
        template = RepetitionPulseTemplate.deserialize(self.serializer, **data)
        # compare!
        self.assertEqual(self.body, template.body)
        self.assertEqual(repetition_count, template.repetition_count)

    def test_deserialize_declaration(self) -> None:
        repetition_count = ParameterDeclaration('foo')
        data = dict(
            repetition_count=dict(name='foo'),
            body=dict(name=str(id(self.body))),
            identifier='foo'
        )
        # prepare dependencies for deserialization
        self.serializer.subelements[str(id(self.body))] = self.body
        self.serializer.subelements['foo'] = repetition_count
        # deserialize
        template = RepetitionPulseTemplate.deserialize(self.serializer, **data)
        # compare!
        self.assertEqual(self.body, template.body)
        self.assertEqual(repetition_count, template.repetition_count)
Exemplo n.º 2
0
class RepetitionPulseTemplateSerializationTests(unittest.TestCase):

    def setUp(self) -> None:
        self.serializer = DummySerializer(deserialize_callback=lambda x: x['name'])
        self.body = DummyPulseTemplate()

    def test_get_serialization_data_constant(self) -> None:
        repetition_count = 3
        template = RepetitionPulseTemplate(self.body, repetition_count)
        expected_data = dict(
            type=self.serializer.get_type_identifier(template),
            body=str(id(self.body)),
            repetition_count=repetition_count
        )
        data = template.get_serialization_data(self.serializer)
        self.assertEqual(expected_data, data)

    def test_get_serialization_data_declaration(self) -> None:
        repetition_count = ParameterDeclaration('foo')
        template = RepetitionPulseTemplate(self.body, repetition_count)
        expected_data = dict(
            type=self.serializer.get_type_identifier(template),
            body=str(id(self.body)),
            repetition_count=str(id(repetition_count))
        )
        data = template.get_serialization_data(self.serializer)
        self.assertEqual(expected_data, data)

    def test_deserialize_constant(self) -> None:
        repetition_count = 3
        data = dict(
            repetition_count=repetition_count,
            body=dict(name=str(id(self.body))),
            identifier='foo'
        )
        # prepare dependencies for deserialization
        self.serializer.subelements[str(id(self.body))] = self.body
        # deserialize
        template = RepetitionPulseTemplate.deserialize(self.serializer, **data)
        # compare!
        self.assertEqual(self.body, template.body)
        self.assertEqual(repetition_count, template.repetition_count)

    def test_deserialize_declaration(self) -> None:
        repetition_count = ParameterDeclaration('foo')
        data = dict(
            repetition_count=dict(name='foo'),
            body=dict(name=str(id(self.body))),
            identifier='foo'
        )
        # prepare dependencies for deserialization
        self.serializer.subelements[str(id(self.body))] = self.body
        self.serializer.subelements['foo'] = repetition_count
        # deserialize
        template = RepetitionPulseTemplate.deserialize(self.serializer, **data)
        # compare!
        self.assertEqual(self.body, template.body)
        self.assertEqual(repetition_count, template.repetition_count)
Exemplo n.º 3
0
 def test_get_serialization_data(self) -> None:
     constant_parameter = ConstantParameter(-0.2)
     serializer = DummySerializer()
     data = constant_parameter.get_serialization_data(serializer)
     self.assertEqual(
         dict(type=serializer.get_type_identifier(constant_parameter),
              constant=-0.2), data)
Exemplo n.º 4
0
class TablePulseTemplateOldSerializationTests(unittest.TestCase):

    def setUp(self) -> None:
        # test for deprecated version during transition period, remove after final switch
        with self.assertWarnsRegex(DeprecationWarning, "deprecated",
                                   msg="TablePT does not issue warning for old serialization routines."):
            self.serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name'])
            self.entries = dict(A=[('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')],
                                B=[(0, 5, 'hold'), (1, 7, 'jump'), ('k', 't', 'hold')])
            self.measurements = [('m', 1, 1), ('foo', 'z', 'o')]
            self.template = TablePulseTemplate(entries=self.entries,
                                               measurements=self.measurements,
                                               identifier='foo', parameter_constraints=['ilse>2', 'k>foo'],
                                               registry=dict())
            self.expected_data = dict(type=self.serializer.get_type_identifier(self.template))
            self.maxDiff = None

    def test_get_serialization_data_old(self) -> None:
        # test for deprecated version during transition period, remove after final switch
        with self.assertWarnsRegex(DeprecationWarning, "deprecated",
                                   msg="TablePT does not issue warning for old serialization routines."):
            expected_data = dict(measurements=self.measurements,
                                 entries=self.entries,
                                 parameter_constraints=[str(Expression('ilse>2')), str(Expression('k>foo'))])

            data = self.template.get_serialization_data(self.serializer)
            self.assertEqual(expected_data, data)

    def test_deserialize_old(self) -> None:
        registry = dict()

        # test for deprecated version during transition period, remove after final switch
        with self.assertWarnsRegex(DeprecationWarning, "deprecated",
                                   msg="TablePT does not issue warning for old serialization routines."):
            data = dict(measurements=self.measurements,
                        entries=self.entries,
                        parameter_constraints=['ilse>2', 'k>foo'],
                        identifier='foo')

            # deserialize
            template = TablePulseTemplate.deserialize(self.serializer, **data, registry=registry)

            self.assertEqual(template.entries, self.template.entries)
            self.assertEqual(template.measurement_declarations, self.template.measurement_declarations)
            self.assertEqual(template.parameter_constraints, self.template.parameter_constraints)

    def test_serializer_integration_old(self):
        registry = dict()

        # test for deprecated version during transition period, remove after final switch
        with self.assertWarnsRegex(DeprecationWarning, "deprecated",
                                   msg="TablePT does not issue warning for old serialization routines."):
            serializer = Serializer(DummyStorageBackend())
            serializer.serialize(self.template)
            template = serializer.deserialize('foo')

            self.assertIsInstance(template, TablePulseTemplate)
            self.assertEqual(template.entries, self.template.entries)
            self.assertEqual(template.measurement_declarations, self.template.measurement_declarations)
            self.assertEqual(template.parameter_constraints, self.template.parameter_constraints)
Exemplo n.º 5
0
 def test_get_serialization_data(self) -> None:
     exp = Expression("foo + bar * hugo")
     p = MappedParameter(exp)
     serializer = DummySerializer()
     data = p.get_serialization_data(serializer)
     self.assertEqual(
         dict(type=serializer.get_type_identifier(p),
              expression=str(id(exp))), data)
class PointPulseTemplateSerializationTests(unittest.TestCase):
    def setUp(self) -> None:
        self.serializer = DummySerializer(lambda x: dict(name=x.name),
                                          lambda x: x.name,
                                          lambda x: x['name'])
        self.entries = [('foo', 2, 'hold'), ('hugo', 'A + B', 'linear')]
        self.measurements = [('m', 1, 1), ('foo', 'z', 'o')]
        self.template = PointPulseTemplate(
            time_point_tuple_list=self.entries,
            channel_names=[0, 'A'],
            measurements=self.measurements,
            identifier='foo',
            parameter_constraints=['ilse>2', 'k>foo'])
        self.expected_data = dict(
            type=self.serializer.get_type_identifier(self.template))
        self.maxDiff = None

    def test_get_serialization_data(self) -> None:
        expected_data = dict(measurements=self.measurements,
                             time_point_tuple_list=self.entries,
                             channel_names=(0, 'A'),
                             parameter_constraints=[
                                 str(Expression('ilse>2')),
                                 str(Expression('k>foo'))
                             ])

        data = self.template.get_serialization_data(self.serializer)
        self.assertEqual(expected_data, data)

    def test_deserialize(self) -> None:
        data = dict(measurements=self.measurements,
                    time_point_tuple_list=self.entries,
                    channel_names=(0, 'A'),
                    parameter_constraints=['ilse>2', 'k>foo'],
                    identifier='foo')

        # deserialize
        template = PointPulseTemplate.deserialize(self.serializer, **data)

        self.assertEqual(template.point_pulse_entries,
                         self.template.point_pulse_entries)
        self.assertEqual(template.measurement_declarations,
                         self.template.measurement_declarations)
        self.assertEqual(template.parameter_constraints,
                         self.template.parameter_constraints)

    def test_serializer_integration(self):
        serializer = Serializer(DummyStorageBackend())
        serializer.serialize(self.template)
        template = serializer.deserialize('foo')

        self.assertIsInstance(template, PointPulseTemplate)
        self.assertEqual(template.point_pulse_entries,
                         self.template.point_pulse_entries)
        self.assertEqual(template.measurement_declarations,
                         self.template.measurement_declarations)
        self.assertEqual(template.parameter_constraints,
                         self.template.parameter_constraints)
class SequencePulseTemplateSerializationTests(unittest.TestCase):

    def setUp(self) -> None:
        self.serializer = DummySerializer()

        self.table_foo = TablePulseTemplate(identifier='foo')
        self.table_foo.add_entry('hugo', 2)
        self.table_foo.add_entry(ParameterDeclaration('albert', max=9.1), 'voltage')

        self.table = TablePulseTemplate(measurement=True)
        self.foo_mappings = dict(hugo='ilse', albert='albert', voltage='voltage')

    def test_get_serialization_data(self) -> None:
        sequence = SequencePulseTemplate([(self.table_foo, self.foo_mappings), (self.table, {})],
                                         ['ilse', 'albert', 'voltage'],
                                         identifier='foo')

        expected_data = dict(
            type=self.serializer.get_type_identifier(sequence),
            external_parameters=['albert', 'ilse', 'voltage'],
            is_interruptable=True,
            subtemplates = [
                dict(template=str(id(self.table_foo)), mappings=self.foo_mappings),
                dict(template=str(id(self.table)), mappings=dict())
            ]
        )
        data = sequence.get_serialization_data(self.serializer)
        self.assertEqual(expected_data, data)

    def test_deserialize(self) -> None:
        data = dict(
            external_parameters={'ilse', 'albert', 'voltage'},
            is_interruptable=True,
            subtemplates = [
                dict(template=str(id(self.table_foo)), mappings=self.foo_mappings),
                dict(template=str(id(self.table)), mappings=dict())
            ],
            identifier='foo'
        )

        # prepare dependencies for deserialization
        self.serializer.subelements[str(id(self.table_foo))] = self.table_foo
        self.serializer.subelements[str(id(self.table))] = self.table

        # deserialize
        sequence = SequencePulseTemplate.deserialize(self.serializer, **data)

        # compare!
        self.assertEqual(data['external_parameters'], sequence.parameter_names)
        self.assertEqual({ParameterDeclaration('ilse'), ParameterDeclaration('albert'), ParameterDeclaration('voltage')},
                         sequence.parameter_declarations)
        self.assertIs(self.table_foo, sequence.subtemplates[0][0])
        self.assertIs(self.table, sequence.subtemplates[1][0])
        self.assertEqual(self.foo_mappings, {k: m.string for k,m in sequence.subtemplates[0][1].items()})
        self.assertEqual(dict(), sequence.subtemplates[1][1])
        self.assertEqual(data['identifier'], sequence.identifier)
Exemplo n.º 8
0
class ParameterDeclarationSerializationTests(unittest.TestCase):

    def setUp(self) -> None:
        self.serializer = DummySerializer()
        self.declaration = ParameterDeclaration('foo')
        self.expected_data = dict(name='foo', type=self.serializer.get_type_identifier(self.declaration))

    def test_get_serialization_data_all_default(self) -> None:
        self.expected_data['min_value'] = float('-inf')
        self.expected_data['max_value'] = float('+inf')
        self.expected_data['default_value'] = None
        self.assertEqual(self.expected_data, self.declaration.get_serialization_data(self.serializer))

    def test_get_serialization_data_all_floats(self) -> None:
        self.declaration = ParameterDeclaration('foo', min=-3.1, max=4.3, default=0.2)
        self.expected_data['min_value'] = -3.1
        self.expected_data['max_value'] = 4.3
        self.expected_data['default_value'] = 0.2
        self.assertEqual(self.expected_data, self.declaration.get_serialization_data(self.serializer))

    def test_get_serialization_data_min_max_references(self) -> None:
        bar_min = ParameterDeclaration('bar_min')
        bar_max = ParameterDeclaration('bar_max')
        self.declaration.min_value = bar_min
        self.declaration.max_value = bar_max
        self.expected_data['min_value'] = 'bar_min'
        self.expected_data['max_value'] = 'bar_max'
        self.expected_data['default_value'] = None
        self.assertEqual(self.expected_data, self.declaration.get_serialization_data(self.serializer))

    def test_deserialize_all_default(self) -> None:
        data = dict(min_value=float('-inf'), max_value=float('+inf'), default_value=None, name='foo')
        declaration = ParameterDeclaration.deserialize(self.serializer, **data)
        self.assertEqual(data['min_value'], declaration.min_value)
        self.assertEqual(data['max_value'], declaration.max_value)
        self.assertEqual(data['default_value'], declaration.default_value)
        self.assertEqual(data['name'], declaration.name)
        self.assertIsNone(declaration.identifier)

    def test_deserialize_all_floats(self) -> None:
        data = dict(min_value=33.3, max_value=44, default_value=41.1, name='foo')
        declaration = ParameterDeclaration.deserialize(self.serializer, **data)
        self.assertEqual(data['min_value'], declaration.min_value)
        self.assertEqual(data['max_value'], declaration.max_value)
        self.assertEqual(data['default_value'], declaration.default_value)
        self.assertEqual(data['name'], declaration.name)
        self.assertIsNone(declaration.identifier)

    def test_deserialize_min_max_references(self) -> None:
        data = dict(min_value='bar_min', max_value='bar_max', default_value=-23.5, name='foo')
        declaration = ParameterDeclaration.deserialize(self.serializer, **data)
        self.assertEqual(float('-inf'), declaration.min_value)
        self.assertEqual(float('+inf'), declaration.max_value)
        self.assertEqual(data['default_value'], declaration.default_value)
        self.assertEqual(data['name'], declaration.name)
        self.assertIsNone(declaration.identifier)
    def test_get_serialization_data(self) -> None:
        body = DummyPulseTemplate()
        condition_name = 'foo_cond'
        identifier = 'foo_loop'
        t = LoopPulseTemplate(condition_name, body, identifier=identifier)

        serializer = DummySerializer()
        expected_data = dict(type=serializer.get_type_identifier(t),
                             body=str(id(body)),
                             condition=condition_name)

        data = t.get_serialization_data(serializer)
        self.assertEqual(expected_data, data)
Exemplo n.º 10
0
    def test_get_serialization_data(self) -> None:
        body = DummyPulseTemplate()
        condition_name = 'foo_cond'
        identifier = 'foo_loop'
        t = WhileLoopPulseTemplate(condition_name, body, identifier=identifier)

        serializer = DummySerializer()
        expected_data = dict(type=serializer.get_type_identifier(t),
                             body=str(id(body)),
                             condition=condition_name)

        data = t.get_serialization_data(serializer)
        self.assertEqual(expected_data, data)
Exemplo n.º 11
0
class TablePulseTemplateSerializationTests(unittest.TestCase):

    def setUp(self) -> None:
        self.serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name'])
        self.template = TablePulseTemplate(measurement=True, identifier='foo')
        self.expected_data = dict(type=self.serializer.get_type_identifier(self.template))

    def test_get_serialization_data(self) -> None:
        self.template.add_entry('foo', 2)
        self.template.add_entry('hugo', 'ilse', interpolation='linear')

        self.expected_data['is_measurement_pulse'] = True
        self.expected_data['time_parameter_declarations'] = [dict(name='foo'), dict(name='hugo')]
        self.expected_data['voltage_parameter_declarations'] = [dict(name='ilse')]
        self.expected_data['entries'] = [[(0, 0, 'hold'), ('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')]]
        data = self.template.get_serialization_data(self.serializer)
        self.assertEqual(self.expected_data, data)

    def test_deserialize(self) -> None:
        data = dict(is_measurement_pulse=True,
                    time_parameter_declarations=[dict(name='hugo'), dict(name='foo')],
                    voltage_parameter_declarations=[dict(name='ilse')],
                    entries=[[(0, 0, 'hold'), ('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')]],
                    identifier='foo')

        # prepare dependencies for deserialization
        self.serializer.subelements['foo'] = ParameterDeclaration('foo')
        self.serializer.subelements['hugo'] = ParameterDeclaration('hugo')
        self.serializer.subelements['ilse'] = ParameterDeclaration('ilse')

        # deserialize
        template = TablePulseTemplate.deserialize(self.serializer, **data)

        # prepare expected parameter declarations
        self.serializer.subelements['foo'].min_value = 0
        self.serializer.subelements['foo'].max_value = self.serializer.subelements['hugo']
        all_declarations = set(self.serializer.subelements.values())

        # prepare expected entries
        entries = [[(0, 0, HoldInterpolationStrategy()),
                   (self.serializer.subelements['foo'], 2, HoldInterpolationStrategy()),
                   (self.serializer.subelements['hugo'], self.serializer.subelements['ilse'], LinearInterpolationStrategy())]]

        # compare!
        self.assertEqual(all_declarations, template.parameter_declarations)
        self.assertEqual({'foo', 'hugo', 'ilse'}, template.parameter_names)
        self.assertEqual(entries, template.entries)
        self.assertEqual('foo', template.identifier)
class TablePulseTemplateSerializationTests(unittest.TestCase):

    def setUp(self) -> None:
        self.serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name'])
        self.template = TablePulseTemplate(measurement=True, identifier='foo')
        self.expected_data = dict(type=self.serializer.get_type_identifier(self.template))

    def test_get_serialization_data(self) -> None:
        self.template.add_entry('foo', 2)
        self.template.add_entry('hugo', 'ilse', interpolation='linear')

        self.expected_data['is_measurement_pulse'] = True
        self.expected_data['time_parameter_declarations'] = [dict(name='foo'), dict(name='hugo')]
        self.expected_data['voltage_parameter_declarations'] = [dict(name='ilse')]
        self.expected_data['entries'] = [(0, 0, 'hold'), ('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')]
        self.assertEqual(self.expected_data, self.template.get_serialization_data(self.serializer))

    def test_deserialize(self) -> None:
        data = dict(is_measurement_pulse=True,
                    time_parameter_declarations=[dict(name='hugo'), dict(name='foo')],
                    voltage_parameter_declarations=[dict(name='ilse')],
                    entries=[(0, 0, 'hold'), ('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')],
                    identifier='foo')

        # prepare dependencies for deserialization
        self.serializer.subelements['foo'] = ParameterDeclaration('foo')
        self.serializer.subelements['hugo'] = ParameterDeclaration('hugo')
        self.serializer.subelements['ilse'] = ParameterDeclaration('ilse')

        # deserialize
        template = TablePulseTemplate.deserialize(self.serializer, **data)

        # prepare expected parameter declarations
        self.serializer.subelements['foo'].min_value = 0
        self.serializer.subelements['foo'].max_value = self.serializer.subelements['hugo']
        all_declarations = set(self.serializer.subelements.values())

        # prepare expected entries
        entries = [(0, 0, HoldInterpolationStrategy()),
                   (self.serializer.subelements['foo'], 2, HoldInterpolationStrategy()),
                   (self.serializer.subelements['hugo'], self.serializer.subelements['ilse'], LinearInterpolationStrategy())]

        # compare!
        self.assertEqual(all_declarations, template.parameter_declarations)
        self.assertEqual({'foo', 'hugo', 'ilse'}, template.parameter_names)
        self.assertEqual(entries, template.entries)
        self.assertEqual('foo', template.identifier)
 def test_get_serialization_data(self) -> None:
     serializer = DummySerializer(serialize_callback=lambda x: str(x))
     foo_mappings = {k: Expression(v) for k, v in self.foo_mappings.items()}
     sequence = SequencePulseTemplate([(self.table_foo, self.foo_mappings),
                                       (self.table, {})],
                                      ['ilse', 'albert', 'voltage'],
                                      identifier='foo')
     expected_data = dict(
         type=serializer.get_type_identifier(sequence),
         external_parameters=['albert', 'ilse', 'voltage'],
         is_interruptable=True,
         subtemplates=[
             dict(template=str(self.table_foo),
                  mappings={k: str(v)
                            for k, v in foo_mappings.items()}),
             dict(template=str(self.table), mappings=dict())
         ])
     data = sequence.get_serialization_data(serializer)
     self.assertEqual(expected_data, data)
Exemplo n.º 14
0
class ParameterDeclarationSerializationTests(unittest.TestCase):
    def setUp(self) -> None:
        self.serializer = DummySerializer()
        self.declaration = ParameterDeclaration('foo')
        self.expected_data = dict(name='foo',
                                  type=self.serializer.get_type_identifier(
                                      self.declaration))

    def test_get_serialization_data_all_default(self) -> None:
        self.expected_data['min_value'] = float('-inf')
        self.expected_data['max_value'] = float('+inf')
        self.expected_data['default_value'] = None
        self.assertEqual(
            self.expected_data,
            self.declaration.get_serialization_data(self.serializer))

    def test_get_serialization_data_all_floats(self) -> None:
        self.declaration = ParameterDeclaration('foo',
                                                min=-3.1,
                                                max=4.3,
                                                default=0.2)
        self.expected_data['min_value'] = -3.1
        self.expected_data['max_value'] = 4.3
        self.expected_data['default_value'] = 0.2
        self.assertEqual(
            self.expected_data,
            self.declaration.get_serialization_data(self.serializer))

    def test_get_serialization_data_min_max_references(self) -> None:
        bar_min = ParameterDeclaration('bar_min')
        bar_max = ParameterDeclaration('bar_max')
        self.declaration.min_value = bar_min
        self.declaration.max_value = bar_max
        self.expected_data['min_value'] = 'bar_min'
        self.expected_data['max_value'] = 'bar_max'
        self.expected_data['default_value'] = None
        self.assertEqual(
            self.expected_data,
            self.declaration.get_serialization_data(self.serializer))

    def test_deserialize_all_default(self) -> None:
        data = dict(min_value=float('-inf'),
                    max_value=float('+inf'),
                    default_value=None,
                    name='foo')
        declaration = ParameterDeclaration.deserialize(self.serializer, **data)
        self.assertEqual(data['min_value'], declaration.min_value)
        self.assertEqual(data['max_value'], declaration.max_value)
        self.assertEqual(data['default_value'], declaration.default_value)
        self.assertEqual(data['name'], declaration.name)
        self.assertIsNone(declaration.identifier)

    def test_deserialize_all_floats(self) -> None:
        data = dict(min_value=33.3,
                    max_value=44,
                    default_value=41.1,
                    name='foo')
        declaration = ParameterDeclaration.deserialize(self.serializer, **data)
        self.assertEqual(data['min_value'], declaration.min_value)
        self.assertEqual(data['max_value'], declaration.max_value)
        self.assertEqual(data['default_value'], declaration.default_value)
        self.assertEqual(data['name'], declaration.name)
        self.assertIsNone(declaration.identifier)

    def test_deserialize_min_max_references(self) -> None:
        data = dict(min_value='bar_min',
                    max_value='bar_max',
                    default_value=-23.5,
                    name='foo')
        declaration = ParameterDeclaration.deserialize(self.serializer, **data)
        self.assertEqual(float('-inf'), declaration.min_value)
        self.assertEqual(float('+inf'), declaration.max_value)
        self.assertEqual(data['default_value'], declaration.default_value)
        self.assertEqual(data['name'], declaration.name)
        self.assertIsNone(declaration.identifier)
Exemplo n.º 15
0
 def test_get_serialization_data(self) -> None:
     constant_parameter = ConstantParameter(-0.2)
     serializer = DummySerializer()
     data = constant_parameter.get_serialization_data(serializer)
     self.assertEqual(dict(type=serializer.get_type_identifier(constant_parameter), constant=-0.2), data)