Gaudi Framework, version v23r5
Home   Generated: Wed Nov 28 2012
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Classes | Functions
test_cmt2cmake Namespace Reference

Classes

class  PackWrap
 
class  ProjWrap
 

Functions

def buildDir
 
def getCalls
 
def test_not_a_package
 
def test_pack_header
 
def test_pack_deps
 
def test_pack_no_deps
 
def test_pack_ext_deps
 
def test_install_headers
 
def test_install_python
 
def test_install_python2
 
def test_install_scripts
 
def test_qmtest
 
def test_libraries
 
def test_libraries_2
 
def test_libraries_3
 
def test_libraries_fix_src_path
 
def test_subdir_links
 
def test_subdir_links_hat
 
def test_subdir_links_missing
 
def test_subdir_links_update
 
def test_subdir_headers
 
def test_subdir_headers_update
 
def test_write_file
 
def test_write_file_exists
 
def test_god_1
 
def test_god_2
 
def test_god_3
 
def test_god_4
 
def test_god_5
 
def test_god_6
 
def test_god_7
 
def test_reflex
 
def test_reflex_2
 
def test_reflex_3
 
def test_linkopts
 
def test_application
 
def test_pyqt_patterns
 
def test_line_cont
 
def test_line_copy_relax
 
def test_project
 
def test_data_pkg_1
 
def test_data_pkg_2
 
def test_data_pkg_3
 
def test_heptools_1
 
def test_heptools_2
 
def test_heptools_3
 
def test_heptools_4
 

Function Documentation

def test_cmt2cmake.buildDir (   files,
  rootdir = os.curdir 
) 
Create a directory structure from the content of files.

@param files: a dictionary or list of pairs mapping a filename to the content
              if the content is a dictionary, recurse
@param rootdir: base directory

Definition at line 35 of file test_cmt2cmake.py.

35 
36 def buildDir(files, rootdir=os.curdir):
37  '''
38  Create a directory structure from the content of files.
39 
40  @param files: a dictionary or list of pairs mapping a filename to the content
41  if the content is a dictionary, recurse
42  @param rootdir: base directory
43  '''
44  if type(files) is dict:
45  files = files.items()
46 
47  # ensure that the root exists (to allow empty directories)
48  if not os.path.exists(rootdir):
49  os.makedirs(rootdir)
50 
51  # create all the entries
52  for filename, data in files:
53  filename = os.path.join(rootdir, filename)
54  if type(data) is dict:
55  buildDir(data, filename)
56  else:
57  d = os.path.dirname(filename)
58  if not os.path.exists(d):
59  os.makedirs(d)
60  f = open(filename, "w")
61  if data:
62  f.write(data)
63  f.close()
def test_cmt2cmake.getCalls (   function,
  cmakelists 
) 
extracts the arguments to all the calls to a cmake function

Definition at line 101 of file test_cmt2cmake.py.

101 
102 def getCalls(function, cmakelists):
103  '''
104  extracts the arguments to all the calls to a cmake function
105  '''
106  exp = re.compile(r'\b{0}\s*\(([^)]*)\)'.format(function), flags=re.MULTILINE)
107  return [m.group(1) for m in exp.finditer(cmakelists)]
108 
109 #
110 # Tests
111 #
def test_cmt2cmake.test_application ( )

Definition at line 1068 of file test_cmt2cmake.py.

1068 
1069 def test_application():
1070  requirements = '''
1071 package Test
1072 version v1r0
1073 
1074 application MyApp1 ../src/app1/*.cpp
1075 
1076 application MyApp2 -group=tests ../src/app2/*.cpp
1077 
1078 application MyApp3 -check ../src/app3/*.cpp
1079 
1080 application MyApp4 ../tests/src/app4.cpp
1081 
1082 application MyTestApp app5a.cpp app5b.cpp
1083  '''
1084  pkg = PackWrap("Test", requirements, files={})
1085 
1086  cmakelists = pkg.generate()
1087  print cmakelists
1088 
1089  calls = getCalls("gaudi_add_executable", cmakelists)
1090  assert len(calls) == 5, "gaudi_add_executable wrong count %d" % len(calls)
1091 
1092  l = calls[0].strip().split()
1093  assert l[0] == 'MyApp1'
1094  assert l[1:] == ['src/app1/*.cpp']
1095 
1096  l = calls[1].strip().split()
1097  assert l[0] == 'MyApp2'
1098  assert l[1:] == ['src/app2/*.cpp']
1099 
1100  l = calls[2].strip().split()
1101  assert l[0] == 'MyApp3'
1102  assert l[1:] == ['src/app3/*.cpp']
1103 
1104  l = calls[3].strip().split()
1105  assert l[0] == 'MyApp4'
1106  assert l[1:] == ['tests/src/app4.cpp']
1107 
1108  l = calls[4].strip().split()
1109  assert l[0] == 'MyTestApp'
1110  assert l[1:] == ['src/app5a.cpp', 'src/app5b.cpp']
1111 
1112  calls = getCalls("if", cmakelists)
1113  assert calls == ['GAUDI_BUILD_TESTS'] * 4
def test_cmt2cmake.test_data_pkg_1 ( )

Definition at line 1225 of file test_cmt2cmake.py.

1225 
1226 def test_data_pkg_1():
1227  proj_cmt = '''
1228 project TestProject
1229  '''
1230  files = {"TestProjectSys": {"cmt": {"requirements": "version v1r0"}},
1231  "Package1": {"cmt": {"requirements":
1232 '''
1233 version v1r0
1234 
1235 use DtPkg v7r* Another
1236 use DataPack v*
1237 use SpecialThing *
1238 '''}},
1239  }
1240  proj = ProjWrap("TestProject", proj_cmt, files=files)
1241 
1242  cmakelists = proj.generate()
1243  print cmakelists
1244 
1245  calls = getCalls("find_package", cmakelists)
1246  assert len(calls) == 1, "find_package wrong count %d" % len(calls)
1247 
1248  l = calls[0].strip().split()
1249  assert l == ['GaudiProject']
1250 
1251  calls = getCalls("gaudi_project", cmakelists)
1252  assert len(calls) == 1, "gaudi_project wrong count %d" % len(calls)
1253 
1254  l = calls[0].strip().split()
1255  assert l == ['TestProject', 'v1r0', 'DATA',
1256  'Another/DtPkg', 'VERSION', 'v7r*',
1257  'DataPack',
1258  'SpecialThing']
def test_cmt2cmake.test_data_pkg_2 ( )

Definition at line 1259 of file test_cmt2cmake.py.

