def test_interpolate_list(self):
     l = [41,42,43]
     d = {'foo': 'bar'.join(PARAMETER_INTERPOLATION_SENTINELS),
          'bar': l}
     p = Parameters(d)
     p.interpolate()
     self.assertEqual(p.as_dict()['foo'], l)

 def _construct_mocked_params(self, iterable=None, delimiter=None):
     p = Parameters(iterable, delimiter)
     self._base = base = p._base
     p._base = mock.MagicMock(spec_set=dict, wraps=base)
     p._base.__repr__ = mock.MagicMock(autospec=dict.__repr__,
                                       return_value=repr(base))
     return p, p._base

 def test_merge_lists(self):
     l1 = [1,2,3]
     l2 = [2,3,4]
     p1 = Parameters(dict(list=l1[:]))
     p2 = Parameters(dict(list=l2))
     p1.merge(p2)
     self.assertListEqual(p1.as_dict()['list'], l1+l2)

 def test_interpolate_infrecursion(self):
     v = 42
     d = {'foo': 'bar'.join(PARAMETER_INTERPOLATION_SENTINELS),
          'bar': 'foo'.join(PARAMETER_INTERPOLATION_SENTINELS)}
     p = Parameters(d)
     with self.assertRaises(InfiniteRecursionError):
         p.interpolate()

 def test_merge_scalars_overwrite(self):
     p = Parameters(SIMPLE)
     mergee = {'two':5,'four':4,'three':None,'one':(1,2,3)}
     p.merge(mergee)
     goal = SIMPLE.copy()
     goal.update(mergee)
     self.assertDictEqual(p.as_dict(), goal)

 def test_merge_scalars(self):
     p = Parameters(SIMPLE)
     mergee = {'five':5,'four':4,'None':None,'tuple':(1,2,3)}
     p.merge(mergee)
     goal = SIMPLE.copy()
     goal.update(mergee)
     self.assertDictEqual(p.as_dict(), goal)

 def test_interpolate_single(self):
     v = 42
     d = {'foo': 'bar'.join(PARAMETER_INTERPOLATION_SENTINELS),
          'bar': v}
     p = Parameters(d)
     p.interpolate()
     self.assertEqual(p.as_dict()['foo'], v)

 def test_merge_dicts_overwrite(self):
     mergee = {'two':5,'four':4,'three':None,'one':(1,2,3)}
     p = Parameters(dict(dict=SIMPLE))
     p.merge(Parameters(dict(dict=mergee)))
     goal = SIMPLE.copy()
     goal.update(mergee)
     self.assertDictEqual(p.as_dict(), dict(dict=goal))

 def test_interpolate_multiple(self):
     v = '42'
     d = {'foo': 'bar'.join(PARAMETER_INTERPOLATION_SENTINELS) + 'meep'.join(PARAMETER_INTERPOLATION_SENTINELS),
          'bar': v[0],
          'meep': v[1]}
     p = Parameters(d)
     p.interpolate()
     self.assertEqual(p.as_dict()['foo'], v)

 def test_merge_dicts_override(self):
     """Validate that tilde merge overrides function properly."""
     mergee = {'~one': {'a': 'alpha'},
               '~two': ['gamma']}
     base = {'one': {'b': 'beta'},
             'two': ['delta']}
     goal = {'one': {'a': 'alpha'},
             'two': ['gamma']}
     p = Parameters(dict(dict=base))
     p.merge(Parameters(dict(dict=mergee)))
     self.assertDictEqual(p.as_dict(), dict(dict=goal))

def _merge(a, b):
    '''
    merge the contents of dictionary ``b`` into dictionary ``a``, using reclass'
    sensible form of deep-dictionary merging and interpolation.
    '''
    m = Parameters(a)
    m.merge(b)
    m.interpolate()
    return m.as_dict()

 def test_constructor1(self):
     DATA = {'blue':'white', 'black':'yellow'}
     c = Parameters(DATA)
     assert len(c) == len(DATA)
     for i in c.iterkeys():
         assert DATA[i] == c[i]

 def test_merge_list_into_scalar(self):
     l = ['foo', 1, 2]
     p1 = Parameters(dict(key=l[0]))
     p1.merge(Parameters(dict(key=l[1:])))
     self.assertListEqual(p1.as_dict()['key'], l)

 def test_merge_scalar_over_list(self):
     l = ['foo', 1, 2]
     p1 = Parameters(dict(key=l[:2]))
     p1.merge(Parameters(dict(key=l[2])))
     self.assertEqual(p1.as_dict()['key'], l[2])

 def test_stray_occurrence_overwrites_during_interpolation(self):
     p1 = Parameters({'r' : mock.sentinel.ref, 'b': '${r}'})
     p2 = Parameters({'b' : mock.sentinel.goal})
     p1.merge(p2)
     p1.interpolate()
     self.assertEqual(p1.as_dict()['b'], mock.sentinel.goal)

 def test_merge_dict_into_scalar(self):
     p = Parameters(dict(base='foo'))
     with self.assertRaises(TypeError):
         p.merge(Parameters(dict(base=SIMPLE)))

 def test_merge_scalar_over_dict(self):
     p = Parameters(dict(base=SIMPLE))
     mergee = {'base':'foo'}
     p.merge(Parameters(mergee))
     self.assertDictEqual(p.as_dict(), mergee)