def test_description(self):
# ARRANGE #
path_rel_home = path_ddvs.of_rel_option(path_ddvs.RelOptionType.REL_HDS_CASE,
PathPartDdvAsNothing())
path_rel_sds = path_ddvs.of_rel_option(path_ddvs.RelOptionType.REL_ACT,
PathPartDdvAsNothing())
path_abs = path_ddvs.absolute_file_name(str(pathlib.Path().resolve()))
cases = [
NameAndValue('rel-hds',
path_rel_home
),
NameAndValue('rel-sds',
path_rel_sds
),
NameAndValue('absolute',
path_abs
),
]
for case in cases:
with self.subTest(case.name):
fragment = strings.PathFragmentDdv(case.value)
# ACT #
actual = fragment.describer().render()
# ASSERT #
expected = case.value.describer().value.render()
self.assertEqual(expected, actual)
def runTest(self):
# ARRANGE #
abs_path = pathlib.Path().resolve()
path_part_component = 'path-part'
cases = [
NEA(
'rel-hds wo path suffix',
expected=rpo.REL_HDS_OPTIONS_MAP[
RelHdsOptionType.REL_HDS_CASE].directory_symbol_reference,
actual=sut.of_rel_option(sut.RelOptionType.REL_HDS_CASE,
sut.PathPartDdvAsNothing()),
),
NEA(
'rel-hds w path suffix',
expected=str(
pathlib.PurePosixPath(
rpo.REL_HDS_OPTIONS_MAP[RelHdsOptionType.REL_HDS_CASE].
directory_symbol_reference) / path_part_component),
actual=sut.of_rel_option(
sut.RelOptionType.REL_HDS_CASE,
PathPartDdvAsFixedPath(path_part_component)),
),
NEA(
'rel-sds',
expected=rpo.REL_SDS_OPTIONS_MAP[
RelSdsOptionType.REL_ACT].directory_symbol_reference,
actual=sut.of_rel_option(sut.RelOptionType.REL_ACT,
sut.PathPartDdvAsNothing()),
),
NEA(
'absolute',
expected=str(abs_path),
actual=sut.absolute_file_name(str(abs_path)),
),
]
for case in cases:
with self.subTest(case.name):
# ACT #
actual = case.actual.describer().value.render()
# ASSERT #
self.assertEqual(case.expected, actual)
def description(self) -> SequenceRenderer[MinorBlock]:
path_ddv = path_ddvs.of_rel_option(
RelOptionType.REL_RESULT,
path_ddvs.constant_path_part(self._sds.result.exitcode_file.name),
)
described_path = path_ddv.value_of_any_dependency__d(self._tcds)
return rend_comb.SingletonSequenceR(
path_rendering.minor_block_renderer_of_primitive(
described_path.describer))
def of_rel_opt_and_suffix(
relativity: RelOptionType,
suffix: str,
accepted_relativities: PathRelativityVariants = ALL_REL_OPTION_VARIANTS,
definition_source: Optional[
SourceLocationInfo] = ARBITRARY_LINE_SEQUENCE_FOR_DEFINITION,
) -> 'PathSymbolValueContext':
return PathSymbolValueContext.of_ddv(
path_ddvs.of_rel_option(relativity,
path_ddvs.constant_path_part(suffix)),
accepted_relativities, definition_source)
def _get_ddv(self) -> PathDdv:
if self._value is None:
original = self._original
path_suffix = self._parent_path_suffix(
original.path_suffix().value())
relativity = original.relativity()
self._value = (path_ddvs.absolute_part(path_suffix) if
relativity.is_absolute else path_ddvs.of_rel_option(
relativity.relativity_type, path_suffix))
return self._value
def _just_string_argument(
self,
argument: str,
) -> PathSdv:
argument_path = pathlib.PurePosixPath(argument)
if argument_path.is_absolute():
# TODO Should we check if absolute paths are allowed according to RelOptionArgumentConfiguration??
return path_sdvs.constant(path_ddvs.absolute_file_name(argument))
path_suffix = path_ddvs.constant_path_part(argument)
return path_sdvs.constant(
path_ddvs.of_rel_option(
self.conf.rel_opt_conf.options.default_option, path_suffix))
def visit_string(self, value: StringSdv) -> PathDdv:
string_ddv = value.resolve(self.symbols)
first_suffix_str = string_ddv.value_when_no_dir_dependencies()
following_suffix_str = self.suffix_sdv.resolve(self.symbols).value()
path_str = first_suffix_str + following_suffix_str
path = pathlib.PurePosixPath(path_str)
if path.is_absolute():
return path_ddvs.absolute_file_name(path_str)
else:
return path_ddvs.of_rel_option(
self.default_relativity,
path_ddvs.constant_path_part(path_str))
def __init__(self, relativity: RelOptionType,
expected_accepted_relativities: PathRelativityVariants,
symbol_name: str):
self.expected_accepted_relativities = expected_accepted_relativities
self.relativity = relativity
self.symbol_name = symbol_name
self.symbol_context = PathDdvSymbolContext(
symbol_name,
path_ddvs.of_rel_option(relativity, path_ddvs.empty_path_part()),
accepted_relativities=expected_accepted_relativities,
default_reference_variant=PathReferenceVariant.PATH,
)
def test(self):
path_rel_home = path_ddvs.of_rel_option(path_ddvs.RelOptionType.REL_HDS_CASE,
PathPartDdvAsNothing())
path_rel_sds = path_ddvs.of_rel_option(path_ddvs.RelOptionType.REL_ACT,
PathPartDdvAsNothing())
path_abs = path_ddvs.absolute_file_name(str(pathlib.Path().resolve()))
cases = [
(
'dependency on ' + str(DirectoryStructurePartition.HDS),
strings.PathFragmentDdv(path_rel_home),
AMultiDirDependentValue(
resolving_dependencies={DirectoryStructurePartition.HDS},
get_value_of_any_dependency=lambda h_s: str(
path_rel_home.value_pre_sds(h_s.hds))),
),
(
'dependency on ' + str(DirectoryStructurePartition.NON_HDS),
strings.PathFragmentDdv(path_rel_sds),
AMultiDirDependentValue(
resolving_dependencies={DirectoryStructurePartition.NON_HDS},
get_value_of_any_dependency=lambda h_s: str(
path_rel_sds.value_post_sds(h_s.sds))),
),
(
'no dependency',
strings.PathFragmentDdv(path_abs),
AMultiDirDependentValue(
resolving_dependencies=set(),
get_value_when_no_dir_dependencies=do_return(str(path_abs.value_when_no_dir_dependencies())),
get_value_of_any_dependency=lambda h_s: str(
path_abs.value_when_no_dir_dependencies())),
),
]
for test_case_name, expected, actual in cases:
assertion = matches_multi_dir_dependent_value(expected)
with self.subTest(name=test_case_name,
expected=str(expected)):
assertion.apply_without_message(self, actual)
def test_success(self):
# ARRANGE #
path_symbol = PathDdvSymbolContext(
'symbol_name', path_ddvs.of_rel_option(RelOptionType.REL_ACT))
reference = data_references.reference_to__on_direct_and_indirect(
path_symbol.name)
path_sdv = PathSdvTestImplWithConstantPathAndSymbolReferences(
path_symbol.ddv, [reference])
assertion = sut.matches_sdv(asrt.is_instance(PathSdv),
asrt.len_equals(1),
asrt.is_(path_symbol.ddv),
asrt.is_(path_sdv),
symbols=path_symbol.symbol_table)
# ACT & ASSERT #
assertion.apply_without_message(self, path_sdv)
def test_rel_tmp_with_argument(self):
for is_after_act_phase in [False, True]:
with self.subTest(is_after_act_phase=is_after_act_phase):
arguments = format_rel_options('{rel_tmp} subdir')
parser = sut.EmbryoParser(
is_after_act_phase=is_after_act_phase)
# ACT #
actual = parser.parse(ARBITRARY_FS_LOCATION_INFO,
remaining_source(arguments))
# ASSERT #
expected_path = path_ddvs.of_rel_option(
RelOptionType.REL_TMP,
path_ddvs.constant_path_part('subdir'))
assertion = matches_path_sdv(expected_path, asrt.is_empty)
assertion.apply_without_message(self, actual.destination)
def test_no_relativity_option_should_use_default_option(self):
for is_after_act_phase in [False, True]:
with self.subTest(is_after_act_phase=is_after_act_phase):
arguments = 'single-argument'
parser = sut.EmbryoParser(
is_after_act_phase=is_after_act_phase)
# ACT #
actual = parser.parse(ARBITRARY_FS_LOCATION_INFO,
remaining_source(arguments))
# ASSERT #
expected_path = path_ddvs.of_rel_option(
RelOptionType.REL_CWD,
path_ddvs.constant_path_part(arguments))
assertion = matches_path_sdv(expected_path, asrt.is_empty)
assertion.apply_without_message(self, actual.destination)
def test_success_when_correct_number_of_arguments__escaped(self):
for is_after_act_phase in [False, True]:
with self.subTest(is_after_act_phase=is_after_act_phase):
arguments = '"expected argument"'
parser = sut.EmbryoParser(
is_after_act_phase=is_after_act_phase)
# ACT #
actual = parser.parse(ARBITRARY_FS_LOCATION_INFO,
remaining_source(arguments))
# ASSERT #
expected_path = path_ddvs.of_rel_option(
RelOptionType.REL_CWD,
path_ddvs.constant_path_part('expected argument'))
assertion = matches_path_sdv(expected_path, asrt.is_empty)
assertion.apply_without_message(self, actual.destination)
def of_no_suffix(
name: str,
relativity: RelOptionType,
accepted_relativities: PathRelativityVariants = ALL_REL_OPTION_VARIANTS,
definition_source: Optional[
SourceLocationInfo] = ARBITRARY_LINE_SEQUENCE_FOR_DEFINITION,
default_reference_variant: PathReferenceVariant = PathReferenceVariant.
PATH_OR_STRING,
) -> 'PathDdvSymbolContext':
return PathDdvSymbolContext(
name,
path_ddvs.of_rel_option(relativity, path_ddvs.empty_path_part()),
accepted_relativities,
definition_source,
default_reference_variant,
)
def __init__(
self,
name: str,
relativity: RelOptionType,
suffix: str,
accepted_relativities: PathRelativityVariants = ALL_REL_OPTION_VARIANTS,
definition_source: Optional[
SourceLocationInfo] = ARBITRARY_LINE_SEQUENCE_FOR_DEFINITION,
default_reference_variant: PathReferenceVariant = PathReferenceVariant.
PATH_OR_STRING,
):
self._path_part = path_ddvs.constant_path_part(suffix)
super().__init__(name,
path_ddvs.of_rel_option(relativity, self._path_part),
accepted_relativities, definition_source,
default_reference_variant)
self._suffix = suffix
def cases__w_argument_list__excluding_program_reference() -> List[PgmAndArgsCase]:
"""Cases of pgm-and-arg:s that have a list of arguments."""
executable_file = fs.executable_file('executable-file', '')
exe_file_relativity = rel_opt.conf_rel_hds(RelHdsOptionType.REL_HDS_CASE)
executable_file_ddv = path_ddvs.of_rel_option(exe_file_relativity.relativity,
path_ddvs.constant_path_part(executable_file.name)
)
system_program = 'the-system-program'
return [
PgmAndArgsCase.w_tcds(
'executable file',
pgm_and_args=pgm_abs_stx.ProgramOfExecutableFileCommandLineAbsStx(
exe_file_relativity.named_file_conf(executable_file.name).abstract_syntax
),
expected_command_driver=lambda env: (
asrt_command.matches_executable_file_command_driver(
asrt.equals(executable_file_ddv.value_of_any_dependency__d(env.tcds).primitive),
)),
tcds=exe_file_relativity.populator_for_relativity_option_root__hds(
DirContents([executable_file])
)
),
PgmAndArgsCase.wo_tcds(
'-python',
pgm_and_args=pgm_abs_stx.ProgramOfPythonInterpreterAbsStx(()),
expected_command_driver=prim_asrt__constant(
asrt_command.matches_executable_file_command_driver(
asrt_path.path_as_str(asrt.equals(sys.executable)),
)),
),
PgmAndArgsCase.wo_tcds(
'system program',
pgm_and_args=pgm_abs_stx.ProgramOfSystemCommandLineAbsStx(
StringLiteralAbsStx(system_program)
),
expected_command_driver=prim_asrt__constant(
asrt_command.matches_system_program_command_driver(
asrt.equals(system_program)
))
),
]
def test(self):
string_of_path_rel_home = string_ddv_of_single_path(
path_ddvs.of_rel_option(path_ddvs.RelOptionType.REL_HDS_CASE,
PathPartDdvAsNothing()))
string_1 = 'string value 1'
string_2 = 'string value 2'
cases = [
(
'single string constant element',
strings.ListFragmentDdv(strings.ListDdv([string_ddv_of_single_string(string_1)])),
AMultiDirDependentValue(
resolving_dependencies=set(),
get_value_when_no_dir_dependencies=do_return(string_1),
get_value_of_any_dependency=do_return(string_1)),
),
(
'multiple string constant element',
strings.ListFragmentDdv(strings.ListDdv([string_ddv_of_single_string(string_1),
string_ddv_of_single_string(string_2)])),
AMultiDirDependentValue(
resolving_dependencies=set(),
get_value_when_no_dir_dependencies=do_return(list_formatting.format_elements([string_1, string_2])),
get_value_of_any_dependency=do_return(list_formatting.format_elements([string_1, string_2]))),
),
(
'dependency on ' + str(DirectoryStructurePartition.HDS),
strings.ListFragmentDdv(strings.ListDdv([string_of_path_rel_home])),
AMultiDirDependentValue(
resolving_dependencies={DirectoryStructurePartition.HDS},
get_value_of_any_dependency=lambda h_s: str(
string_of_path_rel_home.value_of_any_dependency(h_s))),
),
]
for test_case_name, expected, actual in cases:
assertion = matches_multi_dir_dependent_value(expected)
with self.subTest(name=test_case_name):
assertion.apply_without_message(self, actual)
def _path_sdv_for(self, path_suffix: PathPartDdv) -> PathSdv:
return path_sdvs.constant(
path_ddvs.of_rel_option(rel_any_from_rel_sds(self.relativity_sds),
path_suffix))
def path_of_default_relativity(path_suffix: str) -> PathDdv:
return path_ddvs.of_rel_option(
syntax_elements.EXE_FILE_REL_OPTION_ARG_CONF.options.default_option,
path_ddvs.constant_path_part(path_suffix))
def path_of(rel_option: RelOptionType, path_suffix: str) -> PathDdv:
return path_ddvs.of_rel_option(rel_option,
path_ddvs.constant_path_part(path_suffix))
def ret_val(path_suffix: PathPartDdv) -> PathDdv:
return sut.of_rel_option(rel_option_type, path_suffix)
def ret_val(environment: FullResolvingEnvironment) -> FileMatcherModel:
ddv = path_ddvs.of_rel_option(relativity,
path_ddvs.constant_path_part(file_name))
return file_matcher_models.new_model__of_described(
ddv.value_of_any_dependency__d(environment.tcds))
def of_rel_option(
rel_option: relativity_root.RelOptionType,
path_suffix: PathPartDdv = path_ddvs.empty_path_part()
) -> PathSdv:
return constant(path_ddvs.of_rel_option(rel_option, path_suffix))
def resolve(self, symbols: SymbolTable) -> PathDdv:
return path_ddvs.of_rel_option(self.relativity,
self.path_suffix_sdv.resolve(symbols))
def all_command_driver_types() -> Sequence[CommandDriverSdvCase]:
# ARRANGE #
system_program_name = 'system-program'
executable_program_file_name = 'executable-program-file'
executable_file_relativity = relativity_options.conf_rel_any(
RelOptionType.REL_HDS_ACT)
executable_file_ddv = path_ddvs.of_rel_option(
executable_file_relativity.relativity_option,
path_ddvs.constant_path_part(executable_program_file_name))
shell_initial_command = 'shell initial command'
def mk_arrangement__executable_file(symbols: SymbolTable) -> Arrangement:
return arrangement_w_tcds(
symbols=symbols,
tcds_contents=executable_file_relativity.
populator_for_relativity_option_root(
fs.DirContents(
[fs.executable_file(executable_program_file_name)])))
def expected_command_driver__system_program(
env: AssertionResolvingEnvironment) -> Assertion[CommandDriver]:
return asrt_command.matches_system_program_command_driver(
asrt.equals(system_program_name))
def expected_command_driver__executable_file(
env: AssertionResolvingEnvironment) -> Assertion[CommandDriver]:
return asrt_command.matches_executable_file_command_driver(
asrt.equals(
executable_file_ddv.value_of_any_dependency__d(
env.tcds).primitive), )
def expected_command_driver__shell_cmd_line(
env: AssertionResolvingEnvironment) -> Assertion[CommandDriver]:
return asrt_command.matches_shell_command_driver(
asrt.equals(shell_initial_command))
return [
CommandDriverSdvCase(
'system program',
command_driver=driver_sdvs.CommandDriverSdvForSystemProgram(
string_sdvs.str_constant(system_program_name)),
expected_command_driver=expected_command_driver__system_program,
mk_arrangement=lambda sym_tbl: arrangement_wo_tcds(symbols=sym_tbl
),
),
CommandDriverSdvCase(
'executable program file',
command_driver=driver_sdvs.CommandDriverSdvForExecutableFile(
path_sdvs.constant(executable_file_ddv)),
expected_command_driver=expected_command_driver__executable_file,
mk_arrangement=mk_arrangement__executable_file,
),
CommandDriverSdvCase(
'shell command line',
command_driver=driver_sdvs.CommandDriverSdvForShell(
string_sdvs.str_constant(shell_initial_command)),
expected_command_driver=expected_command_driver__shell_cmd_line,
mk_arrangement=lambda sym_tbl: arrangement_wo_tcds(symbols=sym_tbl
),
),
]
def runTest(self):
# ARRANGE #
program_name_string_symbol = StringConstantSymbolContext(
'PROGRAM_NAME_STRING_SYMBOL_NAME', 'the program name')
argument_string_symbol = StringConstantSymbolContext(
'ARGUMENT_STRING_SYMBOL_NAME', 'the argument')
symbols = SymbolContext.symbol_table_of_contexts([
program_name_string_symbol,
argument_string_symbol,
])
file_name = 'a-file.txt'
file_arg_relativity = relativity_options.conf_rel_any(
RelOptionType.REL_HDS_CASE)
path = path_ddvs.of_rel_option(file_arg_relativity.relativity_option,
path_ddvs.constant_path_part(file_name))
argument_cases = [
ArgumentsCase(
'no arguments',
source_elements=[],
expected_resolved_values=lambda tcds: [],
expected_symbol_references=[],
),
ArgumentsCase(
'single constant argument',
source_elements=[
ArgumentOfRichStringAbsStx.of_str('argument')
],
expected_resolved_values=lambda tcds: ['argument'],
expected_symbol_references=[],
),
ArgumentsCase(
'symbol reference and constant argument',
source_elements=[
ArgumentOfSymbolReferenceAbsStx(
argument_string_symbol.name),
ArgumentOfRichStringAbsStx.of_str('argument')
],
expected_resolved_values=lambda tcds:
[argument_string_symbol.str_value, 'argument'],
expected_symbol_references=[
argument_string_symbol.reference_assertion__w_str_rendering
]),
ArgumentsCase(
'existing file argument',
source_elements=[
ArgumentOfExistingPathAbsStx(
file_arg_relativity.path_abs_stx_of_name(file_name),
NonSymLinkFileType.REGULAR)
],
expected_resolved_values=lambda tcds:
[str(path.value_of_any_dependency(tcds))],
expected_symbol_references=[],
tcds_contents=file_arg_relativity.
populator_for_relativity_option_root(
DirContents([File.empty(file_name)]))),
]
program_cases = [
ProgramNameCase('string constant',
source_element=RawSystemCommandLineAbsStx.of_str(
'the_program'),
expected_resolved_value='the_program',
expected_symbol_references=[]),
ProgramNameCase(
'symbol reference',
source_element=RawSystemCommandLineAbsStx(
StringSymbolAbsStx(program_name_string_symbol.name)),
expected_resolved_value=program_name_string_symbol.str_value,
expected_symbol_references=[
program_name_string_symbol.
reference_assertion__string__w_all_indirect_refs_are_strings
]),
]
for argument_case in argument_cases:
for program_case in program_cases:
# ACT & ASSERT #
self._check(program_case, argument_case, symbols)
def of_rel_option_with_const_file_name(
rel_option: relativity_root.RelOptionType, file_name: str) -> PathSdv:
return constant(
path_ddvs.of_rel_option(rel_option,
path_ddvs.constant_path_part(file_name)))
def test_dependence_and_resolving(self):
string_fragment_1 = 'string fragment 1'
string_fragment_2 = 'string fragment 2'
path_rel_home = path_ddvs.of_rel_option(
path_ddvs.RelOptionType.REL_HDS_CASE, PathPartDdvAsNothing())
path_rel_sds = path_ddvs.of_rel_option(path_ddvs.RelOptionType.REL_ACT,
PathPartDdvAsNothing())
single_element_with_dep_on_home = sv.string_ddv_of_single_path(
path_rel_home)
single_element_with_dep_on_sds = sv.string_ddv_of_single_path(
path_rel_sds)
cases = [
(
'no elements',
sut.ListDdv([]),
AMultiDirDependentValue(
resolving_dependencies=set(),
get_value_when_no_dir_dependencies=do_return([]),
get_value_of_any_dependency=do_return([])),
),
(
'single string constant element',
sut.ListDdv(
[sv.string_ddv_of_single_string(string_fragment_1)]),
AMultiDirDependentValue(
resolving_dependencies=set(),
get_value_when_no_dir_dependencies=do_return(
[string_fragment_1]),
get_value_of_any_dependency=do_return([string_fragment_1
])),
),
(
'multiple string constant element',
sut.ListDdv([
sv.string_ddv_of_single_string(string_fragment_1),
sv.string_ddv_of_single_string(string_fragment_2)
]),
AMultiDirDependentValue(
resolving_dependencies=set(),
get_value_when_no_dir_dependencies=do_return(
[string_fragment_1, string_fragment_2]),
get_value_of_any_dependency=do_return(
[string_fragment_1, string_fragment_2])),
),
(
'single dir dependent value/pre sds',
sut.ListDdv([single_element_with_dep_on_home]),
AMultiDirDependentValue(
resolving_dependencies={DirectoryStructurePartition.HDS},
get_value_of_any_dependency=lambda h_s: [
single_element_with_dep_on_home.
value_of_any_dependency(h_s)
]),
),
(
'single dir dependent value/post sds',
sut.ListDdv([single_element_with_dep_on_sds]),
AMultiDirDependentValue(
resolving_dependencies={
DirectoryStructurePartition.NON_HDS
},
get_value_of_any_dependency=lambda h_s: [
single_element_with_dep_on_sds.value_of_any_dependency(
h_s)
]),
),
(
'multiple dir dependent value/pre sds + post sds',
sut.ListDdv([
single_element_with_dep_on_home,
single_element_with_dep_on_sds
]),
AMultiDirDependentValue(
resolving_dependencies={
DirectoryStructurePartition.HDS,
DirectoryStructurePartition.NON_HDS
},
get_value_of_any_dependency=lambda h_s: [
single_element_with_dep_on_home.
value_of_any_dependency(h_s),
single_element_with_dep_on_sds.value_of_any_dependency(
h_s)
]),
),
]
for test_case_name, expected, actual in cases:
assertion = matches_multi_dir_dependent_value(expected)
with self.subTest(name=test_case_name):
assertion.apply_without_message(self, actual)
def _single_line_command_cases() -> List[Case]:
exe_file_name = 'executable-file'
exe_file_relativity__explicit = rel_opt.conf_rel_hds(
RelHdsOptionType.REL_HDS_ACT)
exe_file_ddv__explicit_relativity = path_ddvs.of_rel_option(
exe_file_relativity__explicit.relativity,
path_ddvs.constant_path_part(exe_file_name))
exe_file_relativity__default = rel_opt.default_conf_rel_hds(
RelHdsOptionType.REL_HDS_CASE)
exe_file_ddv__default_relativity = path_ddvs.of_rel_option(
exe_file_relativity__default.relativity,
path_ddvs.constant_path_part(exe_file_name))
system_program = 'the-system-program'
system_program_symbol = StringConstantSymbolContext(
'SYSTEM_PROGRAM_SYMBOL',
system_program,
default_restrictions=reference_assertions.
IS_REFERENCE__STRING__W_ALL_INDIRECT_REFS_ARE_STRINGS,
)
return [
Case(
'executable file / explicit relativity',
source=pgm_args.executable_file_command_line(
exe_file_relativity__explicit.named_file_conf(
exe_file_name).cl_argument.as_str),
expected_command_driver=lambda tcds:
(asrt_command.matches_executable_file_command_driver(
asrt.equals(
exe_file_ddv__explicit_relativity.
value_of_any_dependency__d(tcds).primitive), )),
),
Case(
'executable file / default relativity',
source=pgm_args.executable_file_command_line(
exe_file_relativity__default.named_file_conf(
exe_file_name).cl_argument.as_str),
expected_command_driver=lambda tcds:
(asrt_command.matches_executable_file_command_driver(
asrt.equals(
exe_file_ddv__default_relativity.
value_of_any_dependency__d(tcds).primitive), )),
),
Case(
'-python',
source=pgm_args.py_interpreter_command_line(),
expected_command_driver=constant_assertion(
asrt_command.matches_executable_file_command_driver(
asrt_path.path_as_str(asrt.equals(sys.executable)), )),
),
Case('system program',
source=pgm_args.system_program_command_line(system_program),
expected_command_driver=constant_assertion(
asrt_command.matches_system_program_command_driver(
asrt.equals(system_program)))),
Case('system program / w symbol reference',
source=pgm_args.system_program_command_line(
system_program_symbol.name__sym_ref_syntax),
symbols=[system_program_symbol],
expected_command_driver=constant_assertion(
asrt_command.matches_system_program_command_driver(
asrt.equals(system_program_symbol.str_value)))),
]
def _result_from_no_arguments(self, ) -> Either[SymbolName, PathSdv]:
return Either.of_right(
path_sdvs.constant(
path_ddvs.of_rel_option(
self.conf.rel_opt_conf.options.default_option,
path_ddvs.empty_path_part())))