1259 
1260 def test_data_pkg_2():
1261  proj_cmt = '''
1262 project TestProject
1263  '''
1264  files = {"TestProjectSys": {"cmt": {"requirements": "version v1r0"}},
1265  "Package1": {"cmt": {"requirements":
1266 '''
1267 version v1r0
1268 
1269 use DataPack v*
1270 '''}},
1271  "Package2": {"cmt": {"requirements":
1272 '''
1273 version v1r0
1274 
1275 use SpecialThing *
1276 '''}},
1277  }
1278  proj = ProjWrap("TestProject", proj_cmt, files=files)
1279 
1280  cmakelists = proj.generate()
1281  print cmakelists
1282 
1283  calls = getCalls("find_package", cmakelists)
1284  assert len(calls) == 1, "find_package wrong count %d" % len(calls)
1285 
1286  l = calls[0].strip().split()
1287  assert l == ['GaudiProject']
1288 
1289  calls = getCalls("gaudi_project", cmakelists)
1290  assert len(calls) == 1, "gaudi_project wrong count %d" % len(calls)
1291 
1292  l = calls[0].strip().split()
1293  assert l == ['TestProject', 'v1r0', 'DATA',
1294  'DataPack',
1295  'SpecialThing']
def test_cmt2cmake.test_data_pkg_3 ( )

Definition at line 1296 of file test_cmt2cmake.py.

1296 
1297 def test_data_pkg_3():
1298  proj_cmt = '''
1299 project TestProject
1300  '''
1301  files = {"TestProjectSys": {"cmt": {"requirements": "version v1r0"}},
1302  "Package1": {"cmt": {"requirements":
1303 '''
1304 version v1r0
1305 
1306 use DataPack v7r*
1307 '''}},
1308  "Package2": {"cmt": {"requirements":
1309 '''
1310 version v1r0
1311 
1312 use DataPack v*
1313 use DtPkg v1r0 Another
1314 '''}},
1315  }
1316  proj = ProjWrap("TestProject", proj_cmt, files=files)
1317 
1318  cmakelists = proj.generate()
1319  print cmakelists
1320 
1321  calls = getCalls("find_package", cmakelists)
1322  assert len(calls) == 1, "find_package wrong count %d" % len(calls)
1323 
1324  l = calls[0].strip().split()
1325  assert l == ['GaudiProject']
1326 
1327  calls = getCalls("gaudi_project", cmakelists)
1328  assert len(calls) == 1, "gaudi_project wrong count %d" % len(calls)
1329 
1330  l = calls[0].strip().split()
1331  assert l == ['TestProject', 'v1r0', 'DATA',
1332  'Another/DtPkg', 'VERSION', 'v1r0',
1333  'DataPack', 'VERSION', 'v7r*']
def test_cmt2cmake.test_god_1 ( )

Definition at line 722 of file test_cmt2cmake.py.

722 
723 def test_god_1():
724  # some corner cases
725  # FIXME: we should actually test the warning messages
726  requirements = '''
727 package Test
728 version v1r0
729 
730 apply_pattern god_headers files=../xml/*.xml
731  '''
732  pkg = PackWrap("Test", requirements, files={})
733 
734  cmakelists = pkg.generate()
735  print cmakelists
736 
737  calls = getCalls("include", cmakelists)
738  assert calls
739  l = calls[0].strip()
740  assert l == 'GaudiObjDesc'
741 
742  calls = getCalls("god_build_headers", cmakelists)
743  assert len(calls) == 1, "god_build_headers wrong count %d" % len(calls)
744 
745  l = calls[0].strip()
746  assert l == 'xml/*.xml'
def test_cmt2cmake.test_god_2 ( )

Definition at line 747 of file test_cmt2cmake.py.

747 
748 def test_god_2():
749  requirements = '''
750 package Test
751 version v1r0
752 
753 apply_pattern god_dictionary files=../xml/*.xml
754  '''
755  pkg = PackWrap("Test", requirements, files={})
756 
757  cmakelists = pkg.generate()
758  print cmakelists
759 
760  calls = getCalls("include", cmakelists)
761  assert calls
762  l = calls[0].strip()
763  assert l == 'GaudiObjDesc'
764 
765  calls = getCalls("god_build_dictionary", cmakelists)
766  assert len(calls) == 1, "god_build_dictionary wrong count %d" % len(calls)
767 
768  l = calls[0].strip()
769  assert l == 'xml/*.xml'
def test_cmt2cmake.test_god_3 ( )

Definition at line 770 of file test_cmt2cmake.py.

770 
771 def test_god_3():
772  requirements = '''
773 package Test
774 version v1r0
775 
776 use Boost v* LCG_Interfaces
777 
778 apply_pattern god_headers files=../xml/*.xml
779 apply_pattern god_dictionary files=../xml/*.xml
780  '''
781  pkg = PackWrap("Test", requirements, files={})
782 
783  cmakelists = pkg.generate()
784  print cmakelists
785 
786  calls = getCalls("include", cmakelists)
787  assert calls
788  l = calls[0].strip()
789  assert l == 'GaudiObjDesc'
790 
791  calls = getCalls("god_build_headers", cmakelists)
792  assert len(calls) == 1, "god_build_headers wrong count %d" % len(calls)
793 
794  calls = getCalls("god_build_dictionary", cmakelists)
795  assert len(calls) == 1, "god_build_dictionary wrong count %d" % len(calls)
796 
797  l = calls[0].strip().split()
798  assert l[0] == 'xml/*.xml'
799  assert 'LINK_LIBRARIES' in l
800  assert l[l.index('LINK_LIBRARIES')+1] == 'Boost'
801  assert 'INCLUDE_DIRS' in l
802  assert l[l.index('INCLUDE_DIRS')+1] == 'Boost'
def test_cmt2cmake.test_god_4 ( )

Definition at line 803 of file test_cmt2cmake.py.

803 
804 def test_god_4():
805  requirements = '''
806 package Test
807 version v1r0
808 
809 use Boost v* LCG_Interfaces
810 
811 library Lib *.cpp
812 apply_pattern linker_library library=Lib
813 
814 apply_pattern god_headers files=../xml/*.xml
815 apply_pattern god_dictionary files=../xml/*.xml
816  '''
817  pkg = PackWrap("Test", requirements, files={})
818 
819  cmakelists = pkg.generate()
820  print cmakelists
821 
822  calls = getCalls("include", cmakelists)
823  assert calls
824  l = calls[0].strip()
825  assert l == 'GaudiObjDesc'
826 
827  calls = getCalls("god_build_headers", cmakelists)
828  assert len(calls) == 1, "god_build_headers wrong count %d" % len(calls)
829 
830  calls = getCalls("gaudi_add_library", cmakelists)
831  assert len(calls) == 1, "gaudi_add_library wrong count %d" % len(calls)
832 
833  calls = getCalls("god_build_dictionary", cmakelists)
834  assert len(calls) == 1, "god_build_dictionary wrong count %d" % len(calls)
835 
836  l = calls[0].strip().split()
837  assert l[0] == 'xml/*.xml'
838  assert 'LINK_LIBRARIES' in l
839  i = l.index('LINK_LIBRARIES')+1
840  assert l[i:i+2] == ['Boost', 'Lib']
841  assert 'INCLUDE_DIRS' in l
842  assert l[l.index('INCLUDE_DIRS')+1] == 'Boost'
843 
844  hdr = cmakelists.find('god_build_headers')
845  lib = cmakelists.find('gaudi_add_library')
846  dct = cmakelists.find('god_build_dictionary')
847  assert hdr < lib and lib < dct, "wrong order of calls"
def test_cmt2cmake.test_god_5 ( )

