Skip to content

robot.libraries.String

String

A library for string manipulation and verification.

String is Robot Framework's standard library for manipulating strings (e.g. Replace String Using Regexp, Split To Lines) and verifying their contents (e.g. Should Be String).

Following keywords from BuiltIn library can also be used with strings:

  • Catenate
  • Get Length
  • Length Should Be
  • Should (Not) Be Empty
  • Should (Not) Be Equal (As Strings/Integers/Numbers)
  • Should (Not) Match (Regexp)
  • Should (Not) Contain
  • Should (Not) Start With
  • Should (Not) End With
  • Convert To String
  • Convert To Bytes

convert_to_lower_case 

1
convert_to_lower_case(string)

Converts string to lower case.

Uses Python's standard [https://docs.python.org/library/stdtypes.html#str.lower|lower()] method.

Examples: | ${str1} = | Convert To Lower Case | ABC | | ${str2} = | Convert To Lower Case | 1A2c3D | | Should Be Equal | ${str1} | abc | | Should Be Equal | ${str2} | 1a2c3d |

Source code in src/robot/libraries/String.py 
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def convert_to_lower_case(self, string):
    """Converts string to lower case.

    Uses Python's standard
    [https://docs.python.org/library/stdtypes.html#str.lower|lower()]
    method.

    Examples:
    | ${str1} = | Convert To Lower Case | ABC |
    | ${str2} = | Convert To Lower Case | 1A2c3D |
    | Should Be Equal | ${str1} | abc |
    | Should Be Equal | ${str2} | 1a2c3d |
    """
    return string.lower()

convert_to_upper_case 

1
convert_to_upper_case(string)

Converts string to upper case.

Uses Python's standard [https://docs.python.org/library/stdtypes.html#str.upper|upper()] method.

Examples: | ${str1} = | Convert To Upper Case | abc | | ${str2} = | Convert To Upper Case | 1a2C3d | | Should Be Equal | ${str1} | ABC | | Should Be Equal | ${str2} | 1A2C3D |

Source code in src/robot/libraries/String.py 
67
68
69
70
71
72
73
74
75
76
77
78
79
80
def convert_to_upper_case(self, string):
    """Converts string to upper case.

    Uses Python's standard
    [https://docs.python.org/library/stdtypes.html#str.upper|upper()]
    method.

    Examples:
    | ${str1} = | Convert To Upper Case | abc |
    | ${str2} = | Convert To Upper Case | 1a2C3d |
    | Should Be Equal | ${str1} | ABC |
    | Should Be Equal | ${str2} | 1A2C3D |
    """
    return string.upper()

convert_to_title_case 

1
convert_to_title_case(string, exclude=None)

Converts string to title case.

Uses the following algorithm:

  • Split the string to words from whitespace characters (spaces, newlines, etc.).
  • Exclude words that are not all lower case. This preserves, for example, "OK" and "iPhone".
  • Exclude also words listed in the optional exclude argument.
  • Title case the first alphabetical character of each word that has not been excluded.
  • Join all words together so that original whitespace is preserved.

Explicitly excluded words can be given as a list or as a string with words separated by a comma and an optional space. Excluded words are actually considered to be regular expression patterns, so it is possible to use something like "example[.!?]?" to match the word "example" on it own and also if followed by ".", "!" or "?". See BuiltIn.Should Match Regexp for more information about Python regular expression syntax in general and how to use it in Robot Framework data in particular.

Examples: | ${str1} = | Convert To Title Case | hello, world! | | ${str2} = | Convert To Title Case | it's an OK iPhone | exclude=a, an, the | | ${str3} = | Convert To Title Case | distance is 1 km. | exclude=is, km.? | | Should Be Equal | ${str1} | Hello, World! | | Should Be Equal | ${str2} | It's an OK iPhone | | Should Be Equal | ${str3} | Distance is 1 km. |

The reason this keyword does not use Python's standard [https://docs.python.org/library/stdtypes.html#str.title|title()] method is that it can yield undesired results, for example, if strings contain upper case letters or special characters like apostrophes. It would, for example, convert "it's an OK iPhone" to "It'S An Ok Iphone".

Source code in src/robot/libraries/String.py 
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
@keyword(types=None)
def convert_to_title_case(self, string, exclude=None):
    """Converts string to title case.

    Uses the following algorithm:

    - Split the string to words from whitespace characters (spaces,
      newlines, etc.).
    - Exclude words that are not all lower case. This preserves,
      for example, "OK" and "iPhone".
    - Exclude also words listed in the optional ``exclude`` argument.
    - Title case the first alphabetical character of each word that has
      not been excluded.
    - Join all words together so that original whitespace is preserved.

    Explicitly excluded words can be given as a list or as a string with
    words separated by a comma and an optional space. Excluded words are
    actually considered to be regular expression patterns, so it is
    possible to use something like "example[.!?]?" to match the word
    "example" on it own and also if followed by ".", "!" or "?".
    See `BuiltIn.Should Match Regexp` for more information about Python
    regular expression syntax in general and how to use it in Robot
    Framework data in particular.

    Examples:
    | ${str1} = | Convert To Title Case | hello, world!     |
    | ${str2} = | Convert To Title Case | it's an OK iPhone | exclude=a, an, the |
    | ${str3} = | Convert To Title Case | distance is 1 km. | exclude=is, km.? |
    | Should Be Equal | ${str1} | Hello, World! |
    | Should Be Equal | ${str2} | It's an OK iPhone |
    | Should Be Equal | ${str3} | Distance is 1 km. |

    The reason this keyword does not use Python's standard
    [https://docs.python.org/library/stdtypes.html#str.title|title()]
    method is that it can yield undesired results, for example, if
    strings contain upper case letters or special characters like
    apostrophes. It would, for example, convert "it's an OK iPhone"
    to "It'S An Ok Iphone".
    """
    if not isinstance(string, str):
        raise TypeError('This keyword works only with strings.')
    if isinstance(exclude, str):
        exclude = [e.strip() for e in exclude.split(',')]
    elif not exclude:
        exclude = []
    exclude = [re.compile('^%s$' % e) for e in exclude]

    def title(word):
        if any(e.match(word) for e in exclude) or not word.islower():
            return word
        for index, char in enumerate(word):
            if char.isalpha():
                return word[:index] + word[index].title() + word[index+1:]
        return word

    tokens = re.split(r'(\s+)', string, flags=re.UNICODE)
    return ''.join(title(token) for token in tokens)

encode_string_to_bytes 

1
encode_string_to_bytes(string, encoding, errors='strict')

