OpenKeyWord  Build_ID: 457, Datum: 01.02.2020 07:45:48
Dont repeat yourself. - Do it once and only once!
Öffentliche Methoden | Geschützte Methoden | Geschützte Attribute | Private Methoden | Private Attribute | Statische, private Attribute | Aufstellung aller Elemente
okw.core.OK Klassenreferenz

Klasse OK representiert den Core Zustand "OK". Mehr ...

+ Klassendiagramm für okw.core.OK:
+ Zusammengehörigkeiten von okw.core.OK:

Öffentliche Methoden

 OK (Core fp_OKW)
 Klasse representiert den Zustand "OK" des OKW-Kerns im Ausführungsmodus. Mehr ...
 
void BeginTest (String fpsTestname) throws Exception
 Kennzeichnet den Anfang eines Testfalls. Mehr ...
 
void EndTest () throws Exception
 Signalisiert das Ende eines Testfalls. Mehr ...
 
void ClickOn (String FN) throws Exception
 Klickt auf das gegebene Objekt. Mehr ...
 
void DoubleClickOn (String FN) throws Exception
 Führt ein Doppelklick auf das gegebene GUI-Objekt aus. Mehr ...
 
void LogCaption (String FN) throws Exception
 Gibt die Caption eines GUI-Objektes in den Testergebnissen aus. Mehr ...
 
void LogExists (String FN) throws Exception
 Gibt die Existenz eines GUI-Objektes mit YES/NO in den Testergebnissen aus. Mehr ...
 
void LogHasFocus (String FN) throws Exception
 Dokumentiert den Fokus-Status des gegebenen Objekts. Mehr ...
 
void LogIsActive (String FN) throws Exception
 Dokumentiert den Status des gegebenen Objekts. Mehr ...
 
void LogLabel (String FN) throws Exception
 Gibt den Wert des Etikette/Label in der Logdatei aus. Mehr ...
 
void LogPlaceholder (String FN) throws Exception
 Gibt den Wert des Platzhalters in der Logdatei aus. Mehr ...
 
void LogSelected (String FN) throws Exception
 Dokumentiert den markierten Text des gegebenen Objekts. Mehr ...
 
void LogTablecellValue (String FN, String COL, String ROW) throws Exception
 Dokumentiert den Wert der ausgewählten Zelle. Mehr ...
 
void LogTooltip (String FN) throws Exception
 Dokumentiert die Kurzinfo zu einem Werkzeug des gegebenen Objekts. Mehr ...
 
void LogValue (String FN) throws Exception
 Dokumentiert den Standartwert eines Objekts. Mehr ...
 
void MemorizeCaption (String FN, String MemKey) throws Exception
 Keine Beschreibung zu "MemorizeCaption" verfügbar. Mehr ...
 
void MemorizeExists (String FN, String MemKey) throws Exception
 Merkt sich den aktuell existierenden Zustand des Objekts. Mehr ...
 
void MemorizeHasFocus (String FN, String MemKey) throws Exception
 Keine Beschreibung zu "MemorizeHasFocus" verfügbar. Mehr ...
 
void MemorizeIsActive (String FN, String MemKey) throws Exception
 Merkt sich den Zustand des gegebenen Objekts. Mehr ...
 
void MemorizeLabel (String FN, String MemKey) throws Exception
 Speirchert den aktuellen Wert der Etikette, und legt diesen unter fpsMemKeyName ab. Mehr ...
 
void MemorizePlaceholder (String FN, String MemKey) throws Exception
 Speirchert den aktuellen Wert der Platzhalters, und legt diesen unter fpsMemKeyName ab. Mehr ...
 
void MemorizeSelectedValue (String FN, String MemKey) throws Exception
 Keine Beschreibung zu "MemorizeSelectedValue" verfügbar. Mehr ...
 
void MemorizeTablecellValue (String FN, String COL, String ROW, String MemKey) throws Exception
 Merkt sich den Wert der gegebenen Zelle in der Tabelle. throws Exception Mehr ...
 
void MemorizeTooltip (String FN, String MemKey) throws Exception
 Dokumentiert den Tooltip-Text (Kurzinformation) des gegebenen Objekts. Mehr ...
 
void MemorizeValue (String FN, String MemKey) throws Exception
 Merkt sich den Standartwert eines Objekts. Mehr ...
 
void Select (String FN, String Val) throws Exception
 Auswahl aller Zeilen einer Liste/Tabelle, welche die gegebenen Daten enthalten. Mehr ...
 
void SelectMenu (String FN) throws Exception
 Wählt den gegebenen Menü-Eintrag aus. Mehr ...
 
void SelectMenu (String FN, String Val) throws Exception
 Wählt den gegebenen Menüeintrag aus. Mehr ...
 
void SelectTablecell (String FN, String COL, String ROW) throws Exception
 Wählt die gegebene Tabellenzelle aus. Mehr ...
 
void SelectWindow (String FN) throws Exception
 Setzt den Kontext auf das gegebene Fenster. Mehr ...
 
void SelectChild (String FN) throws Exception
 Setzt den Wert von SELECTEDCHILD auf den Wert von FN. Mehr ...
 
void SelectContext (String FN) throws Exception
 Setzt den Context auf FN. Mehr ...
 
void Sequence (String FN, String SEQ_Name, String SEQ_ID) throws Exception
 Ruft die Sequenz eines Fensters auf. Mehr ...
 
void SetFocus (String FN) throws Exception
 Setzt den Fokus auf das gegebene Fensterobjekt. Mehr ...
 
void setLanguage (String Language)
 
void SetValue (String FN, String Val) throws Exception
 Setzt den Wert des gegebenen Fensterobjekts auf den gegebenen Wert. Mehr ...
 
void SetVar (String VN, String Val) throws Exception
 Setzt den Wert der gegebenen Variablen VN auf den gegebenen Wert Val. Mehr ...
 
void StartApp (String AppName) throws Exception
 Startet die gegebene Anwendung. Mehr ...
 
void StopApp (String AppName) throws Exception
 Beendet eine gegebene Anwendung. Mehr ...
 
void TypeKey (String FN, String Val) throws Exception
 Tastatureingaben von Daten in das aktive Fensterobjekt. Mehr ...
 
void TypeKeyTablecell (String FN, String COL, String ROW, String Val) throws Exception
 Eingabe von Daten in eine gegebene Tabellenzelle über die Tastatur. Mehr ...
 
void TypeKeyWindow (String FN, String Val) throws Exception
 Tastatureingabe in ein bestimmtes Fensterobjekt. Mehr ...
 
void VerifyBadge (String FN, String ExpVal) throws Exception
 Überprüft den Badge des Objektes . Mehr ...
 
void VerifyBadgeWCM (String FN, String ExpVal) throws Exception
 Überprüft den Badge des Objektes . Mehr ...
 
void VerifyBadgeREGX (String FN, String ExpVal) throws Exception
 Überprüft den Badge des Objektes . Mehr ...
 
void VerifyCaption (String FN, String ExpVal) throws Exception
 Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text). Mehr ...
 
void VerifyCaptionWCM (String FN, String ExpVal) throws Exception
 Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text). Mehr ...
 
void VerifyCaptionREGX (String FN, String ExpVal) throws Exception
 Überprüft die Überschrift eines Objektes, Reguläre-Ausdrücke als Sollwert sind erlaubt. Mehr ...
 
void VerifyExists (String FN, String ExpVal) throws Exception
 Prüft, ob das gegebene Objekt existiert. Mehr ...
 
void VerifyHasFocus (String FN, String ExpVal) throws Exception
 Vergleicht den Fokus-Zustand des gegebenen Objekts mit dem erwarteten Wert. Mehr ...
 
void VerifyIsActive (String FN, String ExpVal) throws Exception
 copydoc IOKW_State::VerifyHasFocus(String,String)
 
void VerifyLabel (String FN, String ExpVal) throws Exception
 Überprüft die Beschreibung des Objektes. Mehr ...
 
void VerifyLabelWCM (String FN, String ExpVal) throws Exception
 Überprüft die Beschreibung/Label des Objektes. Mehr ...
 
void VerifyLabelREGX (String FN, String ExpVal) throws Exception
 Überprüft die Überschrift des Objektes. Mehr ...
 
void VerifyPlaceholder (String FN, String ExpVal) throws Exception
 Überprüft die Beschreibung des Objektes. Mehr ...
 
void VerifyPlaceholderWCM (String FN, String ExpVal) throws Exception
 Überprüft den Platzhalter des Objektes. Mehr ...
 
void VerifyMaxLength (String FN, String ExpVal) throws Exception
 Checks the maximum number of characters that can be entered. Mehr ...
 
void VerifyPlaceholderREGX (String FN, String ExpVal) throws Exception
 Überprüft den Platzhalter des Objektes. Mehr ...
 
void VerifySelectedValue (String FN, String ExpVal) throws Exception
 Vergleicht den ausgewählten Wert des gegebenen Listenobjekts mit dem erwarteten Wert. Mehr ...
 
void VerifySelectedValueWCM (String FN, String ExpVal) throws Exception
 Vergleicht den ausgewählten Wert des gegebenen Listenobjekts mit dem erwarteten Wert. Mehr ...
 
void VerifySelectedValueREGX (String FN, String ExpVal) throws Exception
 Vergleicht den ausgewählten Wert des gegebenen Listenobjekts mit dem erwarteten Wert. Mehr ...
 
void VerifyTablecellValue (String FN, String COL, String ROW, String ExpVal) throws Exception
 Vergleicht den Inhalt der gegebenen Tabellenzelle mit dem erwarteten Wert. Mehr ...
 
void VerifyTablecellValueWCM (String FN, String COL, String ROW, String ExpVal) throws Exception
 Vergleicht den Inhalt der gegebenen Tabellenzelle mit dem erwarteten Wert. Mehr ...
 
void VerifyTablecellValueREGX (String FN, String COL, String ROW, String ExpVal) throws Exception
 Vergleicht den Inhalt der gegebenen Tabellenzelle mit dem erwarteten Wert. Mehr ...
 
void VerifyTooltip (String FN, String ExpVal) throws Exception
 Prüft den Tooltip-Text eines Objektes. Mehr ...
 
void VerifyTooltipWCM (String FN, String ExpVal) throws Exception
 Prüft den Tooltip-Text eines Objektes (in den meisten Fällen ist dies der angezeigte Text). Mehr ...
 
void VerifyTooltipREGX (String FN, String ExpVal) throws Exception
 Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text). Mehr ...
 
void VerifyValue (String FN, String ExpVal) throws Exception
 Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text). Mehr ...
 
void VerifyValueWCM (String FN, String ExpVal) throws Exception
 Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text). Mehr ...
 
void VerifyValueREGX (String FN, String ExpVal) throws Exception
 Wichtig: Ein "EMPTY"-Wert ist ein ArrayList String welche keine Array-Elemte enthält, also ArrayList.Size() = 0! Mehr ...
 
void FileCreate (String PATH) throws Exception
 Legt das gegebene Verzeichniss an. Mehr ...
 
void FileDelete (String fpsPathAndFileName) throws Exception
 Löscht die gegebene Datei. Mehr ...
 
void FilesDelete (String fpsDirPath, String fpsFileMatch) throws Exception
 Löscht die gegebene Datei. Mehr ...
 
void DirectoryDelete (String PATH) throws Exception
 Löscht die gegebene Datei. Mehr ...
 
void DirectoryCreate (String PATH) throws Exception
 Legt das gegebene Verzeichniss an. Mehr ...
 
void VerifyFileExists (String fpsPathAndFileName, String ExpVal) throws Exception
 Prüft, ob die gegebene Datei existiert. Mehr ...
 
void VerifyIsFile (String fpsPathAndFileName, String ExpVal) throws Exception
 Prüft, ob es sich bei dem gegebenen Pfad um eine Datei handelt. Mehr ...
 
void VerifyIsDirectory (String fpsPathAndFileName, String ExpVal) throws Exception
 
void VerifyDirectoryExists (String fpsPath, String ExpVal) throws Exception
 Prüft, ob das gegebene Verzeichnis existiert. Mehr ...
 
void CopyFile (String fpsSourcePathAndFileName, String fpsDestinationPathAndFileName) throws Exception
 Copiert die gegebene Quelldatei zur Zieldatei. Mehr ...
 
void VerifyMinLength (String FN, String ExpVal) throws Exception
 Checks the minimum number of characters that has to be entert. Mehr ...
 
void VerifyErrorMSG (String FN, String ExpVal) throws Exception
 Überprüft Fehlermeldungen in mit Angular validierten Formularen. Mehr ...
 
void VerifyErrorMSG_WCM (String FN, String ExpVal) throws Exception
 Überprüft Fehlermeldungen in mit Angular validierten Formularen. Mehr ...
 
void VerifyErrorMSG_REGX (String FN, String ExpVal) throws Exception
 Überprüft Fehlermeldungen in mit Angular validierten Formularen. Mehr ...
 

Geschützte Methoden

void handleException (Exception e) throws Exception
 In dieser Methode werden zentral die Exceptions ausgewertet. Mehr ...
 
void logException (Exception e, Exception e_Wrapped)
 
void newMethod (String ValueToAnalyse, String... NotAllowedValues)
 
void LogVerifyError (String fpsExpected, String fpsActual)
 

Geschützte Attribute

Boolean VerifyFail = false
 

Private Methoden

void verification (String fpsActual, String fpsExpected)
 
void verification (Integer fpiActual, Integer fpiExpected)
 
void verification (ArrayList< String > Actual, ArrayList< String > Expected)
 
void verificationWCM (ArrayList< String > Actual, ArrayList< String > Expected)
 
void verificationREGX (ArrayList< String > Actual, ArrayList< String > Expected)
 
Boolean verify (OKW_TimeOut timeout, Boolean fpbExpected, Supplier< Boolean > Method2Call)
 Prüft ob der gegebene boolische Wert "fpbExpected" innerhalb des Time Out "timeout" durch die gegebene Methode Method2Call gefunden wird. Mehr ...
 
Integer verify (OKW_TimeOut timeout, Integer fpiExpected, Supplier< Integer > Method2Call)
 Prüft ob der gegebene integer Wert "fpiExpected" innerhalb des Time Out "timeout" durch die gegebene Methode Method2Call gefunden wird. Mehr ...
 
ArrayList< String > verify (OKW_TimeOut timeout, String COL, String ROW, ArrayList< String > fpALExpected, BiFunction< String, String, ArrayList< String >> Method2Call)
 
ArrayList< String > verifyWCM (OKW_TimeOut timeout, String COL, String ROW, ArrayList< String > fpALExpectedWCM, BiFunction< String, String, ArrayList< String >> Method2Call)
 
ArrayList< String > verifyREGX (OKW_TimeOut timeout, String COL, String ROW, ArrayList< String > fpALExpectedREGXs, BiFunction< String, String, ArrayList< String >> Method2Call)
 
ArrayList< String > verify (OKW_TimeOut timeout, ArrayList< String > fpALExpected, Supplier< ArrayList< String >> Method2Call)
 Prüft ob der gegebene ArrayList<String> Wert "fpALExpected" innerhalb des Time Out "timeout" durch die gegebene Methode Method2Call gefunden wird. Mehr ...
 
ArrayList< String > verifyWCM (OKW_TimeOut timeout, ArrayList< String > fpALExpectedWCMs, Supplier< ArrayList< String >> Method2Call)
 Prüft ob der gegebene ArrayList<String> Wert "fpALExpected" als WCM innerhalb des Time Out "timeout" durch die gegebene Methode Method2Call gefunden wird. Mehr ...
 
ArrayList< String > verifyREGX (OKW_TimeOut timeout, ArrayList< String > fpALExpectedREGXs, Supplier< ArrayList< String >> Method2Call)
 Prüft ob der gegebene ArrayList<String> Wert "fpALExpected" als REGX innerhalb des Time Out "timeout" durch die gegebene Methode Method2Call gefunden wird. Mehr ...
 

Private Attribute

Core _Kernel
 

Statische, private Attribute

static OKWLanguage CL
 
static Logger_Sngltn Log
 
static OKW_Properties PROP
 
static OKW_CurrentObject_Sngltn CO
 
static OKW_Memorize_Sngltn MEM
 

Ausführliche Beschreibung

Klasse OK representiert den Core Zustand "OK".

Testausführung mit GUI-Aktivität und es ist keine Exception ausgelöst worden.

2019-12-27 - LogMessenger + LM_Ok.xml auf ok.properties umgestellt.

Autor
Zoltán Hrabovszki
Datum
2013.03.02

Definiert in Zeile 67 der Datei OK.java.

Beschreibung der Konstruktoren und Destruktoren

◆ OK()

okw.core.OK.OK ( Core  fp_OKW)

Klasse representiert den Zustand "OK" des OKW-Kerns im Ausführungsmodus.

Autor
Zoltán Hrabovszki
Datum
2014.01.09

Definiert in Zeile 97 der Datei OK.java.