Definition at line 848 of file test_cmt2cmake.py.

848 
849 def test_god_5():
850  requirements = '''
851 package Test
852 version v1r0
853 
854 apply_pattern god_headers files=../xml/*.xml
855 macro TestObj2Doth_GODflags " -s ../Test/ "
856  '''
857  pkg = PackWrap("Test", requirements, files={})
858 
859  cmakelists = pkg.generate()
860  print cmakelists
861 
862  calls = getCalls("include", cmakelists)
863  assert calls
864  l = calls[0].strip()
865  assert l == 'GaudiObjDesc'
866 
867  calls = getCalls("god_build_headers", cmakelists)
868  assert len(calls) == 1, "god_build_headers wrong count %d" % len(calls)
869 
870  l = calls[0].strip().split()
871  assert l[0] == 'xml/*.xml'
872  assert 'DESTINATION' in l
873  assert l[l.index('DESTINATION')+1] == 'Test'
def test_cmt2cmake.test_god_6 ( )

Definition at line 874 of file test_cmt2cmake.py.

874 
875 def test_god_6():
876  requirements = '''
877 package Test
878 version v1r0
879 
880 apply_pattern god_headers files=../xml/*.xml
881 macro TestObj2Doth_GODflags " -s ../src/ "
882  '''
883  pkg = PackWrap("Test", requirements, files={})
884 
885  cmakelists = pkg.generate()
886  print cmakelists
887 
888  calls = getCalls("include", cmakelists)
889  assert calls
890  l = calls[0].strip()
891  assert l == 'GaudiObjDesc'
892 
893  calls = getCalls("god_build_headers", cmakelists)
894  assert len(calls) == 1, "god_build_headers wrong count %d" % len(calls)
895 
896  l = calls[0].strip().split()
897  assert l[0] == 'xml/*.xml'
898  assert 'PRIVATE' in l
899  assert 'DESTINTAION' not in l
def test_cmt2cmake.test_god_7 ( )

Definition at line 900 of file test_cmt2cmake.py.

900 
901 def test_god_7():
902  requirements = '''
903 package Test
904 version v1r0
905 
906 document customdict TestCustomDict ../dict/TestCustomDict.h
907 
908 apply_pattern god_dictionary files=../xml/*.xml
909  '''
910  pkg = PackWrap("Test", requirements, files={})
911 
912  cmakelists = pkg.generate()
913  print cmakelists
914 
915  calls = getCalls("include", cmakelists)
916  assert calls
917  l = calls[0].strip()
918  assert l == 'GaudiObjDesc'
919 
920  calls = getCalls("god_build_dictionary", cmakelists)
921  assert len(calls) == 1, "god_build_dictionary wrong count %d" % len(calls)
922 
923  l = calls[0].strip().split()
924  assert l == ['xml/*.xml', 'EXTEND', 'dict/TestCustomDict.h']
def test_cmt2cmake.test_heptools_1 ( )

Definition at line 1334 of file test_cmt2cmake.py.

1334 
1335 def test_heptools_1():
1336  # check the case of LCGCMT in the project.cmt
1337  proj_cmt = '''
1338 project TestProjectHT
1339 
1340 use LCGCMT LCGCMT_64a
1341  '''
1342  files = {"TestProjectHTSys": {"cmt": {"requirements": "version v1r0"}}}
1343  proj = ProjWrap("TestProjectHT", proj_cmt, files=files)
1344 
1345  k = repr(('TestProjectHT', 'v1r0'))
1346  assert k not in cmt2cmake.cache
1347 
1348  toolchain = proj.generateToolchain()
1349  print toolchain
1350 
1351  calls = getCalls("set", toolchain)
1352  assert len(calls) == 2, "set wrong count %d" % len(calls)
1353 
1354  l = calls[0].strip().split()
1355  assert l == ['heptools_version', '64a']
1356 
1357  assert k in cmt2cmake.cache
1358  assert cmt2cmake.cache[k] == {'heptools': '64a'}
def test_cmt2cmake.test_heptools_2 ( )

Definition at line 1359 of file test_cmt2cmake.py.

1359 
1360 def test_heptools_2():
1361  # check the case of LCGCMT in a used project (already in the cache)
1362  proj_cmt = '''
1363 project TestProjectHT
1364 
1365 use BASEPROJECT BASEPROJECT_v1r0
1366  '''
1367  files = {"TestProjectHTSys": {"cmt": {"requirements": "version v2r0"}}}
1368  proj = ProjWrap("TestProjectHT", proj_cmt, files=files)
1369 
1370  k = repr(('TestProjectHT', 'v2r0'))
1371  assert k not in cmt2cmake.cache
1372 
1373  toolchain = proj.generateToolchain()
1374  print toolchain
1375 
1376  calls = getCalls("set", toolchain)
1377  assert len(calls) == 2, "set wrong count %d" % len(calls)
1378 
1379  l = calls[0].strip().split()
1380  assert l == ['heptools_version', '65']
1381 
1382  assert k in cmt2cmake.cache
1383  assert cmt2cmake.cache[k] == {'heptools': '65'}
def test_cmt2cmake.test_heptools_3 ( )

Definition at line 1384 of file test_cmt2cmake.py.

1384 
1385 def test_heptools_3():
1386  # check the case of LCGCMT not declared, but in the cache for us
1387  proj_cmt = '''
1388 project TestProjectHT
1389  '''
1390  files = {"TestProjectHTSys": {"cmt": {"requirements": "version v3r0"}}}
1391  proj = ProjWrap("TestProjectHT", proj_cmt, files=files)
1392 
1393  k = repr(('TestProjectHT', 'v3r0'))
1394  assert k in cmt2cmake.cache
1395 
1396  toolchain = proj.generateToolchain()
1397  print toolchain
1398 
1399  calls = getCalls("set", toolchain)
1400  assert len(calls) == 2, "set wrong count %d" % len(calls)
1401 
1402  l = calls[0].strip().split()
1403  assert l == ['heptools_version', '23']
1404 
1405  assert k in cmt2cmake.cache
1406  assert cmt2cmake.cache[k] == {'heptools': '23'}
def test_cmt2cmake.test_heptools_4 ( )

Definition at line 1407 of file test_cmt2cmake.py.

1407 
1408 def test_heptools_4():
1409  # check the case of LCGCMT not found
1410  proj_cmt = '''
1411 project TestProjectHT
1412  '''
1413  files = {"TestProjectHTSys": {"cmt": {"requirements": "version v4r0"}}}
1414  proj = ProjWrap("TestProjectHT", proj_cmt, files=files)
1415 
1416  k = repr(('TestProjectHT', 'v4r0'))
1417  assert k not in cmt2cmake.cache
1418 
1419  toolchain = proj.generateToolchain()
1420  assert toolchain is None
1421 
1422  assert k not in cmt2cmake.cache
1423 
1424 
def test_cmt2cmake.test_install_headers ( )

Definition at line 216 of file test_cmt2cmake.py.