Encodes the given string to bytes using the given encoding.

errors argument controls what to do if encoding some characters fails. All values accepted by encode method in Python are valid, but in practice the following values are most useful:

  • strict: fail if characters cannot be encoded (default)
  • ignore: ignore characters that cannot be encoded
  • replace: replace characters that cannot be encoded with a replacement character

Examples: | ${bytes} = | Encode String To Bytes | ${string} | UTF-8 | | ${bytes} = | Encode String To Bytes | ${string} | ASCII | errors=ignore |

Use Convert To Bytes in BuiltIn if you want to create bytes based on character or integer sequences. Use Decode Bytes To String if you need to convert bytes to strings and Convert To String in BuiltIn if you need to convert arbitrary objects to strings.

Source code in src/robot/libraries/String.py 
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
def encode_string_to_bytes(self, string, encoding, errors='strict'):
    """Encodes the given ``string`` to bytes using the given ``encoding``.

    ``errors`` argument controls what to do if encoding some characters fails.
    All values accepted by ``encode`` method in Python are valid, but in
    practice the following values are most useful:

    - ``strict``: fail if characters cannot be encoded (default)
    - ``ignore``: ignore characters that cannot be encoded
    - ``replace``: replace characters that cannot be encoded with
      a replacement character

    Examples:
    | ${bytes} = | Encode String To Bytes | ${string} | UTF-8 |
    | ${bytes} = | Encode String To Bytes | ${string} | ASCII | errors=ignore |

    Use `Convert To Bytes` in ``BuiltIn`` if you want to create bytes based
    on character or integer sequences. Use `Decode Bytes To String` if you
    need to convert bytes to strings and `Convert To String`
    in ``BuiltIn`` if you need to convert arbitrary objects to strings.
    """
    return bytes(string.encode(encoding, errors))

decode_bytes_to_string 

1
decode_bytes_to_string(bytes, encoding, errors='strict')

Decodes the given bytes to a string using the given encoding.

errors argument controls what to do if decoding some bytes fails. All values accepted by decode method in Python are valid, but in practice the following values are most useful:

  • strict: fail if characters cannot be decoded (default)
  • ignore: ignore characters that cannot be decoded
  • replace: replace characters that cannot be decoded with a replacement character

Examples: | ${string} = | Decode Bytes To String | ${bytes} | UTF-8 | | ${string} = | Decode Bytes To String | ${bytes} | ASCII | errors=ignore |

Use Encode String To Bytes if you need to convert strings to bytes, and Convert To String in BuiltIn if you need to convert arbitrary objects to strings.

Source code in src/robot/libraries/String.py 
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
def decode_bytes_to_string(self, bytes, encoding, errors='strict'):
    """Decodes the given ``bytes`` to a string using the given ``encoding``.

    ``errors`` argument controls what to do if decoding some bytes fails.
    All values accepted by ``decode`` method in Python are valid, but in
    practice the following values are most useful:

    - ``strict``: fail if characters cannot be decoded (default)
    - ``ignore``: ignore characters that cannot be decoded
    - ``replace``: replace characters that cannot be decoded with
      a replacement character

    Examples:
    | ${string} = | Decode Bytes To String | ${bytes} | UTF-8 |
    | ${string} = | Decode Bytes To String | ${bytes} | ASCII | errors=ignore |

    Use `Encode String To Bytes` if you need to convert strings to bytes,
    and `Convert To String` in ``BuiltIn`` if you need to
    convert arbitrary objects to strings.
    """
    if isinstance(bytes, str):
        raise TypeError('Cannot decode strings.')
    return bytes.decode(encoding, errors)

format_string 

1
format_string(template, /, *positional, **named)

Formats a template using the given positional and named arguments.

The template can be either be a string or an absolute path to an existing file. In the latter case the file is read and its contents are used as the template. If the template file contains non-ASCII characters, it must be encoded using UTF-8.

The template is formatted using Python's [https://docs.python.org/library/string.html#format-string-syntax|format string syntax]. Placeholders are marked using {} with possible field name and format specification inside. Literal curly braces can be inserted by doubling them like {{ and }}.

Examples: | ${to} = | Format String | To: {} <{}> | ${user} | ${email} | | ${to} = | Format String | To: {name} <{email}> | name=${name} | email=${email} | | ${to} = | Format String | To: {user.name} <{user.email}> | user=${user} | | ${xx} = | Format String | {:*^30} | centered | | ${yy} = | Format String | {0:{width}{base}} | ${42} | base=X | width=10 | | ${zz} = | Format String | ${CURDIR}/template.txt | positional | named=value |

