diff --git a/src/rougail/annotator.py b/src/rougail/annotator.py
index d374d4e6..fd962c5b 100644
--- a/src/rougail/annotator.py
+++ b/src/rougail/annotator.py
@@ -10,8 +10,9 @@ import imp
 
 from .i18n import _
 from .utils import normalize_family
-from .error import CreoleDictConsistencyError
+from .error import DictConsistencyError
 from .xmlreflector import HIGH_COMPATIBILITY
+from .config import variable_namespace
 
 #mode order is important
 modes_level = ('basic', 'normal', 'expert')
@@ -64,8 +65,6 @@ CONVERSION = {'number': int}
 
 FREEZE_AUTOFREEZE_VARIABLE = 'module_instancie'
 
-VARIABLE_NAMESPACE = 'rougail'
-
 
 class ServiceAnnotator:
     """Manage service's object
@@ -215,9 +214,11 @@ class ServiceAnnotator:
         variable.type = type_
         if type_ == 'symlink':
             variable.opt = value
+            variable.multi = None
         else:
             variable.doc = key
             val = self.objectspace.value()
+            val.type = type_
             val.name = value
             variable.value = [val]
         self.paths.add_variable('services',
@@ -274,7 +275,7 @@ class ServiceAnnotator:
             if not hasattr(file_, 'source'):
                 file_.source = basename(file_.name)
         elif not hasattr(file_, 'source'):
-            raise CreoleDictConsistencyError(_('attribute source mandatory for file with variable name '
+            raise DictConsistencyError(_('attribute source mandatory for file with variable name '
                                                'for {}').format(file_.name))
 
 
@@ -330,7 +331,7 @@ class SpaceAnnotator(object):
                         for variable in fam2.variable:
                             if variable.type == 'symlink' and '.' not in variable.name:
                                 variable.opt = self.paths.get_variable_path(variable.opt,
-                                                                            VARIABLE_NAMESPACE,
+                                                                            variable_namespace,
                                                                             )
 
     def convert_helps(self):
@@ -359,7 +360,7 @@ class SpaceAnnotator(object):
                       ) -> None:
         # manage leader's variable
         if variable.multi is not True:
-            raise CreoleDictConsistencyError(_('the variable {} in a group must be multi').format(variable.name))
+            raise DictConsistencyError(_('the variable {} in a group must be multi').format(variable.name))
         leader_space.variable = []
         leader_space.name = leader_name
         leader_space.hidden = variable.hidden
@@ -400,7 +401,7 @@ class SpaceAnnotator(object):
                         leader_is_hidden: bool,
                         ) -> None:
         if variable.name != follower_names[0]:
-            raise CreoleDictConsistencyError(_('cannot found this follower {}').format(follower_names[0]))
+            raise DictConsistencyError(_('cannot found this follower {}').format(follower_names[0]))
         follower_names.remove(variable.name)
         if leader_is_hidden:
             variable.frozen = True
@@ -456,7 +457,7 @@ class SpaceAnnotator(object):
                                                                   )
                             has_a_leader = True
                 else:
-                    raise CreoleDictConsistencyError(_('cannot found followers {}').format(follower_names))
+                    raise DictConsistencyError(_('cannot found followers {}').format(follower_names))
             del self.space.constraints.group
 
     def remove_empty_families(self):  # pylint: disable=C0111,R0201
@@ -531,6 +532,10 @@ class SpaceAnnotator(object):
                                 variable.type = 'string'
                             if variable.type != 'symlink' and not hasattr(variable, 'description'):
                                 variable.description = variable.name
+                            if hasattr(variable, 'value'):
+                                for value in variable.value:
+                                    if not hasattr(value, 'type'):
+                                        value.type = variable.type
 
     def convert_auto_freeze(self):  # pylint: disable=C0111
         if hasattr(self.space, 'variables'):
@@ -549,7 +554,7 @@ class SpaceAnnotator(object):
                                     new_condition.param = [new_param]
                                     new_target = self.objectspace.target()
                                     new_target.type = 'variable'
-                                    if variables.name == VARIABLE_NAMESPACE:
+                                    if variables.name == variable_namespace:
                                         path = variable.name
                                     else:
                                         path = variable.namespace + '.' + family.name + '.' + variable.name
@@ -571,12 +576,12 @@ class SpaceAnnotator(object):
                 else:
                     choice.name = str(value)
             except:
-                raise CreoleDictConsistencyError(_(f'unable to change type of a valid_enum entry "{value}" is not a valid "{type_}" for "{variable.name}"'))
+                raise DictConsistencyError(_(f'unable to change type of a valid_enum entry "{value}" is not a valid "{type_}" for "{variable.name}"'))
             choices.append(choice.name)
             choice.type = type_
             variable.choice.append(choice)
         if not variable.choice:
-            raise CreoleDictConsistencyError(_('empty valid enum is not allowed for variable {}').format(variable.name))
+            raise DictConsistencyError(_('empty valid enum is not allowed for variable {}').format(variable.name))
         if hasattr(variable, 'value'):
             for value in variable.value:
                 value.type = type_
@@ -585,7 +590,7 @@ class SpaceAnnotator(object):
                 else:
                     cvalue = value.name
                 if cvalue not in choices:
-                    raise CreoleDictConsistencyError(_('value "{}" of variable "{}" is not in list of all expected values ({})').format(value.name, variable.name, choices))
+                    raise DictConsistencyError(_('value "{}" of variable "{}" is not in list of all expected values ({})').format(value.name, variable.name, choices))
         else:
             new_value = self.objectspace.value()
             new_value.name = values[0]
@@ -596,7 +601,7 @@ class SpaceAnnotator(object):
     def _convert_valid_enum(self, variable, path):
         if variable.type in FORCE_CHOICE:
             if path in self.valid_enums:
-                raise CreoleDictConsistencyError(_('cannot set valid enum for variable with type {}').format(variable.type))
+                raise DictConsistencyError(_('cannot set valid enum for variable with type {}').format(variable.type))
             self._set_valid_enum(variable, FORCE_CHOICE[variable.type], 'string')
         if path in self.valid_enums:
             values = self.valid_enums[path]['values']
@@ -605,6 +610,7 @@ class SpaceAnnotator(object):
         if path in self.force_value:
             new_value = self.objectspace.value()
             new_value.name = self.force_value[path]
+            new_value.type = variable.type
             variable.value = [new_value]
             del self.force_value[path]
 
@@ -626,7 +632,7 @@ class SpaceAnnotator(object):
                                 self._convert_valid_enum(variable, path)
         # valid_enums must be empty now (all information are store in objects)
         if self.valid_enums:
-            raise CreoleDictConsistencyError(_('valid_enum sets for unknown variables {}').format(self.valid_enums.keys()))
+            raise DictConsistencyError(_('valid_enum sets for unknown variables {}').format(self.valid_enums.keys()))
 
     def change_variable_mode(self):  # pylint: disable=C0111
         if not hasattr(self.space, 'variables'):
@@ -642,11 +648,11 @@ class SpaceAnnotator(object):
                                 mode = modes_level[-1]
                                 for follower in variable.variable:
                                     if follower.auto_save is True:
-                                        raise CreoleDictConsistencyError(_('leader/followers {} '
+                                        raise DictConsistencyError(_('leader/followers {} '
                                                                            'could not be '
                                                                            'auto_save').format(follower.name))
                                     if follower.auto_freeze is True:
-                                        raise CreoleDictConsistencyError(_('leader/followers {} '
+                                        raise DictConsistencyError(_('leader/followers {} '
                                                                            'could not be '
                                                                            'auto_freeze').format(follower.name))
                                     if HIGH_COMPATIBILITY and variable.name != follower.name:  # and variable.variable[0].mode != modes_level[0]:
@@ -682,11 +688,11 @@ class SpaceAnnotator(object):
             fill = fills[idx]
             # test if it's redefined calculation
             if fill.target in targets and not fill.redefine:
-                raise CreoleDictConsistencyError(_(f"A fill already exists for the target: {fill.target}"))
+                raise DictConsistencyError(_(f"A fill already exists for the target: {fill.target}"))
             targets.append(fill.target)
             #
             if not fill.name in eosfunc:
-                raise CreoleDictConsistencyError(_('cannot find fill function {}').format(fill.name))
+                raise DictConsistencyError(_('cannot find fill function {}').format(fill.name))
 
             namespace = fill.namespace
             # let's replace the target by the path
@@ -700,9 +706,9 @@ class SpaceAnnotator(object):
                 param_to_delete = []
                 for fill_idx, param in enumerate(fill.param):
                     if param.type not in TYPE_PARAM_FILL:
-                        raise CreoleDictConsistencyError(_(f'cannot use {param.type} type as a param in a fill/auto'))
+                        raise DictConsistencyError(_(f'cannot use {param.type} type as a param in a fill/auto'))
                     if param.type != 'string' and not hasattr(param, 'text'):
-                        raise CreoleDictConsistencyError(_(f"All '{param.type}' variables shall have a value in order to calculate {fill.target}"))
+                        raise DictConsistencyError(_(f"All '{param.type}' variables shall have a value in order to calculate {fill.target}"))
                     if param.type == 'variable':
                         try:
                             param.text, suffix = self.paths.get_variable_path(param.text,
@@ -710,14 +716,13 @@ class SpaceAnnotator(object):
                                                                               with_suffix=True)
                             if suffix:
                                 param.suffix = suffix
-                        except CreoleDictConsistencyError as err:
+                        except DictConsistencyError as err:
                             if param.optional is False:
                                 raise err
                             param_to_delete.append(fill_idx)
                             continue
-                    if param.hidden is True:
-                        param.transitive = False
-                    param.hidden = None
+                    else:
+                        param.notraisepropertyerror = None
                 param_to_delete.sort(reverse=True)
                 for param_idx in param_to_delete:
                     fill.param.pop(param_idx)
@@ -739,27 +744,27 @@ class SpaceAnnotator(object):
                         subpath = self.paths.get_variable_path(separator.name,
                                                                separator.namespace,
                                                                )
-                        raise CreoleDictConsistencyError(_('{} already has a separator').format(subpath))
+                        raise DictConsistencyError(_('{} already has a separator').format(subpath))
                     option.separator = separator.text
             del family.separators
 
     def load_params_in_validenum(self, param):
         if param.type in ['string', 'python', 'number']:
             if not hasattr(param, 'text') and (param.type == 'python' or param.type == 'number'):
-                raise CreoleDictConsistencyError(_("All '{}' variables shall be set in order to calculate {}").format(param.type, 'valid_enum'))
+                raise DictConsistencyError(_("All '{}' variables shall be set in order to calculate {}").format(param.type, 'valid_enum'))
             if param.type in ['string', 'number']:
                 try:
                     values = literal_eval(param.text)
                 except ValueError:
-                    raise CreoleDictConsistencyError(_('Cannot load {}').format(param.text))
+                    raise DictConsistencyError(_('Cannot load {}').format(param.text))
             elif param.type == 'python':
                 try:
                     #values = eval(param.text, {'eosfunc': self.eosfunc, '__builtins__': {'range': range, 'str': str}})
                     values = eval(param.text, {'eosfunc': self.eosfunc, '__builtins__': {'range': range, 'str': str}})
                 except NameError:
-                    raise CreoleDictConsistencyError(_('The function {} is unknown').format(param.text))
+                    raise DictConsistencyError(_('The function {} is unknown').format(param.text))
             if not isinstance(values, list):
-                raise CreoleDictConsistencyError(_('Function {} shall return a list').format(param.text))
+                raise DictConsistencyError(_('Function {} shall return a list').format(param.text))
             new_values = []
             for val in values:
                 new_values.append(val)
@@ -774,17 +779,19 @@ class SpaceAnnotator(object):
         functions.extend(['valid_enum', 'valid_in_network', 'valid_differ'])
         for check_idx, check in enumerate(self.space.constraints.check):
             if not check.name in functions:
-                raise CreoleDictConsistencyError(_('cannot find check function {}').format(check.name))
+                raise DictConsistencyError(_('cannot find check function {}').format(check.name))
             if hasattr(check, 'param'):
                 param_option_indexes = []
                 for idx, param in enumerate(check.param):
                     if param.type not in TYPE_PARAM_CHECK:
-                        raise CreoleDictConsistencyError(_('cannot use {} type as a param in check for {}').format(param.type, check.target))
+                        raise DictConsistencyError(_('cannot use {} type as a param in check for {}').format(param.type, check.target))
                     if param.type == 'variable' and not self.paths.path_is_defined(param.text):
                         if param.optional is True:
                             param_option_indexes.append(idx)
                         else:
-                            raise CreoleDictConsistencyError(_(f'unknown param {param.text} in check'))
+                            raise DictConsistencyError(_(f'unknown param {param.text} in check'))
+                    if param.type != 'variable':
+                        param.notraisepropertyerror = None
                 param_option_indexes = list(set(param_option_indexes))
                 param_option_indexes.sort(reverse=True)
                 for idx in param_option_indexes:
@@ -818,27 +825,27 @@ class SpaceAnnotator(object):
                             proposed_value_type = self.objectspace.convert_boolean(param.text) == False
                             remove_params.append(param_idx)
                         except TypeError as err:
-                            raise CreoleDictConsistencyError(_('cannot load checkval value for variable {}: {}').format(check.target, err))
+                            raise DictConsistencyError(_('cannot load checkval value for variable {}: {}').format(check.target, err))
                         if proposed_value_type:
                             # no more supported
-                            raise CreoleDictConsistencyError(_('cannot load checkval value for variable {}, no more supported').format(check.target))
+                            raise DictConsistencyError(_('cannot load checkval value for variable {}, no more supported').format(check.target))
                 remove_params.sort(reverse=True)
                 for param_idx in remove_params:
                     del check.param[param_idx]
                 if len(check.param) != 1:
-                    raise CreoleDictConsistencyError(_('cannot set more than one param '
+                    raise DictConsistencyError(_('cannot set more than one param '
                                                        'for valid_enum for variable {}'
                                                        '').format(check.target))
                 param = check.param[0]
                 if check.target in self.valid_enums:
-                    raise CreoleDictConsistencyError(_('valid_enum already set for {}'
+                    raise DictConsistencyError(_('valid_enum already set for {}'
                                                        '').format(check.target))
                 if proposed_value_type:
                     if param.type == 'variable':
                         try:
                             values = self.load_params_in_validenum(param)
                         except NameError as err:
-                            raise CreoleDictConsistencyError(_('cannot load value for variable {}: {}').format(check.target, err))
+                            raise DictConsistencyError(_('cannot load value for variable {}: {}').format(check.target, err))
                         add_default_value = not check.is_in_leadership
                         if add_default_value and values:
                             self.force_value[check.target] = values[0]
@@ -852,18 +859,13 @@ class SpaceAnnotator(object):
             del self.space.constraints.check[idx]
 
     def check_change_warning(self):
-        #convert level to "warnings_only" and hidden to "transitive"
+        #convert level to "warnings_only"
         for check in self.space.constraints.check:
             if check.level == 'warning':
                 check.warnings_only = True
             else:
                 check.warnings_only = False
             check.level = None
-            if hasattr(check, 'param'):
-                for param in check.param:
-                    if not param.hidden is True:
-                        check.transitive = False
-                    param.hidden = None
 
     def filter_check(self):  # pylint: disable=C0111
         # valid param in check
@@ -889,20 +891,20 @@ class SpaceAnnotator(object):
             elif name == 'valid_network_netmask':
                 params_len = 1
                 if len(check.param) != params_len:
-                    raise CreoleDictConsistencyError(_('{} must have {} param').format(name, params_len))
+                    raise DictConsistencyError(_('{} must have {} param').format(name, params_len))
             elif name == 'valid_ipnetmask':
                 params_len = 1
                 if len(check.param) != params_len:
-                    raise CreoleDictConsistencyError(_('{} must have {} param').format(name, params_len))
+                    raise DictConsistencyError(_('{} must have {} param').format(name, params_len))
                 name = 'valid_ip_netmask'
             elif name == 'valid_broadcast':
                 params_len = 2
                 if len(check.param) != params_len:
-                    raise CreoleDictConsistencyError(_('{} must have {} param').format(name, params_len))
+                    raise DictConsistencyError(_('{} must have {} param').format(name, params_len))
             elif name == 'valid_in_network':
                 params_len = 2
                 if len(check.param) != params_len:
-                    raise CreoleDictConsistencyError(_('{} must have {} param').format(name, params_len))
+                    raise DictConsistencyError(_('{} must have {} param').format(name, params_len))
             check_.name = name
             check_.warnings_only = check.warnings_only
             if hasattr(check, 'param'):
@@ -918,13 +920,13 @@ class SpaceAnnotator(object):
             for idx, target in enumerate(condition.target):
                 if target.type == 'variable':
                     if condition.source == target.name:
-                        raise CreoleDictConsistencyError(_('target name and source name must be different: {}').format(condition.source))
+                        raise DictConsistencyError(_('target name and source name must be different: {}').format(condition.source))
                     target.name = self.paths.get_variable_path(target.name, namespace)
                 elif target.type == 'family':
                     try:
                         target.name = self.paths.get_family_path(target.name, namespace)
                     except KeyError:
-                        raise CreoleDictConsistencyError(_('cannot found family {}').format(target.name))
+                        raise DictConsistencyError(_('cannot found family {}').format(target.name))
 
     def convert_xxxlist_to_variable(self):  # pylint: disable=C0111
         # transform *list to variable or family
@@ -958,21 +960,21 @@ class SpaceAnnotator(object):
         for condition in self.space.constraints.condition:
             if condition.name not in ['disabled_if_in', 'disabled_if_not_in', 'hidden_if_in', 'auto_hidden_if_not_in',
                                       'hidden_if_not_in', 'mandatory_if_in', 'mandatory_if_not_in']:
-                raise CreoleDictConsistencyError(_(f'unknown condition {condition.name}'))
+                raise DictConsistencyError(_(f'unknown condition {condition.name}'))
 
     def check_params(self):
         for condition in self.space.constraints.condition:
             for param in condition.param:
                 if param.type not in TYPE_PARAM_CONDITION:
-                    raise CreoleDictConsistencyError(_(f'cannot use {param.type} type as a param in a condition'))
+                    raise DictConsistencyError(_(f'cannot use {param.type} type as a param in a condition'))
 
     def check_target(self):
         for condition in self.space.constraints.condition:
             if not hasattr(condition, 'target'):
-                raise CreoleDictConsistencyError(_('target is mandatory in condition'))
+                raise DictConsistencyError(_('target is mandatory in condition'))
             for target in condition.target:
                 if target.type.endswith('list') and condition.name not in ['disabled_if_in', 'disabled_if_not_in']:
-                    raise CreoleDictConsistencyError(_(f'target in condition for {target.type} not allow in {condition.name}'))
+                    raise DictConsistencyError(_(f'target in condition for {target.type} not allow in {condition.name}'))
 
     def check_condition_fallback_optional(self):
         # a condition with a fallback **and** the source variable doesn't exist
@@ -982,7 +984,7 @@ class SpaceAnnotator(object):
             if condition.fallback is True and not self.paths.path_is_defined(condition.source):
                 for target in condition.target:
                     if target.type in ['variable', 'family']:
-                        if target.name.startswith(VARIABLE_NAMESPACE + '.'):
+                        if target.name.startswith(variable_namespace + '.'):
                             name = target.name.split('.')[-1]
                         else:
                             name = target.name
@@ -1043,7 +1045,7 @@ class SpaceAnnotator(object):
                 if condition.param == []:
                     remove_targets = []
                     for target in condition.target:
-                        if target.name.startswith(f'{VARIABLE_NAMESPACE}.'):
+                        if target.name.startswith(f'{variable_namespace}.'):
                             name = target.name.split('.')[-1]
                         else:
                             name = target.name
@@ -1071,7 +1073,7 @@ class SpaceAnnotator(object):
         for condition in self.space.constraints.condition:
             #parse each variable and family
             for target_idx, target in enumerate(condition.target):
-                if target.name.startswith(f'{VARIABLE_NAMESPACE}.'):
+                if target.name.startswith(f'{variable_namespace}.'):
                     name = target.name.split('.')[-1]
                 else:
                     name = target.name
@@ -1127,7 +1129,7 @@ class SpaceAnnotator(object):
                 else:
                     param = None
                 for target in condition.target:
-                    if target.name.startswith(f'{VARIABLE_NAMESPACE}.'):
+                    if target.name.startswith(f'{variable_namespace}.'):
                         name = target.name.split('.')[-1]
                     else:
                         name = target.name
diff --git a/src/rougail/config.py b/src/rougail/config.py
index b6a58621..671693d7 100644
--- a/src/rougail/config.py
+++ b/src/rougail/config.py
@@ -15,3 +15,5 @@ dtdfilename = join(dtddir, 'rougail.dtd')
 
 # chemin du répertoire source des fichiers templates
 patch_dir = '/srv/rougail/patch'
+
+variable_namespace = 'rougail'
diff --git a/src/rougail/data/rougail.dtd b/src/rougail/data/rougail.dtd
index ee609232..1f50c910 100644
--- a/src/rougail/data/rougail.dtd
+++ b/src/rougail/data/rougail.dtd
@@ -140,7 +140,7 @@
 <!ELEMENT param (#PCDATA)>
 <!ATTLIST param type (string|variable|number|python) "string">
 <!ATTLIST param name CDATA #IMPLIED>
-<!ATTLIST param hidden (True|False) "True">
+<!ATTLIST param notraisepropertyerror (True|False) "False">
 <!ATTLIST param optional (True|False) "False">
 
 <!ELEMENT target (#PCDATA)>
diff --git a/src/rougail/error.py b/src/rougail/error.py
index f9f06150..221e355f 100644
--- a/src/rougail/error.py
+++ b/src/rougail/error.py
@@ -1,9 +1,4 @@
 # -*- coding: utf-8 -*-
-"""
-Erreurs Creole
-"""
-
-
 class ConfigError(Exception):
     pass
 
@@ -19,7 +14,7 @@ class TemplateDisabled(TemplateError):
     pass
 
 
-class CreoleOperationError(Exception):
+class OperationError(Exception):
     """Type error or value Error for Creole variable's type or values
     """
 
@@ -30,11 +25,11 @@ class SpaceObjShallNotBeUpdated(Exception):
     """
 
 
-class CreoleDictConsistencyError(Exception):
+class DictConsistencyError(Exception):
     """It's not only that the Creole XML is valid against the Creole DTD
     it's that it is not consistent.
     """
 
 
-class CreoleLoaderError(Exception):
+class LoaderError(Exception):
     pass
diff --git a/src/rougail/loader.py b/src/rougail/loader.py
index 50ffe570..742c16ab 100644
--- a/src/rougail/loader.py
+++ b/src/rougail/loader.py
@@ -1,33 +1,16 @@
 """loader
 flattened XML specific
 """
-from os.path import join, isfile
+from os.path import isfile
 from lxml.etree import DTD
-import imp
 
-from tiramisu import (StrOption, OptionDescription, DynOptionDescription, PortOption,
-                      IntOption, ChoiceOption, BoolOption, SymLinkOption, IPOption,
-                      NetworkOption, NetmaskOption, DomainnameOption, BroadcastOption,
-                      URLOption, EmailOption, FilenameOption, UsernameOption, DateOption,
-                      PasswordOption, BoolOption, MACOption, Leadership, submulti,
-                      Params, ParamSelfOption, ParamOption, ParamDynOption, ParamValue, Calculation, calc_value)
-
-from .config import dtdfilename
+from .config import dtdfilename, variable_namespace
 from .i18n import _
-from .utils import normalize_family
-from .annotator import VARIABLE_NAMESPACE
-from .error import CreoleLoaderError
+from .error import LoaderError
 
 
 FUNC_TO_DICT = ['valid_not_equal']
-
-
-class ConvertDynOptionDescription(DynOptionDescription):
-    def convert_suffix_to_path(self, suffix):
-        if not isinstance(suffix, str):
-            suffix = str(suffix)
-        return normalize_family(suffix,
-                                check_name=False)
+FORCE_INFORMATIONS = ['help', 'test', 'separator']
 
 
 def convert_boolean(value):
@@ -54,90 +37,71 @@ def convert_tiramisu_value(value, type_):
         return func(value)
 
 
