From: eficas <> Date: Fri, 4 Nov 2005 17:08:06 +0000 (+0000) Subject: CCAR:ajout d'un repertoire de tests elementaires X-Git-Tag: CC_param_poursuite~67 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=22f3da2b30d347fb6f79a04a71ccaa7f923efac0;p=tools%2Feficas.git CCAR:ajout d'un repertoire de tests elementaires --- diff --git a/Ihm/I_JDC.py b/Ihm/I_JDC.py index f4ee8bc6..dd814447 100644 --- a/Ihm/I_JDC.py +++ b/Ihm/I_JDC.py @@ -21,7 +21,7 @@ """ """ # Modules Python -import types,traceback,sys +import types,traceback,sys,os import string,linecache # Modules Eficas diff --git a/Tests/README b/Tests/README new file mode 100644 index 00000000..eb536e9e --- /dev/null +++ b/Tests/README @@ -0,0 +1,15 @@ +Pour executer tous les tests faire:: + + python run.py + +Pour executer seulement un module de test (testsimp1.py par exemple), faire:: + + python run.py testelem/testsimp1.py + +Un test correspond à l'exécution d'une méthode dont le nom commence par test ou Test +d'une classe dont le nom commence par test ou Test dans un module dont le nom +commence par test ou Test éventuellement dans un répertoire dont le nom commence +par test ou Test. + +Quelques tests dont le nom commence par futuretest ne sont pas exécutés. Ils identifient +des limites actuelles d'Accas. diff --git a/Tests/compare.py b/Tests/compare.py new file mode 100644 index 00000000..f81a49e1 --- /dev/null +++ b/Tests/compare.py @@ -0,0 +1,68 @@ +# -*- coding: iso-8859-1 -*- +import re + +BLANKLINE_MARKER = '' +ELLIPSIS_MARKER = '...' +True=1 +False=0 + +def check(want,got): + if got == want: return True + + # Replace in want with a blank line. + want = re.sub('(?m)^%s\s*?$' % re.escape(BLANKLINE_MARKER), + '', want) + # If a line in got contains only spaces, then remove the + # spaces. + got = re.sub('(?m)^\s*?$', '', got) + if got == want: + return True + + if _ellipsis_match(want, got): + return True + + return False + +def _ellipsis_match(want, got): + if ELLIPSIS_MARKER not in want: + return want == got + + # Find "the real" strings. + ws = want.split(ELLIPSIS_MARKER) + assert len(ws) >= 2 + + # Deal with exact matches possibly needed at one or both ends. + startpos, endpos = 0, len(got) + w = ws[0] + if w: # starts with exact match + if got.startswith(w): + startpos = len(w) + del ws[0] + else: + return False + w = ws[-1] + if w: # ends with exact match + if got.endswith(w): + endpos -= len(w) + del ws[-1] + else: + return False + + if startpos > endpos: + # Exact end matches required more characters than we have, as in + # _ellipsis_match('aa...aa', 'aaa') + return False + + # For the rest, we only need to find the leftmost non-overlapping + # match for each piece. If there's no overall match that way alone, + # there's no overall match period. + for w in ws: + # w may be '' at times, if there are consecutive ellipses, or + # due to an ellipsis at the start or end of `want`. That's OK. + # Search for an empty string succeeds, and doesn't change startpos. + startp = got.find(w, startpos, endpos) + if startp < 0: + return False + startpos = startp + len(w) + + return True diff --git a/Tests/prefs.py b/Tests/prefs.py new file mode 100644 index 00000000..e69de29b diff --git a/Tests/run.py b/Tests/run.py new file mode 100644 index 00000000..e1a5dce4 --- /dev/null +++ b/Tests/run.py @@ -0,0 +1,202 @@ +import sys,types,os +import sre +import unittest +from optparse import OptionParser + +sys.path[:0]=[".."] + +testMatch = sre.compile(r'^[Tt]est') + +class TestSuite(unittest.TestSuite): + loader = unittest.defaultTestLoader + + def __init__(self, names=[]): + self.names=names + super(TestSuite,self).__init__() + tests=self.collectTests() + self.addTests(tests) + + def _import(self,name): + mod = __import__(name,{},{}) + components = name.split('.') + for comp in components[1:]: + mod = getattr(mod,comp) + return mod + + def collectTests(self): + if self.names: + entries=self.names + else: + entries = [ item for item in os.listdir(os.getcwd()) + if item.lower().find('test') >= 0 ] + + tests=[] + for item in entries: + path=os.path.abspath(os.path.join(os.getcwd(),item)) + if os.path.isfile(item): + root, ext = os.path.splitext(item) + if ext == '.py': + if root.find('/') >= 0: + dirname, file = os.path.split(path) + root, ext = os.path.splitext(file) + sys.path.insert(0,dirname) + mod=self._import(root) + sys.path.remove(dirname) + else: + mod=self._import(root) + tests.append(ModuleTestSuite(mod)) + elif os.path.isdir(item): + init = os.path.abspath(os.path.join(item,'__init__.py')) + if os.path.isfile(init): + package=self._import(item) + if package: + tests.append(TestPackageSuite(package)) + else: + tests.append(TestDirectorySuite(path)) + return tests + +class TestDirectorySuite(TestSuite): + ignore=[] + def __init__(self,path): + self.path=path + super(TestDirectorySuite,self).__init__() + + def collectTests(self): + tests=[] + if self.path: + sys.path.insert(0,self.path) + entries = os.listdir(self.path) + entries.sort() + for item in entries: + if (item[0] == '.' + or item in self.ignore + or not testMatch.search(item)): + continue + item_path = os.path.abspath(os.path.join(self.path,item)) + if os.path.isfile(item_path): + root, ext = os.path.splitext(item) + if ext != '.py': + continue + if root.find('/') >= 0: + dirname, file = os.path.split(item_path) + root, ext = os.path.splitext(file) + sys.path.insert(0,dirname) + mod=self._import(root) + sys.path.remove(dirname) + else: + mod=self._import(root) + tests.append(ModuleTestSuite(mod)) + elif os.path.isdir(item_path): + init = os.path.abspath(os.path.join(item_path,'__init__.py')) + if os.path.isfile(init): + package=self._import(item) + if package: + tests.append(TestPackageSuite(package)) + else: + tests.append(TestDirectorySuite(item_path)) + sys.path.remove(self.path) + return tests + +class TestPackageSuite(TestDirectorySuite): + def __init__(self,package): + self.package=package + path=os.path.abspath(os.path.dirname(self.package.__file__)) + super(TestPackageSuite,self).__init__(path) + + def collectTests(self): + tests=[] + if self.path: + sys.path.insert(0,self.path) + entries = os.listdir(self.path) + entries.sort() + for item in entries: + if (item[0] == '.' + or item in self.ignore + or not testMatch.search(item)): + continue + item_path = os.path.abspath(os.path.join(self.path,item)) + if os.path.isfile(item_path): + root, ext = os.path.splitext(item) + if ext != '.py': + continue + name="%s.%s" % (self.package.__name__,root) + mod=self._import(name) + tests.append(ModuleTestSuite(mod)) + elif os.path.isdir(item_path): + init = os.path.abspath(os.path.join(item_path,'__init__.py')) + if os.path.isfile(init): + name="%s.%s" % (self.package.__name__,item) + package=self._import(name) + if package: + tests.append(TestPackageSuite(package)) + else: + tests.append(TestDirectorySuite(item_path)) + sys.path.remove(self.path) + return tests + + +class ModuleTestSuite(TestSuite): + + def __init__(self, module): + self.module = module + super(ModuleTestSuite,self).__init__() + + def collectTests(self): + def cmpLineNo(a,b): + a_ln = a.func_code.co_firstlineno + b_ln = b.func_code.co_firstlineno + return cmp(a_ln,b_ln) + + entries = dir(self.module) + tests = [] + func_tests = [] + for item in entries: + test = getattr(self.module,item) + if (isinstance(test, (type, types.ClassType)) + and issubclass(test,unittest.TestCase)): + if testMatch.search(item): + [ tests.append(case) for case in + self.loader.loadTestsFromTestCase(test)._tests ] + elif callable(test) and testMatch.search(item): + # simple functional test + func_tests.append(test) + + # run functional tests in the order in which they are defined + func_tests.sort(cmpLineNo) + [ tests.append(unittest.FunctionTestCase(test)) + for test in func_tests ] + return tests + +class TestProgram(unittest.TestProgram): + USAGE=""" +""" + def __init__(self,testRunner=None): + self.testRunner = testRunner + self.verbosity = 1 + self.parseArgs(sys.argv) + self.createTests() + self.runTests() + + def parseArgs(self,argv): + parser = OptionParser(usage=self.USAGE) + parser.add_option("-v","--verbose",action="count", + dest="verbosity",default=1, + help="Be more verbose. ") + + options, args = parser.parse_args(argv) + self.verbosity = options.verbosity + + if args: + self.names = list(args) + if self.names[0] == 'run.py': + self.names = self.names[1:] + + def createTests(self): + self.test = TestSuite(self.names) + + +main = TestProgram + +if __name__ == "__main__": + main() + diff --git a/Tests/testelem/cata1.py b/Tests/testelem/cata1.py new file mode 100644 index 00000000..fcbb0a1d --- /dev/null +++ b/Tests/testelem/cata1.py @@ -0,0 +1,76 @@ +from Accas import SIMP,FACT,OPER,ASSD,AsException,AsType + +class CATA: + def __init__(self): + CONTEXT.unset_current_cata() + CONTEXT.set_current_cata(self) + def enregistre(self,cmd): + pass + +cata=CATA() + +class concept(ASSD):pass + +OP1 = OPER(nom='OP1',op=1,sd_prod=concept, + a=SIMP(typ='I'), + c=SIMP(typ='I',position='global'), + ) + +class concept2(ASSD):pass +class concept3(ASSD):pass + +def op2_prod(TYPE_RESU,**args): + if TYPE_RESU == "TRANS" : return concept2 + if TYPE_RESU == "HARMO" : return concept3 + raise AsException("type de concept resultat non prevu") + +OP2=OPER(nom='OP2',op=2,sd_prod=op2_prod, + TYPE_RESU =SIMP(statut='f',typ='TXM',defaut="TRANS",into=("TRANS","HARMO") ), + ) + +def op3_prod(MATR,**args): + if AsType(MATR) == concept : return concept2 + raise AsException("type de concept resultat non prevu") + +OP3=OPER(nom='OP3',op=3,sd_prod=op3_prod, + MATR =SIMP(statut='o',typ=concept), + ) + +def op4_prod(MESURE,**args): + vale=MESURE['NOM_PARA'] + if vale == 'INST' : return concept + raise AsException("type de concept resultat non prevu") + +OP4=OPER(nom='OP4',op=4,sd_prod=op4_prod, + MESURE =FACT(statut='o',min=01,max=01, + NOM_PARA =SIMP(statut='f',typ='TXM',defaut="INST",into=("INST",) ), + ) + ) + +def op5_prod(FFT,**args): + if (FFT != None) : + vale=FFT.get_child('FONCTION').get_valeur() + if (AsType(vale) == concept ) : return concept + if (AsType(vale) == concept2) : return concept2 + raise AsException("type de concept resultat non prevu") + + +OP5=OPER(nom='OP5',op=5,sd_prod=op5_prod, + FFT =FACT(statut='f',min=1,max=1, + FONCTION =SIMP(statut='o',typ=(concept,concept2) ) + ), + ) + +def op6_prod(FILTRE,**args): + vale=FILTRE[0]['MODE'] + if AsType(vale) == concept : return concept + if AsType(vale) == concept2 : return concept2 + raise AsException("type de concept resultat non prevu") + +OP6=OPER(nom='OP6',op=6,sd_prod=op6_prod, + FILTRE =FACT(statut='o',min=01,max='**', + MODE =SIMP(statut='o',typ=(concept,concept2) ), + ) + ) + + diff --git a/Tests/testelem/cata2.py b/Tests/testelem/cata2.py new file mode 100644 index 00000000..7a632543 --- /dev/null +++ b/Tests/testelem/cata2.py @@ -0,0 +1,66 @@ +from Accas import SIMP,FACT,OPER,ASSD,AsException,AsType,CO,MACRO + + +class CATA: + def __init__(self): + CONTEXT.unset_current_cata() + CONTEXT.set_current_cata(self) + def enregistre(self,cmd): + pass + +cata=CATA() + +class concept(ASSD):pass + +OP1 = OPER(nom='OP1',op=1,sd_prod=concept, + a=SIMP(typ='I'), + c=SIMP(typ='I',position='global'), + ) + +class concept2(ASSD):pass +class concept3(ASSD):pass + +def op2_prod(self,MATR,**args): + self.type_sdprod(MATR,concept2) + return concept + +OP2=MACRO(nom='OP2',op=-2,sd_prod=op2_prod, + MATR=SIMP(statut='o',typ=(CO,concept2)), + ) + +def op3_prod(self,MATR,**args): + for m in MATR: + t=m['CHAM'] + if t == 'R':self.type_sdprod(m['MM'],concept) + return concept + +OP3=MACRO(nom='OP3',op=-3,sd_prod=op3_prod, + MATR=FACT(statut='f',min=1,max='**', + CHAM=SIMP(statut='o',typ='TXM',into=("R","I"),), + MM=SIMP(statut='o',typ=(CO,concept)), + ), + ) + + +def op4_prod(self,MATR,**args): + if MATR == None :raise AsException("impossible recuperer mot cle facteur par defaut") + return concept + +OP4=MACRO(nom='OP4',op=-4,sd_prod=op4_prod, + MATR=FACT(statut='d',min=1,max='**', + CHAM=SIMP(statut='f',typ='TXM',defaut="R"), + ), + ) +OP5=MACRO(nom='OP5',op=-2,sd_prod=op2_prod, MATR=SIMP(statut='o',typ=CO),) + +def OP6_ops(self,MATR,**args): + """ + """ + ier=0 + self.set_icmd(1) + self.DeclareOut('cc',self.sd) + cc=OP2(MATR=MATR) + return ier + +OP6=MACRO(nom='OP6',op=OP6_ops,sd_prod=op2_prod, MATR=SIMP(statut='o',typ=CO),) + diff --git a/Tests/testelem/cata3.py b/Tests/testelem/cata3.py new file mode 100644 index 00000000..d9c95f28 --- /dev/null +++ b/Tests/testelem/cata3.py @@ -0,0 +1,83 @@ +from Accas import SIMP,FACT,OPER,ASSD,AsException,AsType,CO,MACRO,JDC_CATA + +class concept(ASSD):pass + +JdC=JDC_CATA(code="ASTER") + +OP1 = OPER(nom='OP1',op=1,sd_prod=concept, + a=SIMP(typ='I'), + c=SIMP(typ='I',position='global'), + ) + +class concept2(ASSD):pass +class concept3(ASSD):pass + +def op2_prod(self,MATR,**args): + self.type_sdprod(MATR,concept2) + return concept + +OP2=MACRO(nom='OP2',op=-2,sd_prod=op2_prod, + MATR=SIMP(statut='o',typ=(CO,concept2)), + ) + +def op3_prod(self,MATR,**args): + for m in MATR: + t=m['CHAM'] + if t == 'R':self.type_sdprod(m['MM'],concept) + return concept + +OP3=MACRO(nom='OP3',op=-3,sd_prod=op3_prod, + MATR=FACT(statut='f',min=1,max='**', + CHAM=SIMP(statut='o',typ='TXM',into=("R","I"),), + MM=SIMP(statut='o',typ=(CO,concept)), + ), + ) + + +def op4_prod(self,MATR,**args): + if MATR == None :raise AsException("impossible recuperer mot cle facteur par defaut") + return concept + +OP4=MACRO(nom='OP4',op=-4,sd_prod=op4_prod, + MATR=FACT(statut='d',min=1,max='**', + CHAM=SIMP(statut='f',typ='TXM',defaut="R"), + ), + ) + +def INCLUDE_prod(self,UNITE,**args): + """ Fonction sd_prod pour la macro include + """ + # Si unite a change on reevalue le fichier associe + if not hasattr(self,'unite') or self.unite != UNITE: + f,text=self.get_file(unite=UNITE) + self.unite=UNITE + self.fichier_init = f + # on execute le texte fourni dans le contexte forme par + # le contexte de l etape pere (global au sens Python) + # et le contexte de l etape (local au sens Python) + code=compile(text,f,'exec') + if self.jdc and self.jdc.par_lot == 'NON': + # On est en mode commande par commande + # On teste la validite de la commande avec interruption eventuelle + cr=self.report() + self.parent.cr.add(cr) + if not cr.estvide(): + raise EOFError + d={} + self.g_context = d + self.contexte_fichier_init = d + exec code in self.parent.g_context,d + +def INCLUDE_context(self,d): + """ Fonction op_init pour macro INCLUDE + """ + for k,v in self.g_context.items(): + d[k]=v + +INCLUDE=MACRO(nom="INCLUDE",op=-1, + sd_prod=INCLUDE_prod, + op_init=INCLUDE_context, + #fichier_ini=1, + UNITE = SIMP(statut='o',typ='I'), +); + diff --git a/Tests/testelem/cata5.py b/Tests/testelem/cata5.py new file mode 100644 index 00000000..aeb20947 --- /dev/null +++ b/Tests/testelem/cata5.py @@ -0,0 +1,185 @@ +# -*- coding: iso-8859-15 -*- +from Accas import SIMP,FACT,OPER,ASSD,AsException,AsType,CO,MACRO,JDC_CATA +JdC=JDC_CATA(code="ASTER") + +class concept(ASSD):pass +class concept2(ASSD):pass +class concept3(ASSD):pass +class concept4(concept2):pass + +def OP_ops(self,MATR,**args): + ier=0 + self.set_icmd(1) + return ier + +def op2_prod(self,MATR,**args): + self.type_sdprod(MATR,concept2) + return concept +OP1=MACRO(nom='OP1',op=OP_ops,sd_prod=op2_prod, MATR=SIMP(statut='o',typ=CO),) +OP2=MACRO(nom='OP2',op=OP_ops,sd_prod=op2_prod, MATR=SIMP(statut='o',typ=(CO,concept2)),) +OP10=MACRO(nom='OP10',op=OP_ops,sd_prod=op2_prod, MATR=SIMP(statut='o',typ=concept2),) +OP11=MACRO(nom='OP11',op=OP_ops,sd_prod=concept, MATR=SIMP(statut='o',typ=concept2),) +OP12=MACRO(nom='OP12',op=OP_ops,sd_prod=concept, MATR=SIMP(statut='o',typ=CO),) +OP13=MACRO(nom='OP13',op=OP_ops,sd_prod=concept, MATR=SIMP(statut='o',typ=(CO,concept2)),) + +def op3_prod(self,MATR,**args): + for m in MATR: + t=m['CHAM'] + if t == 'R':self.type_sdprod(m['MM'],concept) + return concept +OP3=MACRO(nom='OP3',op=OP_ops,sd_prod=op3_prod, + MATR=FACT(statut='f',min=1,max='**', + CHAM=SIMP(statut='o',typ='TXM',into=("R","I"),), + MM=SIMP(statut='o',typ=(CO,concept)),),) + +def op4_prod(self,MATR,**args): + if MATR == None :raise AsException("impossible recuperer mot cle facteur par defaut") + return concept +OP4=MACRO(nom='OP4',op=OP_ops,sd_prod=op4_prod, + MATR=FACT(statut='d',min=1,max='**', + CHAM=SIMP(statut='f',typ='TXM',defaut="R"),),) + +OP5=MACRO(nom='OP5',op=OP_ops,sd_prod=op2_prod, MATR=SIMP(statut='o',typ=CO),) + +def op6_prod(self,MATR,**args): + self.type_sdprod(MATR,concept4) + return concept +def OP6_ops(self,MATR,**args): + ier=0 + self.set_icmd(1) + self.DeclareOut('cc',self.sd) + cc=OP2(MATR=MATR) + return ier +OP6=MACRO(nom='OP6',op=OP6_ops,sd_prod=op6_prod, MATR=SIMP(statut='o',typ=CO),) + +def OP7_ops(self,MATR,**args): + ier=0 + self.set_icmd(1) + self.DeclareOut('cc',self.sd) + cc=OP8(MATR=MATR) + return ier +OP7=MACRO(nom='OP7',op=OP7_ops,sd_prod=op2_prod, MATR=SIMP(statut='o',typ=CO),) + +OP8=MACRO(nom='OP8',op=OP_ops,sd_prod=op6_prod, MATR=SIMP(statut='o',typ=(CO,concept4)),) + +def OP9_ops(self,MATR,**args): + ier=0 + self.set_icmd(1) + self.DeclareOut('cc',self.sd) + cc=OP10(MATR=MATR) + return ier +OP9=MACRO(nom='OP9',op=OP9_ops,sd_prod=op6_prod, MATR=SIMP(statut='o',typ=CO),) +def OP14_ops(self,MATR,**args): + ier=0 + self.set_icmd(1) + self.DeclareOut('cc',self.sd) + cc=OP1(MATR=MATR) + return ier +OP14=MACRO(nom='OP14',op=OP14_ops,sd_prod=op6_prod, MATR=SIMP(statut='o',typ=CO),) +def OP15_ops(self,MATR,**args): + ier=0 + self.set_icmd(1) + self.DeclareOut('cc',self.sd) + cc=OP11(MATR=MATR) + return ier +OP15=MACRO(nom='OP15',op=OP15_ops,sd_prod=op6_prod, MATR=SIMP(statut='o',typ=CO),) +def OP16_ops(self,MATR,**args): + ier=0 + self.set_icmd(1) + self.DeclareOut('cc',self.sd) + cc=OP12(MATR=MATR) + return ier +OP16=MACRO(nom='OP16',op=OP16_ops,sd_prod=op6_prod, MATR=SIMP(statut='o',typ=CO),) +def OP17_ops(self,MATR,**args): + ier=0 + self.set_icmd(1) + self.DeclareOut('cc',self.sd) + cc=OP13(MATR=MATR) + return ier +OP17=MACRO(nom='OP17',op=OP17_ops,sd_prod=op6_prod, MATR=SIMP(statut='o',typ=CO),) + +def OP18_ops(self,MATR,**args): + ier=0 + self.set_icmd(1) + self.DeclareOut('cc',self.sd) + cc=OP6(MATR=MATR) + dd=OP2(MATR=MATR) + ee=OP11(MATR=MATR) + return ier +OP18=MACRO(nom='OP18',op=OP18_ops,sd_prod=op6_prod, MATR=SIMP(statut='o',typ=CO),) +OP20=MACRO(nom='OP20',op=OP_ops,sd_prod=op6_prod, MATR=SIMP(statut='o',typ=CO), + MATRB=SIMP(statut='o',typ=CO),) +def OP19_ops(self,MATR,**args): + ier=0 + self.set_icmd(1) + self.DeclareOut('cc',self.sd) + cc=OP20(MATR=MATR,MATRB=MATR) + return ier +OP19=MACRO(nom='OP19',op=OP19_ops,sd_prod=op6_prod, MATR=SIMP(statut='o',typ=CO),) + +OP21=OPER(nom='OP21',op=1,sd_prod=concept) +def OP22_ops(self,MATR,**args): + ier=0 + self.set_icmd(1) + self.DeclareOut('cc',self.sd) + cc=OP21() + return ier +OP22=MACRO(nom='OP22',op=OP22_ops,sd_prod=op6_prod, MATR=SIMP(statut='o',typ=CO),) + +import pickle +import Accas + +def poursuite_sdprod(self,PAR_LOT): + j=self.jdc + #j.UserError=j.codex.error + j.actif_status=1 + j.fico=None + j.set_par_lot(PAR_LOT) + if hasattr(self,'already_init'):return + self.already_init=None + context={} + try: + file=open("pick.1",'r') + # Le contexte sauvegardé a été picklé en une seule fois. Il est seulement + # possible de le récupérer en bloc. Si cette opération echoue, on ne récupère + # aucun objet. + context=pickle.load(file) + file.close() + except: + # En cas d'erreur on ignore le contenu du fichier + import traceback + traceback.print_exc() + pass + for k,v in context.items(): + if isinstance(v,Accas.ASSD): + self.parent.NommerSdprod(v,k) + self.g_context.update(context) + return None + +def poursuite(self,PAR_LOT): + ier=0 + self.set_icmd(1) + return ier + +POURSUITE=MACRO(nom='POURSUITE',op=poursuite,sd_prod=poursuite_sdprod,PAR_LOT=SIMP(typ='TXM',defaut='OUI')) + +def fin(self): + self.set_icmd(1) + raise EOFError +FIN=MACRO(nom='FIN',op=fin,sd_prod=None) + +def debut_sdprod(self,PAR_LOT): + j=self.jdc + #j.UserError=j.codex.error + j.actif_status=1 + j.fico=None + j.set_par_lot(PAR_LOT) + return None + +def debut(self,PAR_LOT): + ier=0 + self.set_icmd(1) + return ier + +DEBUT=MACRO(nom='DEBUT',op=debut,sd_prod=debut_sdprod,PAR_LOT=SIMP(typ='TXM',defaut='OUI')) + diff --git a/Tests/testelem/testbloc1.py b/Tests/testelem/testbloc1.py new file mode 100644 index 00000000..abdd1357 --- /dev/null +++ b/Tests/testelem/testbloc1.py @@ -0,0 +1,174 @@ +# coding=utf-8 +from Accas import SIMP,FACT,BLOC,UN_PARMI,OPER,ASSD,MACRO,_F + +import unittest + +class CATA: + def __init__(self): + CONTEXT.unset_current_cata() + CONTEXT.set_current_cata(self) + def enregistre(self,cmd): + pass + +cata=CATA() + +class concept(ASSD):pass + +OP1 = OPER(nom='OP1',op=1, sd_prod=concept, + WWWW=SIMP(statut='o',typ='TXM', position='global'), + XXXX=SIMP(typ='TXM', position='global',defaut='XXXX'), + traitement=FACT(statut='o', + TATA=SIMP(typ='TXM', position='global',defaut='DDD'), + TTTT=SIMP(statut='o',typ='TXM', position='global',defaut='EEE'), + UUUU=SIMP(typ='TXM', position='global'), + VVVV=SIMP(statut='o',typ='TXM', position='global'), + regles=( UN_PARMI('TYPE_RAFFINEMENT_LIBRE','TYPE_RAFFINEMENT_UNIFORME'),), + TYPE_RAFFINEMENT_LIBRE = FACT(statut='f', + RAFFINEMENT = SIMP(statut='o',typ='TXM', position='global', + into=("LIBRE","UNIFORME",) ), + DERAFFINEMENT = SIMP(statut='o',typ='TXM', position='global', + into=("LIBRE",),), + TOTO=SIMP(statut='o',typ='TXM', position='global'), + # un mot cle global facultatif ne sera pas visible tant + # qu'il n'aura pas de valeur meme s'il a un defaut + TITI=SIMP(typ='TXM', position='global',defaut='BBB'), + TUTU=SIMP(statut='o',typ='TXM', position='global',defaut='CCC'), + ), + b_maj_champ =BLOC(condition="(RAFFINEMENT!=None) or (DERAFFINEMENT!=None)", + NITER =SIMP(statut='o',typ='I',), + NOM_MED_MAILLAGE_NP1 =SIMP(statut='o',typ='TXM',), + FICHIER_MED_MAILLAGE_NP1 =SIMP(statut='o',typ='TXM',), + ), + ), + trait=FACT(statut='o', + FFFF=SIMP(typ='TXM',), + b_champ =BLOC(condition="WWWW=='WWWW'", + N =SIMP(statut='o',typ='I',), + ), + ), +) + +MACR_BIDON=OPER(nom="MACR_BIDON",op=None,sd_prod=concept, + reentrant='n',UIinfo={"groupes":("Outils métier",)},fr="", + NOM_CHAM=SIMP(statut='f',typ='TXM',into=('ACCE','DEPL'),position="global"), + RESULTAT=FACT(statut='o',b_acce=BLOC(condition="NOM_CHAM=='ACCE'", + VAL1=SIMP(statut='o',typ='R'), + ), + VAL2=SIMP(statut='o',typ='R'), + ), + ) +import pprint + +class TestMCBlocCase(unittest.TestCase): + + def test001(self): + """ bloc conditionnel declenche par mot cle global avec defaut + """ + mcf={'TYPE_RAFFINEMENT_LIBRE':{'TOTO':'AAA'}} + co=OP1(traitement=mcf,WWWW='WWWW') + mcfact=co.etape['traitement'] + self.assertEqual(mcfact['TYPE_RAFFINEMENT_LIBRE']['DERAFFINEMENT'] , None) + dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste) + self.assertEqual(dico['DERAFFINEMENT'] , None) + self.assertEqual(dico['RAFFINEMENT'] , None) + self.assertEqual(dico['WWWW'] , 'WWWW') + self.assertRaises(IndexError, mcfact.__getitem__, 'NITER') + + mcfact=co.etape['trait'][0] + dico=mcfact.cree_dict_valeurs(mcfact.mc_liste) + self.assertEqual(dico['DERAFFINEMENT'] , None) + self.assertEqual(dico['RAFFINEMENT'] , None) + self.assertEqual(dico['WWWW'] , 'WWWW') + self.assertEqual(dico['TOTO'] , 'AAA') + self.assertEqual(dico['TUTU'] , 'CCC') + self.assertEqual(dico['FFFF'] , None) + self.assertEqual(dico['VVVV'] , None) + self.assertEqual(dico['TTTT'] , 'EEE') + self.assertEqual(dico['XXXX'] , 'XXXX') + self.assertEqual(mcfact['N'] , None) + self.assertRaises(KeyError, dico.__getitem__, 'TITI') + + def test002(self): + mcf={'TYPE_RAFFINEMENT_LIBRE':{'RAFFINEMENT':'LIBRE'},'NITER':1} + co=OP1(traitement=mcf) + mcfact=co.etape['traitement'] + self.assertEqual(mcfact['TYPE_RAFFINEMENT_LIBRE']['RAFFINEMENT'] , 'LIBRE') + self.assertEqual(mcfact['NITER'] , 1) + + def test003(self): + co=MACR_BIDON(NOM_CHAM='ACCE',RESULTAT=_F(VAL2=3.4)) + mcfact=co.etape['RESULTAT'] + self.assertEqual(co.etape.isvalid(), 0) + + def test004(self): + mcf={'VVVV':'', + 'TYPE_RAFFINEMENT_LIBRE':{'RAFFINEMENT':'LIBRE','DERAFFINEMENT':'LIBRE','TOTO':'AA'}, + 'NITER':1, + 'FICHIER_MED_MAILLAGE_NP1':'', + 'NOM_MED_MAILLAGE_NP1':'', + } + co=OP1(traitement=mcf,WWWW="WWWW",trait={'N':1}) + val=co.etape.isvalid() + if not val:msg=co.etape.report() + else:msg="" + self.assertEqual(co.etape.isvalid() , 1,msg=msg) + + co=OP1(traitement=mcf,WWWW="WWWW") + val=co.etape.isvalid() + if not val:msg=co.etape.report() + else:msg="" + self.assertEqual(co.etape.isvalid() , 0,msg=msg) + + co=OP1(traitement=mcf,WWWW="WW",trait={'N':1}) + val=co.etape.isvalid() + if not val:msg=co.etape.report() + else:msg="" + self.assertEqual(co.etape.isvalid() , 0,msg=msg) + + co=OP1(traitement=mcf,WWWW="WW",trait={'FFFF':'X'}) + val=co.etape.isvalid() + if not val:msg=co.etape.report() + else:msg="" + self.assertEqual(co.etape.isvalid() , 1,msg=msg) + + co=OP1(traitement=mcf,WWWW="WW",) + val=co.etape.isvalid() + if not val:msg=co.etape.report() + else:msg="" + self.assertEqual(co.etape.isvalid() , 1,msg=msg) + + def test005(self): + OP1 = OPER(nom='OP1',op=1, sd_prod=concept, + MASS = FACT(statut='f',max='**', + Y = SIMP(statut='f',typ='I',), + Z = FACT(T=SIMP(typ='I')), + ), + b_mass = BLOC(condition = "MASS != None", + MODE = SIMP(statut='o',typ='I',) + ), + bb_mass = BLOC(condition = "MASS and len(MASS) > 1 ", + XX = SIMP(statut='o',typ='I',) + ), + bbb_mass = BLOC(condition = "MASS and MASS[0]['Y'] == 1 ", + YY = SIMP(statut='o',typ='I',) + ), + bbbb_mass = BLOC(condition = "MASS and MASS[0]['Z'] and MASS[0]['Z'][0]['T'] == 1 ", + ZZ = SIMP(statut='o',typ='I',) + ), + ) + co=OP1() + msg=co.etape.report() + self.assertEqual(co.etape.isvalid() , 1,msg=msg) + co=OP1(MASS={},MODE=1) + msg=co.etape.report() + self.assertEqual(co.etape.isvalid() , 1,msg=msg) + co=OP1(MASS=({},{}),MODE=1,XX=1) + msg=co.etape.report() + self.assertEqual(co.etape.isvalid() , 1,msg=msg) + co=OP1(MASS=({'Y':1},{}),MODE=1,XX=1,YY=1) + msg=co.etape.report() + self.assertEqual(co.etape.isvalid() , 1,msg=msg) + co=OP1(MASS=({'Y':1,'Z':{'T':1}},{}),MODE=1,XX=1,YY=1,ZZ=1) + msg=co.etape.report() + self.assertEqual(co.etape.isvalid() , 1,msg=msg) + diff --git a/Tests/testelem/testfact1.py b/Tests/testelem/testfact1.py new file mode 100644 index 00000000..c3e69896 --- /dev/null +++ b/Tests/testelem/testfact1.py @@ -0,0 +1,90 @@ +# coding=utf-8 +from Accas import SIMP,FACT + +import unittest + +class TestFactCase(unittest.TestCase): + def setUp(self): + self.cata=FACT(a=SIMP(typ='I',statut='o'), + b=SIMP(typ='R'), + c=SIMP(typ='C',defaut=('RI',1,0)), + ) + + def tearDown(self): + del self.cata + + def testStatut1(self): + o=self.cata({'a':1},'mcs1',None) + cr=o.report() + self.assert_(cr.estvide()) + + def testStatut2(self): + o=self.cata(None,'mcs1',None) + cr=o.report() + expected_cr="""Mot cle Facteur :mcs1 + Mot-clé simple : a + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! Mot-clé : a obligatoire non valorisé ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! None n'est pas une valeur autorisée ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + Fin Mot-clé simple : a +Fin Mot cle Facteur :mcs1 +""" + self.assertEqual(str(cr) , expected_cr) + + def testType1(self): + """Verification de type""" + self.assertRaises(AttributeError,self.cata,1,'mcs1',None) + o=self.cata({'a':1.},'mcs1',None) + cr=o.report() + expected_cr="""Mot cle Facteur :mcs1 + Mot-clé simple : a + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! 1.0 n'est pas d'un type autorisé ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + Fin Mot-clé simple : a +Fin Mot cle Facteur :mcs1 +""" + self.assertEqual(str(cr) , expected_cr) + + def test031(self): + cata=FACT(min=2,max=3,a=SIMP(typ='I',statut='o'),) + + liste=( + (({'a':1},{'a':2}),1), + (({'a':1},{'a':2},{'a':3},{'a':4}),0), + (({'a':1},{'a':2},{'a':3}),1), + (({'a':1},),0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcf',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + + def test032(self): + cata=FACT(max=3,a=SIMP(typ='I',statut='o'),) + mcfact=cata({'a':1},'mcf',None) + self.assertEqual(mcfact[0].get_mocle('a') , 1) + self.assertEqual(mcfact['a'] , 1) + + mcfact=cata(({'a':1},{'a':2}),'mcf',None) + self.assertEqual(mcfact[0]['a'] , 1) + self.assertEqual(mcfact[1]['a'] , 2) + self.assertRaises(TypeError,mcfact.__getitem__, 'a') + def f(): + return mcfact['a'] + self.assertRaises(TypeError,f) + + def test033(self): + cata=FACT(xx=FACT(statut='o',max=3,a=SIMP(typ='I'),)) + mcfact=cata({},'mcf',None) + valid=0 + liste=( + ({},1), + ({'xx':{}},1), + ({'xx':{'a':1}},1), + ) + for valeur,valid in liste: + o=cata(valeur,'mcf',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) diff --git a/Tests/testelem/testfact2.py b/Tests/testelem/testfact2.py new file mode 100644 index 00000000..5dce9897 --- /dev/null +++ b/Tests/testelem/testfact2.py @@ -0,0 +1,158 @@ +from Accas import SIMP,FACT,BLOC + +import unittest + + +class TestFactCase(unittest.TestCase): + + def test001(self): + """ + Cas test avec un bloc conditionnel active par un mot cle simple avec + valeur par defaut, non present + Le bloc contient un mot cle simple avec defaut non present + On s'attend a recuperer les 2 mots cles simples avec leur valeur par + defaut. + """ + cata=FACT(ZORGLUB =SIMP(statut='f',typ='TXM',defaut='OOO'), + b_unit1 =BLOC(condition = "ZORGLUB=='OOO'", + TOTO =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + ), + ) + mcfact=cata({},'mcf',None) + valeur_attendue={'ZORGLUB':'OOO','TOTO':'AAA'} + dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste) + #dico=mcfact.cree_dict_valeurs(mcfact.mc_liste) + self.assertEqual(dico , valeur_attendue) + self.assertEqual(mcfact[0].get_mocle('TOTO') , 'AAA') + self.assertEqual(mcfact[0].get_mocle('ZORGLUB') , 'OOO') + self.assertEqual(mcfact['TOTO'] , 'AAA') + self.assertRaises(IndexError, mcfact.__getitem__, 'TITI') + + def test002(self): + cata=FACT(ZORGLUB =SIMP(statut='f',typ='TXM',defaut='OOO'), + b_unit1 =BLOC(condition = "ZORGLUB=='ZZZ'", + TOTO =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + ), + ) + mcfact=cata({},'mcf',None) + valeur_attendue={'ZORGLUB':'OOO'} + dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste) + #dico=mcfact.cree_dict_valeurs(mcfact.mc_liste) + self.assertEqual(dico , valeur_attendue) + self.assertEqual(mcfact[0].get_mocle('ZORGLUB') , 'OOO') + + def test003(self): + cata=FACT(ZORGLUB =SIMP(statut='f',typ='TXM',defaut='OOO'), + b_unit1 =BLOC(condition = "ZORGLUB=='ZZZ'", + TOTO =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + ), + ) + mcfact=cata({'ZORGLUB':'ZZZ'},'mcf',None) + valeur_attendue={'ZORGLUB':'ZZZ', 'TOTO':'AAA'} + dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste) + self.assertEqual(dico , valeur_attendue) + self.assertEqual(mcfact[0].get_mocle('ZORGLUB') , 'ZZZ') + self.assertEqual(mcfact['TOTO'] , 'AAA') + + def test004(self): + cata=FACT(ZORGLUB =SIMP(statut='f',typ='TXM',defaut='OOO'), + b_unit1 =BLOC(condition = "ZORGLUB=='OOO'", + TOTO =SIMP(statut='f',typ='TXM',into=('AAA','BBB'),), + ), + ) + mcfact=cata({},'mcf',None) + valeur_attendue={'ZORGLUB':'OOO','TOTO':None} + dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste) + self.assertEqual(dico , valeur_attendue) + self.assertEqual(mcfact[0].get_mocle('TOTO') , None) + self.assertEqual(mcfact[0].get_child('ZORGLUB').get_valeur() , 'OOO') + self.assertEqual(mcfact[0].get_child('b_unit1').get_child('TOTO').get_valeur() , None) + self.assertEqual(mcfact['TOTO'] , None) + + def test005(self): + cata=FACT( + TOTO=FACT(statut='d', + TITI=SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + b_unit1 =BLOC(condition = "TITI=='AAA'", + TOTO =SIMP(statut='f',typ='TXM',into=('AAA','BBB'),), + ), + ), + ) + mcfact=cata({},'mcf',None) + dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste) + self.assertNotEqual(dico["TOTO"] , None) + + def test010(self): + """ + """ + cata=FACT(ZORGLUB =SIMP(statut='f',typ='TXM',defaut='OOO'), + b_unit1 =BLOC(condition = "ZORGLUB=='OOO'", + TOTO =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + b_unit2 =BLOC(condition = "TOTO == 'BBB'", + UNITE =SIMP(statut='f',typ='I',defaut=25), + ), + ), + ) + mcfact=cata({'TOTO' : 'BBB'},'mcf',None) + valeur_attendue={'UNITE':25, 'ZORGLUB':'OOO','TOTO':'BBB'} + dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste) + self.assertEqual(dico , valeur_attendue) + + def test011(self): + """ + """ + cata=FACT( + TITI =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + TUTU =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + TATA =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + TOTO =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + b_unit1 =BLOC(condition = "TITI =='AAA'", + TOTO1 =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + c_unit1 =BLOC(condition = "TOTO1 == 'AAA'", UNITE1 =SIMP(statut='f',typ='I',defaut=25),), + ), + b_unit2 =BLOC(condition = "TUTU =='AAA'", + TOTO2 =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + c_unit2 =BLOC(condition = "TOTO2 == 'BBB'", UNITE2 =SIMP(statut='f',typ='I',defaut=25),), + ), + b_unit3 =BLOC(condition = "TATA =='BBB'", + TOTO3 =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + c_unit3 =BLOC(condition = "TOTO3 == 'BBB'", UNITE3 =SIMP(statut='f',typ='I',defaut=25),), + ), + b_unit4 =BLOC(condition = "TOTO =='BBB'", + TOTO4 =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + c_unit4 =BLOC(condition = "TOTO4 == 'AAA'", UNITE4 =SIMP(statut='f',typ='I',defaut=25),), + ), + ) + mcfact=cata({'TOTO' : 'BBB'},'mcf',None) + valeur_attendue={ + 'TITI': 'AAA', 'TOTO': 'BBB', 'TUTU': 'AAA', 'TATA': 'AAA', + 'TOTO1': 'AAA', 'UNITE1': 25, + 'TOTO2': 'AAA', + 'TOTO4': 'AAA', 'UNITE4': 25, + } + dico=mcfact[0].cree_dict_valeurs(mcfact[0].mc_liste) + self.assertEqual(dico , valeur_attendue) + + self.assertEqual(mcfact[0].get_child('TATA').get_valeur() , 'AAA') + self.assertEqual(mcfact[0].get_child('TITI').get_valeur() , 'AAA') + self.assertEqual(mcfact[0].get_child('TUTU').get_valeur() , 'AAA') + self.assertEqual(mcfact[0].get_child('TOTO').get_valeur() , 'BBB') + self.assertEqual(mcfact['TITI'] , 'AAA') + self.assertEqual(mcfact['TUTU'] , 'AAA') + self.assertEqual(mcfact['TATA'] , 'AAA') + self.assertEqual(mcfact['TOTO'] , 'BBB') + + self.assertEqual(mcfact['TOTO1'] , 'AAA') + self.assertEqual(mcfact['TOTO2'] , 'AAA') + self.assertEqual(mcfact['TOTO4'] , 'AAA') + self.assertRaises(IndexError, mcfact[0].get_mocle, 'TOTO3') + + self.assertEqual(mcfact['UNITE1'] , 25) + self.assertEqual(mcfact['UNITE4'] , 25) + self.assertRaises(IndexError, mcfact.__getitem__, 'UNITE2') + self.assertRaises(IndexError, mcfact.__getitem__, 'UNITE3') + self.assertRaises(IndexError, mcfact[0].get_mocle, 'UNITE2') + self.assertRaises(IndexError, mcfact[0].get_mocle, 'UNITE3') + + self.assertEqual(mcfact[0].get_child('b_unit4').get_child('TOTO4').get_valeur(),'AAA') + self.assertEqual(mcfact[0].get_child('b_unit4').get_valeur(),{'TOTO4': 'AAA', 'UNITE4': 25}) diff --git a/Tests/testelem/testjdc2.py b/Tests/testelem/testjdc2.py new file mode 100644 index 00000000..8cebe098 --- /dev/null +++ b/Tests/testelem/testjdc2.py @@ -0,0 +1,162 @@ +# -*- coding: iso-8859-1 -*- +import cata5 + +import unittest,re,os +import compare + +class TestJDCCase(unittest.TestCase): + + def test1(self): + text=""" +# OP2 : CO converti en concept2 ou concept2. Retourne concept +# OP6 : uniquement CO converti en concept2. Retourne concept +# OP3 : CO converti en concept ou concept. Retourne concept +co0=OP2(MATR=CO("x1")) +co2=OP6(MATR=CO("xx")) +co3=OP3(MATR={"CHAM":"R","MM":co2}) +""" + self.execute(cata5,text) + + def test2(self): + text=""" +# OP2 : CO converti en concept2 ou concept2. Retourne concept +# OP5 : uniquement CO converti en concept2. Retourne concept +co0=OP2(MATR=CO("x1")) +co1=OP5(MATR=co0) +""" + expected="""DEBUT CR validation : bidon + Etape : OP5 ligne : 5 fichier : 'bidon' + Mot-clé simple : MATR + !!!!!!... + ! ... n'est pas d'un type autorisé ! + !!!!!!... + Fin Mot-clé simple : MATR + Fin Etape : OP5 +FIN CR validation :bidon +""" + self.execute(cata5,text,err3=expected) + + def test3(self): + text=""" +# OP2 : CO converti en concept2 ou concept2. Retourne concept +co0=OP2(MATR=CO("x1")) +co1=OP2(MATR=x1) +co2=OP2(MATR=co0) +""" + expected="""DEBUT CR validation : bidon + Etape : OP2 ligne : 5 fichier : 'bidon' + Mot-clé simple : MATR + !!!!... + ! ... n'est pas d'un type autorisé ! + !!!!... + Fin Mot-clé simple : MATR + Fin Etape : OP2 +FIN CR validation :bidon +""" + self.execute(cata5,text,err3=expected) + + def test8(self): + text=""" +co2=OP14(MATR=CO("xx")) +""" + expected="" + self.execute(cata5,text,err4=expected) + + def test12(self): + text=""" +co2=OP18(MATR=CO("xx")) +co3=OP2(MATR=xx) +co4=OP11(MATR=xx) +""" + expected="" + self.execute(cata5,text,err4=expected) + + def test13(self): + text=""" +co2=OP10(MATR=CO("xx")) +""" + expected="""DEBUT CR validation : bidon + Etape : OP10 ligne : 2 fichier : 'bidon' + Mot-clé simple : MATR + !!!!... + ! ... n'est pas d'un type autorisé ! + !!!!... + Fin Mot-clé simple : MATR + Fin Etape : OP10 +FIN CR validation :bidon +""" + self.execute(cata5,text,err3=expected) + + def test16(self): + text=""" +co=OP22(MATR=CO("xx")) +""" + self.execute(cata5,text) + + def test17(self): + text=""" +co=OP22(MATR=CO("xx")) +co2=OP22(MATR=xx) +""" + expected="""DEBUT CR validation : bidon + Etape : OP22 ligne : 3 fichier : 'bidon' + Mot-clé simple : MATR + !!!!!!!!... + ! ... n'est pas d'un type autorisé ! + !!!!!!!... + Fin Mot-clé simple : MATR + Fin Etape : OP22 +FIN CR validation :bidon +""" + self.execute(cata5,text,err3=expected) + + def setUp(self): + pass + + def tearDown(self): + pass + + def execute(self,cata,text_jdc,err1="",err2="",err3="",err4=""): + j=cata.JdC(procedure=text_jdc,cata=cata,nom="bidon") + j.actif_status=1 + j.fico=None + j.set_par_lot("OUI") + # On compile le texte Python + j.compile() + # On initialise les tops de mesure globale de temps d'execution du jdc + j.cpu_user=os.times()[0] + j.cpu_syst=os.times()[1] + j.impr_macro='NON' + + #print j.cr + if err1 == "": + self.assert_(j.cr.estvide(),msg='Erreur non attendue dans compile (err1):\n%s' % str(j.cr)) + else: + self.assert_(self.check(err1,str(j.cr)),msg='Erreur non attendue dans compile (err1):\n%s\n!=\n%s' % (str(j.cr),err1)) + j.supprime() + return + + j.exec_compile() + #print j.cr + if err2 == "": + self.assert_(j.cr.estvide(),msg='Erreur non attendue dans exec_compile (err2):\n%s' % str(j.cr)) + else: + self.assert_(self.check(err2,str(j.cr)),msg='Erreur non attendue dans exec_compile(err2):\n%s\n!=\n%s' % (str(j.cr),err2)) + j.supprime() + return + + cr=j.report() + #print cr + if err3 == "": + self.assert_(cr.estvide(),msg='Erreur non attendue dans exec_compile (err3):\n%s' % str(cr)) + else: + self.assert_(self.check(err3,str(cr)),msg='Erreur non attendue dans exec_compile(err3):\n%s\n!=\n%s' % (str(cr),err3)) + j.supprime() + return + + j.set_par_lot("NON") + + j.supprime() + + def check(self,want,got): + return compare.check(want,got) diff --git a/Tests/testelem/testmacro1.py b/Tests/testelem/testmacro1.py new file mode 100644 index 00000000..dcb09761 --- /dev/null +++ b/Tests/testelem/testmacro1.py @@ -0,0 +1,67 @@ +import cata2 +from cata2 import OP1,OP2,OP3,OP4,OP5,OP6 + +from Accas import AsException,CO + +import unittest + +class TestMacroCase(unittest.TestCase): + def setUp(self): + pass + + def tearDown(self): + pass + + def test1(self): + co2=OP4() + cr=co2.etape.report() + self.assert_(cr.estvide(),msg='Erreur non attendue:\n%s' % str(cr)) + co2.etape.supprime() + + def test4(self): + co1=OP1(a=1) + co2=OP2(MATR=CO("xx")) + cr=co2.etape.report() + self.assert_(cr.estvide(),msg='Erreur non attendue:\n%s' % str(cr)) + co1.etape.supprime() + co2.etape.supprime() + + def test3(self): + co1=OP1(a=1) + co2=OP3(MATR={"CHAM":"R","MM":CO("xx")}) + cr=co2.etape.report() + self.assert_(cr.estvide(),msg='Erreur non attendue:\n%s' % str(cr)) + co1.etape.supprime() + co2.etape.supprime() + + def test2(self): + co1=OP1(a=1) + co2=OP3(MATR=({"CHAM":"R","MM":CO("xx")}, + {"CHAM":"R","MM":CO("xx")}, + ), + ) + cr=co2.etape.report() + self.assert_(cr.estvide(),msg='Erreur non attendue:\n%s' % str(cr)) + co1.etape.supprime() + co2.etape.supprime() + + def test5(self): + co2=OP5(MATR=CO("xx")) + co3=OP3(MATR={"CHAM":"R","MM":co2}) + #print co3.etape.report() + cr=co2.etape.report() + #print cr + self.assert_(cr.estvide(),msg='Erreur non attendue:\n%s' % str(cr)) + co2.etape.supprime() + co3.etape.supprime() + + def test6(self): + co2=OP6(MATR=CO("xx")) + co3=OP3(MATR={"CHAM":"R","MM":co2}) + #print co3.etape.report() + cr=co2.etape.report() + #print cr + self.assert_(cr.estvide(),msg='Erreur non attendue:\n%s' % str(cr)) + co2.etape.supprime() + co3.etape.supprime() + diff --git a/Tests/testelem/testoper1.py b/Tests/testelem/testoper1.py new file mode 100644 index 00000000..2d497556 --- /dev/null +++ b/Tests/testelem/testoper1.py @@ -0,0 +1,174 @@ +# coding=utf-8 +import cata1 +from cata1 import OP1,OP2,OP3,OP4,OP5,OP6 +from Accas import AsException,ASSD,OPER,SIMP,FACT,BLOC,_F + +class concept(ASSD):pass + +import unittest + +class TestOperCase(unittest.TestCase): + def setUp(self): + pass + + def tearDown(self): + pass + + def test01(self): + co1=OP1(a=1) + cr=co1.etape.report() + self.assert_(cr.estvide()) + co1.etape.supprime() + + def test02(self): + """ Test fonction sd_prod + """ + co1=OP2(TYPE_RESU="TRANS") + cr=co1.etape.report() + self.assert_(cr.estvide()) + co1.etape.supprime() + + def test04(self): + """ Test fonction sd_prod + Test du type d'un argument avec AsType + """ + co1=OP1(a=1) + co2=OP3(MATR=co1) + cr=co2.etape.report() + self.assert_(cr.estvide()) + co1.etape.supprime() + co2.etape.supprime() + + def test05(self): + """ Test fonction sd_prod + Test sur un mot-clé simple d'un mot-clé facteur : mcf[mcs] + """ + co1=OP4(MESURE={'NOM_PARA':'INST'}) + cr=co1.etape.report() + self.assert_(cr.estvide()) + co1.etape.supprime() + + def test06(self): + """ Test fonction sd_prod + Test sur un mot-clé simple d'un mot-clé facteur : mcf.get_child(mcs).get_valeur() + """ + co2=OP1(a=1) + co1=OP5(FFT={'FONCTION':co2}) + cr=co1.etape.report() + self.assert_(cr.estvide()) + co1.etape.supprime() + co2.etape.supprime() + + def test07(self): + """ Test fonction sd_prod + Test sur un mot-clé simple d'un mot-clé facteur : mcf[0][mcs] + """ + co2=OP1(a=1) + co1=OP6(FILTRE={'MODE':co2}) + cr=co1.etape.report() + self.assert_(cr.estvide()) + co1.etape.supprime() + co2.etape.supprime() + + def test08(self): + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(typ='I'), + c=SIMP(statut='o',typ='TXM',position='global', + into=("TABLEAU","AGRAF"), + ), + b=FACT(statut='o',max='**', + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ), + ) + + co1=OP10(a=1,c="TABLEAU",b=_F(d='rr')) + cr=co1.etape.report() + self.assertEqual(co1.etape['a'],1) + self.assertEqual(co1.etape['c'],'TABLEAU') + self.assertEqual(co1.etape['b']['d'],'rr') + self.assert_(cr.estvide()) + co1.etape.supprime() + + def test09(self): + co2=OP1(a=1) + co1=OP5(FFT={'FONCTION':co2}) + l= co1.etape.get_sd_utilisees() + self.assert_(len(l)==1) + self.assert_(co2 in l ) + d=co1.etape.get_sd_mcs_utilisees() + self.assert_(len(d.keys())==1) + self.assert_(len(d['FONCTION'])==1) + self.assert_(co2 in d['FONCTION']) + co1.etape.supprime() + co2.etape.supprime() + + def test10(self): + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(statut='o',typ='R',max=5), + ) + class mylist(list):pass + valeur=(0,1) + co1=OP10(a=mylist(valeur)) + #n,v=co1.etape.getvr8("","a",0,1,3) + v=tuple(co1.etape["a"]) + msg="erreur sur le test " +'\n'+str(co1.etape.report()) + self.assertEqual(v,valeur,msg=msg) + co1.etape.supprime() + + def futuretest11(self): + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(statut='o',typ='R',into=(0,1,2),max=5), + ) + class mylist(list):pass + valeur=(2,0,1) + co1=OP10(a=mylist(valeur)) + v=tuple(co1.etape["a"]) + #n,v=co1.etape.getvr8("","a",0,1,3) + msg="erreur sur le test " +'\n'+str(co1.etape.report()) + self.assertEqual(v,valeur,msg=msg) + co1.etape.supprime() + + def futuretest12(self): + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(statut='o',typ='R',into=(2,4,3,5),max=5), + ) + class mylist(list):pass + valeur=(2,0,1) + co1=OP10(a=mylist(valeur)) + msg="erreur sur le test " +'\n'+str(co1.etape.report()) + self.assertEqual(co1.etape.isvalid(),0,msg=msg) + co1.etape.supprime() + + def futuretest13(self): + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(statut='o',typ='R',val_min=0,val_max=3,max=5), + ) + class mylist(list):pass + valeur=(2,0,1) + co1=OP10(a=mylist(valeur)) + msg="erreur sur le test " +'\n'+str(co1.etape.report()) + self.assertEqual(co1.etape.isvalid(),1,msg=msg) + co1.etape.supprime() + + def futuretest14(self): + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(statut='o',typ='R',val_min=0,val_max=1,max=5), + ) + class mylist(list):pass + valeur=(2,0,1) + co1=OP10(a=mylist(valeur)) + msg="erreur sur le test " +'\n'+str(co1.etape.report()) + self.assertEqual(co1.etape.isvalid(),0,msg=msg) + co1.etape.supprime() + + def test15(self): + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(statut='o',typ='R',val_min=0,val_max=1,max=5), + ) + valeur=(2,0,1) + co1=OP10(a=valeur) + msg="erreur sur le test " +'\n'+str(co1.etape.report()) + self.assertEqual(co1.etape.isvalid(),0,msg=msg) + co1.etape.supprime() diff --git a/Tests/testelem/testposition1.py b/Tests/testelem/testposition1.py new file mode 100644 index 00000000..520b1e4e --- /dev/null +++ b/Tests/testelem/testposition1.py @@ -0,0 +1,254 @@ +# coding=utf-8 +import os +import cata3 +from Accas import AsException,ASSD,OPER,SIMP,FACT,BLOC,_F + +class concept(ASSD):pass + +import unittest + +class TestCase(unittest.TestCase): + def setUp(self): + self.j=cata3.JdC(procedure="",nom="bidon") + self.j.actif_status=1 + CONTEXT.set_current_step(self.j) + + def tearDown(self): + CONTEXT.unset_current_step() + self.j.supprime() + + def test001(self): + """ Test position = global + """ + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(typ='I'), + c=SIMP(statut='o',typ='TXM',position='global', + into=("TABLEAU","AGRAF"), + ), + b=FACT(statut='o',max='**', + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ), + ) + co1=OP10(a=1,c="TABLEAU",b=_F(d='rr')) + msg=co1.etape.report() + self.assertEqual(co1.etape.isvalid(),1,msg=msg) + + def test002(self): + """ Test position=global_jdc + """ + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(typ='I'), + c=SIMP(statut='o',typ='TXM',position='global_jdc', + into=("TABLEAU","AGRAF"), + ), + ) + OP11 = OPER(nom='OP11',op=10,sd_prod=concept, + b=FACT(statut='o',max='**', + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ), + ) + co1=OP10(a=1,c="TABLEAU",) + co2=OP11(b=_F(d='rr')) + msg=co1.etape.report() + self.assertEqual(co1.etape.isvalid(),1,msg=msg) + msg=co2.etape.report() + self.assertEqual(co2.etape.isvalid(),1,msg=msg) + + def test003(self): + """ Test position=global_jdc + """ + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(typ='I'), + b=FACT( c=SIMP(statut='o',typ='TXM',position='global_jdc', + into=("TABLEAU","AGRAF"), + ), + ), + ) + OP11 = OPER(nom='OP11',op=10,sd_prod=concept, + b=FACT(statut='o',max='**', + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ), + ) + OP12 = OPER(nom='OP12',op=10,sd_prod=concept, + b=FACT(statut='o',max='**', + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='o',typ='TXM'), + ), + ), + ) + co1=OP10(a=1,b=_F(c="TABLEAU")) + co2=OP11(b=_F(d='rr')) + co3=OP11() + co4=OP12(b=_F(d='rr')) + msg=co1.etape.report() + self.assertEqual(co1.etape.isvalid(),1,msg=msg) + msg=co2.etape.report() + self.assertEqual(co2.etape.isvalid(),1,msg=msg) + msg=co3.etape.report() + self.assertEqual(co3.etape.isvalid(),1,msg=msg) + msg=co4.etape.report() + self.assertEqual(co4.etape.isvalid(),1,msg=msg) + + def futuretest004(self): + """ Test position = global + """ + msg0= """ + PROBLEME : les mots cles globaux ne sont pas forcément vus + dans les mots cles facteurs (dépendant de l'ordre de création) + Dans ce test xx est avant b qui est avant g : g voit c mais pas xx. + """ + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(typ='I'), + b=FACT( c=SIMP(statut='o',typ='TXM',position='global', + into=("TABLEAU","AGRAF"), + ), + ), + g=FACT(statut='o',max='**', + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ), + xx=FACT(statut='o',max='**', + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ), + ) + co1=OP10(a=1,b=_F(c="TABLEAU"),g=_F(d='rr')) + msg=msg0+str(co1.etape.report()) + self.assertEqual(co1.etape.isvalid(),1,msg=msg) + co2=OP10(a=1,b=_F(c="TABLEAU"),xx=_F(d='rr')) + msg=msg0+str(co2.etape.report()) + self.assertEqual(co2.etape.isvalid(),1,msg=msg) + + def test005(self): + """ Test position = global + """ + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(typ='I'), + g=FACT( c=SIMP(statut='o',typ='TXM',position='global', + into=("TABLEAU","AGRAF"), + ), + ), + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ) + co1=OP10(a=1,g=_F(c="TABLEAU"),d='rr') + msg=co1.etape.report() + self.assertEqual(co1.etape.isvalid(),1,msg=msg) + + def test006(self): + """ Test position = global + ATTENTION : Un mot cle global, facultatif avec defaut (c) défini dans un mot clé facteur + n'est pas vu globalement + """ + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + a=SIMP(typ='I'), + g=FACT(a=SIMP(typ='I'), + c=SIMP(typ='TXM',position='global',into=("TABLEAU","AGRAF"),defaut="TABLEAU"), + ), + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ) + co1=OP10(a=1,g=_F(a=1),d='rr') + msg=co1.etape.report() + self.assertEqual(co1.etape.isvalid(),0,msg=msg) + + def test007(self): + """ Test position = global + """ + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + c=SIMP(typ='TXM',position='global',into=("TABLEAU","AGRAF"),defaut="TABLEAU"), + b=FACT(statut='o',max='**', + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ), + ) + co1=OP10(b=_F(d='rr')) + msg=co1.etape.report() + self.assertEqual(co1.etape.isvalid(),1,msg=msg) + + def test008(self): + """ Test position = global + """ + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + c=SIMP(typ='TXM',position='global',into=("TABLEAU","AGRAF"),defaut="TABLEAU"), + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ) + co1=OP10(d='rr') + msg=co1.etape.report() + self.assertEqual(co1.etape.isvalid(),1,msg=msg) + + def test009(self): + """ Test position = global + """ + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + c=SIMP(statut='o',typ='TXM',position='global',into=("TABLEAU","AGRAF"),defaut="TABLEAU"), + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ) + co1=OP10(d='rr') + msg=co1.etape.report() + self.assertEqual(co1.etape.isvalid(),1,msg=msg) + + def test010(self): + """ Test position = global + """ + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + g=FACT(a=SIMP(typ='I'), + c=SIMP(statut='o',typ='TXM',position='global',into=("TABLEAU","AGRAF"),defaut="TABLEAU"), + ), + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ) + co1=OP10(g=_F(a=1),d='rr') + msg=co1.etape.report() + self.assertEqual(co1.etape.isvalid(),1,msg=msg) + + def test011(self): + """ Test position = global + """ + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + g=FACT(statut='o', + c=SIMP(statut='o',typ='TXM',position='global',into=("TABLEAU","AGRAF"),defaut="TABLEAU"), + ), + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ) + co1=OP10(d='rr') + msg=co1.etape.report() + self.assertEqual(co1.etape.isvalid(),1,msg=msg) + + def test012(self): + """ Test position = global + ATTENTION : Un mot cle global, facultatif avec defaut (c) défini dans un mot clé facteur + n'est pas vu globalement + """ + OP10 = OPER(nom='OP10',op=10,sd_prod=concept, + g=FACT(statut='o', + c=SIMP(typ='TXM',position='global',into=("TABLEAU","AGRAF"),defaut="TABLEAU"), + ), + b_forme=BLOC(condition="c == 'TABLEAU'", + d=SIMP(statut='f',typ='TXM'), + ), + ) + co1=OP10(d='rr') + msg=co1.etape.report() + self.assertEqual(co1.etape.isvalid(),0,msg=msg) + co2=OP10(g=_F(c="TABLEAU"),d='rr') + msg=co2.etape.report() + self.assertEqual(co2.etape.isvalid(),1,msg=msg) diff --git a/Tests/testelem/testsimp0.py b/Tests/testelem/testsimp0.py new file mode 100644 index 00000000..68b3d43b --- /dev/null +++ b/Tests/testelem/testsimp0.py @@ -0,0 +1,47 @@ +from Noyau import SIMP + +import unittest + +class TestSimpCase(unittest.TestCase): + def testStatut1(self): + a=SIMP(typ='I',statut='o') + cr=a.report() + self.assert_(cr.estvide()) + + def testStatut2(self): + a=SIMP(typ='I') + cr=a.report() + self.assert_(cr.estvide()) + + def testStatut3(self): + a=SIMP(typ='I',statut='s') + cr=a.report() + expected_cr=""" + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! L'attribut 'statut' doit valoir 'o','f','c' ou 'd' : 's' ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +""" + self.assertEqual(str(cr) , expected_cr) + + def testPosition1(self): + a=SIMP(typ='I',position='total') + cr=a.report() + expected_cr=""" + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! L'attribut 'position' doit valoir 'local','global' ou 'global_jdc' : 'total' ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +""" + self.assertEqual(str(cr) , expected_cr) + + def testMinMax1(self): + a=SIMP(typ='I',min='**',max=12) + cr=a.report() + expected_cr=""" + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! Nombres d'occurrence min et max invalides : '**' 12 ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +""" + self.assertEqual(str(cr) , expected_cr) diff --git a/Tests/testelem/testsimp1.py b/Tests/testelem/testsimp1.py new file mode 100644 index 00000000..c6f90a76 --- /dev/null +++ b/Tests/testelem/testsimp1.py @@ -0,0 +1,243 @@ +# coding=utf-8 +from Accas import SIMP,ASSD +class maillage(ASSD):pass +class maillage_sdaster(ASSD):pass + +import unittest + +class TestMCSimpCase(unittest.TestCase): + def setUp(self): + self.cata=SIMP(typ='I',statut='o') + + def tearDown(self): + del self.cata + + def testStatut1(self): + o=self.cata(1,'mcs1',None) + cr=o.report() + self.assert_(cr.estvide()) + + def testStatut2(self): + o=self.cata(None,'mcs1',None) + cr=o.report() + expected_cr="""Mot-clé simple : mcs1 + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! Mot-clé : mcs1 obligatoire non valorisé ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! None n'est pas une valeur autorisée ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +Fin Mot-clé simple : mcs1 +""" + self.assertEqual(str(cr) , expected_cr) + + def testType1(self): + o=self.cata(1,'mcs1',None) + cr=o.report() + expected_cr="""Mot-clé simple : mcs1 +Fin Mot-clé simple : mcs1 +""" + self.assertEqual(str(cr) , expected_cr) + + def test004(self): + cata=SIMP(typ='shell',statut='o') + liste=((1,0),("a",1), (1.,0),(('RI',1.,0.),0), (('RI',1,0),0), + (1+0j,0), ("('RI',1,0)",1), ("toto",1), (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + # Chaines + def test040(self): + cata=SIMP(typ='TXM',statut='o') + liste=((1,0),("a",1), (1.,0),(('RI',1.,0.),0), + (('RI',1,0),0), (1+0j,0), + ("('RI',1,0)",1), ("toto",1), (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + def test041(self): + cata=SIMP(typ='TXM',statut='o',max=3) + liste=((1,0),("a",1), (1.,0),(('RI',1.,0.),0), + (('RI',1,0),0), (1+0j,0), + (("toot","titi"),1), + (("toot","titi","tutu"),1), + (("toot","titi",1),0), + (("toot","titi","tutu","tata"),0), + ("('RI',1,0)",1), ("toto",1), (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + def test042(self): + cata=SIMP(typ='TXM',statut='o',into=("toto","titi"),max=3) + liste=((1,0),("a",0), (1.,0),(('RI',1.,0.),0), + (('RI',1,0),0), (1+0j,0), + (("toto","titi"),1), + (("toot","titi","tutu"),0), + (("toot","titi",1),0), + (("toot","titi","tutu","tata"),0), + ("('RI',1,0)",0), ("toto",1), (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + def test043(self): + cata=SIMP(typ='TXM',statut='o',into=("toto","titi"),min=2,max=3) + liste=((1,0),("a",0), (1.,0),(('RI',1.,0.),0), + (('RI',1,0),0), (1+0j,0), + (("toto","titi"),1), + (("toot","titi","tutu"),0), + (("toot","titi",1),0), + (("toot","titi","tutu","tata"),0), + ("('RI',1,0)",0), ("toto",0), (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + # Reels + def test020(self): + cata=SIMP(typ='R',statut='o',max=4) + liste=((1,1),("a",0), (1.,1),(('RI',1.,0.),0), ((1.,2.,3.),1), + ((1.,2.,3.,4.),1), ((1.,2.,3.,4.,5.),0), ("toto",0), (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + def test021(self): + cata=SIMP(typ='R',statut='o',min=2,max=4) + liste=((1,0),("a",0), (1.,0),(('RI',1.,0.),0), + ((1.,2.),1), ((1.,2.,3.),1), ((1.,2.,3.,4.),1), + ((1.,2.,3.,4.,5.),0), ("toto",0), (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + + def test022(self): + cata=SIMP(typ='R',statut='o',val_min=2,val_max=4) + liste=((1,0),("a",0), (1.,0),(('RI',1.,0.),0), (3,1), + (6,0), ((1.,2.),0), ((1.,2.,3.),0), ((1.,2.,3.,4.),0), + ((1.,2.,3.,4.,5.),0), ("toto",0), (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + def test023(self): + cata=SIMP(typ='R',statut='o',val_min=2,val_max=4,max=4) + liste=((1,0),("a",0), (1.,0),(('RI',1.,0.),0), (3,1), + (6,0), ((1.,6.),0), ((3.,2.),1), ((1.,2.,3.),0), + ((1.,2.,3.,4.),0), ((1.,2.,3.,4.,5.),0), ("toto",0), + (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + def test024(self): + cata=SIMP(typ='R',statut='o') + liste=((1,1),("a",0), (1.,1),(('RI',1.,0.),0), (('RI',1,0),0), + (1+0j,0), ("('RI',1,0)",0), ((1.,2.,3.),0), ("toto",0), + (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + + # Entiers + def test030(self): + cata=SIMP(typ='I',statut='o') + liste=((1,1),("a",0), (1.,0),(('RI',1.,0.),0), + (('RI',1,0),0), (1+0j,0), ("1",0), ("toto",0), (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + def test031(self): + cata=SIMP(typ='I',statut='o',into=(1,5,8),max=4) + liste=((1,1),("a",0), ("toto",0), (None,0), + (1.,0),(('RI',1.,0.),0), + (3,0), (6,0), ((1,5),1), ((1,5,8),1), ((1,5,8,5),1), + ((1,5,8,5,1),0), ((1.,6.),0), ((3.,2.),0), ((1.,2.,3.),0), + ((1.,2.,3.,4.),0), ((1.,2.,3.,4.,5.),0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + # Complexes + def test010(self): + cata=SIMP(typ='C',statut='o',into=(('RI',1,0),('RI',2,0),('RI',3,0)),max=4) + liste=((1,0),("a",0), (1.,0),(('RI',1.,0.),1), ("toto",0), (None,0), + ((('RI',1.,0.),('RI',2,0)),1), + ((('RI',1.,0.),('RI',2,0),('RI',3,0)),1), + ((('RI',1.,0.),('RI',2,0),('RI',3,0),('RI',3,0)),1), + ((('RI',1.,0.),('RI',2,0),('RI',3,0),('RI',3,0),('RI',1,0)),0), + ((1,5),0), ((1,5,8,5,1),0), + ((1.,6.),0), ((3.,2.),0), ((1.,2.,3.),0), ((1.,2.,3.,4.,5.),0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + def test011(self): + cata=SIMP(typ='C',statut='o',max=3) + liste=((1,1),("a",0), (1.,1),(('RI',1.,0.),1), ("toto",0), (None,0), + ((('RI',1.,0.),('RI',2,0)),1), + ((('RI',1.,0.),('RI',2,0),('RI',3,0)),1), + ((('RI',1.,0.),('RI',2,0),('RI',3,0),('RI',3,0)),0), + ((('RI',1.,0.),('RI',2,0),('RI',3,0),('RI',3,0),('RI',1,0)),0), + ((1,5),1), ((1,5,8,5,1),0), + ((1.,6.),1), ((3.,2.),1), ((1.,2.,3.),1), ((1.,2.,3.,4.,5.),0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + def test012(self): + cata=SIMP(typ='C',statut='o') + liste=((1,1),("a",0), (1.,1),(('RI',1.,0.),1), (('RI',1,0),1), (1+0j,1), + ("('RI',1,0)",0), ("toto",0), (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid,"erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) + + def test013(self): + cata=SIMP(typ=('R',maillage),statut='o') + liste=((1,1), + (maillage(),1), + (maillage_sdaster(),0), + ("aa",0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + self.assertEqual(o.isvalid(),valid, + "erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report())) + if valid: self.assertEqual(o.get_valeur(),valeur) diff --git a/Tests/testelem/testsimp2.py b/Tests/testelem/testsimp2.py new file mode 100644 index 00000000..4c0aae20 --- /dev/null +++ b/Tests/testelem/testsimp2.py @@ -0,0 +1,42 @@ +# coding=utf-8 +from Accas import SIMP,ASSD + +import unittest + +class TestSimpCase(unittest.TestCase): + def setUp(self): + pass + + def tearDown(self): + pass + + def test001(self): + cata=SIMP(statut='o',typ='TXM',defaut="d") + liste=((1,0),("a",1), (1.,0),(('RI',1.,0.),0), (('RI',1,0),0), + (1+0j,0), ("('RI',1,0)",1), ("toto",1), (None,1), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + msg="erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()) + self.assertEqual(o.isvalid(),valid,msg=msg) + + def test002(self): + cata=SIMP(statut='f',typ='TXM',defaut="d") + liste=((1,0),("a",1), (1.,0),(('RI',1.,0.),0), (('RI',1,0),0), + (1+0j,0), ("('RI',1,0)",1), ("toto",1), (None,1), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + msg="erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()) + self.assertEqual(o.isvalid(),valid,msg=msg) + + def futuretest003(self): + cata=SIMP(statut='o',typ='R',max=3) + class mylist(list):pass + liste=((1,1),(mylist((0.,1.)),1), (1.,1),(mylist((0.,1.)),1), (('RI',1,0),0), + (1+0j,0), ("('RI',1,0)",0), ("toto",0), (None,0), + ) + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + msg="erreur sur le test %s %s" % (valeur,valid)+'\n'+str(o.report()) + self.assertEqual(o.isvalid(),valid,msg=msg) diff --git a/Tests/testelem/testvalidator1.py b/Tests/testelem/testvalidator1.py new file mode 100644 index 00000000..1a57431c --- /dev/null +++ b/Tests/testelem/testvalidator1.py @@ -0,0 +1,178 @@ +# coding=utf-8 +from Accas import * + +import unittest + +class TestValidCase(unittest.TestCase): + def setUp(self): + pass + + def tearDown(self): + pass + + def _test(self,cata,liste): + for valeur,valid in liste: + o=cata(valeur,'mcs',None) + msg=None + if valid != o.isvalid() : + if not valid: + msg="erreur : le mot cle devrait etre invalide. valeur = %s, valid = %s " % (valeur,valid) + else: + msg="erreur : le mot cle devrait etre valide. valeur = %s, valid = %s " % (valeur,valid) + '\n' + str(o.report()) + self.assertEqual(o.isvalid(),valid,msg) + if valid: + self.assertEqual(o.get_valeur(),valeur) + + def test001(self): + cata=SIMP(typ='TXM',validators=LongStr(3,5)) + liste=(("aa",0),("aaa",1), + ("aaaa",1),("aaaaa",1), + ("axyzaa",0),("bbbbaaa",0), + ) + self._test(cata,liste) + + def test002(self): + cata=SIMP(statut='o',typ='TXM',min=1,max=4,validators=LongStr(3,5)) + liste=( + ("aa",0),("aaa",1), + (("aaaa","aaaaa","axyzaa","bbbbaaa","zzz"),0), + (("aaaa","aaaaa","axyz","bbbb","zzz"),0), + (("aaaa","axyz","bbbb","zzz"),1), + ("aaaa",1),("aaaaa",1), + ("axyzaa",0),("bbbbaaa",0), + ) + self._test(cata,liste) + + def test003(self): + cata=SIMP(statut='o',typ='I',validators=TypeVal(1)) + liste=( + (1,1),(1.,0),(1.25,0), + (('RI',0.,1.),0), + ) + self._test(cata,liste) + + def test004(self): + cata=SIMP(statut='o',typ='I',into=(1,2,3,4,5,6),max='**',validators=OrdList("croissant")) + liste=( + (1,1),((1,3),1), + ((3,1),0), + ((1,3,2),0), + ((1.,2.),0), + ) + self._test(cata,liste) + + def test005(self): + cata=SIMP(statut='o',typ='I',validators=EnumVal((3,2,4,8,9,15))) + liste=( + (1,0),(9,1),(15,1), + (50,0),(1.25,0), + ) + self._test(cata,liste) + + def test006(self): + cata=SIMP(statut='o',typ='I',max='**',validators=OrdList("croissant")) + liste=( + (1,1),((1,3),1), + ((50,60,701),1), + ((100,50,60,701),0), + ((3,1),0), + ((1,3,2),0), + ((1.,2.),0), + ) + self._test(cata,liste) + + def test007(self): + cata=SIMP(statut='o',typ='I',min=1,max=4,validators=PairVal()) + liste=( + (2,1),((2,4),1), + (3,0),((3,4),0), + ((2,3),0),((3,5),0), + ((2,4,6,8),1), + ((2,4,6,8,10),0), + ) + self._test(cata,liste) + + def test008(self): + cata=SIMP(statut='o',typ='I',validators=RangeVal(3,15)) + liste=( + (2,0),(4,1), + (16,0),(14,1), + ) + self._test(cata,liste) + + def test009(self): + cata=SIMP(statut='o',typ='I',max='**',validators=CardVal(3,15)) + liste=( + (2,0),((2,4),0), + (3,0),((3,4),0), + ((2,3),0),((3,5),0), + ((2,4,6,8),1), + ((2,4,6,8,10),1), + ) + self._test(cata,liste) + + def test010(self): + cata=SIMP(statut='o',typ='TXM',min=1,max=6,validators=NoRepeat()) + liste=( + ("aa",1),("aaa",1), + (("aaaa","aaaaa","axyzaa","bbbbaaa","zzz"),1), + (("aaaa","aaaa","axyz","bbbb","zzz"),0), + (("aaaa","axyz","bbbb","zzz"),1), + ("aaaa",1),("aaaaa",1), + ("axyzaa",1),("bbbbaaa",1), + ) + self._test(cata,liste) + + def test011(self): + cata=SIMP(statut='o',typ='TXM',min=1,max=6,into =( "TUTU","TATA","CCCC"),validators=NoRepeat()) + liste=( + ("TUTU",1),("TATA",1), + (("TUTU","TATA","CCCC"),1), + (("TUTU","TATA","CCCC","TUTU","TATA","CCCC"),0), + (("TUTU","TATA","CCCC","TUTU","TATA","CCCC","TUTU","TATA","CCCC"),0), + ) + self._test(cata,liste) + + def test012(self): + cata=SIMP(statut='o',typ='I',min=1,max=1,into =( 1,2,3),validators=PairVal()) + liste=( + (2,1),(1,0),(3,0),(4,0), + ) + self._test(cata,liste) + + def test013(self): + cata=SIMP(statut='o',typ='I',min=1,max=1,validators=PairVal()) + liste=( + (2,1),(1,0),(3,0),(4,1), + ) + self._test(cata,liste) + + def test014(self): + cata=SIMP(statut='o',typ='I',min=1,max=6,validators=PairVal()) + liste=( + (2,1),(1,0),(3,0),(4,1), + ((2,4,6,8),1),((2,4,6,8,10,12,14),0), + ((2,4,6,8,7),0),((2,4,6,8,10,12,14,23),0), + ) + self._test(cata,liste) + + def test015(self): + """Test du validateur OU : pas de doublon OU valeur paire """ + cata=SIMP(statut='o',typ='I',min=1,max=6,validators=(NoRepeat(),PairVal())) + liste=( + (2,1),(1,1),(3,1),(4,1), + ((2,4,6,8),1),((2,4,6,8,10,12,14),0), + ((1,2,3,4),1), + ((2,4,6,8,7),1),((2,4,6,8,10,12,14,23),0), + ) + self._test(cata,liste) + + def test016(self): + """Test du validateur ET : pas de doublon ET valeur paire """ + cata=SIMP(statut='o',typ='I',min=1,max=6,validators=[NoRepeat(),PairVal()]) + liste=( ((2,),1),(None,0),((1,3,5),0), + ((2,4,6),1), + ((1,3,5),0), + ((2,4,4),0), + ) + self._test(cata,liste) diff --git a/Tests/testelem/testvalidator2.py b/Tests/testelem/testvalidator2.py new file mode 100644 index 00000000..31b3b1bf --- /dev/null +++ b/Tests/testelem/testvalidator2.py @@ -0,0 +1,126 @@ +# coding=utf-8 +from Accas import * + +import unittest +import compare +OK="""Mot-clé simple : mcs +Fin Mot-clé simple : mcs +""" + +class TestValidCase(unittest.TestCase): + def setUp(self): + pass + + def tearDown(self): + pass + + def _test(self,cata,liste): + for valeur,report in liste: + o=cata(valeur,'mcs',None) + msg="" + rep=str(o.report()) + valid=compare.check(rep,report) + if not valid: + msg="le rapport d'erreur est incorrect.\n valeur = %s\n expected =\n%s\n got =\n%s " % (valeur,report,rep) + print msg + self.assert_(valid,msg=msg) + + def test001(self): + """ Validateur LongStr(3,5) """ + cata=SIMP(typ='TXM',validators=LongStr(3,5)) + liste=(("aa", +"""Mot-clé simple : mcs + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! Mot-clé : mcs devrait avoir longueur de la chaine entre 3 et 5 ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +Fin Mot-clé simple : mcs +"""),("aaa",OK), + ("aaaa",OK),("aaaaa",OK), + ("axyzaa", +"""Mot-clé simple : mcs + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! Mot-clé : mcs devrait avoir longueur de la chaine entre 3 et 5 ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +Fin Mot-clé simple : mcs +"""),("bbbbaaa", +"""Mot-clé simple : mcs + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! Mot-clé : mcs devrait avoir longueur de la chaine entre 3 et 5 ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +Fin Mot-clé simple : mcs +"""), + ) + self._test(cata,liste) + + def test010(self): + cata=SIMP(statut='o',typ='TXM',min=1,max=6,validators=NoRepeat()) + liste=( + ("aa",OK),("aaa",OK), + (("aaaa","aaaaa","axyzaa","bbbbaaa","zzz"),OK), + (("aaaa","aaaa","axyz","bbbb","zzz"), +"""Mot-clé simple : mcs + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! Mot-clé : mcs devrait avoir : pas de présence de doublon dans la liste ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +Fin Mot-clé simple : mcs +"""), + (("aaaa","axyz","bbbb","zzz"),OK), + ("aaaa",OK),("aaaaa",OK), + ("axyzaa",OK),("bbbbaaa",OK), + ) + self._test(cata,liste) + + def test011(self): + cata=SIMP(statut='o',typ='TXM',min=1,max=6,into =( "TUTU","TATA","CCCC"),validators=NoRepeat()) + liste=( + ("TUTU",OK),("TATA",OK), + (("TUTU","TATA","CCCC"),OK), + (("TUTU","TATA","CCCC","TUTU","TATA","CCCC"), +"""Mot-clé simple : mcs + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! Mot-clé : mcs devrait avoir : pas de présence de doublon dans la liste ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +Fin Mot-clé simple : mcs +"""), + (("TUTU","TATA","CCCC","TUTU","TATA","CCCC","TUTU","TATA","CCCC"), +"""Mot-clé simple : mcs + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! Nombre d'arguments de ('TUTU', 'TATA', 'CCCC', 'TUTU', 'TATA', 'CCCC', 'TUTU', ! + ! 'TATA', 'CCCC') incorrect pour mcs (min = 1, max = 6) ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +Fin Mot-clé simple : mcs +"""), + ) + self._test(cata,liste) + + def test016(self): + """Test du validateur ET : pas de doublon ET valeur paire """ + cata=SIMP(statut='o',typ='I',min=1,max=6,validators=[NoRepeat(),PairVal()]) + liste=( ((2,),OK),(None, +"""Mot-clé simple : mcs + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! Mot-clé : mcs obligatoire non valorisé ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! None n'est pas une valeur autorisée ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +Fin Mot-clé simple : mcs +"""),((1,3,5), +"""Mot-clé simple : mcs + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! Mot-clé : mcs devrait avoir : pas de présence de doublon dans la liste ! + ! et valeur paire ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +Fin Mot-clé simple : mcs +"""), + ((2,4,6),OK), + ((2,4,4), +"""Mot-clé simple : mcs + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + ! Mot-clé : mcs devrait avoir : pas de présence de doublon dans la liste ! + ! et valeur paire ! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +Fin Mot-clé simple : mcs +"""), + ) + self._test(cata,liste)