Using Regular Expressions in Scripts

In Python, support for regular expressions is implemented via the re module. This module is not added to your project by default. To import it, add the import re line at the beginning of your test:

The methods used to match regular expressions in Python return a match object on success. This object always has a boolean value of True.

Properties are specified in the method call. For example, to make your regular expression ignore case:

The table below lists the methods and properties that can be used to work with regular expressions in Python:

For detailed information on how to use regular expressions in Python, refer to the re — Regular expression operations article in Python Wiki.

In VBScript, use the RegExp object to create regular expressions:

The RegExp object stores a regular expression pattern along with flags that identify how to apply it. The RegExp object has the following properties and methods:

To iterate through the matches found by the RegExp.Execute method, use the Matches and Match objects. The Matches object holds a collection of Match objects (each object describes a particular match). The Match object has the following properties and methods:

For more information about VBScript regular expressions, see the following MSDN articles:

For DelphiScript, regular expressions support is implemented with the RegExpr object provided by the HISUtils plugin. The object instances define the regular expression pattern and store other properties that identify how to apply the pattern. It also has methods that are required to perform actions over regular expressions. The table below lists the methods and properties of RegExpr object:

The following table lists tokens that are recognized by JavaScript’s, JScript’s, Python’s and VBScript’s “native” regular expressions, and the HISUtils.RegExpr object in DelphiScript.

You can divide an expression into constituent parts or sub-expressions. To specify a sub-expression use parenthesis, for instance, (\s\d+,\d+,d+,)(\d+). The parsing engine detects two sub-expressions in this expression:

• \s\d+,\d+,d+,
• \d+

Besides, the engine assigns an item index to the whole expression and to each sub-expression, where the index of the expression is 0, the index of the first sub-expression is 1 and so on. That is:

• 0: (\s\d+,\d+,d+,)(\d+)
• 1: \s\d+,\d+,d+,
• 2: \d+

A text fragment that matches a sub-expression is called a submatch. How to access a submatch depends on the scripting language:

VBScript does not support mode modifiers.

Mode modifiers specify how the engine interprets regular expressions. They toggle the engine’s behavior modes. The following modifiers are available:

You can specify the modifier in the expression using the (?key) or (?-key) syntax (where key stands for the modifier key and minus sign specifies the disabled state for the corresponding modifier). If you try to specify unsupported modifier keys an error occurs. The modifiers can be applied to the whole expression or only to a sub-expression. For example:

One of the most typical applications of regular expressions is searching for some text fragments within a text. In some cases, you can perform this task without using regular expressions, for instance, make a list of sought for fragments and compare the whole text with the list, but this approach is not effective when the number of possible sought for fragments is large. The regular expressions are designed especially for these situations. Using them you can define a set of rules that the fragment should comply with.

An e-mail address search is a perfect example to illustrate the abilities of regular expressions. Suppose you have text containing e-mail addresses and you need to extract them out of the text. You do not know what these addresses are, so you cannot list them.

However each e-mail address is issued according to the following rules: it can start with any alphanumeric symbol, the further characters can be alphanumeric, underscore, dot or dash, then it should contain the @ symbol that separates the domain. The domain can also hold any alphanumeric characters, underscores, dots or dashes, but the final dot should be followed by a sequence of letters from two to six characters length. By applying the regular expressions syntax notation we can compose the pattern: \w+(\.[\w-]+)*@([\w-]+\.)+[a-zA-Z]{2,6} that specifies an e-mail address.

The sample below seeks and extracts several e-mail addresses from an input string using this pattern.

import re
def ExtractDemo():
  InStr = "Please e-mail us at [email protected] or [email protected]"
  # Set a regular expression pattern that specifies an e-mail address
  regEx = "(\w+@[\w-]+\.+[a-zA-Z]{2,6})"
  # Perform search operation
  Matches = re.findall(regEx, InStr)
  # Iterate through Matches array
  if Matches:
    for i in Matches:
      ResStr=ResStr + str(i) + "; "

    Log.Message("These e-mails were extracted: "+ResStr);
    # Posts the following to the log:
    # "These e-mails were extracted: [email protected]; [email protected]; "