-CONVERT_OPTION = {'number': dict(opttype=IntOption, func=int),
-                  'choice': dict(opttype=ChoiceOption),
-                  'string': dict(opttype=StrOption),
-                  'password': dict(opttype=PasswordOption),
-                  'mail': dict(opttype=EmailOption),
-                  'boolean': dict(opttype=BoolOption, initkwargs={'default': True}, func=convert_boolean),
-                  'symlink': dict(opttype=SymLinkOption),
-                  'filename': dict(opttype=FilenameOption),
-                  'date': dict(opttype=DateOption),
-                  'unix_user': dict(opttype=UsernameOption),
-                  'ip': dict(opttype=IPOption, initkwargs={'allow_reserved': True}),
-                  'local_ip': dict(opttype=IPOption, initkwargs={'private_only': True, 'warnings_only': True}),
-                  'netmask': dict(opttype=NetmaskOption),
-                  'network': dict(opttype=NetworkOption),
-                  'broadcast': dict(opttype=BroadcastOption),
-                  'netbios': dict(opttype=DomainnameOption, initkwargs={'type': 'netbios', 'warnings_only': True}),
-                  'domain': dict(opttype=DomainnameOption, initkwargs={'type': 'domainname', 'allow_ip': True, 'allow_without_dot': True}),
-                  'domain_strict': dict(opttype=DomainnameOption, initkwargs={'type': 'domainname', 'allow_ip': False}),
-                  'hostname': dict(opttype=DomainnameOption, initkwargs={'type': 'hostname', 'allow_ip': True}),
-                  'hostname_strict': dict(opttype=DomainnameOption, initkwargs={'type': 'hostname', 'allow_ip': False}),
-                  'web_address': dict(opttype=URLOption, initkwargs={'allow_ip': True, 'allow_without_dot': True}),
-                  'port': dict(opttype=PortOption, initkwargs={'allow_private': True}),
-                  'mac': dict(opttype=MACOption),
-                  'cidr': dict(opttype=IPOption, initkwargs={'cidr': True}),
-                  'network_cidr': dict(opttype=NetworkOption, initkwargs={'cidr': True}),
+CONVERT_OPTION = {'number': dict(opttype="IntOption", func=int),
+                  'choice': dict(opttype="ChoiceOption"),
+                  'string': dict(opttype="StrOption"),
+                  'password': dict(opttype="PasswordOption"),
+                  'mail': dict(opttype="EmailOption"),
+                  'boolean': dict(opttype="BoolOption", initkwargs={'default': [True]}, func=convert_boolean),
+                  'symlink': dict(opttype="SymLinkOption"),
+                  'filename': dict(opttype="FilenameOption"),
+                  'date': dict(opttype="DateOption"),
+                  'unix_user': dict(opttype="UsernameOption"),
+                  'ip': dict(opttype="IPOption", initkwargs={'allow_reserved': True}),
+                  'local_ip': dict(opttype="IPOption", initkwargs={'private_only': True, 'warnings_only': True}),
+                  'netmask': dict(opttype="NetmaskOption"),
+                  'network': dict(opttype="NetworkOption"),
+                  'broadcast': dict(opttype="BroadcastOption"),
+                  'netbios': dict(opttype="DomainnameOption", initkwargs={'type': 'netbios', 'warnings_only': True}),
+                  'domain': dict(opttype="DomainnameOption", initkwargs={'type': 'domainname', 'allow_ip': True, 'allow_without_dot': True}),
+                  'domain_strict': dict(opttype="DomainnameOption", initkwargs={'type': 'domainname', 'allow_ip': False}),
+                  'hostname': dict(opttype="DomainnameOption", initkwargs={'type': 'hostname', 'allow_ip': True}),
+                  'hostname_strict': dict(opttype="DomainnameOption", initkwargs={'type': 'hostname', 'allow_ip': False}),
+                  'web_address': dict(opttype="URLOption", initkwargs={'allow_ip': True, 'allow_without_dot': True}),
+                  'port': dict(opttype="PortOption", initkwargs={'allow_private': True}),
+                  'mac': dict(opttype="MACOption"),
+                  'cidr': dict(opttype="IPOption", initkwargs={'cidr': True}),
+                  'network_cidr': dict(opttype="NetworkOption", initkwargs={'cidr': True}),
                   }
 
 
-class BaseElt:
-    def __init__(self, attrib):
-        self.attrib = attrib
-
-
-class Common:
-    def populate_properties(self, child):
-        if child.get('type') == 'calculation':
-            kwargs = {'condition': child.attrib['source'],
-                      'expected':  ParamValue(child.attrib.get('expected'))}
-            if child.attrib['inverse'] == 'True':
-                kwargs['reverse_condition'] = ParamValue(True)
-            self.attrib['properties'].append((ParamValue(child.text), kwargs))
-        else:
-            self.attrib['properties'].append(child.text)
-
-    def build_properties(self):
-        for index, prop in enumerate(self.attrib['properties']):
-            if isinstance(prop, tuple):
-                action, kwargs = prop
-                kwargs['condition'] = ParamOption(self.storage.get(kwargs['condition']).get(), todict=True)
-                prop = Calculation(calc_value,
-                                   Params(action,
-                                          kwargs=kwargs))
-                self.attrib['properties'][index] = prop
-        if self.attrib['properties']:
-            self.attrib['properties'] = tuple(self.attrib['properties'])
-        else:
-            del self.attrib['properties']
-
-
 class PopulateTiramisuObjects:
-    def __init__(self):
-        self.storage = ElementStorage()
-        self.booleans = []
+    def __init__(self,
+                 xmlroot,
+                 funcs_path,
+                 ):
+        self.storage = ElementStorage(self.parse_dtd())
+        self.storage.text = ["from tiramisu import *",
+                             "from rougail.tiramisu import ConvertDynOptionDescription",
+                             "import imp",
+                             f"func = imp.load_source('func', '{funcs_path}')",
+                             ]
+        self.make_tiramisu_objects(xmlroot)
+        # parse object
+        self.storage.get('.').get()
 
-    def parse_dtd(self, dtdfilename):
-        """Loads the Creole DTD
+    def parse_dtd(self):
+        """Loads the DTD
 
         :raises IOError: if the DTD is not found
 
-        :param dtdfilename: the full filename of the Creole DTD
+        :param dtdfilename: the full filename of the DTD
         """
         if not isfile(dtdfilename):
             raise IOError(_("no such DTD file: {}").format(dtdfilename))
+        booleans = []
         with open(dtdfilename, 'r') as dtdfd:
             dtd = DTD(dtdfd)
             for elt in dtd.iterelements():
                 if elt.name == 'variable':
                     for attr in elt.iterattributes():
                         if set(attr.itervalues()) == set(['True', 'False']):
-                            self.booleans.append(attr.name)
-
-    def make_tiramisu_objects(self, xmlroot, eosfunc):
-        self.eosfunc = imp.load_source('eosfunc', eosfunc)
+                            booleans.append(attr.name)
+        return booleans
 
+    def make_tiramisu_objects(self,
+                              xmlroot,
+                              ):
         family = self.get_root_family()
         for xmlelt in self.reorder_family(xmlroot):
             self.iter_family(xmlelt,
@@ -148,19 +112,18 @@ class PopulateTiramisuObjects:
     def get_root_family(self):
         family = Family(BaseElt({'name': 'baseoption',
                                  'doc': 'baseoption'}),
-                        self.booleans,
                         self.storage,
-                        self.eosfunc,
+                        False,
+                        '.',
                         )
-        self.storage.add('.', family)
         return family
 
     def reorder_family(self, xmlroot):
         xmlelts = []
         for xmlelt in xmlroot:
-            # VARIABLE_NAMESPACE family has to be loaded before any other family
-            # because `extra` family could use `VARIABLE_NAMESPACE` variables.
-            if xmlelt.attrib['name'] == VARIABLE_NAMESPACE:
+            # variable_namespace family has to be loaded before any other family
+            # because `extra` family could use `variable_namespace` variables.
+            if xmlelt.attrib['name'] == variable_namespace:
                 xmlelts.insert(0, xmlelt)
             else:
                 xmlelts.append(xmlelt)
@@ -194,12 +157,10 @@ class PopulateTiramisuObjects:
                                elt,
                                )
         family = Family(elt,
-                        self.booleans,
                         self.storage,
-                        self.eosfunc,
                         elt.tag == 'leader',
+                        path,
                         )
-        self.storage.add(path, family)
         parent_family.add(family)
         if len(elt) != 0:
             for child in elt:
@@ -216,22 +177,18 @@ class PopulateTiramisuObjects:
         is_follower = False
         is_leader = False
         if family.is_leader:
-            if elt.attrib['name'] != family.attrib['name']:
+            if elt.attrib['name'] != family.elt.attrib['name']:
                 is_follower = True
             else:
                 is_leader = True
-        path = self.build_path(subpath,
-                               elt,
-                               )
-        variable = Variable(elt,
-                            self.booleans,
+        family.add(Variable(elt,
                             self.storage,
                             is_follower,
                             is_leader,
-                            self.eosfunc,
-                            )
-        self.storage.add(path, variable)
-        family.add(variable)
+                            self.build_path(subpath,
+                                            elt,
+                                            )
+                            ))
 
     def build_path(self,
                    subpath,
@@ -241,306 +198,299 @@ class PopulateTiramisuObjects:
             return elt.attrib['name']
         return subpath + '.' + elt.attrib['name']
 
+    def get_text(self):
+        return '\n'.join(self.storage.get('.').get_text())
+
+
+class BaseElt:
+    def __init__(self, attrib):
+        self.attrib = attrib
+
+    def __iter__(self):
+        return iter([])
+
 
 class ElementStorage:
-    def __init__(self):
+    def __init__(self,
+                 booleans,
+                 ):
         self.paths = {}
+        self.text = []
+        self.index = 0
+        self.booleans = booleans
 
     def add(self, path, elt):
-        if path in self.paths:
-            raise CreoleLoaderError(_('path already loaded {}').format(path))
-        self.paths[path] = elt
+        self.paths[path] = (elt, self.index)
+        self.index += 1
 
     def get(self, path):
+        if path not in self.paths or self.paths[path][0] is None:
+            raise LoaderError(_('there is no element for path {}').format(path))
+        return self.paths[path][0]
+
+    def get_name(self, path):
         if path not in self.paths:
-            raise CreoleLoaderError(_('there is no element for path {}').format(path))
-        return self.paths[path]
+            raise LoaderError(_('there is no element for index {}').format(path))
+        return f'option_{self.paths[path][1]}'
+
+
+class Common:
+    def __init__(self,
+                 elt,
+                 storage,
+                 is_leader,
+                 path,
+                 ):
+        self.option_name = None
+        self.path = path
+        self.attrib = {}
+        self.informations = {}
+        self.storage = storage
+        self.is_leader = is_leader
+        self.storage.add(self.path, self)
+
+    def populate_properties(self, child):
+        if child.get('type') == 'calculation':
+            action = f"ParamValue('{child.text}')"
+            option_name = self.storage.get(child.attrib['source']).get()
+            kwargs = f"'condition': ParamOption({option_name}, todict=True), 'expected': ParamValue('{child.attrib.get('expected')}')"
+            if child.attrib['inverse'] == 'True':
+                kwargs += ", 'reverse_condition': ParamValue(True)"
+            prop = 'Calculation(calc_value, Params(' + action + ', kwargs={' + kwargs + '}))'
+        else:
+            prop = "'" + child.text + "'"
+        if self.attrib['properties']:
+            self.attrib['properties'] += ', '
+        self.attrib['properties'] += prop
+        if not self.attrib['properties']:
+            del self.attrib['properties']
+
+    def get_attrib(self, attrib):
+        ret_list = []
+        for key, value in self.attrib.items():
+            if key == 'properties':
+                value = 'frozenset([' + self.attrib[key] + '])'
+            elif key in ['default', 'multi', 'suffixes', 'validators']:
+                value = self.attrib[key]
+            elif isinstance(value, str) and key != 'opt' and not value.startswith('['):
+                value = "'" + value.replace("'", "\\\'") + "'"
+            ret_list.append(f'{key}={value}')
+        return ', '.join(ret_list)
+
+    def populate_informations(self):
+        for key, value in self.informations.items():
+            value = value.replace('"', '\"')
+            self.storage.text.append(f'{self.option_name}.impl_set_information("{key}", "{value}")')
+
+    def get_text(self,
+                 ):
+        return self.storage.text
 
 
 class Variable(Common):
-    def __init__(self, elt, booleans, storage, is_follower, is_leader, eosfunc):
-        self.option = None
-        self.informations = {}
-        self.attrib = {}
-        convert_option = CONVERT_OPTION[elt.attrib['type']]
-        if 'initkwargs' in convert_option:
-            self.attrib.update(convert_option['initkwargs'])
-        if elt.attrib['type'] != 'symlink':
-            self.attrib['properties'] = []
-        self.attrib['validators'] = []
-        self.eosfunc = eosfunc
-        self.storage = storage
-        self.booleans = booleans
-        self.populate_attrib(elt)
+    def __init__(self,
+                 elt,
+                 storage,
+                 is_follower,
+                 is_leader,
+                 path,
+                 ):
+        super().__init__(elt,
+                         storage,
+                         is_leader,
+                         path,
+                         )
         self.is_follower = is_follower
-        self.is_leader = is_leader
+        convert_option = CONVERT_OPTION[elt.attrib['type']]
+        del elt.attrib['type']
         self.object_type = convert_option['opttype']
-        if 'multi' in self.attrib and self.attrib['multi']:
-            self.attrib['default'] = []
-            if self.is_follower:
-                self.attrib['default_multi'] = []
-        self.parse_children(elt)
-        if self.is_follower:
-            if self.attrib['multi'] is True:
-                self.attrib['multi'] = submulti
-            else:
-                self.attrib['multi'] = True
-        if elt.attrib['type'] == 'symlink':
-            self.attrib['opt'] = storage.get(self.attrib['opt'])
+        self.attrib.update(convert_option.get('initkwargs', {}))
+        if self.object_type != 'SymLinkOption':
+            self.attrib['properties'] = ''
+            self.attrib['validators'] = []
+        self.elt = elt
 
-    def parse_children(self,
-                       elt,
-                       ):
-        if elt.attrib['type'] == 'choice':
-            values = []
-        for child in elt:
+    def get(self):
+        if self.option_name is None:
+            self.populate_attrib()
+            if self.object_type == 'SymLinkOption':
+                self.attrib['opt'] = self.storage.get(self.attrib['opt']).get()
+            else:
+                self.parse_multi()
+                self.parse_children()
+            attrib = self.get_attrib(self.attrib)
+            self.option_name = self.storage.get_name(self.path)
+            self.storage.text.append(f'{self.option_name} = {self.object_type}({attrib})')
+            self.populate_informations()
+        return self.option_name
+
+    def populate_attrib(self):
+        for key, value in self.elt.attrib.items():
+            if key in self.storage.booleans:
+                value = convert_boolean(value)
+            if key in FORCE_INFORMATIONS:
+                self.informations[key] = value
+            else:
+                self.attrib[key] = value
+
+    def parse_children(self):
+        if not 'default' in self.attrib or self.attrib['multi']:
+            self.attrib['default'] = []
+        if self.attrib['multi'] == 'submulti' and self.is_follower:
+            self.attrib['default_multi'] = []
+        choices = []
+        for child in self.elt:
             if child.tag == 'property':
                 self.populate_properties(child)
             elif child.tag == 'value':
-                if child.attrib.get('type') == 'calculation':
-                    self.calc_value(child)
+                if child.attrib['type'] == 'calculation':
+                    self.attrib['default'] = self.calculation_value(child, [])
                 else:
-                    self.populate_value(child, elt)
+                    self.populate_value(child)
             elif child.tag == 'check':
-                self.populate_check(child)
+                self.attrib['validators'].append(self.calculation_value(child, ['ParamSelfOption()']))
             elif child.tag == 'choice':
-                value = child.text
-                if child.attrib['type'] == 'number':
-                    value = int(value)
-                values.append(value)
-        if elt.attrib['type'] == 'choice':
-            self.attrib['values'] = tuple(values)
-
-    def populate_attrib(self,
-                        elt,
-                        ):
-        for key, value in elt.attrib.items():
-            if key == 'multi' and elt.attrib['type'] == 'symlink':
-                continue
-            if key in self.booleans:
-                if value == 'True':
-                    value = True
-                elif value == 'False':
-                    value = False
-                else:
-                    raise CreoleLoaderError(_('unknown value {} for {}').format(value, key))
-            if key in ['help', 'test', 'separator']:
-                self.add_information(key, value)
-            elif key != 'type':
-                self.attrib[key] = value
-
-    def calc_value(self, child):
-        args = []
-        kwargs = {}
-        if child.text is not None and child.text.strip():
-            function = child.text.strip()
+                choices.append(convert_tiramisu_value(child.text, child.attrib['type']))
+        if choices:
+            self.attrib['values'] = tuple(choices)
+        if self.attrib['default'] == []:
+            del self.attrib['default']
+        elif not self.attrib['multi'] and isinstance(self.attrib['default'], list):
+            self.attrib['default'] = self.attrib['default'][-1]
+        if self.attrib['validators'] == []:
+            del self.attrib['validators']
         else:
-            function = child.attrib['name']
-            for param in child:
-                self.parse_param(args,
-                                 kwargs,
-                                 param,
-                                 )
-        self.attrib['default'] = {'function': getattr(self.eosfunc, function),
-                                  'args': args,
-                                  'kwargs': kwargs,
-                                  'warnings_only': False}
+            self.attrib['validators'] = '[' + ', '.join(self.attrib['validators']) + ']'
 
-    def populate_value(self, child, elt):
-        if "type" in child.attrib:
-            type_ = child.attrib['type']
-        else:
-            type_ = elt.attrib['type']
-        value = convert_tiramisu_value(child.text, type_)
+    def parse_multi(self):
         if self.is_follower:
             if self.attrib['multi'] is True:
-                self.attrib['default_multi'].append(value)
+                self.attrib['multi'] = 'submulti'
             else:
-                self.attrib['default_multi'] = value
-        elif self.attrib['multi'] is True:
-            self.attrib['default'].append(value)
-            if not self.is_leader:
-                self.attrib['default_multi'] = value
+                self.attrib['multi'] = True
+
+    def calculation_value(self, child, args):
+        kwargs = []
+        if 'name' in child.attrib:
+            # has parameters
+            function = child.attrib['name']
+            for param in child:
+                value = self.populate_param(param)
+                if 'name' not in param.attrib:
+                    args.append(str(value))
+                else:
+                    kwargs.append(f"'{param.attrib['name']}': " + value)
         else:
-            self.attrib['default'] = value
+            # function without any parameter
+            function = child.text.strip()
+        ret = f"Calculation(func.{function}, Params((" + ', '.join(args) + "), kwargs=" + "{" + ', '.join(kwargs) + "})"
+        if 'warnings_only' in child.attrib:
+            ret += f', warnings_only={child.attrib["warnings_only"]}'
+        return ret + ')'
 
-    def populate_check(self, child):
-        args = [ParamSelfOption()]
-        kwargs = {}
-        for param in child:
-            self.parse_param(args,
-                             kwargs,
-                             param,
-                             )
-        self.attrib['validators'].append({'function': getattr(self.eosfunc, child.attrib['name']),
-                                          'args': args,
-                                          'kwargs': kwargs,
-                                          'warnings_only': convert_boolean(child.attrib['warnings_only'])})
-
-    def parse_param(self,
-                    args,
-                    kwargs,
-                    param,
-                    ):
+    def populate_param(self,
+                       param,
+                       ):
         if param.attrib['type'] == 'string':
-            value = ParamValue(param.text)
+            return f'ParamValue("{param.text}")'
         elif param.attrib['type'] == 'number':
-            value = ParamValue(int(param.text))
+            return f'ParamValue({param.text})'
         elif param.attrib['type'] == 'variable':
-            transitive = convert_boolean(param.attrib.get('transitive', 'False'))
             value = {'option': param.text,
-                     'notraisepropertyerror': transitive,
+                     'notraisepropertyerror': convert_boolean(param.attrib['notraisepropertyerror']),
                      'todict': param.text in FUNC_TO_DICT,
                      }
             if 'suffix' in param.attrib:
                 value['suffix'] = param.attrib['suffix']
+            return self.build_param(value)
+        raise LoaderError(_('unknown param type {}').format(param.attrib['type']))
+
+    def populate_value(self,
+                       child,
+                       ):
+        value = convert_tiramisu_value(child.text, child.attrib['type'])
+        if self.attrib['multi'] == 'submulti':
+            self.attrib['default_multi'].append(value)
+        elif self.is_follower:
+            self.attrib['default_multi'] = value
+        elif self.attrib['multi']:
+            self.attrib['default'].append(value)
+            if not self.is_leader:
+                self.attrib['default_multi'] = value
+        elif isinstance(value, int):
+            self.attrib['default'].append(value)
         else:
-            raise CreoleLoaderError(_('unknown param type {}').format(param.attrib['type']))
-        if 'name' not in param.attrib:
-            args.append(value)
-        else:
-            kwargs[param.attrib['name']] = value
+            self.attrib['default'].append("'" + value + "'")
 
-    def build_calculator(self, key):
-        def build_param(param):
-            option = self.storage.get(param['option']).get()
-            if 'suffix' in param:
-                family = '.'.join(param['option'].split('.')[:-1])
-                return ParamDynOption(option,
-                                      param['suffix'],
-                                      self.storage.get(family).get(),
-                                      notraisepropertyerror=param['notraisepropertyerror'],
-                                      todict=param['todict'],
-                                      )
-            return ParamOption(option,
-                               notraisepropertyerror=param['notraisepropertyerror'],
-                               todict=param['todict'],
-                               )
-            return param
-        def build_calculation(value):
-            args = []
-            kwargs = {}
-            for param in value['args']:
-                if isinstance(param, dict):
-                    param = build_param(param)
-                args.append(param)
-            for key, param in value['kwargs'].items():
-                if isinstance(param, dict):
-                    param = build_param(param)
-                kwargs[key] = param
-            return Calculation(value['function'],
-                               Params(tuple(args),
-                                      kwargs=kwargs,
-                                      ),
-                               warnings_only=value['warnings_only'],
-                               )
-        if key in self.attrib:
-            values = self.attrib[key]
-            if isinstance(values, list):
-                self.attrib[key] = []
-                for value in values:
-                    if isinstance(value, dict):
-                        value = build_calculation(value)
-                    self.attrib[key].append(value)
-            else:
-                if isinstance(values, dict):
-                    values = build_calculation(values)
-                self.attrib[key] = values
-
-    def add_information(self, key, value):
-        if key in self.informations:
-            raise CreoleLoaderError(_('key already exists in information {}').format(key))
-        self.informations[key] = value
-
-    def get(self):
-        if self.option is None:
-            if self.object_type is SymLinkOption:
-                self.attrib['opt'] = self.attrib['opt'].get()
-            else:
-                self.build_properties()
-                self.build_calculator('default')
-                self.build_calculator('validators')
-            if not self.attrib['validators']:
-                del self.attrib['validators']
-            try:
-                option = self.object_type(**self.attrib)
-            except Exception as err:
-                import traceback
-                traceback.print_exc()
-                name = self.attrib['name']
-                raise CreoleLoaderError(_('cannot create option "{}": {}').format(name, err))
-            for key, value in self.informations.items():
-                option.impl_set_information(key, value)
-            self.option = option
-        return self.option
+    def build_param(self,
+                    param,
+                    ):
+        option_name = self.storage.get(param['option']).get()
+        if 'suffix' in param:
+            family = '.'.join(param['option'].split('.')[:-1])
+            family_option = self.storage.get_name(family)
+            return f"ParamDynOption({option_name}, '{param['suffix']}', {family_option}, notraisepropertyerror={param['notraisepropertyerror']}, todict={param['todict']})"
+        return f"ParamOption({option_name}, notraisepropertyerror={param['notraisepropertyerror']}, todict={param['todict']})"
 
 
 class Family(Common):
     def __init__(self,
                  elt,
-                 booleans,
                  storage,
-                 eosfunc,
-                 is_leader=False,
+                 is_leader,
+                 path,
                  ):
-        self.option = None
-        self.attrib = {}
-        self.is_leader = False
-        self.informations = {}
+        super().__init__(elt,
+                         storage,
+                         is_leader,
+                         path,
+                         )
         self.children = []
-        self.storage = storage
-        self.eosfunc = eosfunc
-        self.attrib['properties'] = []
-        for key, value in elt.attrib.items():
-            if key == 'help':
-                self.add_information(key, value)
-            else:
-                self.attrib[key] = value
-        if not isinstance(elt, BaseElt) and len(elt) != 0:
-            for child in elt:
-                if child.tag == 'property':
-                    self.populate_properties(child)
-        self.is_leader = is_leader
+        self.elt = elt
 
     def add(self, child):
         self.children.append(child)
 
-    def add_information(self, key, value):
-        if key in self.informations and not (key == 'icon' and self.informations[key] is None):
-            raise CreoleLoaderError(_('key already exists in information {}').format(key))
-        self.informations[key] = value
-
     def get(self):
-        if self.option is None:
-            self.attrib['children'] = []
-            for child in self.children:
-                self.attrib['children'].append(child.get())
-            self.build_properties()
-            try:
-                if 'dynamic' in self.attrib:
-                    dynamic = self.storage.get(self.attrib['dynamic']).get()
-                    del self.attrib['dynamic']
-                    self.attrib['suffixes'] = Calculation(self.eosfunc.calc_value,
-                                                          Params((ParamOption(dynamic),)))
-                    option = ConvertDynOptionDescription(**self.attrib)
-                elif not self.is_leader:
-                    option = OptionDescription(**self.attrib)
-                else:
-                    option = Leadership(**self.attrib)
-            except Exception as err:
-                print(self.attrib)
-                raise CreoleLoaderError(_('cannot create optiondescription "{}": {}').format(self.attrib['name'], err))
-            for key, value in self.informations.items():
-                option.impl_set_information(key, value)
-            self.option = option
-        return self.option
+        if not self.option_name:
+            self.populate_attrib()
+            self.parse_children()
+            self.option_name = self.storage.get_name(self.path)
+            object_name = self.get_object_name()
+            attrib = self.get_attrib(self.attrib) + ', children=[' + ', '.join([child.get() for child in self.children]) + ']'
+            self.storage.text.append(f'{self.option_name} = {object_name}({attrib})')
+            self.populate_informations()
+        return self.option_name
+
+    def populate_attrib(self):
+        for key, value in self.elt.attrib.items():
+            if key == 'help':
+                self.informations[key] = value
+            elif key == 'dynamic':
+                dynamic = self.storage.get(value).get()
+                self.attrib['suffixes'] = f"Calculation(func.calc_value, Params((ParamOption({dynamic}))))"
+            else:
+                self.attrib[key] = value
+
+    def parse_children(self):
+        self.attrib['properties'] = ''
+        for child in self.elt:
+            if child.tag == 'property':
+                self.populate_properties(child)
+        if not self.attrib['properties']:
+            del self.attrib['properties']
+
+    def get_object_name(self):
+        if 'suffixes' in self.attrib:
+            return 'ConvertDynOptionDescription'
+        elif not self.is_leader:
+            return 'OptionDescription'
+        return 'Leadership'
 
 
 def load(xmlroot: str,
-         dtd_path: str,
          funcs_path: str):
-    tiramisu_objects = PopulateTiramisuObjects()
-    tiramisu_objects.parse_dtd(dtd_path)
-    tiramisu_objects.make_tiramisu_objects(xmlroot,
-                                           funcs_path)
-    return tiramisu_objects.storage.paths['.'].get()
+    tiramisu_objects = PopulateTiramisuObjects(xmlroot,
+                                               funcs_path,
+                                               )
+    return tiramisu_objects.get_text()
diff --git a/src/rougail/objspace.py b/src/rougail/objspace.py
index eaacb9ea..c21a0690 100644
--- a/src/rougail/objspace.py
+++ b/src/rougail/objspace.py
@@ -28,10 +28,11 @@ from lxml.etree import Element, SubElement  # pylint: disable=E0611
 
 from .i18n import _
 from .xmlreflector import XMLReflector, HIGH_COMPATIBILITY
-from .annotator import ERASED_ATTRIBUTES, VARIABLE_NAMESPACE, ServiceAnnotator, SpaceAnnotator
+from .annotator import ERASED_ATTRIBUTES,  ServiceAnnotator, SpaceAnnotator
 from .utils import normalize_family
-from .error import CreoleOperationError, SpaceObjShallNotBeUpdated, CreoleDictConsistencyError
+from .error import OperationError, SpaceObjShallNotBeUpdated, DictConsistencyError
 from .path import Path
+from .config import variable_namespace
 
 # CreoleObjSpace's elements like 'family' or 'follower', that shall be forced to the Redefinable type
 FORCE_REDEFINABLES = ('family', 'follower', 'service', 'disknod', 'variables')
@@ -178,7 +179,7 @@ class CreoleObjSpace:
                 continue
             if child.tag == 'family':
                 if child.attrib['name'] in family_names:
-                    raise CreoleDictConsistencyError(_('Family {} is set several times').format(child.attrib['name']))
+                    raise DictConsistencyError(_('Family {} is set several times').format(child.attrib['name']))
                 family_names.append(child.attrib['name'])
             if child.tag == 'variables':
                 child.attrib['name'] = namespace
@@ -296,12 +297,12 @@ class CreoleObjSpace:
                                                )
             elif exists is False:
                 raise SpaceObjShallNotBeUpdated()
-            raise CreoleDictConsistencyError(_(f'Already present in another XML file, {name} cannot be re-created'))
+            raise DictConsistencyError(_(f'Already present in another XML file, {name} cannot be re-created'))
         redefine = self.convert_boolean(subspace.get('redefine', False))
         exists = self.convert_boolean(subspace.get('exists', False))
         if redefine is False or exists is True:
             return getattr(self, child.tag)()
-        raise CreoleDictConsistencyError(_(f'Redefined object: {name} does not exist yet'))
+        raise DictConsistencyError(_(f'Redefined object: {name} does not exist yet'))
 
     def create_tree_structure(self,
                               space,
@@ -325,12 +326,12 @@ class CreoleObjSpace:
             elif isinstance(variableobj, self.UnRedefinable):
                 setattr(space, child.tag, [])
             elif not isinstance(variableobj, self.Atom):  # pragma: no cover
-                raise CreoleOperationError(_("Creole object {} "
+                raise OperationError(_("Creole object {} "
                                              "has a wrong type").format(type(variableobj)))
 
     def is_already_exists(self, name, space, child, namespace):
         if isinstance(space, self.family):  # pylint: disable=E1101
-            if namespace != VARIABLE_NAMESPACE:
+            if namespace != variable_namespace:
                 name = space.path + '.' + name
             return self.paths.path_is_defined(name)
         if child.tag == 'family':
@@ -363,14 +364,14 @@ class CreoleObjSpace:
             else:
                 norm_name = name
             return getattr(family, variable.tag)[norm_name]
-        if namespace == VARIABLE_NAMESPACE:
+        if namespace == variable_namespace:
             path = name
         else:
             path = family.path + '.' + name
         old_family_name = self.paths.get_variable_family_name(path)
         if normalize_family(family.name) == old_family_name:
             return getattr(family, variable.tag)[name]
-        old_family = self.space.variables[VARIABLE_NAMESPACE].family[old_family_name]  # pylint: disable=E1101
+        old_family = self.space.variables[variable_namespace].family[old_family_name]  # pylint: disable=E1101
         variable_obj = old_family.variable[name]
         del old_family.variable[name]
         if 'variable' not in vars(family):
@@ -452,7 +453,7 @@ class CreoleObjSpace:
                 # UNREDEFINABLE concerns only 'variable' node so we can fix name
                 # to child.attrib['name']
                 name = child.attrib['name']
-                raise CreoleDictConsistencyError(_(f'cannot redefine attribute {attr} for variable {name}'))
+                raise DictConsistencyError(_(f'cannot redefine attribute {attr} for variable {name}'))
             if attr in self.booleans_attributs:
                 val = self.convert_boolean(val)
             if not (attr == 'name' and getattr(variableobj, 'name', None) != None):
@@ -504,7 +505,7 @@ class CreoleObjSpace:
                                     document.attrib.get('dynamic') != None,
                                     variableobj)
             if child.attrib.get('redefine', 'False') == 'True':
-                if namespace == VARIABLE_NAMESPACE:
+                if namespace == variable_namespace:
                     self.redefine_variables.append(child.attrib['name'])
                 else:
                     self.redefine_variables.append(namespace + '.' + family_name + '.' +
@@ -512,7 +513,7 @@ class CreoleObjSpace:
 
         elif child.tag == 'family':
             family_name = normalize_family(child.attrib['name'])
-            if namespace != VARIABLE_NAMESPACE:
+            if namespace != variable_namespace:
                 family_name = namespace + '.' + family_name
             self.paths.add_family(namespace,
                                   family_name,
@@ -590,7 +591,7 @@ class CreoleObjSpace:
     def _xml_export(self,
                     node,
                     space,
-                    node_name=VARIABLE_NAMESPACE,
+                    node_name=variable_namespace,
                     ):
         for name in self.get_attributes(space):
             subspace = getattr(space, name)
diff --git a/src/rougail/path.py b/src/rougail/path.py
index 12119c12..abcf4f84 100644
--- a/src/rougail/path.py
+++ b/src/rougail/path.py
@@ -1,7 +1,7 @@
 from .i18n import _
 from .utils import normalize_family
-from .error import CreoleOperationError, CreoleDictConsistencyError
-from .annotator import VARIABLE_NAMESPACE
+from .error import OperationError, DictConsistencyError
+from .config import variable_namespace
 
 
 class Path:
@@ -30,13 +30,13 @@ class Path:
                         current_namespace: str,
                         ) -> str:  # pylint: disable=C0111
         if current_namespace is None:  # pragma: no cover
-            raise CreoleOperationError('current_namespace must not be None')
+            raise OperationError('current_namespace must not be None')
         dico = self.families[normalize_family(name,
                                               check_name=False,
                                               allow_dot=True,
                                               )]
-        if dico['namespace'] != VARIABLE_NAMESPACE and current_namespace != dico['namespace']:
-            raise CreoleDictConsistencyError(_('A family located in the {} namespace '
+        if dico['namespace'] != variable_namespace and current_namespace != dico['namespace']:
+            raise DictConsistencyError(_('A family located in the {} namespace '
                                                'shall not be used in the {} namespace').format(
                                                    dico['namespace'], current_namespace))
         path = dico['name']
@@ -48,7 +48,7 @@ class Path:
                        name: str,
                        ) -> 'Family':  # pylint: disable=C0111
         if name not in self.families:
-            raise CreoleDictConsistencyError(_('unknown family {}').format(name))
+            raise DictConsistencyError(_('unknown family {}').format(name))
         dico = self.families[name]
         return dico['variableobj']
 
@@ -59,7 +59,7 @@ class Path:
                    name: str,
                    leader_name: str,
                    ) -> None:  # pylint: disable=C0111
-        if namespace != VARIABLE_NAMESPACE:
+        if namespace != variable_namespace:
             # need rebuild path and move object in new path
             old_path = namespace + '.' + leader_family_name + '.' + name
             dico = self._get_variable(old_path)
@@ -74,7 +74,7 @@ class Path:
             name = new_path
         dico = self._get_variable(name)
         if dico['leader'] != None:
-            raise CreoleDictConsistencyError(_('Already defined leader {} for variable'
+            raise DictConsistencyError(_('Already defined leader {} for variable'
                                                ' {}'.format(dico['leader'], name)))
         dico['leader'] = leader_name
 
@@ -89,7 +89,7 @@ class Path:
                      is_dynamic: bool,
                      variableobj,
                      ) -> str:  # pylint: disable=C0111
-        if namespace == VARIABLE_NAMESPACE or '.' in name:
+        if namespace == variable_namespace or '.' in name:
             varname = name
         else:
             varname = '.'.join([namespace, family, name])
@@ -127,7 +127,7 @@ class Path:
                           with_suffix: bool=False,
                           ) -> str:  # pylint: disable=C0111
         if current_namespace is None:  # pragma: no cover
-            raise CreoleOperationError('current_namespace must not be None')
+            raise OperationError('current_namespace must not be None')
         if with_suffix:
             dico, suffix = self._get_variable(name,
                                               with_suffix=True,
@@ -135,8 +135,8 @@ class Path:
         else:
             dico = self._get_variable(name)
         if not allow_source:
-            if dico['namespace'] not in [VARIABLE_NAMESPACE, 'services'] and current_namespace != dico['namespace']:
-                raise CreoleDictConsistencyError(_('A variable located in the {} namespace '
+            if dico['namespace'] not in [variable_namespace, 'services'] and current_namespace != dico['namespace']:
+                raise DictConsistencyError(_('A variable located in the {} namespace '
                                                    'shall not be used in the {} namespace').format(
                                                        dico['namespace'], current_namespace))
         if '.' in dico['name']:
@@ -161,13 +161,13 @@ class Path:
                       with_suffix: bool=False,
                       ) -> str:
         if name not in self.variables:
-            if name.startswith(f'{VARIABLE_NAMESPACE}.'):
+            if name.startswith(f'{variable_namespace}.'):
                 name = name.split('.')[-1]
             if name not in self.variables:
                 for var_name, variable in self.variables.items():
                     if variable['is_dynamic'] and name.startswith(var_name):
                         return variable, name[len(var_name):]
-                raise CreoleDictConsistencyError(_('unknown option {}').format(name))
+                raise DictConsistencyError(_('unknown option {}').format(name))
         if with_suffix:
             return self.variables[name], None
         return self.variables[name]
diff --git a/src/rougail/template.py b/src/rougail/template.py
index c445ae51..57a5d3c6 100644
--- a/src/rougail/template.py
+++ b/src/rougail/template.py
@@ -18,8 +18,7 @@ from Cheetah.NameMapper import NotFound as CheetahNotFound
 from tiramisu import Config
 from tiramisu.error import PropertiesOptionError
 
-from .annotator import VARIABLE_NAMESPACE
-from .config import patch_dir
+from .config import patch_dir, variable_namespace
 from .error import FileNotFound, TemplateError
 from .i18n import _
 from .utils import normalize_family
@@ -373,7 +372,7 @@ class CreoleTemplateEngine:
         """
         for option in await self.config.option.list(type='all'):
             namespace = await option.option.name()
-            if namespace == VARIABLE_NAMESPACE:
+            if namespace == variable_namespace:
                 await self.load_eole_variables_rougail(option)
             else:
                 families = await self.load_eole_variables(namespace,
diff --git a/src/rougail/tiramisu.py b/src/rougail/tiramisu.py
new file mode 100644
index 00000000..60a96355
--- /dev/null
+++ b/src/rougail/tiramisu.py
@@ -0,0 +1,10 @@
+from tiramisu import DynOptionDescription
+from .utils import normalize_family
+
+
+class ConvertDynOptionDescription(DynOptionDescription):
+    def convert_suffix_to_path(self, suffix):
+        if not isinstance(suffix, str):
+            suffix = str(suffix)
+        return normalize_family(suffix,
+                                check_name=False)
diff --git a/src/rougail/xmlreflector.py b/src/rougail/xmlreflector.py
index 6b0f0bbf..368fcfa8 100644
--- a/src/rougail/xmlreflector.py
+++ b/src/rougail/xmlreflector.py
@@ -6,7 +6,7 @@ from os import listdir
 from lxml.etree import DTD, parse, tostring  # , XMLParser
 
 from .i18n import _
-from .error import CreoleDictConsistencyError
+from .error import DictConsistencyError
 
 HIGH_COMPATIBILITY = True
 
@@ -38,7 +38,7 @@ class XMLReflector(object):
         # document = parse(BytesIO(xmlfile), XMLParser(remove_blank_text=True))
         document = parse(xmlfile)
         if not self.dtd.validate(document):
-            raise CreoleDictConsistencyError(_("not a valid xml file: {}").format(xmlfile))
+            raise DictConsistencyError(_("not a valid xml file: {}").format(xmlfile))
         return document.getroot()
 
     def load_xml_from_folders(self, xmlfolders):
diff --git a/tests/flattener_dicos/00empty/__init__.py b/tests/flattener_dicos/00empty/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00empty/tiramisu/__init__.py b/tests/flattener_dicos/00empty/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00empty/tiramisu/base.py b/tests/flattener_dicos/00empty/tiramisu/base.py
new file mode 100644
index 00000000..f53499dc
--- /dev/null
+++ b/tests/flattener_dicos/00empty/tiramisu/base.py
@@ -0,0 +1,7 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_2 = OptionDescription(doc='tata', name='tata', children=[])
+option_1 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/00load_autofreeze/__init__.py b/tests/flattener_dicos/00load_autofreeze/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_autofreeze/tiramisu/__init__.py b/tests/flattener_dicos/00load_autofreeze/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_autofreeze/tiramisu/base.py b/tests/flattener_dicos/00load_autofreeze/tiramisu/base.py
new file mode 100644
index 00000000..5a120b55
--- /dev/null
+++ b/tests/flattener_dicos/00load_autofreeze/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='module_instancie', default='non', values=('oui', 'non'))
+option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'auto_freeze', 'mandatory', 'basic', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['basic']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/00load_autofreezeexpert/__init__.py b/tests/flattener_dicos/00load_autofreezeexpert/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_autofreezeexpert/tiramisu/__init__.py b/tests/flattener_dicos/00load_autofreezeexpert/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_autofreezeexpert/tiramisu/base.py b/tests/flattener_dicos/00load_autofreezeexpert/tiramisu/base.py
new file mode 100644
index 00000000..7a1ce4e7
--- /dev/null
+++ b/tests/flattener_dicos/00load_autofreezeexpert/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='module_instancie', default='non', values=('oui', 'non'))
+option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'auto_freeze', 'mandatory', 'expert', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/00load_autosave/__init__.py b/tests/flattener_dicos/00load_autosave/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_autosave/tiramisu/__init__.py b/tests/flattener_dicos/00load_autosave/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_autosave/tiramisu/base.py b/tests/flattener_dicos/00load_autosave/tiramisu/base.py
new file mode 100644
index 00000000..29dda7ba
--- /dev/null
+++ b/tests/flattener_dicos/00load_autosave/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'mandatory', 'basic']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['basic']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/00load_autosaveexpert/__init__.py b/tests/flattener_dicos/00load_autosaveexpert/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_autosaveexpert/tiramisu/__init__.py b/tests/flattener_dicos/00load_autosaveexpert/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_autosaveexpert/tiramisu/base.py b/tests/flattener_dicos/00load_autosaveexpert/tiramisu/base.py
new file mode 100644
index 00000000..5a56eb59
--- /dev/null
+++ b/tests/flattener_dicos/00load_autosaveexpert/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['expert']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/00load_comment/__init__.py b/tests/flattener_dicos/00load_comment/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_comment/tiramisu/__init__.py b/tests/flattener_dicos/00load_comment/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_comment/tiramisu/base.py b/tests/flattener_dicos/00load_comment/tiramisu/base.py
new file mode 100644
index 00000000..afdae789
--- /dev/null
+++ b/tests/flattener_dicos/00load_comment/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/00load_notype/__init__.py b/tests/flattener_dicos/00load_notype/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_notype/result/00-base.xml b/tests/flattener_dicos/00load_notype/result/00-base.xml
index 795fecab..d4b530cf 100644
--- a/tests/flattener_dicos/00load_notype/result/00-base.xml
+++ b/tests/flattener_dicos/00load_notype/result/00-base.xml
@@ -16,7 +16,7 @@
       <variable doc="without_type" multi="False" name="without_type" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>non</value>
