os.chdir("..")
init_local_crate("dep_targeted")
alr_with("gnat_native") # This step also installs the native compiler
os.chdir("..")
# First we check that a root generic dependency mixes well with either of the
# two dependencies
init_local_crate("xxx_generic_generic")
run_alr("with", "--use=../dep_generic")
alr_with("gnat")
# gnat x gnat results in the external available compiler being used, preferred
# over the native also available compiler (but not selected)
match_solution(f"gnat={version} (gnat_external) (installed)", escape=True)
# If we add a precise dependency on e.g. the installed native compiler, this
# should override the external compiler
alr_with("gnat_native")
match_solution("gnat=8888.0.0 (gnat_native) (installed)", escape=True)
match_solution("gnat_native=8888.0.0 (installed)", escape=True)
# Let us swap the generic dependency with a targeted dependency, starting from
# scratch
os.chdir("..")
init_local_crate("xxx_generic_targeted")
run_alr("with", "--use=../dep_targeted")
alr_with("gnat")
print(f"erroneous path was: {paths[0]}")
raise
# First we test manual installation
run_alr("toolchain", "--install", "gnat_native")
check_content("gnat_native")
# Uninstall the compiler and verify absence
run_alr("toolchain", "--uninstall", "gnat_native", quiet=False)
paths = contents(cache_dir, "gnat_native")
assert len(paths) == 0, "Unexpected contents: " + str(paths)
# Require the external compiler and verify no trace appears in install folder
# nor in local folder
init_local_crate("xxx")
alr_with("gnat_external")
match_solution("gnat_external=.* \(installed\)")
paths = contents(cache_dir, "gnat_external")
assert len(paths) == 0, "Unexpected contents: " + str(paths)
paths = contents(".", "gnat_external")
assert len(paths) == 0, "Unexpected contents: " + str(paths)
# Require a cross compiler and verify it is automatically installed
alr_with("gnat_external", delete=True, manual=False)
alr_with("gnat_cross_1")
match_solution("gnat_cross_1=.* \(installed\)")
check_content("gnat_cross_1")
print('SUCCESS')
import subprocess
import os
from drivers.alr import run_alr, init_local_crate, alr_with
from drivers.asserts import assert_eq, assert_match, match_solution
from re import escape as e
# This test relies on two crates in the index: crate_lone=1.0 is unavailable.
# crate_equiv=2.0 also provides crate_lone=1.0 and crate_virtual=1.0.
# Finally there is crate_lone=2.0 that is available and nobody else provides.
init_local_crate("xxx")
alr_with("crate_lone^1")
# Since crate_lone is unavailable, in the solution we should find crate_equiv:
match_solution("crate_lone=2.0.0 (crate_equiv)", escape=True)
# Likewise, a dependency on crate_virtual will be fulfilled by the same crate
alr_with("crate_virtual")
match_solution("crate_virtual=2.0.0 (crate_equiv)", escape=True)
# Whereas a dependency on crate_equiv will show plainly without equivalence
alr_with("crate_equiv")
match_solution(
"Dependencies (solution):\n"
" crate_equiv=2.0.0 (origin: filesystem)\n"
" crate_lone=2.0.0 (crate_equiv) (origin: filesystem)\n"
" crate_virtual=2.0.0 (crate_equiv) (origin: filesystem)\n",
escape=True)
# Finally check that a dependency on crate_lone^2 is only fulfilled by itself
import subprocess
import os
from drivers.alr import run_alr, init_local_crate, alr_with
from drivers.asserts import assert_eq, assert_match, match_solution
from re import escape as e
# This test relies on three crates in the toolchain_index:
# crate_conflict=1.2.3 conflicts with crate_lone* and crate_virtual*
# crate_lone is a regular crate
# crate_virtual has no releases, but is provided by crate_conflict_1
# Crate conflict cannot appear with any of the others in a solution, because of
# its [forbids] table.
init_local_crate("conflict_lone")
alr_with("crate_conflict")
alr_with("crate_lone")
match_solution("crate_(conflict|lone)=.* \(origin:.*\)") # has origin: solved
match_solution("crate_(conflict|lone)\* \(direct,missed\)")
# Because of load/solving details, we do not know which of the two crates is
# going to be missed/accepted in the solution, so we check there is one of each
init_local_crate("conflict_virtual")
alr_with("crate_conflict")
alr_with("crate_virtual")
match_solution("crate_(conflict|virtual)=.* \(origin:.*\)")
match_solution("crate_(conflict|virtual)\* \(direct,missed\)")
print('SUCCESS')
"gnat_external.*Available.*Detected.*\n",
p.out)
# Capture version
version = re.search("gnat_external ([0-9.]+)", p.out, re.MULTILINE).group(1)
print(version)
# When no compiler is selected, since the external one is available, it should
# be used before offering to download a new compiler.
# Create a crate for our experiments
init_local_crate("xxx")
# Check that a generic dependency results in the external being used
alr_with("gnat")
match_solution(f"gnat={version} (gnat_external) (installed)", escape=True)
# Check that requesting a version different to the one externally available
# results in missing compiler, as Alire won't try to install one.
alr_with("gnat", delete=True, manual=False)
alr_with(f"gnat/={version}")
match_solution(f"gnat/={version} (direct,hinted)", escape=True)
# Hinted because we know the crate exists as external
# Now, if the user installs a cross compiler, it will be used
run_alr("toolchain", "--install", "gnat_cross_2")
run_alr("update")
match_solution("gnat=1.0.0 (gnat_cross_2) (installed)", escape=True)
# Likewise, if we install a native compiler, it will be preferred to a
"""
Test that two crates providing the same third crate are compatible
"""
import subprocess
import os
from drivers.alr import run_alr, init_local_crate, alr_with
from drivers.asserts import assert_eq, assert_match, match_solution
from re import escape as e
# This test relies on two crates in the index:
# crate_virt_1=2.0 also provides crate_virtual=1.0
# crate_virt_2=1.0 also provides crate_virtual=1.0
# Verify that these crates provide the same virtual release
p = run_alr("show", "crate_virt_1")
assert_match(".*Provides: crate_virtual=1.0.0.*", p.out)
p = run_alr("show", "crate_virt_2")
assert_match(".*Provides: crate_virtual=1.0.0.*", p.out)
init_local_crate("xxx")
alr_with("crate_virt_1")
alr_with("crate_virt_2")
# Both crates must appear in the solution
match_solution("crate_virt_1=2.0.0 (origin: filesystem)", escape=True)
match_solution("crate_virt_2=1.0.0 (origin: filesystem)", escape=True)
print('SUCCESS')
import os
from drivers.alr import run_alr, init_local_crate, alr_with
from drivers.asserts import assert_eq, assert_match, match_solution
from re import escape as e
# Select the default preferred compiler, which is the native packaged one
run_alr("toolchain", "--select")
# Init a crate depending on gnat
init_local_crate("xxx")
alr_with("gnat*")
# Will appear in the solution as generic fulfilled by the preferred compiler
match_solution("gnat=8888.0.0 (gnat_native) (installed)", escape=True)
# Selecting another default will cause a corresponding change in the solution
run_alr("config", "--set", "toolchain.use.gnat", "gnat_cross_2=1")
run_alr("update")
match_solution("gnat=1.0.0 (gnat_cross_2) (installed)", escape=True)
# Adding another incompatible compiler dependency should result in overriding
# the configured one
alr_with("gnat_cross_1")
# Both dependencies will appear in the solution, matching the same crate
match_solution("gnat=9999.0.0 \(gnat_cross_1\) \(installed\).*"
"gnat_cross_1=9999.0.0 \(installed\)")
print('SUCCESS')
"""
import subprocess
import os
from drivers.alr import run_alr, init_local_crate, alr_with
from drivers.asserts import assert_eq, assert_match, match_solution
from re import escape as e
# This test relies on two crates in the toolchain_index:
# crate_subst both provides and forbids crate_real
# crate_real is a regular crate only provided by itself and crate_subst
# The following has only one possible solution, which is for crate_subst
# providing both dependencies.
init_local_crate("test")
alr_with("crate_real")
# Check that this is initially solved with the regular crate. This is currently
# guaranteed by the solver attempting crates in alphabetical order. We will
# need eventually a way to disable equivalences (via pins, or solver config).
match_solution("crate_real=1.0.0 (origin: filesystem)", escape=True)
# Let's add the drop-in equivalent crate that provides+forbids crate_lone
alr_with("crate_subst")
match_solution("crate_real=1.0.0 (crate_subst) (origin: filesystem)",
escape=True) # This is the substituted release
match_solution("crate_subst=1.0.0 (origin: filesystem)", escape=True)
print('SUCCESS')
".*\n" # Headers
"gnat_external.*Available.*Detected.*\n",
p.out)
# Capture version
version = re.search("gnat_external ([0-9.]+)", p.out, re.MULTILINE).group(1)
# When no compiler is selected, only the gnat_external one should be used
# unless a targeted compiler dependency is used
# Create a crate for our experiments
init_local_crate("xxx")
# Check that a generic dependency results in the external being used
alr_with("gnat")
match_solution(f"gnat={version} (gnat_external) (installed)", escape=True)
# Check that adding a second dependency on native packaged compiler is honored.
# Both dependencies should appear in the solution.
alr_with("gnat_native")
match_solution("gnat=8888.0.0 (gnat_native) (installed)", escape=True)
match_solution("gnat_native=8888.0.0 (installed)", escape=True)
# The previous dependency also should have caused the installation of the
# native compiler as an available compiler, which we will check:
p = run_alr("toolchain")
assert_match(".*gnat_native.*8888.0.0.*Available.*", p.out)
# Move to a new crate
init_local_crate("yyy")