--- a/src/test/test_memory_memory.py	Wed Feb 05 16:36:51 2014 +0100
+++ b/src/test/test_memory_memory.py	Fri Feb 07 17:10:24 2014 +0100
@@ -31,33 +31,41 @@
     def setUp(self):
         self.host = helpers.FakeSAT()
 
-    def _getParamXML(self, name=None, category=None, security_level=None):
-        if not name:
-            name = Const.ENABLE_UNIBOX_PARAM
-        if not category:
-            category = Const.ENABLE_UNIBOX_KEY
+    def _getParamXML(self, param="1", security_level=None):
+        def getParam(name):
+            return """
+            <param name="%(param_name)s" label="%(param_label)s" value="true" type="bool" %(security)s/>
+            """ % {'param_name': name,
+                            'param_label': _(name),
+                            'security': '' if security_level is None else ('security="%d"' % security_level)
+                            }
+        if param == "1":
+            params = getParam(Const.ENABLE_UNIBOX_PARAM)
+        elif param == "2":
+            params = getParam(Const.PARAM_IN_QUOTES)
+        else:
+            params = getParam(Const.ENABLE_UNIBOX_PARAM) + getParam(Const.PARAM_IN_QUOTES)
         return """
         <params>
         <individual>
         <category name="%(category_name)s" label="%(category_label)s">
-            <param name="%(param_name)s" label="%(param_label)s" value="true" type="bool" %(security)s/>
+            %(params)s
          </category>
         </individual>
         </params>
         """ % {
-            'category_name': category,
-            'category_label': _(category),
-            'param_name': name,
-            'param_label': _(name),
-            'security': '' if security_level is None else ('security="%d"' % security_level)
+            'category_name': Const.COMPOSITION_KEY,
+            'category_label': _(Const.COMPOSITION_KEY),
+            'params': params
         }
 
-    def _paramExists(self, name=None, category=None, src=None):
+    def _paramExists(self, param="1", src=None):
         """@return: True is the param (category, name) exists"""
-        if not name:
+        if param == "1":
             name = Const.ENABLE_UNIBOX_PARAM
-        if not category:
-            category = Const.ENABLE_UNIBOX_KEY
+        else:
+            name = Const.PARAM_IN_QUOTES
+        category = Const.COMPOSITION_KEY
         if src is None:
             src = self.host.memory.params.dom.documentElement
         for type_node in src.childNodes:
@@ -74,28 +82,28 @@
                         return True
         return False
 
-    def assertParam_generic(self, src=None, exists=True, deferred=False):
+    def assertParam_generic(self, param="1", src=None, exists=True, deferred=False):
         msg = "Expected parameter not found!\n" if exists else "Unexpected parameter found!\n"
         if deferred == False:
             # in this stack we can see the line where the error came from,
             # if limit=5, 6 is not enough you can increase the value
             msg += "\n".join(traceback.format_stack(limit=5 if exists else 6))
-        assertion = self._paramExists(src=src)
+        assertion = self._paramExists(param, src)
         getattr(self, "assert%s" % exists)(assertion, msg)
 
-    def assertParamExists(self, src=None):
-        self.assertParam_generic(src, True)
+    def assertParamExists(self, param="1", src=None):
+        self.assertParam_generic(param, src, True)
 
-    def assertParamNotExists(self, src=None):
-        self.assertParam_generic(src, False)
+    def assertParamNotExists(self, param="1", src=None):
+        self.assertParam_generic(param, src, False)
 
-    def assertParamExists_async(self, src):
+    def assertParamExists_async(self, src, param="1"):
         """@param src: a deferred result from Memory.getParams"""
-        self.assertParam_generic(minidom.parseString(src.encode("utf-8")), True, True)
+        self.assertParam_generic(param, minidom.parseString(src.encode("utf-8")), True, True)
 
-    def assertParamNotExists_async(self, src):
+    def assertParamNotExists_async(self, src, param="1"):
         """@param src: a deferred result from Memory.getParams"""
-        self.assertParam_generic(minidom.parseString(src.encode("utf-8")), False, True)
+        self.assertParam_generic(param, minidom.parseString(src.encode("utf-8")), False, True)
 
     def _getParams(self, security_limit, app='', profile_key='@NONE@'):
         if profile_key == '@NONE@':
@@ -112,6 +120,29 @@
         self.host.memory.updateParams(self._getParamXML())
         self.assertEqual(previous.toxml().encode("utf-8"), self.host.memory.params.dom.toxml().encode("utf-8"))
 
+        self.host.memory.init()
+        # check successive updates (without intersection)
+        self.host.memory.updateParams(self._getParamXML('1'))
+        self.assertParamExists("1")
+        self.assertParamNotExists("2")
+        self.host.memory.updateParams(self._getParamXML('2'))
+        self.assertParamExists("1")
+        self.assertParamExists("2")
+
+        previous = self.host.memory.params.dom.cloneNode(True)  # save for later
+
+        self.host.memory.init()
+        # check successive updates (with intersection)
+        self.host.memory.updateParams(self._getParamXML('1'))
+        self.assertParamExists("1")
+        self.assertParamNotExists("2")
+        self.host.memory.updateParams(self._getParamXML('both'))
+        self.assertParamExists("1")
+        self.assertParamExists("2")
+
+        # successive updates with or without intersection should have the same result
+        self.assertEqual(previous.toxml().encode("utf-8"), self.host.memory.params.dom.toxml().encode("utf-8"))
+
     def test_getParams(self):
         # tests with no security level on the parameter (most secure)
         params = self._getParamXML()
@@ -155,6 +186,7 @@
         self.host.memory.init()
         register(params, 1, Const.APP_NAME)
         self.assertParamNotExists()
+
         # tests with security level 0 on the parameter (not secure)
         params = self._getParamXML(security_level=0)
         self.host.memory.init()
@@ -166,6 +198,7 @@
         self.host.memory.init()
         register(params, 1, Const.APP_NAME)
         self.assertParamExists()
+
         # tests with security level 1 on the parameter (more secure)
         params = self._getParamXML(security_level=1)
         self.host.memory.init()