Prior to Robot Framework 7.1, possible equal signs in the template string must be escaped with a backslash like `x\={}.

Source code in src/robot/libraries/String.py 
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
def format_string(self, template, /, *positional, **named):
    """Formats a ``template`` using the given ``positional`` and ``named`` arguments.

    The template can be either be a string or an absolute path to
    an existing file. In the latter case the file is read and its contents
    are used as the template. If the template file contains non-ASCII
    characters, it must be encoded using UTF-8.

    The template is formatted using Python's
    [https://docs.python.org/library/string.html#format-string-syntax|format
    string syntax]. Placeholders are marked using ``{}`` with possible
    field name and format specification inside. Literal curly braces
    can be inserted by doubling them like `{{` and `}}`.

    Examples:
    | ${to} = | Format String | To: {} <{}>                    | ${user}      | ${email} |
    | ${to} = | Format String | To: {name} <{email}>           | name=${name} | email=${email} |
    | ${to} = | Format String | To: {user.name} <{user.email}> | user=${user} |
    | ${xx} = | Format String | {:*^30}                        | centered     |
    | ${yy} = | Format String | {0:{width}{base}}              | ${42}        | base=X | width=10 |
    | ${zz} = | Format String | ${CURDIR}/template.txt         | positional   | named=value |

    Prior to Robot Framework 7.1, possible equal signs in the template string must
    be escaped with a backslash like ``x\\={}`.
    """
    if os.path.isabs(template) and os.path.isfile(template):
        template = template.replace('/', os.sep)
        logger.info(f'Reading template from file '
                    f'<a href="{template}">{template}</a>.', html=True)
        with FileReader(template) as reader:
            template = reader.read()
    return template.format(*positional, **named)

get_line_count 

1
get_line_count(string)

Returns and logs the number of lines in the given string.

Source code in src/robot/libraries/String.py 
220
221
222
223
224
def get_line_count(self, string):
    """Returns and logs the number of lines in the given string."""
    count = len(string.splitlines())
    logger.info(f'{count} lines.')
    return count

split_to_lines 

1
split_to_lines(string, start=0, end=None)

Splits the given string to lines.

It is possible to get only a selection of lines from start to end so that start index is inclusive and end is exclusive. Line numbering starts from 0, and it is possible to use negative indices to refer to lines from the end.

Lines are returned without the newlines. The number of returned lines is automatically logged.

Examples: | @{lines} = | Split To Lines | ${manylines} | | | | @{ignore first} = | Split To Lines | ${manylines} | 1 | | | @{ignore last} = | Split To Lines | ${manylines} | | -1 | | @{5th to 10th} = | Split To Lines | ${manylines} | 4 | 10 | | @{first two} = | Split To Lines | ${manylines} | | 1 | | @{last two} = | Split To Lines | ${manylines} | -2 | |

Use Get Line if you only need to get a single line.

Source code in src/robot/libraries/String.py 
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
def split_to_lines(self, string, start=0, end=None):
    """Splits the given string to lines.

    It is possible to get only a selection of lines from ``start``
    to ``end`` so that ``start`` index is inclusive and ``end`` is
    exclusive. Line numbering starts from 0, and it is possible to
    use negative indices to refer to lines from the end.

    Lines are returned without the newlines. The number of
    returned lines is automatically logged.

    Examples:
    | @{lines} =        | Split To Lines | ${manylines} |    |    |
    | @{ignore first} = | Split To Lines | ${manylines} | 1  |    |
    | @{ignore last} =  | Split To Lines | ${manylines} |    | -1 |
    | @{5th to 10th} =  | Split To Lines | ${manylines} | 4  | 10 |
    | @{first two} =    | Split To Lines | ${manylines} |    | 1  |
    | @{last two} =     | Split To Lines | ${manylines} | -2 |    |

    Use `Get Line` if you only need to get a single line.
    """
    start = self._convert_to_index(start, 'start')
    end = self._convert_to_index(end, 'end')
    lines = string.splitlines()[start:end]
    logger.info('%d lines returned' % len(lines))
    return lines

get_line 

1
get_line(string, line_number)

Returns the specified line from the given string.

Line numbering starts from 0, and it is possible to use negative indices to refer to lines from the end. The line is returned without the newline character.

Examples: | ${first} = | Get Line | ${string} | 0 | | ${2nd last} = | Get Line | ${string} | -2 |

Use Split To Lines if all lines are needed.

Source code in src/robot/libraries/String.py 
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
def get_line(self, string, line_number):
    """Returns the specified line from the given ``string``.

    Line numbering starts from 0, and it is possible to use
    negative indices to refer to lines from the end. The line is
    returned without the newline character.

    Examples:
    | ${first} =    | Get Line | ${string} | 0  |
    | ${2nd last} = | Get Line | ${string} | -2 |

    Use `Split To Lines` if all lines are needed.
    """
    line_number = self._convert_to_integer(line_number, 'line_number')
    return string.splitlines()[line_number]

get_lines_containing_string 

1
2
3
4
5
6
get_lines_containing_string(
    string: str,
    pattern: str,
    case_insensitive: bool | None = None,
    ignore_case: bool = False,
)

Returns lines of the given string that contain the pattern.

The pattern is always considered to be a normal string, not a glob or regexp pattern. A line matches if the pattern is found anywhere on it.

The match is case-sensitive by default, but that can be changed by giving ignore_case a true value. This option is new in Robot Framework 7.0, but with older versions it is possible to use the nowadays deprecated case_insensitive argument.

Lines are returned as a string with lines joined together with a newline. Possible trailing newline is never returned. The number of matching lines is automatically logged.

Examples: | ${lines} = | Get Lines Containing String | ${result} | An example | | ${ret} = | Get Lines Containing String | ${ret} | FAIL | ignore_case=True |

See Get Lines Matching Pattern and Get Lines Matching Regexp if you need more complex pattern matching.

Source code in src/robot/libraries/String.py 
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
def get_lines_containing_string(self, string: str, pattern: str,
                                case_insensitive: 'bool|None' = None,
                                ignore_case: bool = False):
    """Returns lines of the given ``string`` that contain the ``pattern``.

    The ``pattern`` is always considered to be a normal string, not a glob
    or regexp pattern. A line matches if the ``pattern`` is found anywhere
    on it.

    The match is case-sensitive by default, but that can be changed by
    giving ``ignore_case`` a true value. This option is new in Robot
    Framework 7.0, but with older versions it is possible to use the
    nowadays deprecated ``case_insensitive`` argument.

    Lines are returned as a string with lines joined together with
    a newline. Possible trailing newline is never returned. The number
    of matching lines is automatically logged.

    Examples:
    | ${lines} = | Get Lines Containing String | ${result} | An example |
    | ${ret} =   | Get Lines Containing String | ${ret} | FAIL | ignore_case=True |

    See `Get Lines Matching Pattern` and `Get Lines Matching Regexp`
    if you need more complex pattern matching.
    """
    if case_insensitive is not None:
        ignore_case = case_insensitive
    if ignore_case:
        pattern = pattern.casefold()
        contains = lambda line: pattern in line.casefold()
    else:
        contains = lambda line: pattern in line
    return self._get_matching_lines(string, contains)

get_lines_matching_pattern 

1
2
3
4
5
6
get_lines_matching_pattern(
    string: str,
    pattern: str,
    case_insensitive: bool | None = None,
    ignore_case: bool = False,
)

Returns lines of the given string that match the pattern.

The pattern is a glob pattern where: | * | matches everything | | ? | matches any single character | | [chars] | matches any character inside square brackets (e.g. [abc] matches either a, b or c) | | [!chars] | matches any character not inside square brackets |

A line matches only if it matches the pattern fully.

The match is case-sensitive by default, but that can be changed by giving ignore_case a true value. This option is new in Robot Framework 7.0, but with older versions it is possible to use the nowadays deprecated case_insensitive argument.

Lines are returned as a string with lines joined together with a newline. Possible trailing newline is never returned. The number of matching lines is automatically logged.

Examples: | ${lines} = | Get Lines Matching Pattern | ${result} | Wild???? example | | ${ret} = | Get Lines Matching Pattern | ${ret} | FAIL: * | ignore_case=True |

See Get Lines Matching Regexp if you need more complex patterns and Get Lines Containing String if searching literal strings is enough.

Source code in src/robot/libraries/String.py 
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
def get_lines_matching_pattern(self, string: str, pattern: str,
                               case_insensitive: 'bool|None' = None,
                               ignore_case: bool = False):
    """Returns lines of the given ``string`` that match the ``pattern``.

    The ``pattern`` is a _glob pattern_ where:
    | ``*``        | matches everything |
    | ``?``        | matches any single character |
    | ``[chars]``  | matches any character inside square brackets (e.g. ``[abc]`` matches either ``a``, ``b`` or ``c``) |
    | ``[!chars]`` | matches any character not inside square brackets |

    A line matches only if it matches the ``pattern`` fully.

    The match is case-sensitive by default, but that can be changed by
    giving ``ignore_case`` a true value. This option is new in Robot
    Framework 7.0, but with older versions it is possible to use the
    nowadays deprecated ``case_insensitive`` argument.

    Lines are returned as a string with lines joined together with
    a newline. Possible trailing newline is never returned. The number
    of matching lines is automatically logged.

    Examples:
    | ${lines} = | Get Lines Matching Pattern | ${result} | Wild???? example |
    | ${ret} = | Get Lines Matching Pattern | ${ret} | FAIL: * | ignore_case=True |

    See `Get Lines Matching Regexp` if you need more complex
    patterns and `Get Lines Containing String` if searching
    literal strings is enough.
    """
    if case_insensitive is not None:
        ignore_case = case_insensitive
    if ignore_case:
        pattern = pattern.casefold()
        matches = lambda line: fnmatchcase(line.casefold(), pattern)
    else:
        matches = lambda line: fnmatchcase(line, pattern)
    return self._get_matching_lines(string, matches)

get_lines_matching_regexp 

1
2
3
get_lines_matching_regexp(
    string, pattern, partial_match=False, flags=None
)

Returns lines of the given string that match the regexp pattern.

See BuiltIn.Should Match Regexp for more information about Python regular expression syntax in general and how to use it in Robot Framework data in particular.

Lines match only if they match the pattern fully by default, but partial matching can be enabled by giving the partial_match argument a true value.

If the pattern is empty, it matches only empty lines by default. When partial matching is enabled, empty pattern matches all lines.

Possible flags altering how the expression is parsed (e.g. re.IGNORECASE, re.VERBOSE) can be given using the flags argument (e.g. flags=IGNORECASE | VERBOSE) or embedded to the pattern (e.g. (?ix)pattern).

Lines are returned as one string concatenated back together with newlines. Possible trailing newline is never returned. The number of matching lines is automatically logged.

Examples: | ${lines} = | Get Lines Matching Regexp | ${result} | Reg\w{3} example | | ${lines} = | Get Lines Matching Regexp | ${result} | Reg\w{3} example | partial_match=true | | ${ret} = | Get Lines Matching Regexp | ${ret} | (?i)FAIL: . | | ${ret} = | Get Lines Matching Regexp | ${ret} | FAIL: . | flags=IGNORECASE |

See Get Lines Matching Pattern and Get Lines Containing String if you do not need the full regular expression powers (and complexity).

The flags argument is new in Robot Framework 6.0.

Source code in src/robot/libraries/String.py 
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
def get_lines_matching_regexp(self, string, pattern, partial_match=False, flags=None):
    """Returns lines of the given ``string`` that match the regexp ``pattern``.

    See `BuiltIn.Should Match Regexp` for more information about
    Python regular expression syntax in general and how to use it
    in Robot Framework data in particular.

    Lines match only if they match the pattern fully by default, but
    partial matching can be enabled by giving the ``partial_match``
    argument a true value.

    If the pattern is empty, it matches only empty lines by default.
    When partial matching is enabled, empty pattern matches all lines.

    Possible flags altering how the expression is parsed (e.g. ``re.IGNORECASE``,
    ``re.VERBOSE``) can be given using the ``flags`` argument (e.g.
    ``flags=IGNORECASE | VERBOSE``) or embedded to the pattern (e.g.
    ``(?ix)pattern``).

    Lines are returned as one string concatenated back together with
    newlines. Possible trailing newline is never returned. The
    number of matching lines is automatically logged.

    Examples:
    | ${lines} = | Get Lines Matching Regexp | ${result} | Reg\\\\w{3} example |
    | ${lines} = | Get Lines Matching Regexp | ${result} | Reg\\\\w{3} example | partial_match=true |
    | ${ret} =   | Get Lines Matching Regexp | ${ret}    | (?i)FAIL: .* |
    | ${ret} =   | Get Lines Matching Regexp | ${ret}    | FAIL: .* | flags=IGNORECASE |

    See `Get Lines Matching Pattern` and `Get Lines Containing String` if you
    do not need the full regular expression powers (and complexity).

    The ``flags`` argument is new in Robot Framework 6.0.
    """
    regexp = re.compile(pattern, flags=parse_re_flags(flags))
    match = regexp.search if partial_match else regexp.fullmatch
    return self._get_matching_lines(string, match)

get_regexp_matches 

1
get_regexp_matches(string, pattern, *groups, flags=None)

Returns a list of all non-overlapping matches in the given string.

string is the string to find matches from and pattern is the regular expression. See BuiltIn.Should Match Regexp for more information about Python regular expression syntax in general and how to use it in Robot Framework data in particular.

If no groups are used, the returned list contains full matches. If one group is used, the list contains only contents of that group. If multiple groups are used, the list contains tuples that contain individual group contents. All groups can be given as indexes (starting from 1) and named groups also as names.

Possible flags altering how the expression is parsed (e.g. re.IGNORECASE, re.MULTILINE) can be given using the flags argument (e.g. flags=IGNORECASE | MULTILINE) or embedded to the pattern (e.g. (?im)pattern).

Examples: | ${no match} = | Get Regexp Matches | the string | xxx | | ${matches} = | Get Regexp Matches | the string | t.. | | ${matches} = | Get Regexp Matches | the string | T.. | flags=IGNORECASE | | ${one group} = | Get Regexp Matches | the string | t(..) | 1 | | ${named group} = | Get Regexp Matches | the string | t(?P..) | name | | ${two groups} = | Get Regexp Matches | the string | t(.)(.) | 1 | 2 | => | ${no match} = [] | ${matches} = ['the', 'tri'] | ${one group} = ['he', 'ri'] | ${named group} = ['he', 'ri'] | ${two groups} = [('h', 'e'), ('r', 'i')]

The flags argument is new in Robot Framework 6.0.

Source code in src/robot/libraries/String.py 
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
def get_regexp_matches(self, string, pattern, *groups, flags=None):
    """Returns a list of all non-overlapping matches in the given string.

    ``string`` is the string to find matches from and ``pattern`` is the
    regular expression. See `BuiltIn.Should Match Regexp` for more
    information about Python regular expression syntax in general and how
    to use it in Robot Framework data in particular.

    If no groups are used, the returned list contains full matches. If one
    group is used, the list contains only contents of that group. If
    multiple groups are used, the list contains tuples that contain
    individual group contents. All groups can be given as indexes (starting
    from 1) and named groups also as names.

    Possible flags altering how the expression is parsed (e.g. ``re.IGNORECASE``,
    ``re.MULTILINE``) can be given using the ``flags`` argument (e.g.
    ``flags=IGNORECASE | MULTILINE``) or embedded to the pattern (e.g.
    ``(?im)pattern``).

    Examples:
    | ${no match} =    | Get Regexp Matches | the string | xxx     |
    | ${matches} =     | Get Regexp Matches | the string | t..     |
    | ${matches} =     | Get Regexp Matches | the string | T..     | flags=IGNORECASE |
    | ${one group} =   | Get Regexp Matches | the string | t(..)   | 1 |
    | ${named group} = | Get Regexp Matches | the string | t(?P<name>..) | name |
    | ${two groups} =  | Get Regexp Matches | the string | t(.)(.) | 1 | 2 |
    =>
    | ${no match} = []
    | ${matches} = ['the', 'tri']
    | ${one group} = ['he', 'ri']
    | ${named group} = ['he', 'ri']
    | ${two groups} = [('h', 'e'), ('r', 'i')]

    The ``flags`` argument is new in Robot Framework 6.0.
    """
    regexp = re.compile(pattern, flags=parse_re_flags(flags))
    groups = [self._parse_group(g) for g in groups]
    return [m.group(*groups) for m in regexp.finditer(string)]

replace_string 

1
replace_string(string, search_for, replace_with, count=-1)

Replaces search_for in the given string with replace_with.

search_for is used as a literal string. See Replace String Using Regexp if more powerful pattern matching is needed. If you need to just remove a string see Remove String.

If the optional argument count is given, only that many occurrences from left are replaced. Negative count means that all occurrences are replaced (default behaviour) and zero means that nothing is done.

A modified version of the string is returned and the original string is not altered.

Examples: | ${str} = | Replace String | Hello, world! | world | tellus | | Should Be Equal | ${str} | Hello, tellus! | | | | ${str} = | Replace String | Hello, world! | l | ${EMPTY} | count=1 | | Should Be Equal | ${str} | Helo, world! | | |

Source code in src/robot/libraries/String.py 
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
def replace_string(self, string, search_for, replace_with, count=-1):
    """Replaces ``search_for`` in the given ``string`` with ``replace_with``.

    ``search_for`` is used as a literal string. See `Replace String
    Using Regexp` if more powerful pattern matching is needed.
    If you need to just remove a string see `Remove String`.

    If the optional argument ``count`` is given, only that many
    occurrences from left are replaced. Negative ``count`` means
    that all occurrences are replaced (default behaviour) and zero
    means that nothing is done.

    A modified version of the string is returned and the original
    string is not altered.

    Examples:
    | ${str} =        | Replace String | Hello, world!  | world | tellus   |
    | Should Be Equal | ${str}         | Hello, tellus! |       |          |
    | ${str} =        | Replace String | Hello, world!  | l     | ${EMPTY} | count=1 |
    | Should Be Equal | ${str}         | Helo, world!   |       |          |
    """
    count = self._convert_to_integer(count, 'count')
    return string.replace(search_for, replace_with, count)

replace_string_using_regexp 

1
2
3
replace_string_using_regexp(
    string, pattern, replace_with, count=-1, flags=None
)

Replaces pattern in the given string with replace_with.

This keyword is otherwise identical to Replace String, but the pattern to search for is considered to be a regular expression. See BuiltIn.Should Match Regexp for more information about Python regular expression syntax in general and how to use it in Robot Framework data in particular.

Possible flags altering how the expression is parsed (e.g. re.IGNORECASE, re.MULTILINE) can be given using the flags argument (e.g. flags=IGNORECASE | MULTILINE) or embedded to the pattern (e.g. (?im)pattern).

If you need to just remove a string see Remove String Using Regexp.

Examples: | ${str} = | Replace String Using Regexp | ${str} | 20\d\d-\d\d-\d\d | | | ${str} = | Replace String Using Regexp | ${str} | (Hello|Hi) | ${EMPTY} | count=1 |

The flags argument is new in Robot Framework 6.0.

Source code in src/robot/libraries/String.py 
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
def replace_string_using_regexp(self, string, pattern, replace_with, count=-1, flags=None):
    """Replaces ``pattern`` in the given ``string`` with ``replace_with``.

    This keyword is otherwise identical to `Replace String`, but
    the ``pattern`` to search for is considered to be a regular
    expression.  See `BuiltIn.Should Match Regexp` for more
    information about Python regular expression syntax in general
    and how to use it in Robot Framework data in particular.

    Possible flags altering how the expression is parsed (e.g. ``re.IGNORECASE``,
    ``re.MULTILINE``) can be given using the ``flags`` argument (e.g.
    ``flags=IGNORECASE | MULTILINE``) or embedded to the pattern (e.g.
    ``(?im)pattern``).

    If you need to just remove a string see `Remove String Using Regexp`.

    Examples:
    | ${str} = | Replace String Using Regexp | ${str} | 20\\\\d\\\\d-\\\\d\\\\d-\\\\d\\\\d | <DATE> |
    | ${str} = | Replace String Using Regexp | ${str} | (Hello|Hi) | ${EMPTY} | count=1 |

    The ``flags`` argument is new in Robot Framework 6.0.
    """
    count = self._convert_to_integer(count, 'count')
    # re.sub handles 0 and negative counts differently than string.replace
    if count == 0:
        return string
    return re.sub(pattern, replace_with, string, max(count, 0), flags=parse_re_flags(flags))

remove_string 

1
remove_string(string, *removables)

Removes all removables from the given string.

removables are used as literal strings. Each removable will be matched to a temporary string from which preceding removables have been already removed. See second example below.

Use Remove String Using Regexp if more powerful pattern matching is needed. If only a certain number of matches should be removed, Replace String or Replace String Using Regexp can be used.

A modified version of the string is returned and the original string is not altered.

Examples: | ${str} = | Remove String | Robot Framework | work | | Should Be Equal | ${str} | Robot Frame | | ${str} = | Remove String | Robot Framework | o | bt | | Should Be Equal | ${str} | R Framewrk |

Source code in src/robot/libraries/String.py 
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
def remove_string(self, string, *removables):
    """Removes all ``removables`` from the given ``string``.

    ``removables`` are used as literal strings. Each removable will be
    matched to a temporary string from which preceding removables have
    been already removed. See second example below.

    Use `Remove String Using Regexp` if more powerful pattern matching is
    needed. If only a certain number of matches should be removed,
    `Replace String` or `Replace String Using Regexp` can be used.

    A modified version of the string is returned and the original
    string is not altered.

    Examples:
    | ${str} =        | Remove String | Robot Framework | work   |
    | Should Be Equal | ${str}        | Robot Frame     |
    | ${str} =        | Remove String | Robot Framework | o | bt |
    | Should Be Equal | ${str}        | R Framewrk      |
    """
    for removable in removables:
        string = self.replace_string(string, removable, '')
    return string

remove_string_using_regexp 

1
remove_string_using_regexp(string, *patterns, flags=None)

Removes patterns from the given string.

This keyword is otherwise identical to Remove String, but the patterns to search for are considered to be a regular expression. See Replace String Using Regexp for more information about the regular expression syntax. That keyword can also be used if there is a need to remove only a certain number of occurrences.

Possible flags altering how the expression is parsed (e.g. re.IGNORECASE, re.MULTILINE) can be given using the flags argument (e.g. flags=IGNORECASE | MULTILINE) or embedded to the pattern (e.g. (?im)pattern).

The flags argument is new in Robot Framework 6.0.

Source code in src/robot/libraries/String.py 
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
def remove_string_using_regexp(self, string, *patterns, flags=None):
    """Removes ``patterns`` from the given ``string``.

    This keyword is otherwise identical to `Remove String`, but
    the ``patterns`` to search for are considered to be a regular
    expression. See `Replace String Using Regexp` for more information
    about the regular expression syntax. That keyword can also be
    used if there is a need to remove only a certain number of
    occurrences.

    Possible flags altering how the expression is parsed (e.g. ``re.IGNORECASE``,
    ``re.MULTILINE``) can be given using the ``flags`` argument (e.g.
    ``flags=IGNORECASE | MULTILINE``) or embedded to the pattern (e.g.
    ``(?im)pattern``).

    The ``flags`` argument is new in Robot Framework 6.0.
    """
    for pattern in patterns:
        string = self.replace_string_using_regexp(string, pattern, '', flags=flags)
    return string

split_string 

1
split_string(string, separator=None, max_split=-1)

Splits the string using separator as a delimiter string.

If a separator is not given, any whitespace string is a separator. In that case also possible consecutive whitespace as well as leading and trailing whitespace is ignored.

Split words are returned as a list. If the optional max_split is given, at most max_split splits are done, and the returned list will have maximum max_split + 1 elements.

Examples: | @{words} = | Split String | ${string} | | @{words} = | Split String | ${string} | ,${SPACE} | | ${pre} | ${post} = | Split String | ${string} | :: | 1 |

See Split String From Right if you want to start splitting from right, and Fetch From Left and Fetch From Right if you only want to get first/last part of the string.

Source code in src/robot/libraries/String.py 
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
@keyword(types=None)
def split_string(self, string, separator=None, max_split=-1):
    """Splits the ``string`` using ``separator`` as a delimiter string.

    If a ``separator`` is not given, any whitespace string is a
    separator. In that case also possible consecutive whitespace
    as well as leading and trailing whitespace is ignored.

    Split words are returned as a list. If the optional
    ``max_split`` is given, at most ``max_split`` splits are done, and
    the returned list will have maximum ``max_split + 1`` elements.

    Examples:
    | @{words} =         | Split String | ${string} |
    | @{words} =         | Split String | ${string} | ,${SPACE} |
    | ${pre} | ${post} = | Split String | ${string} | ::    | 1 |

    See `Split String From Right` if you want to start splitting
    from right, and `Fetch From Left` and `Fetch From Right` if
    you only want to get first/last part of the string.
    """
    if separator == '':
        separator = None
    max_split = self._convert_to_integer(max_split, 'max_split')
    return string.split(separator, max_split)

split_string_from_right 

1
2
3
split_string_from_right(
    string, separator=None, max_split=-1
)

Splits the string using separator starting from right.

Same as Split String, but splitting is started from right. This has an effect only when max_split is given.

Examples: | ${first} | ${rest} = | Split String | ${string} | - | 1 | | ${rest} | ${last} = | Split String From Right | ${string} | - | 1 |

Source code in src/robot/libraries/String.py 
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
@keyword(types=None)
def split_string_from_right(self, string, separator=None, max_split=-1):
    """Splits the ``string`` using ``separator`` starting from right.

    Same as `Split String`, but splitting is started from right. This has
    an effect only when ``max_split`` is given.

    Examples:
    | ${first} | ${rest} = | Split String            | ${string} | - | 1 |
    | ${rest}  | ${last} = | Split String From Right | ${string} | - | 1 |
    """
    if separator == '':
        separator = None
    max_split = self._convert_to_integer(max_split, 'max_split')
    return string.rsplit(separator, max_split)

split_string_to_characters 

1
split_string_to_characters(string)

Splits the given string to characters.

Example: | @{characters} = | Split String To Characters | ${string} |

Source code in src/robot/libraries/String.py 
570
571
572
573
574
575
576
def split_string_to_characters(self, string):
    """Splits the given ``string`` to characters.

    Example:
    | @{characters} = | Split String To Characters | ${string} |
    """
    return list(string)

fetch_from_left 

1
fetch_from_left(string, marker)

Returns contents of the string before the first occurrence of marker.

If the marker is not found, whole string is returned.

See also Fetch From Right, Split String and Split String From Right.

Source code in src/robot/libraries/String.py 
578
579
580
581
582
583
584
585
586
def fetch_from_left(self, string, marker):
    """Returns contents of the ``string`` before the first occurrence of ``marker``.

    If the ``marker`` is not found, whole string is returned.

    See also `Fetch From Right`, `Split String` and `Split String
    From Right`.
    """
    return string.split(marker)[0]

fetch_from_right 

1
fetch_from_right(string, marker)

Returns contents of the string after the last occurrence of marker.

If the marker is not found, whole string is returned.

See also Fetch From Left, Split String and Split String From Right.

Source code in src/robot/libraries/String.py 
588
589
590
591
592
593
594
595
596
def fetch_from_right(self, string, marker):
    """Returns contents of the ``string`` after the last occurrence of ``marker``.

    If the ``marker`` is not found, whole string is returned.

    See also `Fetch From Left`, `Split String` and `Split String
    From Right`.
    """
    return string.split(marker)[-1]

generate_random_string 

1
2
3
generate_random_string(
    length=8, chars="[LETTERS][NUMBERS]"
)

Generates a string with a desired length from the given chars.

length can be given as a number, a string representation of a number, or as a range of numbers, such as 5-10. When a range of values is given the range will be selected by random within the range.

The population sequence chars contains the characters to use when generating the random string. It can contain any characters, and it is possible to use special markers explained in the table below:

| = Marker = | = Explanation = | | [LOWER] | Lowercase ASCII characters from a to z. | | [UPPER] | Uppercase ASCII characters from A to Z. | | [LETTERS] | Lowercase and uppercase ASCII characters. | | [NUMBERS] | Numbers from 0 to 9. |

Examples: | ${ret} = | Generate Random String | | ${low} = | Generate Random String | 12 | [LOWER] | | ${bin} = | Generate Random String | 8 | 01 | | ${hex} = | Generate Random String | 4 | [NUMBERS]abcdef | | ${rnd} = | Generate Random String | 5-10 | # Generates a string 5 to 10 characters long |

Giving length as a range of values is new in Robot Framework 5.0.

Source code in src/robot/libraries/String.py 
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
def generate_random_string(self, length=8, chars='[LETTERS][NUMBERS]'):
    """Generates a string with a desired ``length`` from the given ``chars``.

    ``length`` can be given as a number, a string representation of a number,
    or as a range of numbers, such as ``5-10``. When a range of values is given
    the range will be selected by random within the range.

    The population sequence ``chars`` contains the characters to use
    when generating the random string. It can contain any
    characters, and it is possible to use special markers
    explained in the table below:

    |  = Marker =   |               = Explanation =                   |
    | ``[LOWER]``   | Lowercase ASCII characters from ``a`` to ``z``. |
    | ``[UPPER]``   | Uppercase ASCII characters from ``A`` to ``Z``. |
    | ``[LETTERS]`` | Lowercase and uppercase ASCII characters.       |
    | ``[NUMBERS]`` | Numbers from 0 to 9.                            |

    Examples:
    | ${ret} = | Generate Random String |
    | ${low} = | Generate Random String | 12 | [LOWER]         |
    | ${bin} = | Generate Random String | 8  | 01              |
    | ${hex} = | Generate Random String | 4  | [NUMBERS]abcdef |
    | ${rnd} = | Generate Random String | 5-10 | # Generates a string 5 to 10 characters long |

    Giving ``length`` as a range of values is new in Robot Framework 5.0.
    """
    if length == '':
        length = 8
    if isinstance(length, str) and re.match(r'^\d+-\d+$', length):
        min_length, max_length = length.split('-')
        length = randint(self._convert_to_integer(min_length, "length"),
                         self._convert_to_integer(max_length, "length"))
    else:
        length = self._convert_to_integer(length, 'length')
    for name, value in [('[LOWER]', ascii_lowercase),
                        ('[UPPER]', ascii_uppercase),
                        ('[LETTERS]', ascii_lowercase + ascii_uppercase),
                        ('[NUMBERS]', digits)]:
        chars = chars.replace(name, value)
    maxi = len(chars) - 1
    return ''.join(chars[randint(0, maxi)] for _ in range(length))

get_substring 

1
get_substring(string, start, end=None)

Returns a substring from start index to end index.

The start index is inclusive and end is exclusive. Indexing starts from 0, and it is possible to use negative indices to refer to characters from the end.

Examples: | ${ignore first} = | Get Substring | ${string} | 1 | | | ${ignore last} = | Get Substring | ${string} | 0 | -1 | | ${5th to 10th} = | Get Substring | ${string} | 4 | 10 | | ${first two} = | Get Substring | ${string} | 0 | 1 | | ${last two} = | Get Substring | ${string} | -2 | |

Source code in src/robot/libraries/String.py 
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
def get_substring(self, string, start, end=None):
    """Returns a substring from ``start`` index to ``end`` index.

    The ``start`` index is inclusive and ``end`` is exclusive.
    Indexing starts from 0, and it is possible to use
    negative indices to refer to characters from the end.

    Examples:
    | ${ignore first} = | Get Substring | ${string} | 1  |    |
    | ${ignore last} =  | Get Substring | ${string} | 0  | -1 |
    | ${5th to 10th} =  | Get Substring | ${string} | 4  | 10 |
    | ${first two} =    | Get Substring | ${string} | 0  | 1  |
    | ${last two} =     | Get Substring | ${string} | -2 |    |
    """
    start = self._convert_to_index(start, 'start')
    end = self._convert_to_index(end, 'end')
    return string[start:end]

strip_string 

1
strip_string(string, mode='both', characters=None)

Remove leading and/or trailing whitespaces from the given string.

mode is either left to remove leading characters, right to remove trailing characters, both (default) to remove the characters from both sides of the string or none to return the unmodified string.

If the optional characters is given, it must be a string and the characters in the string will be stripped in the string. Please note, that this is not a substring to be removed but a list of characters, see the example below.

Examples: | ${stripped}= | Strip String | ${SPACE}Hello${SPACE} | | | Should Be Equal | ${stripped} | Hello | | | ${stripped}= | Strip String | ${SPACE}Hello${SPACE} | mode=left | | Should Be Equal | ${stripped} | Hello${SPACE} | | | ${stripped}= | Strip String | aabaHelloeee | characters=abe | | Should Be Equal | ${stripped} | Hello | |

Source code in src/robot/libraries/String.py 
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
@keyword(types=None)
def strip_string(self, string, mode='both', characters=None):
    """Remove leading and/or trailing whitespaces from the given string.

    ``mode`` is either ``left`` to remove leading characters, ``right`` to
    remove trailing characters, ``both`` (default) to remove the
    characters from both sides of the string or ``none`` to return the
    unmodified string.

    If the optional ``characters`` is given, it must be a string and the
    characters in the string will be stripped in the string. Please note,
    that this is not a substring to be removed but a list of characters,
    see the example below.

    Examples:
    | ${stripped}=  | Strip String | ${SPACE}Hello${SPACE} | |
    | Should Be Equal | ${stripped} | Hello | |
    | ${stripped}=  | Strip String | ${SPACE}Hello${SPACE} | mode=left |
    | Should Be Equal | ${stripped} | Hello${SPACE} | |
    | ${stripped}=  | Strip String | aabaHelloeee | characters=abe |
    | Should Be Equal | ${stripped} | Hello | |
    """
    try:
        method = {'BOTH': string.strip,
                  'LEFT': string.lstrip,
                  'RIGHT': string.rstrip,
                  'NONE': lambda characters: string}[mode.upper()]
    except KeyError:
        raise ValueError("Invalid mode '%s'." % mode)
    return method(characters)

should_be_string 

1
should_be_string(item, msg=None)

Fails if the given item is not a string.

The default error message can be overridden with the optional msg argument.

Source code in src/robot/libraries/String.py 
690
691
692
693
694
695
696
def should_be_string(self, item, msg=None):
    """Fails if the given ``item`` is not a string.

    The default error message can be overridden with the optional ``msg`` argument.
    """
    if not isinstance(item, str):
        raise AssertionError(msg or f"{item!r} is {type_name(item)}, not a string.")

should_not_be_string 

1
should_not_be_string(item, msg=None)

Fails if the given item is a string.

The default error message can be overridden with the optional msg argument.

Source code in src/robot/libraries/String.py 
698
699
700
701
702
703
704
def should_not_be_string(self, item, msg=None):
    """Fails if the given ``item`` is a string.

    The default error message can be overridden with the optional ``msg`` argument.
    """
    if isinstance(item, str):
        raise AssertionError(msg or f"{item!r} is a string.")

should_be_unicode_string 

1
should_be_unicode_string(item, msg=None)

Fails if the given item is not a Unicode string.

On Python 3 this keyword behaves exactly the same way Should Be String. That keyword should be used instead and this keyword will be deprecated.

Source code in src/robot/libraries/String.py 
706
707
708
709
710
711
712
def should_be_unicode_string(self, item, msg=None):
    """Fails if the given ``item`` is not a Unicode string.

    On Python 3 this keyword behaves exactly the same way `Should Be String`.
    That keyword should be used instead and this keyword will be deprecated.
    """
    self.should_be_string(item, msg)

should_be_byte_string 

1
should_be_byte_string(item, msg=None)

Fails if the given item is not a byte string.

Use Should Be String if you want to verify the item is a string.

The default error message can be overridden with the optional msg argument.

Source code in src/robot/libraries/String.py 
714
715
716
717
718
719
720
721
722
def should_be_byte_string(self, item, msg=None):
    """Fails if the given ``item`` is not a byte string.

    Use `Should Be String` if you want to verify the ``item`` is a string.

    The default error message can be overridden with the optional ``msg`` argument.
    """
    if not isinstance(item, bytes):
        raise AssertionError(msg or f"{item!r} is not a byte string.")

should_be_lower_case 

1
should_be_lower_case(string, msg=None)

Fails if the given string is not in lower case.

For example, 'string' and 'with specials!' would pass, and 'String', '' and ' ' would fail.

The default error message can be overridden with the optional msg argument.

See also Should Be Upper Case and Should Be Title Case.

Source code in src/robot/libraries/String.py 
724
725
726
727
728
729
730
731
732
733
734
735
736
def should_be_lower_case(self, string, msg=None):
    """Fails if the given ``string`` is not in lower case.

    For example, ``'string'`` and ``'with specials!'`` would pass, and
    ``'String'``, ``''`` and ``' '`` would fail.

    The default error message can be overridden with the optional
    ``msg`` argument.

    See also `Should Be Upper Case` and `Should Be Title Case`.
    """
    if not string.islower():
        raise AssertionError(msg or f"{string!r} is not lower case.")

should_be_upper_case 

1
should_be_upper_case(string, msg=None)

Fails if the given string is not in upper case.

For example, 'STRING' and 'WITH SPECIALS!' would pass, and 'String', '' and ' ' would fail.

The default error message can be overridden with the optional msg argument.

See also Should Be Title Case and Should Be Lower Case.

Source code in src/robot/libraries/String.py 
738
739
740
741
742
743
744
745
746
747
748
749
750
def should_be_upper_case(self, string, msg=None):
    """Fails if the given ``string`` is not in upper case.

    For example, ``'STRING'`` and ``'WITH SPECIALS!'`` would pass, and
    ``'String'``, ``''`` and ``' '`` would fail.

    The default error message can be overridden with the optional
    ``msg`` argument.

    See also `Should Be Title Case` and `Should Be Lower Case`.
    """
    if not string.isupper():
        raise AssertionError(msg or f"{string!r} is not upper case.")

should_be_title_case 

1
should_be_title_case(string, msg=None, exclude=None)

Fails if given string is not title.

string is a title cased string if there is at least one upper case letter in each word.

For example, 'This Is Title' and 'OK, Give Me My iPhone' would pass. 'all words lower' and 'Word In lower' would fail.

This logic changed in Robot Framework 4.0 to be compatible with Convert to Title Case. See Convert to Title Case for title case algorithm and reasoning.

The default error message can be overridden with the optional msg argument.

Words can be explicitly excluded with the optional exclude argument.

Explicitly excluded words can be given as a list or as a string with words separated by a comma and an optional space. Excluded words are actually considered to be regular expression patterns, so it is possible to use something like "example[.!?]?" to match the word "example" on it own and also if followed by ".", "!" or "?". See BuiltIn.Should Match Regexp for more information about Python regular expression syntax in general and how to use it in Robot Framework data in particular.

See also Should Be Upper Case and Should Be Lower Case.

Source code in src/robot/libraries/String.py 
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
@keyword(types=None)
def should_be_title_case(self, string, msg=None, exclude=None):
    """Fails if given ``string`` is not title.

    ``string`` is a title cased string if there is at least one upper case
    letter in each word.

    For example, ``'This Is Title'`` and ``'OK, Give Me My iPhone'``
    would pass. ``'all words lower'`` and ``'Word In lower'`` would fail.

    This logic changed in Robot Framework 4.0 to be compatible with
    `Convert to Title Case`. See `Convert to Title Case` for title case
    algorithm and reasoning.

    The default error message can be overridden with the optional
    ``msg`` argument.

    Words can be explicitly excluded with the optional ``exclude`` argument.

    Explicitly excluded words can be given as a list or as a string with
    words separated by a comma and an optional space. Excluded words are
    actually considered to be regular expression patterns, so it is
    possible to use something like "example[.!?]?" to match the word
    "example" on it own and also if followed by ".", "!" or "?".
    See `BuiltIn.Should Match Regexp` for more information about Python
    regular expression syntax in general and how to use it in Robot
    Framework data in particular.

    See also `Should Be Upper Case` and `Should Be Lower Case`.
    """
    if string != self.convert_to_title_case(string, exclude):
        raise AssertionError(msg or f"{string!r} is not title case.")