IOKW_State (OKW - OpenKeyWord 0.0.16 API)

All Known Implementing Classes:

Core, NOK, OK
```
public interface IOKW_State
```

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`BeginTest(String fpsTestname)` \~german \brief Markiert den Anfang eines neuen Testfalls.
`void`	`ClickOn(String FN)` \~german \brief Klickt auf das gegebene Objekt.
`void`	`CopyFile(String fpsSourcePathAndFileName, String fpsDestinationPathAndFileName)`
`void`	`DoubleClickOn(String FN)` \~german \brief Klickt auf das gegebene Objekt.
`void`	`EndTest()` \~german \brief Beendet den Test, bzw.
`void`	`FileDelete(String fpsPathAndFileName)` \~german \brief Löscht die gegebene Datei.
`void`	`LogCaption(String FN)` \~german \brief Keine Beschreibung zu "LogCaption" verfügbar
`void`	`LogExists(String FN)` \~german \brief Protokolliert, ob das gegebene Objekt existiert.
`void`	`LogHasFocus(String FN)` \~german \brief Dokumentiert den Fokus-Status des gegebenen Objekts.
`void`	`LogIsActive(String FN)` \~german \brief Dokumentiert den Status des gegebenen Objekts.
`void`	`LogLabel(String FN)` \~german \brief Keine Beschreibung zu "LogLabel" verfügbar
`void`	`LogSelected(String FN)` \~german \brief Dokumentiert den markierten Text des gegebenen Objekts.
`void`	`LogTablecellValue(String FN, String fpsCol, String fpsRow)` \~german \brief Dokumentiert den Wert der ausgewählten Zelle.
`void`	`LogTooltip(String FN)` \~german \brief Dokumentiert die Kurzinfo zu einem Werkzeug des gegebenen Objekts.
`void`	`LogValue(String FN)` \~german \brief Dokumentiert den Standartwert eines Objekts.
`void`	`MemorizeCaption(String FN, String fpsMemKeyName)` \~german \brief Keine Beschreibung zu "MemorizeCaption" verfügbar
`void`	`MemorizeExists(String FN, String fpsMemKeyName)` \~german \brief Merkt sich den aktuell existierenden Zustand des Objekts.
`void`	`MemorizeHasFocus(String FN, String fpsMemKeyName)` \~german \brief Keine Beschreibung zu "MemorizeHasFocus" verfügbar
`void`	`MemorizeIsActive(String FN, String fpsMemKeyName)` \~german \brief Merkt sich den Zustand des gegebenen Objekts.
`void`	`MemorizeLabel(String FN, String fpsMemKeyName)` \~german \brief Keine Beschreibung zu "MemorizeLabel" verfügbar
`void`	`MemorizeSelectedValue(String FN, String fpsMemKeyName)` \~german \brief Keine Beschreibung zu "MemorizeSelectedValue" verfügbar
`void`	`MemorizeTablecellValue(String FN, String fpsCol, String fpsRow, String fpsMemKeyName)` \~german \brief Merkt sich den Wert der gegebenen Zelle in der Tabelle.
`void`	`MemorizeTooltip(String FN, String fpsMemKeyName)` \~german \brief Dokumentiert den Tooltip-Text (Kurzinformation) des gegebenen Objekts.
`void`	`MemorizeValue(String FN, String fpsMemKeyName)` \~german \brief Merkt sich den Standartwert eines Objekts.
`void`	`Select(String FN, String Val)` \~german \brief Auswahl aller Zeilen einer Liste/Tabelle, welche die gegebenen Daten enthalten.
`void`	`SelectMenu(String FN)` \~german \brief Wählt den gegebenen Menü-Eintrag aus _Beispiel: Wähle Menüeintrag mit Namen "MeinMenü":_ \verbatim Wähle Aus Menü: "MeinMenü" \endverbatim
`void`	`SelectMenu(String FN, String Val)` \~german \brief Wählt den gegebenen Menüeintrag aus.
`void`	`SelectTablecell(String FN, String fpsCol, String fpsRow)` \~german \brief Wählt die gegebene Tabellenzelle aus.
`void`	`SelectWindow(String FN)` \~german \brief Setzt den Kontext auf das gegebene Fenster.
`void`	`Sequence(String FN, String fpsSequenceName, String SEQ_ID)` \~german \brief Ruft die Sequenz eines Fensters auf.
`void`	`SetFocus(String FN)` \~german \brief Setzt den Fokus auf das gegebene Fensterobjekt.
`void`	`SetLanguage(String Language)` \~german \brief Interne Methode zum setzen der Sprache für die sprachabhängigen Ausgaben der Dokumentation (Log).
`void`	`SetValue(String FN, String Val)` \~german \brief Setzt den Wert des gegebenen Fensterobjekts auf den gegebenen Wert.
`void`	`StartApp(String fpsApplicationName)` \~german \brief Startet die gegebene Anwendung.
`void`	`StopApp(String fpsApplicationName)` \~german \brief Beendet eine gegebene Anwendung.
`void`	`TypeKey(String FN, String Val)` \~german \brief Tastatureingaben von Daten in das aktive Fensterobjekt.
`void`	`TypeKeyTablecell(String FN, String fpsCol, String fpsRow, String Val)` \~german \brief Eingabe von Daten in eine gegebene Tabellenzelle über die Tastatur.
`void`	`TypeKeyWindow(String FN, String Val)` \~german \brief Tastatureingabe in ein bestimmtes Fensterobjekt.
`void`	`VerifyCaption(String FN, String ExpVal)` \~german \brief Überprüft die Überschrift des Objektes.
`void`	`VerifyCaptionREGX(String FN, String ExpVal)` \~german \brief Überprüft die Überschrift des Objektes.
`void`	`VerifyCaptionWCM(String FN, String ExpVal)` \~german \brief Überprüft die Überschrift des Objektes.
`void`	`VerifyDirectoryExists(String fpsPath, String ExpVal)` \~german \brief Prüft, ob das gegebene Verzeichnis existiert.
`void`	`VerifyExists(String FN, String ExpVal)` \~german \brief Prüft, ob das gegebene Objekt existiert. _Beispiel 1: Prüfe, ob das Objekt "MeinObjekt" existiert:_ \verbatim Prüfe Existiert: "MeinObjekt", "JA" \endverbatim _Beispiel 2: Prüfe, ob das Objekt "MeinObjekt" nicht existiert: \verbatim Prüfe Existiert: "MeinObjekt", "NEIN" \endverbatim
`void`	`VerifyFileExists(String fpsPathAndFileName, String ExpVal)` \~german \brief Prüft, ob die gegebene Datei existiert.
`void`	`VerifyHasFocus(String FN, String ExpVal)` \~german \brief Vergleicht den Fokus-Zustand des gegebenen Objekts mit dem erwarteten Wert.
`void`	`VerifyIsActive(String FN, String ExpVal)` \~german \brief Vergleicht den Fokus-Status des gegebenen Objekts mit dem erwarteten Wert.
`void`	`VerifyLabel(String FN, String ExpVal)` \~german \brief Überprüft die Beschreibung des Objektes.
`void`	`VerifyLabelREGX(String FN, String ExpVal)` \~german \brief Überprüft die Überschrift des Objektes.
`void`	`VerifyLabelWCM(String FN, String ExpVal)` \~german \brief Überprüft die Beschreibung des Objektes.
`void`	`VerifySelectedValue(String FN, String ExpVal)` \~german \brief Vergleicht den ausgewählten Wert des gegebenen Listenobjekts mit dem erwarteten Wert.
`void`	`VerifyTablecellValue(String FN, String fpsCol, String fpsRow, String ExpVal)` \~german \brief Vergleicht den Inhalt der gegebenen Tabellenzeile mit dem erwarteten Wert.
`void`	`VerifyTooltip(String FN, String ExpVal)` \~german \brief Prüft den Tooltip-Text eines Objektes.
`void`	`VerifyTooltipREGX(String FN, String ExpVal)` \~german \brief Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text).
`void`	`VerifyTooltipWCM(String FN, String ExpVal)` \~german \brief Prüft den Tooltip-Text eines Objektes (in den meisten Fällen ist dies der angezeigte Text).
`void`	`VerifyValue(String FN, String ExpVal)` \~german \brief Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text).
`void`	`VerifyValueREGX(String FN, String ExpVal)` \~german \brief Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text).
`void`	`VerifyValueWCM(String FN, String ExpVal)` \~german \brief Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text).