+        <value type="string">non</value>
       </variable>
     </family>
   </family>
diff --git a/tests/flattener_dicos/00load_notype/tiramisu/__init__.py b/tests/flattener_dicos/00load_notype/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_notype/tiramisu/base.py b/tests/flattener_dicos/00load_notype/tiramisu/base.py
new file mode 100644
index 00000000..eb9bc1ac
--- /dev/null
+++ b/tests/flattener_dicos/00load_notype/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='without_type', multi=False, name='without_type', default='non')
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/00load_save/__init__.py b/tests/flattener_dicos/00load_save/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_save/tiramisu/__init__.py b/tests/flattener_dicos/00load_save/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_save/tiramisu/base.py b/tests/flattener_dicos/00load_save/tiramisu/base.py
new file mode 100644
index 00000000..afdae789
--- /dev/null
+++ b/tests/flattener_dicos/00load_save/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/00load_subfolder/__init__.py b/tests/flattener_dicos/00load_subfolder/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_subfolder/tiramisu/__init__.py b/tests/flattener_dicos/00load_subfolder/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/00load_subfolder/tiramisu/base.py b/tests/flattener_dicos/00load_subfolder/tiramisu/base.py
new file mode 100644
index 00000000..e651cc66
--- /dev/null
+++ b/tests/flattener_dicos/00load_subfolder/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/01auto_base/__init__.py b/tests/flattener_dicos/01auto_base/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01auto_base/result/00-base.xml b/tests/flattener_dicos/01auto_base/result/00-base.xml
index 67ef68fc..3860acdd 100644
--- a/tests/flattener_dicos/01auto_base/result/00-base.xml
+++ b/tests/flattener_dicos/01auto_base/result/00-base.xml
@@ -12,7 +12,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
diff --git a/tests/flattener_dicos/01auto_base/tiramisu/__init__.py b/tests/flattener_dicos/01auto_base/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01auto_base/tiramisu/base.py b/tests/flattener_dicos/01auto_base/tiramisu/base.py
new file mode 100644
index 00000000..74f73d7c
--- /dev/null
+++ b/tests/flattener_dicos/01auto_base/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})), values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/01auto_withoutparam/__init__.py b/tests/flattener_dicos/01auto_withoutparam/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01auto_withoutparam/tiramisu/__init__.py b/tests/flattener_dicos/01auto_withoutparam/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01auto_withoutparam/tiramisu/base.py b/tests/flattener_dicos/01auto_withoutparam/tiramisu/base.py
new file mode 100644
index 00000000..198ab4e7
--- /dev/null
+++ b/tests/flattener_dicos/01auto_withoutparam/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((), kwargs={})), values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/01base_multi/__init__.py b/tests/flattener_dicos/01base_multi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01base_multi/tiramisu/__init__.py b/tests/flattener_dicos/01base_multi/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01base_multi/tiramisu/base.py b/tests/flattener_dicos/01base_multi/tiramisu/base.py
new file mode 100644
index 00000000..b7860314
--- /dev/null
+++ b/tests/flattener_dicos/01base_multi/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='Redefine description', multi=True, name='mode_conteneur_actif', default=['non'], default_multi='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/01fill_autofreeze/__init__.py b/tests/flattener_dicos/01fill_autofreeze/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_autofreeze/result/00-base.xml b/tests/flattener_dicos/01fill_autofreeze/result/00-base.xml
index 296660a5..ff5a64b9 100644
--- a/tests/flattener_dicos/01fill_autofreeze/result/00-base.xml
+++ b/tests/flattener_dicos/01fill_autofreeze/result/00-base.xml
@@ -12,7 +12,7 @@
         <property>basic</property>
         <property expected="oui" inverse="True" source="rougail.general.module_instancie" type="calculation">auto_frozen</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
diff --git a/tests/flattener_dicos/01fill_autofreeze/tiramisu/__init__.py b/tests/flattener_dicos/01fill_autofreeze/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_autofreeze/tiramisu/base.py b/tests/flattener_dicos/01fill_autofreeze/tiramisu/base.py
new file mode 100644
index 00000000..cd4c11d7
--- /dev/null
+++ b/tests/flattener_dicos/01fill_autofreeze/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='module_instancie', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'auto_freeze', 'mandatory', 'basic', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_5, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))]), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})), values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['basic']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/01fill_autosave/__init__.py b/tests/flattener_dicos/01fill_autosave/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_autosave/result/00-base.xml b/tests/flattener_dicos/01fill_autosave/result/00-base.xml
index 6b0ddc3e..747552f5 100644
--- a/tests/flattener_dicos/01fill_autosave/result/00-base.xml
+++ b/tests/flattener_dicos/01fill_autosave/result/00-base.xml
@@ -10,7 +10,7 @@
         <property>mandatory</property>
         <property>basic</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
diff --git a/tests/flattener_dicos/01fill_autosave/tiramisu/__init__.py b/tests/flattener_dicos/01fill_autosave/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_autosave/tiramisu/base.py b/tests/flattener_dicos/01fill_autosave/tiramisu/base.py
new file mode 100644
index 00000000..f2933b79
--- /dev/null
+++ b/tests/flattener_dicos/01fill_autosave/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'mandatory', 'basic']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})), values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['basic']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/01fill_base/__init__.py b/tests/flattener_dicos/01fill_base/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_base/result/00-base.xml b/tests/flattener_dicos/01fill_base/result/00-base.xml
index 67ef68fc..3860acdd 100644
--- a/tests/flattener_dicos/01fill_base/result/00-base.xml
+++ b/tests/flattener_dicos/01fill_base/result/00-base.xml
@@ -12,7 +12,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
diff --git a/tests/flattener_dicos/01fill_base/tiramisu/__init__.py b/tests/flattener_dicos/01fill_base/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_base/tiramisu/base.py b/tests/flattener_dicos/01fill_base/tiramisu/base.py
new file mode 100644
index 00000000..74f73d7c
--- /dev/null
+++ b/tests/flattener_dicos/01fill_base/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})), values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/01fill_baseaccent/__init__.py b/tests/flattener_dicos/01fill_baseaccent/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_baseaccent/result/00-base.xml b/tests/flattener_dicos/01fill_baseaccent/result/00-base.xml
index d6eb03d7..7ca60059 100644
--- a/tests/flattener_dicos/01fill_baseaccent/result/00-base.xml
+++ b/tests/flattener_dicos/01fill_baseaccent/result/00-base.xml
@@ -12,7 +12,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
diff --git a/tests/flattener_dicos/01fill_baseaccent/tiramisu/__init__.py b/tests/flattener_dicos/01fill_baseaccent/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_baseaccent/tiramisu/base.py b/tests/flattener_dicos/01fill_baseaccent/tiramisu/base.py
new file mode 100644
index 00000000..d1f580e3
--- /dev/null
+++ b/tests/flattener_dicos/01fill_baseaccent/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})), values=('oui', 'non'))
+option_2 = OptionDescription(doc='Général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/01fill_mandatory/__init__.py b/tests/flattener_dicos/01fill_mandatory/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_mandatory/result/00-base.xml b/tests/flattener_dicos/01fill_mandatory/result/00-base.xml
index f6ac60e7..629b0d95 100644
--- a/tests/flattener_dicos/01fill_mandatory/result/00-base.xml
+++ b/tests/flattener_dicos/01fill_mandatory/result/00-base.xml
@@ -7,7 +7,7 @@
         <property>mandatory</property>
         <property>expert</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
diff --git a/tests/flattener_dicos/01fill_mandatory/tiramisu/__init__.py b/tests/flattener_dicos/01fill_mandatory/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_mandatory/tiramisu/base.py b/tests/flattener_dicos/01fill_mandatory/tiramisu/base.py
new file mode 100644
index 00000000..ace69e0e
--- /dev/null
+++ b/tests/flattener_dicos/01fill_mandatory/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_3 = DomainnameOption(type='domainname', allow_ip=True, allow_without_dot=True, properties=frozenset(['mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/01fill_number/__init__.py b/tests/flattener_dicos/01fill_number/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_number/result/00-base.xml b/tests/flattener_dicos/01fill_number/result/00-base.xml
index e4a5a533..d2453599 100644
--- a/tests/flattener_dicos/01fill_number/result/00-base.xml
+++ b/tests/flattener_dicos/01fill_number/result/00-base.xml
@@ -10,7 +10,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="number">3</param>
+          <param type="number">3</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
diff --git a/tests/flattener_dicos/01fill_number/tiramisu/__init__.py b/tests/flattener_dicos/01fill_number/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_number/tiramisu/base.py b/tests/flattener_dicos/01fill_number/tiramisu/base.py
new file mode 100644
index 00000000..3989b406
--- /dev/null
+++ b/tests/flattener_dicos/01fill_number/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = IntOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamValue(3)), kwargs={})))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/01fill_optional/__init__.py b/tests/flattener_dicos/01fill_optional/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_optional/result/00-base.xml b/tests/flattener_dicos/01fill_optional/result/00-base.xml
index 67ef68fc..3860acdd 100644
--- a/tests/flattener_dicos/01fill_optional/result/00-base.xml
+++ b/tests/flattener_dicos/01fill_optional/result/00-base.xml
@@ -12,7 +12,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="variable">rougail.general.mode_conteneur_actif1</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif1" type="choice">
diff --git a/tests/flattener_dicos/01fill_optional/tiramisu/__init__.py b/tests/flattener_dicos/01fill_optional/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01fill_optional/tiramisu/base.py b/tests/flattener_dicos/01fill_optional/tiramisu/base.py
new file mode 100644
index 00000000..74f73d7c
--- /dev/null
+++ b/tests/flattener_dicos/01fill_optional/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={})), values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/01separator_base/__init__.py b/tests/flattener_dicos/01separator_base/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01separator_base/tiramisu/__init__.py b/tests/flattener_dicos/01separator_base/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01separator_base/tiramisu/base.py b/tests/flattener_dicos/01separator_base/tiramisu/base.py
new file mode 100644
index 00000000..0639aa33
--- /dev/null
+++ b/tests/flattener_dicos/01separator_base/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_3.impl_set_information("separator", "Établissement")
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/01separator_neverhidden/__init__.py b/tests/flattener_dicos/01separator_neverhidden/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01separator_neverhidden/tiramisu/__init__.py b/tests/flattener_dicos/01separator_neverhidden/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/01separator_neverhidden/tiramisu/base.py b/tests/flattener_dicos/01separator_neverhidden/tiramisu/base.py
new file mode 100644
index 00000000..0639aa33
--- /dev/null
+++ b/tests/flattener_dicos/01separator_neverhidden/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_3.impl_set_information("separator", "Établissement")
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10autosave_hidden/__init__.py b/tests/flattener_dicos/10autosave_hidden/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10autosave_hidden/result/00-base.xml b/tests/flattener_dicos/10autosave_hidden/result/00-base.xml
index f7cc2bbe..cb652a9c 100644
--- a/tests/flattener_dicos/10autosave_hidden/result/00-base.xml
+++ b/tests/flattener_dicos/10autosave_hidden/result/00-base.xml
@@ -20,7 +20,7 @@
         <property>mandatory</property>
         <property>basic</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="string">oui</param>
+          <param type="string">oui</param>
         </value>
       </variable>
     </family>
diff --git a/tests/flattener_dicos/10autosave_hidden/tiramisu/__init__.py b/tests/flattener_dicos/10autosave_hidden/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10autosave_hidden/tiramisu/base.py b/tests/flattener_dicos/10autosave_hidden/tiramisu/base.py
new file mode 100644
index 00000000..f75a71e3
--- /dev/null
+++ b/tests/flattener_dicos/10autosave_hidden/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = StrOption(properties=frozenset(['force_store_value', 'frozen', 'hidden', 'mandatory', 'basic']), doc='autosave variable', multi=False, name='autosavevar', default=Calculation(func.calc_val, Params((ParamValue("oui")), kwargs={})))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['basic']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10autosave_hidden_frozenifin/__init__.py b/tests/flattener_dicos/10autosave_hidden_frozenifin/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10autosave_hidden_frozenifin/result/00-base.xml b/tests/flattener_dicos/10autosave_hidden_frozenifin/result/00-base.xml
index da350932..6ef71ae6 100644
--- a/tests/flattener_dicos/10autosave_hidden_frozenifin/result/00-base.xml
+++ b/tests/flattener_dicos/10autosave_hidden_frozenifin/result/00-base.xml
@@ -21,7 +21,7 @@
         <property expected="oui" inverse="False" source="rougail.general.mode_conteneur_actif" type="calculation">hidden</property>
         <property expected="oui" inverse="False" source="rougail.general.mode_conteneur_actif" type="calculation">force_default_on_freeze</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="string">oui</param>
+          <param type="string">oui</param>
         </value>
       </variable>
     </family>
diff --git a/tests/flattener_dicos/10autosave_hidden_frozenifin/tiramisu/__init__.py b/tests/flattener_dicos/10autosave_hidden_frozenifin/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10autosave_hidden_frozenifin/tiramisu/base.py b/tests/flattener_dicos/10autosave_hidden_frozenifin/tiramisu/base.py
new file mode 100644
index 00000000..1b6bd890
--- /dev/null
+++ b/tests/flattener_dicos/10autosave_hidden_frozenifin/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = StrOption(properties=frozenset(['force_store_value', 'mandatory', 'basic', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='autosave variable', multi=False, name='autosavevar', default=Calculation(func.calc_val, Params((ParamValue("oui")), kwargs={})))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['basic']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10check_base/__init__.py b/tests/flattener_dicos/10check_base/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_base/result/00-base.xml b/tests/flattener_dicos/10check_base/result/00-base.xml
index b0fdf191..097ff55a 100644
--- a/tests/flattener_dicos/10check_base/result/00-base.xml
+++ b/tests/flattener_dicos/10check_base/result/00-base.xml
@@ -6,7 +6,7 @@
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>b</value>
+        <value type="string">b</value>
       </variable>
       <variable doc="No change" multi="False" name="int" type="number">
         <check name="valid_entier" warnings_only="False">
diff --git a/tests/flattener_dicos/10check_base/tiramisu/__init__.py b/tests/flattener_dicos/10check_base/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_base/tiramisu/base.py b/tests/flattener_dicos/10check_base/tiramisu/base.py
new file mode 100644
index 00000000..124a60f9
--- /dev/null
+++ b/tests/flattener_dicos/10check_base/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='b')
+option_4 = IntOption(properties=frozenset(['normal']), validators=[Calculation(func.valid_entier, Params((ParamSelfOption()), kwargs={'mini': ParamValue("0"), 'maxi': ParamValue("100")}), warnings_only=False)], doc='No change', multi=False, name='int')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10check_option/__init__.py b/tests/flattener_dicos/10check_option/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_option/result/00-base.xml b/tests/flattener_dicos/10check_option/result/00-base.xml
index 587553e3..8a8ac468 100644
--- a/tests/flattener_dicos/10check_option/result/00-base.xml
+++ b/tests/flattener_dicos/10check_option/result/00-base.xml
@@ -6,17 +6,17 @@
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>b</value>
+        <value type="string">b</value>
       </variable>
       <variable doc="No change" multi="False" name="int2" type="number">
         <property>mandatory</property>
         <property>normal</property>
-        <value>100</value>
+        <value type="number">100</value>
       </variable>
       <variable doc="No change" multi="False" name="int" type="number">
         <check name="valid_entier" warnings_only="False">
           <param name="mini" type="string">0</param>
-          <param name="maxi" type="variable">rougail.general.int2</param>
+          <param name="maxi" notraisepropertyerror="False" type="variable">rougail.general.int2</param>
         </check>
         <property>normal</property>
       </variable>
diff --git a/tests/flattener_dicos/10check_option/tiramisu/__init__.py b/tests/flattener_dicos/10check_option/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_option/tiramisu/base.py b/tests/flattener_dicos/10check_option/tiramisu/base.py
new file mode 100644
index 00000000..d37d8dfe
--- /dev/null
+++ b/tests/flattener_dicos/10check_option/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='b')
+option_4 = IntOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='int2', default=100)
+option_5 = IntOption(properties=frozenset(['normal']), validators=[Calculation(func.valid_entier, Params((ParamSelfOption()), kwargs={'mini': ParamValue("0"), 'maxi': ParamOption(option_4, notraisepropertyerror=False, todict=False)}), warnings_only=False)], doc='No change', multi=False, name='int')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10check_optional/__init__.py b/tests/flattener_dicos/10check_optional/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_optional/result/00-base.xml b/tests/flattener_dicos/10check_optional/result/00-base.xml
index 5f4612f0..2858ed5f 100644
--- a/tests/flattener_dicos/10check_optional/result/00-base.xml
+++ b/tests/flattener_dicos/10check_optional/result/00-base.xml
@@ -6,11 +6,11 @@
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>b</value>
+        <value type="string">b</value>
       </variable>
       <variable doc="No change" multi="False" name="int" type="number">
         <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">rougail.general.int2</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.int2</param>
         </check>
         <property>normal</property>
       </variable>
