General Python Resources¶

• Resources for Python 3.8 (default Python version in Squish):

  • Python Documentation (Python 3.8)

  • Python Tutorial (Python 3.8)

  • Python Language Reference (Python 3.8)

• Resources for Python 2.7

  • Python Documentation (Python 2.7)

  • Python Tutorial (Python 2.7)

  • Python Language Reference (Python 2.7)

Squish Python Basics¶

• To execute a test case Squish loads the main test script file ("test.py") and executes the function called "main()". The "main()" function must be declared in the test script. Example of a simple "test.py" script:

  def main():
      test.log("Hello world.")

Printing / Outputting Values¶

• In Python the "print" command is often used for outputting values, for example to read and verify a value. For example, inside of a Squish test script:

  def main():
      print(1)

• In Squish test scripts the output of the print command appears in the Runner/Server Log view (by default at the bottom) in the Squish IDE.

• Because the Runner/Server Log also contains a lot of other information, finding ones own output in it is a bit cumbersome, therefore one should use the test.log() command that is provided by Squish instead:

  def main():
      test.log("Hello world")

  The test.log() command adds an entry with the provided value to the Test Results view in the Squish IDE.

Comments¶

• Single line and multi line comments can be put in Python scripts.

• Single line comments start with a hash symbol (#):

  def main():
      # Single line comment
      test.log("Hello world")

• Comments which span multiple lines can be composed of multiple single line comments or by using multi line comments, which are defined by enclosing the comment in triple double quotes:

  def main():
      # Multiple single line comments
      # used as multi-line comment
  
      test.log("Hello world1")
  
      """A comment that spans
      across multiple lines
      can be useful sometimes."""
  
      test.log("Hello world2")

Variables¶

• Variables act as placeholders for values. The variables can then be used in multiple places where the value that they contain (or represent) should be used:

  def main():
      variable_1 = "Hello world."
      test.log(variable_1)

String Data Type¶

• A string is a sequences of characters.

• String values are defined in test scripts by enclosing the desired text within single or double quotes (so called string literals):

  def main():
      variable_with_string1 = "Hello world1."
      variable_with_string2 = 'Hello world2.'
      test.log(variable_with_string1)
      test.log(variable_with_string2)

• The backslash character has a special meaning in string literals. To have a backslash in a string literal the backslash must be doubled to escape its special meaning:

  def main():
      variable_with_string = "Hello\\world."

• Also see:

  • String literals

  • String literal concatenation

  • String Methods

  • Strings (Tutorial)

Integer Data Type¶

• Integer are number values.

• Integer values are defined in test scripts by entering the number value directly.

• For outputting via test.log() conversion to string is necessary. For this the str() function should be used:

  def main():
      variable_with_int1 = 1
      variable_with_int2 = -1
      variable_with_float = 1.1
  
      test.log(str(variable_with_int1))
      test.log(str(variable_with_int2))

• Also see:

  • Integer and long integer literals

  • str() at Built-in Functions

  • Numbers (Tutorial)

If Statement¶

• The If statement can be used to execute a piece of code when a certain condition is given. For example:

  def main():
      x = 1
      if x > 0:
          test.log(str(x))

• Additional conditions can be checked separately via elif and then only the respective set of commands that belong to that condition will be executed:

  def main():
      x = 1
      if x > 0:
          test.log("x is larger than 0: {}".format(x))
      elif x == 1:
          test.log("x equals 1")

• If none of the specified conditions are true, the else part of the If statement can be used to execute code for that case, too:

  def main():
      x = -1
      if x > 0:
          test.log("x is larger than 0: {}".format(x))
      elif x == 1:
          test.log("x equals 1")
      else:
          test.log("x is not 1 and not larger than 0: {}".format(x))

• Also see:

  • The if statement

  • If statements (Tutorial)

Conditions¶

• The conditions specified for the If statement as well as other statements can consist of multiple conditions, too.

• Multiple conditions can be evaluated together by using "and", "or" and "not":

  def main():
      x = 1
      if x > 0 and x < 10:
          test.log(str(x))
  
      if x > 0 and not x < 10:
          test.log(str(x))

Indentation matters in Python¶

• In Python scripts indentation is relevant. Random indentation is not allowed.

• Less indentation denotes that the code following no longer belongs to the previous block, for example of an if statement:

  def main():
      x = 1
  
      if x > 0:
          # Code for condition "x > 0" starts here...
  
          test.log("x is larger than 0: {}".format(x))
  
          # ...and ends here.
  
      # This change of indentation tells Python that
      # the code for the condition "x > 0" is over
      test.log("x equals 1")

• The recommended indentation is 4 characters (default in Squish IDE) per block. (The above scripts use only 2 characters per block to avoid line wrapping.)

Lists¶

• Lists can be used to store multiple values. For example:

  def main():
      # Declare variable and let it refer to an
      # empty list:
      my_list = []
  
      # Putting some values into the list:
      my_list.append("Hello")
      my_list.append("world")
      my_list.append(".")
  
      # Accessing the separate values, by
      # their index:
      test.log(my_list[0])
      test.log(my_list[1])
      test.log(my_list[2])
  
      # Accessing the "last" list value by
      # using negative index:
      test.log(my_list[-1])

• Declaring a list with values directly:

  def main():
      # Declare variable and let it refer to a
      # list which already contains values:
      my_list = ["Hello", "world", "."]

• Also see:

  • Lists (Tutorial)

For Loops¶

*It is possible to iterate over the values of a list or the characters of a string value directly:

def main():
    my_list = ["Hello", "world", "."]

    for current_list_value in my_list:
        test.log("Current list value: {}".format(current_list_value))

• Example with range() to generate a list of values from 0 to x:

  def main():
      # Declare variable and let it refer to a
      # list which already contains values:
      my_list = ["Hello", "world", "."]
  
      for i in range(len(mylist)):
          test.log("Value at index {} : {}".format(i,my_list[i]))

• A more complex example with enumerate if you want the index and the element at the same time:

  def main():
      # Declare variable and let it refer to a
      # list which already contains values:
      my_list = ["Hello", "world", "."]
  
      for i,element in enumerate(mylist):
          test.log("Value at index {} : {}".format(i,element))

• Also see:

  • The for statement

  • For statements (Tutorial)

  • The range() function

  • Iterators (Tutorial)

While Loops¶

• The while loop repeats until the specified condition is no longer true:

  def main():
      s = "Hello world."
  
      # Keep looping while i is smaller than
      # the length of the string value in s:
  
      i = 0
      while i < len(s):
          # Get character at index i in s:
          c = s[i]
          test.log(c)
          #increment index
          i += 1

• Also see:

  • The while statement

Exiting Loops¶

• The break command can be used to exit a loop:

  def main():
      s = "Hello world."
  
      # Keep looping while i is smaller than
      # the length of the string value in s:
  
      i = 0
      while i < len(s):
          # Exit the loop after the fith character
          if i == 5:
              break
          # Get character at index i in s:
          c = s[i]
          test.log(c)
          #increment index
          i += 1

Functions¶

• We have already seen the mandatory main() function in Squish test scripts. Its purpose is to define a standard starting point for the regular test case execution, so that Squish and the test writer know how and agree on how a test case is being started.

• Python generally allows you to create you own functions.

• The main purpose of creating functions yourself is to avoid repeating smaller or larger amounts of the same code.

• The following example appends values to a list in multiple steps and outputs all list values after each step.

• As you can see some code gets repeated a few times, so we have some code redundancy in this example:

  def main():
      # Something new, a list with number values
      my_list = [1, 2, 3]
  
      # Outputting the list values:
      for v in my_list:
          test.log("Current list value: {}".format(v))
  
      # Append a value; use last value and add 1 to it:
      my_list.append(my_list[-1] + 1)
  
      # Outputting the list values:
      for v in my_list:
          test.log("Current list value: {}".format(v))
  
      # Append a value; use last value and add 10 to it:
      my_list.append(my_list[-1] + 10)
  
      # Outputting the list values:
      for v in my_list:
          test.log("Current list value: {}".format(v))

• The problem with code redundancy is that if the redundant code pieces should all be changed (for example to output the values along with their index in the list), then all code pieces have to be found and changed.

• This tends to be error prone because it is easy to miss some of the code pieces.

• Another problem with redundancy is that it can make code harder to read and understand.

• Redundant code pieces should be put into functions. In the example above the code for outputting all list values is repeated three times, so it is useful to put that into a function and to then call the function instead:

  def output_all_list_values(the_list):
      for v in the_list:
          test.log("Current list value: " + v)
  
  def main():
      # Something new, a list with number values
      my_list = [1, 2, 3]
  
      output_all_list_values(my_list)
  
      # Append a value; use last value and add 1 to it:
      my_list.append(my_list[-1] + 1)
  
      output_all_list_values(my_list)
  
      # Append a value; use last value and add 10 to it:
      my_list.append(my_list[-1] + 10)
  
      output_all_list_values(my_list)

• As you can see there is a new function called output_all_list_values() (def output_all_list_values(the_list)) and it requires a list as its parameter when being called (output_all_list_values(my_list)).

• The new function has a name that expresses its purposes clearly, so that some of the comments could be removed from the original script, too.

• The total number of lines of the above script has only changed slightly (from 21 down to 19), but readability has been improved already, making it easier to see what the script is doing (aside of outputting list values again and again).

• Also see:

  • Defining Functions (Tutorial)

  • More on Defining Functions (Tutorial)

• scripting
• python