def program_sdv_w_stdin__wo_sym_refs(contents_of_stdin: str) -> ProgramSdv:
return program_sdvs.system_program(
string_sdvs.str_constant('the-system-program'),
stdin=[str_src_sdvs.ConstantStringStringSourceSdv(
string_sdvs.str_constant(contents_of_stdin)
)],
)
def _parse__except_transformation(
self, token_parser: TokenParser) -> StringSourceSdv:
either_sym_name_or_string = self._string_parser.parse_from_token_parser(
token_parser)
return (symbol_reference.SymbolReferenceStringStringSourceSdv(
either_sym_name_or_string.left())
if either_sym_name_or_string.is_left() else
sdvs.ConstantStringStringSourceSdv(
either_sym_name_or_string.right()))
def of_primitive_constant(
contents: str,
definition_source: Optional[
SourceLocationInfo] = ARBITRARY_LINE_SEQUENCE_FOR_DEFINITION,
) -> 'StringSourceSymbolValueContext':
return StringSourceSymbolValueContext.of_sdv(
sdvs.ConstantStringStringSourceSdv(
string_sdvs.str_constant(contents)),
definition_source,
)
def resolve(self, symbols: SymbolTable) -> StringSourceDdv:
container = symbols.lookup(self._symbol_name)
assert isinstance(container, SymbolContainer) # Type info for IDE
sdv = container.sdv
if isinstance(sdv, StringSourceSdv):
return sdv.resolve(symbols)
elif isinstance(sdv, StringSdv):
return sdvs.ConstantStringStringSourceSdv(sdv).resolve(symbols)
else:
raise TypeError('Expected string-source or string, found: ' +
str(container.value_type))
def test_stdin_in_referenced_program_and_as_source_argument(self):
# ARRANGE #
str_src_contents__of_argument = 'the_str_src_contents__of_argument'
str_src_contents__of_referenced_pgm = 'the_str_src_contents__of_program'
stdin_argument_syntax = str_src_abs_stx.StringSourceOfStringAbsStx.of_str(
str_src_contents__of_argument)
stdin_sdv__of_referenced = str_src_sdvs.ConstantStringStringSourceSdv(
string_sdvs.str_constant(str_src_contents__of_referenced_pgm))
referenced_program__system_program = 'the-system-program'
referenced_program__sdv = program_sdvs.system_program(
string_sdvs.str_constant(referenced_program__system_program),
stdin=[stdin_sdv__of_referenced],
)
referenced_program = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM', referenced_program__sdv)
symbols__symbol_table = [referenced_program]
symbols__expected_references = [referenced_program]
arguments_cases = [
NameAndValue(
'no arguments',
[],
),
NameAndValue(
'single argument',
['arg1'],
)
]
for arguments_case in arguments_cases:
with self.subTest(arguments=arguments_case.name):
program_w_stdin = FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(referenced_program.name, [
ArgumentOfRichStringAbsStx.of_str(arg)
for arg in arguments_case.value
]),
stdin=stdin_argument_syntax,
)
expected_primitive = asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=asrt_command.
matches_system_program_command_driver(
asrt.equals(referenced_program__system_program)),
arguments=asrt.equals(arguments_case.value),
),
stdin=asrt.matches_sequence([
asrt_str_src.matches__str(
asrt.equals(str_src_contents__of_referenced_pgm)),
asrt_str_src.matches__str(
asrt.equals(str_src_contents__of_argument)),
]),
transformer=asrt_pgm_val.is_no_transformation(),
)
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self, equivalent_source_variants__for_expr_parse__s__nsc,
program_w_stdin,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbols__symbol_table), ),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
symbols__expected_references),
primitive=expected_primitive,
))
def test_stdin_in_referenced_program_and_as_source_argument(self):
# ARRANGE #
stdin_contents = 'str_src_contents'
valid_stdin_sdv = sdvs.ConstantStringStringSourceSdv(
string_sdvs.str_constant(stdin_contents))
valid_stdin_syntax = str_src_abs_stx.StringSourceOfStringAbsStx.of_str(
stdin_contents)
referenced_program__system_program = 'the-system-program'
for validation_case in validation_cases.failing_validation_cases():
invalid_stdin_location_cases = [
ValidationCaseWAccumulation(
'in referenced symbol',
sdv_of_referenced_program=validation_case.value.
symbol_context.sdv,
syntax_accumulated=valid_stdin_syntax,
symbols=[],
),
ValidationCaseWAccumulation(
'as source argument',
sdv_of_referenced_program=valid_stdin_sdv,
syntax_accumulated=validation_case.value.syntax,
symbols=[validation_case.value.symbol_context],
),
]
for invalid_stdin_location_case in invalid_stdin_location_cases:
referenced_program__sdv = program_sdvs.system_program(
string_sdvs.str_constant(
referenced_program__system_program),
stdin=[
invalid_stdin_location_case.sdv_of_referenced_program
])
referenced_program = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM', referenced_program__sdv)
program_w_stdin = FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(referenced_program.name, ),
stdin=invalid_stdin_location_case.syntax_of_accumulated,
)
symbols__all = [
validation_case.value.symbol_context, referenced_program
]
symbols__expected_references = [
referenced_program
] + invalid_stdin_location_case.symbols
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_expr_parse__s__nsc,
program_w_stdin,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbols__all), ),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
symbols__expected_references),
execution=ExecutionExpectation(
validation=validation_case.value.assertion, ),
primitive=asrt.anything_goes(),
),
sub_test_identifiers={
'validation': validation_case.name,
'invalid_stdin_location':
invalid_stdin_location_case.name,
})