diff --git a/tests/flattener_dicos/10check_optional/tiramisu/__init__.py b/tests/flattener_dicos/10check_optional/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_optional/tiramisu/base.py b/tests/flattener_dicos/10check_optional/tiramisu/base.py
new file mode 100644
index 00000000..ad32594b
--- /dev/null
+++ b/tests/flattener_dicos/10check_optional/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='b')
+option_5 = IntOption(properties=frozenset(['normal']), doc='No change', multi=False, name='int2')
+option_4 = IntOption(properties=frozenset(['normal']), validators=[Calculation(func.valid_not_equal, Params((ParamSelfOption(), ParamOption(option_5, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False)], doc='No change', multi=False, name='int')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10check_valid_differ/__init__.py b/tests/flattener_dicos/10check_valid_differ/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_valid_differ/result/00-base.xml b/tests/flattener_dicos/10check_valid_differ/result/00-base.xml
index 5753b99b..9245aa59 100644
--- a/tests/flattener_dicos/10check_valid_differ/result/00-base.xml
+++ b/tests/flattener_dicos/10check_valid_differ/result/00-base.xml
@@ -5,7 +5,7 @@
       <property>normal</property>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">rougail.general.mode_conteneur_actif1</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </check>
         <choice type="string">oui</choice>
         <choice type="string">non</choice>
diff --git a/tests/flattener_dicos/10check_valid_differ/tiramisu/__init__.py b/tests/flattener_dicos/10check_valid_differ/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_valid_differ/tiramisu/base.py b/tests/flattener_dicos/10check_valid_differ/tiramisu/base.py
new file mode 100644
index 00000000..87a8c442
--- /dev/null
+++ b/tests/flattener_dicos/10check_valid_differ/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), validators=[Calculation(func.valid_not_equal, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False)], doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10check_valid_differ_add/__init__.py b/tests/flattener_dicos/10check_valid_differ_add/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_valid_differ_add/result/00-base.xml b/tests/flattener_dicos/10check_valid_differ_add/result/00-base.xml
index 21976c51..ae116358 100644
--- a/tests/flattener_dicos/10check_valid_differ_add/result/00-base.xml
+++ b/tests/flattener_dicos/10check_valid_differ_add/result/00-base.xml
@@ -26,14 +26,14 @@
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif3" type="string">
         <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">rougail.general.mode_conteneur_actif1</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </check>
         <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">rougail.general.mode_conteneur_actif2</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif2</param>
         </check>
         <property>mandatory</property>
         <property>normal</property>
-        <value>oui</value>
+        <value type="string">oui</value>
       </variable>
     </family>
   </family>
diff --git a/tests/flattener_dicos/10check_valid_differ_add/tiramisu/__init__.py b/tests/flattener_dicos/10check_valid_differ_add/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_valid_differ_add/tiramisu/base.py b/tests/flattener_dicos/10check_valid_differ_add/tiramisu/base.py
new file mode 100644
index 00000000..bb3b5a1f
--- /dev/null
+++ b/tests/flattener_dicos/10check_valid_differ_add/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_6 = StrOption(properties=frozenset(['mandatory', 'normal']), validators=[Calculation(func.valid_not_equal, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False), Calculation(func.valid_not_equal, Params((ParamSelfOption(), ParamOption(option_5, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False)], doc='No change', multi=False, name='mode_conteneur_actif3', default='oui')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5, option_6])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10check_valid_differ_removecheck/__init__.py b/tests/flattener_dicos/10check_valid_differ_removecheck/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_valid_differ_removecheck/result/00-base.xml b/tests/flattener_dicos/10check_valid_differ_removecheck/result/00-base.xml
index 21976c51..ae116358 100644
--- a/tests/flattener_dicos/10check_valid_differ_removecheck/result/00-base.xml
+++ b/tests/flattener_dicos/10check_valid_differ_removecheck/result/00-base.xml
@@ -26,14 +26,14 @@
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif3" type="string">
         <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">rougail.general.mode_conteneur_actif1</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif1</param>
         </check>
         <check name="valid_not_equal" warnings_only="False">
-          <param type="variable">rougail.general.mode_conteneur_actif2</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.mode_conteneur_actif2</param>
         </check>
         <property>mandatory</property>
         <property>normal</property>
-        <value>oui</value>
+        <value type="string">oui</value>
       </variable>
     </family>
   </family>
diff --git a/tests/flattener_dicos/10check_valid_differ_removecheck/tiramisu/__init__.py b/tests/flattener_dicos/10check_valid_differ_removecheck/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_valid_differ_removecheck/tiramisu/base.py b/tests/flattener_dicos/10check_valid_differ_removecheck/tiramisu/base.py
new file mode 100644
index 00000000..bb3b5a1f
--- /dev/null
+++ b/tests/flattener_dicos/10check_valid_differ_removecheck/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_6 = StrOption(properties=frozenset(['mandatory', 'normal']), validators=[Calculation(func.valid_not_equal, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False), Calculation(func.valid_not_equal, Params((ParamSelfOption(), ParamOption(option_5, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=False)], doc='No change', multi=False, name='mode_conteneur_actif3', default='oui')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5, option_6])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10check_valid_ipnetmask/__init__.py b/tests/flattener_dicos/10check_valid_ipnetmask/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_valid_ipnetmask/result/00-base.xml b/tests/flattener_dicos/10check_valid_ipnetmask/result/00-base.xml
index bf3f1187..28e093f5 100644
--- a/tests/flattener_dicos/10check_valid_ipnetmask/result/00-base.xml
+++ b/tests/flattener_dicos/10check_valid_ipnetmask/result/00-base.xml
@@ -16,7 +16,7 @@
       </variable>
       <variable doc="Masque de sous réseau de la carte" multi="False" name="adresse_netmask_eth0" type="netmask">
         <check name="valid_ip_netmask" warnings_only="True">
-          <param type="variable">rougail.general.adresse_ip_eth0</param>
+          <param notraisepropertyerror="False" type="variable">rougail.general.adresse_ip_eth0</param>
         </check>
         <property>mandatory</property>
         <property>basic</property>
diff --git a/tests/flattener_dicos/10check_valid_ipnetmask/tiramisu/__init__.py b/tests/flattener_dicos/10check_valid_ipnetmask/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10check_valid_ipnetmask/tiramisu/base.py b/tests/flattener_dicos/10check_valid_ipnetmask/tiramisu/base.py
new file mode 100644
index 00000000..7ef00e92
--- /dev/null
+++ b/tests/flattener_dicos/10check_valid_ipnetmask/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_4 = IPOption(private_only=True, warnings_only=True, properties=frozenset(['mandatory', 'basic']), doc='Adresse IP de la carte', multi=False, name='adresse_ip_eth0')
+option_5 = NetmaskOption(properties=frozenset(['mandatory', 'basic']), validators=[Calculation(func.valid_ip_netmask, Params((ParamSelfOption(), ParamOption(option_4, notraisepropertyerror=False, todict=False)), kwargs={}), warnings_only=True)], doc='Masque de sous réseau de la carte', multi=False, name='adresse_netmask_eth0')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['basic']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10leadership_append/__init__.py b/tests/flattener_dicos/10leadership_append/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_append/result/00-base.xml b/tests/flattener_dicos/10leadership_append/result/00-base.xml
index 964a6b6e..3c7b3004 100644
--- a/tests/flattener_dicos/10leadership_append/result/00-base.xml
+++ b/tests/flattener_dicos/10leadership_append/result/00-base.xml
@@ -20,14 +20,14 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower2" multi="False" name="follower2" type="string">
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">rougail.general1.leader.follower1</param>
+            <param notraisepropertyerror="False" type="variable">rougail.general1.leader.follower1</param>
           </value>
         </variable>
         <variable doc="follower3" multi="False" name="follower3" type="string">
diff --git a/tests/flattener_dicos/10leadership_append/tiramisu/__init__.py b/tests/flattener_dicos/10leadership_append/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_append/tiramisu/base.py b/tests/flattener_dicos/10leadership_append/tiramisu/base.py
new file mode 100644
index 00000000..b50263a2
--- /dev/null
+++ b/tests/flattener_dicos/10leadership_append/tiramisu/base.py
@@ -0,0 +1,14 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_6 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_8 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower2', multi=True, name='follower2', default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_9 = StrOption(properties=frozenset(['normal']), doc='follower3', multi=True, name='follower3')
+option_5 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_6, option_7, option_8, option_9])
+option_4 = OptionDescription(doc='general1', name='general1', properties=frozenset(['normal']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10leadership_auto/__init__.py b/tests/flattener_dicos/10leadership_auto/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_auto/result/00-base.xml b/tests/flattener_dicos/10leadership_auto/result/00-base.xml
index 9dc94d36..0b1ce1f0 100644
--- a/tests/flattener_dicos/10leadership_auto/result/00-base.xml
+++ b/tests/flattener_dicos/10leadership_auto/result/00-base.xml
@@ -20,7 +20,7 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower2" multi="False" name="follower2" type="string">
@@ -30,7 +30,7 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">rougail.general.leader.follower1</param>
+            <param notraisepropertyerror="False" type="variable">rougail.general.leader.follower1</param>
           </value>
         </variable>
         <variable doc="follower3" multi="False" name="follower3" type="string">
@@ -40,7 +40,7 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">rougail.general.leader.leader</param>
+            <param notraisepropertyerror="False" type="variable">rougail.general.leader.leader</param>
           </value>
         </variable>
       </leader>
diff --git a/tests/flattener_dicos/10leadership_auto/tiramisu/__init__.py b/tests/flattener_dicos/10leadership_auto/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_auto/tiramisu/base.py b/tests/flattener_dicos/10leadership_auto/tiramisu/base.py
new file mode 100644
index 00000000..4d8d86b6
--- /dev/null
+++ b/tests/flattener_dicos/10leadership_auto/tiramisu/base.py
@@ -0,0 +1,13 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_6 = StrOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='follower2', multi=True, name='follower2', default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_8 = StrOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='follower3', multi=True, name='follower3', default=Calculation(func.calc_val, Params((ParamOption(option_5, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_4 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_5, option_6, option_7, option_8])
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10leadership_autoleader/__init__.py b/tests/flattener_dicos/10leadership_autoleader/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_autoleader/result/00-base.xml b/tests/flattener_dicos/10leadership_autoleader/result/00-base.xml
index d6145d3f..05f81074 100644
--- a/tests/flattener_dicos/10leadership_autoleader/result/00-base.xml
+++ b/tests/flattener_dicos/10leadership_autoleader/result/00-base.xml
@@ -20,7 +20,7 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower2" multi="False" name="follower2" type="string">
@@ -30,7 +30,7 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">rougail.general.leader.leader</param>
+            <param notraisepropertyerror="False" type="variable">rougail.general.leader.leader</param>
           </value>
         </variable>
       </leader>
diff --git a/tests/flattener_dicos/10leadership_autoleader/tiramisu/__init__.py b/tests/flattener_dicos/10leadership_autoleader/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_autoleader/tiramisu/base.py b/tests/flattener_dicos/10leadership_autoleader/tiramisu/base.py
new file mode 100644
index 00000000..03bdfedb
--- /dev/null
+++ b/tests/flattener_dicos/10leadership_autoleader/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_6 = StrOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='follower2', multi=True, name='follower2', default=Calculation(func.calc_val, Params((ParamOption(option_5, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_4 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_5, option_6, option_7])
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10leadership_autoleader_expert/__init__.py b/tests/flattener_dicos/10leadership_autoleader_expert/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_autoleader_expert/result/00-base.xml b/tests/flattener_dicos/10leadership_autoleader_expert/result/00-base.xml
index 79acf584..4e98911e 100644
--- a/tests/flattener_dicos/10leadership_autoleader_expert/result/00-base.xml
+++ b/tests/flattener_dicos/10leadership_autoleader_expert/result/00-base.xml
@@ -21,7 +21,7 @@
           <property>frozen</property>
           <property>mandatory</property>
           <value name="calc_list" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower1" multi="False" name="follower1" type="string">
diff --git a/tests/flattener_dicos/10leadership_autoleader_expert/tiramisu/__init__.py b/tests/flattener_dicos/10leadership_autoleader_expert/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_autoleader_expert/tiramisu/base.py b/tests/flattener_dicos/10leadership_autoleader_expert/tiramisu/base.py
new file mode 100644
index 00000000..7b865793
--- /dev/null
+++ b/tests/flattener_dicos/10leadership_autoleader_expert/tiramisu/base.py
@@ -0,0 +1,13 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['expert']), children=[option_3])
+option_6 = StrOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'mandatory']), doc='leader', multi=True, name='leader', default=Calculation(func.calc_list, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'expert']), doc='follower1', multi=True, name='follower1')
+option_8 = StrOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'expert']), doc='follower2', multi=True, name='follower2')
+option_5 = Leadership(doc='leader', name='leader', properties=frozenset(['hidden', 'expert']), children=[option_6, option_7, option_8])
+option_4 = OptionDescription(doc='leadermode', name='leadermode', properties=frozenset(['expert']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10leadership_autosaveexpert/__init__.py b/tests/flattener_dicos/10leadership_autosaveexpert/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_autosaveexpert/result/00-base.xml b/tests/flattener_dicos/10leadership_autosaveexpert/result/00-base.xml
index 23ff7f09..1ed7c557 100644
--- a/tests/flattener_dicos/10leadership_autosaveexpert/result/00-base.xml
+++ b/tests/flattener_dicos/10leadership_autosaveexpert/result/00-base.xml
@@ -17,14 +17,14 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower2" multi="False" name="follower2" type="string">
           <property>mandatory</property>
           <property>expert</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">rougail.general.leader.follower1</param>
+            <param notraisepropertyerror="False" type="variable">rougail.general.leader.follower1</param>
           </value>
         </variable>
       </leader>
diff --git a/tests/flattener_dicos/10leadership_autosaveexpert/tiramisu/__init__.py b/tests/flattener_dicos/10leadership_autosaveexpert/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_autosaveexpert/tiramisu/base.py b/tests/flattener_dicos/10leadership_autosaveexpert/tiramisu/base.py
new file mode 100644
index 00000000..e7c6e9ef
--- /dev/null
+++ b/tests/flattener_dicos/10leadership_autosaveexpert/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_6 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(properties=frozenset(['mandatory', 'expert']), doc='follower2', multi=True, name='follower2', default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_4 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_5, option_6, option_7])
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10leadership_familyaccent/__init__.py b/tests/flattener_dicos/10leadership_familyaccent/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_familyaccent/result/00-base.xml b/tests/flattener_dicos/10leadership_familyaccent/result/00-base.xml
index ff159277..a16cbd14 100644
--- a/tests/flattener_dicos/10leadership_familyaccent/result/00-base.xml
+++ b/tests/flattener_dicos/10leadership_familyaccent/result/00-base.xml
@@ -17,14 +17,14 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower2" multi="False" name="follower2" type="string">
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">rougail.general.leader.follower1</param>
+            <param notraisepropertyerror="False" type="variable">rougail.general.leader.follower1</param>
           </value>
         </variable>
       </leader>
diff --git a/tests/flattener_dicos/10leadership_familyaccent/tiramisu/__init__.py b/tests/flattener_dicos/10leadership_familyaccent/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_familyaccent/tiramisu/base.py b/tests/flattener_dicos/10leadership_familyaccent/tiramisu/base.py
new file mode 100644
index 00000000..93a03024
--- /dev/null
+++ b/tests/flattener_dicos/10leadership_familyaccent/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_6 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower2', multi=True, name='follower2', default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_4 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_5, option_6, option_7])
+option_2 = OptionDescription(doc='Général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10leadership_leadermandatory/__init__.py b/tests/flattener_dicos/10leadership_leadermandatory/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_leadermandatory/result/00-base.xml b/tests/flattener_dicos/10leadership_leadermandatory/result/00-base.xml
index bfe4f8d0..cc3edbf2 100644
--- a/tests/flattener_dicos/10leadership_leadermandatory/result/00-base.xml
+++ b/tests/flattener_dicos/10leadership_leadermandatory/result/00-base.xml
@@ -19,14 +19,14 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower2" multi="False" name="follower2" type="string">
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">rougail.general.leader.follower1</param>
+            <param notraisepropertyerror="False" type="variable">rougail.general.leader.follower1</param>
           </value>
         </variable>
       </leader>
diff --git a/tests/flattener_dicos/10leadership_leadermandatory/tiramisu/__init__.py b/tests/flattener_dicos/10leadership_leadermandatory/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_leadermandatory/tiramisu/base.py b/tests/flattener_dicos/10leadership_leadermandatory/tiramisu/base.py
new file mode 100644
index 00000000..402b772f
--- /dev/null
+++ b/tests/flattener_dicos/10leadership_leadermandatory/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = StrOption(properties=frozenset(['mandatory']), doc='leader', multi=True, name='leader')
+option_6 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower2', multi=True, name='follower2', default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_4 = Leadership(doc='leader', name='leader', properties=frozenset(['basic']), children=[option_5, option_6, option_7])
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['basic']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10leadership_mandatory/__init__.py b/tests/flattener_dicos/10leadership_mandatory/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_mandatory/result/00-base.xml b/tests/flattener_dicos/10leadership_mandatory/result/00-base.xml
index 98b255f8..7bdfd937 100644
--- a/tests/flattener_dicos/10leadership_mandatory/result/00-base.xml
+++ b/tests/flattener_dicos/10leadership_mandatory/result/00-base.xml
@@ -17,14 +17,14 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower2" multi="False" name="follower2" type="string">
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">rougail.general.leader.follower1</param>
+            <param notraisepropertyerror="False" type="variable">rougail.general.leader.follower1</param>
           </value>
         </variable>
       </leader>
diff --git a/tests/flattener_dicos/10leadership_mandatory/tiramisu/__init__.py b/tests/flattener_dicos/10leadership_mandatory/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_mandatory/tiramisu/base.py b/tests/flattener_dicos/10leadership_mandatory/tiramisu/base.py
new file mode 100644
index 00000000..3f9c1cb5
--- /dev/null
+++ b/tests/flattener_dicos/10leadership_mandatory/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_6 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower2', multi=True, name='follower2', default=Calculation(func.calc_val, Params((ParamOption(option_6, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_4 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_5, option_6, option_7])
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10leadership_mandatoryfollower/__init__.py b/tests/flattener_dicos/10leadership_mandatoryfollower/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_mandatoryfollower/tiramisu/__init__.py b/tests/flattener_dicos/10leadership_mandatoryfollower/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_mandatoryfollower/tiramisu/base.py b/tests/flattener_dicos/10leadership_mandatoryfollower/tiramisu/base.py
new file mode 100644
index 00000000..2757d82c
--- /dev/null
+++ b/tests/flattener_dicos/10leadership_mandatoryfollower/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_5 = NetmaskOption(properties=frozenset([]), doc='Masque de l\'IP du réseau de l\'esclave', multi=True, name='nut_monitor_netmask')
+option_6 = NetworkOption(properties=frozenset(['mandatory', 'normal']), doc='Adresse IP du réseau de l\'esclave', multi=True, name='nut_monitor_host')
+option_4 = Leadership(doc='Masque de l\'IP du réseau de l\'esclave', name='nut_monitor_netmask', properties=frozenset(['normal']), children=[option_5, option_6])
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10leadership_multi/__init__.py b/tests/flattener_dicos/10leadership_multi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_multi/result/00-base.xml b/tests/flattener_dicos/10leadership_multi/result/00-base.xml
index a0f9b2ce..810cc274 100644
--- a/tests/flattener_dicos/10leadership_multi/result/00-base.xml
+++ b/tests/flattener_dicos/10leadership_multi/result/00-base.xml
@@ -20,14 +20,14 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower2" multi="False" name="follower2" type="string">
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">rougail.general1.leader.follower1</param>
+            <param notraisepropertyerror="False" type="variable">rougail.general1.leader.follower1</param>
           </value>
         </variable>
       </leader>
diff --git a/tests/flattener_dicos/10leadership_multi/tiramisu/__init__.py b/tests/flattener_dicos/10leadership_multi/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10leadership_multi/tiramisu/base.py b/tests/flattener_dicos/10leadership_multi/tiramisu/base.py
new file mode 100644
index 00000000..f62fdd01
--- /dev/null
+++ b/tests/flattener_dicos/10leadership_multi/tiramisu/base.py
@@ -0,0 +1,17 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_6 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_8 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower2', multi=True, name='follower2', default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_5 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_6, option_7, option_8])
+option_10 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader1')
+option_11 = StrOption(properties=frozenset(['normal']), doc='follower1', multi=True, name='follower11')
+option_12 = StrOption(properties=frozenset(['normal']), doc='follower2', multi=True, name='follower21')
+option_9 = Leadership(doc='leader', name='leader1', properties=frozenset(['normal']), children=[option_10, option_11, option_12])
+option_4 = OptionDescription(doc='general1', name='general1', properties=frozenset(['normal']), children=[option_5, option_9])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_disabled_if_in/__init__.py b/tests/flattener_dicos/10load_disabled_if_in/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_disabled_if_in/tiramisu/__init__.py b/tests/flattener_dicos/10load_disabled_if_in/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_disabled_if_in/tiramisu/base.py b/tests/flattener_dicos/10load_disabled_if_in/tiramisu/base.py
new file mode 100644
index 00000000..458897bc
--- /dev/null
+++ b/tests/flattener_dicos/10load_disabled_if_in/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_disabled_if_in_none/__init__.py b/tests/flattener_dicos/10load_disabled_if_in_none/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_disabled_if_in_none/result/00-base.xml b/tests/flattener_dicos/10load_disabled_if_in_none/result/00-base.xml
index 2eb987ca..b255c002 100644
--- a/tests/flattener_dicos/10load_disabled_if_in_none/result/00-base.xml
+++ b/tests/flattener_dicos/10load_disabled_if_in_none/result/00-base.xml
@@ -6,7 +6,7 @@
       <variable doc="No change" multi="False" name="condition" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>non</value>
+        <value type="string">non</value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
         <choice type="string">oui</choice>
diff --git a/tests/flattener_dicos/10load_disabled_if_in_none/tiramisu/__init__.py b/tests/flattener_dicos/10load_disabled_if_in_none/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_disabled_if_in_none/tiramisu/base.py b/tests/flattener_dicos/10load_disabled_if_in_none/tiramisu/base.py
new file mode 100644
index 00000000..af47e446
--- /dev/null
+++ b/tests/flattener_dicos/10load_disabled_if_in_none/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non')
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('None')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('None')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_disabled_if_inaccent/__init__.py b/tests/flattener_dicos/10load_disabled_if_inaccent/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_disabled_if_inaccent/tiramisu/__init__.py b/tests/flattener_dicos/10load_disabled_if_inaccent/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_disabled_if_inaccent/tiramisu/base.py b/tests/flattener_dicos/10load_disabled_if_inaccent/tiramisu/base.py
new file mode 100644
index 00000000..e3d19caa
--- /dev/null
+++ b/tests/flattener_dicos/10load_disabled_if_inaccent/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='Général', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_7 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif3', default='non', values=('oui', 'non'))
+option_6 = OptionDescription(doc='Général2', name='general2', properties=frozenset(['normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), children=[option_7])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_6])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_disabledifin_fallback/__init__.py b/tests/flattener_dicos/10load_disabledifin_fallback/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_disabledifin_fallback/tiramisu/__init__.py b/tests/flattener_dicos/10load_disabledifin_fallback/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_disabledifin_fallback/tiramisu/base.py b/tests/flattener_dicos/10load_disabledifin_fallback/tiramisu/base.py
new file mode 100644
index 00000000..afffd24b
--- /dev/null
+++ b/tests/flattener_dicos/10load_disabledifin_fallback/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['disabled', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_disabledifin_whithouttype/__init__.py b/tests/flattener_dicos/10load_disabledifin_whithouttype/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_disabledifin_whithouttype/tiramisu/__init__.py b/tests/flattener_dicos/10load_disabledifin_whithouttype/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_disabledifin_whithouttype/tiramisu/base.py b/tests/flattener_dicos/10load_disabledifin_whithouttype/tiramisu/base.py
new file mode 100644
index 00000000..375b883d
--- /dev/null
+++ b/tests/flattener_dicos/10load_disabledifin_whithouttype/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_emptyvalue/__init__.py b/tests/flattener_dicos/10load_emptyvalue/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_emptyvalue/tiramisu/__init__.py b/tests/flattener_dicos/10load_emptyvalue/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_emptyvalue/tiramisu/base.py b/tests/flattener_dicos/10load_emptyvalue/tiramisu/base.py
new file mode 100644
index 00000000..34290d14
--- /dev/null
+++ b/tests/flattener_dicos/10load_emptyvalue/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = StrOption(properties=frozenset(['normal']), doc='No change', multi=False, name='mode_conteneur_actif')
+option_4 = StrOption(properties=frozenset(['normal']), doc='No change', multi=False, name='mode_conteneur_actif2')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_frozenifin/__init__.py b/tests/flattener_dicos/10load_frozenifin/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_frozenifin/tiramisu/__init__.py b/tests/flattener_dicos/10load_frozenifin/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_frozenifin/tiramisu/base.py b/tests/flattener_dicos/10load_frozenifin/tiramisu/base.py
new file mode 100644
index 00000000..5a4e9b0f
--- /dev/null
+++ b/tests/flattener_dicos/10load_frozenifin/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_frozenifin_auto/__init__.py b/tests/flattener_dicos/10load_frozenifin_auto/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_frozenifin_auto/result/00-base.xml b/tests/flattener_dicos/10load_frozenifin_auto/result/00-base.xml
index 565615f5..471a037a 100644
--- a/tests/flattener_dicos/10load_frozenifin_auto/result/00-base.xml
+++ b/tests/flattener_dicos/10load_frozenifin_auto/result/00-base.xml
@@ -19,7 +19,7 @@
         <property expected="oui" inverse="False" source="rougail.general.condition" type="calculation">hidden</property>
         <property expected="oui" inverse="False" source="rougail.general.condition" type="calculation">force_default_on_freeze</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="string">non</param>
+          <param type="string">non</param>
         </value>
       </variable>
       <variable doc="No change" multi="False" name="mode_conteneur_actif2" type="choice">
diff --git a/tests/flattener_dicos/10load_frozenifin_auto/tiramisu/__init__.py b/tests/flattener_dicos/10load_frozenifin_auto/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_frozenifin_auto/tiramisu/base.py b/tests/flattener_dicos/10load_frozenifin_auto/tiramisu/base.py
new file mode 100644
index 00000000..1ad4f7e4
--- /dev/null
+++ b/tests/flattener_dicos/10load_frozenifin_auto/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamValue("non")), kwargs={})), values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_frozenifin_multiparam/__init__.py b/tests/flattener_dicos/10load_frozenifin_multiparam/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_frozenifin_multiparam/tiramisu/__init__.py b/tests/flattener_dicos/10load_frozenifin_multiparam/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_frozenifin_multiparam/tiramisu/base.py b/tests/flattener_dicos/10load_frozenifin_multiparam/tiramisu/base.py
new file mode 100644
index 00000000..df835ed9
--- /dev/null
+++ b/tests/flattener_dicos/10load_frozenifin_multiparam/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='tous', values=('tous', 'authentifié', 'aucun'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('tous')})), Calculation(calc_value, Params(ParamValue('frozen'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')})), Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')})), Calculation(calc_value, Params(ParamValue('force_default_on_freeze'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('authentifié')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_frozenifin_noexist/__init__.py b/tests/flattener_dicos/10load_frozenifin_noexist/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_frozenifin_noexist/tiramisu/__init__.py b/tests/flattener_dicos/10load_frozenifin_noexist/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_frozenifin_noexist/tiramisu/base.py b/tests/flattener_dicos/10load_frozenifin_noexist/tiramisu/base.py
new file mode 100644
index 00000000..3569eaf5
--- /dev/null
+++ b/tests/flattener_dicos/10load_frozenifin_noexist/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='tous', values=('tous', 'authentifié', 'aucun'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_leadership/__init__.py b/tests/flattener_dicos/10load_leadership/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership/result/00-base.xml b/tests/flattener_dicos/10load_leadership/result/00-base.xml
index c06c854f..186bf70a 100644
--- a/tests/flattener_dicos/10load_leadership/result/00-base.xml
+++ b/tests/flattener_dicos/10load_leadership/result/00-base.xml
@@ -20,14 +20,14 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower2" multi="False" name="follower2" type="string">
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">rougail.general1.leader.follower1</param>
+            <param notraisepropertyerror="False" type="variable">rougail.general1.leader.follower1</param>
           </value>
         </variable>
       </leader>
diff --git a/tests/flattener_dicos/10load_leadership/tiramisu/__init__.py b/tests/flattener_dicos/10load_leadership/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership/tiramisu/base.py b/tests/flattener_dicos/10load_leadership/tiramisu/base.py
new file mode 100644
index 00000000..f2785bd2
--- /dev/null
+++ b/tests/flattener_dicos/10load_leadership/tiramisu/base.py
@@ -0,0 +1,13 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_6 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_8 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower2', multi=True, name='follower2', default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_5 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_6, option_7, option_8])
+option_4 = OptionDescription(doc='general1', name='general1', properties=frozenset(['normal']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_leadership_default_multi/__init__.py b/tests/flattener_dicos/10load_leadership_default_multi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership_default_multi/result/00-base.xml b/tests/flattener_dicos/10load_leadership_default_multi/result/00-base.xml
index 4ca21273..967f6fb6 100644
--- a/tests/flattener_dicos/10load_leadership_default_multi/result/00-base.xml
+++ b/tests/flattener_dicos/10load_leadership_default_multi/result/00-base.xml
@@ -16,7 +16,7 @@
         <variable doc="follower1" multi="False" name="follower1" type="string">
           <property>mandatory</property>
           <property>normal</property>
-          <value>value</value>
+          <value type="string">value</value>
         </variable>
         <variable doc="follower2" multi="False" name="follower2" type="string">
           <property>normal</property>
diff --git a/tests/flattener_dicos/10load_leadership_default_multi/tiramisu/__init__.py b/tests/flattener_dicos/10load_leadership_default_multi/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership_default_multi/tiramisu/base.py b/tests/flattener_dicos/10load_leadership_default_multi/tiramisu/base.py
new file mode 100644
index 00000000..62bc880e
--- /dev/null
+++ b/tests/flattener_dicos/10load_leadership_default_multi/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='leader', multi=True, name='mode_conteneur_actif', default=['non'], default_multi='non', values=('oui', 'non'))
+option_5 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_6 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default_multi='value')
+option_7 = StrOption(properties=frozenset(['normal']), doc='follower2', multi=True, name='follower2')
+option_4 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_5, option_6, option_7])
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_leadership_default_submulti/__init__.py b/tests/flattener_dicos/10load_leadership_default_submulti/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership_default_submulti/result/00-base.xml b/tests/flattener_dicos/10load_leadership_default_submulti/result/00-base.xml
index d6bf8cf7..2d5ef235 100644
--- a/tests/flattener_dicos/10load_leadership_default_submulti/result/00-base.xml
+++ b/tests/flattener_dicos/10load_leadership_default_submulti/result/00-base.xml
@@ -14,18 +14,18 @@
         <property>normal</property>
         <variable doc="leader" multi="True" name="leader" type="string">
           <property>mandatory</property>
-          <value>leader</value>
+          <value type="string">leader</value>
         </variable>
         <variable doc="follower1" multi="True" name="follower1" type="string">
           <property>mandatory</property>
           <property>normal</property>
-          <value>value</value>
+          <value type="string">value</value>
         </variable>
         <variable doc="follower2" multi="True" name="follower2" type="string">
           <property>mandatory</property>
           <property>normal</property>
-          <value>value1</value>
-          <value>value2</value>
+          <value type="string">value1</value>
+          <value type="string">value2</value>
         </variable>
       </leader>
     </family>
diff --git a/tests/flattener_dicos/10load_leadership_default_submulti/tiramisu/__init__.py b/tests/flattener_dicos/10load_leadership_default_submulti/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership_default_submulti/tiramisu/base.py b/tests/flattener_dicos/10load_leadership_default_submulti/tiramisu/base.py
new file mode 100644
index 00000000..a4cfae7e
--- /dev/null
+++ b/tests/flattener_dicos/10load_leadership_default_submulti/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='leader', multi=True, name='mode_conteneur_actif', default=['non'], default_multi='non', values=('oui', 'non'))
+option_5 = StrOption(properties=frozenset(['mandatory']), doc='leader', multi=True, name='leader', default=['leader'])
+option_6 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower1', multi=submulti, name='follower1', default_multi=['value'])
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower2', multi=submulti, name='follower2', default_multi=['value1', 'value2'])
+option_4 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_5, option_6, option_7])
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_leadership_defaultmulti_leader/__init__.py b/tests/flattener_dicos/10load_leadership_defaultmulti_leader/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership_defaultmulti_leader/result/00-base.xml b/tests/flattener_dicos/10load_leadership_defaultmulti_leader/result/00-base.xml
index e19e6f5a..fa686607 100644
--- a/tests/flattener_dicos/10load_leadership_defaultmulti_leader/result/00-base.xml
+++ b/tests/flattener_dicos/10load_leadership_defaultmulti_leader/result/00-base.xml
@@ -14,7 +14,7 @@
         <property>normal</property>
         <variable doc="leader" multi="True" name="leader" type="string">
           <property>mandatory</property>
-          <value>value</value>
+          <value type="string">value</value>
         </variable>
         <variable doc="follower1" multi="False" name="follower1" type="string">
           <property>normal</property>
diff --git a/tests/flattener_dicos/10load_leadership_defaultmulti_leader/tiramisu/__init__.py b/tests/flattener_dicos/10load_leadership_defaultmulti_leader/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership_defaultmulti_leader/tiramisu/base.py b/tests/flattener_dicos/10load_leadership_defaultmulti_leader/tiramisu/base.py
new file mode 100644
index 00000000..aeb5df56
--- /dev/null
+++ b/tests/flattener_dicos/10load_leadership_defaultmulti_leader/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='leader', multi=True, name='mode_conteneur_actif', default=['non'], default_multi='non', values=('oui', 'non'))
+option_5 = StrOption(properties=frozenset(['mandatory']), doc='leader', multi=True, name='leader', default=['value'])
+option_6 = StrOption(properties=frozenset(['normal']), doc='follower1', multi=True, name='follower1')
+option_7 = StrOption(properties=frozenset(['normal']), doc='follower2', multi=True, name='follower2')
+option_4 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_5, option_6, option_7])
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_leadership_description/__init__.py b/tests/flattener_dicos/10load_leadership_description/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership_description/result/00-base.xml b/tests/flattener_dicos/10load_leadership_description/result/00-base.xml
index 9a59841b..9afe68aa 100644
--- a/tests/flattener_dicos/10load_leadership_description/result/00-base.xml
+++ b/tests/flattener_dicos/10load_leadership_description/result/00-base.xml
@@ -20,14 +20,14 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower2" multi="False" name="follower2" type="string">
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">rougail.general1.leader.follower1</param>
+            <param notraisepropertyerror="False" type="variable">rougail.general1.leader.follower1</param>
           </value>
         </variable>
       </leader>