- Method Detail
  - BeginTest
```
void BeginTest(String fpsTestname)
               throws Exception
```
    \~german \brief Markiert den Anfang eines neuen Testfalls. Beschreibung des Handlungsablaufes \note Alle Testfälle sollten mit BeginneTest afangen: Dieses Schlüsselwort initialisiert OKW und versetz diesen in einen initialen Zustand, d.h. als wäre OKW neu gestartet.
    
    Parameters:
    fpsTestname - Name oder Bezeichnung des Testfalls. \~english \brief Begins a test. Description of the allgorithm \note Keyword initalis
    fpsTestname - No explanation available \~
    
    Throws:
    
    Exception
  - ClickOn
```
void ClickOn(String FN)
             throws Exception
```
    \~german \brief Klickt auf das gegebene Objekt. _Beispiel: Klicke auf das Objekt mit Namen "MeinObjekt":_
    \verbatim Klicke auf: "MeinObjekt" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief Clicks on given object. _Example: Click on the object with the name "My Object":_
    \verbatim click on: "MyObject" \endverbatim
    FN - Functional name of the object _Example: Click on "My Object":_ \verbatim click on: "MyObject" \endverbatim
    
    Throws:
    
    Exception
  - DoubleClickOn
```
void DoubleClickOn(String FN)
                   throws Exception
```
    \~german \brief Klickt auf das gegebene Objekt. _Beispiel: Klicke auf das Objekt mit Namen "MeinObjekt":_
    \verbatim DoppelKlickeAuf( "MeinObjekt" ) \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief Clicks on given object. _Example: Click on the object with the name "My Object":_
    \verbatim DoubleClickOn( "MyObject" ) \endverbatim
    FN - Functional Name of the object \~
    
    Throws:
    
    Exception
  - EndTest
```
void EndTest()
             throws Exception
```
    \~german \brief Beendet den Test, bzw. den Testfall. Beschreibung der Arbeitsweise. \note Zusätzliche Bemerkungen zum Schlüsselwort \~english \brief Terminates the test respectively the testcase. Description of the mode of operation. \note Additional remark to the keyword \~
    
    Throws:
    
    Exception
  - LogCaption
```
void LogCaption(String FN)
                throws Exception
```
    \~german \brief Keine Beschreibung zu "LogCaption" verfügbar
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief No description for "LogCaption" available
    FN - Functional name of the object \~
    
    Throws:
    
    Exception
  - LogExists
```
void LogExists(String FN)
               throws Exception
```
    \~german \brief Protokolliert, ob das gegebene Objekt existiert. _Beispiel: Protokolliert, ob das Objekt mit Namen "Mein Objekt" vorhanden ist:_
    \verbatim logge vorhanden: "MeinObjekt" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief Logs whether the given object is existing. _Example: Logs whether the object with the name "My Object" is existing:_
    \verbatim log exists: "MyObject" \endverbatim
    FN - Functional name of the object \~
    
    Throws:
    
    Exception
  - LogHasFocus
```
void LogHasFocus(String FN)
                 throws Exception
```
    \~german \brief Dokumentiert den Fokus-Status des gegebenen Objekts. _Beispiel: Protokolliert den Fokus-Zustand von "Mein Objekt":_
    \verbatim Logge hat Fokus: "MeinObjekt" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief Logs the focus status of the given object. _Example: Logs the focus status of "My Object":_
    \verbatim LoghasFocus: "MyObject" \endverbatim
    FN - Functional name of the object \~
    
    Throws:
    
    Exception
  - LogIsActive
```
void LogIsActive(String FN)
                 throws Exception
```
    \~german \brief Dokumentiert den Status des gegebenen Objekts. _Beispiel: Protokolliert den Aktivzustand von "Mein Objekt":_
    \verbatim LoggeIstAktiv: "MeinObjekt" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief Logs the status of the given object. _Example: Logs the active status of "My Object":_
    \verbatim LogIsActive: "MyObject" \endverbatim
    FN - Functional name of the object \~
    
    Throws:
    
    Exception
  - LogLabel
```
void LogLabel(String FN)
              throws Exception
```
    \~german \brief Keine Beschreibung zu "LogLabel" verfügbar
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief No description for "LogLabel" available
    FN - Functional name of the object \~
    
    Throws:
    
    Exception
  - LogSelected
```
void LogSelected(String FN)
                 throws Exception
```
    \~german \brief Dokumentiert den markierten Text des gegebenen Objekts.
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief Logs the marked text of the given object.
    FN - Functional name of the object \~
    
    Throws:
    
    Exception
  - LogTablecellValue
```
void LogTablecellValue(String FN,
                     String fpsCol,
                     String fpsRow)
                       throws Exception
```
    \~german \brief Dokumentiert den Wert der ausgewählten Zelle.
    
    Parameters:
    FN - Funktionaler Name des Objekts
    fpsCol - Spaltennummer der zu wählenden Zelle, beginnend mit 1.
    fpsRow - Zeilennummer der zu wählenden Zelle, beginnend mit 1. \~english \brief Logs the value of the selected tablecell.
    FN - Functional name of the object
    fpsCol - Column number of cell to be selected, starting with 1.
    fpsRow - Row number of cell to be selected, starting with 1. \~
    
    Throws:
    
    Exception
  - LogTooltip
```
void LogTooltip(String FN)
                throws Exception
```
    \~german \brief Dokumentiert die Kurzinfo zu einem Werkzeug des gegebenen Objekts. _Beispiel: Protokolliert den Kurzinformationstext (Tooltip) von "Mein Objekt":_
    \verbatim LoggeTooltip: "MeinObjekt" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief Logs the Tooltip of the given object. _Example: Logs the tooltip text of "My Object":_
    \verbatim LogToolip: "MyObject" \endverbatim
    FN - Functional name of the object \~
    
    Throws:
    
    Exception
  - LogValue
```
void LogValue(String FN)
              throws Exception
```
    \~german \brief Dokumentiert den Standartwert eines Objekts. Der Standardwert des Objektes (in den meisten Fällen ist dies der angezeigte Text) wird ausgelesen und in der aktuellen Dokumentationsdatei ausgegeben.
    _Beispiel: Prüfe, ob der Wert (Text) des Objekts "MeinObjekt" dem erwarteten Wert "Django" entspricht:_
    \verbatim Prüfe Wert: "MeinObjekt", "Django" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief Logs the standard value of an object. The standard value of the object (in most cases the visible text) is detected and returned in the actual log-file
    _Example: Check if the value (text) of object "MyObject" equals the expected value "Django":_
    \verbatim Verify Value: "MyObject", "Django" \endverbatim
    FN - Functional name of the object \~
    
    Throws:
    
    Exception
  - MemorizeCaption
```
void MemorizeCaption(String FN,
                   String fpsMemKeyName)
                     throws Exception
```
    \~german \brief Keine Beschreibung zu "MemorizeCaption" verfügbar
    
    Parameters:
    FN - Funktionaler Name des Objekts
    fpsMemKeyName - Name des Schlüssels \~english \brief No description for "MemorizeCaptione" available
    FN - Functional name of the object
    fpsMemKeyName - Name of the key \~
    
    Throws:
    
    Exception
  - MemorizeExists