216 
217 def test_install_headers():
218  requirements = '''
219 #============================================================================
220 package Tell1Kernel
221 version v1r12p1
222 
223 # Structure, i.e. directories to process.
224 #============================================================================
225 branches cmt doc Tell1Kernel
226 
227 # Used packages
228 #============================================================================
229 use GaudiPolicy v*
230 
231 apply_pattern install_more_includes more=Tell1Kernel
232  '''
233  pkg = PackWrap("Tell1Kernel", requirements, files={"Tell1Kernel/hdr.h": None})
234 
235  cmakelists = pkg.generate()
236  print cmakelists
237 
238  calls = getCalls("gaudi_install_headers", cmakelists)
239  assert calls
240 
241  args = set()
242  for call in calls:
243  args.update(call.strip().split())
244  expected = set(['Tell1Kernel'])
245  assert args == expected
def test_cmt2cmake.test_install_python ( )

Definition at line 246 of file test_cmt2cmake.py.

246 
247 def test_install_python():
248  requirements = '''
249 package Test
250 version v1r0
251 
252 apply_pattern install_python_modules
253  '''
254  pkg = PackWrap("Test", requirements, files={"python/Test/__init__.py": None})
255 
256  cmakelists = pkg.generate()
257  print cmakelists
258 
259  calls = getCalls("gaudi_install_python_modules", cmakelists)
260  assert calls
def test_cmt2cmake.test_install_python2 ( )

Definition at line 261 of file test_cmt2cmake.py.

261 
262 def test_install_python2():
263  requirements = '''
264 package Test
265 version v1r0
266 
267 macro TestConfUserModules "Test.CustomModule1 Test.CustomModule2"
268 
269 apply_pattern install_python_modules
270  '''
271  pkg = PackWrap("Test", requirements, files={"python/Test/__init__.py": None})
272 
273  cmakelists = pkg.generate()
274  print cmakelists
275 
276  calls = getCalls("gaudi_install_python_modules", cmakelists)
277  assert calls
278 
279  calls = getCalls("set_property", cmakelists)
280  assert calls
281  args = calls[0].strip().split()
282  assert args == ['DIRECTORY', 'PROPERTY', 'CONFIGURABLE_USER_MODULES', 'Test.CustomModule1', 'Test.CustomModule2'], args
def test_cmt2cmake.test_install_scripts ( )

Definition at line 283 of file test_cmt2cmake.py.

283 
284 def test_install_scripts():
285  requirements = '''
286 package Test
287 version v1r0
288 
289 apply_pattern install_scripts
290  '''
291  pkg = PackWrap("Test", requirements, files={"scripts/someScript": None})
292 
293  cmakelists = pkg.generate()
294  print cmakelists
295 
296  calls = getCalls("gaudi_install_scripts", cmakelists)
297  assert calls
def test_cmt2cmake.test_libraries ( )

Definition at line 317 of file test_cmt2cmake.py.

317 
318 def test_libraries():
319  requirements = '''
320 package Test
321 version v1r0
322 
323 library TestLib lib/*.cpp
324 apply_pattern linker_library library=TestLib
325 
326 library TestComp component/*.cpp
327 apply_pattern component_library library=TestComp
328 
329 library TestTestLib test/lib/*.cpp -group=tests
330 apply_pattern linker_library library=TestTestLib
331 
332 library TestTestComp test/component/*.cpp -group=tests
333 apply_pattern component_library library=TestTestComp
334 
335 apply_pattern install_more_includes more=TestIncludes
336  '''
337  pkg = PackWrap("Test", requirements, files={'TestIncludes': {}})
338 
339  print 'components', pkg.component_libraries
340  print 'linker', pkg.linker_libraries
341  print 'libraries', pkg.libraries
342 
343  assert pkg.component_libraries == set(['TestComp', 'TestTestComp'])
344  assert pkg.linker_libraries == set(['TestLib', 'TestTestLib'])
345  assert pkg.libraries
346 
347  cmakelists = pkg.generate()
348  print cmakelists
349 
350  calls = getCalls("gaudi_add_library", cmakelists)
351  assert len(calls) == 2, "gaudi_add_library wrong count %d" % len(calls)
352  l = calls[0]
353  assert re.match(r' *TestLib\b', l)
354  assert re.search(r'\bPUBLIC_HEADERS +TestIncludes', l)
355  l = calls[1]
356  assert re.match(r' *TestTestLib\b', l)
357  assert re.search(r'\bPUBLIC_HEADERS +TestIncludes', l)
358  assert re.search(r'\bLINK_LIBRARIES +TestLib', l)
359 
360  calls = getCalls("gaudi_add_module", cmakelists)
361  assert len(calls) == 2, "gaudi_add_module wrong count %d" % len(calls)
362 
363  l = calls[0]
364  assert re.match(r' *TestComp\b', l)
365  assert not re.search(r'\bPUBLIC_HEADERS\b', l)
366  assert re.search(r'\bLINK_LIBRARIES +TestLib', l)
367  l = calls[1]
368  assert re.match(r' *TestTestComp\b', l)
369  assert not re.search(r'\bPUBLIC_HEADERS', l)
370  assert re.search(r'\bLINK_LIBRARIES +TestLib +TestTestLib', l)
def test_cmt2cmake.test_libraries_2 ( )

Definition at line 371 of file test_cmt2cmake.py.

371 
372 def test_libraries_2():
373  requirements = '''
374 package Test
375 version v1r0
376 
377 use Boost v* LCG_Interfaces
378 use XercesC v* LCG_Interfaces -no_auto_imports
379 
380 library Lib1 lib1/*.cpp
381 apply_pattern component_library library=Lib1
382 
383 library Lib2 lib2/*.cpp -import=XercesC
384 apply_pattern component_library library=Lib2
385 
386 # We do not use variables
387 library Lib3 lib3/*.cpp a_variable=some_value
388 apply_pattern component_library library=Lib3
389  '''
390  pkg = PackWrap("Test", requirements, files={})
391 
392  print 'components', pkg.component_libraries
393  print 'libraries', pkg.libraries
394 
395  assert pkg.component_libraries == set(['Lib1', 'Lib2', 'Lib3'])
396  assert pkg.libraries
397 
398  cmakelists = pkg.generate()
399  print cmakelists
400 
401  calls = getCalls("gaudi_add_module", cmakelists)
402  assert len(calls) == 3, "gaudi_add_module wrong count %d" % len(calls)
403 
404  l = calls[0]
405  assert re.match(r' *Lib1\b', l)
406  assert not re.search(r'\bPUBLIC_HEADERS\b', l)
407  assert re.search(r'\bLINK_LIBRARIES +Boost', l)
408  assert re.search(r'\bINCLUDE_DIRS +Boost', l)
409  l = calls[1]
410  assert re.match(r' *Lib2\b', l)
411  assert not re.search(r'\bPUBLIC_HEADERS', l)
412  assert re.search(r'\bLINK_LIBRARIES +Boost +XercesC', l)
413  assert re.search(r'\bINCLUDE_DIRS +Boost +XercesC', l)
414  l = calls[2]
415  assert re.match(r' *Lib3\b', l)
416  assert not re.search(r'\bPUBLIC_HEADERS', l)
417  assert re.search(r'\bLINK_LIBRARIES +Boost', l)
418  assert re.search(r'\bINCLUDE_DIRS +Boost', l)
def test_cmt2cmake.test_libraries_3 ( )

