def test_structure(self): error = self._failing_import('NoneExisting') quote = "'" if PY3 else '' type = 'Import' if sys.version_info < (3, 6) else 'ModuleNotFound' message = ("Importing 'NoneExisting' failed: {type}Error: No module " "named {q}NoneExisting{q}".format(q=quote, type=type)) expected = (message, self._get_traceback(error), self._get_pythonpath(error), self._get_classpath(error)) assert_equal(unicode(error), '\n'.join(expected).strip())
def _block(self, error, start, end=None): include = False for line in unicode(error).splitlines(): if line == end: return if line == start: include = True if include: yield line
def _convert_arguments(self): return [{ 'name': a.name, 'type': a.type_repr, 'default': a.default_repr, 'kind': a.kind, 'required': a.required, 'repr': unicode(a) } for a in self.args]
def _arg_to_dict(self, arg): return { 'name': arg.name, 'type': arg.type_repr, 'default': arg.default_repr, 'kind': arg.kind, 'required': arg.required, 'repr': unicode(arg) }
def test_string_reprs(self): for for_, exp_str, exp_repr in [ (For(), 'FOR IN ', "For(variables=(), flavor='IN', values=())"), (For(('${x}',), 'IN RANGE', ('10',)), 'FOR ${x} IN RANGE 10', "For(variables=('${x}',), flavor='IN RANGE', values=('10',))"), (For(('${x}', '${y}'), 'IN ENUMERATE', ('a', 'b')), 'FOR ${x} ${y} IN ENUMERATE a b', "For(variables=('${x}', '${y}'), flavor='IN ENUMERATE', values=('a', 'b'))"), (For([u'${\xfc}'], 'IN', [u'f\xf6\xf6']), u'FOR ${\xfc} IN f\xf6\xf6', u"For(variables=[%r], flavor='IN', values=[%r])" % (u'${\xfc}', u'f\xf6\xf6')) ]: assert_equal(unicode(for_), exp_str) assert_equal(repr(for_), 'robot.model.' + exp_repr) if PY2: assert_equal(str(for_), unicode(for_).encode('UTF-8'))
def test_string_reprs(self): for if_, exp_str, exp_repr in [ (IfBranch(), 'IF None', "IfBranch(type='IF', condition=None)"), (IfBranch(condition='$x > 1'), 'IF $x > 1', "IfBranch(type='IF', condition='$x > 1')"), (IfBranch(ELSE_IF, condition='$x > 2'), 'ELSE IF $x > 2', "IfBranch(type='ELSE IF', condition='$x > 2')"), (IfBranch(ELSE), 'ELSE', "IfBranch(type='ELSE', condition=None)"), (IfBranch(condition=u'$x == "\xe4iti"'), u'IF $x == "\xe4iti"', u"IfBranch(type='IF', condition=%r)" % u'$x == "\xe4iti"'), ]: assert_equal(unicode(if_), exp_str) assert_equal(repr(if_), 'robot.model.' + exp_repr) if PY2: assert_equal(str(if_), unicode(if_).encode('UTF-8'))
def __init__(self, tag_pattern, name=None, critical=True, doc='', links=None): TagStat.__init__(self, name or unicode(tag_pattern), doc, links, critical=critical, non_critical=not critical) self.pattern = tag_pattern
def test_string_repr(self): for token, exp_str, exp_repr in [ ((Token.ELSE_IF, 'ELSE IF', 6, 4), 'ELSE IF', "Token('ELSE IF', 'ELSE IF', 6, 4)"), ((Token.KEYWORD, u'Hyv\xe4', 6, 4), u'Hyv\xe4', u"Token('KEYWORD', %r, 6, 4)" % u'Hyv\xe4'), ((Token.ERROR, 'bad value', 6, 4, 'The error.'), 'bad value', "Token('ERROR', 'bad value', 6, 4, 'The error.')") ]: token = Token(*token) assert_equal(unicode(token), exp_str) assert_equal(repr(token), exp_repr)
def test_string_reprs(self): for kw, exp_str, exp_repr in [ (Keyword(), '', "Keyword(name='', args=(), assign=())"), (Keyword('name'), 'name', "Keyword(name='name', args=(), assign=())"), (Keyword(None), 'None', "Keyword(name=None, args=(), assign=())"), (Keyword('Name', args=('a1', 'a2')), 'Name a1 a2', "Keyword(name='Name', args=('a1', 'a2'), assign=())"), (Keyword('Name', assign=('${x}', '${y}')), '${x} ${y} Name', "Keyword(name='Name', args=(), assign=('${x}', '${y}'))"), (Keyword('Name', assign=['${x}='], args=['x']), '${x}= Name x', "Keyword(name='Name', args=['x'], assign=['${x}='])"), (Keyword('Name', args=(1, 2, 3)), 'Name 1 2 3', "Keyword(name='Name', args=(1, 2, 3), assign=())"), (Keyword(assign=[u'${\xe3}'], name=u'\xe4', args=[u'\xe5']), u'${\xe3} \xe4 \xe5', u'Keyword(name=%r, args=[%r], assign=[%r])' % (u'\xe4', u'\xe5', u'${\xe3}')) ]: assert_equal(unicode(kw), exp_str) assert_equal(repr(kw), 'robot.model.' + exp_repr) if PY2: assert_equal(str(kw), unicode(kw).encode('UTF-8'))
def get_attributes(self, include_label=False, include_elapsed=False, exclude_empty=True, values_as_strings=False, html_escape=False): attrs = {'pass': self.passed, 'fail': self.failed} attrs.update(self._get_custom_attrs()) if include_label: attrs['label'] = self.name if include_elapsed: attrs['elapsed'] = elapsed_time_to_string(self.elapsed, include_millis=False) if exclude_empty: attrs = dict((k, v) for k, v in attrs.items() if v not in ('', None)) if values_as_strings: attrs = dict((k, unicode(v if v is not None else '')) for k, v in attrs.items()) if html_escape: attrs = dict((k, self._html_escape(v)) for k, v in attrs.items()) return attrs
def _verify(self, expected, positional_or_named=None, **config): spec = ArgumentSpec(positional_or_named=positional_or_named, **config) assert_equal(unicode(spec), expected) assert_equal(bool(spec), bool(expected))
def __str__(self): return ' NOT '.join(unicode(pattern) for pattern in self).lstrip()
def test_unicode(self): assert_equal(unicode(Tags()), '[]') assert_equal(unicode(Tags(['y', "X'X", 'Y'])), "[X'X, y]") assert_equal(unicode(Tags([u'\xe4', 'a'])), u'[a, \xe4]')
def __str__(self): parts = list(self.assign) + [self.name] + list(self.args) return ' '.join(unicode(p) for p in parts)
def __unicode__(self): return ' AND '.join(unicode(pattern) for pattern in self)
def __unicode__(self): return u'[%s]' % ', '.join(unicode(item) for item in self)
def _show_keyword(self, kw, show_name=True): if show_name: self._header(kw.name, underline='-') self._data([('Arguments', '[%s]' % unicode(kw.args))]) self._doc(kw.doc)
def _verify_string_representation(self, source, expected): assert_equal(unicode(source), expected) assert_equal(u'-%s-' % source, '-%s-' % expected)
def __unicode__(self): return u'[%s]' % u', '.join(unicode(pattern) for pattern in self)
def __unicode__(self): return ' NOT '.join(unicode(pattern) for pattern in self).lstrip()
def __unicode__(self): return ' OR '.join(unicode(pattern) for pattern in self)
def test_str(self): for tc, expected in [(self.empty, ''), (self.ascii, 'Kekkonen'), (self.non_ascii, u'hyv\xe4 nimi')]: assert_equal(unicode(tc), expected) if PY2: assert_equal(str(tc), unicode(tc).encode('UTF-8'))
def test_unicode(self): assert_equal(unicode(self.empty), '') assert_equal(unicode(self.ascii), 'Kekkonen') assert_equal(unicode(self.non_ascii), u'hyv\xe4 nimi')
def __unicode__(self): return unicode(self.value or '')
def from_Enum(cls, enum_type): return cls(name=enum_type.__name__, doc=getdoc(enum_type) or '', members=[{'name': name, 'value': unicode(member.value)} for name, member in enum_type.__members__.items()])
def test_unicode(self): assert_equal(unicode(ItemList(int, items=[1, 2, 3, 4])), '[1, 2, 3, 4]') assert_equal(unicode(ItemList(unicode, items=[u'hyv\xe4\xe4', u'y\xf6'])), u'[hyv\xe4\xe4, y\xf6]')
def test_unicode(self): pattern = u'\xe4 OR \xe5 NOT \xe6 AND \u2603 OR ??' expected = '[%s]' % pattern assert_equal(unicode(TagPatterns(pattern)), expected) assert_equal(unicode(TagPatterns(pattern.replace(' ', ''))), expected)
def __repr__(self): return repr(unicode(self))
def test_unicode(self): assert_equal(unicode(ItemList(int, items=[1, 2, 3, 4])), '[1, 2, 3, 4]') assert_equal( unicode(ItemList(unicode, items=[u'hyv\xe4\xe4', u'y\xf6'])), unicode([u'hyv\xe4\xe4', u'y\xf6']))
def _get_critical_stat(self, pattern, critical): name = unicode(pattern) return CriticalTagStat(pattern, name, critical, self.get_doc(name), self.get_links(name))
def get_repr_from_json_arg_model(self, model): return unicode( ArgInfo(kind=model['kind'], name=model['name'], types=tuple(model['types']), default=model['default'] or ArgInfo.NOTSET))
def __unicode__(self): return ', '.join(unicode(arg) for arg in self)
def __str__(self): return u'[%s]' % u', '.join(unicode(pattern) for pattern in self)
def __str__(self): return ' OR '.join(unicode(pattern) for pattern in self)