```
void MemorizeExists(String FN,
                  String fpsMemKeyName)
                    throws Exception
```
    \~german \brief Merkt sich den aktuell existierenden Zustand des Objekts. Der Wert wird unter dem als Parameter übergebenen Schlüssel gespeichert.
    _Beispiel: Merkt sich den vorhandenen Zustand des Objektes "MeinObjekt" unter dem Schlüssel "Mein Schlüssel".:_
    \verbatim Merke Existiert: "MeinObjekt", "Mein Schlüssel" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    fpsMemKeyName - Name des Schlüssels \~english \brief Memorizes the actual existing Status of the object. The value is stored under the key returned as parameter.
    _Example: Memorizes the existent state of the object "My Object" under the key "My Key":_
    \verbatim Memorize Exists: "MyObject", "MyKey" \endverbatim
    FN - Functional name of the object
    fpsMemKeyName - Name of the key \~
    
    Throws:
    
    Exception
  - MemorizeHasFocus
```
void MemorizeHasFocus(String FN,
                    String fpsMemKeyName)
                      throws Exception
```
    \~german \brief Keine Beschreibung zu "MemorizeHasFocus" verfügbar
    
    Parameters:
    FN - Funktionaler Name des Objekts
    fpsMemKeyName - Name des Schlüssels \~english \brief No description for "MemorizeHasFocus" available
    FN - Functional name of the object
    fpsMemKeyName - Name of the key \~
    
    Throws:
    
    Exception
  - MemorizeIsActive
```
void MemorizeIsActive(String FN,
                    String fpsMemKeyName)
                      throws Exception
```
    \~german \brief Merkt sich den Zustand des gegebenen Objekts. Der Wert wird unter dem als Parameter übergebenen Schlüssel gespeichert.
    _Beispiel: Merkt den Zustand des Objektes "MeinObjekt" unter dem Schlüssel "Mein Schlüssel":_
    \verbatim Merke Ist Aktiv: "MeinObjekt", "Mein Schlüssel" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    fpsMemKeyName - Name des Schlüssels \~english \brief Memorizes the state of the given object. The value is stored under the key which is given as parameter.
    _Example Memorizes the object-state of MyObject under the key "MyKey":_
    \verbatim Memorize Is Active: "MyObject", "MyKey" \endverbatim
    FN - Functional name of the object
    fpsMemKeyName - Name of the key \~
    
    Throws:
    
    Exception
  - MemorizeLabel
```
void MemorizeLabel(String FN,
                 String fpsMemKeyName)
                   throws Exception
```
    \~german \brief Keine Beschreibung zu "MemorizeLabel" verfügbar
    
    Parameters:
    FN - Funktionaler Name des Objekts
    fpsMemKeyName - Name des Schlüssels \~english \brief No description for "MemorizeLabel" available
    FN - Functional name of the object
    fpsMemKeyName - Name of the key \~
    
    Throws:
    
    Exception
  - MemorizeSelectedValue
```
void MemorizeSelectedValue(String FN,
                         String fpsMemKeyName)
                           throws Exception
```
    \~german \brief Keine Beschreibung zu "MemorizeSelectedValue" verfügbar
    
    Parameters:
    FN - Funktionaler Name des Objekts
    fpsMemKeyName - Name des Schlüssels \~english \brief No description for "MemorizeSelectedValue" available
    FN - Functional name of the object
    fpsMemKeyName - Name of the key \~
    
    Throws:
    
    Exception
  - MemorizeTablecellValue
```
void MemorizeTablecellValue(String FN,
                          String fpsCol,
                          String fpsRow,
                          String fpsMemKeyName)
                            throws Exception
```
    \~german \brief Merkt sich den Wert der gegebenen Zelle in der Tabelle.
    
    Parameters:
    FN - Funktionaler Name des Objekts
    fpsMemKeyName - Name des Schlüssels
    fpsCol - Spaltennummer der zu wählenden Zelle, beginnend mit 1.
    fpsRow - Zeilennummer der zu wählenden Zelle, beginnend mit 1. \~english \brief Memorizes the value of the given tablecell.
    FN - Functional name of the object
    fpsMemKeyName - Name of the key
    fpsCol - Column number of cell to be selected, starting with 1.
    fpsRow - Row number of cell to be selected, starting with 1. \~
    
    Throws:
    
    Exception
  - MemorizeTooltip
```
void MemorizeTooltip(String FN,
                   String fpsMemKeyName)
                     throws Exception
```
    \~german \brief Dokumentiert den Tooltip-Text (Kurzinformation) des gegebenen Objekts. _Beispiel Dokumentiert den Tooltip-Text des Objektes "MeinObjekt":_
    \verbatim Logge Tooltip: "MeinObjekt" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    fpsMemKeyName - Name des Schlüssels \~english \brief Logs the tooltip-text of the given object. _Example logs the tooltip text of the given object "my object"_
    \verbatim Logge Tooltip: "MeinObjekt" \endverbatim
    FN - Functional name of the object
    fpsMemKeyName - Name of the key \~
    
    Throws:
    
    Exception
  - MemorizeValue
```
void MemorizeValue(String FN,
                 String fpsMemKeyName)
                   throws Exception
```
    \~german \brief Merkt sich den Standartwert eines Objekts. Der Standartwert des Objektes (in den meisten Fällen ist dies der angezeigte Text) wird ausgelesen und intern unter dem übergebenen Schlüssel gespeichert. Der Wert kann danach mit dem Schlüsselwort XXXXX wieder ausgelesen werden.
    _Beispiel: Legt sich den Wert (Text) des Objekts "MeinObjekt" unter dem Schlüssel "MeinSchlüssel" ab:_
    \verbatim Merke Wert: "MeinObjekt", "MeinSchlüssel" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    fpsMemKeyName - Name des Schlüssels \~english \brief Memorizes the standard value of an object. The standard value of the object -mostly this is the displayed text- is picked out and stored under the internal given key. The value can read out with the keyword XXXXX after it.
    _Example Memorizes the value (text) of object "MyObject" under the key "MyKey":_
    \verbatim Memorize the value (text) of object "MyObject" under the key "MyKey" \endverbatim
    FN - Functional name of the object
    fpsMemKeyName - Name of the key \~
    
    Throws:
    
    Exception
  - Select
```
void Select(String FN,
          String Val)
            throws Exception
```
    \~german \brief Auswahl aller Zeilen einer Liste/Tabelle, welche die gegebenen Daten enthalten. Tabellenspalten werden zeilenweise zusammengefasst, so dass Listen und Tabellen identisch verarbeitet werden. Die erste Zeile, welche die gegebenen Daten enthält, wird ausgewählt. Die Zeile wird über einen einfachen Klick angewählt. Die Übergabe des zusätzlichen Parameters "Doppelklick" führt zur Verwendung eines Doppelklicks. Die {HSEP}-Konstante kann verwendet werden, wenn definierte Werte in mehreren Spalten gefordert sind.
    _Beispiel 1: Wähle alle Zeilen aus, die den Text "Wert" enthalten:_
    \verbatim Wähle aus: "MeineTabelle", "Wert" \endverbatim
    _Beispiel 2: Wähle alle Zeilen aus, die mit dem Text "Wert1" beginnen und deren zweite Spalte den Text "Wert2" enthält:_
    \verbatim Wähle aus: "MeineTabelle", "Wert1{HSEP}, Wert2" \endverbatim
    _Beispiel 3: Wähle alle Zeilen aus, die mit dem Text "Wert1" beginnen und deren dritte Spalte den Text "Wert2" enthält:_
    \verbatim Wähle aus: "MeineTabelle", "Wert1{HSEP}{HSEP}Wert2" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    Val - Sich ergebender Wert \~english \brief Select all rows in a list/chart, which contain the given data. Chart columns are merged row by row to process lists and charts identical. The first row which contains the given data will be selected. The row is selected by a single click. The delivery of an additional parameter "Doubleclick" leads to the use of a doubleclick. The {HSEP}-constant can be used, if defined values in multiple columns are required.
    _Example #1: Select all rows which contain the text "Value":_
    \verbatim Select: "MyTable", "Value" \endverbatim
    _Example #2: Select all rows which contain the text "Value1" in the first column, followed by the text "Value2" in any of the remaining columns:_
    \verbatim Select: "MyTable", "Value1{HSEP}Value2" \endverbatim
    _Example #3: Select all rows which contain the text "Value1", followed by any (or no) text in the first column, followed by an empty column, followed by the text "Value2" in the third column:_
    \verbatim Select: "MyTable", "Value1{HSEP}{HSEP}Value2" \endverbatim
    FN - Functional name of the object
    Val - Resulting value \~
    
    Throws:
    
    Exception
  - SelectMenu