Definition at line 419 of file test_cmt2cmake.py.

419 
420 def test_libraries_3():
421  # some corner cases
422  # FIXME: we should actually test the warning messages
423  requirements = '''
424 package Test
425 version v1r0
426 
427 library Lib1
428 apply_pattern component_library library=Lib1
429 
430 library Lib2 lib2/*.cpp
431 apply_pattern linker_library library=Lib2
432 
433 library Lib3 lib3/*.cpp
434 
435 library Lib4 lib4/*.cpp
436 apply_pattern linker_library library="Lib4"
437 
438  '''
439  pkg = PackWrap("Test", requirements, files={})
440 
441  print 'components', pkg.component_libraries
442  print 'linker', pkg.linker_libraries
443  print 'libraries', pkg.libraries
444 
445  assert pkg.component_libraries == set(['Lib1'])
446  assert pkg.linker_libraries == set(['Lib2', 'Lib4'])
447  assert len(pkg.libraries) == 4
448 
449  cmakelists = pkg.generate()
450  print cmakelists
451 
452  calls = getCalls("gaudi_add_module", cmakelists)
453  assert len(calls) == 1, "gaudi_add_module wrong count %d" % len(calls)
454 
455  l = calls[0]
456  assert re.match(r' *Lib1\b', l)
457  assert not re.search(r'\bPUBLIC_HEADERS\b', l)
458 
459  calls = getCalls("gaudi_add_library", cmakelists)
460  assert len(calls) == 3, "gaudi_add_module wrong count %d" % len(calls)
461 
462  l = calls[0]
463  assert re.match(r' *Lib2\b', l)
464  assert re.search(r'\bNO_PUBLIC_HEADERS', l)
465 
466  l = calls[1]
467  assert re.match(r' *Lib3\b', l)
468  assert re.search(r'\bNO_PUBLIC_HEADERS', l)
469 
470  l = calls[2]
471  assert re.match(r' *Lib4\b', l)
472  assert re.search(r'\bNO_PUBLIC_HEADERS', l)
def test_cmt2cmake.test_libraries_fix_src_path ( )

Definition at line 473 of file test_cmt2cmake.py.

473 
474 def test_libraries_fix_src_path():
475  requirements = '''
476 package Test
477 version v1r0
478 
479 library TestLib1 ../src/subdir/*.cpp
480 apply_pattern linker_library library=TestLib1
481 
482 library TestLib2 ../tests/src/subdir/*.cpp
483 apply_pattern linker_library library=TestLib2
484 
485 library TestLib3 subdir/*.cpp
486 apply_pattern linker_library library=TestLib3
487  '''
488  pkg = PackWrap("Test", requirements, files={'TestIncludes': {}})
489 
490  assert pkg.linker_libraries == set(['TestLib1', 'TestLib2', 'TestLib3'])
491 
492  cmakelists = pkg.generate()
493  print cmakelists
494 
495  calls = getCalls("gaudi_add_library", cmakelists)
496  assert len(calls) == 3, "gaudi_add_library wrong count %d" % len(calls)
497 
498  l = calls[0].strip().split()
499  assert l[0] == 'TestLib1'
500  assert l[1] == 'src/subdir/*.cpp'
501 
502  l = calls[1].strip().split()
503  assert l[0] == 'TestLib2'
504  assert l[1] == 'tests/src/subdir/*.cpp'
505 
506  l = calls[2].strip().split()
507  assert l[0] == 'TestLib3'
508  assert l[1] == 'src/subdir/*.cpp'
def test_cmt2cmake.test_line_cont ( )

Definition at line 1144 of file test_cmt2cmake.py.

1144 
1145 def test_line_cont():
1146  requirements = '''
1147 package Test
1148 version v1r0
1149 
1150 library Test *.ccp
1151 
1152 macro TEST "value" \\
1153 
1154 apply_pattern component_library library=Test
1155  '''
1156  pkg = PackWrap("Test", requirements, files={})
1157 
1158  cmakelists = pkg.generate()
1159  print cmakelists
1160 
1161  calls = getCalls("gaudi_add_module", cmakelists)
1162  assert len(calls) == 1, "gaudi_add_module wrong count %d" % len(calls)
1163 
def test_cmt2cmake.test_line_copy_relax ( )

Definition at line 1164 of file test_cmt2cmake.py.

1164 
1165 def test_line_copy_relax():
1166  requirements = '''
1167 package Test
1168 version v1r0
1169 
1170 use RELAX v* LCG_Interfaces
1171 
1172 copy_relax_rootmap dict=CLHEP
1173 copy_relax_rootmap dict=HepMC
1174 copy_relax_rootmap dict=STL
1175 copy_relax_rootmap dict=Math
1176  '''
1177  pkg = PackWrap("Test", requirements, files={})
1178 
1179  cmakelists = pkg.generate()
1180  print cmakelists
1181 
1182  calls = getCalls("find_package", cmakelists)
1183  assert len(calls) == 1, "find_package wrong count %d" % len(calls)
1184 
1185  l = calls[0].strip().split()
1186  assert l == ['RELAX', 'REQUIRED', 'COMPONENTS', 'CLHEP', 'HepMC', 'STL', 'Math']
1187 
1188  calls = getCalls("add_custom_target", cmakelists)
1189  assert len(calls) == 1, "add_custom_target wrong count %d" % len(calls)
1190 
1191  l = calls[0].strip().split()
1192  assert l == ['RelaxRootmap', 'ALL', 'DEPENDS', '${rootmapfile}']
1193 
1194  # No need to check every call, just that the sequence is there
1195 
def test_cmt2cmake.test_linkopts ( )

Definition at line 1042 of file test_cmt2cmake.py.

1042 
1043 def test_linkopts():
1044  requirements = '''
1045 package Test
1046 version v1r0
1047 
1048 use ROOT v* LCG_Interfaces
1049 use Boost v* LCG_Interfaces
1050 
1051 macro_append ROOT_linkopts " -lMathCore"
1052 macro_append Boost_linkopts " $(Boost_linkopts_filesystem)"
1053 
1054  '''
1055  pkg = PackWrap("Test", requirements, files={})
1056 
1057  cmakelists = pkg.generate()
1058  print cmakelists
1059 
1060  calls = getCalls("find_package", cmakelists)
1061  assert len(calls) == 2, "find_package wrong count %d" % len(calls)
1062 
1063  l = calls[0].strip().split()
1064  assert l == ['Boost', 'COMPONENTS', 'filesystem'] # find_package are sorted
1065 
1066  l = calls[1].strip().split()
1067  assert l == ['ROOT', 'COMPONENTS', 'MathCore'] # find_package are sorted
def test_cmt2cmake.test_not_a_package ( )

