def test_windows_case_insensitive(): # Append and define operation over the same variable in Windows preserve order env = Environment() env.define("MyVar", "MyValueA") env.define("MYVAR", "MyValueB") env.define("MyVar1", "MyValue1A") env.append("MYVAR1", "MyValue1B") folder = temp_folder() display_bat = textwrap.dedent("""\ @echo off echo MyVar=%MyVar%!! echo MyVar1=%MyVar1%!! """) with chdir(folder): env.save_bat("test.bat", generate_deactivate=True) save("display.bat", display_bat) cmd = "test.bat && display.bat && deactivate_test.bat && display.bat" out, _ = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True).communicate() out = out.decode() assert "MyVar=MyValueB!!" in out assert "MyVar=!!" in out assert "MyVar1=MyValue1A MyValue1B!!" in out assert "MyVar1=!!" in out
def env(): # Append and define operation over the same variable in Windows preserve order env = Environment() env.define("MyVar", "MyValueA") env.define("MYVAR", "MyValueB") env.define("MyVar1", "MyValue1A") env.append("MYVAR1", "MyValue1B") env.define("MyVar2", "MyNewValue2") env = env.vars(ConanFileMock()) env._subsystem = WINDOWS return env
def environment(self): flags = GnuDepsFlags(self._conanfile, self.cpp_info) # cpp_flags cpp_flags = [] cpp_flags.extend(flags.include_paths) cpp_flags.extend(flags.defines) # Ldflags ldflags = flags.sharedlinkflags ldflags.extend(flags.exelinkflags) ldflags.extend(flags.frameworks) ldflags.extend(flags.framework_paths) ldflags.extend(flags.lib_paths) # FIXME: Previously we had an argument "include_rpath_flags" defaulted to False ldflags.extend(flags.rpath_flags) # cflags cflags = flags.cflags cxxflags = flags.cxxflags srf = flags.sysroot if srf: cflags.append(srf) cxxflags.append(srf) ldflags.append(srf) env = Environment() env.append("CPPFLAGS", cpp_flags) env.append("LIBS", flags.libs) env.append("LDFLAGS", ldflags) env.append("CXXFLAGS", cxxflags) env.append("CFLAGS", cflags) return env
def env(): env = Environment() env.define("MyVar", "MyValue") env.define("MyVar1", "MyValue1") env.append("MyVar2", "MyValue2") env.prepend("MyVar3", "MyValue3") env.unset("MyVar4") env.define("MyVar5", "MyValue5 With Space5=More Space5;:More") env.append("MyVar6", "MyValue6") # Append, but previous not existing env.define_path("MyPath1", "/Some/Path1/") env.append_path("MyPath2", ["/Some/Path2/", "/Other/Path2/"]) env.prepend_path("MyPath3", "/Some/Path3/") env.unset("MyPath4") return env
def environment(self): env = Environment() # defines if self.ndebug: self.defines.append(self.ndebug) if self.gcc_cxx11_abi: self.defines.append(self.gcc_cxx11_abi) if self.libcxx: self.cxxflags.append(self.libcxx) if self.cppstd: self.cxxflags.append(self.cppstd) if self.arch_flag: self.cxxflags.append(self.arch_flag) self.cflags.append(self.arch_flag) self.ldflags.append(self.arch_flag) if self.build_type_flags: self.cxxflags.extend(self.build_type_flags) self.cflags.extend(self.build_type_flags) if self.fpic: self.cxxflags.append("-fPIC") self.cflags.append("-fPIC") env.append("CPPFLAGS", ["-D{}".format(d) for d in self.defines]) env.append("CXXFLAGS", self.cxxflags) env.append("CFLAGS", self.cflags) env.append("LDFLAGS", self.ldflags) return env
def environment(self): # TODO: Seems we want to make this uniform, equal to other generators if self._environment is None: flags = GnuDepsFlags(self._conanfile, self._get_cpp_info()) # cpp_flags cpp_flags = [] cpp_flags.extend(flags.include_paths) cpp_flags.extend(flags.defines) # Ldflags ldflags = flags.sharedlinkflags ldflags.extend(flags.exelinkflags) ldflags.extend(flags.frameworks) ldflags.extend(flags.framework_paths) ldflags.extend(flags.lib_paths) # cflags cflags = flags.cflags cxxflags = flags.cxxflags srf = flags.sysroot if srf: cflags.append(srf) cxxflags.append(srf) ldflags.append(srf) env = Environment() env.append("CPPFLAGS", cpp_flags) env.append("LIBS", flags.libs) env.append("LDFLAGS", ldflags) env.append("CXXFLAGS", cxxflags) env.append("CFLAGS", cflags) self._environment = env return self._environment
def test_dict_access(): env = Environment() env.append("MyVar", "MyValue", separator="@") ret = env.vars(ConanFileMock()).items() assert dict(ret) == {"MyVar": "MyValue"} env = Environment() env.prepend("MyVar", "MyValue", separator="@") env_vars = env.vars(ConanFileMock()) assert dict(env_vars.items()) == {"MyVar": "MyValue"} assert env_vars["MyVar"] == "MyValue" env2 = Environment() env2.define("MyVar", "MyValue2") env.compose_env(env2) env_vars = env.vars(ConanFileMock()) assert dict(env_vars.items()) == {"MyVar": "MyValue@MyValue2"} with pytest.raises(KeyError): _ = env_vars["Missing"] # With previous values in the environment env = Environment() env.prepend("MyVar", "MyValue", separator="@") old_env = dict(os.environ) os.environ.update({"MyVar": "PreviousValue"}) env_vars = env.vars(ConanFileMock()) try: assert env_vars["MyVar"] == "MyValue@PreviousValue" finally: os.environ.clear() os.environ.update(old_env) env = Environment() env.append_path("MyVar", "MyValue") old_env = dict(os.environ) os.environ.update({"MyVar": "PreviousValue"}) env_vars = env.vars(ConanFileMock()) try: assert env_vars["MyVar"] == "PreviousValue{}MyValue".format(os.pathsep) with env_vars.apply(): assert os.getenv("MyVar") == "PreviousValue{}MyValue".format( os.pathsep) finally: os.environ.clear() os.environ.update(old_env) assert list(env_vars.keys()) == ["MyVar"] assert dict(env_vars.items()) == {"MyVar": "MyValue"}
def test_public_access(): env = Environment(ConanFileMock()) env.define("MyVar", "MyValue") env.append("MyVar", "MyValue2") env.define_path("MyPath", "c:/path/to/something") env.append_path("MyPath", "D:/Otherpath") for name, values in env.items(): if name == "MyVar": assert values == "MyValue MyValue2" if name == "MyPath": assert values == "c:/path/to/something{}D:/Otherpath".format( os.pathsep) env.remove("MyPath", "D:/Otherpath") assert env.get("MyPath") == "c:/path/to/something"
def test_env_win_bash(): conanfile = ConanFileMock() conanfile.win_bash = True conanfile.conf = {"tools.microsoft.bash:subsystem": "msys2"} folder = temp_folder() env = Environment(conanfile) env.define("MyVar", "MyValue") env.define_path("MyPath", "c:/path/to/something") env.append("MyPath", "D:/Otherpath") sh_path = os.path.join(folder, "foo.sh") with mock.patch("platform.system", side_effect=lambda: "Windows"): env.save_sh(sh_path) with open(sh_path) as f: content = f.read() assert 'MyVar="MyValue"' in content assert 'MyPath="/c/path/to/something:/d/otherpath"' in content
def test_env_win_bash(): conanfile = ConanFileMock() conanfile.settings_build = MockSettings({"os": "Windows"}) conanfile.win_bash = True conanfile.conf.define("tools.microsoft.bash:subsystem", "msys2") folder = temp_folder() conanfile.folders.generators = folder env = Environment() env.define("MyVar", "MyValue") env.define_path("MyPath", "c:/path/to/something") env.append("MyPath", "D:/Otherpath") env_vars = env.vars(conanfile) env_vars.save_script("foo") content = open(os.path.join(folder, "foo.sh")).read() assert 'MyVar="MyValue"' in content # Note the unit letter is lowercase assert 'MyPath="/c/path/to/something:/d/otherpath"' in content
def test_define_append(): env = Environment() env.define("MyVar", "MyValue") env.append("MyVar", "MyValue1") env.append("MyVar", ["MyValue2", "MyValue3"]) assert env.get("MyVar") == "MyValue MyValue1 MyValue2 MyValue3" env = Environment() env.append("MyVar", "MyValue") env.append("MyVar", "MyValue1") env.define("MyVar", "MyValue2") assert env.get("MyVar") == "MyValue2"
def environment(self): env = Environment() # defines if self.ndebug: self.defines.append(self.ndebug) if self.gcc_cxx11_abi: self.defines.append(self.gcc_cxx11_abi) if self.libcxx: self.cxxflags.append(self.libcxx) if self.cppstd: self.cxxflags.append(self.cppstd) if self.arch_flag: self.cxxflags.append(self.arch_flag) self.cflags.append(self.arch_flag) self.ldflags.append(self.arch_flag) if self.build_type_flags: self.cxxflags.extend(self.build_type_flags) self.cflags.extend(self.build_type_flags) if self.build_type_link_flags: self.ldflags.extend(self.build_type_link_flags) if self.fpic: self.cxxflags.append("-fPIC") self.cflags.append("-fPIC") if self.msvc_runtime_flag: self.cxxflags.append(self.msvc_runtime_flag) self.cflags.append(self.msvc_runtime_flag) if is_msvc(self._conanfile): env.define("CXX", "cl") env.define("CC", "cl") # FIXME: Previously these flags where checked if already present at env 'CFLAGS', 'CXXFLAGS' # and 'self.cxxflags', 'self.cflags' before adding them for f in list(filter(bool, [self.apple_isysroot_flag, self.apple_arch_flag, self.apple_min_version_flag])): self.cxxflags.append(f) self.cflags.append(f) self.ldflags.append(f) env.append("CPPFLAGS", ["-D{}".format(d) for d in self.defines]) env.append("CXXFLAGS", self.cxxflags) env.append("CFLAGS", self.cflags) env.append("LDFLAGS", self.ldflags) return env
def test_compose(): env = Environment() env.define("MyVar", "MyValue") env.define("MyVar2", "MyValue2") env.define("MyVar3", "MyValue3") env.define("MyVar4", "MyValue4") env.unset("MyVar5") env2 = Environment() env2.define("MyVar", "MyNewValue") env2.append("MyVar2", "MyNewValue2") env2.prepend("MyVar3", "MyNewValue3") env2.unset("MyVar4") env2.define("MyVar5", "MyNewValue5") env.compose(env2) assert env.value("MyVar") == "MyValue" assert env.value("MyVar2") == 'MyValue2' assert env.value("MyVar3") == 'MyValue3' assert env.value("MyVar4") == "MyValue4" assert env.value("MyVar5") == ''
def environment(self): # cpp_flags cpp_flags = [] include_paths = ['-I"%s"' % p for p in self.include_paths] cpp_flags.extend(include_paths) cpp_flags.extend(["-D%s" % define for define in self.defines]) # Libs libs = ["-l%s" % library for library in self.libs] # Ldflags # TODO: Discuss, should the helper filter frameworks based on compiler? frameworks = ["-framework %s" % framework for framework in self.frameworks] frameworks_paths = ["-F %s" % framework_path for framework_path in self.framework_paths] ldflags = self.sharedlinkflags ldflags.extend(self.exelinkflags) ldflags.extend(frameworks) ldflags.extend(frameworks_paths) lib_paths = ['-L"%s"' % p for p in self.lib_paths] ldflags.extend(lib_paths) # cflags cflags = self.cflags cxxflags = self.cxxflags if self.sysroot: srf = '--sysroot={}'.format(self.sysroot) cflags.append(srf) cxxflags.append(srf) ldflags.append(srf) env = Environment() env.append("CPPFLAGS", cpp_flags) env.append("LIBS", libs) env.append("LDFLAGS", ldflags) env.append("CXXFLAGS", cxxflags) env.append("CFLAGS", cflags) return env
def environment(self): # TODO: Seems we want to make this uniform, equal to other generators if self._environment is None: flags = GnuDepsFlags(self._conanfile, self._get_cpp_info()) # cpp_flags cpp_flags = [] cpp_flags.extend(flags.include_paths) cpp_flags.extend(flags.defines) # Ldflags ldflags = flags.sharedlinkflags ldflags.extend(flags.exelinkflags) ldflags.extend(flags.frameworks) ldflags.extend(flags.framework_paths) ldflags.extend(flags.lib_paths) ## set the rpath in Macos so that the library are found in the configure step if self._conanfile.settings.get_safe("os") == "Macos": ldflags.extend(self._rpaths_flags()) # libs libs = flags.libs libs.extend(flags.system_libs) # cflags cflags = flags.cflags cxxflags = flags.cxxflags env = Environment() env.append("CPPFLAGS", cpp_flags) env.append("LIBS", libs) env.append("LDFLAGS", ldflags) env.append("CXXFLAGS", cxxflags) env.append("CFLAGS", cflags) self._environment = env return self._environment
def environment(self): env = Environment() apple_flags = [ self.apple_isysroot_flag, self.apple_arch_flag, self.apple_min_version_flag ] fpic = "-fPIC" if self.fpic else None extra_flags = self._get_extra_flags() self.cxxflags.extend([ self.libcxx, self.cppstd, self.arch_flag, fpic, self.msvc_runtime_flag, self.sysroot_flag ] + self.build_type_flags + apple_flags + extra_flags["cxxflags"]) self.cflags.extend( [self.arch_flag, fpic, self.msvc_runtime_flag, self.sysroot_flag] + self.build_type_flags + apple_flags + extra_flags["cflags"]) self.ldflags.extend([self.arch_flag, self.sysroot_flag] + self.build_type_link_flags + apple_flags + extra_flags["ldflags"]) self.defines.extend([self.ndebug, self.gcc_cxx11_abi] + extra_flags["defines"]) if is_msvc(self._conanfile): env.define("CXX", "cl") env.define("CC", "cl") env.append("CPPFLAGS", [ "-D{}".format(d) for d in self._filter_list_empty_fields(self.defines) ]) env.append("CXXFLAGS", self._filter_list_empty_fields(self.cxxflags)) env.append("CFLAGS", self._filter_list_empty_fields(self.cflags)) env.append("LDFLAGS", self._filter_list_empty_fields(self.ldflags)) env.prepend_path("PKG_CONFIG_PATH", self._conanfile.generators_folder) return env
def test_env_files(): env = Environment() env.define("MyVar", "MyValue") env.define("MyVar1", "MyValue1") env.append("MyVar2", "MyValue2") env.prepend("MyVar3", "MyValue3") env.unset("MyVar4") env.define("MyVar5", "MyValue5 With Space5=More Space5;:More") env.append("MyVar6", "MyValue6") # Append, but previous not existing env.define_path("MyPath1", "/Some/Path1/") env.append_path("MyPath2", ["/Some/Path2/", "/Other/Path2/"]) env.prepend_path("MyPath3", "/Some/Path3/") env.unset("MyPath4") folder = temp_folder() prevenv = {"MyVar1": "OldVar1", "MyVar2": "OldVar2", "MyVar3": "OldVar3", "MyVar4": "OldVar4", "MyPath1": "OldPath1", "MyPath2": "OldPath2", "MyPath3": "OldPath3", "MyPath4": "OldPath4", } display_bat = textwrap.dedent("""\ @echo off echo MyVar=%MyVar%!! echo MyVar1=%MyVar1%!! echo MyVar2=%MyVar2%!! echo MyVar3=%MyVar3%!! echo MyVar4=%MyVar4%!! echo MyVar5=%MyVar5%!! echo MyVar6=%MyVar6%!! echo MyPath1=%MyPath1%!! echo MyPath2=%MyPath2%!! echo MyPath3=%MyPath3%!! echo MyPath4=%MyPath4%!! """) display_sh = textwrap.dedent("""\ echo MyVar=$MyVar!! echo MyVar1=$MyVar1!! echo MyVar2=$MyVar2!! echo MyVar3=$MyVar3!! echo MyVar4=$MyVar4!! echo MyVar5=$MyVar5!! echo MyVar6=$MyVar6!! echo MyPath1=$MyPath1!! echo MyPath2=$MyPath2!! echo MyPath3=$MyPath3!! echo MyPath4=$MyPath4!! """) def check(cmd_): out, _ = subprocess.Popen(cmd_, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=prevenv, shell=True).communicate() out = out.decode() assert "MyVar=MyValue!!" in out assert "MyVar1=MyValue1!!" in out assert "MyVar2=OldVar2 MyValue2!!" in out assert "MyVar3=MyValue3 OldVar3!!" in out assert "MyVar4=!!" in out assert "MyVar5=MyValue5 With Space5=More Space5;:More!!" in out assert "MyVar6= MyValue6!!" in out # The previous is non existing, append has space assert "MyPath1=/Some/Path1/!!" in out assert "MyPath2=OldPath2:/Some/Path2/:/Other/Path2/!!" in out assert "MyPath3=/Some/Path3/:OldPath3!!" in out assert "MyPath4=!!" in out # This should be output when deactivated assert "MyVar=!!" in out assert "MyVar1=OldVar1!!" in out assert "MyVar2=OldVar2!!" in out assert "MyVar3=OldVar3!!" in out assert "MyVar4=OldVar4!!" in out assert "MyVar5=!!" in out assert "MyVar6=!!" in out assert "MyPath1=OldPath1!!" in out assert "MyPath2=OldPath2!!" in out assert "MyPath3=OldPath3!!" in out assert "MyPath4=OldPath4!!" in out with chdir(folder): if platform.system() == "Windows": env.save_bat("test.bat", pathsep=":", generate_deactivate=True) save("display.bat", display_bat) cmd = "test.bat && display.bat && deactivate_test.bat && display.bat" check(cmd) # FIXME: Powershell still not working # env.save_ps1("test.ps1", pathsep=":") # cmd = 'powershell.exe -ExecutionPolicy ./test.ps1; gci env:' # shell = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # (stdout, stderr) = shell.communicate() # stdout, stderr = decode_text(stdout), decode_text(stderr) # check(cmd) else: env.save_sh("test.sh", generate_deactivate=True) save("display.sh", display_sh) os.chmod("display.sh", 0o777) cmd = '. ./test.sh && ./display.sh && . ./deactivate_test.sh && ./display.sh' check(cmd)