def test_add_entry_for_interpolation(self) -> None:
        table = TablePulseTemplate()
        strategies = ["linear","hold","jump","hold"]
        for i,strategy in enumerate(strategies):
            table.add_entry(2*(i+1), i+1, strategy)

        self.assertRaises(ValueError, table.add_entry, 1,2, "bar")

 def test_add_entry_empty_time_is_str(self) -> None:
     table = TablePulseTemplate()
     table.add_entry('t', 0)
     decl = ParameterDeclaration('t', min=0)
     self.assertEqual([(0, 0, HoldInterpolationStrategy()), (decl, 0, HoldInterpolationStrategy())], table.entries)
     self.assertEqual({'t'}, table.parameter_names)
     self.assertEqual({decl}, table.parameter_declarations)

 def test_add_entry_empty_time_is_0_voltage_is_parameter(self) -> None:
     table = TablePulseTemplate()
     table.add_entry(0, 'foo')
     decl = ParameterDeclaration('foo')
     self.assertEqual([(0, decl, HoldInterpolationStrategy())], table.entries)
     self.assertEqual({'foo'}, table.parameter_names)
     self.assertEqual({decl}, table.parameter_declarations)

 def generate_TablePulseTemplates(self,number_of_entries,max_dist=RANGE):
     while 1:
         x = TablePulseTemplate()
         name = "TablePulseTemplate_{}".format(self.__TablePulseTemplateOffset)
         self.__TablePulseTemplateOffset +=1
         if bool(random.getrandbits(1)):
             x.identifier = name
         previous_min = 0
         previous_max = 0
         parameter_names = []
         
         for i in range(number_of_entries):
             dict_ = {}
             for j in ["time","voltage"]:
                 a = random.choice(["float","str","ParameterDeclaration"])
                 if a == "float":
                     if j == "time":
                         dict_[j] = random.uniform(previous_max,previous_max+max_dist)
                         previous_min = dict_[j]
                         previous_max = dict_[j]
                     else:
                         dict_[j] = random.uniform(-RANGE,RANGE)
                 elif a == "str":
                     dict_[j] = "_".join([name,"str",str(i),str(j)])
                     parameter_names.append(dict_[j])
                 elif a == "ParameterDeclaration":
                     if j == "time":
                         dict_[j] = self.generate_ParameterDeclaration(previous_min, previous_min+max_dist, name, previous_max).__next__()
                         previous_min = dict_[j].min_value
                         previous_max = dict_[j].max_value
                     else:
                         dict_[j] = self.generate_ParameterDeclaration().__next__()
                     parameter_names.append(dict_[j].name)
             x.add_entry(time=dict_["time"],voltage=dict_["voltage"],interpolation=random.choice(INTERPOLATION_STRATEGIES))
         yield x

 def test_add_entry_time_float_after_declaration_smaller_bound(self) -> None:
     table = TablePulseTemplate()
     decl = ParameterDeclaration('t', min=1.0, max=1.3)
     table.add_entry(decl, 7.1)
     table.add_entry(2.1, 5.5)
     self.assertEqual([(0, 0, HoldInterpolationStrategy()), (decl, 7.1, HoldInterpolationStrategy()), (2.1, 5.5, HoldInterpolationStrategy())], table.entries)
     self.assertEqual({'t'}, table.parameter_names)
     self.assertEqual({decl}, table.parameter_declarations)

 def test_add_entry_empty_time_is_declaration(self) -> None:
     table = TablePulseTemplate()
     decl = ParameterDeclaration('foo')
     table.add_entry(decl, 0)
     decl.min_value = 0
     self.assertEqual([(0, 0, HoldInterpolationStrategy()), (decl, 0, HoldInterpolationStrategy())], table.entries)
     self.assertEqual({'foo'}, table.parameter_names)
     self.assertEqual({decl}, table.parameter_declarations)

    def test_add_entry_known_interpolation_strategies(self) -> None:
        table = TablePulseTemplate()
        strategies = ["linear", "hold", "jump"]
        for i,strategy in enumerate(strategies):
            table.add_entry(i, i, strategy)

        manual = [(0,0,LinearInterpolationStrategy()), (1,1,HoldInterpolationStrategy()), (2,2,JumpInterpolationStrategy())]
        self.assertEqual(manual, table.entries)

 def test_add_entry_time_declaration_lower_min_after_float(self) -> None:
     table = TablePulseTemplate()
     table.add_entry(3.2, 92.1)
     decl = ParameterDeclaration('t', min=0.1)
     self.assertRaises(ValueError, table.add_entry, decl, 1.2)
     self.assertEqual([(0, 0, HoldInterpolationStrategy()), (3.2, 92.1, HoldInterpolationStrategy())], table.entries)
     self.assertFalse(table.parameter_names)
     self.assertFalse(table.parameter_declarations)

 def test_add_entry_voltage_declaration_in_use_as_time(self) -> None:
     table = TablePulseTemplate()
     foo_decl = ParameterDeclaration('foo', min=0, max=2)
     table.add_entry(foo_decl, 0)
     self.assertRaises(ValueError, table.add_entry, 4, foo_decl)
     self.assertEqual([(0, 0, HoldInterpolationStrategy()), (foo_decl, 0, HoldInterpolationStrategy())], table.entries)
     self.assertEqual({'foo'}, table.parameter_names)
     self.assertEqual({foo_decl}, table.parameter_declarations)

 def test_get_entries_instantiated_two_entries_invalid_parameters(self) -> None:
     table = TablePulseTemplate()
     table.add_entry(0, 'v1')
     t_decl = ParameterDeclaration('t', min=1, max=2)
     v2_decl = ParameterDeclaration('v2', min=10, max=30)
     table.add_entry(t_decl, v2_decl)
     self.assertRaises(ParameterValueIllegalException, table.get_entries_instantiated, {'v1': -5, 't': 0, 'v2': 20})
     self.assertRaises(ParameterValueIllegalException, table.get_entries_instantiated, {'v1': -5, 't': 1, 'v2': -20})

 def test_add_entry_time_declaration_higher_min_after_float(self) -> None:
     table = TablePulseTemplate()
     table.add_entry(3.2, 92.1)
     decl = ParameterDeclaration('t', min=4.5)
     table.add_entry(decl, 1.2)
     self.assertEqual([(0, 0, HoldInterpolationStrategy()), (3.2, 92.1, HoldInterpolationStrategy()), (decl, 1.2, HoldInterpolationStrategy())], table.entries)
     self.assertEqual({'t'}, table.parameter_names)
     self.assertEqual({decl}, table.parameter_declarations)

 def test_add_entry_time_float_after_declaration_greater_bound(self) -> None:
     table = TablePulseTemplate()
     decl = ParameterDeclaration('t', max=3.4)
     table.add_entry(decl, 7.1)
     decl.min_value = 0
     self.assertRaises(ValueError, table.add_entry, 2.1, 5.5)
     self.assertEqual([(0, 0, HoldInterpolationStrategy()), (decl, 7.1, HoldInterpolationStrategy())], table.entries)
     self.assertEqual({'t'}, table.parameter_names)
     self.assertEqual({decl}, table.parameter_declarations)

 def test_add_entry_time_declaration_lower_bound_upper_bound_too_small_after_declaration(self) -> None:
     table = TablePulseTemplate()
     bar_decl = ParameterDeclaration('bar', min=1, max=2)
     foo_decl = ParameterDeclaration('foo', min=1, max=1.5)
     table.add_entry(bar_decl, -3)
     self.assertRaises(ValueError, table.add_entry, foo_decl, 0.1)
     self.assertEqual([(0, 0, HoldInterpolationStrategy()), (bar_decl, -3, HoldInterpolationStrategy())], table.entries)
     self.assertEqual({'bar'}, table.parameter_names)
     self.assertEqual({bar_decl}, table.parameter_declarations)

 def test_add_entry_time_declaration_lower_bound_after_declaration_upper_bound(self) -> None:
     table = TablePulseTemplate()
     bar_decl = ParameterDeclaration('bar', min=1, max=2)
     foo_decl = ParameterDeclaration('foo', min=1)
     table.add_entry(bar_decl, -3)
     table.add_entry(foo_decl, 0.1)
     self.assertEqual([(0, 0, HoldInterpolationStrategy()), (bar_decl, -3, HoldInterpolationStrategy()), (foo_decl, 0.1, HoldInterpolationStrategy())], table.entries)
     self.assertEqual({'foo', 'bar'}, table.parameter_names)
     self.assertEqual({foo_decl, bar_decl}, table.parameter_declarations)

 def test_add_entry_time_parmeter_name_in_use_as_time(self) -> None:
     table = TablePulseTemplate()
     table.add_entry('foo', 'bar')
     foo_decl = ParameterDeclaration('foo', min=0)
     bar_decl = ParameterDeclaration('bar')
     self.assertRaises(ValueError, table.add_entry, ParameterDeclaration('foo'), 3.4)
     self.assertEqual([(0, 0, HoldInterpolationStrategy()), (foo_decl, bar_decl, HoldInterpolationStrategy())], table.entries)
     self.assertEqual({'foo', 'bar'}, table.parameter_names)
     self.assertEqual({foo_decl, bar_decl}, table.parameter_declarations)

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)

 def test_add_entry_time_declaration_after_declaration_no_upper_bound(self) -> None:
     table = TablePulseTemplate()
     table.add_entry('bar', 72.14)
     table.add_entry('foo', 0)
     bar_decl = ParameterDeclaration('bar', min=0)
     foo_decl = ParameterDeclaration('foo')
     foo_decl.min_value = bar_decl
     self.assertEqual([(0, 0, HoldInterpolationStrategy()), (bar_decl, 72.14, HoldInterpolationStrategy()), (foo_decl, 0, HoldInterpolationStrategy())], table.entries)
     self.assertEqual({'bar', 'foo'}, table.parameter_names)
     self.assertEqual({bar_decl, foo_decl}, table.parameter_declarations)

 def test_add_entry_time_parameter_name_in_use_as_voltage(self) -> None:
     table = TablePulseTemplate()
     table.add_entry(0, 'foo')
     foo_decl = ParameterDeclaration('foo')
     self.assertEqual({'foo'}, table.parameter_names)
     self.assertEqual({foo_decl}, table.parameter_declarations)
     self.assertRaises(ValueError, table.add_entry, 'foo', 4.3)
     self.assertEqual({'foo'}, table.parameter_names)
     self.assertEqual({foo_decl}, table.parameter_declarations)
     self.assertEqual([(0, foo_decl, HoldInterpolationStrategy())], table.entries)

 def test_add_entry_time_float_after_float(self) -> None:
     table = TablePulseTemplate()
     table.add_entry(1.2, -3.8)
     # expect ValueError if next float is smaller or equal than previous
     self.assertRaises(ValueError, table.add_entry, 0.423, 0)
     self.assertRaises(ValueError, table.add_entry, 1.2, 0)
     # adding a higher value as next entry should work
     table.add_entry(3.7, 1.34875)
     self.assertEqual([(0, 0, HoldInterpolationStrategy()), (1.2, -3.8, HoldInterpolationStrategy()), (3.7, 1.34875, HoldInterpolationStrategy())], table.entries)
     self.assertFalse(table.parameter_names)
     self.assertFalse(table.parameter_declarations)

    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)