Another frequent operation with regular expressions is replacement. It works in the same way as the search operation, but the found occurrences are substituted with the specified text. The example below locates an e-mail address within an input string and replaces it with the specified string.

import re
def ReplaceDemo():
  InStr = "If you have any questions, send them to [email protected].";
  # Set regular expression pattern that specifies an e-mail address
  regEx = "(\w+@[\w-]+\.+[a-zA-Z]{2,6})"
  # Perform replace operation
  ResStr = re.sub(regEx,"mycompany support team", InStr)

  Log.Message(ResStr);
  # Posts the following to the log:
  # "If you have any questions, send them to mycompany support team."

You can use regular expressions to specify variable parts in object captions in calls to methods that simulate user actions (ClickItem, SelectItem, CheckItem, ClickCell, and so forth). To recognize a control, TestComplete often uses its caption. Captions of some controls may change from one application run to another, so using regular expressions makes the created tests stable.

The following code demonstrates how you can use regular expressions to select a combo-box item which contains "sans" in its caption:

import re
def VariablePartsDemo():
  TestedApps.notepad.Run()
  notepad = Sys.Process("notepad")
  notepad.Window("Notepad", "*").MainMenu.Click("Format|Font...")
  dlgFont = notepad.Window("#32770", "Font")
  # Use a regular expression pattern that matches any sans serif typeface
  dlgFont.Window("ComboBox", "", 1).ClickItem(re.compile(".* [S|s]ans"))

Another example of using regular expressions in object captions is testing localized or multilingual applications. When the control's caption can have several variants in different languages, you may use regular expressions to list all possible variants of the caption.

The following code shows how to identify a grid cell using the column's caption in English, German, French, and Spanish locales:

import re
def LocaleIndependentDemo():
  TestedApps.DataGridViewSample.Run()
  dataGridView = Sys.Process("DataGridViewSample").WinFormsObject("Form1").WinFormsObject("dataGridView1")
  # Set regular expression pattern that specifies caption in multiple languages 
  caption = re.compile("(Customer Name)|(Kundenname)|(Nom du client)|(Nombre del cliente)")
  dataGridView.ClickCell(3, caption)

With regular expressions you can define patterns that contain multiple lines of text. That is a pattern can include special characters like carriage returns and line feeds. This could be useful when handling large fragments of formatted text, like text files or code listings. Note, that tokens for special symbols in regular expression patterns do not depend on a scripting language. However, to specify a replacement string that would hold multiple text lines, you should use language-specific notation of special characters. (See Special characters section in Working With Strings topic that corresponds to the language you use.) Here is a sample routine that accepts Pascal code fragments and inserts a comment before a function declaration, like in the fragment below:

import re
def InsertComments(ProgramText):
  # Set regular expression pattern that corresponds to Pascal function declaration
  regEx ="(\r\n+function)"
  ReplacementLines = ";\r\n\r\n//A helper routine\r\nfunction";
  # Perform replace operation
  NewProgramText = re.sub(regEx, ReplacementLines, ProgramText)
  Log.Message("Comments have been inserted. See Remarks section for the new text of a program.", NewProgramText)
  return NewProgramText

This sample demonstrates how to address submatches of the found text. To do this, you should define sub-expressions beforehand. Sub-expressions are denoted in a pattern with the parenthesis. The code below extracts the phone number from an input string, parses the number into sub-group elements and forms a new string that contains those elements.

def SubMatchesDemo():
  InStr = "Jack, when you arrive, phone me +1(234)567-89-01."
  # Set regular expression pattern that specifies a phone number
  regEx = "(\+\d *?)(\(\d+\) *?)(\d+(-\d*)*)"
  # Perform search operation
  Matches = re.search(regEx, InStr)
  # Access to the whole match and its submatches
  ResStr = "The phone number " + Matches.group(0) + " consists of these parts:\r\n"
  ResStr = ResStr + "Zone code " + Matches.group(1) + ", "
  ResStr = ResStr + "city code " + Matches.group(2) + " " 
  ResStr = ResStr + "and number itself " + Matches.group(3) + "."
  
  Log.Message(ResStr)
  # Posts the following to the log:
  # 'The phone number +1(234)567-89-01 consists of these parts:
  # Zone code +1, city code (234) and number itself 567-89-01.'