1 #

     2 # Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).

     3 # All rights reserved.

     4 # This component and the accompanying materials are made available

     5 # under the terms of the License "Eclipse Public License v1.0"

     6 # which accompanies this distribution, and is available

     7 # at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 #

     9 # Initial Contributors:

    10 # Nokia Corporation - initial contribution.

    11 #

    12 # Contributors:

    13 #

    14 # Description: 

    15 # raptor_data_unit module

    16 # This module tests the classes that make up the Raptor Data Model.

    17 #

    18 

    19 import generic_path

    20 import os

    21 import raptor

    22 import raptor_cache

    23 import raptor_data

    24 import sys

    25 import unittest

    26 

    27 class TestRaptorData(unittest.TestCase):

    28 

    29 	def setUp(self):

    30 		self.envStack = {}

    31 		

    32 		

    33 	def SetEnv(self, name, value):

    34 		# set environment variable and remember the old value (if there is one)		

    35 		if os.environ.has_key(name):

    36 			self.envStack[name] = os.environ[name]

    37 		os.environ[name] = value

    38 		

    39 	def isWin(self):

    40 		return 'win' in raptor.hostplatform

    41 			

    42 	def RestoreEnv(self, name):

    43 		# put environment back to its state before SetEnv

    44 		if self.envStack.has_key(name):

    45 			os.environ[name] = self.envStack[name]

    46 		else:

    47 			del os.environ[name]    # was not defined

    48 			

    49 			

    50 	def testSimpleSpecification(self):

    51 		spec = raptor_data.Specification("myProject")

    52 

    53 		spec.SetInterface("Symbian.EXE")

    54 		

    55 		var = raptor_data.Variant("X")

    56 

    57 		var.AddOperation(raptor_data.Set("SOURCES", "a.cpp"))

    58 		var.AddOperation(raptor_data.Append("LIBS", "all.dll"))

    59 		var.AddOperation(raptor_data.Append("INC", "/C/include"))

    60 		var.AddOperation(raptor_data.Prepend("INC", "/B/include"))

    61 

    62 		spec.AddVariant(var)

    63 		spec.AddVariant("AlwaysBuildAsArm")

    64 

    65 		self.failUnless(spec)

    66 		self.failUnless(spec.Valid())

    67 		self.failUnless(var.Valid())

    68 		self.assertEqual(spec.name, "myProject")

    69 

    70 

    71 	def testSimpleFilter(self):

    72 		filter = raptor_data.Filter("filtered")

    73 		filter.SetConfigCondition("ARMV5")

    74 		

    75 		filter.SetInterface(raptor_data.Interface("True.EXE"))

    76 		filter.Else.SetInterface(raptor_data.Interface("False.EXE"))

    77 		

    78 		filter.AddVariant(raptor_data.Variant("True_var"))

    79 		filter.Else.AddVariant(raptor_data.Variant("False_var"))

    80 		

    81 		filter.AddChildSpecification(raptor_data.Specification("TrueSpec"))

    82 		filter.Else.AddChildSpecification(raptor_data.Specification("FalseSpec"))

    83 		

    84 		filter.Configure( raptor_data.BuildUnit("ARMV5",[]), cache=None )

    85 		# check a positive test

    86 		iface = filter.GetInterface(cache=None)

    87 		self.assertEqual(iface.name, "True.EXE")

    88 		vars = filter.GetVariants(cache = None)

    89 		self.assertEqual(vars[0].name, "True_var")

    90 		kids = filter.GetChildSpecs()

    91 		self.assertEqual(kids[0].name, "TrueSpec")

    92 		

    93 		filter.Configure( raptor_data.BuildUnit("NOT_ARMV5",[]) , cache = None)

    94 		# check a negative test

    95 		iface = filter.GetInterface(cache = None)

    96 		self.assertEqual(iface.name, "False.EXE")

    97 		vars = filter.GetVariants(cache = None)

    98 		self.assertEqual(vars[0].name, "False_var")

    99 		kids = filter.GetChildSpecs()

   100 		self.assertEqual(kids[0].name, "FalseSpec")

   101 		

   102 

   103 	def testSimpleVariant(self):

   104 		var = raptor_data.Variant()

   105 		self.failUnless(var)

   106 		self.failIf( var.Valid() )

   107 

   108 		var.SetProperty("name", "ABC")

   109 		var.SetProperty("extends", "DEF")

   110 		var.SetProperty("host", "GHI")

   111 

   112 		self.assertEqual(var.name, "ABC")

   113 		self.assertEqual(var.extends, "DEF")

   114 		self.assertEqual(var.host, None)

   115 

   116 		var.SetProperty("host", "win32")

   117 		self.assertEqual(var.host, "win32")

   118 

   119 		self.failUnless( var.Valid() )

   120 

   121 		var.AddOperation( raptor_data.Set("CC", "armcc") )

   122 		var.AddOperation( raptor_data.Set("LN", "armlink") )

   123 

   124 		self.failUnless( var.Valid() )

   125 

   126 		var.SetProperty("extends", "")

   127 		ops = var.GetAllOperationsRecursively(None)

   128 

   129 		self.assertEqual( len(ops), 1 )

   130 		self.assertEqual( len(ops[0]), 2 )

   131 

   132 	def testExtendedVariant(self):

   133 		r = raptor.Raptor()

   134 

   135 		varA = raptor_data.Variant("A")

   136 		varA.SetProperty("extends", None)

   137 		varA.AddOperation( raptor_data.Set("V1", "1A") )

   138 		varA.AddOperation( raptor_data.Set("V2", "2A") )

   139 

   140 		varB = raptor_data.Variant("B")

   141 		varB.SetProperty("extends", "A")

   142 		varB.AddOperation( raptor_data.Set("V2", "2B") )

   143 		varB.AddOperation( raptor_data.Set("V3", "3B") )

   144 

   145 		varC = raptor_data.Variant("C")

   146 		varC.SetProperty("extends", "B")

   147 		varC.AddOperation( raptor_data.Set("V3", "3C") )

   148 		varC.AddOperation( raptor_data.Set("V4", "4C") )

   149 

   150 		self.failUnless( varA.Valid() )

   151 		self.failUnless( varB.Valid() )

   152 		self.failUnless( varC.Valid() )

   153 

   154 		r.cache.AddVariant(varA)

   155 		r.cache.AddVariant(varB)

   156 		r.cache.AddVariant(varC)

   157 

   158 		e = r.GetEvaluator(None, varA.GenerateBuildUnits(r.cache)[0] )

   159 		self.assertEqual( e.Get("V1"), "1A" )

   160 		self.assertEqual( e.Get("V2"), "2A" )

   161 

   162 		e = r.GetEvaluator(None, varB.GenerateBuildUnits(r.cache)[0] )

   163 		self.assertEqual( e.Get("V1"), "1A" )

   164 		self.assertEqual( e.Get("V2"), "2B" )

   165 		self.assertEqual( e.Get("V3"), "3B" )

   166 

   167 		e = r.GetEvaluator(None, varC.GenerateBuildUnits(r.cache)[0] )

   168 		self.assertEqual( e.Get("V1"), "1A" )

   169 		self.assertEqual( e.Get("V2"), "2B" )

   170 		self.assertEqual( e.Get("V3"), "3C" )

   171 		self.assertEqual( e.Get("V4"), "4C" )

   172 

   173 	def testReferencedVariant(self):

   174 		r = raptor.Raptor()

   175 

   176 		varA = raptor_data.Variant("A")

   177 		varA.SetProperty("extends", None)

   178 		varA.AddOperation( raptor_data.Set("V1", "1A") )

   179 		varA.AddOperation( raptor_data.Set("V2", "2A") )

   180 

   181 		# B extends A, and has a reference to C.

   182 		varB = raptor_data.Variant("B")

   183 		varB.SetProperty("extends", "A")

   184 		varB.AddOperation( raptor_data.Set("V2", "2B") )

   185 		varB.AddOperation( raptor_data.Set("V3", "3B") )

   186 		varB.AddChild( raptor_data.VariantRef("C") )

   187 

   188 		varC = raptor_data.Variant("C")

   189 		varC.SetProperty("extends", None)

   190 		varC.AddOperation( raptor_data.Set("V3", "3C") )

   191 		varC.AddOperation( raptor_data.Set("V4", "4C") )

   192 

   193 		self.failUnless( varA.Valid() )

   194 		self.failUnless( varB.Valid() )

   195 		self.failUnless( varC.Valid() )

   196 

   197 		r.cache.AddVariant(varA)

   198 		r.cache.AddVariant(varB)

   199 		r.cache.AddVariant(varC)

   200 

   201 		e = r.GetEvaluator(None, varA.GenerateBuildUnits(r.cache)[0] )

   202 		self.assertEqual( e.Get("V1"), "1A" )

   203 		self.assertEqual( e.Get("V2"), "2A" )

   204 

   205 		e = r.GetEvaluator(None, varC.GenerateBuildUnits(r.cache)[0] )

   206 		self.assertEqual( e.Get("V3"), "3C" )

   207 		self.assertEqual( e.Get("V4"), "4C" )

   208 

   209 		e = r.GetEvaluator(None, varB.GenerateBuildUnits(r.cache)[0] )

   210 		self.assertEqual( e.Get("V1"), "1A" )

   211 		self.assertEqual( e.Get("V2"), "2B" )

   212 		self.assertEqual( e.Get("V3"), "3B" )

   213 		self.assertEqual( e.Get("V4"), "4C" )

   214 

   215 	def testAlias(self):

   216 		r = raptor.Raptor()

   217 

   218 		varA = raptor_data.Variant("A")

   219 		varA.AddOperation( raptor_data.Set("V1", "1A") )

   220 		varA.AddOperation( raptor_data.Set("V2", "2A") )

   221 		r.cache.AddVariant(varA)

   222 

   223 		varB = raptor_data.Variant("B")

   224 		varB.AddOperation( raptor_data.Set("V2", "2B") )

   225 		varB.AddOperation( raptor_data.Set("V3", "3B") )

   226 		r.cache.AddVariant(varB)

   227 

   228 		varC = raptor_data.Variant("C")

   229 		varC.AddOperation( raptor_data.Set("V3", "3C") )

   230 		varC.AddOperation( raptor_data.Set("V4", "4C") )

   231 		r.cache.AddVariant(varC)

   232 

   233 		# <alias name="an_alias" meaning="A.B.C"/>

   234 		alias = raptor_data.Alias("an_alias")

   235 		alias.SetProperty("meaning", "A.B.C")

   236 		r.cache.AddAlias(alias)

   237 

   238 		self.failUnless( alias.Valid() )

   239 

   240 		e = r.GetEvaluator(None, alias.GenerateBuildUnits(r.cache)[0] )

   241 		self.assertEqual( e.Get("V1"), "1A" )

   242 		self.assertEqual( e.Get("V2"), "2B" )

   243 		self.assertEqual( e.Get("V3"), "3C" )

   244 		self.assertEqual( e.Get("V4"), "4C" )

   245 

   246 	def testGroup1(self):

   247 		r = raptor.Raptor()

   248 

   249 		varA = raptor_data.Variant("A")

   250 		varA.AddOperation( raptor_data.Set("V1", "1A") )

   251 		varA.AddOperation( raptor_data.Set("V2", "2A") )

   252 		r.cache.AddVariant(varA)

   253 

   254 		varB = raptor_data.Variant("B")

   255 		varB.AddOperation( raptor_data.Set("V2", "2B") )

   256 		varB.AddOperation( raptor_data.Set("V3", "3B") )

   257 		r.cache.AddVariant(varB)

   258 

   259 		varC = raptor_data.Variant("C")

   260 		varC.AddOperation( raptor_data.Set("V3", "3C") )

   261 		varC.AddOperation( raptor_data.Set("V4", "4C") )

   262 		r.cache.AddVariant(varC)

   263 

   264 		alias = raptor_data.Alias("alias")

   265 		alias.SetProperty("meaning", "B.C")

   266 		r.cache.AddAlias(alias)

   267 

   268 		# This group has two buildable units: "A" and "alias" = "B.C".

   269 		# <group name="group1">

   270 		#	<varRef ref="A"/>

   271 		#   <aliasRef ref="alias">

   272 		# <group>

   273 		group1 = raptor_data.Group("group1")

   274 		group1.AddChild( raptor_data.VariantRef("A") )

   275 		group1.AddChild( raptor_data.AliasRef("alias") )

   276 		r.cache.AddGroup(group1)

   277 

   278 		vRef = raptor_data.VariantRef("C")

   279 		vRef.SetProperty("mod", "B")

   280 

   281 		# This group has three buildable units: "C.B", "A" and "alias" = "B.C".

   282 		# <group name="group2">

   283 		#	<varRef ref="C" mod="B"/>

   284 		#   <groupRef ref="group1"/>

   285 		# <group>

   286 		group2 = raptor_data.Group("group2")

   287 		group2.AddChild(vRef)

   288 		group2.AddChild( raptor_data.GroupRef("group1") )

   289 		r.cache.AddGroup(group2)

   290 

   291 		self.failUnless( group1.Valid() )

   292 		self.failUnless( group2.Valid() )

   293 

   294 		buildUnits = group1.GenerateBuildUnits(r.cache)

   295 		self.assertEqual( len(buildUnits), 2 )

   296 		self.assertEqual( buildUnits[0].name, "A" )

   297 		self.assertEqual( buildUnits[1].name, "alias" )

   298 		self.assertEqual( buildUnits[1].variants[0].name, "B" )

   299 		self.assertEqual( buildUnits[1].variants[1].name, "C" )

   300 

   301 		buildUnits = group2.GenerateBuildUnits(r.cache)

   302 		self.assertEqual( len(buildUnits), 3 )

   303 		self.assertEqual( buildUnits[0].name, "C.B" )

   304 		self.assertEqual( buildUnits[1].name, "A" )

   305 		self.assertEqual( buildUnits[2].name, "alias" )

   306 

   307 		self.assertEqual( len(buildUnits[0].variants), 2 )

   308 		self.assertEqual( len(buildUnits[1].variants), 1 )

   309 		self.assertEqual( len(buildUnits[2].variants), 2 )

   310 

   311 	def testGroup2(self):

   312 		r = raptor.Raptor()

   313 

   314 		r.cache.Load( generic_path.Join(r.home, "test", "config", "arm.xml") )

   315 

   316 		buildUnits = r.cache.FindNamedGroup("G2").GenerateBuildUnits(r.cache)

   317 

   318 		self.assertEqual( len(buildUnits), 8 )

   319 

   320 		self.assertEqual(buildUnits[0].name, "ARMV5_UREL.MOD1")

   321 		self.assertEqual(buildUnits[1].name, "ARMV5_UDEB.MOD1.MOD2")

   322 		self.assertEqual(buildUnits[2].name, "ALIAS_1")

   323 		self.assertEqual(buildUnits[3].name, "ALIAS_2.MOD1.MOD2.MOD1")

   324 		self.assertEqual(buildUnits[4].name, "ARMV5_UREL.MOD2")

   325 		self.assertEqual(buildUnits[5].name, "ARMV5_UDEB.MOD2")

   326 		self.assertEqual(buildUnits[6].name, "MOD1")

   327 		self.assertEqual(buildUnits[7].name, "MOD2")

   328 

   329 	def testRefs(self):

   330 		i1 = raptor_data.InterfaceRef()

   331 		self.failIf(i1.Valid())

   332 

   333 		i2 = raptor_data.InterfaceRef("")

   334 		self.failIf(i2.Valid())

   335 

   336 		i3 = raptor_data.InterfaceRef("ABC_abc.123")

   337 		self.failUnless(i3.Valid())

   338 		self.assertEqual(i3.ref, "ABC_abc.123")

   339 

   340 

   341 	def testEvaluator(self):

   342 		self.SetEnv("EPOCROOT", "/C")

   343 		aRaptor = raptor.Raptor()

   344 		cache = aRaptor.cache

   345 		aRaptor.debugOutput = True

   346 		cache.Load(generic_path.Join(aRaptor.home, "test", "config", "arm.xml"))

   347 		

   348 		var = cache.FindNamedVariant("ARMV5_UREL")

   349 		eval = aRaptor.GetEvaluator( None, var.GenerateBuildUnits(aRaptor.cache)[0])

   350 		self.RestoreEnv("EPOCROOT")

   351 		

   352 		# test the Get method

   353 		varcfg = eval.Get("VARIANT_CFG")

   354 		self.assertEqual(varcfg, "/C/variant/variant.cfg")

   355 		

   356 		# test the Resolve wrt EPOCROOT

   357 		varcfg = eval.Resolve("VARIANT_CFG")

   358 		self.assertEqual(varcfg, "/C/variant/variant.cfg")

   359 		

   360 	def testProblematicEnvironment(self):

   361 		aRaptor = raptor.Raptor()		

   362 		

   363 		# 1: ask for environment variable values that will break makefile parsing due to

   364 		# backslashes forming line continuation characters

   365 		self.SetEnv("ENVVAR_BSLASH_END1", "C:\\test1a\\;C:\\test1b\\")

   366 		self.SetEnv("ENVVAR_BSLASH_END2", "C:\\test2a\\;C:\\test2b\\\\")

   367 		self.SetEnv("ENVVAR_BSLASH_END3", "C:\\test3a\\;C:\\test3b\\\\\\")

   368 		var = raptor_data.Variant("my.var")

   369 		var.AddOperation(raptor_data.Env("ENVVAR_BSLASH_END1"))

   370 		var.AddOperation(raptor_data.Env("ENVVAR_BSLASH_END2"))

   371 		var.AddOperation(raptor_data.Env("ENVVAR_BSLASH_END3"))

   372 

   373 		eval = aRaptor.GetEvaluator(None, var.GenerateBuildUnits(aRaptor.cache)[0])

   374 		self.RestoreEnv("ENVVAR_BSLASH_END1")

   375 		self.RestoreEnv("ENVVAR_BSLASH_END2")

   376 		self.RestoreEnv("ENVVAR_BSLASH_END3")

   377 		

   378 		value = eval.Get("ENVVAR_BSLASH_END1")

   379 		self.assertEqual(value, "C:\\test1a\\;C:\\test1b\\\\")

   380 		

   381 		value = eval.Get("ENVVAR_BSLASH_END2")

   382 		self.assertEqual(value, "C:\\test2a\\;C:\\test2b\\\\")

   383 		

   384 		value = eval.Get("ENVVAR_BSLASH_END3")

   385 		self.assertEqual(value, "C:\\test3a\\;C:\\test3b\\\\\\\\")

   386 		

   387 		# 2: check 'tool' and 'toolchain' type environment variable values for correct behaviour when paths contain spaces

   388 		# this is different depending on host OS platform and whether or not the paths/tools actually exist

   389 		epocroot = os.path.abspath(os.environ.get('EPOCROOT')).replace('\\','/').rstrip('/')

   390 		pathwithspaces = epocroot+"/epoc32/build/Program Files/Some tool installed with spaces/no_spaces/s p c/no_more_spaces"

   391 		toolwithspaces = pathwithspaces+"/testtool.exe"	

   392 		self.SetEnv("ENVVAR_TOOL_WITH_SPACES", toolwithspaces)

   393 		self.SetEnv("ENVVAR_TOOLCHAINPATH_WITH_SPACES", pathwithspaces)

   394 		toolVar = raptor_data.Variant("tool.var")

   395 		toolchainpathVar = raptor_data.Variant("toolchainpath.var")

   396 		toolVar.AddOperation(raptor_data.Env("ENVVAR_TOOL_WITH_SPACES", "", "tool"))

   397 		toolchainpathVar.AddOperation(raptor_data.Env("ENVVAR_TOOLCHAINPATH_WITH_SPACES", "", "toolchainpath"))

   398 		invalidValueException = "the environment variable %s is incorrect - it is a '%s' type but contains spaces that cannot be neutralised:"

   399 		

   400 		# 2a: paths/tools exist - on Windows we expect 8.3 paths post-evaluation, on all other platforms error exceptions

   401 		os.makedirs(pathwithspaces)

   402 		testtool = open(toolwithspaces,'wb')

   403 		testtool.close()

   404 		

   405 		exceptionText = ""

   406 		value = ""

   407 		try:

   408 			eval = aRaptor.GetEvaluator(None, toolVar.GenerateBuildUnits(aRaptor.cache)[0])

   409 			value = eval.Get("ENVVAR_TOOL_WITH_SPACES")

   410 		except Exception, e:

   411 			exceptionText = str(e)

   412 			

   413 		if self.isWin():

   414 			self.assertTrue(value)

   415 			self.assertFalse(' ' in value)

   416 		else:

   417 			self.assertTrue(exceptionText.startswith(invalidValueException % ("ENVVAR_TOOL_WITH_SPACES", "tool")))

   418 

   419 		exceptionText = ""

   420 		value = ""

   421 		try:

   422 			eval = aRaptor.GetEvaluator(None, toolchainpathVar.GenerateBuildUnits(aRaptor.cache)[0])

   423 			value = eval.Get("ENVVAR_TOOLCHAINPATH_WITH_SPACES")

   424 		except Exception, e:

   425 			exceptionText = str(e)

   426 			

   427 		if self.isWin():

   428 			self.assertTrue(value)

   429 			self.assertFalse(' ' in value)

   430 		else:

   431 			self.assertTrue(exceptionText.startswith(invalidValueException % ("ENVVAR_TOOLCHAINPATH_WITH_SPACES", "toolchainpath")))

   432 		

   433 		# 2b: paths/tools don't exist - should throw error exceptions on all platforms as 8.3 paths are only available

   434 		# for use if a path/tool exists

   435 		os.remove(toolwithspaces)

   436 		os.removedirs(pathwithspaces)

   437 

   438 		exceptionText = ""

   439 		try:

   440 			eval = aRaptor.GetEvaluator(None, toolVar.GenerateBuildUnits(aRaptor.cache)[0])

   441 		except Exception, e:

   442 			exceptionText = str(e)

   443 		self.assertTrue(exceptionText.startswith(invalidValueException % ("ENVVAR_TOOL_WITH_SPACES", "tool")))

   444 

   445 		exceptionText = ""

   446 		try:

   447 			eval = aRaptor.GetEvaluator(None, toolchainpathVar.GenerateBuildUnits(aRaptor.cache)[0])

   448 		except Exception, e:

   449 			exceptionText = str(e)			

   450 		self.assertTrue(exceptionText.startswith(invalidValueException % ("ENVVAR_TOOLCHAINPATH_WITH_SPACES", "toolchainpath")))

   451 

   452 		# clean-up

   453 		self.RestoreEnv("ENVVAR_TOOL_WITH_SPACES")

   454 		self.RestoreEnv("ENVVAR_TOOLCHAINPATH_WITH_SPACES")

   455 	

   456 	def testMissingEnvironment(self):

   457 		# ask for an environment variable that is not set

   458 		# and has no default value.

   459 		var = raptor_data.Variant("my.var")

   460 		var.AddOperation(raptor_data.Env("RAPTOR_SAYS_NO"))

   461 

   462 		aRaptor = raptor.Raptor()

   463 	

   464 		try:	

   465 			eval = aRaptor.GetEvaluator(None, var.GenerateBuildUnits(aRaptor.cache)[0] )

   466 			badval = eval.Get("RAPTOR_SAYS_NO")

   467 		except raptor_data.UninitialisedVariableException, e:

   468 			return

   469 

   470 		self.assertTrue(False)

   471 

   472 	def checkForParam(self, params, name, default):

   473 		for p in params:

   474 			if p.name == name and (default == None or p.default == default):

   475 				return True

   476 		return False

   477 	

   478 	def testInterface(self):

   479 		aRaptor = raptor.Raptor()

   480 		cache = aRaptor.cache

   481 		cache.Load(generic_path.Join(aRaptor.home, "test", "config", "interface.xml"))

   482 		

   483 		base = cache.FindNamedInterface("Base.XYZ")

   484 		p = base.GetParams(cache)

   485 		self.failUnless(self.checkForParam(p, "A", None))

   486 		self.failUnless(self.checkForParam(p, "B", "baseB"))

   487 		self.failUnless(self.checkForParam(p, "C", "baseC"))

   488 		

   489 		extended = cache.FindNamedInterface("Extended.XYZ")

   490 		p = extended.GetParams(cache)

   491 		self.failUnless(self.checkForParam(p, "A", None))

   492 		self.failUnless(self.checkForParam(p, "B", "baseB"))

   493 		self.failUnless(self.checkForParam(p, "C", "extC"))

   494 		self.failUnless(self.checkForParam(p, "D", None))

   495 		f = extended.GetFLMIncludePath(cache=cache)

   496 		self.assertEqual(f.File(), "ext.flm")

   497 		

   498 		extended = cache.FindNamedInterface("Extended2.XYZ")

   499 		p = extended.GetParams(cache)

   500 		self.failUnless(self.checkForParam(p, "A", None))

   501 		self.failUnless(self.checkForParam(p, "B", "baseB"))

   502 		self.failUnless(self.checkForParam(p, "C", "extC"))

   503 		self.failUnless(self.checkForParam(p, "D", None))

   504 		f = extended.GetFLMIncludePath(cache)

   505 		self.assertEqual(f.File(), "base.flm")

   506 

   507 	def testGetBuildUnits(self):

   508 		r = raptor.Raptor()

   509 

   510 		# <group name="g1">

   511 		g1 = raptor_data.Group("g1")

   512 		r.cache.AddGroup(g1)

   513 		

   514 		# <groupRef ref="g2" mod="A.B"/>

   515 		g2a = raptor_data.GroupRef()

   516 		g2a.SetProperty("ref", "g2")

   517 		g2a.SetProperty("mod", "A.B")

   518 		g1.AddChild(g2a)

   519 		

   520 		# <groupRef ref="g2" mod="C.D"/>

   521 		g2b = raptor_data.GroupRef()

   522 		g2b.SetProperty("ref", "g2")

   523 		g2b.SetProperty("mod", "C.D")

   524 		g1.AddChild(g2b)

   525 		

   526 		# <group name="g2">

   527 		g2 = raptor_data.Group("g2")

   528 		r.cache.AddGroup(g2)

   529 		

   530 		# <varRef ref="V" mod="E.F"/>

   531 		v2 = raptor_data.VariantRef()

   532 		v2.SetProperty("ref", "V")

   533 		v2.SetProperty("mod", "E.F")

   534 		g2.AddChild(v2)

   535 		

   536 		# <varRef ref="V" mod="G.H"/>

   537 		v3 = raptor_data.VariantRef()

   538 		v3.SetProperty("ref", "V")

   539 		v3.SetProperty("mod", "G.H")

   540 		g2.AddChild(v3)

   541 		

   542 		# <aliasRef ref="X" mod="I.J"/>

   543 		v4 = raptor_data.AliasRef()

   544 		v4.SetProperty("ref", "X")

   545 		v4.SetProperty("mod", "I.J")

   546 		g2.AddChild(v4)

   547 		

   548 		# <aliasRef ref="X" mod="K.L"/>

   549 		v5 = raptor_data.AliasRef()

   550 		v5.SetProperty("ref", "X")

   551 		v5.SetProperty("mod", "K.L")

   552 		g2.AddChild(v5)

   553 		

   554 		r.cache.AddVariant(raptor_data.Variant("A"))

   555 		r.cache.AddVariant(raptor_data.Variant("B"))

   556 		r.cache.AddVariant(raptor_data.Variant("C"))

   557 		r.cache.AddVariant(raptor_data.Variant("D"))

   558 		r.cache.AddVariant(raptor_data.Variant("E"))

   559 		r.cache.AddVariant(raptor_data.Variant("F"))

   560 		r.cache.AddVariant(raptor_data.Variant("G"))

   561 		r.cache.AddVariant(raptor_data.Variant("H"))

   562 		r.cache.AddVariant(raptor_data.Variant("I"))

   563 		r.cache.AddVariant(raptor_data.Variant("J"))

   564 		r.cache.AddVariant(raptor_data.Variant("K"))

   565 		r.cache.AddVariant(raptor_data.Variant("L"))

   566 		

   567 		r.cache.AddVariant(raptor_data.Variant("V"))

   568 		

   569 		# <alias name="X" meaning="A.B.C.D.E.F.G.H/>

   570 		alias = raptor_data.Alias("X")

   571 		alias.SetProperty("meaning", "A.B.C.D.E.F.G.H")

   572 		r.cache.AddAlias(alias)

   573 

   574 		r.cache.AddVariant(raptor_data.Variant("Y"))

   575 		r.cache.AddVariant(raptor_data.Variant("Z"))

   576 	

   577 		units = raptor_data.GetBuildUnits(["g1.Y", "g1.Z"], r.cache, r)

   578 		

   579 		# <group name="g1">

   580 		#   <groupRef ref="g2" mod="A.B"/>    g2.A.B

   581 		#   <groupRef ref="g2" mod="C.D"/>    g2.C.D

   582 		# </group>

   583 		# <group name="g2">

   584 		#   <varRef ref="V" mod="E.F"/>       V.E.F

   585 		#   <varRef ref="V" mod="G.H"/>       V.G.H

   586 		#   <aliasRef ref="X" mod="I.J"/>     X.I.J

   587 		#   <aliasRef ref="X" mod="K.L"/>     X.K.L

   588 		# </group>

   589 		# <alias name="X" meaning="A.B.C.D.E.F.G.H/>

   590 		#

   591 		expected = [ "VEFABY", "VGHABY", "ABCDEFGHIJABY", "ABCDEFGHKLABY",

   592 				     "VEFCDY", "VGHCDY", "ABCDEFGHIJCDY", "ABCDEFGHKLCDY",

   593 		             "VEFABZ", "VGHABZ", "ABCDEFGHIJABZ", "ABCDEFGHKLABZ",

   594 				     "VEFCDZ", "VGHCDZ", "ABCDEFGHIJCDZ", "ABCDEFGHKLCDZ" ]

   595 		

   596 		self.failUnlessEqual(len(units), len(expected))

   597 		

   598 		for u in units:

   599 			vars = "".join([v.name for v in u.variants])

   600 			self.failUnless(vars in expected, vars + " was not expected")

   601 			expected.remove(vars)

   602 		

   603 		self.failUnless(len(expected) == 0, str(expected) + " not found")

   604 		

   605 # run all the tests

   606 

   607 from raptor_tests import SmokeTest

   608 

   609 def run():

   610 	t = SmokeTest()

   611 	t.id = "999"

   612 	t.name = "raptor_data_unit"

   613 

   614 	tests = unittest.makeSuite(TestRaptorData)

   615 	result = unittest.TextTestRunner(verbosity=2).run(tests)

   616 

   617 	if result.wasSuccessful():

   618 		t.result = SmokeTest.PASS

   619 	else:

   620 		t.result = SmokeTest.FAIL

   621 

   622 	return t