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)