Definition at line 112 of file test_cmt2cmake.py.

112 
113 def test_not_a_package():
114  d = mkdtemp()
115  buildDir({'NoPackage': {'a_file.txt': None}}, d)
116  try:
117  cmt2cmake.Package(os.path.join(d, 'NoPackage'))
118  assert False, 'bad package not recognized'
119  except ValueError:
120  pass
121  finally:
122  shutil.rmtree(d)
123 
def test_cmt2cmake.test_pack_deps ( )

Definition at line 145 of file test_cmt2cmake.py.

145 
146 def test_pack_deps():
147  requirements = """
148  package Test
149  version v1r0
150 
151  # series of uses
152  use GaudiKernel v*
153  use GaudiAlg *
154  use GaudiPolicy *
155  use GaudiCoreSvc v* # comment
156  use GaudiUtils * -no_auto_imports
157 
158  use LHCbKernel v* Kernel
159  """
160  pkg = PackWrap("Test", requirements)
161 
162  cmakelists = pkg.generate()
163  print cmakelists
164 
165  calls = getCalls("gaudi_depends_on_subdirs", cmakelists)
166  assert calls, "gaudi_depends_on_subdirs not called"
167 
168  args = set()
169  for call in calls:
170  args.update(call.strip().split())
171  expected = set(['GaudiKernel', 'GaudiAlg', 'GaudiCoreSvc',
172  'GaudiUtils', 'Kernel/LHCbKernel'])
173  assert args == expected
def test_cmt2cmake.test_pack_ext_deps ( )

Definition at line 189 of file test_cmt2cmake.py.

189 
190 def test_pack_ext_deps():
191  requirements = """
192  package Test
193  version v1r0
194 
195  # series of uses
196  use Boost v* LCG_Interfaces
197  use Python v* LCG_Interfaces
198  use XercesC v* LCG_Interfaces -no_auto_imports
199  """
200  pkg = PackWrap("Test", requirements)
201 
202  cmakelists = pkg.generate()
203  print cmakelists
204 
205  expected = set(['Boost', 'XercesC'])
206 
207  calls = getCalls("find_package", cmakelists)
208  assert calls, "find_pacakge not called"
209  assert len(calls) == len(expected)
210 
211  args = set()
212  for call in calls:
213  args.add(call.strip().split()[0])
214  print args
215  assert args == expected
def test_cmt2cmake.test_pack_header ( )

Definition at line 124 of file test_cmt2cmake.py.

124 
125 def test_pack_header():
126  requirements = """
127  package ThisIsAPackage
128  version v123r456
129 
130  branches cmt branches are ignored
131  macro test parsing of \\
132  multi line
133  """
134  pkg = PackWrap("ThisIsAPackage", requirements)
135 
136  cmakelists = pkg.generate()
137  print cmakelists
138 
139  calls = getCalls("gaudi_subdir", cmakelists)
140  assert calls, "gaudi_subdir not called"
141  assert len(calls) == 1, "gaudi_subdir called more than once"
142 
143  args = calls[0].strip().split()
144  assert args == ["ThisIsAPackage", "v123r456"], args
def test_cmt2cmake.test_pack_no_deps ( )

Definition at line 174 of file test_cmt2cmake.py.

174 
175 def test_pack_no_deps():
176  requirements = """
177  package Test
178  version v1r0
179 
180  # no uses
181  """
182  pkg = PackWrap("Test", requirements)
183 
184  cmakelists = pkg.generate()
185  print cmakelists
186 
187  calls = getCalls("gaudi_depends_on_subdirs", cmakelists)
188  assert not calls, "gaudi_depends_on_subdirs called"
def test_cmt2cmake.test_project ( )

Definition at line 1196 of file test_cmt2cmake.py.

1196 
1197 def test_project():
1198  proj_cmt = '''
1199 project LHCB
1200 
1201 use GAUDI GAUDI_v23r4
1202 use DBASE
1203 use PARAM
1204 
1205 build_strategy with_installarea
1206 setup_strategy root
1207  '''
1208  files = {"LHCbSys": {"cmt": {"requirements": "version v35r2"}}}
1209  proj = ProjWrap("LHCb", proj_cmt, files=files)
1210 
1211  cmakelists = proj.generate()
1212  print cmakelists
1213 
1214  calls = getCalls("find_package", cmakelists)
1215  assert len(calls) == 1, "find_package wrong count %d" % len(calls)
1216 
1217  l = calls[0].strip().split()
1218  assert l == ['GaudiProject']
1219 
1220  calls = getCalls("gaudi_project", cmakelists)
1221  assert len(calls) == 1, "gaudi_project wrong count %d" % len(calls)
1222 
1223  l = calls[0].strip().split()
1224  assert l == ['LHCb', 'v35r2', 'USE', 'Gaudi', 'v23r4']
def test_cmt2cmake.test_pyqt_patterns ( )

Definition at line 1114 of file test_cmt2cmake.py.

1114 
1115 def test_pyqt_patterns():
1116  requirements = '''
1117 package Test
1118 version v1r0
1119 
1120 use pygraphics v* LCG_Interfaces -no_auto_imports
1121 use Qt v* LCG_Interfaces -no_auto_imports
1122 
1123 apply_pattern install_python_modules
1124 
1125 apply_pattern PyQtResource qrc_files=../qt_resources/*.qrc outputdir=../python/Test/QtApp
1126 apply_pattern PyQtUIC ui_files=../qt_resources/*.ui outputdir=../python/Test/QtApp
1127 macro_append Test_python_dependencies " PyQtResource PyQtUIC "
1128  '''
1129  pkg = PackWrap("Test", requirements, files={})
1130 
1131  cmakelists = pkg.generate()
1132  print cmakelists
1133 
1134  calls = getCalls("gen_pyqt_resource", cmakelists)
1135  assert len(calls) == 1, "gen_pyqt_resource wrong count %d" % len(calls)
1136  l = calls[0].strip().split()
1137  assert l == ['Test.QtApp.Resources', 'Test/QtApp', 'qt_resources/*.qrc']
1138 
1139  calls = getCalls("gen_pyqt_uic", cmakelists)
1140  assert len(calls) == 1, "gen_pyqt_uic wrong count %d" % len(calls)
1141  l = calls[0].strip().split()
1142  assert l == ['Test.QtApp.UI', 'Test/QtApp', 'qt_resources/*.ui']
1143 
def test_cmt2cmake.test_qmtest ( )

Definition at line 298 of file test_cmt2cmake.py.

298 
299 def test_qmtest():
300  requirements = '''
301 package Test
302 version v1r0
303 
304 apply_pattern QMTest
305  '''
306  pkg = PackWrap("Test", requirements, files={"tests/qmtest/test.qms/a_test.qmt": None})
307 
308  cmakelists = pkg.generate()
309  print cmakelists
310 
311  calls = getCalls("gaudi_add_test", cmakelists)
312  assert calls, "no test added"
313  assert len(calls) == 1, "gaudi_add_test called more than once"
314 
315  args = calls[0].strip().split()
316  assert args == ["QMTest", "QMTEST"]
def test_cmt2cmake.test_reflex ( )

