def test_GLOB(self): """ test Syntax.GLOB """ #test case of one file files = Syntax.GLOB("./*.cpp") self.assertEqual(files, "hello.cpp") #test case of more files and those files must in the lexicographical order module = self._module Function.RunCommand("touch %s/hello1.h" % module.root_path, ignore_stderr_when_ok = True) Function.RunCommand("touch %s/hello2.h" % module.root_path, ignore_stderr_when_ok = True) Function.RunCommand("touch %s/hello3.h" % module.root_path, ignore_stderr_when_ok = True) Function.RunCommand("touch %s/hello10.h" % module.root_path, ignore_stderr_when_ok = True) files = Syntax.GLOB("./*.h") self.assertEqual(files, "hello.h hello1.h hello10.h hello2.h hello3.h") #test case of files not in self module Function.RunCommand("touch %s/../README" % module.root_path, ignore_stderr_when_ok = True) flag = False try: Syntax.GLOB("../README") except Syntax.NotInSelfModuleError as e: flag = True self.assertTrue(flag) #test case of no such files flag = False try: Syntax.GLOB("./just_test.cpp") except Syntax.BrocArgumentIllegalError as e: flag = True self.assertTrue(flag)
def test_ParseNameAndArgs(self): """ test Syntax._ParseNameAndArgs """ #only has name files, args = Syntax._ParseNameAndArgs("broc") self.assertEqual(files, ["broc"]) self.assertEqual(args, []) #more args inctag = Syntax.Include("./ ./include") cpptag = Syntax.CppFlags("-DDEBUG", "-DBROC") ctag = Syntax.CFlags("-O2", "-O0") cxxtag = Syntax.CxxFlags("-Werror", "-Wall") files, args = Syntax._ParseNameAndArgs("./*.cpp", inctag) self.assertEqual(files, ["./*.cpp"]) self.assertEqual(args, [inctag]) files, args = Syntax._ParseNameAndArgs("./*.cpp", inctag, cpptag) self.assertEqual(files, ["./*.cpp"]) self.assertEqual(args, [inctag, cpptag]) files, args = Syntax._ParseNameAndArgs("./*.cpp", cpptag, ctag) self.assertEqual(files, ["./*.cpp"]) self.assertEqual(args, [cpptag, ctag]) files, args = Syntax._ParseNameAndArgs("./*.cpp", "./*.c", cxxtag, ctag) self.assertEqual(files, ["./*.cpp", "./*.c"]) self.assertEqual(args, [cxxtag, ctag]) files, args = Syntax._ParseNameAndArgs("./*.cpp", "./*.c", inctag, cpptag, cxxtag, ctag) self.assertEqual(files, ["./*.cpp", "./*.c"]) self.assertEqual(args, [inctag, cpptag, cxxtag, ctag])
def test_Libs(self): """ test Syntax.Libs """ #one lib in arg tag = Syntax.Libs("$OUT_ROOT/baidu/broc/lib/libbroc.a") self.assertTrue("broc_out/baidu/broc/lib/libbroc.a" in tag.V()) #more than one libs in args flag = True tag = Syntax.Libs("$OUT_ROOT/baidu/broc/lib/libbroc.a", \ "$OUT_ROOT/protobuf/lib/libprotobuf.a", \ "$OUT_ROOT/ccode/lib/libccode.a" \ "$OUT_ROOT/dict/lib/libdict.a") lib_list = ["broc_out/baidu/broc/lib/libbroc.a", \ "broc_out/protobuf/lib/libprotobuf.a", \ "broc_out/ccode/lib/libccode.a" \ "broc_out/dict/lib/libdict.a"] for lib in lib_list: if lib not in tag.V(): flag = False self.assertTrue(flag) #arg not start with $OUT_ROOT flag = False try: tag = Syntax.Libs("baidu/broc/lib/libbroc.a") except Syntax.BrocArgumentIllegalError as ex: flag = True self.assertTrue(flag)
def test_INCLUDE(self): """ test Syntax.INCLUDE """ Environment.SetCurrent(self._env) # arg starts with $WORKSPACE Syntax.INCLUDE("$WORKSPACE/baidu/broc") self.assertTrue("baidu/broc" in self._env.IncludePaths().V()) self.assertTrue("baidu/agile" not in self._env.IncludePaths().V()) # arg starts with broc_out Syntax.INCLUDE("broc_out/baidu/broc") self.assertTrue("broc_out/baidu/broc" in self._env.IncludePaths().V()) self.assertTrue("broc_out/baidu/agile" not in self._env.IncludePaths().V()) # arg is abs path Syntax.INCLUDE("/opt/include") self.assertTrue("/opt/include" in self._env.IncludePaths().V()) self.assertTrue("/home/include" not in self._env.IncludePaths().V()) # arg in self module Syntax.INCLUDE("./include") incpath = os.path.normpath(os.path.join(self._module.workspace, \ self._module.module_cvspath, "include")) self.assertTrue(incpath in self._env.IncludePaths().V())
def test_Include(self): """ test Syntax.Include """ Environment.SetCurrent(self._env) # arg starts with $WORKSPACE tag = Syntax.Include("$WORKSPACE/baidu/broc") self.assertTrue("baidu/broc" in tag.V()) self.assertTrue("baidu/agile" not in tag.V()) # arg starts with broc_out tag = Syntax.Include("broc_out/baidu/broc") self.assertTrue("broc_out/baidu/broc" in tag.V()) self.assertTrue("broc_out/baidu/agile" not in tag.V()) # arg is abs path tag = Syntax.Include("/opt/include") self.assertTrue("/opt/include" in tag.V()) self.assertTrue("/home/include" not in tag.V()) # arg in self module tag = Syntax.Include("./include") #incpath = os.path.normpath(os.path.join(self._module.workspace, \ # self._module.module_cvspath, "include")) incpath=os.path.join(self._module.module_cvspath, 'include') self.assertTrue(incpath in tag.V())
def test_PUBLISH(self): """ test Syntax.PUBLISH """ #src has one file Syntax.PUBLISH("conf/a.conf", "$OUT/conf") dst = os.path.join(self._env.OutputPath(), "conf") src = os.path.join(self._module.module_cvspath, "conf/a.conf") self.assertTrue("mkdir -p %s && cp -rf %s %s" % (dst, src, dst)) #src has more files Syntax.PUBLISH("conf/a1.conf conf/a2.conf", "$OUT/conf") dst = os.path.join(self._env.OutputPath(), "conf") for s in "conf/a1.conf conf/a2.conf".split(' '): src = os.path.join(self._module.module_cvspath, s) self.assertTrue("mkdir -p %s && cp -rf %s %s" % (dst, src, dst)) #out_dir doesn't start with $OUT flag = False try: Syntax.PUBLISH("conf/a3.conf", "conf") except Syntax.BrocArgumentIllegalError as e: flag = True self.assertTrue(flag) #src doesn't in self module flag = False try: Syntax.PUBLISH("../../conf/a3.conf", "$OUT/conf") except Syntax.NotInSelfModuleError as e: flag = True self.assertTrue(flag)
def test_CPPFLAGS(self): """ test Syntax.CPPFLAGS """ #test case of debug mode self._env._build_mode = 'debug' Syntax.CPPFLAGS("-g -Wall", "-g -O2") self.assertTrue("-g -Wall" in self._env._g_cppflags.V() \ and "-g -O2" not in self._env._g_cppflags.V()) #test case of muti CPPFLAGS Syntax.CPPFLAGS("-W -Wshadow", "-g -O2") Syntax.CPPFLAGS("-finline-functions", "-g -O2") self.assertTrue("-g -Wall" in self._env._g_cppflags.V() \ and "-g -O2" not in self._env._g_cppflags.V()) self.assertTrue("-W -Wshadow" in self._env._g_cppflags.V() \ and "-g -O2" not in self._env._g_cppflags.V()) self.assertTrue("-finline-functions" in self._env._g_cppflags.V() \ and "-g -O2" not in self._env._g_cppflags.V()) #reset g_cppflags self._env._g_cppflags = SyntaxTag.TagCPPFLAGS() #test case of release mode self._env._build_mode = 'release' Syntax.CPPFLAGS("-g -Wall", "-g -O2") self.assertTrue("-g -O2" in self._env._g_cppflags.V() \ and "-g -Wall" not in self._env._g_cppflags.V())
def test_PROTO_LIBRARY(self): """ test Syntax.PROTO_LIBRARY """ #make a new proto file Function.RunCommand("touch %s/hello.proto" % self._module.root_path, \ ignore_stderr_when_ok = True) #set local flags cpptags = Syntax.CppFlags("-DDEBUG_LOCAL", "-DRELEASE_LOCAL") cxxtags = Syntax.CxxFlags("-Wwrite-strings", "-Wswitch") incflag = Syntax.Include("") libflag = Syntax.Libs("$OUT_ROOT/baidu/broc/output/lib/libhello.a") now_dir = os.getcwd() os.chdir(self._module.workspace) protos = Syntax.PROTO_LIBRARY("hello", "*.proto", cpptags, cxxtags, incflag, libflag) proto_library = self._env.Targets()[0] src = proto_library.tag_sources.V()[0] proto_library.Action() os.chdir(now_dir) #check result proto_cmd = """mkdir -p broc_out/baidu/broc && protoc \ --cpp_out=broc_out/baidu/broc -I=baidu/broc \ -I=. baidu/broc/*.proto\n""" self.assertEqual(' '.join(protos.__str__().split()), ' '.join(proto_cmd.split())) self.assertEqual(src.cppflags, ["-DDEBUG_LOCAL"]) self.assertEqual(src.cxxflags, ["-Wwrite-strings"]) self.assertEqual(src.includes, [".", "broc_out", 'baidu/broc', u'broc_out/baidu/broc']) self.assertEqual(src.infile, "broc_out/baidu/broc/hello.pb.cc") self.assertEqual(proto_library.tag_libs.V(), \ ["broc_out/baidu/broc/output/lib/libhello.a"])
def DoPlanish(self, download_flag=True): """ choose one version from multiple version of module Args: download_flag : whether download the code of module, if it is set True download code, and vice versa Returns: return True if planish successfully, otherwise return False """ self.logger.LevPrint('MSG', 'Analyzing dependency ...') # create dependent tree broc_loader = Syntax.BrocLoader() try: broc_loader.LoadBROC() except BaseException as err: self.logger.LevPrint('ERROR', '%s' % err) return False if len(broc_loader.LackBrocModules()) != 0: self.logger.LevPrint('ERROR', "Can't find BROC in following module(s):") for cvspath in broc_loader.LackBrocModules(): self.logger.LevPrint('ERROR', "\t%s" % cvspath) return False # check graph has circles (ret, msg) = BrocTree.BrocTree().HasCircle() if ret: self.logger.LevPrint( "ERROR", "There is a circle in dependency graph\nCircle is [%s]" % msg, False) return False nodes = Syntax.BrocLoader().AllNodes() for k, nodes in nodes.iteritems(): for node in nodes: # jump main module itself if node.module.is_main: continue if node.module.module_cvspath not in self.planished_nodes: self.planished_nodes[node.module.module_cvspath] = node else: reserved_node = self.planished_nodes[ node.module.module_cvspath] ret = self._filter_dep_nodes(reserved_node, node) if ret == 1: self.planished_nodes[node.module.module_cvspath] = node if ret == -1: self.logger.LevPrint("ERROR", "dependent conficts(%s PK %s)" % \ (reserved_node.module.origin_config, \ node.module.origin_config), False) return False self.logger.LevPrint('MSG', 'Analyzing dependency success') # dump planished dependency tree self.Dump() if download_flag: return self._download_modules() else: return True
def test_CONVERT_OUT(self): """ test Syntax.CONVERT_OUT """ self.assertEqual("broc_out/baidu/broc/hello.h", Syntax.CONVERT_OUT("./hello.h")) #test CONVERT_OUT can raise Syntax.NotInSelfModuleError or not flag = False try: Syntax.CONVERT_OUT("../hello.h") except Syntax.NotInSelfModuleError as er: flag = True self.assertTrue(flag)
def test_CppFlags(self): """ test Syntax.CppFlags """ #test case of debug mode self._env._build_mode = 'debug' tag = Syntax.CppFlags("-g -Wall", "-g -O2") self.assertTrue("-g -Wall" in tag._v and "-g -O2" not in tag.V()) #test case of release mode self._env._build_mode = 'release' tag2 = Syntax.CppFlags("-g -Wall", "-g -O2") self.assertTrue("-g -O2" in tag2.V() and "-g -Wall" not in tag2.V())
def test_singleton(self): """ Test singleton interface """ logger = Log.Log() repo_domain = 'https://github.com' postfix = ['trunk', 'BRANCH', 'PD_BL'] root = PlanishUtil.CreateBrocModuleFromDir("..", repo_domain, postfix[1], postfix[2], logger) loader1 = Syntax.BrocLoader() loader2 = Syntax.BrocLoader() self.assertEqual(loader1.Id(), loader2.Id())
def test_load_broc(self): """ """ logger = Log.Log() repo_domain = 'https://github.com' postfix = ['trunk', 'BRANCH', 'PD_BL'] root = PlanishUtil.CreateBrocModuleFromDir("..", repo_domain, postfix[1], postfix[2], logger) node = BrocTree.BrocNode(root, None, True) Syntax.BrocLoader().SetRoot(node) Syntax.BrocLoader().LoadBROC() if Syntax.BrocLoader().LackBrocModules(): print(Syntax.BrocLoader().LackBrocModules())
def test_UTArgs(self): """ test Syntax.UTArgs """ tag = Syntax.UTArgs("--conf=a.conf --log=a.log") self.assertTrue("--conf=a.conf" in tag.V()) self.assertTrue("--log=a.log" in tag.V()) self.assertTrue("--help" not in tag.V())
def test_LDFlags(self): """ test Syntax.LDFlags """ #test case of debug mode Environment.SetCurrent(self._env) self._env._build_mode = 'debug' tag = Syntax.LDFlags("-lpthread -lcrypto", "-lprotobuf -lpthread") self.assertTrue("-lpthread -lcrypto" in tag.V() \ and "-lprotobuf -lpthread" not in tag.V()) #reset g_linkflags self._env._g_linkflags = SyntaxTag.TagLDFLAGS() #test case of release mode self._env._build_mode = 'release' tag = Syntax.LDFlags("-lpthread -lcrypto", "-lprotobuf -lpthread") self.assertTrue("-lprotobuf -lpthread" in tag.V() \ and "-lpthread -lcrypto" not in tag.V())
def test_Sources(self): """ test Syntax.Sources """ #get local flags tag cpptags = Syntax.CppFlags("-DDEBUG_LOCAL", "-DRELEASE_LOCAL") cxxtags = Syntax.CxxFlags("-Wwrite-strings", "-Wswitch") ctags = Syntax.CFlags("-Wwrite-strings", "-Wswitch") incflags = Syntax.Include("$WORKSPACE/baidu/bcloud") tag = Syntax.Sources("hello.cpp", cpptags, cxxtags, ctags, incflags) src = tag.V()[0] Source.Source.Action(src) self.assertEqual(src.cppflags, ["-DDEBUG_LOCAL"]) self.assertEqual(src.cxxflags, ["-Wwrite-strings"]) self.assertEqual(src.cflags, ["-Wwrite-strings"]) self.assertEqual(src.includes, [".", "broc_out", "baidu/bcloud"]) self.assertEqual(src.infile, "baidu/broc/hello.cpp")
def test_STATIC_LIBRARY(self): """ test Syntax.STATIC_LIBRARY """ #set local flags tag libs = Syntax.Libs("$OUT_ROOT/baidu/broc/libhello.a") cpptags = Syntax.CppFlags("-DBROC", "-DRELEASE") src = Syntax.Sources("hello.cpp") #an error name of application flag = False try: Syntax.STATIC_LIBRARY("^*^&*!*$^", src) except Syntax.BrocArgumentIllegalError as ex: flag = True self.assertTrue(flag) #an error args of application flag = False try: Syntax.STATIC_LIBRARY("hello", src, cpptags) except Syntax.BrocArgumentIllegalError as ex: flag = True self.assertTrue(flag) #Libs Syntax.STATIC_LIBRARY("hello", src, libs) library = self._env.Targets()[0] library.Action() self.assertEqual(library.tag_libs.V(), ["broc_out/baidu/broc/libhello.a"]) #two samename target flag = False try: Syntax.STATIC_LIBRARY("hello", src) except Syntax.BrocArgumentIllegalError as ex: flag = True self.assertTrue(flag) #library DoCopy Function.RunCommand("mkdir -p %s/lib" % self._module.root_path, \ ignore_stderr_when_ok = True) Function.RunCommand("touch %s/lib/libhello1.a" % self._module.root_path, \ ignore_stderr_when_ok = True) now_dir = os.getcwd() os.chdir(self._module.workspace) Syntax.STATIC_LIBRARY("hello1") lib_paths = os.path.join(self._module.workspace, "broc_out", \ self._module.module_cvspath, "output/lib/libhello1.a") self.assertTrue(os.path.exists(lib_paths)) os.chdir(now_dir)
def __init__(self, main_module, repo_domain, logger, postfix): """ Args: main_module : the BrocModule_pb2.Module object representing the main module repo_domain : the domain name of repository logger : the log facility object postfix : the list of postfix [postfix_branche, postfix_tag] """ Syntax.BrocLoader().SetRoot(BrocTree.BrocNode(main_module, None, True)) self.logger = logger self.planished_nodes = dict() # module cvspath --> BrocNode
def test_GIT_URL(self): """ test Syntax. """ self.assertEqual(self._module.url, Syntax.GIT_URL())
def test_GIT_PATH(self): """ test Syntax.GIT_PATH """ self.assertEqual(self._module.root_path, Syntax.GIT_PATH())
def test_SVN_LAST_CHANGED_REV(self): """ test Syntax.LAST_CHANGED_REV """ self.assertEqual(self._module.last_changed_rev, Syntax.SVN_LAST_CHANGED_REV())
def test_SVN_REVISION(self): """ test Syntax.SVN_REVISION """ self.assertEqual(self._module.revision, Syntax.SVN_REVISION())
def test_SVN_URL(self): """ test Syntax.SVN_URL """ self.assertEqual(self._module.url, Syntax.SVN_URL())
def test_GIT_BRANCH(self): """ test Syntax.GIT_BRANCH """ self.assertEqual(self._module.br_name, Syntax.GIT_BRANCH())
def test_COMPILER_PATH(self): """ test Syntax.COMPILER_PATH """ Syntax.COMPILER_PATH('/usr/bin/') self.assertEqual('/usr/bin/', self._env.CompilerDir())
def test_UT_APPLICATION(self): """ test Syntax.UT_APPLICATION """ #set local flags tag ldflag = Syntax.LDFlags("-lpthread", "-lcrypto") libs = Syntax.Libs("$OUT_ROOT/baidu/broc/libhello.a") cpptags = Syntax.CppFlags("-DBROC", "-DRELEASE") utargs = Syntax.UTArgs("--log=a.log --conf=a.conf") #set global flags Syntax.LDFLAGS("-lmcpack", "-lrt") src = Syntax.Sources("hello.cpp") #an error name of utapplication flag = False try: Syntax.UT_APPLICATION("^*^&*!*$^", src) except Syntax.BrocArgumentIllegalError as ex: flag = True self.assertTrue(flag) #an error args of utapplication flag = False try: Syntax.UT_APPLICATION("hello", src, cpptags) except Syntax.BrocArgumentIllegalError as ex: flag = True self.assertTrue(flag) #global ldflags Syntax.UT_APPLICATION("hello", src) utapp = self._env.Targets()[0] utapp.Action() self.assertEqual(utapp.link_options, ["-lmcpack"]) self.assertEqual(utapp.tag_libs.V(), []) self.assertEqual(utapp._ut_args, []) #two samename target flag = False try: Syntax.UT_APPLICATION("hello", src) except Syntax.BrocArgumentIllegalError as ex: flag = True self.assertTrue(flag) #local ldflags Syntax.UT_APPLICATION("hello2", src, ldflag) utapp = self._env.Targets()[1] utapp.Action() self.assertEqual(utapp.link_options, ["-lpthread"]) self.assertEqual(utapp.tag_libs.V(), []) self.assertEqual(utapp._ut_args, []) #Libs Syntax.UT_APPLICATION("hello3", src, ldflag, libs) utapp = self._env.Targets()[2] utapp.Action() self.assertEqual(utapp.link_options, ["-lpthread"]) self.assertEqual(utapp.tag_libs.V(), ["broc_out/baidu/broc/libhello.a"]) self.assertEqual(utapp._ut_args, []) #UTArgs Syntax.UT_APPLICATION("hello4", src, ldflag, libs, utargs) utapp = self._env.Targets()[3] utapp.Action() self.assertEqual(utapp.link_options, ["-lpthread"]) self.assertEqual(utapp.tag_libs.V(), ["broc_out/baidu/broc/libhello.a"]) self.assertEqual(utapp._ut_args, ["--log=a.log", "--conf=a.conf"])
def test_GIT_TAG(self): """ test Syntax.GIT_TAG """ self.assertEqual(self._module.tag_name, Syntax.GIT_TAG())
def test_CreateSources(self): """ test Syntax._CreateSource """ #init env global flags self._env._g_cppflags = SyntaxTag.TagCPPFLAGS() self._env._g_cflags = SyntaxTag.TagCFLAGS() self._env._g_cxxflags = SyntaxTag.TagCXXFLAGS() self._env._g_incflags = SyntaxTag.TagINCLUDE() self._env._g_incflags.AddV('. broc_out') self._env._build_mode = 'debug' #set local flags tag cpptags = Syntax.CppFlags("-DDEBUG_LOCAL", "-DRELEASE_LOCAL") cxxtags = Syntax.CxxFlags("-Wwrite-strings", "-Wswitch") ctags = Syntax.CFlags("-Wwrite-strings", "-Wswitch") incflag = Syntax.Include("$WORKSPACE/baidu/bcloud") #no flags src = Syntax._CreateSources("baidu/broc/hello.cpp", []) Source.Source.Action(src) self.assertEqual(src.cppflags, []) self.assertEqual(src.cxxflags, []) self.assertEqual(src.cflags, []) self.assertEqual(src.includes, [".", "broc_out"]) self.assertEqual(src.infile, "baidu/broc/hello.cpp") #only local flags src = Syntax._CreateSources("baidu/broc/hello.cpp", \ [cpptags, cxxtags, ctags, incflag]) Source.Source.Action(src) self.assertEqual(src.cppflags, ["-DDEBUG_LOCAL"]) self.assertEqual(src.cxxflags, ["-Wwrite-strings"]) self.assertEqual(src.cflags, ["-Wwrite-strings"]) self.assertEqual(src.includes, [".", "broc_out", "baidu/bcloud"]) #only global flags Syntax.CFLAGS("-Werror -O2", "-W") Syntax.CXXFLAGS("-Werror -O2", "-W") Syntax.CPPFLAGS("-DDEBUG", "-DRELEASE") Syntax.INCLUDE("$WORKSPACE/baidu/broc") src = Syntax._CreateSources("baidu/broc/hello.cpp", []) Source.Source.Action(src) self.assertEqual(src.cppflags, ["-DDEBUG"]) self.assertEqual(src.cxxflags, ["-Werror -O2"]) self.assertEqual(src.cflags, ["-Werror -O2"]) self.assertEqual(src.includes, [".", "broc_out", "baidu/broc"]) self.assertEqual(src.infile, "baidu/broc/hello.cpp") #more value of global flags Syntax.CFLAGS("-Wall", "-Wall") Syntax.CXXFLAGS("-Wall", "-Wall") Syntax.CPPFLAGS("-DBROC", "-DBROC") src = Syntax._CreateSources("baidu/broc/hello.cpp", []) Source.Source.Action(src) self.assertEqual(src.cppflags, ["-DDEBUG", "-DBROC"]) self.assertEqual(src.cxxflags, ["-Werror -O2", "-Wall"]) self.assertEqual(src.cflags, ["-Werror -O2", "-Wall"]) self.assertEqual(src.includes, [".", "broc_out", "baidu/broc"]) self.assertEqual(src.infile, "baidu/broc/hello.cpp") #local flags cover golbal flags src = Syntax._CreateSources("baidu/broc/hello.cpp", [cpptags, cxxtags]) Source.Source.Action(src) self.assertEqual(src.cppflags, ["-DDEBUG_LOCAL"]) self.assertEqual(src.cxxflags, ["-Wwrite-strings"]) self.assertEqual(src.cflags, ["-Werror -O2", "-Wall"]) self.assertEqual(src.includes, [".", "broc_out", "baidu/broc"]) self.assertEqual(src.infile, "baidu/broc/hello.cpp")