Mercurial > hg > orthanc-stone

comparison Resources/CodeGeneration/stonegentool_test.py @ 628:84af39146e76 am-dev

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
CodeGeneration: support default values
author Alain Mazy <alain@mazy.be>
date Wed, 08 May 2019 16:32:57 +0200
parents b7fd0471281c
children 0d42bda615a8
comparison
equal deleted inserted replaced
627:b7fd0471281c 628:84af39146e76
4 # 4 #
5 5
6 from stonegentool import \ 6 from stonegentool import \
7 EatToken,SplitListOfTypes,ParseTemplateType,ProcessSchema, \ 7 EatToken,SplitListOfTypes,ParseTemplateType,ProcessSchema, \
8 CheckSchemaSchema,LoadSchema,trim,ComputeRequiredDeclarationOrder, \ 8 CheckSchemaSchema,LoadSchema,trim,ComputeRequiredDeclarationOrder, \
9 GetTemplatingDictFromSchemaFilename,MakeTemplate,MakeTemplateFromFile 9 GetTemplatingDictFromSchemaFilename,MakeTemplate,MakeTemplateFromFile,LoadSchemaFromString,GetTemplatingDictFromSchema
10 import unittest 10 import unittest
11 import os 11 import os
12 import re 12 import re
13 import pprint 13 import pprint
14 from jinja2 import Template 14 from jinja2 import Template
125 125
126 self.assertTrue('C' in structs) 126 self.assertTrue('C' in structs)
127 self.assertTrue('someBs' in structs['C']['fields']) 127 self.assertTrue('someBs' in structs['C']['fields'])
128 self.assertTrue('CrispType' in enums) 128 self.assertTrue('CrispType' in enums)
129 self.assertTrue('Message1' in structs) 129 self.assertTrue('Message1' in structs)
130 message1Struct = structs['Message1'] 130 self.assertEqual('int32', structs['Message1']['fields']['a'].type)
131 self.assertDictEqual(message1Struct, 131 self.assertEqual('string', structs['Message1']['fields']['b'].type)
132 { 132 self.assertEqual('EnumMonth0', structs['Message1']['fields']['c'].type)
133 'name':'Message1', 133 self.assertEqual('bool', structs['Message1']['fields']['d'].type)
134 '__meta__': {'handleInCpp': False, 'handleInTypescript': False},
135 'fields': {
136 'a': 'int32',
137 'b': 'string',
138 'c': 'EnumMonth0',
139 'd': 'bool'
140 }
141 })
142 134
143 def test_GenerateTypeScriptEnums(self): 135 def test_GenerateTypeScriptEnums(self):
144 fn = os.path.join(os.path.dirname(__file__), 'test_data', 'test1.yaml') 136 fn = os.path.join(os.path.dirname(__file__), 'test_data', 'test1.yaml')
145 tdico = GetTemplatingDictFromSchemaFilename(fn) 137 tdico = GetTemplatingDictFromSchemaFilename(fn)
146 template = Template(""" // end of generic methods 138 template = Template(""" // end of generic methods
266 # container['value'] = this; 258 # container['value'] = this;
267 # return JSON.stringify(container); 259 # return JSON.stringify(container);
268 # } };""") 260 # } };""")
269 template = MakeTemplate(""" // end of generic methods 261 template = MakeTemplate(""" // end of generic methods
270 {% for struct in structs%} export class {{struct['name']}} { 262 {% for struct in structs%} export class {{struct['name']}} {
271 {% for key in struct['fields']%} {{key}}:{{CanonToTs(struct['fields'][key])}}; 263 {% for key in struct['fields']%} {{key}}:{{CanonToTs(struct['fields'][key]['type'])}};
272 {% endfor %} 264 {% endfor %}
273 constructor() { 265 constructor() {
274 {% for key in struct['fields']%} this.{{key}} = new {{CanonToTs(struct['fields'][key])}}(); 266 {% for key in struct['fields']%} this.{{key}} = new {{CanonToTs(struct['fields'][key]['type'])}}();
275 {% endfor %} } 267 {% endfor %} }
276 268
277 public StoneSerialize(): string { 269 public StoneSerialize(): string {
278 let container: object = {}; 270 let container: object = {};
279 container['type'] = '{{rootName}}.{{struct['name']}}'; 271 container['type'] = '{{rootName}}.{{struct['name']}}';
409 pass 401 pass
410 402
411 def test_GenerateCppDispatcher(self): 403 def test_GenerateCppDispatcher(self):
412 pass 404 pass
413 405
406 def test_StringDefaultValueInTs(self):
407 schema = LoadSchemaFromString("""
408 rootName: MyTest
409 struct Toto:
410 withoutDefault: string
411 withDefault: string = \"tutu\"
412 """)
413 tdico = GetTemplatingDictFromSchema(schema)
414
415 tsTemplateFile = os.path.join(os.path.dirname(__file__), 'template.in.ts.j2')
416 template = MakeTemplateFromFile(tsTemplateFile)
417 renderedCode = template.render(**tdico)
418 self.assertIn("withDefault = \"tutu\"", renderedCode)
419 # print(renderedCode)
420
421 cppTemplateFile = os.path.join(os.path.dirname(__file__), 'template.in.h.j2')
422 template = MakeTemplateFromFile(cppTemplateFile)
423 renderedCode = template.render(**tdico)
424 print(renderedCode)
425 self.assertIn("withDefault = \"tutu\"", renderedCode)
426
427
428 def test_EnumDefaultValue(self):
429 schema = LoadSchemaFromString("""
430 rootName: MyTest
431 enum MyEnum:
432 - Toto
433 - Tutu
434 struct Toto:
435 withoutDefault: MyEnum
436 withDefault: MyEnum = Toto
437 """)
438 tdico = GetTemplatingDictFromSchema(schema)
439
440 tsTemplateFile = os.path.join(os.path.dirname(__file__), 'template.in.ts.j2')
441 template = MakeTemplateFromFile(tsTemplateFile)
442 renderedCode = template.render(**tdico)
443 # print(renderedCode)
444 self.assertIn("withDefault = MyEnum.Toto", renderedCode)
445
446 tsTemplateFile = os.path.join(os.path.dirname(__file__), 'template.in.h.j2')
447 template = MakeTemplateFromFile(tsTemplateFile)
448 renderedCode = template.render(**tdico)
449 self.assertIn("withDefault = MyTest::MyEnum_Toto", renderedCode)
450 # print(renderedCode)
451
452
414 # def test(self): 453 # def test(self):
415 # s = 'hello world' 454 # s = 'hello world'
416 # self.assertEqual(s.split(), ['hello', 'world']) 455 # self.assertEqual(s.split(), ['hello', 'world'])
417 # # check that s.split fails when the separator is not a string 456 # # check that s.split fails when the separator is not a string
418 # with self.assertRaises(TypeError): 457 # with self.assertRaises(TypeError):