diff --git a/tests/flattener_dicos/10load_leadership_description/tiramisu/__init__.py b/tests/flattener_dicos/10load_leadership_description/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership_description/tiramisu/base.py b/tests/flattener_dicos/10load_leadership_description/tiramisu/base.py
new file mode 100644
index 00000000..4223d908
--- /dev/null
+++ b/tests/flattener_dicos/10load_leadership_description/tiramisu/base.py
@@ -0,0 +1,13 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_6 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_8 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower2', multi=True, name='follower2', default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_5 = Leadership(doc='other description', name='leader', properties=frozenset(['normal']), children=[option_6, option_7, option_8])
+option_4 = OptionDescription(doc='general1', name='general1', properties=frozenset(['normal']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_leadership_normalize_family/__init__.py b/tests/flattener_dicos/10load_leadership_normalize_family/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership_normalize_family/tiramisu/__init__.py b/tests/flattener_dicos/10load_leadership_normalize_family/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership_normalize_family/tiramisu/base.py b/tests/flattener_dicos/10load_leadership_normalize_family/tiramisu/base.py
new file mode 100644
index 00000000..25f0d1fc
--- /dev/null
+++ b/tests/flattener_dicos/10load_leadership_normalize_family/tiramisu/base.py
@@ -0,0 +1,13 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_6 = StrOption(properties=frozenset(['mandatory']), doc='leader', multi=True, name='leader')
+option_7 = StrOption(properties=frozenset(['normal']), doc='follower1', multi=True, name='follower1')
+option_8 = StrOption(properties=frozenset(['normal']), doc='follower2', multi=True, name='follower2')
+option_5 = Leadership(doc='leader', name='leader', properties=frozenset(['basic']), children=[option_6, option_7, option_8])
+option_4 = OptionDescription(doc='general-1', name='general_1', properties=frozenset(['basic']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_leadership_submulti/__init__.py b/tests/flattener_dicos/10load_leadership_submulti/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership_submulti/result/00-base.xml b/tests/flattener_dicos/10load_leadership_submulti/result/00-base.xml
index ee134b75..b8e45586 100644
--- a/tests/flattener_dicos/10load_leadership_submulti/result/00-base.xml
+++ b/tests/flattener_dicos/10load_leadership_submulti/result/00-base.xml
@@ -20,14 +20,14 @@
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower2" multi="True" name="follower2" type="string">
           <property>mandatory</property>
           <property>normal</property>
           <value name="calc_val" type="calculation">
-            <param transitive="False" type="variable">rougail.general1.leader.follower1</param>
+            <param notraisepropertyerror="False" type="variable">rougail.general1.leader.follower1</param>
           </value>
         </variable>
       </leader>
diff --git a/tests/flattener_dicos/10load_leadership_submulti/tiramisu/__init__.py b/tests/flattener_dicos/10load_leadership_submulti/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_leadership_submulti/tiramisu/base.py b/tests/flattener_dicos/10load_leadership_submulti/tiramisu/base.py
new file mode 100644
index 00000000..c104f422
--- /dev/null
+++ b/tests/flattener_dicos/10load_leadership_submulti/tiramisu/base.py
@@ -0,0 +1,13 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_6 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_8 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='follower2', multi=submulti, name='follower2', default=Calculation(func.calc_val, Params((ParamOption(option_7, notraisepropertyerror=False, todict=False)), kwargs={})), default_multi=[])
+option_5 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_6, option_7, option_8])
+option_4 = OptionDescription(doc='general1', name='general1', properties=frozenset(['normal']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_mandatoryifin/__init__.py b/tests/flattener_dicos/10load_mandatoryifin/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_mandatoryifin/tiramisu/__init__.py b/tests/flattener_dicos/10load_mandatoryifin/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_mandatoryifin/tiramisu/base.py b/tests/flattener_dicos/10load_mandatoryifin/tiramisu/base.py
new file mode 100644
index 00000000..ee84abe7
--- /dev/null
+++ b/tests/flattener_dicos/10load_mandatoryifin/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('mandatory'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('mandatory'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10load_multivalue/__init__.py b/tests/flattener_dicos/10load_multivalue/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_multivalue/tiramisu/__init__.py b/tests/flattener_dicos/10load_multivalue/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10load_multivalue/tiramisu/base.py b/tests/flattener_dicos/10load_multivalue/tiramisu/base.py
new file mode 100644
index 00000000..e2cfe856
--- /dev/null
+++ b/tests/flattener_dicos/10load_multivalue/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=True, name='mode_conteneur_actif', default=['non', 'oui'], default_multi='oui', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_accent/__init__.py b/tests/flattener_dicos/10valid_enum_accent/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_accent/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_accent/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_accent/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_accent/tiramisu/base.py
new file mode 100644
index 00000000..b91f4523
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_accent/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['expert']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='multi', multi=False, name='enumvar', default='c', values=('a', 'b', 'c', 'é'))
+option_5.impl_set_information("help", "bla bla bla")
+option_4 = OptionDescription(doc='enumfam', name='enumfam', properties=frozenset(['expert']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_base/__init__.py b/tests/flattener_dicos/10valid_enum_base/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_base/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_base/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_base/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_base/tiramisu/base.py
new file mode 100644
index 00000000..23b94178
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_base/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['expert']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='multi', multi=False, name='enumvar', default='c', values=('a', 'b', 'c'))
+option_5.impl_set_information("help", "bla bla bla")
+option_4 = OptionDescription(doc='enumfam', name='enumfam', properties=frozenset(['expert']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_base_redefine/__init__.py b/tests/flattener_dicos/10valid_enum_base_redefine/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_base_redefine/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_base_redefine/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_base_redefine/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_base_redefine/tiramisu/base.py
new file mode 100644
index 00000000..b490f5ae
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_base_redefine/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['expert']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='multi', multi=False, name='enumvar2', default='c', values=('a', 'b', 'c'))
+option_6 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='multi', multi=False, name='enumvar', default='c', values=('a', 'c'))
+option_6.impl_set_information("help", "bla bla bla")
+option_4 = OptionDescription(doc='enumfam', name='enumfam', properties=frozenset(['expert']), children=[option_5, option_6])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_checkval_true/__init__.py b/tests/flattener_dicos/10valid_enum_checkval_true/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_checkval_true/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_checkval_true/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_checkval_true/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_checkval_true/tiramisu/base.py
new file mode 100644
index 00000000..d12b43e6
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_checkval_true/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='a', values=('a', 'b', 'c'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_eosfunc/__init__.py b/tests/flattener_dicos/10valid_enum_eosfunc/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_eosfunc/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_eosfunc/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_eosfunc/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_eosfunc/tiramisu/base.py
new file mode 100644
index 00000000..540734b7
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_eosfunc/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_leader/__init__.py b/tests/flattener_dicos/10valid_enum_leader/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_leader/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_leader/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_leader/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_leader/tiramisu/base.py
new file mode 100644
index 00000000..a0069088
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_leader/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_6 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='follower1', multi=True, name='follower1', default_multi='a', values=('a', 'b', 'c'))
+option_7 = StrOption(properties=frozenset(['normal']), doc='follower2', multi=True, name='follower2')
+option_4 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_5, option_6, option_7])
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_mandatory/__init__.py b/tests/flattener_dicos/10valid_enum_mandatory/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_mandatory/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_mandatory/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_mandatory/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_mandatory/tiramisu/base.py
new file mode 100644
index 00000000..2e93b8f5
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_mandatory/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['expert']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='multi', multi=False, name='enumvar', default='a', values=('a', 'b', 'c'))
+option_4 = OptionDescription(doc='enumfam', name='enumfam', properties=frozenset(['expert']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_multi/__init__.py b/tests/flattener_dicos/10valid_enum_multi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_multi/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_multi/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_multi/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_multi/tiramisu/base.py
new file mode 100644
index 00000000..f1b23d06
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_multi/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='multi', multi=True, name='multi', default=['a'], default_multi='a', values=('a', 'b', 'c'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_none/__init__.py b/tests/flattener_dicos/10valid_enum_none/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_none/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_none/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_none/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_none/tiramisu/base.py
new file mode 100644
index 00000000..637c347a
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_none/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['expert']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='multi', multi=False, name='enumvar', default='b', values=('a', 'b', None))
+option_5.impl_set_information("help", "bla bla bla")
+option_4 = OptionDescription(doc='enumfam', name='enumfam', properties=frozenset(['expert']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_number/__init__.py b/tests/flattener_dicos/10valid_enum_number/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_number/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_number/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_number/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_number/tiramisu/base.py
new file mode 100644
index 00000000..5285de74
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_number/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['expert']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='enumvar', multi=False, name='enumvar', default=1, values=(1, 2, 3))
+option_5.impl_set_information("help", "bla bla bla")
+option_4 = OptionDescription(doc='enumfam', name='enumfam', properties=frozenset(['expert']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_numberdefault/__init__.py b/tests/flattener_dicos/10valid_enum_numberdefault/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_numberdefault/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_numberdefault/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_numberdefault/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_numberdefault/tiramisu/base.py
new file mode 100644
index 00000000..92588dfa
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_numberdefault/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['expert']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='enumvar', multi=False, name='enumvar', default=3, values=(1, 2, 3))
+option_5.impl_set_information("help", "bla bla bla")
+option_4 = OptionDescription(doc='enumfam', name='enumfam', properties=frozenset(['expert']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_python/__init__.py b/tests/flattener_dicos/10valid_enum_python/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_python/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_python/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_python/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_python/tiramisu/base.py
new file mode 100644
index 00000000..1dfe8dd2
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_python/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['expert']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'expert']), doc='multi', multi=False, name='enumvar', default='test', values=('test',))
+option_5.impl_set_information("help", "bla bla bla")
+option_4 = OptionDescription(doc='enumfam', name='enumfam', properties=frozenset(['expert']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/10valid_enum_value/__init__.py b/tests/flattener_dicos/10valid_enum_value/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_value/tiramisu/__init__.py b/tests/flattener_dicos/10valid_enum_value/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/10valid_enum_value/tiramisu/base.py b/tests/flattener_dicos/10valid_enum_value/tiramisu/base.py
new file mode 100644
index 00000000..e564dece
--- /dev/null
+++ b/tests/flattener_dicos/10valid_enum_value/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='b', values=('a', 'b', 'c'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/11disabled_if_in_filelist/__init__.py b/tests/flattener_dicos/11disabled_if_in_filelist/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabled_if_in_filelist/result/00-base.xml b/tests/flattener_dicos/11disabled_if_in_filelist/result/00-base.xml
index bd771116..f0c16049 100644
--- a/tests/flattener_dicos/11disabled_if_in_filelist/result/00-base.xml
+++ b/tests/flattener_dicos/11disabled_if_in_filelist/result/00-base.xml
@@ -6,26 +6,26 @@
       <family name="files" doc="files">
         <family doc="file" name="file">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/etc/file</value>
+            <value type="string">/etc/file</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>file</value>
+            <value type="string">file</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
             <property expected="oui" inverse="False" source="rougail.general.condition" type="calculation">disabled</property>
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/11disabled_if_in_filelist/tiramisu/__init__.py b/tests/flattener_dicos/11disabled_if_in_filelist/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabled_if_in_filelist/tiramisu/base.py b/tests/flattener_dicos/11disabled_if_in_filelist/tiramisu/base.py
new file mode 100644
index 00000000..c1c482a0
--- /dev/null
+++ b/tests/flattener_dicos/11disabled_if_in_filelist/tiramisu/base.py
@@ -0,0 +1,21 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = BoolOption(default=True, properties=frozenset(['normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_10 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_11 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_12 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/etc/file')
+option_13 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_14 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='file')
+option_15 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_16 = BoolOption(default=True, properties=frozenset([Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='activate', multi=False, name='activate')
+option_9 = OptionDescription(doc='file', name='file', children=[option_10, option_11, option_12, option_13, option_14, option_15, option_16])
+option_8 = OptionDescription(name='files', doc='files', children=[option_9])
+option_7 = OptionDescription(doc='test', name='test', children=[option_8])
+option_6 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_7])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_6])
diff --git a/tests/flattener_dicos/11disabled_if_in_filelist_disabled/__init__.py b/tests/flattener_dicos/11disabled_if_in_filelist_disabled/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabled_if_in_filelist_disabled/result/00-base.xml b/tests/flattener_dicos/11disabled_if_in_filelist_disabled/result/00-base.xml
index f4c96f6b..df74ad65 100644
--- a/tests/flattener_dicos/11disabled_if_in_filelist_disabled/result/00-base.xml
+++ b/tests/flattener_dicos/11disabled_if_in_filelist_disabled/result/00-base.xml
@@ -6,26 +6,26 @@
       <family name="files" doc="files">
         <family doc="file" name="file">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/etc/file</value>
+            <value type="string">/etc/file</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>file</value>
+            <value type="string">file</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
             <property expected="oui" inverse="False" source="rougail.general.condition" type="calculation">disabled</property>
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/11disabled_if_in_filelist_disabled/tiramisu/__init__.py b/tests/flattener_dicos/11disabled_if_in_filelist_disabled/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabled_if_in_filelist_disabled/tiramisu/base.py b/tests/flattener_dicos/11disabled_if_in_filelist_disabled/tiramisu/base.py
new file mode 100644
index 00000000..7c26fc1e
--- /dev/null
+++ b/tests/flattener_dicos/11disabled_if_in_filelist_disabled/tiramisu/base.py
@@ -0,0 +1,21 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='oui', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_10 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_11 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_12 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/etc/file')
+option_13 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_14 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='file')
+option_15 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_16 = BoolOption(default=True, properties=frozenset([Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='activate', multi=False, name='activate')
+option_9 = OptionDescription(doc='file', name='file', children=[option_10, option_11, option_12, option_13, option_14, option_15, option_16])
+option_8 = OptionDescription(name='files', doc='files', children=[option_9])
+option_7 = OptionDescription(doc='test', name='test', children=[option_8])
+option_6 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_7])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_6])
diff --git a/tests/flattener_dicos/11disabled_if_in_filelist_multi/__init__.py b/tests/flattener_dicos/11disabled_if_in_filelist_multi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabled_if_in_filelist_multi/result/00-base.xml b/tests/flattener_dicos/11disabled_if_in_filelist_multi/result/00-base.xml
index 6cc80b32..98ca9406 100644
--- a/tests/flattener_dicos/11disabled_if_in_filelist_multi/result/00-base.xml
+++ b/tests/flattener_dicos/11disabled_if_in_filelist_multi/result/00-base.xml
@@ -6,50 +6,50 @@
       <family name="files" doc="files">
         <family doc="file1" name="file1">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/tmp/file1</value>
+            <value type="string">/tmp/file1</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>file1</value>
+            <value type="string">file1</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
             <property expected="oui" inverse="False" source="rougail.general.condition" type="calculation">disabled</property>
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
         <family doc="file2" name="file2">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/tmp/file2</value>
+            <value type="string">/tmp/file2</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>file2</value>
+            <value type="string">file2</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
             <property expected="oui" inverse="False" source="rougail.general.condition" type="calculation">disabled</property>
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/11disabled_if_in_filelist_multi/tiramisu/__init__.py b/tests/flattener_dicos/11disabled_if_in_filelist_multi/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabled_if_in_filelist_multi/tiramisu/base.py b/tests/flattener_dicos/11disabled_if_in_filelist_multi/tiramisu/base.py
new file mode 100644
index 00000000..d85fe558
--- /dev/null
+++ b/tests/flattener_dicos/11disabled_if_in_filelist_multi/tiramisu/base.py
@@ -0,0 +1,29 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_10 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_11 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_12 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/tmp/file1')
+option_13 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_14 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='file1')
+option_15 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_16 = BoolOption(default=True, properties=frozenset([Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='activate', multi=False, name='activate')
+option_9 = OptionDescription(doc='file1', name='file1', children=[option_10, option_11, option_12, option_13, option_14, option_15, option_16])
+option_18 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_19 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_20 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/tmp/file2')
+option_21 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_22 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='file2')
+option_23 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_24 = BoolOption(default=True, properties=frozenset([Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), doc='activate', multi=False, name='activate')
+option_17 = OptionDescription(doc='file2', name='file2', children=[option_18, option_19, option_20, option_21, option_22, option_23, option_24])
+option_8 = OptionDescription(name='files', doc='files', children=[option_9, option_17])
+option_7 = OptionDescription(doc='test', name='test', children=[option_8])
+option_6 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_7])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_6])
diff --git a/tests/flattener_dicos/11disabledifin_filelist_notexist/__init__.py b/tests/flattener_dicos/11disabledifin_filelist_notexist/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabledifin_filelist_notexist/result/00-base.xml b/tests/flattener_dicos/11disabledifin_filelist_notexist/result/00-base.xml
index 5eada970..c2672b11 100644
--- a/tests/flattener_dicos/11disabledifin_filelist_notexist/result/00-base.xml
+++ b/tests/flattener_dicos/11disabledifin_filelist_notexist/result/00-base.xml
@@ -6,26 +6,26 @@
       <family name="files" doc="files">
         <family doc="file" name="file">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/tmp/file</value>
+            <value type="string">/tmp/file</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>file</value>
+            <value type="string">file</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
             <property>disabled</property>
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/11disabledifin_filelist_notexist/tiramisu/__init__.py b/tests/flattener_dicos/11disabledifin_filelist_notexist/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabledifin_filelist_notexist/tiramisu/base.py b/tests/flattener_dicos/11disabledifin_filelist_notexist/tiramisu/base.py
new file mode 100644
index 00000000..1233c6fa
--- /dev/null
+++ b/tests/flattener_dicos/11disabledifin_filelist_notexist/tiramisu/base.py
@@ -0,0 +1,21 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_10 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_11 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_12 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/tmp/file')
+option_13 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_14 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='file')
+option_15 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_16 = BoolOption(default=True, properties=frozenset(['disabled']), doc='activate', multi=False, name='activate')
+option_9 = OptionDescription(doc='file', name='file', children=[option_10, option_11, option_12, option_13, option_14, option_15, option_16])
+option_8 = OptionDescription(name='files', doc='files', children=[option_9])
+option_7 = OptionDescription(doc='test', name='test', children=[option_8])
+option_6 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_7])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_6])
diff --git a/tests/flattener_dicos/11disabledifnotin_filelist_notexist/__init__.py b/tests/flattener_dicos/11disabledifnotin_filelist_notexist/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabledifnotin_filelist_notexist/result/00-base.xml b/tests/flattener_dicos/11disabledifnotin_filelist_notexist/result/00-base.xml
index 5eada970..c2672b11 100644
--- a/tests/flattener_dicos/11disabledifnotin_filelist_notexist/result/00-base.xml
+++ b/tests/flattener_dicos/11disabledifnotin_filelist_notexist/result/00-base.xml
@@ -6,26 +6,26 @@
       <family name="files" doc="files">
         <family doc="file" name="file">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/tmp/file</value>
+            <value type="string">/tmp/file</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>file</value>
+            <value type="string">file</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
             <property>disabled</property>
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/11disabledifnotin_filelist_notexist/tiramisu/__init__.py b/tests/flattener_dicos/11disabledifnotin_filelist_notexist/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabledifnotin_filelist_notexist/tiramisu/base.py b/tests/flattener_dicos/11disabledifnotin_filelist_notexist/tiramisu/base.py
new file mode 100644
index 00000000..1233c6fa
--- /dev/null
+++ b/tests/flattener_dicos/11disabledifnotin_filelist_notexist/tiramisu/base.py
@@ -0,0 +1,21 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_10 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_11 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_12 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/tmp/file')
+option_13 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_14 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='file')
+option_15 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_16 = BoolOption(default=True, properties=frozenset(['disabled']), doc='activate', multi=False, name='activate')
+option_9 = OptionDescription(doc='file', name='file', children=[option_10, option_11, option_12, option_13, option_14, option_15, option_16])
+option_8 = OptionDescription(name='files', doc='files', children=[option_9])
+option_7 = OptionDescription(doc='test', name='test', children=[option_8])
+option_6 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_7])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_6])
diff --git a/tests/flattener_dicos/11disabledifnotin_filelist_notexist_multi/__init__.py b/tests/flattener_dicos/11disabledifnotin_filelist_notexist_multi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabledifnotin_filelist_notexist_multi/result/00-base.xml b/tests/flattener_dicos/11disabledifnotin_filelist_notexist_multi/result/00-base.xml
index e896df29..70c8f2f1 100644
--- a/tests/flattener_dicos/11disabledifnotin_filelist_notexist_multi/result/00-base.xml
+++ b/tests/flattener_dicos/11disabledifnotin_filelist_notexist_multi/result/00-base.xml
@@ -6,27 +6,27 @@
       <family name="files" doc="files">
         <family doc="file" name="file">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/tmp/file</value>
+            <value type="string">/tmp/file</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>file</value>
+            <value type="string">file</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
             <property>disabled</property>
             <property expected="oui" inverse="True" source="rougail.general.mode_conteneur_actif2" type="calculation">disabled</property>
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/11disabledifnotin_filelist_notexist_multi/tiramisu/__init__.py b/tests/flattener_dicos/11disabledifnotin_filelist_notexist_multi/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabledifnotin_filelist_notexist_multi/tiramisu/base.py b/tests/flattener_dicos/11disabledifnotin_filelist_notexist_multi/tiramisu/base.py
new file mode 100644
index 00000000..f8ace6e9
--- /dev/null
+++ b/tests/flattener_dicos/11disabledifnotin_filelist_notexist_multi/tiramisu/base.py
@@ -0,0 +1,21 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_10 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_11 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_12 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/tmp/file')
+option_13 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_14 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='file')
+option_15 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_16 = BoolOption(default=True, properties=frozenset(['disabled', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_5, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))]), doc='activate', multi=False, name='activate')
+option_9 = OptionDescription(doc='file', name='file', children=[option_10, option_11, option_12, option_13, option_14, option_15, option_16])
+option_8 = OptionDescription(name='files', doc='files', children=[option_9])
+option_7 = OptionDescription(doc='test', name='test', children=[option_8])
+option_6 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_7])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_6])
diff --git a/tests/flattener_dicos/11disabledifnotin_filelist_notexist_validenum/__init__.py b/tests/flattener_dicos/11disabledifnotin_filelist_notexist_validenum/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabledifnotin_filelist_notexist_validenum/result/00-base.xml b/tests/flattener_dicos/11disabledifnotin_filelist_notexist_validenum/result/00-base.xml
index 163f681c..3ae01a7c 100644
--- a/tests/flattener_dicos/11disabledifnotin_filelist_notexist_validenum/result/00-base.xml
+++ b/tests/flattener_dicos/11disabledifnotin_filelist_notexist_validenum/result/00-base.xml
@@ -6,26 +6,26 @@
       <family name="files" doc="files">
         <family doc="file" name="file">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/tmp/file</value>
+            <value type="string">/tmp/file</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>file</value>
+            <value type="string">file</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
             <property expected="statique" inverse="True" source="rougail.general.condition" type="calculation">disabled</property>
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/11disabledifnotin_filelist_notexist_validenum/tiramisu/__init__.py b/tests/flattener_dicos/11disabledifnotin_filelist_notexist_validenum/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11disabledifnotin_filelist_notexist_validenum/tiramisu/base.py b/tests/flattener_dicos/11disabledifnotin_filelist_notexist_validenum/tiramisu/base.py
new file mode 100644
index 00000000..b92a0330
--- /dev/null
+++ b/tests/flattener_dicos/11disabledifnotin_filelist_notexist_validenum/tiramisu/base.py
@@ -0,0 +1,21 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('non', 'statique'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_10 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_11 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_12 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/tmp/file')
+option_13 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_14 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='file')
+option_15 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_16 = BoolOption(default=True, properties=frozenset([Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('statique'), 'reverse_condition': ParamValue(True)}))]), doc='activate', multi=False, name='activate')
+option_9 = OptionDescription(doc='file', name='file', children=[option_10, option_11, option_12, option_13, option_14, option_15, option_16])
+option_8 = OptionDescription(name='files', doc='files', children=[option_9])
+option_7 = OptionDescription(doc='test', name='test', children=[option_8])
+option_6 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_7])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_6])
diff --git a/tests/flattener_dicos/11multi_disabled_if_in_filelist/__init__.py b/tests/flattener_dicos/11multi_disabled_if_in_filelist/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11multi_disabled_if_in_filelist/result/00-base.xml b/tests/flattener_dicos/11multi_disabled_if_in_filelist/result/00-base.xml
index 9f0f0859..254132a5 100644
--- a/tests/flattener_dicos/11multi_disabled_if_in_filelist/result/00-base.xml
+++ b/tests/flattener_dicos/11multi_disabled_if_in_filelist/result/00-base.xml
@@ -6,25 +6,25 @@
       <family name="files" doc="files">
         <family doc="file1" name="file1">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/tmp/file1</value>
+            <value type="string">/tmp/file1</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>file1</value>
+            <value type="string">file1</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>False</value>
+            <value type="boolean">False</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/11multi_disabled_if_in_filelist/tiramisu/__init__.py b/tests/flattener_dicos/11multi_disabled_if_in_filelist/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/11multi_disabled_if_in_filelist/tiramisu/base.py b/tests/flattener_dicos/11multi_disabled_if_in_filelist/tiramisu/base.py
new file mode 100644
index 00000000..8e1376f4
--- /dev/null
+++ b/tests/flattener_dicos/11multi_disabled_if_in_filelist/tiramisu/base.py
@@ -0,0 +1,20 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_9 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_10 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_11 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/tmp/file1')
+option_12 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_13 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='file1')
+option_14 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_15 = BoolOption(default=False, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_8 = OptionDescription(doc='file1', name='file1', children=[option_9, option_10, option_11, option_12, option_13, option_14, option_15])
+option_7 = OptionDescription(name='files', doc='files', children=[option_8])
+option_6 = OptionDescription(doc='test', name='test', children=[option_7])
+option_5 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_6])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_5])
diff --git a/tests/flattener_dicos/20family_append/__init__.py b/tests/flattener_dicos/20family_append/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_append/tiramisu/__init__.py b/tests/flattener_dicos/20family_append/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_append/tiramisu/base.py b/tests/flattener_dicos/20family_append/tiramisu/base.py
new file mode 100644
index 00000000..5d820e02
--- /dev/null
+++ b/tests/flattener_dicos/20family_append/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/20family_appendaccent/__init__.py b/tests/flattener_dicos/20family_appendaccent/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_appendaccent/tiramisu/__init__.py b/tests/flattener_dicos/20family_appendaccent/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_appendaccent/tiramisu/base.py b/tests/flattener_dicos/20family_appendaccent/tiramisu/base.py
new file mode 100644
index 00000000..860882f3
--- /dev/null
+++ b/tests/flattener_dicos/20family_appendaccent/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_7 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif3', default='non', values=('oui', 'non'))
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_7, todict=True), 'expected': ParamValue('non')}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='Général', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_6 = OptionDescription(doc='Other', name='other', properties=frozenset(['normal']), children=[option_7])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_6])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/20family_dynamic/__init__.py b/tests/flattener_dicos/20family_dynamic/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_dynamic/result/00-base.xml b/tests/flattener_dicos/20family_dynamic/result/00-base.xml
index 3369aefa..8153bca8 100644
--- a/tests/flattener_dicos/20family_dynamic/result/00-base.xml
+++ b/tests/flattener_dicos/20family_dynamic/result/00-base.xml
@@ -6,8 +6,8 @@
       <variable doc="No change" multi="True" name="varname" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>val1</value>
-        <value>val2</value>
+        <value type="string">val1</value>
+        <value type="string">val2</value>
       </variable>
     </family>
     <family dynamic="rougail.general.varname" doc="dyn" name="dyn">
diff --git a/tests/flattener_dicos/20family_dynamic/tiramisu/__init__.py b/tests/flattener_dicos/20family_dynamic/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_dynamic/tiramisu/base.py b/tests/flattener_dicos/20family_dynamic/tiramisu/base.py
new file mode 100644
index 00000000..8d2275fb
--- /dev/null
+++ b/tests/flattener_dicos/20family_dynamic/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=True, name='varname', default=['val1', 'val2'], default_multi='val2')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_5 = StrOption(properties=frozenset(['normal']), doc='No change', multi=False, name='vardyn')
+option_4 = ConvertDynOptionDescription(suffixes=Calculation(func.calc_value, Params((ParamOption(option_3)))), doc='dyn', name='dyn', properties=frozenset(['normal']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/20family_dynamic_calc/__init__.py b/tests/flattener_dicos/20family_dynamic_calc/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_dynamic_calc/result/00-base.xml b/tests/flattener_dicos/20family_dynamic_calc/result/00-base.xml
index 5b67434c..4c6a714f 100644
--- a/tests/flattener_dicos/20family_dynamic_calc/result/00-base.xml
+++ b/tests/flattener_dicos/20family_dynamic_calc/result/00-base.xml
@@ -6,8 +6,8 @@
       <variable doc="No change" multi="True" name="varname" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>val1</value>
-        <value>val2</value>
+        <value type="string">val1</value>
+        <value type="string">val2</value>
       </variable>
     </family>
     <family dynamic="rougail.general.varname" doc="dyn" name="dyn">
@@ -15,7 +15,7 @@
       <variable doc="No change" multi="False" name="vardyn" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>val</value>
+        <value type="string">val</value>
       </variable>
     </family>
     <family doc="new" name="new">
@@ -24,7 +24,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param suffix="val1" transitive="False" type="variable">rougail.dyn.vardyn</param>
+          <param notraisepropertyerror="False" suffix="val1" type="variable">rougail.dyn.vardyn</param>
         </value>
       </variable>
     </family>
diff --git a/tests/flattener_dicos/20family_dynamic_calc/tiramisu/__init__.py b/tests/flattener_dicos/20family_dynamic_calc/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_dynamic_calc/tiramisu/base.py b/tests/flattener_dicos/20family_dynamic_calc/tiramisu/base.py
new file mode 100644
index 00000000..f0cf7135
--- /dev/null
+++ b/tests/flattener_dicos/20family_dynamic_calc/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=True, name='varname', default=['val1', 'val2'], default_multi='val2')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_5 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='vardyn', default='val')
+option_4 = ConvertDynOptionDescription(suffixes=Calculation(func.calc_value, Params((ParamOption(option_3)))), doc='dyn', name='dyn', properties=frozenset(['normal']), children=[option_5])
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='newvar', default=Calculation(func.calc_val, Params((ParamDynOption(option_5, 'val1', option_4, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_6 = OptionDescription(doc='new', name='new', properties=frozenset(['normal']), children=[option_7])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4, option_6])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/20family_dynamic_number/__init__.py b/tests/flattener_dicos/20family_dynamic_number/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_dynamic_number/result/00-base.xml b/tests/flattener_dicos/20family_dynamic_number/result/00-base.xml
index b9386dd8..92660ce4 100644
--- a/tests/flattener_dicos/20family_dynamic_number/result/00-base.xml
+++ b/tests/flattener_dicos/20family_dynamic_number/result/00-base.xml
@@ -6,8 +6,8 @@
       <variable doc="No change" multi="True" name="varname" type="number">
         <property>mandatory</property>
         <property>normal</property>
-        <value>1</value>
-        <value>2</value>
+        <value type="number">1</value>
+        <value type="number">2</value>
       </variable>
     </family>
     <family dynamic="rougail.general.varname" doc="dyn" name="dyn">
@@ -15,7 +15,7 @@
       <variable doc="No change" multi="False" name="vardyn" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>val</value>
+        <value type="string">val</value>
       </variable>
     </family>
     <family doc="new" name="new">
@@ -24,7 +24,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param suffix="1" transitive="False" type="variable">rougail.dyn.vardyn</param>
+          <param notraisepropertyerror="False" suffix="1" type="variable">rougail.dyn.vardyn</param>
         </value>
       </variable>
     </family>
diff --git a/tests/flattener_dicos/20family_dynamic_number/tiramisu/__init__.py b/tests/flattener_dicos/20family_dynamic_number/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_dynamic_number/tiramisu/base.py b/tests/flattener_dicos/20family_dynamic_number/tiramisu/base.py
new file mode 100644
index 00000000..5682c7d6
--- /dev/null
+++ b/tests/flattener_dicos/20family_dynamic_number/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = IntOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=True, name='varname', default=[1, 2], default_multi=2)
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_5 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='vardyn', default='val')
+option_4 = ConvertDynOptionDescription(suffixes=Calculation(func.calc_value, Params((ParamOption(option_3)))), doc='dyn', name='dyn', properties=frozenset(['normal']), children=[option_5])
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='newvar', default=Calculation(func.calc_val, Params((ParamDynOption(option_5, '1', option_4, notraisepropertyerror=False, todict=False)), kwargs={})))
+option_6 = OptionDescription(doc='new', name='new', properties=frozenset(['normal']), children=[option_7])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4, option_6])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/20family_empty/__init__.py b/tests/flattener_dicos/20family_empty/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_empty/tiramisu/__init__.py b/tests/flattener_dicos/20family_empty/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_empty/tiramisu/base.py b/tests/flattener_dicos/20family_empty/tiramisu/base.py
new file mode 100644
index 00000000..18987792
--- /dev/null
+++ b/tests/flattener_dicos/20family_empty/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'basic']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['basic']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/20family_hidden/__init__.py b/tests/flattener_dicos/20family_hidden/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_hidden/tiramisu/__init__.py b/tests/flattener_dicos/20family_hidden/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_hidden/tiramisu/base.py b/tests/flattener_dicos/20family_hidden/tiramisu/base.py
new file mode 100644
index 00000000..731af754
--- /dev/null
+++ b/tests/flattener_dicos/20family_hidden/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['hidden', 'normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/20family_mode/__init__.py b/tests/flattener_dicos/20family_mode/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_mode/tiramisu/__init__.py b/tests/flattener_dicos/20family_mode/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_mode/tiramisu/base.py b/tests/flattener_dicos/20family_mode/tiramisu/base.py
new file mode 100644
index 00000000..18987792
--- /dev/null
+++ b/tests/flattener_dicos/20family_mode/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'basic']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['basic']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/20family_modeleadership/__init__.py b/tests/flattener_dicos/20family_modeleadership/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_modeleadership/tiramisu/__init__.py b/tests/flattener_dicos/20family_modeleadership/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20family_modeleadership/tiramisu/base.py b/tests/flattener_dicos/20family_modeleadership/tiramisu/base.py
new file mode 100644
index 00000000..140bdef1
--- /dev/null
+++ b/tests/flattener_dicos/20family_modeleadership/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_5 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_6 = StrOption(properties=frozenset(['normal']), doc='follower1', multi=True, name='follower1')
+option_7 = StrOption(properties=frozenset(['normal']), doc='follower2', multi=True, name='follower2')
+option_4 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_5, option_6, option_7])
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/20notemplating/__init__.py b/tests/flattener_dicos/20notemplating/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20notemplating/result/00-base.xml b/tests/flattener_dicos/20notemplating/result/00-base.xml
index 83d4d01d..54c30e32 100644
--- a/tests/flattener_dicos/20notemplating/result/00-base.xml
+++ b/tests/flattener_dicos/20notemplating/result/00-base.xml
@@ -6,25 +6,25 @@
       <family name="files" doc="files">
         <family doc="file" name="file">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/etc/file</value>