Definition at line 925 of file test_cmt2cmake.py.

925 
926 def test_reflex():
927  requirements = '''
928 package Test
929 version v1r0
930 
931 use ROOT v* LCG_Interfaces
932 
933 apply_pattern reflex_dictionary \\
934  dictionary=Test \\
935  headerfiles=$(TESTROOT)/dict/TestDict.h \\
936  selectionfile=$(TESTROOT)/dict/TestDict.xml
937 
938 apply_pattern reflex_dictionary \\
939  dictionary=Test2 \\
940  headerfiles=$(TESTROOT)/dict/Test2Dict.h \\
941  selectionfile=$(TESTROOT)/dict/Test2Dict.xml \\
942  options="-DOPTION"
943  '''
944  pkg = PackWrap("Test", requirements, files={})
945 
946  cmakelists = pkg.generate()
947  print cmakelists
948 
949  calls = getCalls("gaudi_add_dictionary", cmakelists)
950  assert len(calls) == 2, "gaudi_add_dictionary wrong count %d" % len(calls)
951 
952  l = calls[0].strip().split()
953  assert l[0:3] == ['Test', 'dict/TestDict.h', 'dict/TestDict.xml']
954  assert 'LINK_LIBRARIES' in l
955  assert l[l.index('LINK_LIBRARIES')+1] == 'ROOT'
956  assert 'INCLUDE_DIRS' in l
957  assert l[l.index('INCLUDE_DIRS')+1] == 'ROOT'
958 
959  l = calls[1].strip().split()
960  assert l[0:3] == ['Test2', 'dict/Test2Dict.h', 'dict/Test2Dict.xml']
961  assert 'LINK_LIBRARIES' in l
962  assert l[l.index('LINK_LIBRARIES')+1] == 'ROOT'
963  assert 'INCLUDE_DIRS' in l
964  assert l[l.index('INCLUDE_DIRS')+1] == 'ROOT'
965  assert 'OPTIONS' in l
966  assert l[l.index('OPTIONS')+1:] == ['"-DOPTION"']
967 
def test_cmt2cmake.test_reflex_2 ( )

Definition at line 968 of file test_cmt2cmake.py.

968 
969 def test_reflex_2():
970  requirements = '''
971 package Test
972 version v1r0
973 
974 use ROOT v* LCG_Interfaces
975 
976 library Test *.ccp
977 apply_pattern component_library library=Test
978 
979 apply_pattern reflex_dictionary \\
980  dictionary=Test \\
981  headerfiles=$(TESTROOT)/dict/TestDict.h \\
982  selectionfile=$(TESTROOT)/dict/TestDict.xml
983  '''
984  pkg = PackWrap("Test", requirements, files={})
985 
986  cmakelists = pkg.generate()
987  print cmakelists
988 
989  calls = getCalls("gaudi_add_module", cmakelists)
990  assert len(calls) == 1, "gaudi_add_module wrong count %d" % len(calls)
991 
992  l = calls[0].strip().split()
993  assert l[0] == 'Test'
994 
995  calls = getCalls("gaudi_add_dictionary", cmakelists)
996  assert len(calls) == 1, "gaudi_add_dictionary wrong count %d" % len(calls)
997 
998  l = calls[0].strip().split()
999  assert l[0:3] == ['Test', 'dict/TestDict.h', 'dict/TestDict.xml']
def test_cmt2cmake.test_reflex_3 ( )

Definition at line 1000 of file test_cmt2cmake.py.

1000 
1001 def test_reflex_3():
1002  requirements = '''
1003 package Test
1004 version v1r0
1005 
1006 use ROOT v* LCG_Interfaces
1007 use COOL v* LCG_Interfaces -no_auto_imports
1008 use CORAL v* LCG_Interfaces -no_auto_imports
1009 use Boost v* LCG_Interfaces -no_auto_imports
1010 
1011 library Test *.ccp
1012 apply_pattern component_library library=Test
1013 
1014 apply_pattern reflex_dictionary \\
1015  dictionary=Test \\
1016  headerfiles=$(TESTROOT)/dict/TestDict.h \\
1017  selectionfile=$(TESTROOT)/dict/TestDict.xml \\
1018  imports="COOL -import=CORAL -import=Boost"
1019  '''
1020  pkg = PackWrap("Test", requirements, files={})
1021 
1022  cmakelists = pkg.generate()
1023  print cmakelists
1024 
1025  calls = getCalls("gaudi_add_module", cmakelists)
1026  assert len(calls) == 1, "gaudi_add_module wrong count %d" % len(calls)
1027 
1028  l = calls[0].strip().split()
1029  assert l[0] == 'Test'
1030 
1031  calls = getCalls("gaudi_add_dictionary", cmakelists)
1032  assert len(calls) == 1, "gaudi_add_dictionary wrong count %d" % len(calls)
1033 
1034  l = calls[0].strip().split()
1035  assert l[0:3] == ['Test', 'dict/TestDict.h', 'dict/TestDict.xml']
1036  assert 'INCLUDE_DIRS' in l
1037  i = l.index('INCLUDE_DIRS')
1038  assert 'LINK_LIBRARIES' in l
1039  j = l.index('LINK_LIBRARIES')
1040  assert set(l[i+1:j]) == set(['ROOT', 'COOL', 'CORAL', 'Boost'])
1041  assert set(l[j+1:]) == set(['ROOT', 'COOL', 'CORAL', 'Boost'])
def test_cmt2cmake.test_subdir_headers ( )

Definition at line 645 of file test_cmt2cmake.py.

645 
646 def test_subdir_headers():
647  if 'GaudiDummy' in cmt2cmake.cache:
648  del cmt2cmake.cache['GaudiDummy']
649 
650  requirements = '''
651 package GaudiDummy
652 version v1r0
653 
654 use JustHeaders v*
655 use JustHeaders v* Hat
656 
657 library Dummy *.cpp
658 apply_pattern linker_library library=Dummy
659  '''
660  pkg = PackWrap("GaudiDummy", requirements, files={'Dummy':{}})
661 
662  cmakelists = pkg.generate()
663  print cmakelists
664 
665  calls = getCalls("gaudi_add_library", cmakelists)
666  assert len(calls) == 1, "gaudi_add_library wrong count %d" % len(calls)
667 
668  l = calls[0].strip().split()
669  assert l[0] == 'Dummy'
670  assert 'INCLUDE_DIRS' in l
671  links = set(l[l.index('INCLUDE_DIRS')+1:])
672  assert links == set(['JustHeaders', 'Hat/JustHeaders'])
def test_cmt2cmake.test_subdir_headers_update ( )

Definition at line 673 of file test_cmt2cmake.py.

673 
674 def test_subdir_headers_update():
675  if 'GaudiDummy' in cmt2cmake.cache:
676  del cmt2cmake.cache['GaudiDummy']
677 
678  requirements = '''
679 package GaudiDummy
680 version v1r0
681 
682 apply_pattern install_more_includes more=Dummy
683  '''
684  PackWrap("GaudiDummy", requirements, files={'Dummy':{}})
685 
686  assert cmt2cmake.cache['GaudiDummy']['includes'] == True
687  assert not cmt2cmake.cache['GaudiDummy']['libraries']
def test_cmt2cmake.test_subdir_links ( )