```
void SelectMenu(String FN)
                throws Exception
```
    \~german \brief Wählt den gegebenen Menü-Eintrag aus _Beispiel: Wähle Menüeintrag mit Namen "MeinMenü":_
    \verbatim Wähle Aus Menü: "MeinMenü" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief Selects the given menu item. _Example Select menu item with name "MyMenu":_
    \verbatim Select menu: "MyMenu" \endverbatim
    FN - Functional name of the object \~
    
    Throws:
    
    Exception
  - SelectMenu
```
void SelectMenu(String FN,
              String Val)
                throws Exception
```
    \~german \brief Wählt den gegebenen Menüeintrag aus. _Beispiel: Wähle Menüeintrag mit Namen "MeinMenü":_
    \verbatim Wähle Aus Menü: "MeinMenü" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    Val - Sich ergebender Wert \~english \brief Selects the given menu item. _Example Select menu item with name "MyMenu":_
    \verbatim Select menu: "MyMenu" \endverbatim
    FN - Functional name of the object
    Val - Resulting value \~
    
    Throws:
    
    Exception
  - SelectTablecell
```
void SelectTablecell(String FN,
                   String fpsCol,
                   String fpsRow)
                     throws Exception
```
    \~german \brief Wählt die gegebene Tabellenzelle aus. Die Parameter für die Spalten- und Zeilenpositionen werden immer als Strings eingegeben. Wenn ein Positionsparameter mit einem Hash (#) beginnt, dann wird er als Zahl interpretiert, z.B. "#1". Wenn das Hashzeichen als Text interpretiert werden soll, dann muss dies über einen vorangestellten Backslash gekennzeichnet werden, z.B. "#1 Text mit vorangestellter Nummer". Die Kopfzeile der Tabelle wird über den Index "0" angesprochen. Die erste Datenzeile beginnt mit dem Index 1. Für Tabellen mit mehrzeiligen Kopfzeilen kann im Objekt selbst der Offset zur ersten Datenzeile festgelegt werden. Der Spaltenindex beginnt mit der Nummer 1.
    _Beispiel 1: Auswahl der Zelle in Spalte 2 und Zeile 5:_
    \verbatim Wähle aus Tabellenzelle: "MeineTabelle", "#2", "#5" \endverbatim _Beispiel 2: Auswahl der Zelle in erster Spalte mit Text "Toni" und Zeile mit dem Namen "Tester":_
    \verbatim Wähle aus Tabellenzelle: "MeineTabelle", "Toni", "Tester" \endverbatim _Beispiel 3: Auswahl der Zelle in erster Spalte mit Text "Toni" und Zeile 3:_
    \verbatim Wähle aus Tabellenzelle: "MeineTabelle", "Toni", "#3" \endverbatim _Beispiel 4: Auswahl der Zelle in Spalte 1 und erster Zeile mit Text "42":_
    \verbatim Wähle aus Tabellenzelle: "MeineTabelle", "#1", "42" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    fpsCol - Spaltennummer der zu wählenden Zelle, beginnend mit 1.
    fpsRow - Zeilennummer der zu wählenden Zelle, beginnend mit 1. \~english \brief Selects the given table cell. The column and row positions are always entered as strings. If such a parameter is starting with a hash (#) the String is interpreted as an index number, e.g. "#1"). If a hash sign should be interpreted as text it must signed with a backslash, e.g. "\#1 text with leading number"). The header row is addressed with the index "0". The first data row starts with the index 1. For tables with multiline headers the offset to the first data row can be set The column index starts with the number 1.
    _Example #1: Select cell at first column with text "Toni" and row with number 3:_
    \verbatim Select Tablecell: "MyTable", "Toni", "#3" \endverbatim _Example #2: Select cell at column with number 1 and row with name "Address":_
    \verbatim Select Tablecell: "MyTable", "#1", "Address" \endverbatim _Example #3: Select cell at column number 1 and row 1:_
    \verbatim Select Tablecell: "MyTable", "#1", "#1" \endverbatim _Example #4: Select cell at col number 1 and first row with text "42":_
    \verbatim Select Tablecell: "MyTable", "#1", "42" \endverbatim
    FN - Functional name of the object
    fpsCol - Column number of cell to be selected, starting with 1.
    fpsRow - Row number of cell to be selected, starting with 1. \~
    
    Throws:
    
    Exception
  - SelectWindow
```
void SelectWindow(String FN)
                  throws Exception
```
    \~german \brief Setzt den Kontext auf das gegebene Fenster. Das Fenster wird aktiviert und in den Vordergrund geholt. Alle nachfolgen GUI-Schlüssleworte (z.B. Gib ein) beziehen sich auf das gegeben Fenster. Der Kontext wechselt erst mit dem nächsten _Wähle aus Fenster_ auf ein anderes Fenster. \todo zh: jnic die englische Beschreibung für Selectwindow anpassen. _Beispiel: Auswahl des Fensters mit dem Namen "MeinFenster":_
    \verbatim Wähle aus Fenster: "MeinFenster" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief Setting the context for the given window and ensuring that the window is active and in the foreground. _Example: Select window with name "MyWindow":_
    \verbatim Select Window: "MyWindow" \endverbatim
    FN - Functionalname of the object \~
    
    Throws:
    
    Exception
  - Sequence
```
void Sequence(String FN,
            String fpsSequenceName,
            String SEQ_ID)
              throws Exception
```
    \~german \brief Ruft die Sequenz eines Fensters auf. Sequenzen sind je Fenster definiert und haben innerhalb des Fenster einen eindeutigen Sequenznamen. Einzugebende Datensätze werden mit der Sequenz-ID referenziert. _Beispiel: Aufrufen der Sequenz _Anmelden_ des Fensters _Login_ mit dem Datensatz _Administrator_:_
    \verbatim Sequenz: "Login", "Anmelden" = "Administrator" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Fensterobjekts, in der die Sequenz definiert ist.
    fpsSequenceName - Name der Sequenz, die aufgerufen werden soll.
    SEQ_ID - Sequenz ID des Datensatzes, die als Eingabe verwendet werden soll. \~english \brief Calls the sequence of the window. Sequences are defined per window and have a unique sequence name within the window. Entered records are referenced with the sequence ID. _Example: Calling the sequence _Login_ of the window _Login_ with the record _Administrator_:_
    \verbatim Sequence: "Login", "Login" = "Administrator" \endverbatim
    FN - Functional name of the object
    fpsSequenceName - No explanation available
    SEQ_ID - No explanation available \~
    
    Throws:
    
    Exception
  - SetFocus
```
void SetFocus(String FN)
              throws Exception
```
    \~german \brief Setzt den Fokus auf das gegebene Fensterobjekt.
    
    Parameters:
    FN - Funktionaler Name des Objekts \~english \brief Setting the focus to the given window object.
    FN - Functional name of the object \~
    
    Throws:
    
    Exception
  - SetLanguage
```
void SetLanguage(String Language)
```
    \~german \brief Interne Methode zum setzen der Sprache für die sprachabhängigen Ausgaben der Dokumentation (Log). Die auswählbaren Sprachen sind in OKWLanguage::cvLsLanguagesImplemented definiert und werden mit dieser Liste abgeprüft.
    
    Parameters:
    Language - Sprache die ausgewählt werden soll, z.B. mit "de" \~english \brief Internal method to set the language of the language depending outputs of the log documentation. The choosable languages are defined in OKWLanguage::cvLsLanguagesImplemented and are prooved with this list.
    Language - Select "en" \~
  - SetValue
```
void SetValue(String FN,
            String Val)
              throws Exception
```
    \~german \brief Setzt den Wert des gegebenen Fensterobjekts auf den gegebenen Wert. Der Wert wird nicht durch die Simulation einzelner Tastatureingaben eingegeben, sondern direkt ins Objekte geschrieben:
    Sollte z.B. in einem TextFeld bereits ein Wert vorhanden sein, dann wird dieser mit _fpsValue_ überschrieben. __Beispiel:__ Setze den Wert des Objekts "MeinObjekt" auf "Hallo":
    \verbatim Setze Wert: "Name", "Zoltan" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    Val - Sich ergebender Wert \~english \brief Setting the value of the given window object to the given value. The input is not working with the simulation of single keyboard inputs, but with High-Level Setter-Methods of the objects:
    Inputs of the object are written over with "Val". _Example: Set the value of the objekt "MyWindow" to "Hello":_
    \verbatim Set Value: "Name", "Zoltan" \endverbatim
    FN - Functional name of the object
    Val - Resulting value \~
    
    Throws:
    
    Exception
  - StartApp
```
void StartApp(String fpsApplicationName)
              throws Exception
```
    \~german \brief Startet die gegebene Anwendung. _Beispiel: Befehl zum Starten der Anwendung "InternetExplorer":_
    \verbatim Starte Anwendung: "InternetExplorer"\endverbatim \remark Die Methode "StartApp()" muss in der Klasse "fpsApplikatioName" implementiert werden. Der fachliche Bezeichner muss nicht zwangsläufing mit dem Namen der Exe-Datei übereinstimmen: Hier findet ein Mapping/Zuordnung zwischen fachlichen Bezeichner und der aufzurufenden "*.exe" statt.
    Ein Beispiel, wie eine Ausimplementierung aussehen kann, ist in SeInternetExplorerApp.StartApp zu finden.
    
    Parameters:
    fpsApplicationName - Der fachliche Name der Anwendung. \~english \brief Starts the given application. _Example: Order to start the application "InternetExplorer":_
    \verbatim Start Application: "InternetExplorer"\endverbatim \remark Te method "StartApp()" must be implemented in the class "fpsApplikatioName". The technical identifier must not inevitably be identical to the name of the exe file: here we hav e a mapping between the technical identifier and the invoked "*.exe"
    An example how a full Implementation can look at, is to be find in SeInternetExplorerApp.StartApp
    fpsApplicationName - No explanation available \~
    
    Throws:
    
    Exception
  - StopApp
```
void StopApp(String fpsApplicationName)
             throws Exception
```
    \~german \brief Beendet eine gegebene Anwendung. _Beispiel: Befehl zum Starten der Anwendung "InternetExplorer":_
    \verbatim Beende Anwendung: "InternetExplorer"\endverbatim \remark Die Methode "StopApp()" muss in der Klasse "fpsApplikatioName" implementiert werden. Das Framework kann nicht wissen, wie eine spezielle Anwendung beendet werden muss. Das muss projektspezifisch ausimplementiert werden.
    Ein Beispiel, wie eine Ausimplementierung aussehen kann, ist in SeInternetExplorerApp.StopApp zu finden.
    
    Parameters:
    fpsApplicationName - Derf achliche Name der Anwendung \~english \brief Ends a given application. _Example: Order to start the application "InternetExplorer":_
    \verbatim End Application: "InternetExplorer"\endverbatim \remark The method "StopApp()" must be implemented in the class "fpsApplikatioName" The framework is not able to know, how a specific application is to be closed. The must be fully implemented specific to the project.
    An example, how the full implementation can look at is to be find at SeInternetExplorerApp.StopApp.
    fpsApplicationName - The technical name of the application \~
    
    Throws:
    
    Exception
  - TypeKey
```
void TypeKey(String FN,
           String Val)
             throws Exception
```
    \~german \brief Tastatureingaben von Daten in das aktive Fensterobjekt. Die Daten werden als Tastureingaben an das Kindobjekt des aktiven Fenters gesendet. Dies ermöglicht die Verwendung von Hotkeys und Funktionstasten als Eingabedaten. Wenn mit Hilfe des Wertseparators {SEP} mehrere Werte im Parameter übergeben werden, dann werden alle Werte als Tastatureingabe an das Fensterobjekt gesendet, getrennt durch einen Zeilenumbruch. __Beispiel "Einfache Eingabe":__
    \verbatim Gib ein: "MeinFensterObjekt", "EingabeWert" \endverbatim __Beispiel "Eingabe einer Konstanten":__
    \verbatim Gib ein: "MeinFensterObjekt", "{F2}" \endverbatim __Beispiel "Eingabe mehrerer Werte":__
    \verbatim Gib ein: "MeinFensterObjekt", "Eingabewert1{SEP}Eingabewert2" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    Val - Sich ergebender Wert \~english \brief Keyboard inputs of data in the active windows object. The data are sent as keyboard inputs to the child object of the active window. This enables the use of hot keys and function keys as input data. If with help of the valueseparator (SEP) multiple values are passed in the parameter, then all values are sent as keyboard input to the window object, separated by a line break. __Example: "Simple Input":__
    \verbatim Type Key: "MyWindowObjekt", "InputValue" \endverbatim __Example: "Input of constant value":__
    \verbatim Type Key: "MainWindow", "{F2}" \endverbatim __Example: "Input of more than one value":__
    \verbatim Type Key: "MyWindowObjekt", "InputValue1{SEP}InputValue2" \endverbatim
    FN - Functional name of the object
    Val - Resulting value \~
    
    Throws:
    
    Exception
  - TypeKeyTablecell
```
void TypeKeyTablecell(String FN,
                    String fpsCol,
                    String fpsRow,
                    String Val)
                      throws Exception
```
    \~german \brief Eingabe von Daten in eine gegebene Tabellenzelle über die Tastatur. Die Daten werden als Tastureingaben an die gegebene Zelle einer Tabelle gesendet. Dies ermöglicht die Verwendung von Hotkeys (Schnellzugang)und Funktionstasten als Eingabedaten. Die Parameter für die Spalten- und Zeilenpositionen werden immer als Strings eingegeben. Wenn ein Positionsparameter mit einem Hash (#) beginnt, dann wird er als Zahl interpretiert, z.B. "#1". Wenn das Hashzeichen als Text interpretiert werden soll, dann muss dies über einen vorangestellten Backslash gekennzeichnet werden, z.B. "#1 Text mit vorangestellter Nummer". Die Kopfzeile der Tabelle wird über den Index "0" angesprochen. Die erste Datenzeile beginnt mit dem Index 1. Für Tabellen mit mehrzeiligen Kopfzeilen kann im Objekt selbst der Offset zur ersten Datenzeile festgelegt werden. Der Spaltenindex beginnt mit der Nummer 1.
    _Beispiel 1: Einfache Eingabe in Zelle an Spalte 2 und Zeile 5:_
    \verbatim Gib ein Tabellenzelle: "MeineTabelle", 2, 5, "Eingabewert" \endverbatim _Beispiel 2: Einfache Eingabe in Zelle an erster Spalte mit Text "Toni" und Zeile mit dem Namen "Tester":_
    \verbatim Gib ein Tabellenzelle: "MeineTabelle", "Toni", "Tester", "Eingabewert" \endverbatim _Beispiel 3: Einfache Eingabe in Zelle an erster Spalte mit Text "Toni" und Zeile 3:_
    \verbatim Gib ein Tabellenzelle: "MeineTabelle": "MeineTabelle", "Toni", 3, "Eingabewert" \endverbatim _Beispiel 4: Einfache Eingabe in Zelle an Spalte 1 und Zeile mit Namen "Adresse":_
    \verbatim Gib ein Tabellenzelle: "MeineTabelle", 1, "Adresse", "Eingabewert" \endverbatim _Beispiel 5: Eingabe der Konstanten "F2" in Zelle an Spalte 1 und Zeile 1:_
    \verbatim Gib ein Tabellenzelle: "MeineTabelle", 1, 1, "{F2}" \endverbatim _Beispiel 6: Eingabe mehrerer Werte in Zelle an erster Spalte mit Test "Ernie" und Zeile 3:_
    \verbatim Gib ein Tabellenzelle: "MeineTabelle", "Ernie", 3, "Wer1{SEP}Wert2" \endverbatim _Beispiel 7: Eingabe des Wertes "HiHo" in Zelle an Spalte 1 und erster Zeile mit Text "42":_
    \verbatim Gib ein Tabellenzelle: "MeineTabelle", "#1", "42", "HiHo" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    Val - Sich ergebender Wert
    fpsRow - Zeilennummer der zu wählenden Zelle, beginnend mit 1.
    fpsCol - Spaltennummer der zu wählenden Zelle, beginnend mit 1. \~english \brief Input of date to a given tablecell by the keyboard. The data are sent as keyboard inputs to the given tablecell. This ensures the use of hotkeys and functional tabs as input data. The parameters of the row and column positions are always set as strings. If such a parameter is starting with a hash (#) the String is interpreted as an index number, e.g. "#1"). If a hash sign should be interpreted as text it must signed with a backslash, e.g. "\#1 text with leading number"). The header row is adressed with the index "0". The first data row starts with the index 1. For tables with multiline headers the offset to the first data row can be set The column index starts with the number 1.
    _Example #1: Simple Input in cell at column 2 and row 5:_
    \verbatim Type Key Tablecell: "MyTable", 2, 5, "InputValue" \endverbatim _Example #2: Simple Input in cell at first column with text "Toni" and row with name "Tester":_
    \verbatim Type Key Tablecell: "MyTable", "Toni", "Tester", "InputValue" \endverbatim _Example #3: Simple Input in cell at first column with text "Toni" and row with number 3:_
    \verbatim Type Key Tablecell: "MyTable", "Toni", 3, "InputValue" \endverbatim _Example #4: Simple Input in cell at column with number 1 and row with name "Address":_
    \verbatim Type Key Tablecell: "MyTable", 1, "Address", "InputValue" \endverbatim _Example #5: Input of constant value named "F2" in cell at column number 1 and row 1:_
    \verbatim Type Key Tablecell: "MyTable", 1, 1, "{F2}" \endverbatim _Example #6: Input of more than one value in cell at first column with text "Ernie" and third row:_
    \verbatim Type Key Tablecell: "MyTable", "Ernie", 3, "InputValue1{SEP}InputValue2" \endverbatim _Example #7: Input of value "Hiho" into cell at column number 1 and first row with text "42":_
    \verbatim Type Key Tablecell: "MyTable", "#1", "42", "HiHo" \endverbatim
    FN - Functional name of the object
    Val - Resulting value
    fpsRow - Row number of cell to be selected, starting with 1.
    fpsCol - Column number of cell to be selected, starting with 1. \~
    
    Throws:
    
    Exception
  - TypeKeyWindow
```
void TypeKeyWindow(String FN,
                 String Val)
                   throws Exception
```
    \~german \brief Tastatureingabe in ein bestimmtes Fensterobjekt. Die Daten werden als Tastureingaben an das Fensterobjekt gesendet. Dies ermöglicht die Verwendung von Hotkeys (Schnellzugang) und Funktionstasten als Eingabedaten. Mehrere Werte können mit Hilfe der Konstanten {SEP} eingegeben werden (siehe Beispiele). Die Werte werden dann bei der Eingabe durch Zeilenumbrüche getrennt.
    _Beispiel 1: Einfache Eingabe:_
    \verbatim Gib ein Fenster: "MeinFensterObjekt", "EingabeWert" \endverbatim _Beispiel 2: Eingabe einer Konstanten:_
    \verbatim Gib ein Fenster: "MeinFensterObjekt", "{F2}" \endverbatim _Beispiel 3: Eingabe mehrerer Werte:_Beispiel \verbatim Gib ein Fenster: "MeinFensterObjekt", "Eingabewert1{SEP}Eingabewert2" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    Val - Sich ergebender Wert \~english \brief Keyboard input to a particular window object. The data will be sent as keyboard inputs to the window object. This ensures the use of hotkeys an functional keys as input data. Multiple values can be given as input by help of the constant {SEP} (see examples). The values are divided with tabstops with the input.
    _Example #1: Simple Input:_
    \verbatim Type Key Window: "MyWindowObjekt", "InputValue" \endverbatim _Example #2: Input of constant value:_
    \verbatim Type Key Window: "MainWindow", "{F2}" \endverbatim _Example #3: Input of more than one value:_
    \verbatim Type Key Window: "MyWindowObjekt", "InputValue1{SEP}InputValue2" \endverbatim
    FN - Functional name of the object
    Val - Resulting value \~
    
    Throws:
    
    Exception
  - VerifyCaption
```
void VerifyCaption(String FN,
                 String ExpVal)
                   throws Exception
```
    \~german \brief Überprüft die Überschrift des Objektes.
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert \~english \brief No description for "VerifyCaption" available
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - VerifyCaptionWCM
```
void VerifyCaptionWCM(String FN,
                    String ExpVal)
                      throws Exception
```
    \~german \brief Überprüft die Überschrift des Objektes. Der Sollwert wird als Wildcard-Match angegeben. Folgende Platzhalter sind möglich: * "?" - genau ein beliebiges Zeichen wird Maskiert * "*" - (0-n) beliebiges Zeichen wird Maskiert * "#" - genau eine Ziffer [0..9] kann maskiert werden _Beispiel: Prüfe, ob der Wert (Text) des Objekts "MeinObjekt" dem erwarteten Wert "\\.jango" entspricht:_
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert \~english \brief No description for "VerifyCaption" available
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - VerifyCaptionREGX
```
void VerifyCaptionREGX(String FN,
                     String ExpVal)
                       throws Exception
```
    \~german \brief Überprüft die Überschrift des Objektes. Reguläre aus drücke als sollwert sind erlaubt. _Beispiel: Prüfe, ob der Wert (Text) des Objekts "MeinObjekt" dem erwarteten Wert "\\.jango" entspricht:_
    \verbatim PrüfeWertREGX: "MeinObjekt", "$Django" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert \~english \brief No description for "VerifyCaption" available
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - VerifyExists
```
void VerifyExists(String FN,
                String ExpVal)
                  throws Exception
```
    \~german \brief Prüft, ob das gegebene Objekt existiert.
    _Beispiel 1: Prüfe, ob das Objekt "MeinObjekt" existiert:_
    \verbatim Prüfe Existiert: "MeinObjekt", "JA" \endverbatim _Beispiel 2: Prüfe, ob das Objekt "MeinObjekt" nicht existiert:
    \verbatim Prüfe Existiert: "MeinObjekt", "NEIN" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert \~english \brief Checks the existence of the given object.
    _Example #1: Check if the object MyObject exists:_
    \verbatim Verify Exists: "MyObject", "YES" \endverbatim _Example #2: Check if the object MyObject does not exist:_
    \verbatim Verify Exists: "MyObject", "NO" \endverbatim
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - VerifyHasFocus
```
void VerifyHasFocus(String FN,
                  String ExpVal)
                    throws Exception
```
    \~german \brief Vergleicht den Fokus-Zustand des gegebenen Objekts mit dem erwarteten Wert. _Beispiel 1: Prüfe, ob das Objekt "MeinObjekt" den Fokus besitzt:_
    \verbatim Prüfe Hat Fokus: "MeinObjekt", "JA" \endverbatim _Beispiel 2: Prüfe, ob das Objekt "MeinObjekt" den Fokus NICHT besitzt:_
    \verbatim Prüfe Hat Fokus: "MeinObjekt", "NEIN" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert. Erlaubte Werte sind: "JA", "NEIN" und "IGNORIEREN". \~english \brief Compares the focus status of the given object with the expected value. _Example #1: Verify if the object MyObject has the focus:_
    \verbatim Verify Has Focus: "MyObject", "YES" \endverbatim _Example #2: Verify if the object MyObject has NOT the focus:_
    \verbatim Verify Has Focus: "MyObject", "NO" \endverbatim
    FN - Functional name of the object
    ExpVal - Expected Value. Following values are Allowed here: "YES, "NO", and "IGNORE". \~
    
    Throws:
    
    Exception
  - VerifyIsActive
```
void VerifyIsActive(String FN,
                  String ExpVal)
                    throws Exception
```
    \~german \brief Vergleicht den Fokus-Status des gegebenen Objekts mit dem erwarteten Wert. _Beispiel: Prüfe, ob das Objekt "MeinObjekt" sich im Status "aktiv" befindet:_
    \verbatim Prüfe Ist Aktiv: "MeinObjekt", "JA" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert. Erlaubte Werte sind: "JA", "NEIN" und "IGNORIEREN". \~english \brief Compares the focus status of the given object with the expected value. _Example: Verify if the object MyObject is in the state "active":_
    \verbatim Verify Is Active: "MyObject", "YES" \endverbatim
    FN - Functional name of the object
    ExpVal - Expected Value. Following values are Allowed here: "YES, "NO", and "IGNORE". \~
    
    Throws:
    
    Exception
  - VerifyLabel
```
void VerifyLabel(String FN,
               String ExpVal)
                 throws Exception
```
    \~german \brief Überprüft die Beschreibung des Objektes.
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert \~english \brief Verifies the Label of a GUI-object.
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - VerifyLabelWCM
```
void VerifyLabelWCM(String FN,
                  String ExpVal)
                    throws Exception
```
    \~german \brief Überprüft die Beschreibung des Objektes. Der Sollwert wird als Wildcard-Match angegeben. Folgende Platzhalter sind möglich: * "?" - genau ein beliebiges Zeichen wird Maskiert * "*" - (0-n) beliebiges Zeichen wird Maskiert * "#" - genau eine Ziffer [0..9] kann maskiert werden _Beispiel: Prüfe, ob der Wert (Text) des Objekts "MeinObjekt" dem erwarteten Wert "\\.jango" entspricht:_
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert \~english \brief Verifies the Label of a GUI-object.
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - VerifyLabelREGX
```
void VerifyLabelREGX(String FN,
                   String ExpVal)
                     throws Exception
```
    \~german \brief Überprüft die Überschrift des Objektes. Reguläre aus drücke als sollwert sind erlaubt. _Beispiel: Prüfe, ob der Wert (Text) des Objekts "MeinObjekt" dem erwarteten Wert "\\.jango" entspricht:_
    \verbatim PrüfeWertREGX: "MeinObjekt", "$Django" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert \~english \brief Verifies the Label of a GUI-object.
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - VerifySelectedValue
```
void VerifySelectedValue(String FN,
                       String ExpVal)
                         throws Exception
```
    \~german \brief Vergleicht den ausgewählten Wert des gegebenen Listenobjekts mit dem erwarteten Wert. Eine Liste ist eine einfache Liste, eine Tabelle oder eine Baumansicht. Bei erwarteten Werten in Baumansichten (Treeview) wird immer die gesamte Hierarchie angegeben (siehe Beispiel). Dabei werden die Hierarchie-Elemente über den Separator {SEP} getrennt.
    _Beispiel 1: Prüfe, ob das Element "Henry" in der Liste "MeineListe" ausgewählt ist:_
    \verbatim Prüfe Ausgewählter Wert: "MeineListe", "Henry" \endverbatim _Beispiel 2: Prüfe, ob das Element "Namen{SEP}Henry" in der Baumansicht "MeinTreeview" ausgewählt ist:_
    \verbatim Prüfe Ausgewählter Wert: "MeinTreeview", "Namen{SEP}Henry" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert \~english \brief Compares the selected value of the given listobject with the expected value. A list can be a simple list, a table or a tree-view. Expected Values in tree-views are indicated with the whole hierarchy (see example). With this the hierarchical elements are divided with the separator {SEP}.
    _Example #1: Check if the list entry "Henry" is selected in the list "MyList":_
    \verbatim Verify Selected Value: "MyList", "Henry" \endverbatim _Example #2: Check if the entry "Names{SEP}Henry" is selected in the treeview "MyTreeview":_
    \verbatim Verify Selected Value: "MyTreeview", "Names{SEP}Henry" \endverbatim
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - VerifyTablecellValue
```
void VerifyTablecellValue(String FN,
                        String fpsCol,
                        String fpsRow,
                        String ExpVal)
                          throws Exception
```
    \~german \brief Vergleicht den Inhalt der gegebenen Tabellenzeile mit dem erwarteten Wert.
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert
    fpsRow - Zeilennummer der zu wählenden Zelle, beginnend mit 1.
    fpsCol - Spaltennummer der zu wählenden Zelle, beginnend mit 1. \~english \brief Compares the content of the given table cell with the expected value.
    FN - Functional name of the object
    ExpVal - Expected Value
    fpsRow - Row number of cell to be selected, starting with 1.
    fpsCol - Column number of cell to be selected, starting with 1. \~
    
    Throws:
    
    Exception
  - VerifyTooltip
```
void VerifyTooltip(String FN,
                 String ExpVal)
                   throws Exception
```
    \~german \brief Prüft den Tooltip-Text eines Objektes. Der Sollwert wird exakt, d.h ohne Platzhalter, angegeben.
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert \~english \brief Checks the tooltip-text of an object. The expected value is exactly, i.e. without wildcards, specified.
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - VerifyTooltipREGX
```
void VerifyTooltipREGX(String FN,
                     String ExpVal)
                       throws Exception
```
    \~german \brief Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text). Der Sollwert wird als RegulererAusdruck angegeben. _Beispiel: Prüfe, ob der Tooltip-Text des Objekts "MeinObjekt" dem erwarteten Wert "\\.jango" entspricht:_
    \verbatim PrüfeTooltipREGX: "MeinObjekt", "\\.jango" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert, gegegebn als Regulärerausdruck. \~english \brief Checks the tooltip-text of an object. The expected tooltip text is givan as Regularexpression. _Example: Check if the tooltip text of object "MyObject" equals the expected tooltip text "\\.jango":_
    \verbatim VerifyTooltipREGX( "MyObject", "\\.jango" ) \endverbatim
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - VerifyTooltipWCM
```
void VerifyTooltipWCM(String FN,
                    String ExpVal)
                      throws Exception
```
    \~german \brief Prüft den Tooltip-Text eines Objektes (in den meisten Fällen ist dies der angezeigte Text). Der Sollwert wird als Wildcard-Match angegeben. Folgende Platzhalter sind möglich: * "?" - genau ein beliebiges Zeichen wird Maskiert * "*" - (0-n) beliebig viele Zeichen werden Maskiert * "#" - genau eine Ziffer [0..9] wird maskiert _Beispiel: Prüfe, ob der Tooltip Text des Objekts "MeinObjekt" dem erwarteten Wert "?jango" entspricht:_
    \verbatim PrüfeTooltipWCM: "MeinObjekt", "?jango" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert als Wildcardmatch. \~english \brief Checks the tooltip text of an object. The expected Value is givan as WildCardMatch The following wildcards can be used: * "?" - exactly one character is masked * "*" - (0-n) any number of characters to be masked * "#" - exactly one number [0..9] is masked _Example: Check if the tooltip text of object "MyObject" equals the expected value "?jango":_
    \verbatim VerifyTooltipWCM( "MyObject", "?jango" ) \endverbatim
    FN - Functional name of the object
    ExpVal - Expected Value as WildCardMatch \~
    
    Throws:
    
    Exception
  - VerifyValue
```
void VerifyValue(String FN,
               String ExpVal)
                 throws Exception
```
    \~german \brief Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text). _Beispiel: Prüfe, ob der Wert (Text) des Objekts "MeinObjekt" dem erwarteten Wert "Django" entspricht:_
    \verbatim Prüfe Wert: "MeinObjekt", "Django" \endverbatim Dieses Schlüsselwort prüft die exakte Übereinstimmung. Wildkards sind nicht möglich.
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert \~english \brief Checks the standard value of an object (in most cases this is the displayed text). The expected value is exactly, i.e. without wildcards, specified. _Example: Check if the value (text) of object "MyObject" equals the expected value "Django":_
    \verbatim VerifyValue( "MyObject", "Django" ) \endverbatim
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - VerifyValueREGX
```
void VerifyValueREGX(String FN,
                   String ExpVal)
                     throws Exception
```
    \~german \brief Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text). Der Sollwert wird als RegulererAusdruck angegeben. _Beispiel: Prüfe, ob der Wert (Text) des Objekts "MeinObjekt" dem erwarteten Wert "\\.jango" entspricht:_
    \verbatim PrüfeWertREGX: "MeinObjekt", "$Django" \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert \~english \brief Checks the standard value of an object (in most cases this is the displayed text). The expected Value is givan as Regularexpression _Example: Check if the value (text) of object "MyObject" equals the expected value "Django":_
    \verbatim VerifyValueREGX( "MyObject", "$Django" ) \endverbatim
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - VerifyValueWCM
```
void VerifyValueWCM(String FN,
                  String ExpVal)
                    throws Exception
```
    \~german \brief Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text). Der Sollwert wird als Wildcard-Match angegeben. Folgende Platzhalter sind möglich: * "?" - genau ein beliebiges Zeichen wird Maskiert * "*" - (0-n) beliebiges Zeichen wird Maskiert * "#" - genau eine Ziffer [0..9] kann maskiert werden _Beispiel: Prüfe, ob der Wert (Text) des Objekts "MeinObjekt" dem erwarteten Wert "\\.jango" entspricht:_
    \verbatim PrüfeWertWCM( "MeinObjekt", "$Django" ) \endverbatim
    
    Parameters:
    FN - Funktionaler Name des Objekts
    ExpVal - Erwarteter Wert / Sollwert. \~english \brief Checks the standard value of an object (in most cases this is the displayed text). The expected Value is givan as Regularexpression The following wildcards can be used: * "?" - exactly one character is masked * "*" - (0-n) any number of characters to be masked * "#" - exactly one number [0..9] is masked _Example: Check if the value (text) of object "MyObject" equals the expected value "Django":_
    \verbatim VerifyValueWCM( "MyObject", "Django" ) \endverbatim
    FN - Functional name of the object
    ExpVal - Expected Value \~
    
    Throws:
    
    Exception
  - CopyFile