+            <value type="string">/etc/file</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>file</value>
+            <value type="string">file</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>False</value>
+            <value type="boolean">False</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/20notemplating/tiramisu/__init__.py b/tests/flattener_dicos/20notemplating/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20notemplating/tiramisu/base.py b/tests/flattener_dicos/20notemplating/tiramisu/base.py
new file mode 100644
index 00000000..01a36468
--- /dev/null
+++ b/tests/flattener_dicos/20notemplating/tiramisu/base.py
@@ -0,0 +1,19 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_8 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_9 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_10 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/etc/file')
+option_11 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_12 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='file')
+option_13 = BoolOption(default=False, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_14 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_7 = OptionDescription(doc='file', name='file', children=[option_8, option_9, option_10, option_11, option_12, option_13, option_14])
+option_6 = OptionDescription(name='files', doc='files', children=[option_7])
+option_5 = OptionDescription(doc='test', name='test', children=[option_6])
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/20override/__init__.py b/tests/flattener_dicos/20override/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20override/result/00-base.xml b/tests/flattener_dicos/20override/result/00-base.xml
index 11d18451..2ca29eca 100644
--- a/tests/flattener_dicos/20override/result/00-base.xml
+++ b/tests/flattener_dicos/20override/result/00-base.xml
@@ -6,25 +6,25 @@
       <family name="overrides" doc="overrides">
         <family doc="test.service" name="test_service">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/systemd/system/test.service.d/rougail.conf</value>
+            <value type="string">/systemd/system/test.service.d/rougail.conf</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>test.service</value>
+            <value type="string">test.service</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/20override/tiramisu/__init__.py b/tests/flattener_dicos/20override/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/20override/tiramisu/base.py b/tests/flattener_dicos/20override/tiramisu/base.py
new file mode 100644
index 00000000..9547e7b6
--- /dev/null
+++ b/tests/flattener_dicos/20override/tiramisu/base.py
@@ -0,0 +1,19 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_8 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_9 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_10 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/systemd/system/test.service.d/rougail.conf')
+option_11 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_12 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='test.service')
+option_13 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_14 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_7 = OptionDescription(doc='test.service', name='test_service', children=[option_8, option_9, option_10, option_11, option_12, option_13, option_14])
+option_6 = OptionDescription(name='overrides', doc='overrides', children=[option_7])
+option_5 = OptionDescription(doc='test', name='test', children=[option_6])
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/21family_change/__init__.py b/tests/flattener_dicos/21family_change/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/21family_change/tiramisu/__init__.py b/tests/flattener_dicos/21family_change/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/21family_change/tiramisu/base.py b/tests/flattener_dicos/21family_change/tiramisu/base.py
new file mode 100644
index 00000000..a74e84af
--- /dev/null
+++ b/tests/flattener_dicos/21family_change/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_4 = OptionDescription(doc='other', name='other', properties=frozenset(['normal']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/21family_changeaccent/__init__.py b/tests/flattener_dicos/21family_changeaccent/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/21family_changeaccent/tiramisu/__init__.py b/tests/flattener_dicos/21family_changeaccent/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/21family_changeaccent/tiramisu/base.py b/tests/flattener_dicos/21family_changeaccent/tiramisu/base.py
new file mode 100644
index 00000000..3f1d43ee
--- /dev/null
+++ b/tests/flattener_dicos/21family_changeaccent/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='Général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_4 = OptionDescription(doc='Otherwithé', name='otherwithe', properties=frozenset(['normal']), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/21family_empty/__init__.py b/tests/flattener_dicos/21family_empty/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/21family_empty/tiramisu/__init__.py b/tests/flattener_dicos/21family_empty/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/21family_empty/tiramisu/base.py b/tests/flattener_dicos/21family_empty/tiramisu/base.py
new file mode 100644
index 00000000..540734b7
--- /dev/null
+++ b/tests/flattener_dicos/21family_empty/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/30mandatory_withoutvalue/__init__.py b/tests/flattener_dicos/30mandatory_withoutvalue/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/30mandatory_withoutvalue/tiramisu/__init__.py b/tests/flattener_dicos/30mandatory_withoutvalue/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/30mandatory_withoutvalue/tiramisu/base.py b/tests/flattener_dicos/30mandatory_withoutvalue/tiramisu/base.py
new file mode 100644
index 00000000..d583db90
--- /dev/null
+++ b/tests/flattener_dicos/30mandatory_withoutvalue/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = StrOption(properties=frozenset(['mandatory', 'basic']), doc='No change', multi=False, name='mode_conteneur_actif')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['basic']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/30mandatory_withoutvaluecalc/__init__.py b/tests/flattener_dicos/30mandatory_withoutvaluecalc/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/30mandatory_withoutvaluecalc/result/00-base.xml b/tests/flattener_dicos/30mandatory_withoutvaluecalc/result/00-base.xml
index d6ad10e5..a667155d 100644
--- a/tests/flattener_dicos/30mandatory_withoutvaluecalc/result/00-base.xml
+++ b/tests/flattener_dicos/30mandatory_withoutvaluecalc/result/00-base.xml
@@ -10,7 +10,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="string">value</param>
+          <param type="string">value</param>
         </value>
       </variable>
     </family>
diff --git a/tests/flattener_dicos/30mandatory_withoutvaluecalc/tiramisu/__init__.py b/tests/flattener_dicos/30mandatory_withoutvaluecalc/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/30mandatory_withoutvaluecalc/tiramisu/base.py b/tests/flattener_dicos/30mandatory_withoutvaluecalc/tiramisu/base.py
new file mode 100644
index 00000000..9b200ab2
--- /dev/null
+++ b/tests/flattener_dicos/30mandatory_withoutvaluecalc/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = StrOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamValue("value")), kwargs={})))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/30mandatory_withvalue/__init__.py b/tests/flattener_dicos/30mandatory_withvalue/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/30mandatory_withvalue/result/00-base.xml b/tests/flattener_dicos/30mandatory_withvalue/result/00-base.xml
index fec2a314..3e8c374a 100644
--- a/tests/flattener_dicos/30mandatory_withvalue/result/00-base.xml
+++ b/tests/flattener_dicos/30mandatory_withvalue/result/00-base.xml
@@ -6,7 +6,7 @@
       <variable doc="No change" multi="False" name="mode_conteneur_actif" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>value</value>
+        <value type="string">value</value>
       </variable>
     </family>
   </family>
diff --git a/tests/flattener_dicos/30mandatory_withvalue/tiramisu/__init__.py b/tests/flattener_dicos/30mandatory_withvalue/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/30mandatory_withvalue/tiramisu/base.py b/tests/flattener_dicos/30mandatory_withvalue/tiramisu/base.py
new file mode 100644
index 00000000..d4339c4c
--- /dev/null
+++ b/tests/flattener_dicos/30mandatory_withvalue/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='value')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/30mandatory_withvaluecalc/__init__.py b/tests/flattener_dicos/30mandatory_withvaluecalc/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/30mandatory_withvaluecalc/result/00-base.xml b/tests/flattener_dicos/30mandatory_withvaluecalc/result/00-base.xml
index 54df87a2..37ec5aac 100644
--- a/tests/flattener_dicos/30mandatory_withvaluecalc/result/00-base.xml
+++ b/tests/flattener_dicos/30mandatory_withvaluecalc/result/00-base.xml
@@ -7,7 +7,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="string">value</param>
+          <param type="string">value</param>
         </value>
       </variable>
     </family>
diff --git a/tests/flattener_dicos/30mandatory_withvaluecalc/tiramisu/__init__.py b/tests/flattener_dicos/30mandatory_withvaluecalc/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/30mandatory_withvaluecalc/tiramisu/base.py b/tests/flattener_dicos/30mandatory_withvaluecalc/tiramisu/base.py
new file mode 100644
index 00000000..43108d1e
--- /dev/null
+++ b/tests/flattener_dicos/30mandatory_withvaluecalc/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.calc_val, Params((ParamValue("value")), kwargs={})))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/40condition_base/__init__.py b/tests/flattener_dicos/40condition_base/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40condition_base/tiramisu/__init__.py b/tests/flattener_dicos/40condition_base/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40condition_base/tiramisu/base.py b/tests/flattener_dicos/40condition_base/tiramisu/base.py
new file mode 100644
index 00000000..fcb1bfd3
--- /dev/null
+++ b/tests/flattener_dicos/40condition_base/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_6 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5, option_6])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/40condition_fallback/__init__.py b/tests/flattener_dicos/40condition_fallback/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40condition_fallback/tiramisu/__init__.py b/tests/flattener_dicos/40condition_fallback/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40condition_fallback/tiramisu/base.py b/tests/flattener_dicos/40condition_fallback/tiramisu/base.py
new file mode 100644
index 00000000..fac953f4
--- /dev/null
+++ b/tests/flattener_dicos/40condition_fallback/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['disabled', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['disabled', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/40condition_optional/__init__.py b/tests/flattener_dicos/40condition_optional/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40condition_optional/tiramisu/__init__.py b/tests/flattener_dicos/40condition_optional/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40condition_optional/tiramisu/base.py b/tests/flattener_dicos/40condition_optional/tiramisu/base.py
new file mode 100644
index 00000000..e5464923
--- /dev/null
+++ b/tests/flattener_dicos/40condition_optional/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/40ifin_leadership/__init__.py b/tests/flattener_dicos/40ifin_leadership/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40ifin_leadership/tiramisu/__init__.py b/tests/flattener_dicos/40ifin_leadership/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40ifin_leadership/tiramisu/base.py b/tests/flattener_dicos/40ifin_leadership/tiramisu/base.py
new file mode 100644
index 00000000..6bfe678c
--- /dev/null
+++ b/tests/flattener_dicos/40ifin_leadership/tiramisu/base.py
@@ -0,0 +1,13 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='condition', multi=False, name='condition', default='oui', values=('oui', 'non'))
+option_6 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_7 = StrOption(properties=frozenset(['normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui')}))]), doc='follower1', multi=True, name='follower1')
+option_8 = StrOption(properties=frozenset(['normal']), doc='follower2', multi=True, name='follower2')
+option_5 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_6, option_7, option_8])
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/40ifin_leadershipauto/__init__.py b/tests/flattener_dicos/40ifin_leadershipauto/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40ifin_leadershipauto/result/00-base.xml b/tests/flattener_dicos/40ifin_leadershipauto/result/00-base.xml
index 73303560..0855e2f2 100644
--- a/tests/flattener_dicos/40ifin_leadershipauto/result/00-base.xml
+++ b/tests/flattener_dicos/40ifin_leadershipauto/result/00-base.xml
@@ -28,7 +28,7 @@
           <property>normal</property>
           <property expected="oui" inverse="False" source="rougail.general.condition" type="calculation">disabled</property>
           <value name="calc_val" type="calculation">
-            <param name="valeur" transitive="False" type="string">valfill</param>
+            <param name="valeur" type="string">valfill</param>
           </value>
         </variable>
         <variable doc="follower2" multi="False" name="follower2" type="string">
diff --git a/tests/flattener_dicos/40ifin_leadershipauto/tiramisu/__init__.py b/tests/flattener_dicos/40ifin_leadershipauto/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40ifin_leadershipauto/tiramisu/base.py b/tests/flattener_dicos/40ifin_leadershipauto/tiramisu/base.py
new file mode 100644
index 00000000..b1264f6e
--- /dev/null
+++ b/tests/flattener_dicos/40ifin_leadershipauto/tiramisu/base.py
@@ -0,0 +1,13 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='condition', multi=False, name='condition', default='oui', values=('oui', 'non'))
+option_6 = StrOption(properties=frozenset([]), doc='leader', multi=True, name='leader')
+option_7 = StrOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui')}))]), doc='follower1', multi=True, name='follower1', default=Calculation(func.calc_val, Params((), kwargs={'valeur': ParamValue("valfill")})))
+option_8 = StrOption(properties=frozenset(['normal']), doc='follower2', multi=True, name='follower2')
+option_5 = Leadership(doc='leader', name='leader', properties=frozenset(['normal']), children=[option_6, option_7, option_8])
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/40ifin_multi/__init__.py b/tests/flattener_dicos/40ifin_multi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40ifin_multi/tiramisu/__init__.py b/tests/flattener_dicos/40ifin_multi/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40ifin_multi/tiramisu/base.py b/tests/flattener_dicos/40ifin_multi/tiramisu/base.py
new file mode 100644
index 00000000..ec121ccb
--- /dev/null
+++ b/tests/flattener_dicos/40ifin_multi/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_6 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')})), Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_5, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif3', default='non', values=('oui', 'non'))
+option_4 = OptionDescription(doc='general2', name='general2', properties=frozenset(['hidden', 'normal']), children=[option_5, option_6])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/40ifin_validenum/__init__.py b/tests/flattener_dicos/40ifin_validenum/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40ifin_validenum/tiramisu/__init__.py b/tests/flattener_dicos/40ifin_validenum/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/40ifin_validenum/tiramisu/base.py b/tests/flattener_dicos/40ifin_validenum/tiramisu/base.py
new file mode 100644
index 00000000..a909e5d6
--- /dev/null
+++ b/tests/flattener_dicos/40ifin_validenum/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['disabled', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_6 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif3', default='a', values=('a', 'b', 'c'))
+option_4 = OptionDescription(doc='general2', name='general2', properties=frozenset(['hidden', 'normal']), children=[option_5, option_6])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/50exists_exists/__init__.py b/tests/flattener_dicos/50exists_exists/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/50exists_exists/tiramisu/__init__.py b/tests/flattener_dicos/50exists_exists/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/50exists_exists/tiramisu/base.py b/tests/flattener_dicos/50exists_exists/tiramisu/base.py
new file mode 100644
index 00000000..96976d78
--- /dev/null
+++ b/tests/flattener_dicos/50exists_exists/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='Description', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/50redefine_description/__init__.py b/tests/flattener_dicos/50redefine_description/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/50redefine_description/tiramisu/__init__.py b/tests/flattener_dicos/50redefine_description/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/50redefine_description/tiramisu/base.py b/tests/flattener_dicos/50redefine_description/tiramisu/base.py
new file mode 100644
index 00000000..063b1161
--- /dev/null
+++ b/tests/flattener_dicos/50redefine_description/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='Redefined', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51exists_nonexists/__init__.py b/tests/flattener_dicos/51exists_nonexists/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51exists_nonexists/tiramisu/__init__.py b/tests/flattener_dicos/51exists_nonexists/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51exists_nonexists/tiramisu/base.py b/tests/flattener_dicos/51exists_nonexists/tiramisu/base.py
new file mode 100644
index 00000000..450918f0
--- /dev/null
+++ b/tests/flattener_dicos/51exists_nonexists/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='Description', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='Description', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='New description', multi=False, name='mode_conteneur_actif2', default='oui', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_auto/__init__.py b/tests/flattener_dicos/51redefine_auto/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_auto/result/00-base.xml b/tests/flattener_dicos/51redefine_auto/result/00-base.xml
index 3ac687bf..3dcb40d5 100644
--- a/tests/flattener_dicos/51redefine_auto/result/00-base.xml
+++ b/tests/flattener_dicos/51redefine_auto/result/00-base.xml
@@ -12,7 +12,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="concat" type="calculation">
-          <param name="valeur" transitive="False" type="string">non</param>
+          <param name="valeur" type="string">non</param>
         </value>
       </variable>
     </family>
diff --git a/tests/flattener_dicos/51redefine_auto/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_auto/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_auto/tiramisu/base.py b/tests/flattener_dicos/51redefine_auto/tiramisu/base.py
new file mode 100644
index 00000000..42b1cd76
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_auto/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.concat, Params((), kwargs={'valeur': ParamValue("non")})), values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_autofill/__init__.py b/tests/flattener_dicos/51redefine_autofill/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_autofill/result/00-base.xml b/tests/flattener_dicos/51redefine_autofill/result/00-base.xml
index 8689c1a8..35ab2969 100644
--- a/tests/flattener_dicos/51redefine_autofill/result/00-base.xml
+++ b/tests/flattener_dicos/51redefine_autofill/result/00-base.xml
@@ -9,7 +9,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="concat" type="calculation">
-          <param name="valeur" transitive="False" type="string">non</param>
+          <param name="valeur" type="string">non</param>
         </value>
       </variable>
     </family>
diff --git a/tests/flattener_dicos/51redefine_autofill/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_autofill/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_autofill/tiramisu/base.py b/tests/flattener_dicos/51redefine_autofill/tiramisu/base.py
new file mode 100644
index 00000000..3d2d6a4b
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_autofill/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.concat, Params((), kwargs={'valeur': ParamValue("non")})), values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_family/__init__.py b/tests/flattener_dicos/51redefine_family/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_family/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_family/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_family/tiramisu/base.py b/tests/flattener_dicos/51redefine_family/tiramisu/base.py
new file mode 100644
index 00000000..88f6885b
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_family/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_4 = OptionDescription(doc='general2', name='general2', properties=frozenset(['hidden', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_3, todict=True), 'expected': ParamValue('oui')}))]), children=[option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2, option_4])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_fill/__init__.py b/tests/flattener_dicos/51redefine_fill/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_fill/result/00-base.xml b/tests/flattener_dicos/51redefine_fill/result/00-base.xml
index 3ac687bf..3dcb40d5 100644
--- a/tests/flattener_dicos/51redefine_fill/result/00-base.xml
+++ b/tests/flattener_dicos/51redefine_fill/result/00-base.xml
@@ -12,7 +12,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="concat" type="calculation">
-          <param name="valeur" transitive="False" type="string">non</param>
+          <param name="valeur" type="string">non</param>
         </value>
       </variable>
     </family>
diff --git a/tests/flattener_dicos/51redefine_fill/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_fill/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_fill/tiramisu/base.py b/tests/flattener_dicos/51redefine_fill/tiramisu/base.py
new file mode 100644
index 00000000..42b1cd76
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_fill/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.concat, Params((), kwargs={'valeur': ParamValue("non")})), values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_fillauto/__init__.py b/tests/flattener_dicos/51redefine_fillauto/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_fillauto/result/00-base.xml b/tests/flattener_dicos/51redefine_fillauto/result/00-base.xml
index 3ac687bf..3dcb40d5 100644
--- a/tests/flattener_dicos/51redefine_fillauto/result/00-base.xml
+++ b/tests/flattener_dicos/51redefine_fillauto/result/00-base.xml
@@ -12,7 +12,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="concat" type="calculation">
-          <param name="valeur" transitive="False" type="string">non</param>
+          <param name="valeur" type="string">non</param>
         </value>
       </variable>
     </family>
diff --git a/tests/flattener_dicos/51redefine_fillauto/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_fillauto/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_fillauto/tiramisu/base.py b/tests/flattener_dicos/51redefine_fillauto/tiramisu/base.py
new file mode 100644
index 00000000..42b1cd76
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_fillauto/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default=Calculation(func.concat, Params((), kwargs={'valeur': ParamValue("non")})), values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_help/__init__.py b/tests/flattener_dicos/51redefine_help/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_help/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_help/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_help/tiramisu/base.py b/tests/flattener_dicos/51redefine_help/tiramisu/base.py
new file mode 100644
index 00000000..e3d41ecd
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_help/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='redefine help', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_3.impl_set_information("help", "redefine help ok")
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_2.impl_set_information("help", "redefine help family ok")
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_hidden/__init__.py b/tests/flattener_dicos/51redefine_hidden/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_hidden/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_hidden/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_hidden/tiramisu/base.py b/tests/flattener_dicos/51redefine_hidden/tiramisu/base.py
new file mode 100644
index 00000000..ddcdfbcd
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_hidden/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='Redefine hidden', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_multi/__init__.py b/tests/flattener_dicos/51redefine_multi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_remove_check/__init__.py b/tests/flattener_dicos/51redefine_remove_check/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_remove_check/result/00-base.xml b/tests/flattener_dicos/51redefine_remove_check/result/00-base.xml
index f4d21bae..ec88acad 100644
--- a/tests/flattener_dicos/51redefine_remove_check/result/00-base.xml
+++ b/tests/flattener_dicos/51redefine_remove_check/result/00-base.xml
@@ -9,7 +9,7 @@
         <property>hidden</property>
         <property>mandatory</property>
         <property>normal</property>
-        <value>non</value>
+        <value type="string">non</value>
       </variable>
     </family>
   </family>
diff --git a/tests/flattener_dicos/51redefine_remove_check/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_remove_check/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_remove_check/tiramisu/base.py b/tests/flattener_dicos/51redefine_remove_check/tiramisu/base.py
new file mode 100644
index 00000000..1a758e48
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_remove_check/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = StrOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non')
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_remove_condition/__init__.py b/tests/flattener_dicos/51redefine_remove_condition/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_remove_condition/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_remove_condition/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_remove_condition/tiramisu/base.py b/tests/flattener_dicos/51redefine_remove_condition/tiramisu/base.py
new file mode 100644
index 00000000..2cdea98d
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_remove_condition/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_6 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5, option_6])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_removecondition_alltarget/__init__.py b/tests/flattener_dicos/51redefine_removecondition_alltarget/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_removecondition_alltarget/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_removecondition_alltarget/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_removecondition_alltarget/tiramisu/base.py b/tests/flattener_dicos/51redefine_removecondition_alltarget/tiramisu/base.py
new file mode 100644
index 00000000..76b864c7
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_removecondition_alltarget/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_6 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5, option_6])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_removecondition_nonautofreeze/__init__.py b/tests/flattener_dicos/51redefine_removecondition_nonautofreeze/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_removecondition_nonautofreeze/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_removecondition_nonautofreeze/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_removecondition_nonautofreeze/tiramisu/base.py b/tests/flattener_dicos/51redefine_removecondition_nonautofreeze/tiramisu/base.py
new file mode 100644
index 00000000..b319b2c5
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_removecondition_nonautofreeze/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_7 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='module_instancie', default='non', values=('oui', 'non'))
+option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'auto_freeze', 'mandatory', 'basic', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_7, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='No change', multi=False, name='condition', default='non', values=('oui', 'non'))
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif1', default='non', values=('oui', 'non'))
+option_6 = ChoiceOption(properties=frozenset(['mandatory', 'normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_4, todict=True), 'expected': ParamValue('oui')}))]), doc='No change', multi=False, name='mode_conteneur_actif2', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['basic']), children=[option_3, option_4, option_5, option_6, option_7])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_type/__init__.py b/tests/flattener_dicos/51redefine_type/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_validenum/__init__.py b/tests/flattener_dicos/51redefine_validenum/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_validenum/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_validenum/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_validenum/tiramisu/base.py b/tests/flattener_dicos/51redefine_validenum/tiramisu/base.py
new file mode 100644
index 00000000..4865cd1f
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_validenum/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='Redefine description', multi=False, name='mode_conteneur_actif', default='a', values=('a', 'b'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/51redefine_value/__init__.py b/tests/flattener_dicos/51redefine_value/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_value/tiramisu/__init__.py b/tests/flattener_dicos/51redefine_value/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/51redefine_value/tiramisu/base.py b/tests/flattener_dicos/51redefine_value/tiramisu/base.py
new file mode 100644
index 00000000..2d49c670
--- /dev/null
+++ b/tests/flattener_dicos/51redefine_value/tiramisu/base.py
@@ -0,0 +1,9 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='Redefine value', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='Redefine value', multi=False, name='mode_conteneur_actif1', default='oui', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/52exists_redefine/__init__.py b/tests/flattener_dicos/52exists_redefine/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/52exists_redefine/tiramisu/__init__.py b/tests/flattener_dicos/52exists_redefine/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/52exists_redefine/tiramisu/base.py b/tests/flattener_dicos/52exists_redefine/tiramisu/base.py
new file mode 100644
index 00000000..841c2d99
--- /dev/null
+++ b/tests/flattener_dicos/52exists_redefine/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='New description', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='general', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/60action_external/__init__.py b/tests/flattener_dicos/60action_external/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60action_external/result/00-base.xml b/tests/flattener_dicos/60action_external/result/00-base.xml
index f4b7b9c7..191f3291 100644
--- a/tests/flattener_dicos/60action_external/result/00-base.xml
+++ b/tests/flattener_dicos/60action_external/result/00-base.xml
@@ -21,7 +21,7 @@
       <variable doc="délai en minutes avant lancement" multi="False" name="delay" type="number">
         <property>mandatory</property>
         <property>normal</property>
-        <value>0</value>
+        <value type="number">0</value>
       </variable>
       <variable doc="domain" multi="False" name="calc_url" type="web_address">
         <property>force_default_on_freeze</property>
@@ -30,7 +30,7 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_val" type="calculation">
-          <param transitive="False" type="string">http://localhost/</param>
+          <param type="string">http://localhost/</param>
         </value>
       </variable>
     </family>
diff --git a/tests/flattener_dicos/60action_external/tiramisu/__init__.py b/tests/flattener_dicos/60action_external/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60action_external/tiramisu/base.py b/tests/flattener_dicos/60action_external/tiramisu/base.py
new file mode 100644
index 00000000..5b2eae6e
--- /dev/null
+++ b/tests/flattener_dicos/60action_external/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_6 = IntOption(properties=frozenset(['mandatory', 'normal']), doc='délai en minutes avant lancement', multi=False, name='delay', default=0)
+option_7 = URLOption(allow_ip=True, allow_without_dot=True, properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='domain', multi=False, name='calc_url', default=Calculation(func.calc_val, Params((ParamValue("http://localhost/")), kwargs={})))
+option_5 = OptionDescription(doc='test', name='test', properties=frozenset(['normal']), children=[option_6, option_7])
+option_4 = OptionDescription(doc='extra', name='extra', children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/60extra_externalspace/__init__.py b/tests/flattener_dicos/60extra_externalspace/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_externalspaceauto/__init__.py b/tests/flattener_dicos/60extra_externalspaceauto/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_externalspacecondition/__init__.py b/tests/flattener_dicos/60extra_externalspacecondition/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_externalspacecondition/result/00-base.xml b/tests/flattener_dicos/60extra_externalspacecondition/result/00-base.xml
index 5ff2d623..4d298973 100644
--- a/tests/flattener_dicos/60extra_externalspacecondition/result/00-base.xml
+++ b/tests/flattener_dicos/60extra_externalspacecondition/result/00-base.xml
@@ -41,7 +41,7 @@
       <variable doc="description" multi="False" name="description" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>Exportation de la base de ejabberd</value>
+        <value type="string">Exportation de la base de ejabberd</value>
       </variable>
       <variable doc="day" multi="False" name="day" type="choice">
         <choice type="string">none</choice>
@@ -68,7 +68,7 @@
       <variable doc="description" multi="False" name="description" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>test</value>
+        <value type="string">test</value>
       </variable>
     </family>
   </family>
diff --git a/tests/flattener_dicos/60extra_externalspacecondition/tiramisu/__init__.py b/tests/flattener_dicos/60extra_externalspacecondition/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_externalspacecondition/tiramisu/base.py b/tests/flattener_dicos/60extra_externalspacecondition/tiramisu/base.py
new file mode 100644
index 00000000..7631921d
--- /dev/null
+++ b/tests/flattener_dicos/60extra_externalspacecondition/tiramisu/base.py
@@ -0,0 +1,18 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_5 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='module_instancie', default='non', values=('oui', 'non'))
+option_3 = ChoiceOption(properties=frozenset(['force_store_value', 'auto_freeze', 'mandatory', 'basic', Calculation(calc_value, Params(ParamValue('auto_frozen'), kwargs={'condition': ParamOption(option_5, todict=True), 'expected': ParamValue('oui'), 'reverse_condition': ParamValue(True)}))]), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='activer_ejabberd', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['basic']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_8 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='description', multi=False, name='description', default='Exportation de la base de ejabberd')
+option_9 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='day', multi=False, name='day', default='none', values=('none', 'daily', 'weekly', 'monthly'))
+option_10 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='mode', multi=False, name='mode', default='pre', values=('pre', 'post'))
+option_7 = OptionDescription(doc='ejabberd', name='ejabberd', properties=frozenset(['normal']), children=[option_8, option_9, option_10])
+option_6 = OptionDescription(doc='extra', name='extra', children=[option_7])
+option_13 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='description', multi=False, name='description', default='test')
+option_12 = OptionDescription(doc='external', name='external', properties=frozenset(['normal', Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(option_8, todict=True), 'expected': ParamValue('non')}))]), children=[option_13])
+option_11 = OptionDescription(doc='extra1', name='extra1', children=[option_12])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_6, option_11])
diff --git a/tests/flattener_dicos/60extra_externalspacecondition2/__init__.py b/tests/flattener_dicos/60extra_externalspacecondition2/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_externalspacecondition3/__init__.py b/tests/flattener_dicos/60extra_externalspacecondition3/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_group/__init__.py b/tests/flattener_dicos/60extra_group/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_group/result/00-base.xml b/tests/flattener_dicos/60extra_group/result/00-base.xml
index 2d645b1d..063d244e 100644
--- a/tests/flattener_dicos/60extra_group/result/00-base.xml
+++ b/tests/flattener_dicos/60extra_group/result/00-base.xml
@@ -6,25 +6,25 @@
       <family name="files" doc="files">
         <family doc="mailname" name="mailname">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/etc/mailname</value>
+            <value type="string">/etc/mailname</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>mailname</value>
+            <value type="string">mailname</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
@@ -62,12 +62,12 @@
         <property>normal</property>
         <variable doc="description" multi="True" name="description" type="string">
           <property>mandatory</property>
-          <value>test</value>
+          <value type="string">test</value>
         </variable>
         <variable doc="mode" multi="False" name="mode" type="string">
           <property>mandatory</property>
           <property>normal</property>
-          <value>pre</value>
+          <value type="string">pre</value>
         </variable>
       </leader>
     </family>
