def _normalize(self, tags): normalized = NormalizedDict([(unic(t), None) for t in tags], ignore='_') for remove in '', 'NONE': if remove in normalized: normalized.pop(remove) return tuple(normalized)
class VariableStore(object): def __init__(self, variables): self.store = NormalizedDict(ignore='_') self._variables = variables def resolve_delayed(self): for name, value in self.store.items(): try: self._resolve_delayed(name, value) except DataError: pass def _resolve_delayed(self, name, value): if not isinstance(value, DelayedVariable): return value self.store[name] = value.resolve(name, self._variables) return self.store[name] def find(self, name): return self._resolve_delayed(name, self.store[name]) def __getitem__(self, name): return self.find(name) # TODO: __getitem__ vs find def clear(self): self.store.clear() def add(self, name, value, overwrite=True): if overwrite or name not in self.store: self.store[name] = value def remove(self, name): if name in self.store: self.store.pop(name) def __len__(self): return len(self.store) def __iter__(self): return iter(self.store) def __contains__(self, name): return name in self.store
def _normalize(self, tags): normalized = NormalizedDict(((unic(t), 1) for t in tags), ignore='_') for removed in '', 'NONE': if removed in normalized: normalized.pop(removed) return tuple(normalized)
class VariableStore(object): def __init__(self, variables): self.data = NormalizedDict(ignore='_') self._variables = variables def resolve_delayed(self): for name, value in self.data.items(): try: self._resolve_delayed(name, value) except DataError: pass def _resolve_delayed(self, name, value): if not isinstance(value, VariableTableValueBase): return value try: self.data[name] = value.resolve(self._variables) except DataError as err: # Recursive resolving may have already removed variable. if name in self: self.remove(name) value.report_error(err) raise_not_found('${%s}' % name, self.data, "Variable '${%s}' not found." % name) return self.data[name] def __getitem__(self, name): return self._resolve_delayed(name, self.data[name]) def update(self, store): self.data.update(store.data) def clear(self): self.data.clear() def add(self, name, value, overwrite=True, decorated=True): if decorated: name, value = self._undecorate(name, value) if overwrite or name not in self.data: self.data[name] = value def _undecorate(self, name, value): validate_var(name) if name[0] == '@': if not is_list_like(value): self._raise_cannot_set_type(name, value, 'list') value = list(value) if name[0] == '&': if not is_dict_like(value): self._raise_cannot_set_type(name, value, 'dictionary') value = DotDict(value) return name[2:-1], value def _raise_cannot_set_type(self, name, value, expected): raise DataError("Cannot set variable '%s': Expected %s-like value, " "got %s." % (name, expected, type_name(value))) def remove(self, name): if name in self.data: self.data.pop(name) def __len__(self): return len(self.data) def __iter__(self): return iter(self.data) def __contains__(self, name): return name in self.data def as_dict(self): variables = (self._decorate(name, self[name]) for name in self) return NormalizedDict(variables, ignore='_') def _decorate(self, name, value): if is_dict_like(value): name = '&{%s}' % name elif is_list_like(value): name = '@{%s}' % name else: name = '${%s}' % name return name, value
class HandlerStore(object): def __init__(self, source): self._source = source self._normal = NormalizedDict(ignore='_') self._embedded = [] def add(self, handler, embedded=False): if embedded: self._embedded.append(handler) else: self._normal[handler.name] = handler def remove(self, name): if name in self._normal: self._normal.pop(name) self._embedded = [e for e in self._embedded if not e.matches(name)] def __iter__(self): return iter(sorted(self._normal.values() + self._embedded, key=attrgetter('name'))) def __len__(self): return len(self._normal) + len(self._embedded) def __contains__(self, name): if name in self._normal: return True return any(template.matches(name) for template in self._embedded) def __getitem__(self, name): try: return self._normal[name] except KeyError: return self._find_embedded(name) def _find_embedded(self, name): embedded = [template.create(name) for template in self._embedded if template.matches(name)] if len(embedded) == 1: return embedded[0] self._raise_no_single_match(name, embedded) def _raise_no_single_match(self, name, found): if self._source is None: where = "Test case file" elif self._is_resource(self._source): where = "Resource file '%s'" % self._source else: where = "Test library '%s'" % self._source if not found: raise DataError("%s contains no keywords matching name '%s'." % (where, name)) error = ["%s contains multiple keywords matching name '%s':" % (where, name)] names = sorted(handler.orig_name for handler in found) raise DataError('\n '.join(error + names)) def _is_resource(self, source): extension = splitext(source)[1][1:].lower() return extension in RESOURCE_EXTENSIONS
def test_pop(self): nd = NormalizedDict({'A': 1, 'b': 2}) assert_equal(nd.pop('A'), 1) assert_equal(nd.pop('B'), 2) assert_equal(nd._data, {}) assert_equal(list(nd.keys()), [])
def test_popping_items(self): nd = NormalizedDict({'A': 1, 'b': 2}) assert_equals(nd.pop('A'), 1) assert_equals(nd.pop('B'), 2) assert_equals(nd.data, {}) assert_equals(nd.keys(), [])
class VariableStore(object): def __init__(self, variables): self.data = NormalizedDict(ignore='_') self._variables = variables def resolve_delayed(self, item=None): if item: return self._resolve_delayed(*item) for name, value in list(self.data.items()): try: self._resolve_delayed(name, value) except DataError: pass def _resolve_delayed(self, name, value): if not self._is_resolvable(value): return value try: self.data[name] = value.resolve(self._variables) except DataError as err: # Recursive resolving may have already removed variable. if name in self: self.remove(name) value.report_error(err) variable_not_found('${%s}' % name, self.data, "Variable '${%s}' not found." % name) return self.data[name] def _is_resolvable(self, value): try: # isinstance can throw an exception in ironpython and jython return isinstance(value, VariableTableValueBase) except Exception: return False def __getitem__(self, name): return self._resolve_delayed(name, self.data[name]) def update(self, store): self.data.update(store.data) def clear(self): self.data.clear() def add(self, name, value, overwrite=True, decorated=True): if decorated: name, value = self._undecorate(name, value) if overwrite or name not in self.data: self.data[name] = value def _undecorate(self, name, value): validate_var(name) if name[0] == '@': if not is_list_like(value): self._raise_cannot_set_type(name, value, 'list') value = list(value) if name[0] == '&': if not is_dict_like(value): self._raise_cannot_set_type(name, value, 'dictionary') value = DotDict(value) return name[2:-1], value def _raise_cannot_set_type(self, name, value, expected): raise VariableError("Cannot set variable '%s': Expected %s-like value, " "got %s." % (name, expected, type_name(value))) def remove(self, name): if name in self.data: self.data.pop(name) def __len__(self): return len(self.data) def __iter__(self): return iter(self.data) def __contains__(self, name): return name in self.data def as_dict(self, decoration=True): if decoration: variables = (self._decorate(name, self[name]) for name in self) else: variables = self.data return NormalizedDict(variables, ignore='_') def _decorate(self, name, value): if is_dict_like(value): name = '&{%s}' % name elif is_list_like(value): name = '@{%s}' % name else: name = '${%s}' % name return name, value
def test_pop(self): nd = NormalizedDict({'A': 1, 'b': 2}) assert_equals(nd.pop('A'), 1) assert_equals(nd.pop('B'), 2) assert_equals(nd.data, {}) assert_equals(nd.keys(), [])
def _normalize(self, tags): normalized = NormalizedDict(((t, 1) for t in tags), ignore='_') for removed in '', 'NONE': if removed in normalized: normalized.pop(removed) return tuple(normalized)
def _deduplicate_normalized(self, tags): normalized = NormalizedDict(((unic(t), 1) for t in tags), ignore='_') for removed in '', 'NONE': if removed in normalized: normalized.pop(removed) return tuple(normalized)
class VariableStore(object): def __init__(self, variables): self.data = NormalizedDict(ignore='_') self._variables = variables def resolve_delayed(self): for name, value in self.data.items(): try: self._resolve_delayed(name, value) except DataError: pass def _resolve_delayed(self, name, value): if not isinstance(value, VariableTableValueBase): return value try: self.data[name] = value.resolve(self._variables) except DataError as err: # Recursive resolving may have already removed variable. if name in self: self.remove(name) value.report_error(err) raise_not_found('${%s}' % name, self.data, "Variable '${%s}' not found." % name) return self.data[name] def find(self, name): return self._resolve_delayed(name, self.data[name]) def __getitem__(self, name): return self.find(name) # TODO: __getitem__ vs find def clear(self): self.data.clear() def add(self, name, value, overwrite=True, decorated=True): if decorated: name, value = self._undecorate(name, value) if overwrite or name not in self.data: self.data[name] = value def _undecorate(self, name, value): validate_var(name) if name[0] == '@': if not is_list_like(value): self._raise_cannot_set_type(name, value, 'list') value = list(value) if name[0] == '&': if not is_dict_like(value): self._raise_cannot_set_type(name, value, 'dictionary') value = DotDict(value) return name[2:-1], value def _raise_cannot_set_type(self, name, value, expected): raise DataError("Cannot set variable '%s': Expected %s-like value, " "got %s." % (name, expected, type_name(value))) def remove(self, name): if name in self.data: self.data.pop(name) def __len__(self): return len(self.data) def __iter__(self): return iter(self.data) def __contains__(self, name): return name in self.data
class HandlerStore(object): def __init__(self, source): self._source = source self._normal = NormalizedDict(ignore='_') self._embedded = [] def add(self, handler, embedded=False): if embedded: self._embedded.append(handler) else: self._normal[handler.name] = handler def remove(self, name): if name in self._normal: self._normal.pop(name) self._embedded = [e for e in self._embedded if not e.matches(name)] def __iter__(self): return iter( sorted(self._normal.values() + self._embedded, key=attrgetter('name'))) def __len__(self): return len(self._normal) + len(self._embedded) def __contains__(self, name): if name in self._normal: return True return any(template.matches(name) for template in self._embedded) def __getitem__(self, name): try: return self._normal[name] except KeyError: return self._find_embedded(name) def _find_embedded(self, name): embedded = [ template.create(name) for template in self._embedded if template.matches(name) ] if len(embedded) == 1: return embedded[0] self._raise_no_single_match(name, embedded) def _raise_no_single_match(self, name, found): if self._source is None: where = "Test case file" elif self._is_resource(self._source): where = "Resource file '%s'" % self._source else: where = "Test library '%s'" % self._source if not found: raise DataError("%s contains no keywords matching name '%s'." % (where, name)) error = [ "%s contains multiple keywords matching name '%s':" % (where, name) ] names = sorted(handler.orig_name for handler in found) raise DataError('\n '.join(error + names)) def _is_resource(self, source): extension = splitext(source)[1][1:].lower() return extension in RESOURCE_EXTENSIONS
def test_popping_items(self): nd = NormalizedDict({"A": 1, "b": 2}) assert_equals(nd.pop("A"), 1) assert_equals(nd.pop("B"), 2) assert_equals(nd.data, {}) assert_equals(nd.keys(), [])
class VariableStore: def __init__(self, variables): self.data = NormalizedDict(ignore='_') self._variables = variables def resolve_delayed(self, item=None): if item: return self._resolve_delayed(*item) for name, value in list(self.data.items()): try: self._resolve_delayed(name, value) except DataError: pass def _resolve_delayed(self, name, value): if not self._is_resolvable(value): return value try: self.data[name] = value.resolve(self._variables) except DataError as err: # Recursive resolving may have already removed variable. if name in self.data: self.data.pop(name) value.report_error(err) variable_not_found('${%s}' % name, self.data) return self.data[name] def _is_resolvable(self, value): try: return isinstance(value, Resolvable) except Exception: return False def __getitem__(self, name): if name not in self.data: variable_not_found('${%s}' % name, self.data) return self._resolve_delayed(name, self.data[name]) def get(self, name, default=NOT_SET, decorated=True): try: if decorated: name = self._undecorate(name) return self[name] except VariableError: if default is NOT_SET: raise return default def update(self, store): self.data.update(store.data) def clear(self): self.data.clear() def add(self, name, value, overwrite=True, decorated=True): if decorated: name, value = self._undecorate_and_validate(name, value) if (overwrite or name not in self.data or isinstance(self.data[name], GlobalVariableValue)): self.data[name] = value def _undecorate(self, name): if not is_assign(name): raise VariableError("Invalid variable name '%s'." % name) return name[2:-1] def _undecorate_and_validate(self, name, value): undecorated = self._undecorate(name) if name[0] == '@': if not is_list_like(value): self._raise_cannot_set_type(name, value, 'list') value = list(value) if name[0] == '&': if not is_dict_like(value): self._raise_cannot_set_type(name, value, 'dictionary') value = DotDict(value) return undecorated, value def _raise_cannot_set_type(self, name, value, expected): raise VariableError( "Cannot set variable '%s': Expected %s-like value, got %s." % (name, expected, type_name(value))) def __len__(self): return len(self.data) def __iter__(self): return iter(self.data) def __contains__(self, name): return name in self.data def as_dict(self, decoration=True): if decoration: variables = (self._decorate(name, self[name]) for name in self) else: variables = self.data return NormalizedDict(variables, ignore='_') def _decorate(self, name, value): if is_dict_like(value): name = '&{%s}' % name elif is_list_like(value): name = '@{%s}' % name else: name = '${%s}' % name return name, value