```
void CopyFile(String fpsSourcePathAndFileName,
            String fpsDestinationPathAndFileName)
              throws Exception
```
    Throws:
    
    Exception
  - FileDelete
```
void FileDelete(String fpsPathAndFileName)
                throws Exception
```
    \~german \brief Löscht die gegebene Datei. In der Pfadangabe sind - OKW-Parser angaben sind erlaubt ${umgebungsvariable}, ${merkewertschlüssel}. - im Dateinamen sind Wildcards * + ? erlaubt. \note Dieses Schlüsselwort stellt sicher, dass _nach_ der Ausführung die angegebene Datei oder Dateien nicht (mehr) existiert/existieren. Falls die gegebene Datei _nicht_ existiert, dann wird _ohne Fehlermeldung_ und auslösen einer Ausnahme das Schlüsselwort beendet. \par Beispiel DE.LöscheDatei( "C:\temp\meineDatei.txt" ) - Löscht die Datei meineDatei.txt im Verzeichniss C:\temp DE.LöscheDatei( "C:\temp\*.*" ) - Löscht alle Dateien im Verzeichniss C:\temp \par Siehe auch - DE::LöscheDatei(string) - EN::FileDelete(string) - Core::FileDelete(string) - OK::FileDelete(string) - NOK::FileDelete(string) - OK_TRY::FileDelete(string) - NOK_TRY::FileDelete(string) - IOKW_State::FileDelete(string)
    
    Parameters:
    fpsPathAndFileName - Vollständiger Pfad und Dateiname. \~english \brief Deletes the given file. If the file does not exist, then this keyword ends without error message and an exception will not rais. - OKW-Parser is included. - widcards are in the filename allowed.
    fpsPathAndFileName - Full path of teh File \~
    
    Throws:
    
    Exception
  - VerifyFileExists