diff --git a/tests/flattener_dicos/60extra_group/tiramisu/__init__.py b/tests/flattener_dicos/60extra_group/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_group/tiramisu/base.py b/tests/flattener_dicos/60extra_group/tiramisu/base.py
new file mode 100644
index 00000000..096d2a0a
--- /dev/null
+++ b/tests/flattener_dicos/60extra_group/tiramisu/base.py
@@ -0,0 +1,25 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='activer_ejabberd', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_9 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_10 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_11 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/etc/mailname')
+option_12 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_13 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='mailname')
+option_14 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_15 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_8 = OptionDescription(doc='mailname', name='mailname', children=[option_9, option_10, option_11, option_12, option_13, option_14, option_15])
+option_7 = OptionDescription(name='files', doc='files', children=[option_8])
+option_6 = OptionDescription(doc='test', name='test', children=[option_7])
+option_5 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_6])
+option_19 = StrOption(properties=frozenset(['mandatory']), doc='description', multi=True, name='description', default=['test'])
+option_20 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='mode', multi=True, name='mode', default_multi='pre')
+option_18 = Leadership(doc='description', name='description', properties=frozenset(['normal']), children=[option_19, option_20])
+option_17 = OptionDescription(doc='ejabberd', name='ejabberd', properties=frozenset(['normal']), children=[option_18])
+option_16 = OptionDescription(doc='extra', name='extra', children=[option_17])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_5, option_16])
diff --git a/tests/flattener_dicos/60extra_help/60extra/00-base.xml b/tests/flattener_dicos/60extra_help/60extra/00-base.xml
deleted file mode 100644
index 91f8117c..00000000
--- a/tests/flattener_dicos/60extra_help/60extra/00-base.xml
+++ /dev/null
@@ -1,84 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<rougail>
-  <family name="containers">
-    <family name="container0" doc="test">
-      <family doc="files" name="files">
-        <family doc="file0" name="file0">
-          <variable doc="" multi="False" name="mkdir" type="boolean">
-            <value>False</value>
-          </variable>
-          <variable doc="" multi="False" name="name" type="string">
-            <value>/etc/mailname</value>
-          </variable>
-          <variable doc="" multi="False" name="rm" type="boolean">
-            <value>False</value>
-          </variable>
-          <variable doc="" multi="False" name="source" type="string">
-            <value>mailname</value>
-          </variable>
-          <variable doc="" multi="False" name="activate" type="boolean">
-            <value>True</value>
-          </variable>
-        </family>
-      </family>
-      <property>basic</property>
-    </family>
-  </family>
-  <family doc="" name="creole">
-    <family doc="général" name="general">
-      <property>normal</property>
-      <variable doc="No change" multi="False" name="mode_conteneur_actif" type="choice">
-        <choice type="string">oui</choice>
-        <choice type="string">non</choice>
-        <property>force_default_on_freeze</property>
-        <property>frozen</property>
-        <property>hidden</property>
-        <property>mandatory</property>
-        <property>normal</property>
-        <value type="string">non</value>
-      </variable>
-      <variable doc="No change" multi="False" name="activer_ejabberd" type="choice">
-        <choice type="string">oui</choice>
-        <choice type="string">non</choice>
-        <property>force_default_on_freeze</property>
-        <property>frozen</property>
-        <property>hidden</property>
-        <property>mandatory</property>
-        <property>normal</property>
-        <value type="string">non</value>
-      </variable>
-    </family>
-    <separators/>
-  </family>
-  <family doc="" name="extra">
-    <family doc="ejabberd" name="ejabberd">
-      <property>normal</property>
-      <variable doc="description" multi="False" name="description" type="string">
-        <property>mandatory</property>
-        <property>normal</property>
-        <value>Exportation de la base de ejabberd</value>
-      </variable>
-      <variable doc="day" multi="False" name="day" type="choice">
-        <choice type="string">none</choice>
-        <choice type="string">daily</choice>
-        <choice type="string">weekly</choice>
-        <choice type="string">monthly</choice>
-        <property>mandatory</property>
-        <property>normal</property>
-        <value name="calc_multi_condition" type="calculation">
-          <param transitive="False" type="string">non</param>
-          <param name="condition_1" type="variable">creole.general.activer_ejabberd</param>
-          <param name="match" transitive="False" type="string">none</param>
-          <param name="mismatch" transitive="False" type="string">daily</param>
-        </value>
-      </variable>
-      <variable doc="mode" multi="False" name="mode" type="choice">
-        <choice type="string">pre</choice>
-        <choice type="string">post</choice>
-        <property>mandatory</property>
-        <property>normal</property>
-        <value type="string">pre</value>
-      </variable>
-    </family>
-  </family>
-</rougail>
diff --git a/tests/flattener_dicos/60extra_help/60extra/result/test/etc/mailname b/tests/flattener_dicos/60extra_help/60extra/result/test/etc/mailname
deleted file mode 100644
index 174cc656..00000000
--- a/tests/flattener_dicos/60extra_help/60extra/result/test/etc/mailname
+++ /dev/null
@@ -1 +0,0 @@
-Exportation de la base de ejabberd
diff --git a/tests/flattener_dicos/60extra_help/60extra/tmpl/mailname b/tests/flattener_dicos/60extra_help/60extra/tmpl/mailname
deleted file mode 100644
index cd745cac..00000000
--- a/tests/flattener_dicos/60extra_help/60extra/tmpl/mailname
+++ /dev/null
@@ -1 +0,0 @@
-%%extra.ejabberd.description
diff --git a/tests/flattener_dicos/60extra_help/__init__.py b/tests/flattener_dicos/60extra_help/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_help/extra_dirs/extra/00-base.xml b/tests/flattener_dicos/60extra_help/extra_dirs/extra/00-base.xml
index ab3d1cdd..15a5a566 100644
--- a/tests/flattener_dicos/60extra_help/extra_dirs/extra/00-base.xml
+++ b/tests/flattener_dicos/60extra_help/extra_dirs/extra/00-base.xml
@@ -15,7 +15,7 @@
     <constraints>
         <fill name='calc_multi_condition' target='extra.ejabberd.day'>
             <param>non</param>
-            <param type='variable' name='condition_1' hidden='False'>activer_ejabberd</param>
+            <param type='variable' name='condition_1' notraisepropertyerror='True'>activer_ejabberd</param>
             <param name='match'>none</param>
             <param name='mismatch'>daily</param>
         </fill>
diff --git a/tests/flattener_dicos/60extra_help/result/00-base.xml b/tests/flattener_dicos/60extra_help/result/00-base.xml
index 2731f873..edb63e32 100644
--- a/tests/flattener_dicos/60extra_help/result/00-base.xml
+++ b/tests/flattener_dicos/60extra_help/result/00-base.xml
@@ -6,25 +6,25 @@
       <family name="files" doc="files">
         <family doc="mailname" name="mailname">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/etc/mailname</value>
+            <value type="string">/etc/mailname</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>mailname</value>
+            <value type="string">mailname</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
@@ -61,7 +61,7 @@
       <variable doc="description" multi="False" name="description" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>Exportation de la base de ejabberd</value>
+        <value type="string">Exportation de la base de ejabberd</value>
       </variable>
       <variable doc="day" help="Test help" multi="False" name="day" type="choice">
         <choice type="string">none</choice>
@@ -71,10 +71,10 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_multi_condition" type="calculation">
-          <param transitive="False" type="string">non</param>
-          <param name="condition_1" type="variable">rougail.general.activer_ejabberd</param>
-          <param name="match" transitive="False" type="string">none</param>
-          <param name="mismatch" transitive="False" type="string">daily</param>
+          <param type="string">non</param>
+          <param name="condition_1" notraisepropertyerror="True" type="variable">rougail.general.activer_ejabberd</param>
+          <param name="match" type="string">none</param>
+          <param name="mismatch" type="string">daily</param>
         </value>
       </variable>
       <variable doc="mode" multi="False" name="mode" type="choice">
diff --git a/tests/flattener_dicos/60extra_help/tiramisu/__init__.py b/tests/flattener_dicos/60extra_help/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_help/tiramisu/base.py b/tests/flattener_dicos/60extra_help/tiramisu/base.py
new file mode 100644
index 00000000..bc18cef5
--- /dev/null
+++ b/tests/flattener_dicos/60extra_help/tiramisu/base.py
@@ -0,0 +1,26 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='activer_ejabberd', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_9 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_10 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_11 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/etc/mailname')
+option_12 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_13 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='mailname')
+option_14 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_15 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_8 = OptionDescription(doc='mailname', name='mailname', children=[option_9, option_10, option_11, option_12, option_13, option_14, option_15])
+option_7 = OptionDescription(name='files', doc='files', children=[option_8])
+option_6 = OptionDescription(doc='test', name='test', children=[option_7])
+option_5 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_6])
+option_18 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='description', multi=False, name='description', default='Exportation de la base de ejabberd')
+option_19 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='day', multi=False, name='day', default=Calculation(func.calc_multi_condition, Params((ParamValue("non")), kwargs={'condition_1': ParamOption(option_4, notraisepropertyerror=True, todict=False), 'match': ParamValue("none"), 'mismatch': ParamValue("daily")})), values=('none', 'daily', 'weekly', 'monthly'))
+option_19.impl_set_information("help", "Test help")
+option_20 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='mode', multi=False, name='mode', default='pre', values=('pre', 'post'))
+option_17 = OptionDescription(doc='ejabberd', name='ejabberd', properties=frozenset(['normal']), children=[option_18, option_19, option_20])
+option_16 = OptionDescription(doc='extra', name='extra', children=[option_17])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_5, option_16])
diff --git a/tests/flattener_dicos/60extra_load/__init__.py b/tests/flattener_dicos/60extra_load/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_load/extra_dirs/extra/00-base.xml b/tests/flattener_dicos/60extra_load/extra_dirs/extra/00-base.xml
index 185ac9b8..651c2125 100644
--- a/tests/flattener_dicos/60extra_load/extra_dirs/extra/00-base.xml
+++ b/tests/flattener_dicos/60extra_load/extra_dirs/extra/00-base.xml
@@ -15,7 +15,7 @@
     <constraints>
         <fill name='calc_multi_condition' target='extra.ejabberd.day'>
             <param>non</param>
-            <param type='variable' name='condition_1' hidden='False'>activer_ejabberd</param>
+            <param type='variable' name='condition_1' notraisepropertyerror='True'>activer_ejabberd</param>
             <param name='match'>none</param>
             <param name='mismatch'>daily</param>
         </fill>
diff --git a/tests/flattener_dicos/60extra_load/result/00-base.xml b/tests/flattener_dicos/60extra_load/result/00-base.xml
index 756c4421..bcd752ac 100644
--- a/tests/flattener_dicos/60extra_load/result/00-base.xml
+++ b/tests/flattener_dicos/60extra_load/result/00-base.xml
@@ -31,7 +31,7 @@
       <variable doc="description" multi="False" name="description" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>Exportation de la base de ejabberd</value>
+        <value type="string">Exportation de la base de ejabberd</value>
       </variable>
       <variable doc="day" multi="False" name="day" type="choice">
         <choice type="string">none</choice>
@@ -41,10 +41,10 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_multi_condition" type="calculation">
-          <param transitive="False" type="string">non</param>
-          <param name="condition_1" type="variable">rougail.general.activer_ejabberd</param>
-          <param name="match" transitive="False" type="string">none</param>
-          <param name="mismatch" transitive="False" type="string">daily</param>
+          <param type="string">non</param>
+          <param name="condition_1" notraisepropertyerror="True" type="variable">rougail.general.activer_ejabberd</param>
+          <param name="match" type="string">none</param>
+          <param name="mismatch" type="string">daily</param>
         </value>
       </variable>
       <variable doc="mode" multi="False" name="mode" type="choice">
diff --git a/tests/flattener_dicos/60extra_load/tiramisu/__init__.py b/tests/flattener_dicos/60extra_load/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_load/tiramisu/base.py b/tests/flattener_dicos/60extra_load/tiramisu/base.py
new file mode 100644
index 00000000..c8db5a96
--- /dev/null
+++ b/tests/flattener_dicos/60extra_load/tiramisu/base.py
@@ -0,0 +1,14 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='activer_ejabberd', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='description', multi=False, name='description', default='Exportation de la base de ejabberd')
+option_8 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='day', multi=False, name='day', default=Calculation(func.calc_multi_condition, Params((ParamValue("non")), kwargs={'condition_1': ParamOption(option_4, notraisepropertyerror=True, todict=False), 'match': ParamValue("none"), 'mismatch': ParamValue("daily")})), values=('none', 'daily', 'weekly', 'monthly'))
+option_9 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='mode', multi=False, name='mode', default='pre', values=('pre', 'post'))
+option_6 = OptionDescription(doc='ejabberd', name='ejabberd', properties=frozenset(['normal']), children=[option_7, option_8, option_9])
+option_5 = OptionDescription(doc='extra', name='extra', children=[option_6])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_5])
diff --git a/tests/flattener_dicos/60extra_mandatory/__init__.py b/tests/flattener_dicos/60extra_mandatory/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_mandatory/extra_dirs/extra/00-base.xml b/tests/flattener_dicos/60extra_mandatory/extra_dirs/extra/00-base.xml
index 9db3b32e..76cfb57b 100644
--- a/tests/flattener_dicos/60extra_mandatory/extra_dirs/extra/00-base.xml
+++ b/tests/flattener_dicos/60extra_mandatory/extra_dirs/extra/00-base.xml
@@ -14,7 +14,7 @@
     <constraints>
         <fill name='calc_multi_condition' target='extra.ejabberd.day'>
             <param>non</param>
-            <param type='variable' name='condition_1' hidden='False'>activer_ejabberd</param>
+            <param type='variable' name='condition_1' notraisepropertyerror='True'>activer_ejabberd</param>
             <param name='match'>none</param>
             <param name='mismatch'>daily</param>
         </fill>
diff --git a/tests/flattener_dicos/60extra_mandatory/result/00-base.xml b/tests/flattener_dicos/60extra_mandatory/result/00-base.xml
index e886aa84..c40d8f38 100644
--- a/tests/flattener_dicos/60extra_mandatory/result/00-base.xml
+++ b/tests/flattener_dicos/60extra_mandatory/result/00-base.xml
@@ -31,7 +31,7 @@
       <variable doc="description" multi="False" name="description" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>Exportation de la base de ejabberd</value>
+        <value type="string">Exportation de la base de ejabberd</value>
       </variable>
       <variable doc="day" multi="False" name="day" type="choice">
         <choice type="string">none</choice>
@@ -41,10 +41,10 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_multi_condition" type="calculation">
-          <param transitive="False" type="string">non</param>
-          <param name="condition_1" type="variable">rougail.general.activer_ejabberd</param>
-          <param name="match" transitive="False" type="string">none</param>
-          <param name="mismatch" transitive="False" type="string">daily</param>
+          <param type="string">non</param>
+          <param name="condition_1" notraisepropertyerror="True" type="variable">rougail.general.activer_ejabberd</param>
+          <param name="match" type="string">none</param>
+          <param name="mismatch" type="string">daily</param>
         </value>
       </variable>
       <variable doc="mode" multi="False" name="mode" type="choice">
diff --git a/tests/flattener_dicos/60extra_mandatory/tiramisu/__init__.py b/tests/flattener_dicos/60extra_mandatory/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_mandatory/tiramisu/base.py b/tests/flattener_dicos/60extra_mandatory/tiramisu/base.py
new file mode 100644
index 00000000..38e30ff4
--- /dev/null
+++ b/tests/flattener_dicos/60extra_mandatory/tiramisu/base.py
@@ -0,0 +1,15 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='activer_ejabberd', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='description', multi=False, name='description', default='Exportation de la base de ejabberd')
+option_8 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='day', multi=False, name='day', default=Calculation(func.calc_multi_condition, Params((ParamValue("non")), kwargs={'condition_1': ParamOption(option_4, notraisepropertyerror=True, todict=False), 'match': ParamValue("none"), 'mismatch': ParamValue("daily")})), values=('none', 'daily', 'weekly', 'monthly'))
+option_9 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='mode', multi=False, name='mode', default='pre', values=('pre', 'post'))
+option_10 = StrOption(properties=frozenset(['mandatory', 'basic']), doc='var1', multi=False, name='var1')
+option_6 = OptionDescription(doc='ejabberd', name='ejabberd', properties=frozenset(['basic']), children=[option_7, option_8, option_9, option_10])
+option_5 = OptionDescription(doc='extra', name='extra', children=[option_6])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_5])
diff --git a/tests/flattener_dicos/60extra_redefine/__init__.py b/tests/flattener_dicos/60extra_redefine/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_redefine/extra_dirs/extra/00-base.xml b/tests/flattener_dicos/60extra_redefine/extra_dirs/extra/00-base.xml
index 185ac9b8..651c2125 100644
--- a/tests/flattener_dicos/60extra_redefine/extra_dirs/extra/00-base.xml
+++ b/tests/flattener_dicos/60extra_redefine/extra_dirs/extra/00-base.xml
@@ -15,7 +15,7 @@
     <constraints>
         <fill name='calc_multi_condition' target='extra.ejabberd.day'>
             <param>non</param>
-            <param type='variable' name='condition_1' hidden='False'>activer_ejabberd</param>
+            <param type='variable' name='condition_1' notraisepropertyerror='True'>activer_ejabberd</param>
             <param name='match'>none</param>
             <param name='mismatch'>daily</param>
         </fill>
diff --git a/tests/flattener_dicos/60extra_redefine/result/00-base.xml b/tests/flattener_dicos/60extra_redefine/result/00-base.xml
index 5e591783..937fc257 100644
--- a/tests/flattener_dicos/60extra_redefine/result/00-base.xml
+++ b/tests/flattener_dicos/60extra_redefine/result/00-base.xml
@@ -34,7 +34,7 @@
         <property>hidden</property>
         <property>mandatory</property>
         <property>normal</property>
-        <value>Exportation de la base de ejabberd</value>
+        <value type="string">Exportation de la base de ejabberd</value>
       </variable>
       <variable doc="day" multi="False" name="day" type="choice">
         <choice type="string">none</choice>
@@ -44,10 +44,10 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_multi_condition" type="calculation">
-          <param transitive="False" type="string">non</param>
-          <param name="condition_1" type="variable">rougail.general.activer_ejabberd</param>
-          <param name="match" transitive="False" type="string">none</param>
-          <param name="mismatch" transitive="False" type="string">daily</param>
+          <param type="string">non</param>
+          <param name="condition_1" notraisepropertyerror="True" type="variable">rougail.general.activer_ejabberd</param>
+          <param name="match" type="string">none</param>
+          <param name="mismatch" type="string">daily</param>
         </value>
       </variable>
       <variable doc="mode" multi="False" name="mode" type="choice">
diff --git a/tests/flattener_dicos/60extra_redefine/tiramisu/__init__.py b/tests/flattener_dicos/60extra_redefine/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_redefine/tiramisu/base.py b/tests/flattener_dicos/60extra_redefine/tiramisu/base.py
new file mode 100644
index 00000000..b08a07d3
--- /dev/null
+++ b/tests/flattener_dicos/60extra_redefine/tiramisu/base.py
@@ -0,0 +1,14 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='activer_ejabberd', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_7 = StrOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='description', multi=False, name='description', default='Exportation de la base de ejabberd')
+option_8 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='day', multi=False, name='day', default=Calculation(func.calc_multi_condition, Params((ParamValue("non")), kwargs={'condition_1': ParamOption(option_4, notraisepropertyerror=True, todict=False), 'match': ParamValue("none"), 'mismatch': ParamValue("daily")})), values=('none', 'daily', 'weekly', 'monthly'))
+option_9 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='mode', multi=False, name='mode', default='pre', values=('pre', 'post'))
+option_6 = OptionDescription(doc='ejabberd', name='ejabberd', properties=frozenset(['normal']), children=[option_7, option_8, option_9])
+option_5 = OptionDescription(doc='extra', name='extra', children=[option_6])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_5])
diff --git a/tests/flattener_dicos/60extra_separators/__init__.py b/tests/flattener_dicos/60extra_separators/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_separators/extra_dirs/extra/00-base.xml b/tests/flattener_dicos/60extra_separators/extra_dirs/extra/00-base.xml
index b6247865..f51f8a14 100644
--- a/tests/flattener_dicos/60extra_separators/extra_dirs/extra/00-base.xml
+++ b/tests/flattener_dicos/60extra_separators/extra_dirs/extra/00-base.xml
@@ -18,7 +18,7 @@
     <constraints>
         <fill name='calc_multi_condition' target='extra.ejabberd.day'>
             <param>non</param>
-            <param type='variable' name='condition_1' hidden='False'>activer_ejabberd</param>
+            <param type='variable' name='condition_1' notraisepropertyerror='True'>activer_ejabberd</param>
             <param name='match'>none</param>
             <param name='mismatch'>daily</param>
         </fill>
diff --git a/tests/flattener_dicos/60extra_separators/result/00-base.xml b/tests/flattener_dicos/60extra_separators/result/00-base.xml
index 0147ea94..7a59f723 100644
--- a/tests/flattener_dicos/60extra_separators/result/00-base.xml
+++ b/tests/flattener_dicos/60extra_separators/result/00-base.xml
@@ -31,7 +31,7 @@
       <variable doc="description" multi="False" name="description" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>Exportation de la base de ejabberd</value>
+        <value type="string">Exportation de la base de ejabberd</value>
       </variable>
       <variable doc="day" multi="False" name="day" separator="Séparateur" type="choice">
         <choice type="string">none</choice>
@@ -41,10 +41,10 @@
         <property>mandatory</property>
         <property>normal</property>
         <value name="calc_multi_condition" type="calculation">
-          <param transitive="False" type="string">non</param>
-          <param name="condition_1" type="variable">rougail.general.activer_ejabberd</param>
-          <param name="match" transitive="False" type="string">none</param>
-          <param name="mismatch" transitive="False" type="string">daily</param>
+          <param type="string">non</param>
+          <param name="condition_1" notraisepropertyerror="True" type="variable">rougail.general.activer_ejabberd</param>
+          <param name="match" type="string">none</param>
+          <param name="mismatch" type="string">daily</param>
         </value>
       </variable>
       <variable doc="mode" multi="False" name="mode" type="choice">
diff --git a/tests/flattener_dicos/60extra_separators/tiramisu/__init__.py b/tests/flattener_dicos/60extra_separators/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60extra_separators/tiramisu/base.py b/tests/flattener_dicos/60extra_separators/tiramisu/base.py
new file mode 100644
index 00000000..337cb092
--- /dev/null
+++ b/tests/flattener_dicos/60extra_separators/tiramisu/base.py
@@ -0,0 +1,15 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_4 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='activer_ejabberd', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_7 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='description', multi=False, name='description', default='Exportation de la base de ejabberd')
+option_8 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='day', multi=False, name='day', default=Calculation(func.calc_multi_condition, Params((ParamValue("non")), kwargs={'condition_1': ParamOption(option_4, notraisepropertyerror=True, todict=False), 'match': ParamValue("none"), 'mismatch': ParamValue("daily")})), values=('none', 'daily', 'weekly', 'monthly'))
+option_8.impl_set_information("separator", "Séparateur")
+option_9 = ChoiceOption(properties=frozenset(['mandatory', 'normal']), doc='mode', multi=False, name='mode', default='pre', values=('pre', 'post'))
+option_6 = OptionDescription(doc='ejabberd', name='ejabberd', properties=frozenset(['normal']), children=[option_7, option_8, option_9])
+option_5 = OptionDescription(doc='extra', name='extra', children=[option_6])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_5])
diff --git a/tests/flattener_dicos/60familyaction/__init__.py b/tests/flattener_dicos/60familyaction/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60familyaction/result/00-base.xml b/tests/flattener_dicos/60familyaction/result/00-base.xml
index 2136b58e..02f93e60 100644
--- a/tests/flattener_dicos/60familyaction/result/00-base.xml
+++ b/tests/flattener_dicos/60familyaction/result/00-base.xml
@@ -21,7 +21,7 @@
       <variable doc="délai en minutes avant lancement" multi="False" name="delay" type="number">
         <property>mandatory</property>
         <property>normal</property>
-        <value>0</value>
+        <value type="number">0</value>
       </variable>
     </family>
   </family>
diff --git a/tests/flattener_dicos/60familyaction/tiramisu/__init__.py b/tests/flattener_dicos/60familyaction/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60familyaction/tiramisu/base.py b/tests/flattener_dicos/60familyaction/tiramisu/base.py
new file mode 100644
index 00000000..9122bae2
--- /dev/null
+++ b/tests/flattener_dicos/60familyaction/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_6 = IntOption(properties=frozenset(['mandatory', 'normal']), doc='délai en minutes avant lancement', multi=False, name='delay', default=0)
+option_5 = OptionDescription(doc='test', name='test', properties=frozenset(['normal']), children=[option_6])
+option_4 = OptionDescription(doc='extra', name='extra', children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/60familyaction_accent/__init__.py b/tests/flattener_dicos/60familyaction_accent/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60familyaction_accent/result/00-base.xml b/tests/flattener_dicos/60familyaction_accent/result/00-base.xml
index 2136b58e..02f93e60 100644
--- a/tests/flattener_dicos/60familyaction_accent/result/00-base.xml
+++ b/tests/flattener_dicos/60familyaction_accent/result/00-base.xml
@@ -21,7 +21,7 @@
       <variable doc="délai en minutes avant lancement" multi="False" name="delay" type="number">
         <property>mandatory</property>
         <property>normal</property>
-        <value>0</value>
+        <value type="number">0</value>
       </variable>
     </family>
   </family>
diff --git a/tests/flattener_dicos/60familyaction_accent/tiramisu/__init__.py b/tests/flattener_dicos/60familyaction_accent/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60familyaction_accent/tiramisu/base.py b/tests/flattener_dicos/60familyaction_accent/tiramisu/base.py
new file mode 100644
index 00000000..9122bae2
--- /dev/null
+++ b/tests/flattener_dicos/60familyaction_accent/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_6 = IntOption(properties=frozenset(['mandatory', 'normal']), doc='délai en minutes avant lancement', multi=False, name='delay', default=0)
+option_5 = OptionDescription(doc='test', name='test', properties=frozenset(['normal']), children=[option_6])
+option_4 = OptionDescription(doc='extra', name='extra', children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/60familyaction_mandatory/__init__.py b/tests/flattener_dicos/60familyaction_mandatory/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60familyaction_mandatory/result/00-base.xml b/tests/flattener_dicos/60familyaction_mandatory/result/00-base.xml
index 9e63517e..f9c1bcb3 100644
--- a/tests/flattener_dicos/60familyaction_mandatory/result/00-base.xml
+++ b/tests/flattener_dicos/60familyaction_mandatory/result/00-base.xml
@@ -21,7 +21,7 @@
       <variable doc="délai en minutes avant lancement" multi="False" name="delay" type="number">
         <property>mandatory</property>
         <property>normal</property>
-        <value>0</value>
+        <value type="number">0</value>
       </variable>
       <variable doc="day avant lancement" multi="False" name="day" type="number">
         <property>mandatory</property>
diff --git a/tests/flattener_dicos/60familyaction_mandatory/tiramisu/__init__.py b/tests/flattener_dicos/60familyaction_mandatory/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/60familyaction_mandatory/tiramisu/base.py b/tests/flattener_dicos/60familyaction_mandatory/tiramisu/base.py
new file mode 100644
index 00000000..0de65c86
--- /dev/null
+++ b/tests/flattener_dicos/60familyaction_mandatory/tiramisu/base.py
@@ -0,0 +1,12 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_6 = IntOption(properties=frozenset(['mandatory', 'normal']), doc='délai en minutes avant lancement', multi=False, name='delay', default=0)
+option_7 = IntOption(properties=frozenset(['mandatory', 'basic']), doc='day avant lancement', multi=False, name='day')
+option_5 = OptionDescription(doc='test', name='test', properties=frozenset(['basic']), children=[option_6, option_7])
+option_4 = OptionDescription(doc='extra', name='extra', children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/70container_files/__init__.py b/tests/flattener_dicos/70container_files/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_files/result/00-base.xml b/tests/flattener_dicos/70container_files/result/00-base.xml
index 811f7b2a..3e6ccef9 100644
--- a/tests/flattener_dicos/70container_files/result/00-base.xml
+++ b/tests/flattener_dicos/70container_files/result/00-base.xml
@@ -6,48 +6,48 @@
       <family name="files" doc="files">
         <family doc="mailname" name="mailname">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/etc/mailname</value>
+            <value type="string">/etc/mailname</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>mailname</value>
+            <value type="string">mailname</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
         <family doc="rougail.conf" name="rougail_conf">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/rougail.conf</value>
+            <value type="string">/rougail.conf</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>rougail.conf</value>
+            <value type="string">rougail.conf</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/70container_files/tiramisu/__init__.py b/tests/flattener_dicos/70container_files/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_files/tiramisu/base.py b/tests/flattener_dicos/70container_files/tiramisu/base.py
new file mode 100644
index 00000000..fa71a54a
--- /dev/null
+++ b/tests/flattener_dicos/70container_files/tiramisu/base.py
@@ -0,0 +1,27 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_8 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_9 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_10 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/etc/mailname')
+option_11 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_12 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='mailname')
+option_13 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_14 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_7 = OptionDescription(doc='mailname', name='mailname', children=[option_8, option_9, option_10, option_11, option_12, option_13, option_14])
+option_16 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_17 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_18 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/rougail.conf')
+option_19 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_20 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='rougail.conf')
+option_21 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_22 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_15 = OptionDescription(doc='rougail.conf', name='rougail_conf', children=[option_16, option_17, option_18, option_19, option_20, option_21, option_22])
+option_6 = OptionDescription(name='files', doc='files', children=[option_7, option_15])
+option_5 = OptionDescription(doc='test', name='test', children=[option_6])
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/70container_files_symlink_multi/__init__.py b/tests/flattener_dicos/70container_files_symlink_multi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_files_symlink_multi/result/00-base.xml b/tests/flattener_dicos/70container_files_symlink_multi/result/00-base.xml
index f2eff7ec..986a8e48 100644
--- a/tests/flattener_dicos/70container_files_symlink_multi/result/00-base.xml
+++ b/tests/flattener_dicos/70container_files_symlink_multi/result/00-base.xml
@@ -6,23 +6,23 @@
       <family name="files" doc="files">
         <family doc="mailname" name="mailname">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
-          <variable multi="False" name="name" opt="rougail.general.file_name" type="symlink"/>
+          <variable name="name" opt="rougail.general.file_name" type="symlink"/>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>mailname</value>
+            <value type="string">mailname</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
@@ -44,8 +44,8 @@
       <variable doc="file_name" multi="True" name="file_name" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>/etc/mailname</value>
-        <value>/etc/mailname2</value>
+        <value type="string">/etc/mailname</value>
+        <value type="string">/etc/mailname2</value>
       </variable>
     </family>
   </family>
diff --git a/tests/flattener_dicos/70container_files_symlink_multi/tiramisu/__init__.py b/tests/flattener_dicos/70container_files_symlink_multi/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_files_symlink_multi/tiramisu/base.py b/tests/flattener_dicos/70container_files_symlink_multi/tiramisu/base.py
new file mode 100644
index 00000000..bfdf0910
--- /dev/null
+++ b/tests/flattener_dicos/70container_files_symlink_multi/tiramisu/base.py
@@ -0,0 +1,20 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_4 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='file_name', multi=True, name='file_name', default=['/etc/mailname', '/etc/mailname2'], default_multi='/etc/mailname2')
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_9 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_10 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_11 = SymLinkOption(name='name', opt=option_4)
+option_12 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_13 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='mailname')
+option_14 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_15 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_8 = OptionDescription(doc='mailname', name='mailname', children=[option_9, option_10, option_11, option_12, option_13, option_14, option_15])
+option_7 = OptionDescription(name='files', doc='files', children=[option_8])
+option_6 = OptionDescription(doc='test', name='test', children=[option_7])
+option_5 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_6])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_5])
diff --git a/tests/flattener_dicos/70container_files_symlink_multi_variable/__init__.py b/tests/flattener_dicos/70container_files_symlink_multi_variable/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_files_symlink_multi_variable/result/00-base.xml b/tests/flattener_dicos/70container_files_symlink_multi_variable/result/00-base.xml
index b3f0634e..1ed33554 100644
--- a/tests/flattener_dicos/70container_files_symlink_multi_variable/result/00-base.xml
+++ b/tests/flattener_dicos/70container_files_symlink_multi_variable/result/00-base.xml
@@ -6,24 +6,24 @@
       <family name="files" doc="files">
         <family doc="mailname" name="mailname">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
