def _handle_deprecated_exit_for_loop(self, error): if self._get(error, 'EXIT_FOR_LOOP'): from robot.output import LOGGER LOGGER.warn("Support for using 'ROBOT_EXIT_FOR_LOOP' attribute to " "exit for loops is deprecated in Robot Framework 2.8 " "and will be removed in 2.9.") raise ExitForLoop
def _get_multisource_suite(datasources, include_suites, warn_on_skipped): suitedatas = [] for datasource in datasources: try: suitedatas.append(_parse_suite(datasource, include_suites, warn_on_skipped)) except DataError, err: LOGGER.warn(err)
def _deprecate_quoting(self, cell, path, line_number): if len(cell) > 1 and cell[0] == cell[-1] == '"': LOGGER.warn("TSV file '%s' has quotes around cells which is " "deprecated and must be fixed. Remove quotes " "from '%s' on line %d." % (path, cell, line_number)) return cell[1:-1].replace('""', '"').strip() return cell
def main(self, datasources, **options): settings = RobotSettings(options) LOGGER.register_console_logger(**settings.console_output_config) if settings['Critical'] or settings['NonCritical']: LOGGER.warn("Command line options --critical and --noncritical have been " "deprecated. Use --skiponfailure instead.") if settings['XUnitSkipNonCritical']: LOGGER.warn("Command line option --xunitskipnoncritical has been " "deprecated and has no effect.") LOGGER.info('Settings:\n%s' % unic(settings)) builder = TestSuiteBuilder(settings['SuiteNames'], included_extensions=settings.extension, rpa=settings.rpa, allow_empty_suite=settings.run_empty_suite) suite = builder.build(*datasources) settings.rpa = suite.rpa if settings.pre_run_modifiers: suite.visit(ModelModifier(settings.pre_run_modifiers, settings.run_empty_suite, LOGGER)) suite.configure(**settings.suite_config) with pyloggingconf.robot_handler_enabled(settings.log_level): old_max_error_lines = text.MAX_ERROR_LINES text.MAX_ERROR_LINES = settings.max_error_lines try: result = suite.run(settings) finally: text.MAX_ERROR_LINES = old_max_error_lines LOGGER.info("Tests execution ended. Statistics:\n%s" % result.suite.stat_message) if settings.log or settings.report or settings.xunit: writer = ResultWriter(settings.output if settings.log else result) writer.write_results(settings.get_rebot_settings()) return result.return_code
def _get_variable(self, var): """'var' is an instance of a VariableSplitter""" # 1) Handle reserved syntax if var.identifier not in ['$','@','%']: value = '%s{%s}' % (var.identifier, var.base) LOGGER.warn("Syntax '%s' is reserved for future use. Please " "escape it like '\\%s'." % (value, value)) return value # 2) Handle environment variables elif var.identifier == '%': try: name = var.get_replaced_base(self).strip() if name != '': return os.environ[name] else: return '%%{%s}' % var.base except KeyError: raise DataError("Environment variable '%s' does not exist" % name) # 3) Handle ${scalar} variables and @{list} variables without index elif var.index is None: name = '%s{%s}' % (var.identifier, var.get_replaced_base(self)) return self[name] # 4) Handle items from list variables e.g. @{var}[1] else: try: index = int(self.replace_string(var.index)) name = '@{%s}' % var.get_replaced_base(self) return self[name][index] except (ValueError, DataError, IndexError): raise DataError("Non-existing variable '@{%s}[%s]'" % (var.base, var.index))
def _get_variable(self, var): """'var' is an instance of a VariableSplitter""" # 1) Handle reserved syntax if var.identifier not in "$@%": value = "%s{%s}" % (var.identifier, var.base) LOGGER.warn("Syntax '%s' is reserved for future use. Please " "escape it like '\\%s'." % (value, value)) return value # 2) Handle environment variables and Java system properties elif var.identifier == "%": name = var.get_replaced_base(self).strip() if not name: return "%%{%s}" % var.base value = utils.get_env_var(name) if value is not None: return value value = getJavaSystemProperty(name) if value is not None: return value raise DataError("Environment variable '%s' does not exist" % name) # 3) Handle ${scalar} variables and @{list} variables without index elif var.index is None: name = "%s{%s}" % (var.identifier, var.get_replaced_base(self)) return self[name] # 4) Handle items from list variables e.g. @{var}[1] else: try: index = int(self.replace_string(var.index)) name = "@{%s}" % var.get_replaced_base(self) return self[name][index] except (ValueError, DataError, IndexError): raise DataError("Non-existing variable '@{%s}[%s]'" % (var.base, var.index))
def _deprecate_escaped_cells_before_continuation(self, data): index = data.index(self._row_continuation_marker) if any(cell == '\\' for cell in data[:index]): LOGGER.warn("Error in file '%s': Escaping empty cells with " "'\\' before line continuation marker '...' is " "deprecated. Remove escaping before Robot " "Framework 3.2." % self.source)
def _get_multisource_suite(sources, include_suites, warn_on_skipped, process_variables): data = [] for src in sources: try: data.append(_parse_suite(src, include_suites, warn_on_skipped)) except DataError, err: LOGGER.warn(err)
def _log_imported_library(self, name, args, lib): type = lib.__class__.__name__.replace('Library', '').lower()[1:] LOGGER.info("Imported library '%s' with arguments %s " "(version %s, %s type, %s scope, %d keywords)" % (name, utils.seq2str2(args), lib.version, type, lib.scope.lower(), len(lib))) if not lib: LOGGER.warn("Imported library '%s' contains no keywords" % name)
def _warn_about_registeration_error(self, signum, err): name, ctrlc = { signal.SIGINT: ('INT', 'or with Ctrl-C '), signal.SIGTERM: ('TERM', '') }[signum] LOGGER.warn('Registering signal %s failed. Stopping execution ' 'gracefully with this signal %sis not possible. ' 'Original error was: %s' % (name, ctrlc, err))
def _log_imported_library(self, name, args, lib): type = lib.__class__.__name__.replace('Library', '').lower()[1:] LOGGER.info("Imported library '%s' with arguments %s " "(version %s, %s type, %s scope, %d keywords)" % (name, utils.seq2str2(args), lib.version or '<unknown>', type, lib.scope.lower(), len(lib))) if not lib: LOGGER.warn("Imported library '%s' contains no keywords" % name)
def _log_warning_when_basename_already_used(self, name, other, path): msg = ("Using same base name with scalar and list variables is " "deprecated. Please change either '%s' or '%s'") % (name, other) if path: msg += " in file '%s'" % path msg += " before Robot Framework 2.6." # If path is not known we are executing keywords and can log message LOGGER.warn(msg, log=not path)
def _convert_to_new_style_metadata(self): # TODO: Remove support for olde style metadata in RF 2.10. LOGGER.warn( "Setting suite metadata using '%s' syntax is deprecated. " "Use 'Metadata' setting with name and value in separate " "cells instead." % self.head ) return ["Metadata"] + [self.head.split(":", 1)[1].strip()] + self.tail
def build_resource(data, source): resource = ResourceFile(source=source) if data.sections: ResourceBuilder(resource).visit(data) LOGGER.info("Imported resource file '%s' (%d keywords)." % (source, len(resource.keywords))) else: LOGGER.warn("Imported resource file '%s' is empty." % source) return resource
def deprecate_tags_starting_with_hyphen(node, source): for tag in node.values: if tag.startswith('-'): LOGGER.warn( f"Error in file '{source}' on line {node.lineno}: " f"Settings tags starting with a hyphen using the '[Tags]' setting " f"is deprecated. In Robot Framework 5.2 this syntax will be used " f"for removing tags. Escape '{tag}' like '\\{tag}' to use the " f"literal value and to avoid this warning.")
def _log_imported_library(self, name, args, lib): type = lib.__class__.__name__.replace('Library', '').lower()[1:] listener = ', with listener' if lib.has_listener else '' LOGGER.info("Imported library '%s' with arguments %s " "(version %s, %s type, %s scope, %d keywords%s)" % (name, seq2str2(args), lib.version or '<unknown>', type, lib.scope.lower(), len(lib), listener)) if not lib and not lib.has_listener: LOGGER.warn("Imported library '%s' contains no keywords" % name)
def _process_cell(self, cell, path): if len(cell) > 1 and cell[0] == cell[-1] == '"': cell = cell[1:-1].replace('""', '"') if path not in self._warned_escaping: LOGGER.warn("Un-escaping quotes in TSV files is deprecated. " "Change cells in '%s' to not contain surrounding " "quotes." % path) self._warned_escaping.add(path) return cell
def build(self, source): LOGGER.info("Parsing resource file '%s'." % source) resource = self._parse(source) if resource.imports or resource.variables or resource.keywords: LOGGER.info("Imported resource file '%s' (%d keywords)." % (source, len(resource.keywords))) else: LOGGER.warn("Imported resource file '%s' is empty." % source) return resource
def _process_deprecated_cli_opts(self, opts): for oldname, newname in self._deprecated.items(): if oldname not in opts or opts[oldname] in [None, []]: continue if newname: LOGGER.warn("Option '--%s' is deprecated. Use '--%s' instead." % (oldname, newname)) opts[newname] = opts[oldname] else: LOGGER.error("Option '--%s' has been removed." % oldname)
def _run_tests(self, context, errors): executed_tests = [] for test in self.tests: normname = utils.normalize(test.name) if normname in executed_tests: LOGGER.warn("Multiple test cases with name '%s' executed in " "test suite '%s'" % (test.name, self.longname)) executed_tests.append(normname) test.run(context, errors) context.set_prev_test_variables(test)
def _run_tests(self, context, errors): executed_tests = [] for test in self.tests: normname = utils.normalize(test.name) if normname in executed_tests: LOGGER.warn("Multiple test cases with name '%s' executed in " "test suite '%s'"% (test.name, self.longname)) executed_tests.append(normname) test.run(context, errors) context.set_prev_test_variables(test)
def _process_deprecated_cli_opts(self, opts): for oldname, newname in self._deprecated.items(): if oldname not in opts or opts[oldname] in [None, []]: continue if newname: LOGGER.warn( "Option '--%s' is deprecated. Use '--%s' instead." % (oldname, newname)) opts[newname] = opts[oldname] else: LOGGER.error("Option '--%s' has been removed." % oldname)
def _get_var_table_scalar_value(self, name, value, path=None): if len(value) == 1: return self.replace_scalar(value[0]) msg = ("Creating a scalar variable with a list value in the Variable " "table is deprecated and this functionality will be removed in " "Robot Framework 2.8. Create a list variable '@%s' and use " "it as a scalar variable '%s' instead" % (name[1:], name)) if path: msg += " in file '%s'" % path LOGGER.warn(msg + '.') return self.replace_list(value)
def _check_deprecations(self, cells, path, line_number): for original in cells: normalized = ' '.join(original.split()) if normalized != original: if len(normalized) != len(original): msg = 'Collapsing consecutive whitespace' else: msg = 'Converting whitespace characters to ASCII spaces' LOGGER.warn("%s during parsing is deprecated. Fix %s in file " "'%s' on line %d." % (msg, prepr(original), path, line_number)) yield normalized
def main(self, datasources, **options): settings = RebotSettings(options) LOGGER.register_console_logger(**settings.console_output_config) if settings['XUnitSkipNonCritical']: LOGGER.warn( "Command line option --xunitskipnoncritical has been deprecated." ) LOGGER.disable_message_cache() rc = ResultWriter(*datasources).write_results(settings) if rc < 0: raise DataError('No outputs created.') return rc
def _check_deprecations(self, cells, path, line_number): for original in cells: normalized = self._normalize_whitespace(original) if normalized != original: if len(normalized) != len(original): msg = 'Collapsing consecutive whitespace' else: msg = 'Converting whitespace characters to ASCII spaces' LOGGER.warn("%s during parsing is deprecated. Fix %s in file " "'%s' on line %d." % (msg, prepr(original), path, line_number)) yield normalized
def _validate_arguments_exist(self, arguments): valid = [] nonex = [] for arg in arguments: (valid if os.path.exists(arg) else nonex).append(arg) if nonex: s, were = ('s', 'were') if len(nonex) > 1 else ('', 'was') LOGGER.warn("Argument%s %s did not exist and %s ignored. " "Validate the used command line syntax." % (s, seq2str(nonex), were)) if not valid: raise DataError('No valid arguments given.') return valid
def _removed_in_26(self, name, log): start, instead = { 'SplitOutputs': ('Splitting outputs is', 'The --splitlog option can be used instead. '), 'Summary': ('Summary reports are', ''), 'SummaryTitle': ('Summary titles are', '') }[name] option, default = self._cli_opts[name] if log: LOGGER.warn('%s not supported in Robot Framework 2.6 or newer. %s' 'The --%s option will be removed altogether in ' 'version 2.7.' % (start, instead, option)) return default
def build_resource(data, source): resource = ResourceFile(source=source) if data.data_sections: ErrorLogger(source).visit(data) if data.has_tests: raise DataError("Resource file '%s' cannot contain tests or tasks." % source) ResourceBuilder(resource).visit(data) LOGGER.info("Imported resource file '%s' (%d keywords)." % (source, len(resource.keywords))) else: LOGGER.warn("Imported resource file '%s' is empty." % source) return resource
def _check_deprecated_extensions(self, source): if os.path.isdir(source): return ext = os.path.splitext(source)[1][1:].lower() if self.extensions and ext in self.extensions: return # HTML files cause deprecation warning that cannot be avoided with # --extension at parsing time. No need for double warning. if ext not in ('robot', 'html', 'htm', 'xhtml'): LOGGER.warn("Automatically parsing other than '*.robot' files is " "deprecated. Convert '%s' to '*.robot' format or use " "'--extension' to explicitly configure which files to " "parse." % source)
def _unescape_opts_and_args(self, opts, args): from robot.output import LOGGER with LOGGER.cache_only: LOGGER.warn("Option '--escape' is deprecated. Use console escape " "mechanism instead.") try: escape_strings = opts['escape'] except KeyError: raise FrameworkError("No 'escape' in options") escapes = self._get_escapes(escape_strings) for name, value in opts.items(): if name != 'escape': opts[name] = self._unescape(value, escapes) return opts, [self._unescape(arg, escapes) for arg in args]
def _process_value(self, name, value): if name in ['ReRunFailed', 'DeprecatedRunFailed']: return gather_failed_tests(value) if name == 'LogLevel': return self._process_log_level(value) if value == self._get_default_value(name): return value if name in ['Name', 'Doc', 'LogTitle', 'ReportTitle']: if name == 'Doc': value = self._escape_as_data(value) return value.replace('_', ' ') if name in ['Metadata', 'TagDoc']: if name == 'Metadata': value = [self._escape_as_data(v) for v in value] return [self._process_metadata_or_tagdoc(v) for v in value] if name in ['Include', 'Exclude']: return [self._format_tag_patterns(v) for v in value] if name in self._output_opts and (not value or value.upper() == 'NONE'): return None if name == 'DeprecatedXUnit': LOGGER.warn( 'Option --xunitfile is deprecated. Use --xunit instead.') return self._process_value('XUnit', value) if name == 'OutputDir': return utils.abspath(value) if name in ['SuiteStatLevel', 'MonitorWidth']: return self._convert_to_positive_integer_or_default(name, value) if name in ['Listeners', 'VariableFiles']: return [self._split_args_from_name_or_path(item) for item in value] if name == 'ReportBackground': return self._process_report_background(value) if name == 'TagStatCombine': return [self._process_tag_stat_combine(v) for v in value] if name == 'TagStatLink': return [ v for v in [self._process_tag_stat_link(v) for v in value] if v ] if name == 'Randomize': return self._process_randomize_value(value) if name == 'RunMode': LOGGER.warn( 'Option --runmode is deprecated in Robot Framework 2.8 ' 'and will be removed in the future.') return [self._process_runmode_value(v) for v in value] if name == 'RemoveKeywords': self._validate_remove_keywords(value) if name == 'FlattenKeywords': self._validate_flatten_keywords(value) return value
def read(self, htmlfile, populator, path=None): self.populator = populator self.state = self.IGNORE self.current_row = None self.current_cell = None for line in htmlfile.readlines(): self.feed(self._decode(line)) # Calling close is required by the HTMLParser but may cause problems # if the same instance of our HtmlParser is reused. Currently it's # used only once so there's no problem. self.close() if self.populator.eof(): LOGGER.warn("Using test data in HTML format is deprecated. " "Convert '%s' to plain text format." % (path or htmlfile.name))
def main(self, datasources, **options): settings = RebotSettings(options) LOGGER.register_console_logger(**settings.console_output_config) if settings['Critical'] or settings['NonCritical']: LOGGER.warn("Command line options --critical and --noncritical have been " "deprecated and have no effect with Rebot. Use --skiponfailure " "when starting execution instead.") if settings['XUnitSkipNonCritical']: LOGGER.warn("Command line option --xunitskipnoncritical has been " "deprecated and has no effect.") LOGGER.disable_message_cache() rc = ResultWriter(*datasources).write_results(settings) if rc < 0: raise DataError('No outputs created.') return rc
def _process_value(self, name, value): if name == 'ReRunFailed': return gather_failed_tests(value) if name == 'ReRunFailedSuites': return gather_failed_suites(value) if name == 'LogLevel': return self._process_log_level(value) if value == self._get_default_value(name): return value if name == 'Doc': return self._escape_as_data(value) if name in ['Metadata', 'TagDoc']: if name == 'Metadata': value = [self._escape_as_data(v) for v in value] return [self._process_metadata_or_tagdoc(v) for v in value] if name in ['Include', 'Exclude']: return [self._format_tag_patterns(v) for v in value] if name in self._output_opts and (not value or value.upper() == 'NONE'): return None if name == 'OutputDir': return abspath(value) if name in ['SuiteStatLevel', 'ConsoleWidth']: return self._convert_to_positive_integer_or_default(name, value) if name == 'VariableFiles': return [split_args_from_name_or_path(item) for item in value] if name == 'ReportBackground': return self._process_report_background(value) if name == 'TagStatCombine': return [self._process_tag_stat_combine(v) for v in value] if name == 'TagStatLink': return [ v for v in [self._process_tag_stat_link(v) for v in value] if v ] if name == 'Randomize': return self._process_randomize_value(value) if name == 'MaxErrorLines': return self._process_max_error_lines(value) if name == 'RemoveKeywords': self._validate_remove_keywords(value) if name == 'FlattenKeywords': self._validate_flatten_keywords(value) if name == 'WarnOnSkipped': with LOGGER.cache_only: LOGGER.warn("Option '--warnonskippedfiles' is deprecated and " "has no effect. Nowadays all skipped files are " "reported.") return value
def _import_library(self, name, positional, named, lib): key = (name, positional, named) if self._libraries.has_key(key): LOGGER.info("Found test library '%s' with arguments %s from cache" % (name, utils.seq2str2(positional))) return self._libraries[key] lib.create_handlers() self._libraries[key] = lib libtype = lib.__class__.__name__.replace('Library', '').lower()[1:] LOGGER.info("Imported library '%s' with arguments %s (version %s, " "%s type, %s scope, %d keywords, source %s)" % (name, utils.seq2str2(positional), lib.version, libtype, lib.scope.lower(), len(lib), lib.source)) if len(lib) == 0: LOGGER.warn("Imported library '%s' contains no keywords" % name) return lib
def _process_value(self, name, value): if name == 'ReRunFailed': return gather_failed_tests(value) if name == 'DeprecatedRunFailed': if value.upper() != 'NONE': LOGGER.warn('Option --runfailed is deprecated and will be ' 'removed in the future. Use --rerunfailed instead.') return gather_failed_tests(value) if name == 'DeprecatedMerge' and value is True: LOGGER.warn('Option --rerunmerge is deprecated and will be ' 'removed in the future. Use --merge instead.') if name == 'LogLevel': return self._process_log_level(value) if value == self._get_default_value(name): return value if name in ['Name', 'Doc', 'LogTitle', 'ReportTitle']: if name == 'Doc': value = self._escape_as_data(value) return value.replace('_', ' ') if name in ['Metadata', 'TagDoc']: if name == 'Metadata': value = [self._escape_as_data(v) for v in value] return [self._process_metadata_or_tagdoc(v) for v in value] if name in ['Include', 'Exclude']: return [self._format_tag_patterns(v) for v in value] if name in self._output_opts and (not value or value.upper() == 'NONE'): return None if name == 'OutputDir': return utils.abspath(value) if name in ['SuiteStatLevel', 'MonitorWidth']: return self._convert_to_positive_integer_or_default(name, value) if name in ['PreRunModifiers', 'PreRebotModifiers', 'Listeners', 'VariableFiles']: return [self._split_args_from_name_or_path(item) for item in value] if name == 'ReportBackground': return self._process_report_background(value) if name == 'TagStatCombine': return [self._process_tag_stat_combine(v) for v in value] if name == 'TagStatLink': return [v for v in [self._process_tag_stat_link(v) for v in value] if v] if name == 'Randomize': return self._process_randomize_value(value) if name == 'RemoveKeywords': self._validate_remove_keywords(value) if name == 'FlattenKeywords': self._validate_flatten_keywords(value) return value
def _filter_stdlib_handler(self, handler1, handler2): if handler1.library.orig_name in STDLIB_NAMES: standard, external = handler1, handler2 elif handler2.library.orig_name in STDLIB_NAMES: standard, external = handler2, handler1 else: return [handler1, handler2] if not RUN_KW_REGISTER.is_run_keyword(external.library.orig_name, external.name): LOGGER.warn( "Keyword '%s' found both from a user created test library " "'%s' and Robot Framework standard library '%s'. The user " "created keyword is used. To select explicitly, and to get " "rid of this warning, use either '%s' or '%s'." % (standard.name, external.library.orig_name, standard.library.orig_name, external.longname, standard.longname)) return [external]
def _import_library(self, name, positional, named, lib): key = (name, positional, named) if self._libraries.has_key(key): LOGGER.info( "Found test library '%s' with arguments %s from cache" % (name, utils.seq2str2(positional))) return self._libraries[key] lib.create_handlers() self._libraries[key] = lib libtype = lib.__class__.__name__.replace('Library', '').lower()[1:] LOGGER.info("Imported library '%s' with arguments %s (version %s, " "%s type, %s scope, %d keywords, source %s)" % (name, utils.seq2str2(positional), lib.version, libtype, lib.scope.lower(), len(lib), lib.source)) if len(lib) == 0: LOGGER.warn("Imported library '%s' contains no keywords" % name) return lib
def _process_value(self,name,value): if name =='RunFailed': return gather_failed_tests(value) if name =='LogLevel': return self._process_log_level(value) if value == self._get_default_value(name): return value if name in ['Name','Doc','LogTitle','ReportTitle']: if name =='Doc': value= self._escape_as_data(value) return value.replace('_',' ') if name in ['Metadata','TagDoc']: if name == 'Metadata': value = [self._escape_as_data(v) for v in value] return [self._process_metadata_or_tagdoc(v) for v in value] if name in ['Include','Exclude']: return [v.replace('AND','&').replace('_','') for in value] if name in self._output_opts and (not value or value.upper()=='NONE'): return None if name =='DeprecatedXUnit': LOGGER.warn('Option --xunitfile is deprecated use --xunit instead') return self._process_value('XUnit',value) if name =='OutputDir': return utils.abspath(value) if name in ['SuiteStatLevel','MonitorWidth']: return self._convert_to_positive_integer_or_default(name,value) if name in ['Listeners','VariableFiles']: return [self._split_args_from_name_or_path(item) for item in value] if name =='ReportBackground': return self._process_report_background(value) if name =='TagStatCombine': return [self._process_tag_stat_combine(v) for v in value] if name =='TagStatLink': return [v for v in [self._process_tag_stat_link(v) for v in value ] if v] if name =='Randomize': return self._process_randomize_value(value) if name =='RemoveKeywords': return [v.upper() for v in value] if name =='RunMode': LOGGER.warn('Option --runmode is deprecated in robot Framework 2.8' 'and will be removed in the future' ) return [self._process_runmode_value(v) for v in value] return value
def set_runmode(self, runmode): origmode = runmode runmode = runmode.upper() if runmode == 'EXITONFAILURE': self._run_mode_exit_on_failure = True elif runmode == 'SKIPTEARDOWNONEXIT': self._run_mode_skip_teardowns_on_exit = True elif runmode == 'DRYRUN': self._run_mode_dry_run = True elif runmode == 'RANDOM:TEST': random.shuffle(self.tests) elif runmode == 'RANDOM:SUITE': random.shuffle(self.suites) elif runmode == 'RANDOM:ALL': random.shuffle(self.suites) random.shuffle(self.tests) else: from robot.output import LOGGER # avoid recursive import LOGGER.warn("Option '--runmode' does not support value '%s'." % origmode) return for suite in self.suites: suite.set_runmode(runmode)
def _get_variable(self, var): """'var' is an instance of a VariableSplitter""" # 1) Handle reserved syntax if var.identifier not in '$@%': value = '%s{%s}' % (var.identifier, var.base) LOGGER.warn("Syntax '%s' is reserved for future use. Please " "escape it like '\\%s'." % (value, value)) return value # 2) Handle environment variables and Java system properties elif var.identifier == '%': name = var.get_replaced_base(self).strip() if not name: return '%%{%s}' % var.base value = utils.get_env_var(name) if value is not None: return value value = getJavaSystemProperty(name) if value is not None: return value msg = "Environment variable '%%{%s}' not found." % name self._raise_non_existing_variable('%%{%s}' % name, msg, env_vars=True) # 3) Handle ${scalar} variables and @{list} variables without index elif var.index is None: name = '%s{%s}' % (var.identifier, var.get_replaced_base(self)) return self[name] # 4) Handle items from list variables e.g. @{var}[1] else: try: index = int(self.replace_string(var.index)) name = '@{%s}' % var.get_replaced_base(self) return self[name][index] except (ValueError, DataError, IndexError): msg = ("Variable '@{%s}[%s]' not found." % (var.base, var.index)) self._raise_non_existing_variable(var.base, msg)
def _get_reserved_variable(self, splitter): value = splitter.get_replaced_variable(self) LOGGER.warn("Syntax '%s' is reserved for future use. Please " "escape it like '\\%s'." % (value, value)) return value
def _log_failed_parsing(self, message, warn): if warn: LOGGER.warn(message) else: LOGGER.info(message)
def _report_status(self): if self.setting_table or self.variable_table or self.keyword_table: LOGGER.info("Imported resource file '%s' (%d keywords)." % (self.source, len(self.keyword_table.keywords))) else: LOGGER.warn("Imported resource file '%s' is empty." % self.source)
def _deprecate_empty_data_cells(self, cells, path, line_number): data_cells = dropwhile(lambda c: not c, cells) if not all(data_cells): LOGGER.warn("TSV file '%s' has empty data cells which is " "deprecated and must be fixed. Escape empty cells " "on line %d with '${EMPTY}'." % (path, line_number))