```
void VerifyFileExists(String fpsPathAndFileName,
                    String ExpVal)
                      throws Exception
```
    \~german \brief Prüft, ob die gegebene Datei existiert.
    
    Parameters:
    fpsPathAndFileName - Pfad und Name der Datei, die Geprüft werden soll
    ExpVal - Erwarteter Wert. Möglich Werte sind: "JA"/"NEIN"/"${IGNORIERE}" /exception OKWFileDoesNotExistsException Wenn die gegeben Datei ein Verzeichniss ist, also eben keine Datei, dann wird ein OKWFileDoesNotExistsException ausgelöst. \~english \brief
    fpsPath - Path and name of the file.
    ExpVal - Expected Value. ExpVal: "YES"/"NO"/"${IGNORE}" \~
    
    Throws:
    
    Exception
  - VerifyDirectoryExists
```
void VerifyDirectoryExists(String fpsPath,
                         String ExpVal)
                           throws Exception
```
    \~german \brief Prüft, ob das gegebene Verzeichnis existiert.
    
    Parameters:
    fpsPathA - Pfad des Verzeichnisses, die Geprüft werden soll
    ExpVal - Erwarteter Wert. Möglich Werte sind: "JA"/"NEIN"/"${IGNORIERE}" \~english \brief
    fpsPathAndFileName - Functional name of the object
    ExpVal - Expected Value. ExpVal: "YES"/"NO"/"${IGNORE}" \~
    
    Throws:
    
    Exception

Interface IOKW_State

Method Summary

Method Detail

BeginTest

ClickOn

DoubleClickOn

EndTest

LogCaption

LogExists

LogHasFocus

LogIsActive

LogLabel

LogSelected

LogTablecellValue

LogTooltip

LogValue

MemorizeCaption

MemorizeExists

MemorizeHasFocus

MemorizeIsActive

MemorizeLabel

MemorizeSelectedValue

MemorizeTablecellValue

MemorizeTooltip

MemorizeValue

Select

SelectMenu

SelectMenu

SelectTablecell

SelectWindow

Sequence

SetFocus

SetLanguage

SetValue

StartApp

StopApp

TypeKey

TypeKeyTablecell

TypeKeyWindow

VerifyCaption

VerifyCaptionWCM

VerifyCaptionREGX

VerifyExists

VerifyHasFocus

VerifyIsActive

VerifyLabel

VerifyLabelWCM

VerifyLabelREGX

VerifySelectedValue

VerifyTablecellValue

VerifyTooltip

VerifyTooltipREGX

VerifyTooltipWCM

VerifyValue

VerifyValueREGX

VerifyValueWCM

CopyFile

FileDelete

VerifyFileExists

VerifyDirectoryExists