Definition at line 509 of file test_cmt2cmake.py.

509 
510 def test_subdir_links():
511  requirements = '''
512 package Test
513 version v1r0
514 
515 use Boost v* LCG_Interfaces
516 use XercesC v* LCG_Interfaces -no_auto_imports
517 
518 use GaudiKernel *
519 use GaudiUtils * -no_auto_imports
520 
521 
522 library Lib1 *.cpp
523 apply_pattern component_library library=Lib1
524 
525 library Lib2 *.cpp -import=XercesC
526 apply_pattern component_library library=Lib2
527 
528 library Lib3 *.cpp -import=GaudiUtils
529 apply_pattern component_library library=Lib3
530  '''
531  pkg = PackWrap("Test", requirements, files={})
532 
533  print 'components', pkg.component_libraries
534  print 'linker', pkg.linker_libraries
535  print 'libraries', pkg.libraries
536 
537  assert pkg.component_libraries == set(['Lib1', 'Lib2', 'Lib3'])
538  assert len(pkg.libraries) == 3
539 
540  cmakelists = pkg.generate()
541  print cmakelists
542 
543  calls = getCalls("gaudi_add_module", cmakelists)
544  assert len(calls) == 3, "gaudi_add_module wrong count %d" % len(calls)
545 
546  l = calls[0].strip().split()
547  assert l[0] == 'Lib1'
548  links = set(l[l.index('LINK_LIBRARIES')+1:])
549  assert links == set(['Boost', 'GaudiKernel'])
550 
551  l = calls[1].strip().split()
552  assert l[0] == 'Lib2'
553  assert 'LINK_LIBRARIES' in l
554  links = set(l[l.index('LINK_LIBRARIES')+1:])
555  assert links == set(['Boost', 'GaudiKernel', 'XercesC'])
556 
557  l = calls[2].strip().split()
558  assert l[0] == 'Lib3'
559  assert 'LINK_LIBRARIES' in l
560  links = set(l[l.index('LINK_LIBRARIES')+1:])
561  assert links == set(['Boost', 'GaudiKernel', 'GaudiUtilsLib'])
def test_cmt2cmake.test_subdir_links_hat ( )

Definition at line 562 of file test_cmt2cmake.py.

562 
563 def test_subdir_links_hat():
564  requirements = '''
565 package Test
566 version v1r0
567 
568 use LHCbKernel * Kernel
569 use SomeSubdir * Hat -no_auto_imports
570 
571 library Lib1 *.cpp
572 apply_pattern component_library library=Lib1
573 
574 library Lib2 *.cpp -import=SomeSubdir
575 apply_pattern component_library library=Lib2
576  '''
577  pkg = PackWrap("Test", requirements, files={})
578 
579  print 'components', pkg.component_libraries
580  print 'linker', pkg.linker_libraries
581  print 'libraries', pkg.libraries
582 
583  assert pkg.component_libraries == set(['Lib1', 'Lib2'])
584  assert len(pkg.libraries) == 2
585 
586  cmakelists = pkg.generate()
587  print cmakelists
588 
589  calls = getCalls("gaudi_add_module", cmakelists)
590  assert len(calls) == 2, "gaudi_add_module wrong count %d" % len(calls)
591 
592  l = calls[0].strip().split()
593  assert l[0] == 'Lib1'
594  links = set(l[l.index('LINK_LIBRARIES')+1:])
595  assert links == set(['LHCbKernel'])
596 
597  l = calls[1].strip().split()
598  assert l[0] == 'Lib2'
599  links = set(l[l.index('LINK_LIBRARIES')+1:])
600  assert links == set(['LHCbKernel', 'SubdirLib'])
def test_cmt2cmake.test_subdir_links_missing ( )

Definition at line 601 of file test_cmt2cmake.py.

601 
602 def test_subdir_links_missing():
603  requirements = '''
604 package Test
605 version v1r0
606 
607 use UnknownSubdir *
608 
609 library Lib1 *.cpp
610 apply_pattern component_library library=Lib1
611  '''
612  pkg = PackWrap("Test", requirements, files={})
613 
614  assert pkg.component_libraries == set(['Lib1'])
615  assert len(pkg.libraries) == 1
616 
617  cmakelists = pkg.generate()
618  print cmakelists
619 
620  calls = getCalls("gaudi_add_module", cmakelists)
621  assert len(calls) == 1, "gaudi_add_module wrong count %d" % len(calls)
622 
623  l = calls[0].strip().split()
624  assert l[0] == 'Lib1'
625  assert 'LINK_LIBRARIES' not in l
626  # FIXME: we should test the warning
def test_cmt2cmake.test_subdir_links_update ( )

Definition at line 627 of file test_cmt2cmake.py.

627 
628 def test_subdir_links_update():
629  if 'GaudiDummy' in cmt2cmake.cache:
630  del cmt2cmake.cache['GaudiDummy']
631 
632  requirements = '''
633 package GaudiDummy
634 version v1r0
635 
636 apply_pattern install_more_includes more=Dummy
637 
638 library Dummy *.cpp
639 apply_pattern linker_library library=Dummy
640  '''
641  PackWrap("GaudiDummy", requirements, files={'Dummy':{}})
642 
643  assert cmt2cmake.cache['GaudiDummy']['libraries'] == ['Dummy']
644  assert cmt2cmake.cache['GaudiDummy']['includes'] == False
def test_cmt2cmake.test_write_file ( )

Definition at line 688 of file test_cmt2cmake.py.

688 
689 def test_write_file():
690  requirements = '''
691 package Test
692 version v1r0
693 
694 library Lib1 *.cpp
695 apply_pattern component_library library=Lib1
696  '''
697  pkg = PackWrap("Test", requirements, files={})
698 
699  cmakelists = pkg.generate()
700  print cmakelists
701 
702  cmakefile = os.path.join(pkg.path, 'CMakeLists.txt')
703  pkg.process()
704  assert os.path.exists(cmakefile)
705  assert open(cmakefile).read() == cmakelists
def test_cmt2cmake.test_write_file_exists ( )

Definition at line 706 of file test_cmt2cmake.py.

706 
707 def test_write_file_exists():
708  requirements = '''
709 package Test
710 version v1r0
711 
712 library Lib1 *.cpp
713 apply_pattern component_library library=Lib1
714  '''
715  pkg = PackWrap("Test", requirements, files={'CMakeLists.txt': 'dummy data'})
716 
717  cmakefile = os.path.join(pkg.path, 'CMakeLists.txt')
718  pkg.process()
719  # FIXME: we should test the warning
720  assert open(cmakefile).read() == 'dummy data'
721 
Generated at Wed Nov 28 2012 12:17:43 for Gaudi Framework, version v23r5 by Doxygen version 1.8.2 written by Dimitri van Heesch, © 1997-2004