-          <variable multi="False" name="name" opt="rougail.general.file_name" type="symlink"/>
+          <variable name="name" opt="rougail.general.file_name" type="symlink"/>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>mailname</value>
+            <value type="string">mailname</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
-          <variable multi="False" name="variable" opt="rougail.general.var" type="symlink"/>
+          <variable name="variable" opt="rougail.general.var" type="symlink"/>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
@@ -45,14 +45,14 @@
       <variable doc="file_name" multi="True" name="file_name" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>/etc/mailname</value>
-        <value>/etc/mailname2</value>
+        <value type="string">/etc/mailname</value>
+        <value type="string">/etc/mailname2</value>
       </variable>
       <variable doc="var" multi="True" name="var" type="string">
         <property>mandatory</property>
         <property>normal</property>
-        <value>mailname</value>
-        <value>mailname2</value>
+        <value type="string">mailname</value>
+        <value type="string">mailname2</value>
       </variable>
     </family>
   </family>
diff --git a/tests/flattener_dicos/70container_files_symlink_multi_variable/tiramisu/__init__.py b/tests/flattener_dicos/70container_files_symlink_multi_variable/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_files_symlink_multi_variable/tiramisu/base.py b/tests/flattener_dicos/70container_files_symlink_multi_variable/tiramisu/base.py
new file mode 100644
index 00000000..44b7d300
--- /dev/null
+++ b/tests/flattener_dicos/70container_files_symlink_multi_variable/tiramisu/base.py
@@ -0,0 +1,22 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_4 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='file_name', multi=True, name='file_name', default=['/etc/mailname', '/etc/mailname2'], default_multi='/etc/mailname2')
+option_5 = StrOption(properties=frozenset(['mandatory', 'normal']), doc='var', multi=True, name='var', default=['mailname', 'mailname2'], default_multi='mailname2')
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_10 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_11 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_12 = SymLinkOption(name='name', opt=option_4)
+option_13 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_14 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='mailname')
+option_15 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_16 = SymLinkOption(name='variable', opt=option_5)
+option_17 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_9 = OptionDescription(doc='mailname', name='mailname', children=[option_10, option_11, option_12, option_13, option_14, option_15, option_16, option_17])
+option_8 = OptionDescription(name='files', doc='files', children=[option_9])
+option_7 = OptionDescription(doc='test', name='test', children=[option_8])
+option_6 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_7])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_6])
diff --git a/tests/flattener_dicos/70container_filesmulti/__init__.py b/tests/flattener_dicos/70container_filesmulti/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_filesmulti/result/00-base.xml b/tests/flattener_dicos/70container_filesmulti/result/00-base.xml
index 5469a501..2393fd26 100644
--- a/tests/flattener_dicos/70container_filesmulti/result/00-base.xml
+++ b/tests/flattener_dicos/70container_filesmulti/result/00-base.xml
@@ -6,48 +6,48 @@
       <family name="files" doc="files">
         <family doc="mailname" name="mailname">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/etc/mailname</value>
+            <value type="string">/etc/mailname</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>mailname</value>
+            <value type="string">mailname</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
         <family doc="mailname2" name="mailname2">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/etc/mailname2</value>
+            <value type="string">/etc/mailname2</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>mailname2</value>
+            <value type="string">mailname2</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/70container_filesmulti/tiramisu/__init__.py b/tests/flattener_dicos/70container_filesmulti/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_filesmulti/tiramisu/base.py b/tests/flattener_dicos/70container_filesmulti/tiramisu/base.py
new file mode 100644
index 00000000..0ec5b6d1
--- /dev/null
+++ b/tests/flattener_dicos/70container_filesmulti/tiramisu/base.py
@@ -0,0 +1,27 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_8 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_9 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_10 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/etc/mailname')
+option_11 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_12 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='mailname')
+option_13 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_14 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_7 = OptionDescription(doc='mailname', name='mailname', children=[option_8, option_9, option_10, option_11, option_12, option_13, option_14])
+option_16 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_17 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_18 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/etc/mailname2')
+option_19 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_20 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='mailname2')
+option_21 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_22 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_15 = OptionDescription(doc='mailname2', name='mailname2', children=[option_16, option_17, option_18, option_19, option_20, option_21, option_22])
+option_6 = OptionDescription(name='files', doc='files', children=[option_7, option_15])
+option_5 = OptionDescription(doc='test', name='test', children=[option_6])
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/70container_filesredefine/__init__.py b/tests/flattener_dicos/70container_filesredefine/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_filesredefine/result/00-base.xml b/tests/flattener_dicos/70container_filesredefine/result/00-base.xml
index b98857b1..7e6af2c2 100644
--- a/tests/flattener_dicos/70container_filesredefine/result/00-base.xml
+++ b/tests/flattener_dicos/70container_filesredefine/result/00-base.xml
@@ -6,25 +6,25 @@
       <family name="files" doc="files">
         <family doc="mailname.new" name="mailname_new">
           <variable doc="group" multi="False" name="group" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="mode" multi="False" name="mode" type="string">
-            <value>0644</value>
+            <value type="string">0644</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="string">
-            <value>/etc/mailname</value>
+            <value type="string">/etc/mailname</value>
           </variable>
           <variable doc="owner" multi="False" name="owner" type="string">
-            <value>root</value>
+            <value type="string">root</value>
           </variable>
           <variable doc="source" multi="False" name="source" type="string">
-            <value>mailname.new</value>
+            <value type="string">mailname.new</value>
           </variable>
           <variable doc="templating" multi="False" name="templating" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/70container_filesredefine/tiramisu/__init__.py b/tests/flattener_dicos/70container_filesredefine/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_filesredefine/tiramisu/base.py b/tests/flattener_dicos/70container_filesredefine/tiramisu/base.py
new file mode 100644
index 00000000..8029b4d3
--- /dev/null
+++ b/tests/flattener_dicos/70container_filesredefine/tiramisu/base.py
@@ -0,0 +1,19 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_8 = StrOption(properties=frozenset([]), doc='group', multi=False, name='group', default='root')
+option_9 = StrOption(properties=frozenset([]), doc='mode', multi=False, name='mode', default='0644')
+option_10 = StrOption(properties=frozenset([]), doc='name', multi=False, name='name', default='/etc/mailname')
+option_11 = StrOption(properties=frozenset([]), doc='owner', multi=False, name='owner', default='root')
+option_12 = StrOption(properties=frozenset([]), doc='source', multi=False, name='source', default='mailname.new')
+option_13 = BoolOption(default=True, properties=frozenset([]), doc='templating', multi=False, name='templating')
+option_14 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_7 = OptionDescription(doc='mailname.new', name='mailname_new', children=[option_8, option_9, option_10, option_11, option_12, option_13, option_14])
+option_6 = OptionDescription(name='files', doc='files', children=[option_7])
+option_5 = OptionDescription(doc='test', name='test', children=[option_6])
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/70container_new/__init__.py b/tests/flattener_dicos/70container_new/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_new/tiramisu/__init__.py b/tests/flattener_dicos/70container_new/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_new/tiramisu/base.py b/tests/flattener_dicos/70container_new/tiramisu/base.py
new file mode 100644
index 00000000..26efa8c6
--- /dev/null
+++ b/tests/flattener_dicos/70container_new/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_5 = OptionDescription(doc='test', name='test', children=[])
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/70container_newnocont/__init__.py b/tests/flattener_dicos/70container_newnocont/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_newnocont/tiramisu/__init__.py b/tests/flattener_dicos/70container_newnocont/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_newnocont/tiramisu/base.py b/tests/flattener_dicos/70container_newnocont/tiramisu/base.py
new file mode 100644
index 00000000..94b83079
--- /dev/null
+++ b/tests/flattener_dicos/70container_newnocont/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='non', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_5 = OptionDescription(doc='test', name='test', children=[])
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/70container_newwithip/__init__.py b/tests/flattener_dicos/70container_newwithip/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_newwithip/tiramisu/__init__.py b/tests/flattener_dicos/70container_newwithip/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_newwithip/tiramisu/base.py b/tests/flattener_dicos/70container_newwithip/tiramisu/base.py
new file mode 100644
index 00000000..80512cc7
--- /dev/null
+++ b/tests/flattener_dicos/70container_newwithip/tiramisu/base.py
@@ -0,0 +1,11 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_4 = IPOption(allow_reserved=True, properties=frozenset(['normal']), doc='No change', multi=False, name='adresse_ip_test')
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_6 = OptionDescription(doc='test', name='test', children=[])
+option_5 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_6])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_5])
diff --git a/tests/flattener_dicos/70container_pathaccess/__init__.py b/tests/flattener_dicos/70container_pathaccess/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_pathaccess/result/00-base.xml b/tests/flattener_dicos/70container_pathaccess/result/00-base.xml
index 8dcff25a..c28cae29 100644
--- a/tests/flattener_dicos/70container_pathaccess/result/00-base.xml
+++ b/tests/flattener_dicos/70container_pathaccess/result/00-base.xml
@@ -6,12 +6,12 @@
       <family name="ips" doc="ips">
         <family doc="nut_monitor_host" name="nut_monitor_host">
           <variable doc="interface" multi="False" name="interface" type="string">
-            <value>auto</value>
+            <value type="string">auto</value>
           </variable>
-          <variable multi="False" name="name" opt="rougail.general.nut_monitor_host" type="symlink"/>
-          <variable multi="False" name="netmask" opt="rougail.general.nut_monitor_netmask" type="symlink"/>
+          <variable name="name" opt="rougail.general.nut_monitor_host" type="symlink"/>
+          <variable name="netmask" opt="rougail.general.nut_monitor_netmask" type="symlink"/>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/70container_pathaccess/tiramisu/__init__.py b/tests/flattener_dicos/70container_pathaccess/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_pathaccess/tiramisu/base.py b/tests/flattener_dicos/70container_pathaccess/tiramisu/base.py
new file mode 100644
index 00000000..8c65112d
--- /dev/null
+++ b/tests/flattener_dicos/70container_pathaccess/tiramisu/base.py
@@ -0,0 +1,18 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_4 = NetmaskOption(properties=frozenset(['mandatory', 'basic']), doc='Masque de l\'IP du réseau de l\'esclave', multi=False, name='nut_monitor_netmask')
+option_5 = NetworkOption(properties=frozenset(['mandatory', 'basic']), doc='Adresse IP du réseau de l\'esclave', multi=False, name='nut_monitor_host')
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['basic']), children=[option_3, option_4, option_5])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_10 = StrOption(properties=frozenset([]), doc='interface', multi=False, name='interface', default='auto')
+option_11 = SymLinkOption(name='name', opt=option_5)
+option_12 = SymLinkOption(name='netmask', opt=option_4)
+option_13 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_9 = OptionDescription(doc='nut_monitor_host', name='nut_monitor_host', children=[option_10, option_11, option_12, option_13])
+option_8 = OptionDescription(name='ips', doc='ips', children=[option_9])
+option_7 = OptionDescription(doc='nut', name='nut', children=[option_8])
+option_6 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_7])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_6])
diff --git a/tests/flattener_dicos/70container_pathaccess_leadership/__init__.py b/tests/flattener_dicos/70container_pathaccess_leadership/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_pathaccess_leadership/result/00-base.xml b/tests/flattener_dicos/70container_pathaccess_leadership/result/00-base.xml
index 5f35dabc..8eb7d53b 100644
--- a/tests/flattener_dicos/70container_pathaccess_leadership/result/00-base.xml
+++ b/tests/flattener_dicos/70container_pathaccess_leadership/result/00-base.xml
@@ -6,12 +6,12 @@
       <family name="ips" doc="ips">
         <family doc="nut_monitor_host" name="nut_monitor_host">
           <variable doc="interface" multi="False" name="interface" type="string">
-            <value>auto</value>
+            <value type="string">auto</value>
           </variable>
-          <variable multi="False" name="name" opt="rougail.general.nut_monitor_netmask.nut_monitor_host" type="symlink"/>
-          <variable multi="False" name="netmask" opt="rougail.general.nut_monitor_netmask.nut_monitor_netmask" type="symlink"/>
+          <variable name="name" opt="rougail.general.nut_monitor_netmask.nut_monitor_host" type="symlink"/>
+          <variable name="netmask" opt="rougail.general.nut_monitor_netmask.nut_monitor_netmask" type="symlink"/>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/70container_pathaccess_leadership/tiramisu/__init__.py b/tests/flattener_dicos/70container_pathaccess_leadership/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_pathaccess_leadership/tiramisu/base.py b/tests/flattener_dicos/70container_pathaccess_leadership/tiramisu/base.py
new file mode 100644
index 00000000..2a75d88a
--- /dev/null
+++ b/tests/flattener_dicos/70container_pathaccess_leadership/tiramisu/base.py
@@ -0,0 +1,19 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_5 = NetmaskOption(properties=frozenset(['mandatory']), doc='Masque de l\'IP du réseau de l\'esclave', multi=True, name='nut_monitor_netmask')
+option_6 = NetworkOption(properties=frozenset(['mandatory', 'basic']), doc='Adresse IP du réseau de l\'esclave', multi=True, name='nut_monitor_host')
+option_4 = Leadership(doc='Masque de l\'IP du réseau de l\'esclave', name='nut_monitor_netmask', properties=frozenset(['basic']), children=[option_5, option_6])
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['basic']), children=[option_3, option_4])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_11 = StrOption(properties=frozenset([]), doc='interface', multi=False, name='interface', default='auto')
+option_12 = SymLinkOption(name='name', opt=option_6)
+option_13 = SymLinkOption(name='netmask', opt=option_5)
+option_14 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_10 = OptionDescription(doc='nut_monitor_host', name='nut_monitor_host', children=[option_11, option_12, option_13, option_14])
+option_9 = OptionDescription(name='ips', doc='ips', children=[option_10])
+option_8 = OptionDescription(doc='ntp', name='ntp', children=[option_9])
+option_7 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_8])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_7])
diff --git a/tests/flattener_dicos/70container_save/__init__.py b/tests/flattener_dicos/70container_save/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_save/tiramisu/__init__.py b/tests/flattener_dicos/70container_save/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_save/tiramisu/base.py b/tests/flattener_dicos/70container_save/tiramisu/base.py
new file mode 100644
index 00000000..89840741
--- /dev/null
+++ b/tests/flattener_dicos/70container_save/tiramisu/base.py
@@ -0,0 +1,8 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1])
diff --git a/tests/flattener_dicos/70container_serviceaccess/__init__.py b/tests/flattener_dicos/70container_serviceaccess/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_serviceaccess/result/00-base.xml b/tests/flattener_dicos/70container_serviceaccess/result/00-base.xml
index c603bc1d..0bcf2d19 100644
--- a/tests/flattener_dicos/70container_serviceaccess/result/00-base.xml
+++ b/tests/flattener_dicos/70container_serviceaccess/result/00-base.xml
@@ -6,13 +6,13 @@
       <family name="ports" doc="ports">
         <family doc="123" name="123">
           <variable doc="name" multi="False" name="name" type="port">
-            <value>123</value>
+            <value type="port">123</value>
           </variable>
           <variable doc="protocol" multi="False" name="protocol" type="string">
-            <value>udp</value>
+            <value type="string">udp</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/70container_serviceaccess/tiramisu/__init__.py b/tests/flattener_dicos/70container_serviceaccess/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_serviceaccess/tiramisu/base.py b/tests/flattener_dicos/70container_serviceaccess/tiramisu/base.py
new file mode 100644
index 00000000..4dba8f53
--- /dev/null
+++ b/tests/flattener_dicos/70container_serviceaccess/tiramisu/base.py
@@ -0,0 +1,15 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_8 = PortOption(allow_private=True, properties=frozenset([]), doc='name', multi=False, name='name', default='123')
+option_9 = StrOption(properties=frozenset([]), doc='protocol', multi=False, name='protocol', default='udp')
+option_10 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_7 = OptionDescription(doc='123', name='123', children=[option_8, option_9, option_10])
+option_6 = OptionDescription(name='ports', doc='ports', children=[option_7])
+option_5 = OptionDescription(doc='ntp', name='ntp', children=[option_6])
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/70container_servicerestriction/__init__.py b/tests/flattener_dicos/70container_servicerestriction/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_servicerestriction/result/00-base.xml b/tests/flattener_dicos/70container_servicerestriction/result/00-base.xml
index e6709841..28dd3254 100644
--- a/tests/flattener_dicos/70container_servicerestriction/result/00-base.xml
+++ b/tests/flattener_dicos/70container_servicerestriction/result/00-base.xml
@@ -6,16 +6,16 @@
       <family name="ips" doc="ips">
         <family doc="192.168.1.1" name="192_168_1_1">
           <variable doc="interface" multi="False" name="interface" type="string">
-            <value>eth0</value>
+            <value type="string">eth0</value>
           </variable>
           <variable doc="name" multi="False" name="name" type="network">
-            <value>192.168.1.1</value>
+            <value type="network">192.168.1.1</value>
           </variable>
           <variable doc="netmask" multi="False" name="netmask" type="netmask">
-            <value>255.255.255.255</value>
+            <value type="netmask">255.255.255.255</value>
           </variable>
           <variable doc="activate" multi="False" name="activate" type="boolean">
-            <value>True</value>
+            <value type="boolean">True</value>
           </variable>
         </family>
       </family>
diff --git a/tests/flattener_dicos/70container_servicerestriction/tiramisu/__init__.py b/tests/flattener_dicos/70container_servicerestriction/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_servicerestriction/tiramisu/base.py b/tests/flattener_dicos/70container_servicerestriction/tiramisu/base.py
new file mode 100644
index 00000000..82aef0a4
--- /dev/null
+++ b/tests/flattener_dicos/70container_servicerestriction/tiramisu/base.py
@@ -0,0 +1,16 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_8 = StrOption(properties=frozenset([]), doc='interface', multi=False, name='interface', default='eth0')
+option_9 = NetworkOption(properties=frozenset([]), doc='name', multi=False, name='name', default='192.168.1.1')
+option_10 = NetmaskOption(properties=frozenset([]), doc='netmask', multi=False, name='netmask', default='255.255.255.255')
+option_11 = BoolOption(default=True, properties=frozenset([]), doc='activate', multi=False, name='activate')
+option_7 = OptionDescription(doc='192.168.1.1', name='192_168_1_1', children=[option_8, option_9, option_10, option_11])
+option_6 = OptionDescription(name='ips', doc='ips', children=[option_7])
+option_5 = OptionDescription(doc='testsrv', name='testsrv', children=[option_6])
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/70container_services/__init__.py b/tests/flattener_dicos/70container_services/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_services/tiramisu/__init__.py b/tests/flattener_dicos/70container_services/tiramisu/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/70container_services/tiramisu/base.py b/tests/flattener_dicos/70container_services/tiramisu/base.py
new file mode 100644
index 00000000..ea0725dc
--- /dev/null
+++ b/tests/flattener_dicos/70container_services/tiramisu/base.py
@@ -0,0 +1,10 @@
+from tiramisu import *
+from rougail.tiramisu import ConvertDynOptionDescription
+import imp
+func = imp.load_source('func', 'tests/flattener_dicos/../eosfunc/test.py')
+option_3 = ChoiceOption(properties=frozenset(['force_default_on_freeze', 'frozen', 'hidden', 'mandatory', 'normal']), doc='No change', multi=False, name='mode_conteneur_actif', default='oui', values=('oui', 'non'))
+option_2 = OptionDescription(doc='général', name='general', properties=frozenset(['normal']), children=[option_3])
+option_1 = OptionDescription(doc='rougail', name='rougail', children=[option_2])
+option_5 = OptionDescription(doc='testsrv', name='testsrv', children=[])
+option_4 = OptionDescription(name='services', doc='services', properties=frozenset(['hidden']), children=[option_5])
+option_0 = OptionDescription(name='baseoption', doc='baseoption', children=[option_1, option_4])
diff --git a/tests/flattener_dicos/80action_onlyone/__init__.py b/tests/flattener_dicos/80action_onlyone/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80auto_autofreeze/__init__.py b/tests/flattener_dicos/80auto_autofreeze/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80auto_autosave/__init__.py b/tests/flattener_dicos/80auto_autosave/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80auto_error/__init__.py b/tests/flattener_dicos/80auto_error/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80auto_multi/__init__.py b/tests/flattener_dicos/80auto_multi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80condition_itself/__init__.py b/tests/flattener_dicos/80condition_itself/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80condition_not_exists_error/__init__.py b/tests/flattener_dicos/80condition_not_exists_error/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80container_files_symlink_without_source/__init__.py b/tests/flattener_dicos/80container_files_symlink_without_source/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80container_filesredefine_error/__init__.py b/tests/flattener_dicos/80container_filesredefine_error/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80empty_typeeole_container/__init__.py b/tests/flattener_dicos/80empty_typeeole_container/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80empty_typeeole_eole/__init__.py b/tests/flattener_dicos/80empty_typeeole_eole/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80empty_typeeole_number/__init__.py b/tests/flattener_dicos/80empty_typeeole_number/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80empty_typeeole_python/__init__.py b/tests/flattener_dicos/80empty_typeeole_python/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80empty_validenum/__init__.py b/tests/flattener_dicos/80empty_validenum/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80family_several/__init__.py b/tests/flattener_dicos/80family_several/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80fill_container/__init__.py b/tests/flattener_dicos/80fill_container/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80hidden_if_in_filelist/__init__.py b/tests/flattener_dicos/80hidden_if_in_filelist/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80leadership_auto_save/__init__.py b/tests/flattener_dicos/80leadership_auto_save/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80leadership_autofreeze/__init__.py b/tests/flattener_dicos/80leadership_autofreeze/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80leadership_none_follower_between_follower/__init__.py b/tests/flattener_dicos/80leadership_none_follower_between_follower/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80leadership_not_ordered/__init__.py b/tests/flattener_dicos/80leadership_not_ordered/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80leadership_not_same_family/__init__.py b/tests/flattener_dicos/80leadership_not_same_family/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80leadership_notexists/__init__.py b/tests/flattener_dicos/80leadership_notexists/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80redefine_autoerror/__init__.py b/tests/flattener_dicos/80redefine_autoerror/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80redefine_error/__init__.py b/tests/flattener_dicos/80redefine_error/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80redefine_helperror/__init__.py b/tests/flattener_dicos/80redefine_helperror/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80redefine_notexists/__init__.py b/tests/flattener_dicos/80redefine_notexists/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80separator_multi/__init__.py b/tests/flattener_dicos/80separator_multi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80separator_multi2/__init__.py b/tests/flattener_dicos/80separator_multi2/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80separator_nonexists/__init__.py b/tests/flattener_dicos/80separator_nonexists/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80unknown_validenum/__init__.py b/tests/flattener_dicos/80unknown_validenum/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80validenum_ouinon/__init__.py b/tests/flattener_dicos/80validenum_ouinon/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80validenum_python_not_list/__init__.py b/tests/flattener_dicos/80validenum_python_not_list/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80validenum_python_unknown/__init__.py b/tests/flattener_dicos/80validenum_python_unknown/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/80validenum_python_unknownvalue/__init__.py b/tests/flattener_dicos/80validenum_python_unknownvalue/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/88valid_enum_not_number/__init__.py b/tests/flattener_dicos/88valid_enum_not_number/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/88valid_enum_numberdefaultstring/__init__.py b/tests/flattener_dicos/88valid_enum_numberdefaultstring/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/flattener_dicos/__init__.py b/tests/flattener_dicos/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_flattener.py b/tests/test_1_flattener.py
similarity index 90%
rename from tests/test_flattener.py
rename to tests/test_1_flattener.py
index 8056111e..82d57693 100644
--- a/tests/test_flattener.py
+++ b/tests/test_1_flattener.py
@@ -6,9 +6,8 @@ from json import load
 
 from rougail import objspace, annotator
 from rougail.xml_compare import xml_compare
-from rougail.error import CreoleDictConsistencyError
-from rougail.config import dtdfilename
-from rougail.annotator import VARIABLE_NAMESPACE
+from rougail.error import DictConsistencyError
+from rougail.config import dtdfilename, variable_namespace
 
 
 
@@ -23,7 +22,7 @@ for test in listdir(dico_dirs):
     if isdir(join(dico_dirs, test)):
         if isdir(join(dico_dirs, test, 'result')):
             test_ok.add(test)
-        else:
+        elif test != '__pycache__':
             test_raise.add(test)
 
 excludes = set([])
@@ -67,12 +66,14 @@ def compare_xml(exported_xmlfile, expected_xmlfile):
 
 
 def launch_flattener(test_dir, test_ok=False):
+    debug = False
+#    debug = True
     eolobj = objspace.CreoleObjSpace(dtdfilename)
     dirs = [test_dir]
     subfolder = join(test_dir, 'subfolder')
     if isdir(subfolder):
         dirs.append(subfolder)
-    eolobj.create_or_populate_from_xml(VARIABLE_NAMESPACE, dirs)
+    eolobj.create_or_populate_from_xml(variable_namespace, dirs)
     subfolder = join(test_dir, 'extra_dirs', 'extra')
     if isdir(subfolder):
         eolobj.create_or_populate_from_xml('extra', [subfolder])
@@ -84,7 +85,8 @@ def launch_flattener(test_dir, test_ok=False):
     eolobj.save(destfile)
     result_file = join(test_dir, 'result/00-base.xml')
     if isfile(result_file):
-        #eolobj.save(result_file)
+        if debug:
+            eolobj.save(result_file)
         compare_xml(destfile, result_file)
     elif test_ok:
         raise Exception(f'no test found for {test_dir}')
@@ -113,7 +115,7 @@ def test_dictionary(test_dir):
 
 def test_error_dictionary(test_dir_error):
     test_dir = join(dico_dirs, test_dir_error)
-    with raises(CreoleDictConsistencyError):
+    with raises(DictConsistencyError):
         launch_flattener(test_dir)
 
 
diff --git a/tests/test_2_tiramisu.py b/tests/test_2_tiramisu.py
new file mode 100644
index 00000000..e96dd58a
--- /dev/null
+++ b/tests/test_2_tiramisu.py
@@ -0,0 +1,80 @@
+from lxml import etree
+from os.path import isfile, join, isdir
+from pytest import fixture, mark
+from os import listdir, mkdir
+from json import dump, load, dumps, loads
+
+from tiramisu import Config
+from rougail import load as rougail_load
+from rougail.xml_compare import xml_compare
+from rougail.error import DictConsistencyError
+
+
+dico_dirs = 'tests/flattener_dicos'
+
+
+test_ok = set()
+
+for test in listdir(dico_dirs):
+    if isdir(join(dico_dirs, test)):
+        if isdir(join(dico_dirs, test, 'result')):
+            test_ok.add(test)
+
+excludes = set([])
+#excludes = set(['70container_services'])
+test_ok -= excludes
+#test_ok = ['10leadership_append']
+
+
+test_ok = list(test_ok)
+test_ok.sort()
+
+
+@fixture(scope="module", params=test_ok)
+def test_dir(request):
+    return request.param
+
+
+async def launch_flattener(test_dir):
+    debug = False
+#    debug = True
+    eosfunc = join(dico_dirs, '../eosfunc/test.py')
+    cache_file = test_dir + '/result/00-base.xml'
+    fileio = open(cache_file)
+    xmlroot = etree.parse(fileio).getroot()
+    tiramisu_objects = rougail_load(xmlroot,
+                                    eosfunc,
+                                    )
+    tiramisu_objects += '\n'
+    #print(tiramisu_objects)
+    tiramisu_dir = join(test_dir, 'tiramisu')
+    tiramisu_file = join(tiramisu_dir, 'base.py')
+    #config = await Config(tiramisu_objects)
+    #await config.property.read_only()
+    #await config.property.pop('mandatory')
+    #config_dict = await config.value.dict()
+    if not isdir(tiramisu_dir):
+        mkdir(tiramisu_dir)
+    if not isfile(tiramisu_file) or debug:
+        with open(tiramisu_file, 'w') as fh:
+            fh.write(tiramisu_objects)
+    with open(tiramisu_file, 'r') as fh:
+        tiramisu_objects_ori = fh.read()
+    assert tiramisu_objects == tiramisu_objects_ori
+    #if config_dict:
+    #    if not isdir(tiramisu_dir):
+    #        mkdir(tiramisu_dir)
+    #    #with open(tiramisu_file, 'w') as fh:
+    #    #    dump(config_dict, fh)
+    #    #    fh.write('\n')
+    #if not isfile(tiramisu_file):
+    #    if config_dict:
+    #        raise Exception('dict is not empty')
+    #else:
+    #        assert load(fh) == loads(dumps(config_dict))
+
+
+@mark.asyncio
+async def test_dictionary(test_dir):
+    test_dir = join(dico_dirs, test_dir)
+    await launch_flattener(test_dir)
diff --git a/tests/test_makedict.py b/tests/test_3_makedict.py
similarity index 73%
rename from tests/test_makedict.py
rename to tests/test_3_makedict.py
index 5b4e370d..ec2af49d 100644
--- a/tests/test_makedict.py
+++ b/tests/test_3_makedict.py
@@ -7,7 +7,7 @@ from json import dump, load, dumps, loads
 from tiramisu import Config
 from rougail import load as rougail_load
 from rougail.xml_compare import xml_compare
-from rougail.error import CreoleDictConsistencyError
+from rougail.error import DictConsistencyError
 from rougail.config import dtdfilename
 
 
@@ -37,16 +37,21 @@ def test_dir(request):
 
 
 async def launch_flattener(test_dir):
-    eosfunc = join(dico_dirs, '../eosfunc/test.py')
-    cache_file = test_dir + '/result/00-base.xml'
-    fileio = open(cache_file)
-    xmlroot = etree.parse(fileio).getroot()
-    tiramisu_objects = rougail_load(xmlroot,
-                                    dtdfilename,
-                                    eosfunc)
+    #eosfunc = join(dico_dirs, '../eosfunc/test.py')
+    #cache_file = test_dir + '/result/00-base.xml'
+    #fileio = open(cache_file)
+    #xmlroot = etree.parse(fileio).getroot()
+    #tiramisu_objects = rougail_load(xmlroot,
+    #                                dtdfilename,
+    #                                eosfunc)
     makedict_dir = join(test_dir, 'makedict')
     makedict_file = join(makedict_dir, 'base.json')
-    config = await Config(tiramisu_objects)
+
+    modulepath = test_dir.replace('/', '.') + '.tiramisu.base'
+    mod = __import__(modulepath)
+    for token in modulepath.split(".")[1:]:
+        mod = getattr(mod, token)
+    config = await Config(mod.option_0)
     await config.property.read_only()
     await config.property.pop('mandatory')
     config_dict = await config.value.dict()
diff --git a/tests/test_template.py b/tests/test_4_template.py
similarity index 98%
rename from tests/test_template.py
rename to tests/test_4_template.py
index ca03230a..86ed1015 100644
--- a/tests/test_template.py
+++ b/tests/test_4_template.py
@@ -51,7 +51,6 @@ async def test_dictionary(test_dir):
     with open(join(test_dir, '00-base.xml')) as fileio:
         xmlroot = parse(fileio).getroot()
         optiondescription = load(xmlroot,
-                                 dtdfilename,
                                  funcs_file)
 
     config = await Config(optiondescription)