98  {
99  try
100  {
101  CL = OKWLanguage.getInstance();
102  Log = Logger_Sngltn.getInstance();
103 
104  PROP = OKW_Properties.getInstance();
105 
106  CO = OKW_CurrentObject_Sngltn.getInstance();
107  MEM = OKW_Memorize_Sngltn.getInstance();
108 
109  this._Kernel = fp_OKW;
110  }
111  catch (Exception e)
112  {
113  final ByteArrayOutputStream stream = new ByteArrayOutputStream();
114  e.printStackTrace( new PrintStream( stream ) );
115 
116  System.out.println( "=================================================================================" );
117  System.out.println( "= Exception during initialization of Class >>OK<<! Stop running!" );
118  System.out.println( "=================================================================================" );
119  System.out.println( stream );
120 
121  System.exit( 1 );
122  }
123  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Dokumentation der Elementfunktionen

◆ BeginTest()

void okw.core.OK.BeginTest ( String  fpsTestname) throws Exception

Kennzeichnet den Anfang eines Testfalls.

Dieses Schlüsselwort ist obligatorisch: OKW Testfälle müssen mit EN.BeginTest(String) beginnen und mit EN.EndTest() aufhören zwischen diesen Schlüsselwörten wird der Testfall beschrieben.

Zu beachten
EN.BeginTest(String) initialisiert OKW:
  1. Versetz OKW in den Zustand okw.core.OK
  2. Name des Testfalls wird in ${TCN} abgelegt
Parameter
TCNName oder Bezeichnung des Testfalls
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-18

Implementiert okw.core.IOKW_State.

Definiert in Zeile 219 der Datei OK.java.

220  {
221 
222  Log.LogFunctionStartDebug( "BeginTest", "fpsTestname", fpsTestname );
223  try
224  {
225  OKW_Memorize_Sngltn.getInstance().set( "TCN", fpsTestname );
226 
227  this._Kernel.SetCoreStateOK();
228  }
229  catch (Exception e)
230  {
231  this.handleException( e );
232  }
233  finally
234  {
235  Log.LogFunctionEndDebug();
236  }
237  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ ClickOn()

void okw.core.OK.ClickOn ( String  FN) throws Exception

Klickt auf das gegebene Objekt.

Beispiel: Klicke auf das Objekt mit Namen "MeinObjekt"

EN.ClickOn( "MeinObjekt" )
Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-18
Ausnahmebehandlung
Exception

Implementiert okw.core.IOKW_State.

Definiert in Zeile 269 der Datei OK.java.

270  {
271  Log.LogFunctionStartDebug( "ClickOn", "FN", FN );
272 
273  try
274  {
275  ( ( IGUIChildwindow ) CO.setChildName( FN ) ).ClickOn();
276  }
277  catch (Exception e)
278  {
279  this.handleException( e );
280  }
281  finally
282  {
283  Log.LogFunctionEndDebug();
284  }
285  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ CopyFile()

void okw.core.OK.CopyFile ( String  fpsSourcePathAndFileName,
String  fpsDestinationPathAndFileName 
) throws Exception

Copiert die gegebene Quelldatei zur Zieldatei.

In den Pfadangaben sind:

  • OKW-Parser angaben sind erlaubt ${umgebungsvariable}, ${merkewertschlüssel}.
  • im Dateinamen sind Wildcards * + ? erlaubt.
Zu beachten
Dieses Schlüsselwort stellt sicher, dass nach der Ausführung die angegebene Datei oder Dateien kopiert worden sind. Falls die gegebene Quelldatei nicht existiert, dann wird Fehlermeldung und eine Ausnahme augelöst und das Schlüsselwort/Tesfall beendet.
Beispiel
EN.CopyFile( "C:\temp\quellDatei.txt", "C:\temp\ZielDatei.txt" )
Siehe auch
Parameter
fpsPathAndFileNameVollständiger Pfad und Dateiname.
Autor
Zoltán Hrabovszki
Datum
2015.08.20

Implementiert okw.core.IOKW_State.

Definiert in Zeile 4317 der Datei OK.java.

4318  {
4319  // TODO Auto-generated method stub
4320  }

◆ DirectoryCreate()

void okw.core.OK.DirectoryCreate ( String  PATH) throws Exception

Legt das gegebene Verzeichniss an.

Nachdem Ausführen des Schlüsselwortes ist das gegebene Verzeichniss vorhanden.

  1. wenn das Verzeichniss existiert, dann passiert nicht weiter.
  2. Wenn das Verzeichniss nicht existiert, dann wird diese mit allen Eltern-Verzeicnissen angelegt
Parameter
PATHVerzeichniss welches angelegt werden soll
Autor
Zoltán Hrabovszki
Datum
2019-12-01

Implementiert okw.core.IOKW_State.

Definiert in Zeile 4051 der Datei OK.java.

4052  {
4053  String lvsPATH = "";
4054 
4055  Log.LogFunctionStartDebug( "DirectoryCreate", "PATH", PATH );
4056  try
4057  {
4058  // Prüfen ob ignoriert werden muss...
4059  if ( PATH.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || "".equals( PATH ) )
4060  {
4061  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
4062  String lvsLM = PROP.getProperty( "ok.Ignore" );
4063  Log.LogPrint( lvsLM );
4064  }
4065  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
4066  else
4067  {
4068  // 1. Parsen der Pfad-Eingabe
4069  lvsPATH = Parser.ParseMe( PATH );
4070  // 2. Konvertieren des Pfad separators.
4071  lvsPATH = OKW_FileHelper.convertDirectorySeperator( lvsPATH );
4072 
4073  String lsvLog = PROP.getProperty( "ok.DirectoryCreate.ResolvedPath.${LANGUAGE}", lvsPATH );
4074  Log.LogPrint( lsvLog );
4075 
4076  // Basis-Funktion aufrufen...
4077  OKW_FileHelper.DirectoryCreate( lvsPATH );
4078  }
4079  }
4080  catch (Exception e)
4081  {
4082  handleException( e );
4083  }
4084  finally
4085  {
4086  Log.LogFunctionEndDebug();
4087  }
4088  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ DirectoryDelete()

void okw.core.OK.DirectoryDelete ( String  PATH) throws Exception

Löscht die gegebene Datei.

In der Pfadangabe sind

  • OKW-Parser angaben sind erlaubt ${umgebungsvariable}, ${merkewertschlüssel}.
  • im Dateinamen sind Wildcards * + ? erlaubt.
Zu beachten
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.
Siehe auch
  • EN::DirectoryDelete(string)
  • Core::DirectoryDelete(string)
  • OK::DirectoryDelete(string)
  • NOK::DirectoryDelete(string)
  • IOKW_State::DirectoryDelete(string)
Parameter
PATHVollständiger Pfad und Dateiname.
Autor
Zoltán Hrabovszki
Datum
2019.12.01

Implementiert okw.core.IOKW_State.

Definiert in Zeile 4008 der Datei OK.java.

4009  {
4010  String lvsPATH = "";
4011 
4012  Log.LogFunctionStartDebug( "FileDelete", "PATH", PATH );
4013  try
4014  {
4015  // Prüfen ob ignoriert werden muss...
4016  if ( PATH.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || "".equals( PATH ) )
4017  {
4018  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
4019  String lvsLM = PROP.getProperty( "ok.Ignore" );
4020  Log.LogPrint( lvsLM );
4021  }
4022  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
4023  else
4024  {
4025  // 1. Parsen der Pfad-Eingabe
4026  lvsPATH = Parser.ParseMe( PATH );
4027  // 2. Konvertieren des Pfad separators.
4028  lvsPATH = OKW_FileHelper.convertDirectorySeperator( lvsPATH );
4029 
4030  String lsvLog = PROP.getProperty( "ok.DirectoryDelete.ResolvedPath.${LANGUAGE}", lvsPATH );
4031  Log.LogPrint( lsvLog );
4032 
4033  // Basis-Funktion aufrufen...
4034  OKW_FileHelper.deleteDirectory( lvsPATH );
4035  }
4036  }
4037  catch (Exception e)
4038  {
4039  handleException( e );
4040  }
4041  finally
4042  {
4043  Log.LogFunctionEndDebug();
4044  }
4045  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ DoubleClickOn()

void okw.core.OK.DoubleClickOn ( String  FN) throws Exception

Führt ein Doppelklick auf das gegebene GUI-Objekt aus.

Beispiel: Klicke auf das Objekt mit Namen "MeinObjekt":

DoppelKlickeAuf( "MeinObjekt" )
Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-18
Ausnahmebehandlung
Exception

Implementiert okw.core.IOKW_State.

Definiert in Zeile 290 der Datei OK.java.

291  {
292  Log.LogFunctionStartDebug( "DoubleClickOn", "FN", FN );
293 
294  try
295  {
296  ( ( IGUIChildwindow ) CO.setChildName( FN ) ).DoubleClickOn();
297  }
298  catch (Exception e)
299  {
300  this.handleException( e );
301  }
302  finally
303  {
304  Log.LogFunctionEndDebug();
305  }
306  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ EndTest()

void okw.core.OK.EndTest ( ) throws Exception

Signalisiert das Ende eines Testfalls.

Mit EndTest() werden aufräum Aktivitäten angestoßem, in der aktuellen Version ist das jedoch noch nicht implementiert.

Zu beachten
Zusätzliche Bemerkungen zum Schlüsselwort
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-18
Ausnahmebehandlung
Exception
Exception

Implementiert okw.core.IOKW_State.

Definiert in Zeile 243 der Datei OK.java.

244  {
245  Log.LogFunctionStartDebug( "EndTest" );
246 
247  String msg = "";
248  try {
249  if ( this.VerifyFail )
250  {
251  throw _Kernel.getNOK_Reason();
252  }
253  else
254  {
255  msg = PROP.getProperty( "ok.endtest.verifypass.msg.${LANGUAGE}" );
256  Log.LogPrint( msg );
257  }
258  }
259  finally
260  {
261  Log.LogFunctionEndDebug();
262  }
263 
264  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ FileCreate()

void okw.core.OK.FileCreate ( String  PATH) throws Exception

Legt das gegebene Verzeichniss an.

Nachdem Ausführen des Schlüsselwortes ist die gegebene Datei vorhanden.

  1. Wenn die Datei existiert, dann passiert nicht weiter.
  2. Wenn die Datei nicht existiert, dann wird diese mit allen Eltern-Verzeichnissen angelegt.
Parameter
PATHDatei, welches angelegt werden soll.
Autor
Zoltán Hrabovszki
Datum
2019-12-18

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3875 der Datei OK.java.

3876  {
3877  String lvsPATH = "";
3878 
3879  Log.LogFunctionStartDebug( "FileCreate", "PATH", PATH );
3880  try
3881  {
3882  // Prüfen ob ignoriert werden muss...
3883  if ( PATH.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || "".equals( PATH ) )
3884  {
3885  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
3886  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3887  Log.LogPrint( lvsLM );
3888  }
3889  else
3890  {
3891  // 1. Parsen der Pfad-Eingabe
3892  lvsPATH = Parser.ParseMe( PATH );
3893  // 2. Konvertieren des Pfad separators.
3894  lvsPATH = OKW_FileHelper.convertDirectorySeperator( lvsPATH );
3895 
3896  String lsvLog = PROP.getProperty( "ok.FileCreate.ResolvedPath.${LANGUAGE}", lvsPATH );
3897  Log.LogPrint( lsvLog );
3898 
3899  OKW_FileHelper.createFile( lvsPATH );
3900  }
3901  }
3902  catch (Exception e)
3903  {
3904  handleException( e );
3905  }
3906  finally
3907  {
3908  Log.LogFunctionEndDebug();
3909  }
3910  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ FileDelete()

void okw.core.OK.FileDelete ( String  fpsPathAndFileName) throws Exception

Löscht die gegebene Datei.

In der Pfadangabe sind

  • OKW-Parser angaben sind erlaubt ${umgebungsvariable}, ${merkewertschlüssel}.
  • im Dateinamen sind Wildcards * + ? erlaubt.
Zu beachten
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.
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
Siehe auch
  • EN::FileDelete(string)
  • Core::FileDelete(string)
  • OK::FileDelete(string)
  • NOK::FileDelete(string)
  • IOKW_State::FileDelete(string)
Parameter
fpsPathAndFileNameVollständiger Pfad und Dateiname.
Autor
Zoltán Hrabovszki
Datum
2015.08.20

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3916 der Datei OK.java.

3917  {
3918  String lvsPathAndFileName = "";
3919 
3920  Log.LogFunctionStartDebug( "FileDelete", "fpsPathAndFileName", fpsPathAndFileName );
3921  try
3922  {
3923  // Prüfen ob ignoriert werden muss...
3924  if ( fpsPathAndFileName.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || "".equals( fpsPathAndFileName ) )
3925  {
3926  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
3927  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3928  Log.LogPrint( lvsLM );
3929  }
3930  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
3931  else
3932  {
3933  // 1. Parsen der Pfad-Eingabe
3934  lvsPathAndFileName = Parser.ParseMe( fpsPathAndFileName );
3935  // 2. Konvertieren des Pfad separators.
3936  lvsPathAndFileName = OKW_FileHelper.convertDirectorySeperator( lvsPathAndFileName );
3937 
3938  String lsvLog = PROP.getProperty( "ok.FileDelete.ResolvedPath.${LANGUAGE}", lvsPathAndFileName );
3939  Log.LogPrint( lsvLog );
3940 
3941  // Basis-Funktion aufrufen...
3942  OKW_FileHelper.deleteFile( lvsPathAndFileName );
3943  }
3944  }
3945  catch (Exception e)
3946  {
3947  handleException( e );
3948  }
3949  finally
3950  {
3951  Log.LogFunctionEndDebug();
3952  }
3953  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ FilesDelete()

void okw.core.OK.FilesDelete ( String  fpsDirPath,
String  fpsFileMatch 
) throws Exception

Löscht die gegebene Datei.

In der Pfadangabe sind

  • OKW-Parser angaben sind erlaubt ${umgebungsvariable}, ${merkewertschlüssel}.
  • im Dateinamen sind Wildcards * + ? erlaubt.
Zu beachten
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.
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
Siehe auch
  • EN::FileDelete(string)
  • Core::FileDelete(string)
  • OK::FileDelete(string)
  • NOK::FileDelete(string)
  • IOKW_State::FileDelete(string)
Parameter
fpsPathAndFileNameVollständiger Pfad und Dateiname.
Autor
Zoltán Hrabovszki
Datum
2019.12.16

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3959 der Datei OK.java.

3960  {
3961  String lvsDirPath = "";
3962  String lvsFileMatch = "";
3963 
3964  Log.LogFunctionStartDebug( "FilesDelete", "fpsDirPath", fpsDirPath, "fpsFileMatch", fpsFileMatch );
3965  try
3966  {
3967  // Check if you need to ignore...
3968  // FIXME: Testfall für fpsFileMatch schreiben
3969  if ( fpsDirPath.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) )
3970  || "".equals( fpsDirPath )
3971  || fpsFileMatch.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) )
3972  || "".equals( fpsFileMatch ))
3973  {
3974  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
3975  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3976  Log.LogPrint( lvsLM );
3977  }
3978  else
3979  {
3980  // 1. Parsen der Pfad-Eingabe
3981  lvsDirPath = Parser.ParseMe( fpsDirPath );
3982  lvsFileMatch = Parser.ParseMe( fpsDirPath );
3983 
3984  // 2. Konvertieren des Pfad separators.
3985  lvsDirPath = OKW_FileHelper.convertDirectorySeperator( lvsDirPath );
3986  lvsFileMatch = OKW_FileHelper.convertDirectorySeperator( lvsFileMatch );
3987 
3988  String lsvLog = PROP.getProperty( "ok.FileDelete.ResolvedPath.${LANGUAGE}", lvsFileMatch );
3989  Log.LogPrint( lsvLog );
3990 
3991  // Basis-Funktion aufrufen...
3992  OKW_FileHelper.deleteFiles( lvsDirPath );
3993  }
3994  }
3995  catch (Exception e)
3996  {
3997  handleException( e );
3998  }
3999  finally
4000  {
4001  Log.LogFunctionEndDebug();
4002  }
4003  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ handleException()

void okw.core.OK.handleException ( Exception  e) throws Exception
protected

In dieser Methode werden zentral die Exceptions ausgewertet.

Methode führt folge Aktivitäten aus:

  1. Exception wird als Log ausgegeben.
  2. Daten des aktuellen Objektes werden für eine Fehler-Analyse ausgegeben (CO.LogObjectData()).
  3. Wenn es sich um eine OKWVerifyingFailsException handelt, dann geht der Status von VerifyFail nach true
  4. Wechselt den Zustand auf NOK. dann wird an das Unittest-Framework die Exception weitergereicht.
Parameter
eException aus der OK-Schlüsselwort-Methode
Autor
Zoltán Hrabovszki
Datum
2013-03-02
Ausnahmebehandlung
Exception

Definiert in Zeile 154 der Datei OK.java.

155  {
156  Exception e_Wrapped = null;
157 
158  if ( e instanceof okw.exceptions.OKWVerifyingFailsException )
159  {
160  Boolean lvbAbbort = PROP.getProperty2Boolean( "core.AbbortOnVerifyFail", "false" );
161  _Kernel.setNOK_Reason( e );
162 
163  if ( lvbAbbort )
164  {
165  // Change State to NOK if Property core.AbbortOnVerifyFail is true
166  logException( e, e_Wrapped );
167  this._Kernel.SetCoreStateNOK( );
168  }
169  else
170  { // If we don't want to abort, then we stay at State OK!
171  // Loggen zur Abbweichung die Objektdaten.
172  logException( e, e_Wrapped );
173  // Und/Aber Merken uns dass wir einen VerifyFehler hatte mit this.VerifyFail = true
174  this.VerifyFail = true;
175  }
176  }
177  // if we have an InvocationTargetException...
178  else if ( e instanceof InvocationTargetException )
179  {
180  // ... then get the origin exception.
181  e = ( Exception ) e.getCause();
182  logException( e, e_Wrapped );
183  this._Kernel.SetCoreStateNOK( );
184  _Kernel.setNOK_Reason( e );
185  }
186  else if ( e instanceof RuntimeException )
187  {
188  // ... then get the origin exception.
189  e_Wrapped = ( Exception ) e.getCause();
190  logException( e, e_Wrapped );
191  this._Kernel.SetCoreStateNOK( );
192  _Kernel.setNOK_Reason( e );
193  }
194  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ LogCaption()

void okw.core.OK.LogCaption ( String  FN) throws Exception

Gibt die Caption eines GUI-Objektes in den Testergebnissen aus.

Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-18/jnic
Noch zu erledigen:
jnic-->keine Beschreibung vorhanden

Implementiert okw.core.IOKW_State.

Definiert in Zeile 311 der Datei OK.java.

312  {
313  Log.LogFunctionStartDebug( "LogCaption", "FN", FN );
314 
315  try
316  {
317  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).LogCaption();
318 
319  Log.ResOpenListDebug( "Log... " );
320 
321  for ( String Value : ActualValues )
322  {
323  Log.LogPrint( "'" + Value + "'" );
324  }
325 
326  Log.ResCloseListDebug();
327  }
328  catch (Exception e)
329  {
330  this.handleException( e );
331  }
332  finally
333  {
334  Log.LogFunctionEndDebug();
335  }
336  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ LogExists()

void okw.core.OK.LogExists ( String  FN) throws Exception

Gibt die Existenz eines GUI-Objektes mit YES/NO in den Testergebnissen aus.

Beispiel: Protokolliert, ob das Objekt mit Namen "Mein Objekt" vorhanden ist:

LogExists( "myObject" )
Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-18

Implementiert okw.core.IOKW_State.

Definiert in Zeile 341 der Datei OK.java.

342  {
343  Log.LogFunctionStartDebug( "LogExists", "FN", FN );
344 
345  try
346  {
347  Boolean lvbActual = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).LogExists();
348  String lvsActual = OKW_Const_Sngltn.getInstance().Boolean2YesNo( lvbActual );
349 
350  // String lvsLM = LM.GetMessage( "LogExists", "LogValue", lvsActual );
351  // Print: "Value found: '%P1%'"
352  String lvsLM = PROP.getProperty( "ok.Log.ValueFound.${LANGUAGE}", lvsActual );
353  Log.LogPrint( lvsLM );
354  }
355  catch (Exception e)
356  {
357  this.handleException( e );
358  }
359  finally
360  {
361  Log.LogFunctionEndDebug();
362  }
363  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ LogHasFocus()

void okw.core.OK.LogHasFocus ( String  FN) throws Exception

Dokumentiert den Fokus-Status des gegebenen Objekts.

Beispiel: Protokolliert den Fokus-Zustand von "Mein Objekt":

Logge hat Fokus: "MeinObjekt"
Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 368 der Datei OK.java.

369  {
370  Log.LogFunctionStartDebug( "LogHasFocus", "FN", FN );
371 
372  try
373  {
374  Boolean lvbActual = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).LogHasFocus();
375  String lvsActual = OKW_Const_Sngltn.getInstance().Boolean2YesNo( lvbActual );
376 
377  // String lvsLM = LM.GetMessage( "LogHasFocus", "LogValue", lvsActual );
378  // Print: "Value found: '%P1%'"
379  String lvsLM = PROP.getProperty( "ok.Log.ValueFound.${LANGUAGE}", lvsActual );
380  Log.LogPrint( lvsLM );
381  }
382  catch (Exception e)
383  {
384  this.handleException( e );
385  }
386  finally
387  {
388  Log.LogFunctionEndDebug();
389  }
390  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ LogIsActive()

void okw.core.OK.LogIsActive ( String  FN) throws Exception

Dokumentiert den Status des gegebenen Objekts.

Beispiel: Protokolliert den Aktivzustand von "Mein Objekt":

LoggeIstAktiv: "MeinObjekt"
Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 395 der Datei OK.java.

396  {
397  Log.LogFunctionStartDebug( "LogIsActive", "FN", FN );
398 
399  try
400  {
401  Boolean lvbActual = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).LogIsActive();
402  String lvsActual = OKW_Const_Sngltn.getInstance().Boolean2YesNo( lvbActual );
403 
404  //String lvsLM = LM.GetMessage( "LogIsActive", "LogValue", lvsActual );
405  // Print: "Value found: '%P1%'"
406  String lvsLM = PROP.getProperty( "ok.Log.ValueFound.${LANGUAGE}", lvsActual );
407  Log.LogPrint( lvsLM );
408  }
409  catch (Exception e)
410  {
411  this.handleException( e );
412  }
413  finally
414  {
415  Log.LogFunctionEndDebug();
416  }
417  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ LogLabel()

void okw.core.OK.LogLabel ( String  FN) throws Exception

Gibt den Wert des Etikette/Label in der Logdatei aus.

Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 422 der Datei OK.java.

423  {
424  Log.LogFunctionStartDebug( "LogLabel", "FN", FN );
425 
426  try
427  {
428  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).LogLabel();
429 
430  Log.ResOpenList( "Log... " );
431 
432  for ( String Value : ActualValues )
433  {
434  Log.LogPrint( "'" + Value + "'" );
435  }
436 
437  Log.ResCloseList();
438  }
439  catch (Exception e)
440  {
441  this.handleException( e );
442  }
443  finally
444  {
445  Log.LogFunctionEndDebug();
446  }
447  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ LogPlaceholder()

void okw.core.OK.LogPlaceholder ( String  FN) throws Exception

Gibt den Wert des Platzhalters in der Logdatei aus.

Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 452 der Datei OK.java.

453  {
454  Log.LogFunctionStartDebug( "LogPlaceholder", "FN", FN );
455 
456  try
457  {
458  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).LogPlaceholder();
459 
460  Log.ResOpenList( "Log... " );
461 
462  for ( String Value : ActualValues )
463  {
464  Log.LogPrint( "'" + Value + "'" );
465  }
466 
467  Log.ResCloseList();
468  }
469  catch (Exception e)
470  {
471  this.handleException( e );
472  }
473  finally
474  {
475  Log.LogFunctionEndDebug();
476  }
477  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ LogSelected()

void okw.core.OK.LogSelected ( String  FN) throws Exception

Dokumentiert den markierten Text des gegebenen Objekts.

Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 483 der Datei OK.java.

484  {
485  Log.LogFunctionStartDebug( "LogSelected", "FN", FN );
486 
487  try
488  {
489  ArrayList<String> actualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).LogSelected();
490 
491  // String lvsLM = LM.GetMessage( "LogSelected", "LogValue" );
492 
493  // String lvsLM = LM.GetMessage( "LogSelected", "LogValue" );
494  String lvsLM = PROP.getProperty( "ok.Log.ListValuesFound.${LANGUAGE}" );
495  Log.ResOpenList( lvsLM );
496 
497  for ( String Value : actualValues )
498  {
499  Log.LogPrint( "'" + Value + "'" );
500  }
501 
502  Log.ResCloseList();
503  }
504  catch (Exception e)
505  {
506  this.handleException( e );
507  }
508  finally
509  {
510  Log.LogFunctionEndDebug();
511  }
512  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ LogTablecellValue()

void okw.core.OK.LogTablecellValue ( String  FN,
String  COL,
String  ROW 
) throws Exception

Dokumentiert den Wert der ausgewählten Zelle.

Parameter
FNFunktionaler Name des Objekts
COLSpaltennummer der zu wählenden Zelle, beginnend mit 1.
ROWZeilennummer der zu wählenden Zelle, beginnend mit 1.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19
Noch zu erledigen:
Beschreibung überprüfen

Implementiert okw.core.IOKW_State.

Definiert in Zeile 517 der Datei OK.java.

518  {
519  Log.LogFunctionStartDebug( "LogTablecellValue", "String FN", FN, "COL", COL, "ROW", ROW );
520 
521  try
522  {
523  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).LogTablecellValue( COL, ROW );
524 
525  String lvsLM = PROP.getProperty( "ok.Log.ListValuesFound.${LANGUAGE}" );
526  Log.ResOpenList( lvsLM );
527 
528  for ( String Value : ActualValues )
529  {
530  Log.LogPrint( ">>" + Value + "<<" );
531  }
532 
533  Log.ResCloseList();
534  }
535  catch (Exception e)
536  {
537  this.handleException( e );
538  }
539  finally
540  {
541  Log.LogFunctionEndDebug();
542  }
543  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ LogTooltip()

void okw.core.OK.LogTooltip ( String  FN) throws Exception

Dokumentiert die Kurzinfo zu einem Werkzeug des gegebenen Objekts.

Beispiel: Protokolliert den Kurzinformationstext (Tooltip) von "Mein Objekt":

LoggeTooltip: "MeinObjekt"
Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 548 der Datei OK.java.

549  {
550  Log.LogFunctionStartDebug( "LogTooltip", "FN", FN );
551 
552  try
553  {
554  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).LogTooltip();
555 
556  String lvsLM = PROP.getProperty( "ok.Log.ListValuesFound.${LANGUAGE}" );
557  Log.ResOpenList( lvsLM );
558 
559  for ( String Value : ActualValues )
560  {
561  Log.LogPrint( "'" + Value + "'" );
562  }
563 
564  Log.ResCloseList();
565  }
566  catch (Exception e)
567  {
568  this.handleException( e );
569  }
570  finally
571  {
572  Log.LogFunctionEndDebug();
573  }
574  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ LogValue()

void okw.core.OK.LogValue ( String  FN) throws Exception

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:

Prüfe Wert: "MeinObjekt", "Django"
Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 579 der Datei OK.java.

580  {
581  Log.LogFunctionStartDebug( "LogValue", "FN", FN );
582 
583  try
584  {
585  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).LogValue();
586 
587  String lvsLM = PROP.getProperty( "ok.Log.ListValuesFound.${LANGUAGE}" );
588  Log.ResOpenList( lvsLM );
589 
590  for ( String Value : ActualValues )
591  {
592  Log.LogPrint( "'" + Value + "'" );
593  }
594 
595  Log.ResCloseList();
596  }
597  catch (Exception e)
598  {
599  this.handleException( e );
600  }
601  finally
602  {
603  Log.LogFunctionEndDebug();
604  }
605  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ MemorizeCaption()

void okw.core.OK.MemorizeCaption ( String  FN,
String  MemKey 
) throws Exception

Keine Beschreibung zu "MemorizeCaption" verfügbar.

Parameter
FNFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 610 der Datei OK.java.

611  {
612  Log.LogFunctionStartDebug( "MemorizeCaption", "FN", FN, "fpsMemKeyName", MemKey );
613 
614  try
615  {
616  if ( MemKey.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || "".equals( MemKey ) )
617  {
618  // Wenn fpsMemKeyName = IGNORE oder "" ist ->
619  // OKWNotAllowedValueException auslösen...
620 
621  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.${LANGUAGE}", MemKey );
622  throw new OKWNotAllowedValueException( lvsLM );
623  }
624  else
625  {
626  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
627  this.newMethod( MemKey, "IGNORE", "DELETE" );
628 
629  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).MemorizeCaption();
630 
631  String lvsToMemorize = OKW_Const_Sngltn.getInstance().ConcatSEP( ActualValues );
632 
633  MEM.set( MemKey, lvsToMemorize );
634  }
635  }
636  catch (Exception e)
637  {
638  this.handleException( e );
639  }
640  finally
641  {
642  Log.LogFunctionEndDebug();
643  }
644  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ MemorizeExists()

void okw.core.OK.MemorizeExists ( String  FN,
String  MemKey 
) throws Exception

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".:

Merke Existiert: "MeinObjekt", "Mein Schlüssel"
Parameter
FNFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 649 der Datei OK.java.

650  {
651  Log.LogFunctionStartDebug( "MemorizeExists", "FN", FN, "MemKey", MemKey );
652 
653  try
654  {
655  // Prüfen ob ignoriert werden muss...
656  if ( MemKey.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || MemKey.equals( "" ) )
657  {
658  // Wenn fpsMemKeyName = IGNORE oder "" ist ->
659  // OKWNotAllowedValueException auslösen...
660  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.${LANGUAGE}", MemKey );
661  throw new OKWNotAllowedValueException( lvsLM );
662  }
663  else
664  {
665  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
666  this.newMethod( MemKey, "IGNORE", "DELETE" );
667 
668  Boolean lvbActual = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).MemorizeExists();
669 
670  String lvsActual = OKW_Const_Sngltn.getInstance().Boolean2YesNo( lvbActual );
671 
672  MEM.set( MemKey, lvsActual );
673  }
674  }
675  catch (Exception e)
676  {
677  this.handleException( e );
678  }
679  finally
680  {
681  Log.LogFunctionEndDebug();
682  }
683  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ MemorizeHasFocus()

void okw.core.OK.MemorizeHasFocus ( String  FN,
String  MemKey 
) throws Exception

Keine Beschreibung zu "MemorizeHasFocus" verfügbar.

Parameter
FNFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19/jnic
Noch zu erledigen:
TODO: keine Beschreibung vorhanden

Implementiert okw.core.IOKW_State.

Definiert in Zeile 688 der Datei OK.java.

689  {
690  Log.LogFunctionStartDebug( "MemorizeHasFocus", "FN", FN, "MemKey", MemKey );
691 
692  try
693  {
694  // Prüfen ob ignoriert werden muss...
695  if ( MemKey.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || MemKey.equals( "" ) )
696  {
697  // Wenn fps_MemKeyName = IGNORE oder "" ist ->
698  // OKWNotAllowedValueException auslösen...
699  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.${LANGUAGE}", MemKey );
700  throw new OKWNotAllowedValueException( lvsLM );
701  }
702  else
703  {
704  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
705  this.newMethod( MemKey, "IGNORE", "DELETE" );
706 
707  Boolean lvbActual = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).MemorizeHasFocus();
708 
709  String lvsActual = OKW_Const_Sngltn.getInstance().Boolean2YesNo( lvbActual );
710 
711  MEM.set( MemKey, lvsActual );
712  }
713  }
714  catch (Exception e)
715  {
716  this.handleException( e );
717  }
718  finally
719  {
720  Log.LogFunctionEndDebug();
721  }
722  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ MemorizeIsActive()

void okw.core.OK.MemorizeIsActive ( String  FN,
String  MemKey 
) throws Exception

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":

Merke Ist Aktiv: "MeinObjekt", "Mein Schlüssel"
Parameter
FNFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
TODO: 2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 727 der Datei OK.java.

728  {
729  Log.LogFunctionStartDebug( "MemorizeIsActive", "FN", FN, "MemKey", MemKey );
730 
731  try
732  {
733  // Prüfen ob ignoriert werden muss...
734  if ( MemKey.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || MemKey.equals( "" ) )
735  {
736  // Wenn fpsMemKeyName = IGNORE oder "" ist ->
737  // OKWNotAllowedValueException auslösen...
738  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.${LANGUAGE}", MemKey );
739  throw new OKWNotAllowedValueException( lvsLM );
740  }
741  else
742  {
743  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
744  this.newMethod( MemKey, "IGNORE", "DELETE" );
745 
746  Boolean lvbActual = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).MemorizeIsActive();
747 
748  String lvsActual = OKW_Const_Sngltn.getInstance().Boolean2YesNo( lvbActual );
749 
750  MEM.set( MemKey, lvsActual );
751  }
752  }
753  catch (Exception e)
754  {
755  this.handleException( e );
756  }
757  finally
758  {
759  Log.LogFunctionEndDebug();
760  }
761  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ MemorizeLabel()

void okw.core.OK.MemorizeLabel ( String  FN,
String  MemKey 
) throws Exception

Speirchert den aktuellen Wert der Etikette, und legt diesen unter fpsMemKeyName ab.

Parameter
FNFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 766 der Datei OK.java.

767  {
768  Log.LogFunctionStartDebug( "MemorizeLabel", "FN", FN, "MemKey", MemKey );
769 
770  try
771  {
772  if ( MemKey.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || MemKey.equals( "" ) )
773  {
774  // Wenn fps_MemKeyName = IGNORE oder "" ist ->
775  // OKWNotAllowedValueException auslösen...
776  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.${LANGUAGE}", MemKey );
777  throw new OKWNotAllowedValueException( lvsLM );
778  }
779  else
780  {
781  // If One of the Give OKW-Const-Values is contained in MemVal -> trigger OKWNotAllowedValueException
782  this.newMethod( MemKey, "IGNORE", "DELETE" );
783 
784  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).MemorizeLabel();
785 
786  String lvsToMemorize = OKW_Const_Sngltn.getInstance().ConcatSEP( ActualValues );
787 
788  MEM.set( MemKey, lvsToMemorize );
789  }
790  }
791  catch (Exception e)
792  {
793  this.handleException( e );
794  }
795  finally
796  {
797  Log.LogFunctionEndDebug();
798  }
799  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ MemorizePlaceholder()

void okw.core.OK.MemorizePlaceholder ( String  FN,
String  MemKey 
) throws Exception

Speirchert den aktuellen Wert der Platzhalters, und legt diesen unter fpsMemKeyName ab.

Parameter
FNFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 804 der Datei OK.java.

805  {
806  Log.LogFunctionStartDebug( "MemorizePlaceholder", "FN", FN, "MemKey", MemKey );
807 
808  try
809  {
810  if ( MemKey.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || MemKey.equals( "" ) )
811  {
812  // Wenn fps_MemKeyName = IGNORE oder "" ist ->
813  // OKWNotAllowedValueException auslösen...
814  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.${LANGUAGE}", MemKey );
815  throw new OKWNotAllowedValueException( lvsLM );
816  }
817  else
818  {
819  // If One of the Give OKW-Const-Values is contained in MemVal -> trigger OKWNotAllowedValueException
820  this.newMethod( MemKey, "IGNORE", "DELETE" );
821 
822  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).MemorizePlaceholder();
823 
824  String lvsToMemorize = OKW_Const_Sngltn.getInstance().ConcatSEP( ActualValues );
825 
826  MEM.set( MemKey, lvsToMemorize );
827  }
828  }
829  catch (Exception e)
830  {
831  this.handleException( e );
832  }
833  finally
834  {
835  Log.LogFunctionEndDebug();
836  }
837  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ MemorizeSelectedValue()

void okw.core.OK.MemorizeSelectedValue ( String  FN,
String  MemKey 
) throws Exception

Keine Beschreibung zu "MemorizeSelectedValue" verfügbar.

Parameter
FNFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19/jnic
Noch zu erledigen:
TODO:keine Beschreibung vorhanden

Implementiert okw.core.IOKW_State.

Definiert in Zeile 842 der Datei OK.java.

843  {
844  Log.LogFunctionStartDebug( "MemorizeSelectedValue", "FN", FN, "MemKey", MemKey );
845 
846  try
847  {
848  if ( MemKey.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || MemKey.equals( "" ) )
849  {
850  // Wenn fps_MemKeyName = IGNORE oder "" ist ->
851  // OKWNotAllowedValueException auslösen...
852  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.${LANGUAGE}", MemKey );
853  throw new OKWNotAllowedValueException( lvsLM );
854  }
855  else
856  {
857  // If One of the Give OKW-Const-Values is contained in MemVal -> trigger OKWNotAllowedValueException
858  this.newMethod( MemKey, "IGNORE", "DELETE" );
859 
860  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).MemorizeSelectedValue();
861 
862  String lvsToMemorize = OKW_Const_Sngltn.getInstance().ConcatSEP( ActualValues );
863 
864  MEM.set( MemKey, lvsToMemorize );
865  }
866  }
867  catch (Exception e)
868  {
869  this.handleException( e );
870  }
871  finally
872  {
873  Log.LogFunctionEndDebug();
874  }
875  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ MemorizeTablecellValue()

void okw.core.OK.MemorizeTablecellValue ( String  FN,
String  COL,
String  ROW,
String  MemKey 
) throws Exception

Merkt sich den Wert der gegebenen Zelle in der Tabelle. throws Exception

Parameter
FNFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
COLSpaltennummer der zu wählenden Zelle, beginnend mit 1.
ROWZeilennummer der zu wählenden Zelle, beginnend mit 1.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de throws Exception

Implementiert okw.core.IOKW_State.

Definiert in Zeile 880 der Datei OK.java.

881  {
882  Log.LogFunctionStartDebug( "MemorizeTablecellValue", "FN", FN, "COL", COL, "ROW", ROW, "MemKey", MemKey );
883 
884  try
885  {
886 
887  if ( MemKey.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || MemKey.equals( "" ) )
888  {
889  // Wenn fpsMemKeyName = IGNORE oder "" ist ->
890  // OKWNotAllowedValueException auslösen...
891  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.${LANGUAGE}", MemKey );
892  throw new OKWNotAllowedValueException( lvsLM );
893  }
894  else
895  {
896  // If One of the Give OKW-Const-Values is contained in MemVal -> trigger OKWNotAllowedValueException
897  this.newMethod( MemKey, "IGNORE", "DELETE" );
898 
899  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).MemorizeTablecellValue( COL, ROW );
900 
901  String lvsToMemorize = OKW_Const_Sngltn.getInstance().ConcatSEP( ActualValues );
902 
903  MEM.set( MemKey, lvsToMemorize );
904  }
905  }
906  catch (Exception e)
907  {
908  this.handleException( e );
909  }
910  finally
911  {
912  Log.LogFunctionEndDebug();
913  }
914  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ MemorizeTooltip()

void okw.core.OK.MemorizeTooltip ( String  FN,
String  MemKey 
) throws Exception

Dokumentiert den Tooltip-Text (Kurzinformation) des gegebenen Objekts.

Beispiel Dokumentiert den Tooltip-Text des Objektes "MeinObjekt":

Logge Tooltip: "MeinObjekt"
Parameter
FNFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19/jnic

Implementiert okw.core.IOKW_State.

Definiert in Zeile 919 der Datei OK.java.

920  {
921  Log.LogFunctionStartDebug( "MemorizeTooltip", "FN", FN, "fps_MemKeyName", MemKey );
922 
923  try
924  {
925  if ( MemKey.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || MemKey.equals( "" ) )
926  {
927  // Wenn fpsMemKeyName = IGNORE oder "" ist ->
928  // OKWNotAllowedValueException auslösen...
929  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.${LANGUAGE}", MemKey );
930  throw new OKWNotAllowedValueException( lvsLM );
931 
932  }
933  else
934  {
935  // If One of the Give OKW-Const-Values is contained in MemVal -> trigger OKWNotAllowedValueException
936  this.newMethod( MemKey, "IGNORE", "DELETE" );
937 
938  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).MemorizeTooltip();
939 
940  String lvsToMemorize = OKW_Const_Sngltn.getInstance().ConcatSEP( ActualValues );
941 
942  MEM.set( MemKey, lvsToMemorize );
943  }
944  }
945  catch (Exception e)
946  {
947  this.handleException( e );
948  }
949  finally
950  {
951  Log.LogFunctionEndDebug();
952  }
953  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ MemorizeValue()

void okw.core.OK.MemorizeValue ( String  FN,
String  MemKey 
) throws Exception

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:

Merke Wert: "MeinObjekt", "MeinSchlüssel"
Parameter
FNFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 958 der Datei OK.java.

959  {
960  Log.LogFunctionStartDebug( "MemorizeValue", "FN", FN, "MemKey", MemKey );
961 
962  try
963  {
964  if ( MemKey.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || MemKey.equals( "" ) )
965  {
966  // Wenn fpsMemKeyName = IGNORE oder "" ist ->
967  // OKWNotAllowedValueException auslösen...
968  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.${LANGUAGE}", MemKey );
969  throw new OKWNotAllowedValueException( lvsLM );
970 
971  }
972  else
973  {
974  // If One of the Give OKW-Const-Values is contained in MemVal -> trigger OKWNotAllowedValueException
975  this.newMethod( MemKey, "IGNORE", "DELETE" );
976 
977  ArrayList<String> ActualValues = ( ( IGUIChildwindow ) CO.setChildName( FN ) ).MemorizeValue();
978 
979  String lvsToMemorize = OKW_Const_Sngltn.getInstance().ConcatSEP( ActualValues );
980 
981  MEM.set( MemKey, lvsToMemorize );
982  }
983  }
984  catch (Exception e)
985  {
986  this.handleException( e );
987  }
988  finally
989  {
990  Log.LogFunctionEndDebug();
991  }
992  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ Select()

void okw.core.OK.Select ( String  FN,
String  Val 
) throws Exception

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:

Wähle aus: "MeineTabelle", "Wert"


Beispiel 2: Wähle alle Zeilen aus, die mit dem Text "Wert1" beginnen und deren zweite Spalte den Text "Wert2" enthält:

Wähle aus: "MeineTabelle", "Wert1{HSEP}, Wert2"


Beispiel 3: Wähle alle Zeilen aus, die mit dem Text "Wert1" beginnen und deren dritte Spalte den Text "Wert2" enthält:

Wähle aus: "MeineTabelle", "Wert1{HSEP}{HSEP}Wert2"
Parameter
FNFunktionaler Name des Objekts
ValSich ergebender Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 997 der Datei OK.java.

998  {
999  Log.LogFunctionStartDebug( "Select", "FN", FN, "Val", Val );
1000  try
1001  {
1002  // Prüfen ob ignoriert werden muss...
1003  if ( Val.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || "".equals( Val ) )
1004  {
1005  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1006  // Print: "KeyWord was ignored!'"
1007  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1008  Log.LogPrint( lvsLM );
1009  }
1010  else
1011  {
1012  // If One of the Give OKW-Const-Values is contained in Val -> trigger OKWNotAllowedValueException
1013  this.newMethod( Val, "IGNORE" );
1014 
1015  // Sonst Methode des Objektes aufrufen....
1016  ArrayList<String> lvlsValue = OKW_Const_Sngltn.getInstance().SplitSEP( Val );
1017 
1018  lvlsValue = Parser.ParseMe( lvlsValue );
1019 
1020  ( ( IGUIChildwindow ) CO.setChildName( FN ) ).Select( lvlsValue );
1021 
1022  }
1023  }
1024  catch (Exception e)
1025  {
1026  this.handleException( e );
1027  }
1028  finally
1029  {
1030  Log.LogFunctionEndDebug();
1031  }
1032  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ SelectChild()

void okw.core.OK.SelectChild ( String  FN) throws Exception

Setzt den Wert von SELECTEDCHILD auf den Wert von FN.

In nachfolgenden OpeKeywords kann dieser Wert mit "SELECTEDCHILD" abgerufen bzw referenziert werden.

Beispiel: Auswahl des Kindobjektes mit dem Namen "MeinKindobjekt"

EN.SelectChild( "MeinKindobjekt" )
EN.SetValue("SELECTEDCHILD", "MyValue")
EN.VerifyValue("SELECTEDCHILD", "MyValue")
EN.VerifyLabel("SELECTEDCHILD", "MyLabel")
Parameter
FNFunktionaler Name des KindObjektes
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2018-10-02

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1137 der Datei OK.java.

1138  {
1139  Log.LogFunctionStartDebug( "SelectChild", "FN", FN );
1140 
1141  try
1142  {
1143  CO.setChildName( FN );
1144  }
1145  catch (Exception e)
1146  {
1147  this.handleException( e );
1148  }
1149  finally
1150  {
1151  Log.LogFunctionEndDebug();
1152  }
1153  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ SelectContext()

void okw.core.OK.SelectContext ( String  FN) throws Exception

Setzt den Context auf FN.

SelectContext() ist wie SelectWindow(String) zu verwenden. Der Unterschied zu SelectWindow(String) ist, dass SelectContext(String) keine Interaktionen, wie Existenzprüfung oder Fenster in den Vordergrund holen, auslöst. Technisch wird lediglich das Frame mit dem gegebenen Namen ausgewählt.

Beispiel:

EN.SelectContext( "Login" )
EN.SetValue("User", "MyUser")
EN.SetValue("Password", "MyPassword")
EN.ClickOn("OK")
Parameter
FNFunktionaler Name des Parentobjektes
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2018-10-02

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1158 der Datei OK.java.

1159  {
1160  Log.LogFunctionStartDebug( "OK.SelectContext", "FN", FN );
1161 
1162  try
1163  {
1164  CO.setWindowName( FN );
1165  }
1166  catch (Exception e)
1167  {
1168  this.handleException( e );
1169  }
1170  finally
1171  {
1172  Log.LogFunctionEndDebug( );
1173  }
1174  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ SelectMenu() [1/2]

void okw.core.OK.SelectMenu ( String  FN) throws Exception

Wählt den gegebenen Menü-Eintrag aus.

Beispiel: Wähle Menüeintrag mit Namen "MeinMenü":

Wähle Aus Menü: "MeinMenü"
Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014.09.19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1037 der Datei OK.java.

1038  {
1039  Log.LogFunctionStartDebug( "SelectMenu", "FN", FN );
1040 
1041  try
1042  {
1043  ( ( IGUIChildwindow ) CO.setChildName( FN ) ).SelectMenu();
1044  }
1045  catch (Exception e)
1046  {
1047  this.handleException( e );
1048  }
1049  finally
1050  {
1051  Log.LogFunctionEndDebug();
1052  }
1053  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:
+ Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

◆ SelectMenu() [2/2]

void okw.core.OK.SelectMenu ( String  FN,
String  Val 
) throws Exception

Wählt den gegebenen Menüeintrag aus.

Beispiel: Wähle Menüeintrag mit Namen "MeinMenü":

Wähle Aus Menü: "MeinMenü"
Parameter
FNFunktionaler Name des Objekts
ValSich ergebender Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014.09.19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1058 der Datei OK.java.

1059  {
1060  Log.LogFunctionStartDebug( "SelectMenu", "FN", FN, "Val", Val );
1061 
1062  try
1063  {
1064  if ( Val.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || Val.equals( "" ) )
1065  {
1066  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1067  // Print: "KeyWord was ignored!'"
1068  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1069  Log.LogPrint( lvsLM );
1070  }
1071  else
1072  {
1073  // If One of the Give OKW-Const-Values is contained in Val -> trigger OKWNotAllowedValueException
1074  this.newMethod( Val, "IGNORE" );
1075 
1076  ArrayList<String> lvlsValue = OKW_Const_Sngltn.getInstance().SplitSEP( Val );
1077 
1078  ( ( IGUIChildwindow ) CO.setChildName( FN ) ).SelectMenu( lvlsValue );
1079  }
1080  }
1081  catch (Exception e)
1082  {
1083  this.handleException( e );
1084  }
1085  finally
1086  {
1087  Log.LogFunctionEndDebug();
1088  }
1089  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ SelectTablecell()

void okw.core.OK.SelectTablecell ( String  FN,
String  COL,
String  ROW 
) throws Exception

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: 

Wähle aus Tabellenzelle: "MeineTabelle", "#2", "#5"

Beispiel 2: Auswahl der Zelle in erster Spalte mit Text "Toni" und Zeile mit dem Namen "Tester": 

Wähle aus Tabellenzelle: "MeineTabelle", "Toni", "Tester"

Beispiel 3: Auswahl der Zelle in erster Spalte mit Text "Toni" und Zeile 3:

Wähle aus Tabellenzelle: "MeineTabelle", "Toni", "#3"

Beispiel 4: Auswahl der Zelle in Spalte 1 und erster Zeile mit Text "42":

Wähle aus Tabellenzelle: "MeineTabelle", "#1", "42"
Parameter
FNFunktionaler Name des Objekts
COLSpaltennummer der zu wählenden Zelle, beginnend mit 1.
ROWZeilennummer der zu wählenden Zelle, beginnend mit 1.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1094 der Datei OK.java.

1095  {
1096  Log.LogFunctionStartDebug( "SelectTablecell", "FN", FN, "COL", COL, "ROW", ROW );
1097 
1098  try
1099  {
1100  ( ( IGUIChildwindow ) CO.setChildName( FN ) ).SelectTablecell( COL, ROW );
1101  }
1102  catch (Exception e)
1103  {
1104  this.handleException( e );
1105  }
1106  finally
1107  {
1108  Log.LogFunctionEndDebug();
1109  }
1110  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ SelectWindow()

void okw.core.OK.SelectWindow ( String  FN) throws Exception

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.

Noch zu erledigen:
zh: jnic die englische Beschreibung für Selectwindow anpassen.

Beispiel: Auswahl des Fensters mit dem Namen "MeinFenster": 

Wähle aus Fenster: "MeinFenster"
Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-19

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1115 der Datei OK.java.

1116  {
1117  Log.LogFunctionStartDebug( "OK.SelectWindow", "FN", FN );
1118 
1119  try
1120  {
1121  ( ( IGUIWindow ) CO.setWindowName( FN ) ).SelectWindow();
1122  }
1123  catch (Exception e)
1124  {
1125  this.handleException( e );
1126  }
1127  finally
1128  {
1129  Log.LogFunctionEndDebug( );
1130  }
1131  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ Sequence()

void okw.core.OK.Sequence ( String  FN,
String  SEQ_Name,
String  SEQ_ID 
) throws Exception

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:_ 

Sequenz: "Login", "Anmelden" = "Administrator"
Parameter
FNFunktionaler Name des Fensterobjekts, in der die Sequenz definiert ist.
fpsSequenceNameName der Sequenz, die aufgerufen werden soll.
SEQ_IDSequenz ID des Datensatzes, die als Eingabe verwendet werden soll.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1179 der Datei OK.java.

1180  {
1181  Log.LogFunctionStartDebug( "Sequence", "FN", FN, "SEQ_Name", SEQ_Name, "SEQ_ID", SEQ_ID );
1182 
1183  try
1184  {
1185  // Prüfen ob ignoriert werden muss...
1186  if ( SEQ_ID.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || "".equals( SEQ_ID ) )
1187  {
1188  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1189  // Print: "KeyWord was ignored!'"
1190  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1191  Log.LogPrint( lvsLM );
1192  }
1193  else
1194  {
1195  // If One of the Give OKW-Const-Values is contained in SEQ_ID -> trigger OKWNotAllowedValueException
1196  this.newMethod( SEQ_ID, "IGNORE", "DELETE" );
1197 
1198  CO.Sequence( FN, SEQ_Name, SEQ_ID );
1199  }
1200  }
1201  catch (Exception e)
1202  {
1203  this.handleException( e );
1204  }
1205  finally
1206  {
1207  Log.LogFunctionEndDebug();
1208  }
1209  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ SetFocus()

void okw.core.OK.SetFocus ( String  FN) throws Exception

Setzt den Fokus auf das gegebene Fensterobjekt.

Parameter
FNFunktionaler Name des Objekts
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1214 der Datei OK.java.

1215  {
1216  Log.LogFunctionStartDebug( "SetFocus", "FN", FN );
1217 
1218  try
1219  {
1220  ( ( IGUIChildwindow ) CO.setChildName( FN ) ).SetFocus();
1221  }
1222  catch (Exception e)
1223  {
1224  this.handleException( e );
1225  }
1226  finally
1227  {
1228  Log.LogFunctionEndDebug();
1229  }
1230  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ setLanguage()

void okw.core.OK.setLanguage ( String  Language)
Autor
Zoltán Hrabovszki
Datum
02.03.2013

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1238 der Datei OK.java.

1239  {
1240  CL.setLanguage( Language );
1241  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ SetValue()

void okw.core.OK.SetValue ( String  FN,
String  Val 
) throws Exception

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": 

Setze Wert: "Name", "Zoltan"
Parameter
FNFunktionaler Name des Objekts
ValSich ergebender Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1246 der Datei OK.java.

1247  {
1248  Log.LogFunctionStartDebug( "SetValue", "FN", FN );
1249 
1250  ArrayList<String> lvlsValue;
1251 
1252  try
1253  {
1254  // Prüfen ob ignoriert werden muss...
1255  if ( Val.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || Val.equals( "" ) )
1256  {
1257  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1258  // Print: "KeyWord was ignored!'"
1259  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1260  Log.LogPrint( lvsLM );
1261 
1262  }
1263  else
1264  {
1265  // If One of the Give OKW-Const-Values is contained in Val -> trigger OKWNotAllowedValueException
1266  this.newMethod( Val, "IGNORE" );
1267 
1268  lvlsValue = OKW_Const_Sngltn.getInstance().SplitSEP( Val );
1269 
1270  lvlsValue = Parser.ParseMe( lvlsValue );
1271 
1272  ( ( IGUIChildwindow ) CO.setChildName( FN ) ).SetValue( lvlsValue );
1273  }
1274  }
1275  catch (Exception e)
1276  {
1277  this.handleException( e );
1278  }
1279  finally
1280  {
1281  Log.LogFunctionEndDebug();
1282  }
1283  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ SetVar()

void okw.core.OK.SetVar ( String  VN,
String  Val 
) throws Exception

Setzt den Wert der gegebenen Variablen VN auf den gegebenen Wert Val.

Beispiel: Setze den Wert der Variablen "myVar" auf den Wert "myValue": 

EN.SetVar( "myVar", "myValue" )

Die Variable kann nun in den Schlüsselwörter Werten verwendet werden:

EN.SetValue( "myObject", "${myVar}" )
Parameter
VNName der Var, die du definieren möchtest
ValWert, der dem Var-Namen zuzuordnen ist.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2019-11-26

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1289 der Datei OK.java.

1290  {
1291  Log.LogFunctionStartDebug( "SetVar", "VN", VN );
1292 
1293  String lvsValue = "";
1294 
1295  try
1296  {
1297  lvsValue = Parser.ParseMe( Val );
1298  Log.LogPrint( VN + "= \"" + lvsValue + "\"" );
1299  OKW_Memorize_Sngltn.getInstance().set( VN, lvsValue );
1300  }
1301  catch (Exception e)
1302  {
1303  this.handleException( e );
1304  }
1305  finally
1306  {
1307  Log.LogFunctionEndDebug();
1308  }
1309  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ StartApp()

void okw.core.OK.StartApp ( String  AppName) throws Exception

Startet die gegebene Anwendung.

Beispiel: Befehl zum Starten der Anwendung "InternetExplorer": 

Starte Anwendung: "InternetExplorer"
Bemerkungen
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.
Parameter
fpsApplicationNameDer fachliche Name der Anwendung.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1315 der Datei OK.java.

1316  {
1317  Log.LogFunctionStartDebug( "StartApp", "AppName", AppName );
1318 
1319  try
1320  {
1321  ( ( IGUIWindow ) CO.setWindowName( AppName ) ).StartApp();
1322  }
1323  catch (Exception e)
1324  {
1325  this.handleException( e );
1326  }
1327  finally
1328  {
1329  Log.LogFunctionEndDebug();
1330  }
1331  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ StopApp()

void okw.core.OK.StopApp ( String  AppName) throws Exception

Beendet eine gegebene Anwendung.

Beispiel: Befehl zum Starten der Anwendung "InternetExplorer": 

Beende Anwendung: "InternetExplorer"
Bemerkungen
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.
Parameter
fpsApplicationNameDerf achliche Name der Anwendung
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1336 der Datei OK.java.

1337  {
1338  Log.LogFunctionStartDebug( "StopApp", "AppName", AppName );
1339 
1340  try
1341  {
1342  ( ( IGUIWindow ) CO.setWindowName( AppName ) ).StopApp();
1343  }
1344  catch (Exception e)
1345  {
1346  this.handleException( e );
1347  }
1348  finally
1349  {
1350  Log.LogFunctionEndDebug();
1351  }
1352  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ TypeKey()

void okw.core.OK.TypeKey ( String  FN,
String  Val 
) throws Exception

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":

Gib ein: "MeinFensterObjekt", "EingabeWert"

Beispiel "Eingabe einer Konstanten":

Gib ein: "MeinFensterObjekt", "{F2}"

Beispiel "Eingabe mehrerer Werte":

Gib ein: "MeinFensterObjekt", "Eingabewert1{SEP}Eingabewert2"
Parameter
FNFunktionaler Name des Objekts
ValSich ergebender Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21/jnic

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1357 der Datei OK.java.

1358  {
1359  Log.LogFunctionStartDebug( "TypeKey", "FN", FN, "Val", Val );
1360 
1361  ArrayList<String> lvlsValue;
1362 
1363  try
1364  {
1365  // Prüfen ob ignoriert werden muss...
1366  if ( Val.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || Val.equals( "" ) )
1367  {
1368  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1369  // Print: "KeyWord was ignored!'"
1370  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1371  Log.LogPrint( lvsLM );
1372  }
1373  else
1374  {
1375  // If One of the Give OKW-Const-Values is contained in Val -> trigger OKWNotAllowedValueException
1376  this.newMethod( Val, "IGNORE" );
1377 
1378  lvlsValue = OKW_Const_Sngltn.getInstance().SplitSEP( Val );
1379 
1380  lvlsValue = Parser.ParseMe( lvlsValue );
1381 
1382  ( ( IGUIChildwindow ) CO.setChildName( FN ) ).TypeKey( lvlsValue );
1383  }
1384  }
1385  catch (Exception e)
1386  {
1387  this.handleException( e );
1388  }
1389  finally
1390  {
1391  Log.LogFunctionEndDebug();
1392  }
1393  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ TypeKeyTablecell()

void okw.core.OK.TypeKeyTablecell ( String  FN,
String  COL,
String  ROW,
String  Val 
) throws Exception

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: 

Gib ein Tabellenzelle: "MeineTabelle", 2, 5, "Eingabewert"

Beispiel 2: Einfache Eingabe in Zelle an erster Spalte mit Text "Toni" und Zeile mit dem Namen "Tester": 

Gib ein Tabellenzelle: "MeineTabelle", "Toni", "Tester", "Eingabewert"

Beispiel 3: Einfache Eingabe in Zelle an erster Spalte mit Text "Toni" und Zeile 3: 

Gib ein Tabellenzelle: "MeineTabelle": "MeineTabelle", "Toni", 3, "Eingabewert"

Beispiel 4: Einfache Eingabe in Zelle an Spalte 1 und Zeile mit Namen "Adresse": 

Gib ein Tabellenzelle: "MeineTabelle", 1, "Adresse", "Eingabewert"

Beispiel 5: Eingabe der Konstanten "F2" in Zelle an Spalte 1 und Zeile 1: 

Gib ein Tabellenzelle: "MeineTabelle", 1, 1, "{F2}"

Beispiel 6: Eingabe mehrerer Werte in Zelle an erster Spalte mit Test "Ernie" und Zeile 3: 

Gib ein Tabellenzelle: "MeineTabelle", "Ernie", 3, "Wer1{SEP}Wert2"

Beispiel 7: Eingabe des Wertes "HiHo" in Zelle an Spalte 1 und erster Zeile mit Text "42": 

Gib ein Tabellenzelle: "MeineTabelle", "#1", "42", "HiHo"
Parameter
FNFunktionaler Name des Objekts
ValSich ergebender Wert
ROWZeilennummer der zu wählenden Zelle, beginnend mit 1.
COLSpaltennummer der zu wählenden Zelle, beginnend mit 1.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21/jnic

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1398 der Datei OK.java.

1399  {
1400  Log.LogFunctionStartDebug( "TypeKeyTablecell", "FN", FN, "COL", COL, "ROW", ROW, "Val", Val );
1401 
1402  ArrayList<String> lvlsValue;
1403 
1404  try
1405  {
1406  // Prüfen ob ignoriert werden muss...
1407  if ( Val.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || Val.equals( "" ) )
1408  {
1409  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1410  // Print: "KeyWord was ignored!'"
1411  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1412  Log.LogPrint( lvsLM );
1413  }
1414  else
1415  {
1416  // If One of the Give OKW-Const-Values is contained in Val -> trigger OKWNotAllowedValueException
1417  this.newMethod( Val, "IGNORE" );
1418 
1419  // Werte in Val separieren
1420  lvlsValue = OKW_Const_Sngltn.getInstance().SplitSEP( Val );
1421 
1422  lvlsValue = Parser.ParseMe( lvlsValue );
1423 
1424  ( ( IGUIChildwindow ) CO.setChildName( FN ) ).TypeKeyTablecell( COL, ROW, lvlsValue );
1425  }
1426  }
1427  catch (Exception e)
1428  {
1429  this.handleException( e );
1430  }
1431  finally
1432  {
1433  Log.LogFunctionEndDebug();
1434  }
1435  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ TypeKeyWindow()

void okw.core.OK.TypeKeyWindow ( String  FN,
String  Val 
) throws Exception

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: 

Gib ein Fenster: "MeinFensterObjekt", "EingabeWert"

Beispiel 2: Eingabe einer Konstanten: 

Gib ein Fenster: "MeinFensterObjekt", "{F2}"

_Beispiel 3: Eingabe mehrerer Werte:_Beispiel 

Gib ein Fenster: "MeinFensterObjekt", "Eingabewert1{SEP}Eingabewert2"
Parameter
FNFunktionaler Name des Objekts
ValEinzugebender gebender Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1440 der Datei OK.java.

1441  {
1442  Log.LogFunctionStartDebug( "TypeKeyWindow", "FN", FN, "Val", Val );
1443 
1444  try
1445  {
1446  // Prüfen ob ignoriert werden muss...
1447  if ( Val.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || Val.equals( "" ) )
1448  {
1449  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1450  // Print: "KeyWord was ignored!'"
1451  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1452  Log.LogPrint( lvsLM );
1453  }
1454  else
1455  {
1456  // If One of the Give OKW-Const-Values is contained in Val -> trigger OKWNotAllowedValueException
1457  this.newMethod( Val, "IGNORE" );
1458 
1459  ArrayList<String> lvlsValue = OKW_Const_Sngltn.getInstance().SplitSEP( Val );
1460  lvlsValue = Parser.ParseMe( lvlsValue );
1461 
1462  ( ( IGUIWindow ) CO.setWindowName( FN ) ).TypeKeyWindow( lvlsValue );
1463  }
1464  }
1465  catch (Exception e)
1466  {
1467  this.handleException( e );
1468  }
1469  finally
1470  {
1471  Log.LogFunctionEndDebug();
1472  }
1473  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ verify() [1/4]

ArrayList<String> okw.core.OK.verify ( OKW_TimeOut  timeout,
ArrayList< String >  fpALExpected,
Supplier< ArrayList< String >>  Method2Call 
)
private

Prüft ob der gegebene ArrayList<String> Wert "fpALExpected" innerhalb des Time Out "timeout" durch die gegebene Methode Method2Call gefunden wird.

Die Absicht dieser Methode ist nicht ein Soll/Ist vergleich, sondern das warten auf einen Werten, der sich einstellen sollte, wenn ein Testfall wie geplant abläuft. Der Soll-/Istvergleich wird in der jeweiligen okw.core.IOKW_State methode, die diese Methode ruft, durchgeführt.

Die Methode wird aus folgenden zwei Gründen beendet:

  1. der erwartet Wert fpALExpected wurde gefunden
  2. der Time Out timeout ist erreicht
Siehe auch
https://www.codementor.io/eh3rrera/using-java-8-method-reference-du10866vx
Parameter
timeoutEnthält die Timeout Daten.
fpALExpectedErwarteter Wert, der sich einstellen sollte.
Method2CallFunctions Referenz auf die aufzurufende Methode
Rückgabe
Liefert den gefundenen aktuellen Wert zurück.
Autor
Zoltán Hrabovszki
Datum
2014-01-09

Definiert in Zeile 2524 der Datei OK.java.

2525  {
2526  Integer Count = 0;
2527 
2528  ArrayList<String> lvLsReturn = null;
2529  Boolean bOK = false;
2530 
2531  Log.LogFunctionStartDebug( "verify", "timeout", timeout.toString(), "ArrayList<String> fpALExpected", fpALExpected.toString() );
2532 
2533  try
2534  {
2535  Count = 0;
2536 
2537  while ( Count < timeout.getMaxCount() )
2538  {
2539  lvLsReturn = Method2Call.get();
2540 
2541  if ( fpALExpected.equals( lvLsReturn ) )
2542  {
2543  break;
2544  }
2545  else
2546  {
2547  Thread.sleep( timeout.getPT() );
2548  }
2549 
2550  Count++;
2551  }
2552 
2553  bOK = true;
2554  }
2555  catch (IllegalArgumentException e)
2556  {
2557  throw new RuntimeException( e );
2558  }
2559  catch (InterruptedException e)
2560  {
2561  throw new RuntimeException( e );
2562  }
2563  finally
2564  {
2565  if ( bOK )
2566  {
2567  Log.LogFunctionEndDebug( lvLsReturn );
2568  }
2569  else
2570  {
2571  Log.LogFunctionEndDebug();
2572  }
2573  }
2574  return lvLsReturn;
2575  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ verify() [2/4]

Boolean okw.core.OK.verify ( OKW_TimeOut  timeout,
Boolean  fpbExpected,
Supplier< Boolean >  Method2Call 
)
private

Prüft ob der gegebene boolische Wert "fpbExpected" innerhalb des Time Out "timeout" durch die gegebene Methode Method2Call gefunden wird.

Die Absicht dieser Methode ist nicht ein Soll/Ist vergleich, sondern das warten auf einen Werten, der sich einstellen sollte, wenn ein Testfall wie geplant abläuft. Der Soll-/Istvergleich wird in der jeweiligen okw.core.IOKW_State methode, die diese Methode ruft, durchgeführt.

Die Methode wird aus folgenden zwei Gründen beendet:

  1. der erwartet Wert fpbExpected wurde gefunden
  2. der Time Out timeout ist erreicht
Siehe auch
https://www.codementor.io/eh3rrera/using-java-8-method-reference-du10866vx
Parameter
timeoutEnthält die Timeout Daten.
fpbExpectedErwarteter Wert, der sich einstellen sollte.
Method2CallFunctions Referenz auf die aufzurufende Methode
Rückgabe
Liefert den gefundenen aktuellen Wert zurück.
Autor
Zoltán Hrabovszki
Datum
2014-01-09

Definiert in Zeile 2215 der Datei OK.java.

2216  {
2217  Integer Count = 0;
2218 
2219  Boolean lvbReturn = false;
2220  Boolean bOK = false;
2221 
2222  Log.LogFunctionStartDebug( "verify", "timeout", timeout.toString(), "fpbExpected", fpbExpected.toString() );
2223 
2224  try
2225  {
2226  Count = 0;
2227 
2228  while ( Count < timeout.getMaxCount() )
2229  {
2230  lvbReturn = Method2Call.get();
2231 
2232  if ( fpbExpected.equals( lvbReturn ) )
2233  {
2234  break;
2235  }
2236  else
2237  {
2238  Thread.sleep( timeout.getPT() );
2239  }
2240  Count++;
2241  }
2242  bOK = true;
2243  }
2244  catch (IllegalArgumentException | InterruptedException e)
2245  {
2246  throw new RuntimeException( e );
2247  }
2248  finally
2249  {
2250  if ( bOK )
2251  {
2252  Log.LogFunctionEndDebug( lvbReturn );
2253  }
2254  else
2255  {
2256  Log.LogFunctionEndDebug();
2257  }
2258  }
2259  return lvbReturn;
2260  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:
+ Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

◆ verify() [3/4]

Integer okw.core.OK.verify ( OKW_TimeOut  timeout,
Integer  fpiExpected,
Supplier< Integer >  Method2Call 
)
private

Prüft ob der gegebene integer Wert "fpiExpected" innerhalb des Time Out "timeout" durch die gegebene Methode Method2Call gefunden wird.

Die Absicht dieser Methode ist nicht ein Soll/Ist vergleich, sondern das warten auf einen Werten, der sich einstellen sollte, wenn ein Testfall wie geplant abläuft. Der Soll-/Istvergleich wird in der jeweiligen okw.core.IOKW_State methode, die diese Methode ruft, durchgeführt.

Die Methode wird aus folgenden zwei Gründen beendet:

  1. der erwartet Wert fpiExpected wurde gefunden
  2. der Time Out timeout ist erreicht
Siehe auch
https://www.codementor.io/eh3rrera/using-java-8-method-reference-du10866vx
Parameter
timeoutEnthält die Timeout Daten.
fpiExpectedErwarteter Wert, der sich einstellen sollte.
Method2CallFunctions Referenz auf die aufzurufende Methode
Rückgabe
Liefert den gefundenen aktuellen Wert zurück.
Autor
Zoltán Hrabovszki
Datum
2014-01-09

Definiert in Zeile 2288 der Datei OK.java.

2289  {
2290  Integer Count = 0;
2291 
2292  Integer lviReturn = 0;
2293  Boolean bOK = false;
2294 
2295  //Log.LogFunctionStartDebug( "Verify", "String", "OKW_TimeOut", timeout.toString(), "fpbExpected", fpbExpected.toString() );
2296 
2297  Log.LogFunctionStartDebug( "verify", "timeout", timeout.toString(), "fpbExpected", fpiExpected.toString() );
2298 
2299  try
2300  {
2301  Count = 0;
2302 
2303  while ( Count < timeout.getMaxCount() )
2304  {
2305  lviReturn = Method2Call.get();
2306 
2307  if ( fpiExpected == lviReturn )
2308  {
2309  break;
2310  }
2311  else
2312  {
2313  Thread.sleep( timeout.getPT() );
2314  }
2315  Count++;
2316  }
2317 
2318  bOK = true;
2319  }
2320  catch (IllegalArgumentException | InterruptedException e)
2321  {
2322  throw new RuntimeException( e );
2323  }
2324  finally
2325  {
2326  if ( bOK )
2327  {
2328  Log.LogFunctionEndDebug( lviReturn.toString() );
2329  }
2330  else
2331  {
2332  Log.LogFunctionEndDebug();
2333  }
2334  }
2335  return lviReturn;
2336  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ verify() [4/4]

ArrayList<String> okw.core.OK.verify ( OKW_TimeOut  timeout,
String  COL,
String  ROW,
ArrayList< String >  fpALExpected,
BiFunction< String, String, ArrayList< String >>  Method2Call 
)
private
Siehe auch
https://www.codementor.io/eh3rrera/using-java-8-method-reference-du10866vx
Parameter
timeoutEntält Timeout Daten.
fpALExpectedErwaretetr Wert
Method2CallFunctions eferenz auf die aufzurufende Methode
Rückgabe

Definiert in Zeile 2348 der Datei OK.java.

2349  {
2350  Integer Count = 0;
2351 
2352  ArrayList<String> lvLsReturn = null;
2353 
2354  Log.LogFunctionStartDebug( "Verify", "timeout", timeout.toString(), "COL", COL, "ROW", ROW, "ArrayList<String> fpALExpected", fpALExpected.toString() );
2355 
2356  try
2357  {
2358  Count = 0;
2359 
2360  while ( Count < timeout.getMaxCount() )
2361  {
2362  lvLsReturn = Method2Call.apply( COL, ROW );
2363 
2364  if ( fpALExpected.equals( lvLsReturn ) )
2365  {
2366  break;
2367  }
2368  else
2369  {
2370  Thread.sleep( timeout.getPT() );
2371  }
2372 
2373  Count++;
2374  }
2375  }
2376  catch (IllegalArgumentException e)
2377  {
2378  throw new RuntimeException( e );
2379  }
2380  catch (InterruptedException e)
2381  {
2382  throw new RuntimeException( e );
2383  }
2384  finally
2385  {
2386  Log.LogFunctionEndDebug( lvLsReturn );
2387  }
2388  return lvLsReturn;
2389  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyBadge()

void okw.core.OK.VerifyBadge ( String  FN,
String  ExpVal 
) throws Exception

Überprüft den Badge des Objektes .

Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
Daniel Krüger
Datum
2019-04-04

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1478 der Datei OK.java.

1479  {
1480 
1481  ArrayList<String> lvlsExpected = null;
1482  ArrayList<String> Actual = null;
1483  Log.LogFunctionStartDebug( "VerifyBadge", "FN", FN, "ExpVal", ExpVal );
1484 
1485  try
1486  {
1487  // Prüfen ob ignoriert werden muss...
1488  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
1489  {
1490  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1491  // Print: "KeyWord was ignored!'"
1492  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1493  Log.LogPrint( lvsLM );
1494  }
1495  else
1496  {
1497  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
1498  this.newMethod( ExpVal, "IGNORE", "DELETE" );
1499 
1500  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
1501  {
1502  lvlsExpected = new ArrayList<String>();
1503  lvlsExpected.add( "" );
1504  }
1505  else
1506  {
1507  // Split giveneExpected Value
1508  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
1509  lvlsExpected = Parser.ParseMe( lvlsExpected );
1510  }
1511 
1512  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
1513 
1514  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
1515  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyBadge_TO(), myOKW.VerifyBadge_PT() );
1516 
1517  Actual = verify( TimeOut, lvlsExpected, () ->
1518  {
1519  return MyObject.VerifyBadge();
1520  } );
1521  verification( Actual, lvlsExpected );
1522  }
1523  }
1524  catch (Exception e)
1525  {
1526  this.handleException( e );
1527  }
1528  finally
1529  {
1530  Log.LogFunctionEndDebug();
1531  }
1532  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyBadgeREGX()

void okw.core.OK.VerifyBadgeREGX ( String  FN,
String  ExpVal 
) throws Exception

Überprüft den Badge des Objektes .

Mit RegulererAusdruck

Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
Daniel Krüger
Datum
2019-04-04

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1599 der Datei OK.java.

1600  {
1601 
1602  ArrayList<String> lvlsExpected = null;
1603  ArrayList<String> Actual = null;
1604 
1605  Log.LogFunctionStartDebug( "VerifyBadgeREGX", "FN", FN, "fpsExpected", ExpVal );
1606 
1607  try
1608  {
1609  // Prüfen ob ignoriert werden muss...
1610  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
1611  {
1612  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1613  // Print: "KeyWord was ignored!'"
1614  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1615  Log.LogPrint( lvsLM );
1616  }
1617  else
1618  {
1619  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
1620  this.newMethod( ExpVal, "IGNORE", "DELETE" );
1621 
1622  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
1623  {
1624  lvlsExpected = new ArrayList<String>();
1625  lvlsExpected.add( "" );
1626  }
1627  else
1628  {
1629  // Split giveneExpected Value
1630  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
1631  lvlsExpected = Parser.ParseMe( lvlsExpected );
1632  }
1633 
1634  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
1635 
1636  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
1637  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyBadge_TO(), myOKW.VerifyBadge_PT() );
1638 
1639  Actual = verifyREGX( TimeOut, lvlsExpected, () ->
1640  {
1641  return MyObject.VerifyBadge();
1642  } );
1643 
1644  verificationREGX( Actual, lvlsExpected );
1645  }
1646  }
1647  catch (Exception e)
1648  {
1649  this.handleException( e );
1650  }
1651  finally
1652  {
1653  Log.LogFunctionEndDebug();
1654  }
1655  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyBadgeWCM()

void okw.core.OK.VerifyBadgeWCM ( String  FN,
String  ExpVal 
) throws Exception

Überprüft den Badge des Objektes .

Mit Wildcard-Match

Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
Daniel Krüger
Datum
2019-04-04

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1537 der Datei OK.java.

1538  {
1539 
1540  ArrayList<String> lvlsExpected = null;
1541  ArrayList<String> Actual = null;
1542 
1543  Log.LogFunctionStartDebug( "VerifyBadgeWCM", "FN", FN, "fpsExpected", ExpVal );
1544 
1545  try
1546  {
1547  // Prüfen ob ignoriert werden muss...
1548  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
1549  {
1550  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1551  // Print: "KeyWord was ignored!'"
1552  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1553  Log.LogPrint( lvsLM );
1554 
1555  }
1556  else
1557  {
1558  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
1559  this.newMethod( ExpVal, "IGNORE", "DELETE" );
1560 
1561  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
1562  {
1563  lvlsExpected = new ArrayList<String>();
1564  lvlsExpected.add( "" );
1565  }
1566  else
1567  {
1568  // Split giveneExpected Value
1569  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
1570  lvlsExpected = Parser.ParseMe( lvlsExpected );
1571  }
1572 
1573  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
1574 
1575  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
1576  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyBadge_TO(), myOKW.VerifyBadge_PT() );
1577 
1578  Actual = verifyWCM( TimeOut, lvlsExpected, () ->
1579  {
1580  return MyObject.VerifyBadge();
1581  } );
1582 
1583  verificationWCM( Actual, lvlsExpected );
1584  }
1585  }
1586  catch (Exception e)
1587  {
1588  this.handleException( e );
1589  }
1590  finally
1591  {
1592  Log.LogFunctionEndDebug();
1593  }
1594  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyCaption()

void okw.core.OK.VerifyCaption ( String  FN,
String  ExpVal 
) throws Exception

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: 

Prüfe Wert: "MeinObjekt", "Django"

Dieses Schlüsselwort prüft die exakte Übereinstimmung. Wildkards sind nicht möglich.

Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1660 der Datei OK.java.

1661  {
1662 
1663  ArrayList<String> lvlsExpected = null;
1664  ArrayList<String> Actual = null;
1665 
1666  Log.LogFunctionStartDebug( "VerifyCaption", "FN", FN, "fpsExpected", ExpVal );
1667 
1668  try
1669  {
1670  // Prüfen ob ignoriert werden muss...
1671  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || "".equals( ExpVal ) )
1672  {
1673  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1674  // Print: "KeyWord was ignored!'"
1675  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1676  Log.LogPrint( lvsLM );
1677  }
1678  else
1679  {
1680  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
1681  this.newMethod( ExpVal, "IGNORE", "DELETE" );
1682 
1683  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
1684  {
1685  lvlsExpected = new ArrayList<String>();
1686  lvlsExpected.add( "" );
1687  }
1688  else
1689  {
1690  // Split giveneExpected Value
1691  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
1692  lvlsExpected = Parser.ParseMe( lvlsExpected );
1693  }
1694  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
1695 
1696  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
1697  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyCaption_TO(), myOKW.VerifyCaption_PT() );
1698 
1699  Actual = verify( TimeOut, lvlsExpected, () ->
1700  {
1701  return MyObject.VerifyCaption();
1702  } );
1703  verification( Actual, lvlsExpected );
1704  }
1705  }
1706  catch (Exception e)
1707  {
1708  this.handleException( e );
1709  }
1710  finally
1711  {
1712  Log.LogFunctionEndDebug();
1713  }
1714  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyCaptionREGX()

void okw.core.OK.VerifyCaptionREGX ( String  FN,
String  ExpVal 
) throws Exception

Überprüft die Überschrift eines Objektes, Reguläre-Ausdrücke als Sollwert sind erlaubt.

Beispiel: Prüfe, ob der Wert (Text) des Objekts "MeinObjekt" mit dem erwarteten Wert "Django" begint:

EN.VerifyCaptionREGX( "MeinObjekt", "^Django.*" )
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1780 der Datei OK.java.

1781  {
1782 
1783  ArrayList<String> lvlsExpected = null;
1784  ArrayList<String> Actual = null;
1785 
1786  Log.LogFunctionStartDebug( "VerifyCaptionREGX", "FN", FN, "fpsExpected", ExpVal );
1787 
1788  try
1789  {
1790  // Prüfen ob ignoriert werden muss...
1791  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
1792  {
1793  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1794  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1795  Log.LogPrint( lvsLM );
1796  }
1797  else
1798  {
1799  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
1800  this.newMethod( ExpVal, "IGNORE", "DELETE" );
1801 
1802  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
1803  {
1804 
1805  lvlsExpected = new ArrayList<String>();
1806  lvlsExpected.add( "" );
1807  }
1808  else
1809  {
1810  // Split giveneExpected Value
1811  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
1812  lvlsExpected = Parser.ParseMe( lvlsExpected );
1813  }
1814 
1815  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
1816 
1817  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
1818  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyCaption_TO(), myOKW.VerifyCaption_PT() );
1819 
1820  Actual = verifyREGX( TimeOut, lvlsExpected, () ->
1821  {
1822  return MyObject.VerifyCaption();
1823  } );
1824  verificationREGX( Actual, lvlsExpected );
1825 
1826  }
1827  }
1828  catch (Exception e)
1829  {
1830  this.handleException( e );
1831  }
1832  finally
1833  {
1834  Log.LogFunctionEndDebug();
1835  }
1836  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyCaptionWCM()

void okw.core.OK.VerifyCaptionWCM ( String  FN,
String  ExpVal 
) throws Exception

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: 
PrüfeWertWCM( "MeinObjekt", "$Django" )
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert / Sollwert.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1719 der Datei OK.java.

1720  {
1721 
1722  ArrayList<String> lvlsExpected = null;
1723  ArrayList<String> Actual = null;
1724 
1725  Log.LogFunctionStartDebug( "VerifyCaptionWCM", "FN", FN, "fpsExpected", ExpVal );
1726 
1727  try
1728  {
1729  // Prüfen ob ignoriert werden muss...
1730  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
1731  {
1732  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1733  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1734  Log.LogPrint( lvsLM );
1735  }
1736  else
1737  {
1738  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
1739  this.newMethod( ExpVal, "IGNORE", "DELETE" );
1740 
1741  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
1742  {
1743 
1744  lvlsExpected = new ArrayList<String>();
1745  lvlsExpected.add( "" );
1746  }
1747  else
1748  {
1749  // Split giveneExpected Value
1750  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
1751  lvlsExpected = Parser.ParseMe( lvlsExpected );
1752  }
1753 
1754  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
1755 
1756  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
1757  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyCaption_TO(), myOKW.VerifyCaption_PT() );
1758 
1759  Actual = verifyWCM( TimeOut, lvlsExpected, () ->
1760  {
1761  return MyObject.VerifyCaption();
1762  } );
1763 
1764  verificationWCM( Actual, lvlsExpected );
1765  }
1766  }
1767  catch (Exception e)
1768  {
1769  this.handleException( e );
1770  }
1771  finally
1772  {
1773  Log.LogFunctionEndDebug();
1774  }
1775  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyDirectoryExists()

void okw.core.OK.VerifyDirectoryExists ( String  fpsPath,
String  ExpVal 
) throws Exception

Prüft, ob das gegebene Verzeichnis existiert.

Parameter
fpsPathAPfad des Verzeichnisses, die Geprüft werden soll
ExpValErwarteter Wert. Möglich Werte sind: "JA"/"NEIN"/"${IGNORIERE}"
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2015-06-26

Implementiert okw.core.IOKW_State.

Definiert in Zeile 4263 der Datei OK.java.

4264  {
4265  String lvsPath = "";
4266 
4267  Log.LogFunctionStartDebug( "VerifyDirectoryExists", "fpsPath", fpsPath, "ExpVal", ExpVal );
4268  try
4269  {
4270  // Prüfen ob ignoriert werden muss...
4271  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
4272  {
4273  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
4274  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
4275  Log.LogPrint( lvsLM );
4276  }
4277  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
4278  else if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetConst4Internalname( "YES" ) )
4279  || ExpVal.equals( OKW_Const_Sngltn.getInstance().GetConst4Internalname( "NO" )) )
4280  {
4281  // Aktuellen Wert holen...
4282 
4283  // 1. Parsen der Pfad-Eingabe
4284  lvsPath = Parser.ParseMe( fpsPath );
4285  // 2. Konvertieren des Pfad separators.
4286  lvsPath = OKW_FileHelper.convertDirectorySeperator( lvsPath );
4287 
4288  String lsvLog = PROP.getProperty( "ok.VerifyDirectoryExists.ResolvedPath.${LANGUAGE}", lvsPath );
4289  Log.LogPrint( lsvLog );
4290 
4291  // Basis-Funkton aufrufen...
4292  Boolean lvbActual = OKW_FileHelper.directoryExists( lvsPath );
4293 
4294  // Aktuellen Wert nach YES/NO, Sprachabhänging, wandel...
4295  String lvsActual = OKW_Const_Sngltn.getInstance().Boolean2YesNo( lvbActual );
4296 
4297  verification( lvsActual, ExpVal );
4298  }
4299  else
4300  {
4301  // Both conditions are not fulfilled: An exception must be thrown since no other value is allowed here.
4302  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.YesNoIgnore.${LANGUAGE}", ExpVal );
4303  throw new OKWNotAllowedValueException( lvsLM );
4304  }
4305  }
4306  catch (Exception e)
4307  {
4308  this.handleException( e );
4309  }
4310  finally
4311  {
4312  Log.LogFunctionEndDebug();
4313  }
4314  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyErrorMSG()

void okw.core.OK.VerifyErrorMSG ( String  FN,
String  ExpVal 
) throws Exception

Überprüft Fehlermeldungen in mit Angular validierten Formularen.

Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
Daniel Krüger
Datum
2019-05-28

Implementiert okw.core.IOKW_State.

Definiert in Zeile 4388 der Datei OK.java.

4389  {
4390 
4391  ArrayList<String> lvlsExpected = null;
4392  ArrayList<String> Actual = null;
4393  Log.LogFunctionStartDebug( "VerifyErrorMSG", "FN", FN, "ExpVal", ExpVal );
4394 
4395  try
4396  {
4397  // Prüfen ob ignoriert werden muss...
4398  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
4399  {
4400  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
4401  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
4402  Log.LogPrint( lvsLM );
4403  }
4404  else
4405  {
4406  // If One of the given OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
4407  this.newMethod( ExpVal, "IGNORE", "DELETE" );
4408 
4409  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
4410  {
4411  lvlsExpected = new ArrayList<String>();
4412  lvlsExpected.add( "" );
4413  }
4414  else
4415  {
4416  // Split giveneExpected Value
4417  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
4418  lvlsExpected = Parser.ParseMe( lvlsExpected );
4419  }
4420 
4421  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
4422 
4423  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
4424  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyErrorMSG_TO(), myOKW.VerifyErrorMSG_PT() );
4425 
4426  Actual = verify( TimeOut, lvlsExpected, () ->
4427  {
4428  return MyObject.VerifyErrorMSG();
4429  } );
4430  verification( Actual, lvlsExpected );
4431  }
4432  }
4433  catch (Exception e)
4434  {
4435  this.handleException( e );
4436  }
4437  finally
4438  {
4439  Log.LogFunctionEndDebug();
4440  }
4441  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyErrorMSG_REGX()

void okw.core.OK.VerifyErrorMSG_REGX ( String  FN,
String  ExpVal 
) throws Exception

Überprüft Fehlermeldungen in mit Angular validierten Formularen.

Reguläre aus drücke als sollwert sind erlaubt.

Beispiel: Prüfe, ob der Wert (Text) des Objekts "MeinObjekt" dem erwarteten Wert "\\.jango" entspricht: 

PrüfeWertREGX: "MeinObjekt", "$Django"
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 4506 der Datei OK.java.

4507  {
4508 
4509  ArrayList<String> lvlsExpected = null;
4510  ArrayList<String> Actual = null;
4511 
4512  Log.LogFunctionStartDebug( "VerifyErrorMSG_REGX", "FN", FN, "fpsExpected", ExpVal );
4513 
4514  try
4515  {
4516  // Prüfen ob ignoriert werden muss...
4517  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
4518  {
4519  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
4520  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
4521  Log.LogPrint( lvsLM );
4522  }
4523  else
4524  {
4525  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
4526  this.newMethod( ExpVal, "IGNORE", "DELETE" );
4527 
4528  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
4529  {
4530  lvlsExpected = new ArrayList<String>();
4531  lvlsExpected.add( "" );
4532  }
4533  else
4534  {
4535  // Split giveneExpected Value
4536  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
4537  lvlsExpected = Parser.ParseMe( lvlsExpected );
4538  }
4539 
4540  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
4541 
4542  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
4543  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyErrorMSG_TO(), myOKW.VerifyErrorMSG_PT() );
4544 
4545  Actual = verifyREGX( TimeOut, lvlsExpected, () ->
4546  {
4547  return MyObject.VerifyErrorMSG();
4548  } );
4549 
4550  verificationREGX( Actual, lvlsExpected );
4551  }
4552  }
4553  catch (Exception e)
4554  {
4555  this.handleException( e );
4556  }
4557  finally
4558  {
4559  Log.LogFunctionEndDebug();
4560  }
4561  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyErrorMSG_WCM()

void okw.core.OK.VerifyErrorMSG_WCM ( String  FN,
String  ExpVal 
) throws Exception

Überprüft Fehlermeldungen in mit Angular validierten Formularen.

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:
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 4446 der Datei OK.java.

4447  {
4448 
4449  ArrayList<String> lvlsExpected = null;
4450  ArrayList<String> Actual = null;
4451 
4452  Log.LogFunctionStartDebug( "VerifyErrorMSG_WCM", "FN", FN, "fpsExpected", ExpVal );
4453 
4454  try
4455  {
4456  // Prüfen ob ignoriert werden muss...
4457  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
4458  {
4459  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
4460  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
4461  Log.LogPrint( lvsLM );
4462  }
4463  else
4464  {
4465  // If One of the given OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
4466  this.newMethod( ExpVal, "IGNORE", "DELETE" );
4467 
4468  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
4469  {
4470  lvlsExpected = new ArrayList<String>();
4471  lvlsExpected.add( "" );
4472  }
4473  else
4474  {
4475  // Split giveneExpected Value
4476  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
4477  lvlsExpected = Parser.ParseMe( lvlsExpected );
4478  }
4479 
4480  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
4481 
4482  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
4483  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyErrorMSG_TO(), myOKW.VerifyErrorMSG_PT() );
4484 
4485  Actual = verifyWCM( TimeOut, lvlsExpected, () ->
4486  {
4487  return MyObject.VerifyErrorMSG();
4488  } );
4489 
4490  verificationWCM( Actual, lvlsExpected );
4491  }
4492  }
4493  catch (Exception e)
4494  {
4495  this.handleException( e );
4496  }
4497  finally
4498  {
4499  Log.LogFunctionEndDebug();
4500  }
4501  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyExists()

void okw.core.OK.VerifyExists ( String  FN,
String  ExpVal 
) throws Exception

Prüft, ob das gegebene Objekt existiert.

Beispiel 1: Prüfe, ob das Objekt "MeinObjekt" existiert: 

Prüfe Existiert: "MeinObjekt", "JA"

_Beispiel 2: Prüfe, ob das Objekt "MeinObjekt" nicht existiert: 

Prüfe Existiert: "MeinObjekt", "NEIN"
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1841 der Datei OK.java.

1842  {
1843 
1844  Log.LogFunctionStartDebug( "VerifyExists", "FN", FN, "ExpVal", ExpVal );
1845 
1846  try
1847  {
1848  // Only three values are possible here: YES/NO/IGNORE
1849  // 1. check if you need to ignore...
1850  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
1851  {
1852  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1853  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1854  Log.LogPrint( lvsLM );
1855  }
1856  else
1857  { // 2. Dann den wert durch den Parser laufenlassen, danach darf nur Nun darf nur ...
1858  String lvsExpected = Parser.ParseMe( ExpVal );
1859 
1860  if ( lvsExpected.equals( OKW_Const_Sngltn.getInstance().GetConst4Internalname( "YES" ) )
1861  || lvsExpected.equals( OKW_Const_Sngltn.getInstance().GetConst4Internalname( "NO" ) ) )
1862  {
1863  Boolean lvbExpectedValue = OKW_Const_Sngltn.getInstance().YesNo2Boolean( lvsExpected );
1864 
1865  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
1866 
1867  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
1868  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyExists_TO(), myOKW.VerifyExists_PT() );
1869 
1870  Boolean lvbActual = verify( TimeOut, lvbExpectedValue, () ->
1871  {
1872  return MyObject.VerifyExists();
1873  } );
1874 
1875  String lvsActual = OKW_Const_Sngltn.getInstance().Boolean2YesNo( lvbActual );
1876 
1877  verification( lvsActual, lvsExpected );
1878  }
1879  else
1880  {
1881  // Both conditions are not fulfilled: An exception must be thrown since no other value is allowed here.
1882  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.YesNoIgnore.${LANGUAGE}", ExpVal );
1883  throw new OKWNotAllowedValueException( lvsLM );
1884  }
1885  }
1886  }
1887  catch (Exception e)
1888  {
1889  this.handleException( e );
1890  }
1891  finally
1892  {
1893  Log.LogFunctionEndDebug();
1894  }
1895  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyFileExists()

void okw.core.OK.VerifyFileExists ( String  fpsPathAndFileName,
String  ExpVal 
) throws Exception

Prüft, ob die gegebene Datei existiert.

Parameter
fpsPathAndFileNamePfad und Name der Datei, die Geprüft werden soll
ExpValErwarteter Wert. Möglich Werte sind: "JA"/"NEIN"/"${IGNORIERE}"
Ausnahmebehandlung
OKWFileDoesNotExistsExceptionWenn die gegeben Datei ein Verzeichniss ist, also eben keine Datei, dann wird ein OKWFileDoesNotExistsException ausgelöst.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2015-06-26

Implementiert okw.core.IOKW_State.

Definiert in Zeile 4093 der Datei OK.java.

4094  {
4095  String lvsPathAndFileName = "";
4096 
4097  Log.LogFunctionStartDebug( "VerifyFileExist", "fpsPathAndFileName", fpsPathAndFileName, "ExpVal", ExpVal );
4098  try
4099  {
4100  // Prüfen ob ignoriert werden muss...
4101  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
4102  {
4103  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
4104  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
4105  Log.LogPrint( lvsLM );
4106  }
4107  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
4108  else if ( ExpVal.equals(OKW_Const_Sngltn.getInstance().GetConst4Internalname( "YES" ) )
4109  || ExpVal.equals( OKW_Const_Sngltn.getInstance().GetConst4Internalname( "NO" ) ) )
4110  {
4111  // Aktuellen Wert holen...
4112 
4113  // 1. Parsen der Pfad-Eingabe
4114  lvsPathAndFileName = Parser.ParseMe( fpsPathAndFileName );
4115  // 2. Konvertieren des Pfad separators.
4116  lvsPathAndFileName = OKW_FileHelper.convertDirectorySeperator( lvsPathAndFileName );
4117 
4118  String lsvLog = PROP.getProperty( "ok.VerifyFileExists.ResolvedPath.${LANGUAGE}", lvsPathAndFileName );
4119  Log.LogPrint( lsvLog );
4120 
4121  // Basis-Funkton aufrufen...
4122  Boolean lvbActual = OKW_FileHelper.fileExists( lvsPathAndFileName );
4123 
4124  // Aktuellen Wert nach YES/NO, Sprachabhänging, wandel...
4125  String lvsActual = OKW_Const_Sngltn.getInstance().Boolean2YesNo( lvbActual );
4126 
4127  verification( lvsActual, ExpVal );
4128  }
4129  else
4130  {
4131  // Both conditions are not fulfilled: An exception must be thrown since no other value is allowed here.
4132  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.YesNoIgnore.${LANGUAGE}", ExpVal );
4133  throw new OKWNotAllowedValueException( lvsLM );
4134  }
4135  }
4136  catch (Exception e)
4137  {
4138  this.handleException( e );
4139  }
4140  finally
4141  {
4142  Log.LogFunctionEndDebug();
4143  }
4144  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyHasFocus()

void okw.core.OK.VerifyHasFocus ( String  FN,
String  ExpVal 
) throws Exception

Vergleicht den Fokus-Zustand des gegebenen Objekts mit dem erwarteten Wert.

Beispiel 1: Prüfe, ob das Objekt "MeinObjekt" den Fokus besitzt: 

Prüfe Hat Fokus: "MeinObjekt", "JA"

Beispiel 2: Prüfe, ob das Objekt "MeinObjekt" den Fokus NICHT besitzt: 

Prüfe Hat Fokus: "MeinObjekt", "NEIN"
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert. Erlaubte Werte sind: "JA", "NEIN" und "IGNORIEREN".
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 1900 der Datei OK.java.

1901  {
1902 
1903  Log.LogFunctionStartDebug( "VerifyHasFocus", "FN", FN, "ExpVal", ExpVal );
1904 
1905  try
1906  {
1907  // Hier sind nur drei Werte erlaubt: YES/NO/IGNORE
1908  // Prüfen ob ignoriert werden muss...
1909  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
1910  {
1911  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1912  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
1913  Log.LogPrint( lvsLM );
1914  }
1915  else
1916  {
1917  String lvsExpected = Parser.ParseMe( ExpVal );
1918 
1919  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
1920  if ( lvsExpected.equals( OKW_Const_Sngltn.getInstance().GetConst4Internalname( "YES" ) )
1921  || lvsExpected.equals( OKW_Const_Sngltn.getInstance().GetConst4Internalname( "NO" ) ) )
1922  {
1923 
1924  // Sprachabhängiges YES/NO nach Boolean transformieren
1925  Boolean lvbExpectedValue = OKW_Const_Sngltn.getInstance().YesNo2Boolean( lvsExpected );
1926 
1927  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
1928 
1929  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
1930  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyHasFocus_TO(), myOKW.VerifyHasFocus_PT() );
1931 
1932  Boolean lvbActual = verify( TimeOut, lvbExpectedValue, () ->
1933  {
1934  return MyObject.VerifyHasFocus();
1935  } );
1936 
1937  String lvsActual = OKW_Const_Sngltn.getInstance().Boolean2YesNo( lvbActual );
1938 
1939  verification( lvsActual, lvsExpected );
1940  }
1941  else
1942  {
1943  // Both conditions are not fulfilled: An exception must be thrown since no other value is allowed here.
1944  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.YesNoIgnore.${LANGUAGE}", ExpVal );
1945  throw new OKWNotAllowedValueException( lvsLM );
1946  }
1947  }
1948  }
1949  catch (Exception e)
1950  {
1951  this.handleException( e );
1952  }
1953  finally
1954  {
1955  Log.LogFunctionEndDebug();
1956  }
1957  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyIsDirectory()

void okw.core.OK.VerifyIsDirectory ( String  fpsPathAndFileName,
String  ExpVal 
) throws Exception

Definiert in Zeile 4207 der Datei OK.java.

4208  {
4209  String lvsPathAndFileName = "";
4210 
4211  Log.LogFunctionStartDebug( "VerifyIsDirectory", "fpsPathAndFileName", fpsPathAndFileName, "ExpVal", ExpVal );
4212  try
4213  {
4214  // Prüfen ob ignoriert werden muss...
4215  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
4216  {
4217  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
4218  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
4219  Log.LogPrint( lvsLM );
4220  }
4221  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
4222  else if ( ExpVal.equals(OKW_Const_Sngltn.getInstance().GetConst4Internalname( "YES" ) )
4223  || ExpVal.equals( OKW_Const_Sngltn.getInstance().GetConst4Internalname( "NO" ) ) )
4224  {
4225  // Aktuellen Wert holen...
4226 
4227  // 1. Parsen der Pfad-Eingabe
4228  lvsPathAndFileName = Parser.ParseMe( fpsPathAndFileName );
4229  // 2. Konvertieren des Pfad separators.
4230  lvsPathAndFileName = OKW_FileHelper.convertDirectorySeperator( lvsPathAndFileName );
4231 
4232  String lsvLog = PROP.getProperty( "ok.VerifyIsDirectory.ResolvedPath.${LANGUAGE}", lvsPathAndFileName );
4233  Log.LogPrint( lsvLog );
4234 
4235  // Basis-Funkton aufrufen...
4236  Boolean lvbActual = OKW_FileHelper.isFile( lvsPathAndFileName );
4237 
4238  // Aktuellen Wert nach YES/NO, Sprachabhänging, wandel...
4239  String lvsActual = OKW_Const_Sngltn.getInstance().Boolean2YesNo( lvbActual );
4240 
4241  verification( lvsActual, ExpVal );
4242  }
4243  else
4244  {
4245  // Both conditions are not fulfilled: An exception must be thrown since no other value is allowed here.
4246  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.YesNoIgnore.${LANGUAGE}", ExpVal );
4247  throw new OKWNotAllowedValueException( lvsLM );
4248  }
4249  }
4250  catch (Exception e)
4251  {
4252  this.handleException( e );
4253  }
4254  finally
4255  {
4256  Log.LogFunctionEndDebug();
4257  }
4258  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyIsFile()

void okw.core.OK.VerifyIsFile ( String  fpsPathAndFileName,
String  ExpVal 
) throws Exception

Prüft, ob es sich bei dem gegebenen Pfad um eine Datei handelt.

Parameter
fpsPathAndFileNamePfad und Name der Datei, die geprüft werden soll.
ExpValErwarteter Wert. Möglich Werte sind: "JA"/"NEIN"/"${IGNORIERE}"
Ausnahmebehandlung
OKWFileDoesNotExistsExceptionWenn die gegeben Datei ein Verzeichniss ist, also eben keine Datei, dann wird ein OKWFileDoesNotExistsException ausgelöst.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2019-01-12

Implementiert okw.core.IOKW_State.

Definiert in Zeile 4150 der Datei OK.java.

4151  {
4152  String lvsPathAndFileName = "";
4153 
4154  Log.LogFunctionStartDebug( "VerifyIsFile", "fpsPathAndFileName", fpsPathAndFileName, "ExpVal", ExpVal );
4155  try
4156  {
4157  // Prüfen ob ignoriert werden muss...
4158  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
4159  {
4160  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
4161  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
4162  Log.LogPrint( lvsLM );
4163  }
4164  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
4165  else if ( ExpVal.equals(OKW_Const_Sngltn.getInstance().GetConst4Internalname( "YES" ) )
4166  || ExpVal.equals( OKW_Const_Sngltn.getInstance().GetConst4Internalname( "NO" ) ) )
4167  {
4168  // Aktuellen Wert holen...
4169 
4170  // 1. Parsen der Pfad-Eingabe
4171  lvsPathAndFileName = Parser.ParseMe( fpsPathAndFileName );
4172  // 2. Konvertieren des Pfad separators.
4173  lvsPathAndFileName = OKW_FileHelper.convertDirectorySeperator( lvsPathAndFileName );
4174 
4175  String lsvLog = PROP.getProperty( "ok.VerifyIsFile.ResolvedPath.${LANGUAGE}", lvsPathAndFileName );
4176  Log.LogPrint( lsvLog );
4177 
4178  // Basis-Funkton aufrufen...
4179  Boolean lvbActual = OKW_FileHelper.isFile( lvsPathAndFileName );
4180 
4181  // Aktuellen Wert nach YES/NO, Sprachabhänging, wandel...
4182  String lvsActual = OKW_Const_Sngltn.getInstance().Boolean2YesNo( lvbActual );
4183 
4184  verification( lvsActual, ExpVal );
4185  }
4186  else
4187  {
4188  // Both conditions are not fulfilled: An exception must be thrown since no other value is allowed here.
4189  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.YesNoIgnore.${LANGUAGE}", ExpVal );
4190  throw new OKWNotAllowedValueException( lvsLM );
4191  }
4192  }
4193  catch (Exception e)
4194  {
4195  this.handleException( e );
4196  }
4197  finally
4198  {
4199  Log.LogFunctionEndDebug();
4200  }
4201  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyLabel()

void okw.core.OK.VerifyLabel ( String  FN,
String  ExpVal 
) throws Exception

Überprüft die Beschreibung des Objektes.

Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 2736 der Datei OK.java.

2737  {
2738 
2739  ArrayList<String> lvlsExpected = null;
2740  ArrayList<String> Actual = null;
2741  Log.LogFunctionStartDebug( "VerifyLabel", "FN", FN, "ExpVal", ExpVal );
2742 
2743  try
2744  {
2745  // Prüfen ob ignoriert werden muss...
2746  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
2747  {
2748  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
2749  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
2750  Log.LogPrint( lvsLM );
2751  }
2752  else
2753  {
2754  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
2755  this.newMethod( ExpVal, "IGNORE", "DELETE" );
2756 
2757  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
2758  {
2759  lvlsExpected = new ArrayList<String>();
2760  lvlsExpected.add( "" );
2761  }
2762  else
2763  {
2764  // Split giveneExpected Value
2765  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
2766  lvlsExpected = Parser.ParseMe( lvlsExpected );
2767  }
2768 
2769  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
2770 
2771  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
2772  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyLabel_TO(), myOKW.VerifyLabel_PT() );
2773 
2774  Actual = verify( TimeOut, lvlsExpected, () ->
2775  {
2776  return MyObject.VerifyLabel();
2777  } );
2778  verification( Actual, lvlsExpected );
2779  }
2780  }
2781  catch (Exception e)
2782  {
2783  this.handleException( e );
2784  }
2785  finally
2786  {
2787  Log.LogFunctionEndDebug();
2788  }
2789  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyLabelREGX()

void okw.core.OK.VerifyLabelREGX ( String  FN,
String  ExpVal 
) throws Exception

Ü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: 

PrüfeWertREGX: "MeinObjekt", "$Django"
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 2854 der Datei OK.java.

2855  {
2856 
2857  ArrayList<String> lvlsExpected = null;
2858  ArrayList<String> Actual = null;
2859 
2860  Log.LogFunctionStartDebug( "VerifyLabelREGX", "FN", FN, "fpsExpected", ExpVal );
2861 
2862  try
2863  {
2864  // Prüfen ob ignoriert werden muss...
2865  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
2866  {
2867  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
2868  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
2869  Log.LogPrint( lvsLM );
2870  }
2871  else
2872  {
2873  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
2874  this.newMethod( ExpVal, "IGNORE", "DELETE" );
2875 
2876  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
2877  {
2878  lvlsExpected = new ArrayList<String>();
2879  lvlsExpected.add( "" );
2880  }
2881  else
2882  {
2883  // Split giveneExpected Value
2884  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
2885  lvlsExpected = Parser.ParseMe( lvlsExpected );
2886  }
2887 
2888  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
2889 
2890  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
2891  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyLabel_TO(), myOKW.VerifyLabel_PT() );
2892 
2893  Actual = verifyREGX( TimeOut, lvlsExpected, () ->
2894  {
2895  return MyObject.VerifyLabel();
2896  } );
2897 
2898  verificationREGX( Actual, lvlsExpected );
2899  }
2900  }
2901  catch (Exception e)
2902  {
2903  this.handleException( e );
2904  }
2905  finally
2906  {
2907  Log.LogFunctionEndDebug();
2908  }
2909  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyLabelWCM()

void okw.core.OK.VerifyLabelWCM ( String  FN,
String  ExpVal 
) throws Exception

Überprüft die Beschreibung/Label 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:
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 2794 der Datei OK.java.

2795  {
2796 
2797  ArrayList<String> lvlsExpected = null;
2798  ArrayList<String> Actual = null;
2799 
2800  Log.LogFunctionStartDebug( "VerifyLabelWCM", "FN", FN, "fpsExpected", ExpVal );
2801 
2802  try
2803  {
2804  // Prüfen ob ignoriert werden muss...
2805  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
2806  {
2807  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
2808  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
2809  Log.LogPrint( lvsLM );
2810  }
2811  else
2812  {
2813  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
2814  this.newMethod( ExpVal, "IGNORE", "DELETE" );
2815 
2816  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
2817  {
2818  lvlsExpected = new ArrayList<String>();
2819  lvlsExpected.add( "" );
2820  }
2821  else
2822  {
2823  // Split giveneExpected Value
2824  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
2825  lvlsExpected = Parser.ParseMe( lvlsExpected );
2826  }
2827 
2828  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
2829 
2830  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
2831  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyLabel_TO(), myOKW.VerifyLabel_PT() );
2832 
2833  Actual = verifyWCM( TimeOut, lvlsExpected, () ->
2834  {
2835  return MyObject.VerifyLabel();
2836  } );
2837 
2838  verificationWCM( Actual, lvlsExpected );
2839  }
2840  }
2841  catch (Exception e)
2842  {
2843  this.handleException( e );
2844  }
2845  finally
2846  {
2847  Log.LogFunctionEndDebug();
2848  }
2849  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyMaxLength()

void okw.core.OK.VerifyMaxLength ( String  FN,
String  ExpVal 
) throws Exception

Checks the maximum number of characters that can be entered.

Beispiel: Prüfe, ob max. 10 Zeichen in ein das Objekt mit FN = "Name" eingeben werden darf:

EN.VerifyMaxLength( "Name", "10" )
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert, als String Zahl
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2018-12-25

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3035 der Datei OK.java.

3036  {
3037 
3038  Integer lviExpected = null;
3039  Integer Actual = null;
3040 
3041  Log.LogFunctionStartDebug( "VerifyMaxLength", "FN", FN, "fpsExpected", ExpVal );
3042 
3043  try
3044  {
3045  // Prüfen ob ignoriert werden muss...
3046  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3047  {
3048  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3049  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3050  Log.LogPrint( lvsLM );
3051  }
3052  else
3053  {
3054  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3055  this.newMethod( ExpVal, "IGNORE", "DELETE", "SEP", "VSEP", "HSEP", "EMPTY" );
3056 
3057  try {
3058  String myExpVal = Parser.ParseMe( ExpVal );
3059 
3060  lviExpected = Integer.parseInt( myExpVal );
3061  }
3062  catch (NumberFormatException e)
3063  {
3064  // Wenn ExpVal = keine Zahl enthält -> OKWNotAllowedValueException auslösen...
3065  // OKWNotAllowedValueException.IntegerOnly
3066  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.IntegerOnly.${LANGUAGE}", ExpVal );
3067  throw new OKWNotAllowedValueException( lvsLM );
3068  }
3069 
3070  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3071 
3072  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3073  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyMaxLength_TO(), myOKW.VerifyMaxLength_PT() );
3074 
3075  Actual = verify( TimeOut, lviExpected, () ->
3076  {
3077  return MyObject.VerifyMaxLength();
3078  } );
3079 
3080  verification( Actual, lviExpected );
3081  }
3082  }
3083  catch (Exception e)
3084  {
3085  this.handleException( e );
3086  }
3087  finally
3088  {
3089  Log.LogFunctionEndDebug();
3090  }
3091  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyMinLength()

void okw.core.OK.VerifyMinLength ( String  FN,
String  ExpVal 
) throws Exception

Checks the minimum number of characters that has to be entert.

Beispiel: Prüfe, ob min. 3 Zeichen in ein das Objekt mit FN = "Name" eingeben wurden:

EN.VerifyMinLength( "Name", "3" )
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert, als String Zahl
Autor
Daniel Krüger
Datum
2019.06.18

Implementiert okw.core.IOKW_State.

Definiert in Zeile 4326 der Datei OK.java.

4327  {
4328 
4329  Integer lviExpected = null;
4330  Integer Actual = null;
4331 
4332  Log.LogFunctionStartDebug( "VerifyMinLength", "FN", FN, "fpsExpected", ExpVal );
4333 
4334  try
4335  {
4336  // Prüfen ob ignoriert werden muss...
4337  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
4338  {
4339  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
4340  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
4341  Log.LogPrint( lvsLM );
4342  }
4343  else
4344  {
4345  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
4346  this.newMethod( ExpVal, "IGNORE", "DELETE", "SEP", "VSEP", "HSEP", "EMPTY" );
4347 
4348  try
4349  {
4350  String myExpVal = Parser.ParseMe( ExpVal );
4351  lviExpected = Integer.parseInt( myExpVal );
4352  }
4353  catch (NumberFormatException e)
4354  {
4355  // Wenn ExpVal = keine Zahl enthält -> OKWNotAllowedValueException auslösen...
4356  // OKWNotAllowedValueException.IntegerOnly
4357  String lvsLM = PROP.getProperty( "OKWNotAllowedValueException.IntegerOnly.${LANGUAGE}", ExpVal );
4358  throw new OKWNotAllowedValueException( lvsLM );
4359  }
4360 
4361  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
4362 
4363  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
4364  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyMinLength_TO(), myOKW.VerifyMinLength_PT() );
4365 
4366  Actual = verify( TimeOut, lviExpected, () ->
4367  {
4368  return MyObject.VerifyMinLength();
4369  } );
4370 
4371  verification( Actual, lviExpected );
4372  }
4373  }
4374  catch (Exception e)
4375  {
4376  this.handleException( e );
4377  }
4378  finally
4379  {
4380  Log.LogFunctionEndDebug();
4381  }
4382  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyPlaceholder()

void okw.core.OK.VerifyPlaceholder ( String  FN,
String  ExpVal 
) throws Exception

Überprüft die Beschreibung des Objektes.

Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 2915 der Datei OK.java.

2916  {
2917 
2918  ArrayList<String> lvlsExpected = null;
2919  ArrayList<String> Actual = null;
2920  Log.LogFunctionStartDebug( "VerifyPlaceholder", "FN", FN, "ExpVal", ExpVal );
2921 
2922  try
2923  {
2924  // Prüfen ob ignoriert werden muss...
2925  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
2926  {
2927  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
2928  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
2929  Log.LogPrint( lvsLM );
2930  }
2931  else
2932  {
2933  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
2934  this.newMethod( ExpVal, "IGNORE", "DELETE" );
2935 
2936  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
2937  {
2938  lvlsExpected = new ArrayList<String>();
2939  lvlsExpected.add( "" );
2940  }
2941  else
2942  {
2943  // Split giveneExpected Value
2944  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
2945  lvlsExpected = Parser.ParseMe( lvlsExpected );
2946  }
2947 
2948  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
2949 
2950  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
2951  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyPlaceholder_TO(), myOKW.VerifyPlaceholder_PT() );
2952 
2953  Actual = verify( TimeOut, lvlsExpected, () ->
2954  {
2955  return MyObject.VerifyPlaceholder();
2956  } );
2957  verification( Actual, lvlsExpected );
2958  }
2959  }
2960  catch (Exception e)
2961  {
2962  this.handleException( e );
2963  }
2964  finally
2965  {
2966  Log.LogFunctionEndDebug();
2967  }
2968  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyPlaceholderREGX()

void okw.core.OK.VerifyPlaceholderREGX ( String  FN,
String  ExpVal 
) throws Exception

Überprüft den Platzhalter des Objektes.

Reguläre Ausdrücke als Sollwert sind erlaubt.

Beispiel: Prüfe, ob der Plathalter (Text) des Objekts "MeinObjekt" dem erwarteten Wert "\\.jango" entspricht: 

VerifyPlaceholderREGX: "MeinObjekt", "$Django"
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2018-10-03

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3097 der Datei OK.java.

3098  {
3099 
3100  ArrayList<String> lvlsExpected = null;
3101  ArrayList<String> Actual = null;
3102 
3103  Log.LogFunctionStartDebug( "VerifyPlaceholderREGX", "FN", FN, "fpsExpected", ExpVal );
3104 
3105  try
3106  {
3107  // Prüfen ob ignoriert werden muss...
3108  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3109  {
3110  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3111  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3112  Log.LogPrint( lvsLM );
3113  }
3114  else
3115  {
3116  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3117  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3118 
3119  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3120  {
3121  lvlsExpected = new ArrayList<String>();
3122  lvlsExpected.add( "" );
3123  }
3124  else
3125  {
3126  // Split giveneExpected Value
3127  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3128  lvlsExpected = Parser.ParseMe( lvlsExpected );
3129  }
3130 
3131  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3132 
3133  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3134  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyPlaceholder_TO(), myOKW.VerifyPlaceholder_PT() );
3135 
3136  Actual = verifyREGX( TimeOut, lvlsExpected, () ->
3137  {
3138  return MyObject.VerifyPlaceholder();
3139  } );
3140 
3141  verificationREGX( Actual, lvlsExpected );
3142  }
3143  }
3144  catch (Exception e)
3145  {
3146  this.handleException( e );
3147  }
3148  finally
3149  {
3150  Log.LogFunctionEndDebug();
3151  }
3152  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyPlaceholderWCM()

void okw.core.OK.VerifyPlaceholderWCM ( String  FN,
String  ExpVal 
) throws Exception

Überprüft den Platzhalter des Objektes.

Wildcards sind im erwartetem Wert erlaubt.

Folgende Wildcards sind möglich:

  • "?" - genau ein beliebiges Zeichen wird Maskiert
  • "*" - (0-n) beliebige Zeichen werden maskiert
  • "#" - genau eine Ziffer [0..9] kann maskiert werden

Beispiel: Prüfe, ob der Platzhalter (Text) des Objekts "MeinObjekt" dem erwarteten Wert "*jango" entspricht: 

VerifyPlaceholderWCM: "MeinObjekt", "*jango"
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2018-10-03

Implementiert okw.core.IOKW_State.

Definiert in Zeile 2974 der Datei OK.java.

2975  {
2976 
2977  ArrayList<String> lvlsExpected = null;
2978  ArrayList<String> Actual = null;
2979 
2980  Log.LogFunctionStartDebug( "VerifyLabelWCM", "FN", FN, "fpsExpected", ExpVal );
2981 
2982  try
2983  {
2984  // Prüfen ob ignoriert werden muss...
2985  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
2986  {
2987  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
2988  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
2989  Log.LogPrint( lvsLM );
2990  }
2991  else
2992  {
2993  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
2994  this.newMethod( ExpVal, "IGNORE", "DELETE" );
2995 
2996  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
2997  {
2998  lvlsExpected = new ArrayList<String>();
2999  lvlsExpected.add( "" );
3000  }
3001  else
3002  {
3003  // Split giveneExpected Value
3004  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3005  lvlsExpected = Parser.ParseMe( lvlsExpected );
3006  }
3007 
3008  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3009 
3010  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3011  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyPlaceholder_TO(), myOKW.VerifyPlaceholder_PT() );
3012 
3013  Actual = verifyWCM( TimeOut, lvlsExpected, () ->
3014  {
3015  return MyObject.VerifyPlaceholder();
3016  } );
3017 
3018  verificationWCM( Actual, lvlsExpected );
3019  }
3020  }
3021  catch (Exception e)
3022  {
3023  this.handleException( e );
3024  }
3025  finally
3026  {
3027  Log.LogFunctionEndDebug();
3028  }
3029  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ verifyREGX() [1/2]

ArrayList<String> okw.core.OK.verifyREGX ( OKW_TimeOut  timeout,
ArrayList< String >  fpALExpectedREGXs,
Supplier< ArrayList< String >>  Method2Call 
)
private

Prüft ob der gegebene ArrayList<String> Wert "fpALExpected" als REGX innerhalb des Time Out "timeout" durch die gegebene Methode Method2Call gefunden wird.

Die Absicht dieser Methode ist nicht ein Soll/Ist vergleich, sondern das warten auf einen Werten, der sich einstellen sollte, wenn ein Testfall wie geplant abläuft. Der Soll-/Istvergleich wird in der jeweiligen okw.core.IOKW_State methode, die diese Methode ruft, durchgeführt.

Die Methode wird aus folgenden zwei Gründen beendet:

  1. der erwartet Wert fpALExpected wurde gefunden
  2. der Time Out timeout ist erreicht
Siehe auch
https://www.codementor.io/eh3rrera/using-java-8-method-reference-du10866vx
Parameter
timeoutEnthält die Timeout Daten.
fpALExpectedErwarteter Wert, der sich einstellen sollte.
Method2CallFunctions Referenz auf die aufzurufende Methode
Rückgabe
Liefert den gefundenen aktuellen Wert zurück.
Autor
Zoltán Hrabovszki
Datum
2014-01-09

Definiert in Zeile 2680 der Datei OK.java.

2681  {
2682  Integer Count = 0;
2683 
2684  ArrayList<String> lvLsReturn = null;
2685  Boolean bOK = false;
2686 
2687  Log.LogFunctionStartDebug( "verifyWCN", "timeout", timeout.toString(), "ArrayList<String> fpALExpectedREGXs", fpALExpectedREGXs.toString() );
2688 
2689  try
2690  {
2691  Count = 0;
2692 
2693  while ( Count < timeout.getMaxCount() )
2694  {
2695  lvLsReturn = Method2Call.get();
2696 
2697  if ( Matcher.RegexMatch( lvLsReturn, fpALExpectedREGXs ) )
2698  {
2699  break;
2700  }
2701  else
2702  {
2703  Thread.sleep( timeout.getPT() );
2704  }
2705 
2706  Count++;
2707  }
2708 
2709  bOK = true;
2710  }
2711  catch (IllegalArgumentException e)
2712  {
2713  throw new RuntimeException( e );
2714  }
2715  catch (InterruptedException e)
2716  {
2717  throw new RuntimeException( e );
2718  }
2719  finally
2720  {
2721  if ( bOK )
2722  {
2723  Log.LogFunctionEndDebug( lvLsReturn );
2724  }
2725  else
2726  {
2727  Log.LogFunctionEndDebug();
2728  }
2729  }
2730  return lvLsReturn;
2731  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ verifyREGX() [2/2]

ArrayList<String> okw.core.OK.verifyREGX ( OKW_TimeOut  timeout,
String  COL,
String  ROW,
ArrayList< String >  fpALExpectedREGXs,
BiFunction< String, String, ArrayList< String >>  Method2Call 
)
private
Siehe auch
https://www.codementor.io/eh3rrera/using-java-8-method-reference-du10866vx
Parameter
timeoutEntält Timeout Daten.
COLSpalten auswahl.
ROWSpalten auswahl.
fpALExpectedREGXsErwaretetr Wert
Method2CallFunctions eferenz auf die aufzurufende Methode
Rückgabe

Definiert in Zeile 2455 der Datei OK.java.

2456  {
2457  Integer Count = 0;
2458 
2459  ArrayList<String> lvLsReturn = null;
2460 
2461  Log.LogFunctionStartDebug( "verifyREGX", "timeout", timeout.toString(), "COL", COL, "ROW", ROW, "ArrayList<String> fpALExpected", fpALExpectedREGXs.toString() );
2462 
2463  try
2464  {
2465  Count = 0;
2466 
2467  while ( Count < timeout.getMaxCount() )
2468  {
2469  lvLsReturn = Method2Call.apply( COL, ROW );
2470 
2471  if ( Matcher.RegexMatch( lvLsReturn, fpALExpectedREGXs ) )
2472  {
2473  break;
2474  }
2475  else
2476  {
2477  Thread.sleep( timeout.getPT() );
2478  }
2479 
2480  Count++;
2481  }
2482  }
2483  catch (IllegalArgumentException e)
2484  {
2485  throw new RuntimeException( e );
2486  }
2487  catch (InterruptedException e)
2488  {
2489  throw new RuntimeException( e );
2490  }
2491  finally
2492  {
2493  Log.LogFunctionEndDebug( lvLsReturn );
2494  }
2495  return lvLsReturn;
2496  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:
+ Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

◆ VerifySelectedValue()

void okw.core.OK.VerifySelectedValue ( String  FN,
String  ExpVal 
) throws Exception

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: 

Prüfe Ausgewählter Wert: "MeineListe", "Henry"

Beispiel 2: Prüfe, ob das Element "Namen{SEP}Henry" in der Baumansicht "MeinTreeview" ausgewählt ist: 

Prüfe Ausgewählter Wert: "MeinTreeview", "Namen{SEP}Henry"
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3157 der Datei OK.java.

3158  {
3159  Log.LogFunctionStartDebug( "VerifySelectedValue", "FN", FN, "fpsExpected", ExpVal );
3160 
3161  ArrayList<String> lvlsExpected = null;
3162  ArrayList<String> Actual = null;
3163 
3164  try
3165  {
3166  // Prüfen ob ignoriert werden muss...
3167  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3168  {
3169  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3170  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3171  Log.LogPrint( lvsLM );
3172  }
3173  else
3174  {
3175  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3176  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3177 
3178  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3179  {
3180  lvlsExpected = new ArrayList<String>();
3181  lvlsExpected.add( "" );
3182  }
3183  else
3184  {
3185  // Split giveneExpected Value
3186  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3187  lvlsExpected = Parser.ParseMe( lvlsExpected );
3188  }
3189 
3190  // Get the actuel value from object
3191  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3192 
3193  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3194  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifySelectedValue_TO(), myOKW.VerifySelectedValue_PT() );
3195 
3196  Actual = verify( TimeOut, lvlsExpected, () ->
3197  {
3198  return MyObject.VerifySelectedValue();
3199  } );
3200 
3201  verification( Actual, lvlsExpected );
3202  }
3203  }
3204  catch (Exception e)
3205  {
3206  this.handleException( e );
3207  }
3208  finally
3209  {
3210  Log.LogFunctionEndDebug();
3211  }
3212  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifySelectedValueREGX()

void okw.core.OK.VerifySelectedValueREGX ( String  FN,
String  ExpVal 
) throws Exception

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: 

Prüfe Ausgewählter Wert: "MeineListe", "Henry"

Beispiel 2: Prüfe, ob das Element "Namen{SEP}Henry" in der Baumansicht "MeinTreeview" ausgewählt ist: 

Prüfe Ausgewählter Wert: "MeinTreeview", "Namen{SEP}Henry"
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3277 der Datei OK.java.

3278  {
3279  Log.LogFunctionStartDebug( "VerifySelectedValueREGX", "FN", FN, "fpsExpected", ExpVal );
3280 
3281  ArrayList<String> lvlsExpected = null;
3282  ArrayList<String> Actual = null;
3283 
3284  try
3285  {
3286  // Prüfen ob ignoriert werden muss...
3287  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3288  {
3289  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3290  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3291  Log.LogPrint( lvsLM );
3292  }
3293  else
3294  {
3295  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3296  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3297 
3298  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3299  {
3300  lvlsExpected = new ArrayList<String>();
3301  lvlsExpected.add( "" );
3302  }
3303  else
3304  {
3305  // Split giveneExpected Value
3306  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3307  lvlsExpected = Parser.ParseMe( lvlsExpected );
3308  }
3309 
3310  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3311 
3312  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3313  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifySelectedValue_TO(), myOKW.VerifySelectedValue_PT() );
3314 
3315  Actual = verifyREGX( TimeOut, lvlsExpected, () ->
3316  {
3317  return MyObject.VerifySelectedValue();
3318  } );
3319 
3320  verificationREGX( Actual, lvlsExpected );
3321  }
3322  }
3323  catch (Exception e)
3324  {
3325  this.handleException( e );
3326  }
3327  finally
3328  {
3329  Log.LogFunctionEndDebug();
3330  }
3331  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifySelectedValueWCM()

void okw.core.OK.VerifySelectedValueWCM ( String  FN,
String  ExpVal 
) throws Exception

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: 

Prüfe Ausgewählter Wert: "MeineListe", "Henry"

Beispiel 2: Prüfe, ob das Element "Namen{SEP}Henry" in der Baumansicht "MeinTreeview" ausgewählt ist: 

Prüfe Ausgewählter Wert: "MeinTreeview", "Namen{SEP}Henry"
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3217 der Datei OK.java.

3218  {
3219  Log.LogFunctionStartDebug( "VerifySelectedValueWCM", "FN", FN, "fpsExpected", ExpVal );
3220 
3221  ArrayList<String> lvlsExpected = null;
3222  ArrayList<String> Actual = null;
3223 
3224  try
3225  {
3226  // Prüfen ob ignoriert werden muss...
3227  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3228  {
3229  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3230  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3231  Log.LogPrint( lvsLM );
3232  }
3233  else
3234  {
3235  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3236  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3237 
3238  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3239  {
3240  lvlsExpected = new ArrayList<String>();
3241  lvlsExpected.add( "" );
3242  }
3243  else
3244  {
3245  // Split giveneExpected Value
3246  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3247  lvlsExpected = Parser.ParseMe( lvlsExpected );
3248  }
3249 
3250  // Get the actuel value from object
3251  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3252 
3253  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3254  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifySelectedValue_TO(), myOKW.VerifySelectedValue_PT() );
3255 
3256  Actual = verifyWCM( TimeOut, lvlsExpected, () ->
3257  {
3258  return MyObject.VerifySelectedValue();
3259  } );
3260 
3261  verificationWCM( Actual, lvlsExpected );
3262  }
3263  }
3264  catch (Exception e)
3265  {
3266  this.handleException( e );
3267  }
3268  finally
3269  {
3270  Log.LogFunctionEndDebug();
3271  }
3272  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyTablecellValue()

void okw.core.OK.VerifyTablecellValue ( String  FN,
String  COL,
String  ROW,
String  ExpVal 
) throws Exception

Vergleicht den Inhalt der gegebenen Tabellenzelle mit dem erwarteten Wert.

Parameter
FNFunktionaler Name des Objekts
COLSpaltennummer der zu wählenden Zelle, beginnend mit 1.
ROWZeilennummer der zu wählenden Zelle, beginnend mit 1.
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3336 der Datei OK.java.

3337  {
3338  ArrayList<String> lvlsExpected = null;
3339  ArrayList<String> Actual = null;
3340 
3341  Log.LogFunctionStartDebug( "VerifyTablecellValue", "FN", FN, "COL", COL, "ROW", ROW, "fpsExpected", ExpVal );
3342 
3343  try
3344  {
3345  // Prüfen ob ignoriert werden muss...
3346  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3347  {
3348  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3349  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3350  Log.LogPrint( lvsLM );
3351  }
3352  else
3353  {
3354  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3355  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3356 
3357  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3358  {
3359  lvlsExpected = new ArrayList<String>();
3360  lvlsExpected.add( "" );
3361  }
3362  else
3363  {
3364  // Split giveneExpected Value
3365  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3366  lvlsExpected = Parser.ParseMe( lvlsExpected );
3367  }
3368 
3369  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3370 
3371  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3372  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyTablecellValue_TO(), myOKW.VerifyTablecellValue_PT() );
3373 
3374  Actual = verify( TimeOut, COL, ROW, lvlsExpected, (String col, String row) ->
3375  {
3376  return MyObject.VerifyTablecellValue(col, row);
3377  } );
3378 
3379  verification( Actual, lvlsExpected );
3380  }
3381  }
3382  catch (Exception e)
3383  {
3384  this.handleException( e );
3385  }
3386  finally
3387  {
3388  Log.LogFunctionEndDebug();
3389  }
3390  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyTablecellValueREGX()

void okw.core.OK.VerifyTablecellValueREGX ( String  FN,
String  COL,
String  ROW,
String  ExpVal 
) throws Exception

Vergleicht den Inhalt der gegebenen Tabellenzelle mit dem erwarteten Wert.

Parameter
FNFunktionaler Name des Objekts
COLSpaltennummer der zu wählenden Zelle, beginnend mit 1.
ROWZeilennummer der zu wählenden Zelle, beginnend mit 1.
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3454 der Datei OK.java.

3455  {
3456  ArrayList<String> lvlsExpected = null;
3457  ArrayList<String> Actual = null;
3458 
3459  Log.LogFunctionStartDebug( "VerifyTablecellValue", "FN", FN, "COL", COL, "ROW", ROW, "fpsExpected", ExpVal );
3460 
3461  try
3462  {
3463  // Prüfen ob ignoriert werden muss...
3464  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3465  {
3466  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3467  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3468  Log.LogPrint( lvsLM );
3469  }
3470  else
3471  {
3472  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3473  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3474 
3475  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3476  {
3477  lvlsExpected = new ArrayList<String>();
3478  lvlsExpected.add( "" );
3479  }
3480  else
3481  {
3482  // Split giveneExpected Value
3483  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3484  lvlsExpected = Parser.ParseMe( lvlsExpected );
3485  }
3486 
3487  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3488 
3489  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3490  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyTablecellValue_TO(), myOKW.VerifyTablecellValue_PT() );
3491 
3492  Actual = verifyREGX( TimeOut, COL, ROW, lvlsExpected, (String col, String row) ->
3493  {
3494  return MyObject.VerifyTablecellValue(col, row);
3495  } );
3496 
3497  verificationREGX( Actual, lvlsExpected );
3498  }
3499  }
3500  catch (Exception e)
3501  {
3502  this.handleException( e );
3503  }
3504  finally
3505  {
3506  Log.LogFunctionEndDebug();
3507  }
3508  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyTablecellValueWCM()

void okw.core.OK.VerifyTablecellValueWCM ( String  FN,
String  COL,
String  ROW,
String  ExpVal 
) throws Exception

Vergleicht den Inhalt der gegebenen Tabellenzelle mit dem erwarteten Wert.

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
Parameter
FNFunktionaler Name des Objekts
COLSpaltennummer der zu wählenden Zelle, beginnend mit 1.
ROWZeilennummer der zu wählenden Zelle, beginnend mit 1.
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3395 der Datei OK.java.

3396  {
3397  ArrayList<String> lvlsExpected = null;
3398  ArrayList<String> Actual = null;
3399 
3400  Log.LogFunctionStartDebug( "VerifyTablecellValue", "FN", FN, "COL", COL, "ROW", ROW, "fpsExpected", ExpVal );
3401 
3402  try
3403  {
3404  // Prüfen ob ignoriert werden muss...
3405  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3406  {
3407  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3408  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3409  Log.LogPrint( lvsLM );
3410  }
3411  else
3412  {
3413  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3414  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3415 
3416  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3417  {
3418  lvlsExpected = new ArrayList<String>();
3419  lvlsExpected.add( "" );
3420  }
3421  else
3422  {
3423  // Split giveneExpected Value
3424  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3425  lvlsExpected = Parser.ParseMe( lvlsExpected );
3426  }
3427 
3428  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3429 
3430  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3431  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyTablecellValue_TO(), myOKW.VerifyTablecellValue_PT() );
3432 
3433  Actual = verifyWCM( TimeOut, COL, ROW, lvlsExpected, (String col, String row) ->
3434  {
3435  return MyObject.VerifyTablecellValue(col, row);
3436  } );
3437 
3438  verificationWCM( Actual, lvlsExpected );
3439  }
3440  }
3441  catch (Exception e)
3442  {
3443  this.handleException( e );
3444  }
3445  finally
3446  {
3447  Log.LogFunctionEndDebug();
3448  }
3449  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyTooltip()

void okw.core.OK.VerifyTooltip ( String  FN,
String  ExpVal 
) throws Exception

Prüft den Tooltip-Text eines Objektes.

Der Sollwert wird exakt, d.h ohne Platzhalter, angegeben.

Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3513 der Datei OK.java.

3514  {
3515  ArrayList<String> lvlsExpected = null;
3516  ArrayList<String> Actual = null;
3517 
3518  Log.LogFunctionStartDebug( "VerifyTooltip", "FN", FN, "ExpVal", ExpVal );
3519 
3520  try
3521  {
3522  // Prüfen ob ignoriert werden muss...
3523  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3524  {
3525  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3526  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3527  Log.LogPrint( lvsLM );
3528  }
3529  else
3530  {
3531  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3532  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3533 
3534  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3535  {
3536  lvlsExpected = new ArrayList<String>();
3537  lvlsExpected.add( "" );
3538  }
3539  else
3540  {
3541  // Split giveneExpected Value
3542  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3543  lvlsExpected = Parser.ParseMe( lvlsExpected );
3544  }
3545 
3546  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3547 
3548  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3549  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyTooltip_TO(), myOKW.VerifyTooltip_PT() );
3550 
3551  Actual = verify( TimeOut, lvlsExpected, () ->
3552  {
3553  return MyObject.VerifyTooltip();
3554  } );
3555  verification( Actual, lvlsExpected );
3556  }
3557  }
3558  catch (Exception e)
3559  {
3560  this.handleException( e );
3561  }
3562  finally
3563  {
3564  Log.LogFunctionEndDebug();
3565  }
3566  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyTooltipREGX()

void okw.core.OK.VerifyTooltipREGX ( String  FN,
String  ExpVal 
) throws Exception

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: 

VerifyTooltipREGX( "MeinObjekt", "\\.jango" )
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert, gegegebn als Regulärerausdruck.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3632 der Datei OK.java.

3633  {
3634 
3635  ArrayList<String> Actual = null;
3636  ArrayList<String> lvlsExpected = null;
3637 
3638  Log.LogFunctionStartDebug( "VerifyTooltipREGX", "FN", FN, "ExpVal", ExpVal );
3639 
3640  try
3641  {
3642  // Prüfen ob ignoriert werden muss...
3643  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3644  {
3645  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3646  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3647  Log.LogPrint( lvsLM );
3648  }
3649  else
3650  {
3651  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3652  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3653 
3654  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3655  {
3656  lvlsExpected = new ArrayList<String>();
3657  lvlsExpected.add( "" );
3658  }
3659  else
3660  {
3661  // Split giveneExpected Value
3662  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3663  lvlsExpected = Parser.ParseMe( lvlsExpected );
3664  }
3665 
3666  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3667 
3668  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3669  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyTooltip_TO(), myOKW.VerifyTooltip_PT() );
3670 
3671  Actual = verifyREGX( TimeOut, lvlsExpected, () ->
3672  {
3673  return MyObject.VerifyTooltip();
3674  } );
3675  verificationREGX( Actual, lvlsExpected );
3676 
3677  }
3678  }
3679  catch (Exception e)
3680  {
3681  this.handleException( e );
3682  }
3683  finally
3684  {
3685  Log.LogFunctionEndDebug();
3686  }
3687  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyTooltipWCM()

void okw.core.OK.VerifyTooltipWCM ( String  FN,
String  ExpVal 
) throws Exception

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: 

PrüfeTooltipWCM: "MeinObjekt", "?jango"
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert als Wildcardmatch.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3571 der Datei OK.java.

3572  {
3573 
3574  ArrayList<String> Actual = null;
3575  ArrayList<String> lvlsExpected = null;
3576 
3577  Log.LogFunctionStartDebug( "VerifyTooltipWCM", "FN", FN, "ExpVal", ExpVal );
3578 
3579  try
3580  {
3581  // Prüfen ob ignoriert werden muss...
3582  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3583  {
3584  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3585  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3586  Log.LogPrint( lvsLM );
3587  }
3588  else
3589  {
3590  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3591  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3592 
3593  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3594  {
3595 
3596  lvlsExpected = new ArrayList<String>();
3597  lvlsExpected.add( "" );
3598  }
3599  else
3600  {
3601  // Split giveneExpected Value
3602  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3603  lvlsExpected = Parser.ParseMe( lvlsExpected );
3604  }
3605 
3606  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3607 
3608  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3609  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyTooltip_TO(), myOKW.VerifyTooltip_PT() );
3610 
3611  Actual = verifyWCM( TimeOut, lvlsExpected, () ->
3612  {
3613  return MyObject.VerifyTooltip();
3614  } );
3615  verificationWCM( Actual, lvlsExpected );
3616 
3617  }
3618  }
3619  catch (Exception e)
3620  {
3621  this.handleException( e );
3622  }
3623  finally
3624  {
3625  Log.LogFunctionEndDebug();
3626  }
3627  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyValue()

void okw.core.OK.VerifyValue ( String  FN,
String  ExpVal 
) throws Exception

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: 

Prüfe Wert: "MeinObjekt", "Django"

Dieses Schlüsselwort prüft die exakte Übereinstimmung. Wildkards sind nicht möglich.

Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3692 der Datei OK.java.

3693  {
3694  ArrayList<String> lvlsExpected = null;
3695  ArrayList<String> Actual = null;
3696 
3697  Log.LogFunctionStartDebug( "VerifyValue", "FN", FN, "ExpVal", ExpVal );
3698 
3699  try
3700  {
3701  // Prüfen ob ignoriert werden muss...
3702  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3703  {
3704  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3705  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3706  Log.LogPrint( lvsLM );
3707  }
3708  else
3709  {
3710  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3711  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3712 
3713  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3714  {
3715  lvlsExpected = new ArrayList<String>();
3716  lvlsExpected.add( "" );
3717  }
3718  else
3719  {
3720  // Split giveneExpected Value
3721  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3722  lvlsExpected = Parser.ParseMe( lvlsExpected );
3723  }
3724 
3725  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3726 
3727  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3728  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyValue_TO(), myOKW.VerifyValue_PT() );
3729 
3730  Actual = verify( TimeOut, lvlsExpected, () ->
3731  {
3732  return MyObject.VerifyValue();
3733  } );
3734 
3735  verification( Actual, lvlsExpected );
3736  }
3737  }
3738  catch (Exception e)
3739  {
3740  this.handleException( e );
3741  }
3742  finally
3743  {
3744  Log.LogFunctionEndDebug();
3745  }
3746  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyValueREGX()

void okw.core.OK.VerifyValueREGX ( String  FN,
String  ExpVal 
) throws Exception

Wichtig: Ein "EMPTY"-Wert ist ein ArrayList String welche keine Array-Elemte enthält, also ArrayList.Size() = 0!

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: 

PrüfeWertREGX: "MeinObjekt", "$Django"
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3813 der Datei OK.java.

3814  {
3815 
3816  ArrayList<String> Actual = null;
3817  ArrayList<String> lvlsExpected = null;
3818 
3819  Log.LogFunctionStartDebug( "VerifyValueREGX", "FN", FN, "fpsExpected", ExpVal );
3820 
3821  try
3822  {
3823  // Prüfen ob ignoriert werden muss...
3824  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3825  {
3826  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3827  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3828  Log.LogPrint( lvsLM );
3829  }
3830  else
3831  {
3832  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3833  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3834 
3835  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3836  {
3837 
3838  lvlsExpected = new ArrayList<String>();
3839  lvlsExpected.add( "" );
3840  }
3841  else
3842  {
3843  // Split giveneExpected Value
3844  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3845  lvlsExpected = Parser.ParseMe( lvlsExpected );
3846  }
3847 
3848  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3849 
3850  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3851  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyValue_TO(), myOKW.VerifyValue_PT() );
3852 
3853  Actual = verifyREGX( TimeOut, lvlsExpected, () ->
3854  {
3855  return MyObject.VerifyValue();
3856  } );
3857 
3858  verificationREGX( Actual, lvlsExpected );
3859  }
3860  }
3861  catch (Exception e)
3862  {
3863  this.handleException( e );
3864  }
3865  finally
3866  {
3867  Log.LogFunctionEndDebug();
3868  }
3869  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ VerifyValueWCM()

void okw.core.OK.VerifyValueWCM ( String  FN,
String  ExpVal 
) throws Exception

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: 
PrüfeWertWCM( "MeinObjekt", "$Django" )
Parameter
FNFunktionaler Name des Objekts
ExpValErwarteter Wert / Sollwert.
Autor
zh@op.nosp@m.enke.nosp@m.yword.nosp@m..de
Datum
2014-09-21

Implementiert okw.core.IOKW_State.

Definiert in Zeile 3751 der Datei OK.java.

3752  {
3753 
3754  ArrayList<String> Actual = null;
3755  ArrayList<String> lvlsExpected = null;
3756 
3757  Log.LogFunctionStartDebug( "VerifyValueWCM", "FN", FN, "fpsExpected", ExpVal );
3758 
3759  try
3760  {
3761  // Prüfen ob ignoriert werden muss...
3762  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "IGNORE" ) ) || ExpVal.equals( "" ) )
3763  {
3764  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
3765  String lvsLM = PROP.getProperty( "ok.Ignore.${LANGUAGE}" );
3766  Log.LogPrint( lvsLM );
3767  }
3768  else
3769  {
3770  // If One of the Give OKW-Const-Values is contained in ExpVal -> trigger OKWNotAllowedValueException
3771  this.newMethod( ExpVal, "IGNORE", "DELETE" );
3772 
3773  if ( ExpVal.equals( OKW_Const_Sngltn.getInstance().GetOKWConst4Internalname( "EMPTY" ) ) )
3774  {
3775  lvlsExpected = new ArrayList<String>();
3776  lvlsExpected.add( "" );
3777  }
3778  else
3779  {
3780  // Split giveneExpected Value
3781  lvlsExpected = OKW_Const_Sngltn.getInstance().SplitSEP( ExpVal );
3782  lvlsExpected = Parser.ParseMe( lvlsExpected );
3783  }
3784 
3785  IGUIChildwindow MyObject = ( ( IGUIChildwindow ) CO.setChildName( FN ) );
3786 
3787  OKW myOKW = okw.FrameObjectDictionary_Sngltn.myAnnotationDictionary.get( CO.getObjectFN() );
3788  OKW_TimeOut TimeOut = new OKW_TimeOut( myOKW.VerifyValue_TO(), myOKW.VerifyValue_PT() );
3789 
3790  Actual = verifyWCM( TimeOut, lvlsExpected, () ->
3791  {
3792  return MyObject.VerifyValue();
3793  } );
3794 
3795  verificationWCM( Actual, lvlsExpected );
3796  }
3797  }
3798  catch (Exception e)
3799  {
3800  this.handleException( e );
3801  }
3802  finally
3803  {
3804  Log.LogFunctionEndDebug();
3805  }
3806  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ verifyWCM() [1/2]

ArrayList<String> okw.core.OK.verifyWCM ( OKW_TimeOut  timeout,
ArrayList< String >  fpALExpectedWCMs,
Supplier< ArrayList< String >>  Method2Call 
)
private

Prüft ob der gegebene ArrayList<String> Wert "fpALExpected" als WCM innerhalb des Time Out "timeout" durch die gegebene Methode Method2Call gefunden wird.

Die Absicht dieser Methode ist nicht ein Soll/Ist vergleich, sondern das warten auf einen Werten, der sich einstellen sollte, wenn ein Testfall wie geplant abläuft. Der Soll-/Istvergleich wird in der jeweiligen okw.core.IOKW_State methode, die diese Methode ruft, durchgeführt.

Die Methode wird aus folgenden zwei Gründen beendet:

  1. der erwartet Wert fpALExpected wurde gefunden
  2. der Time Out timeout ist erreicht
Siehe auch
https://www.codementor.io/eh3rrera/using-java-8-method-reference-du10866vx
Parameter
timeoutEnthält die Timeout Daten.
fpALExpectedErwarteter Wert, der sich einstellen sollte.
Method2CallFunctions Referenz auf die aufzurufende Methode
Rückgabe
Liefert den gefundenen aktuellen Wert zurück.
Autor
Zoltán Hrabovszki
Datum
2014-01-09

Definiert in Zeile 2602 der Datei OK.java.

2603  {
2604  Integer Count = 0;
2605 
2606  ArrayList<String> lvLsReturn = null;
2607  Boolean bOK = false;
2608 
2609  Log.LogFunctionStartDebug( "verifyWCN", "timeout", timeout.toString(), "ArrayList<String> fpALExpectedWCMs", fpALExpectedWCMs.toString() );
2610 
2611  try
2612  {
2613  Count = 0;
2614 
2615  while ( Count < timeout.getMaxCount() )
2616  {
2617  lvLsReturn = Method2Call.get();
2618 
2619  if ( Matcher.WildcardMatch( lvLsReturn, fpALExpectedWCMs ) )
2620  {
2621  break;
2622  }
2623  else
2624  {
2625  Thread.sleep( timeout.getPT() );
2626  }
2627 
2628  Count++;
2629  }
2630 
2631  bOK = true;
2632  }
2633  catch (IllegalArgumentException e)
2634  {
2635  throw new RuntimeException( e );
2636  }
2637  catch (InterruptedException e)
2638  {
2639  throw new RuntimeException( e );
2640  }
2641  finally
2642  {
2643  if ( bOK )
2644  {
2645  Log.LogFunctionEndDebug( lvLsReturn );
2646  }
2647  else
2648  {
2649  Log.LogFunctionEndDebug();
2650  }
2651  }
2652  return lvLsReturn;
2653  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

◆ verifyWCM() [2/2]

ArrayList<String> okw.core.OK.verifyWCM ( OKW_TimeOut  timeout,
String  COL,
String  ROW,
ArrayList< String >  fpALExpectedWCM,
BiFunction< String, String, ArrayList< String >>  Method2Call 
)
private
Siehe auch
https://www.codementor.io/eh3rrera/using-java-8-method-reference-du10866vx
Parameter
timeoutEntält Timeout Daten.
fpALExpectedWCMErwaretetr Wert
Method2CallFunctions eferenz auf die aufzurufende Methode
Rückgabe

Definiert in Zeile 2402 der Datei OK.java.

2403  {
2404  Integer Count = 0;
2405 
2406  ArrayList<String> lvLsReturn = null;
2407 
2408  Log.LogFunctionStartDebug( "verifyWCM", "timeout", timeout.toString(), "COL", COL, "ROW", ROW, "ArrayList<String> fpALExpectedWCM", fpALExpectedWCM.toString() );
2409 
2410  try
2411  {
2412  Count = 0;
2413 
2414  while ( Count < timeout.getMaxCount() )
2415  {
2416  lvLsReturn = Method2Call.apply( COL, ROW );
2417 
2418  if ( Matcher.WildcardMatch( lvLsReturn, fpALExpectedWCM ) )
2419  {
2420  break;
2421  }
2422  else
2423  {
2424  Thread.sleep( timeout.getPT() );
2425  }
2426 
2427  Count++;
2428  }
2429  }
2430  catch (IllegalArgumentException e)
2431  {
2432  throw new RuntimeException( e );
2433  }
2434  catch (InterruptedException e)
2435  {
2436  throw new RuntimeException( e );
2437  }
2438  finally
2439  {
2440  Log.LogFunctionEndDebug( lvLsReturn );
2441  }
2442  return lvLsReturn;
2443  }
+ Hier ist ein Graph, der zeigt, was diese Funktion aufruft:
+ Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:
Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:
okw.core.OK.SetFocus
void SetFocus(String FN)
Setzt den Fokus auf das gegebene Fensterobjekt.
Definition: OK.java:1214
okw.OKW.VerifyMaxLength_TO
int VerifyMaxLength_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifyMaxLength.
okw.core.OK.Select
void Select(String FN, String Val)
Auswahl aller Zeilen einer Liste/Tabelle, welche die gegebenen Daten enthalten.
Definition: OK.java:997
okw.OKW.VerifySelectedValue_PT
int VerifySelectedValue_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifySelectedValue.
okw.OKW_FileHelper
OKW_FileHelper enthält FilfsMethoden für die Handhabung von Dateien und Verzechnissen.
Definition: OKW_FileHelper.java:63
okw.core.OK.LogTooltip
void LogTooltip(String FN)
Dokumentiert die Kurzinfo zu einem Werkzeug des gegebenen Objekts.
Definition: OK.java:548
okw.OKW_FileHelper.isFile
static Boolean isFile(String PATH)
Prüft, ob der gegebene PATH eine Datei ist.
Definition: OKW_FileHelper.java:589
okw.core.OK.LogSelected
void LogSelected(String FN)
Dokumentiert den markierten Text des gegebenen Objekts.
Definition: OK.java:483
okw.OKW.VerifyValue_PT
int VerifyValue_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifyValue.
okw.log.Logger_Sngltn.ResOpenList
void ResOpenList(String fps_Name)
Creates a new hierarchical level in the results file.
Definition: Logger_Sngltn.java:614
okw.OKW.VerifyMinLength_TO
int VerifyMinLength_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifyMinLength.
okw.core.OK.SetValue
void SetValue(String FN, String Val)
Setzt den Wert des gegebenen Fensterobjekts auf den gegebenen Wert.
Definition: OK.java:1246
okw.OKW_Const_Sngltn.SplitSEP
ArrayList< String > SplitSEP(String fpsString2Split)
Methode trennt einen String und wandelt diesen in einen ListString um.
Definition: OKW_Const_Sngltn.java:727
okw.OKW.VerifyHasFocus_TO
int VerifyHasFocus_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifyHasFocus.
okw.OKW.VerifyTablecellValue_PT
int VerifyTablecellValue_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifyTablecellValue.
okw.OKW_Properties
Reihenfolge der Resourcen-"Beladung".
Definition: OKW_Properties.java:46
okw.OKW_FileHelper.fileExists
static Boolean fileExists(String fpsPaFiNa)
Prüft, ob die gegebene fpsPaFiNa Datei existiert.
Definition: OKW_FileHelper.java:532
okw.OKW_Const_Sngltn.GetConst4Internalname
String GetConst4Internalname(String fpsInternalname)
Methode ermittelt für Internalname und der aktuell eingestellten Sprache den Wert für Const.
Definition: OKW_Const_Sngltn.java:524
okw.core.OK.verify
Boolean verify(OKW_TimeOut timeout, Boolean fpbExpected, Supplier< Boolean > Method2Call)
Prüft ob der gegebene boolische Wert "fpbExpected" innerhalb des Time Out "timeout" durch die gegeben...
Definition: OK.java:2215
okw.OKW.VerifyBadge_TO
int VerifyBadge_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifyBadge.
okw.core.Core.getNOK_Reason
Exception getNOK_Reason()
Definition: Core.java:132
okw.core.OK.StopApp
void StopApp(String AppName)
Beendet eine gegebene Anwendung.
Definition: OK.java:1336
okw.log.Logger_Sngltn.LogFunctionEndDebug
void LogFunctionEndDebug()
LogFunctionEndDebug:
Definition: Logger_Sngltn.java:249
okw.log.Logger_Sngltn.getInstance
static Logger_Sngltn getInstance()
Zentrale Logger-Klasse stellt Logger-Methoden innerhalb von OKW zur Verfügung.
Definition: Logger_Sngltn.java:88
okw.core.OKW_CurrentObject_Sngltn.getObjectFN
String getObjectFN()
Ermittelt den ObjektNamen des aktuellen Objektes.
Definition: OKW_CurrentObject_Sngltn.java:305
okw.OKW_FileHelper.DirectoryCreate
static void DirectoryCreate(String PATH)
Erstellt ein Verzeichnis, einschließlich aller notwendigen, aber nicht vorhandenen übergeordneten Ver...
Definition: OKW_FileHelper.java:829
okw.OKW.VerifyMinLength_PT
int VerifyMinLength_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifyMinLength.
okw.core.OK.MemorizeTablecellValue
void MemorizeTablecellValue(String FN, String COL, String ROW, String MemKey)
Merkt sich den Wert der gegebenen Zelle in der Tabelle. throws Exception
Definition: OK.java:880
okw.OKW.VerifyExists_TO
int VerifyExists_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifyExists.
okw.core.OKW_CurrentObject_Sngltn.setChildName
Object setChildName(String fpsChildName)
Setzt das Kindobjekt.
Definition: OKW_CurrentObject_Sngltn.java:522
okw.log.Logger_Sngltn.ResOpenListDebug
void ResOpenListDebug(String fpsListCaption)
Erzeugt eine hierachische Log-Ebene in der Ergenbniss-Ausgabe.
Definition: Logger_Sngltn.java:647
okw.OKW.VerifySelectedValue_TO
int VerifySelectedValue_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifySelectedValue.
okw.core.OK.MemorizeHasFocus
void MemorizeHasFocus(String FN, String MemKey)
Keine Beschreibung zu "MemorizeHasFocus" verfügbar.
Definition: OK.java:688
okw.core.OK.LogHasFocus
void LogHasFocus(String FN)
Dokumentiert den Fokus-Status des gegebenen Objekts.
Definition: OK.java:368
okw.OKW.VerifyTooltip_TO
int VerifyTooltip_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifyTooltip.
okw.OKW_Memorize_Sngltn
OKW_Memorize ist die Speicher-Klasse hinter den Merke*-Schlüsselwörter.
Definition: OKW_Memorize_Sngltn.java:73
okw.OKW.VerifyExists_PT
int VerifyExists_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifyExists.
okw.core.OK.TypeKey
void TypeKey(String FN, String Val)
Tastatureingaben von Daten in das aktive Fensterobjekt.
Definition: OK.java:1357
okw.OKW_Properties.getInstance
static OKW_Properties getInstance()
Holt die einzige Instanz dieser Klasse.
Definition: OKW_Properties.java:116
okw.log.Logger_Sngltn.LogFunctionStartDebug
void LogFunctionStartDebug(String fps_FunctionName, String... fpsParameter)
LogFunctionStartDebug:
Definition: Logger_Sngltn.java:311
okw.core.OK.LogPlaceholder
void LogPlaceholder(String FN)
Gibt den Wert des Platzhalters in der Logdatei aus.
Definition: OK.java:452
okw.OKW.VerifyCaption_PT
int VerifyCaption_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifyCaption.
okw.OKW_FileHelper.convertDirectorySeperator
static String convertDirectorySeperator(String fpsPath)
Konvertiert für das Host-Betriebsystem den Path Separator.
Definition: OKW_FileHelper.java:778
okw.OKW_Const_Sngltn.ConcatSEP
String ConcatSEP(ArrayList< String > fpLs_ListString2Concat)
Methode verbindet die einzelne Strings eines List<Strings> zu einem string und trennt diese mit der K...
Definition: OKW_Const_Sngltn.java:416
okw.OKW_FileHelper.deleteFile
static Boolean deleteFile(String fpsPaFiNa)
Löscht die gegebene Datei fpsPaFiNa.
Definition: OKW_FileHelper.java:496
okw.OKW.VerifyMaxLength_PT
int VerifyMaxLength_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifyMaxLength.
okw.core.OK.verifyWCM
ArrayList< String > verifyWCM(OKW_TimeOut timeout, String COL, String ROW, ArrayList< String > fpALExpectedWCM, BiFunction< String, String, ArrayList< String >> Method2Call)
Definition: OK.java:2402
okw.log.Logger_Sngltn.ResCloseListDebug
void ResCloseListDebug()
Closes a hierarchical level in the results file that was opened with ResOpenList.
Definition: Logger_Sngltn.java:594
okw.OKWLanguage.setLanguage
void setLanguage(String value)
Wählt die sprache von OKW, default Sprache ist "en".
Definition: OKWLanguage.java:106
okw.core.OK.MemorizeExists
void MemorizeExists(String FN, String MemKey)
Merkt sich den aktuell existierenden Zustand des Objekts.
Definition: OK.java:649
okw.OKW_FileHelper.deleteDirectory
static void deleteDirectory(String Path)
Löschent rekursiv alle Dateien und Unterverzeichnisse und das gegebenen Verzeichniss selbst.
Definition: OKW_FileHelper.java:168
okw.OKW_FileHelper.createFile
static boolean createFile(String fpsPaFiNa)
Legt eine Leere Datei an.
Definition: OKW_FileHelper.java:676
okw.OKW_Const_Sngltn.YesNo2Boolean
Boolean YesNo2Boolean(String fpsYesOrNo)
Konvertiert sprachabhängig Ja/Nein zu einem Booleanean Wert (Wahr/Falsch).
Definition: OKW_Const_Sngltn.java:840
okw.OKW.VerifyBadge_PT
int VerifyBadge_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifyBadge.
okw.core.OK.StartApp
void StartApp(String AppName)
Startet die gegebene Anwendung.
Definition: OK.java:1315
okw.OKW.VerifyErrorMSG_TO
int VerifyErrorMSG_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifyLabel.
okw.OKWLanguage
http://de.wikipedia.org/wiki/ISO-3166-1-Kodierliste
Definition: OKWLanguage.java:47
okw.OKW.VerifyErrorMSG_PT
int VerifyErrorMSG_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifyLabel.
okw.parser.Parser
Definition: Parser.java:14
okw.core.OK.LogIsActive
void LogIsActive(String FN)
Dokumentiert den Status des gegebenen Objekts.
Definition: OK.java:395
okw.log.Logger_Sngltn.LogPrint
void LogPrint(String fps_Message)
LogPrint Function: Prints the values of expressions to the results file.
Definition: Logger_Sngltn.java:487
okw.OKW.VerifyValue_TO
int VerifyValue_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifyValue.
okw.core.OK.ClickOn
void ClickOn(String FN)
Klickt auf das gegebene Objekt.
Definition: OK.java:269
okw.OKW_Properties.getProperty
String getProperty(String fpsKey)
Ermittelt den aktuellen Wert des Propertys gegeben mit dem Schlüssel fpsKey.
Definition: OKW_Properties.java:804
okw.core.OK.LogLabel
void LogLabel(String FN)
Gibt den Wert des Etikette/Label in der Logdatei aus.
Definition: OK.java:422
okw.log.Logger_Sngltn.ResCloseList
void ResCloseList()
Closes a hierarchical level in the results file that was opened with ResOpenList.
Definition: Logger_Sngltn.java:574
okw.OKW.VerifyPlaceholder_PT
int VerifyPlaceholder_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifyPlaceholder.
okw.OKW_Memorize_Sngltn.set
void set(String fpsKey, String fpsValue)
Setzt/Merkt sich das MemKey/Value-Paar.
Definition: OKW_Memorize_Sngltn.java:452
okw.OKW_Const_Sngltn.Boolean2YesNo
String Boolean2YesNo(Boolean fpbTrueOrFalse)
Konvertiert WAHR/FALSCH (true/false) sprachabhängig nach "Ja"/"Nein" (Yes/No)
Definition: OKW_Const_Sngltn.java:311
okw.core.OK.MemorizePlaceholder
void MemorizePlaceholder(String FN, String MemKey)
Speirchert den aktuellen Wert der Platzhalters, und legt diesen unter fpsMemKeyName ab.
Definition: OK.java:804
okw.core.OK.MemorizeTooltip
void MemorizeTooltip(String FN, String MemKey)
Dokumentiert den Tooltip-Text (Kurzinformation) des gegebenen Objekts.
Definition: OK.java:919
okw.OKW.VerifyLabel_PT
int VerifyLabel_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifyLabel.
okw.core.OK.MemorizeIsActive
void MemorizeIsActive(String FN, String MemKey)
Merkt sich den Zustand des gegebenen Objekts.
Definition: OK.java:727
okw.OKW_FileHelper.directoryExists
static Boolean directoryExists(String fpsPaFiNa)
Prüft, ob die gegebene fpsPaFiNa Datei existiert.
Definition: OKW_FileHelper.java:222
okw.OKW.VerifyPlaceholder_TO
int VerifyPlaceholder_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifyPlaceholder.
okw.core.OK.MemorizeValue
void MemorizeValue(String FN, String MemKey)
Merkt sich den Standartwert eines Objekts.
Definition: OK.java:958
okw.OKW_Memorize_Sngltn.getInstance
static OKW_Memorize_Sngltn getInstance()
Diese Methode gibt die einzige Instanz dieser Klasse zurück.
Definition: OKW_Memorize_Sngltn.java:198
okw.OKW_Properties.getProperty2Boolean
Boolean getProperty2Boolean(String fpsKey, String fpsDefault)
Definition: OKW_Properties.java:940
okw.OKW_TimeOut.getPT
Integer getPT()
Wartezeit zwischen zwei Pollings in [ms].
Definition: OKW_TimeOut.java:18
okw.core.OK.TypeKeyTablecell
void TypeKeyTablecell(String FN, String COL, String ROW, String Val)
Eingabe von Daten in eine gegebene Tabellenzelle über die Tastatur.
Definition: OK.java:1398
okw.core.OK.LogExists
void LogExists(String FN)
Gibt die Existenz eines GUI-Objektes mit YES/NO in den Testergebnissen aus.
Definition: OK.java:341
okw.core.OK.SelectMenu
void SelectMenu(String FN)
Wählt den gegebenen Menü-Eintrag aus.
Definition: OK.java:1037
okw.core.Core.setNOK_Reason
void setNOK_Reason(Exception nOK_Reason)
Definition: Core.java:140
okw.OKW.VerifyLabel_TO
int VerifyLabel_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifyLabel.
okw.core.OK.LogValue
void LogValue(String FN)
Dokumentiert den Standartwert eines Objekts.
Definition: OK.java:579
okw.core.OK.SelectWindow
void SelectWindow(String FN)
Setzt den Kontext auf das gegebene Fenster.
Definition: OK.java:1115
okw.OKW_Const_Sngltn.getInstance
static OKW_Const_Sngltn getInstance()
Holt die einzige Instanz dieser Klasse.
Definition: OKW_Const_Sngltn.java:277
okw.OKW_FileHelper.deleteFiles
static void deleteFiles(String fpsPaFiNa)
Löscht alle Dateien des gegebenen Musters im gegebenen Verzeichniss Rekursive.
Definition: OKW_FileHelper.java:461
okw.core.OK.LogCaption
void LogCaption(String FN)
Gibt die Caption eines GUI-Objektes in den Testergebnissen aus.
Definition: OK.java:311
okw.OKW_Const_Sngltn
OKW_Const verwaltet die sprachabhängigen OKW-Konstanten.
Definition: OKW_Const_Sngltn.java:127
okw.core.OK.handleException
void handleException(Exception e)
In dieser Methode werden zentral die Exceptions ausgewertet.
Definition: OK.java:154
okw.core.OK.verifyREGX
ArrayList< String > verifyREGX(OKW_TimeOut timeout, String COL, String ROW, ArrayList< String > fpALExpectedREGXs, BiFunction< String, String, ArrayList< String >> Method2Call)
Definition: OK.java:2455
okw.core.OK.SelectTablecell
void SelectTablecell(String FN, String COL, String ROW)
Wählt die gegebene Tabellenzelle aus.
Definition: OK.java:1094
okw.core.OK.LogTablecellValue
void LogTablecellValue(String FN, String COL, String ROW)
Dokumentiert den Wert der ausgewählten Zelle.
Definition: OK.java:517
okw.OKW.VerifyCaption_TO
int VerifyCaption_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifyCaption.
okw.core.OKW_CurrentObject_Sngltn.setWindowName
Object setWindowName(String fpsWindowName)
Hier wird der Kontext auf ein Fenster gesetzt.
Definition: OKW_CurrentObject_Sngltn.java:589
okw.core.OK.TypeKeyWindow
void TypeKeyWindow(String FN, String Val)
Tastatureingabe in ein bestimmtes Fensterobjekt.
Definition: OK.java:1440
okw.OKW
Annotations-Klasses für die Zuordnung von.
Definition: OKW.java:38
okw.core.OK.MemorizeLabel
void MemorizeLabel(String FN, String MemKey)
Speirchert den aktuellen Wert der Etikette, und legt diesen unter fpsMemKeyName ab.
Definition: OK.java:766
okw.core.OK.DoubleClickOn
void DoubleClickOn(String FN)
Führt ein Doppelklick auf das gegebene GUI-Objekt aus.
Definition: OK.java:290
okw.OKW.VerifyTooltip_PT
int VerifyTooltip_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifyTooltip.
okw.OKW.VerifyTablecellValue_TO
int VerifyTablecellValue_TO() default 5
TimeOut in Sekunden [s] für das Schlüsselwort VerifyTablecellValue.
okw.exceptions.OKWNotAllowedValueException
OKWNotAllowedValueException-Ausnahme wird ausgelöst, wenn ein gegebener Wert im Schlüsselwort nicht e...
Definition: OKWNotAllowedValueException.java:63
okw.log.Logger_Sngltn
Definition: Logger_Sngltn.java:54
okw.core.OK.MemorizeSelectedValue
void MemorizeSelectedValue(String FN, String MemKey)
Keine Beschreibung zu "MemorizeSelectedValue" verfügbar.
Definition: OK.java:842
okw.core.OK.MemorizeCaption
void MemorizeCaption(String FN, String MemKey)
Keine Beschreibung zu "MemorizeCaption" verfügbar.
Definition: OK.java:610
okw.OKW_TimeOut.getMaxCount
Integer getMaxCount()
Anzahl der berechnetten Zyklen.
Definition: OKW_TimeOut.java:46
okw.parser.Parser.ParseMe
static ArrayList< String > ParseMe(ArrayList< String > fpLsString2Parse)
Parst einen ArayList&lt string&gt, ersetzt die Parser-Schlüsslewörter durch Werte.
Definition: Parser.java:32
okw.OKW_Const_Sngltn.GetOKWConst4Internalname
String GetOKWConst4Internalname(String fpsInternalname)
Methode ermittelt für Internalname und der aktuell eingestellten Sprache den Wert für OKWConst.
Definition: OKW_Const_Sngltn.java:608
okw.OKW.VerifyHasFocus_PT
int VerifyHasFocus_PT() default 1000
Polling Time in [ms] für das Schlüsselwort VerifyHasFocus.
okw.OKW_TimeOut
Definition: OKW_TimeOut.java:3