OpenKeyWord  Build Tag: jenkins-DoxyGen_EN-107, Build ID: 2015-03-08_20-51-06
 All Classes Namespaces Functions Variables Properties Pages
Public Member Functions | Private Member Functions | Private Attributes | List of all members
OKW.OK Class Reference
Inheritance diagram for OKW.OK:
Inheritance graph
[legend]
Collaboration diagram for OKW.OK:
Collaboration graph
[legend]

Public Member Functions

 OK (Core fp_OKW)
 
void BeginTest (string fpsTestname)
 Begins a test. More...
 
void ClickOn (string fpsFunctionalname)
 Clicks on given object. More...
 
void ClickOn (string fpsFunctionalname, string fpsClickType)
 Clicks on given object. More...
 
void EndTest ()
 Terminates the test respectively the testcase. More...
 
void LogCaption (string fpsFunctionalname)
 No description for "LogCaption" available. More...
 
void LogExists (string fpsFunctionalname)
 Logs whether the given object is existing. More...
 
void LogHasFocus (string fpsFunctionalname)
 Logs the focus status of the given object. More...
 
void LogIsActive (string fpsFunctionalname)
 Logs the status of the given object. More...
 
void LogLabel (string fpsFunctionalname)
 No description for "LogLabel" available. More...
 
void LogSelected (string fpsFunctionalname)
 Logs the marked text of the given object. More...
 
void LogTablecellValue (string fpsFunctionalname, string fpsCol, string fpsRow)
 Logs the value of the selected tablecell. More...
 
void LogTooltip (string fpsFunctionalname)
 Logs the Tooltip of the given object. More...
 
void LogValue (string fpsFunctionalname)
 Logs the standard value of an object. More...
 
void MemorizeCaption (string fpsFunctionalname, string fps_MemKeyName)
 No description for "MemorizeCaptione" available. More...
 
void MemorizeExists (string fpsFunctionalname, string fps_MemKeyName)
 Memorizes the actual existing Status of the object. More...
 
void MemorizeHasFocus (string fpsFunctionalname, string fps_MemKeyName)
 No description for "MemorizeHasFocus" available. More...
 
void MemorizeIsActive (string fpsFunctionalname, string fps_MemKeyName)
 Memorizes the state of the given object. More...
 
void MemorizeLabel (string fpsFunctionalname, string fps_MemKeyName)
 No description for "MemorizeLabel" available. More...
 
void MemorizeSelectedValue (string fpsFunctionalname, string fps_MemKeyName)
 No description for "MemorizeSelectedValue" available. More...
 
void MemorizeTablecellValue (string fpsFunctionalname, string fpsCol, string fpsRow, string fps_MemKeyName)
 Memorizes the value of the given tablecell. More...
 
void MemorizeTooltip (string fpsFunctionalname, string fps_MemKeyName)
 Logs the tooltip-text of the given object. More...
 
void MemorizeValue (string fpsFunctionalname, string fps_MemKeyName)
 No description for "MemorizeLabel" available. More...
 
void Select (string fpsFunctionalname, string fpsValue)
 Select all rows in a list/chart, which contain the given data. More...
 
void Select (string fpsFunctionalname, string fpsValue, string fpsClickType)
 Select all rows in a list/chart, which contain the given data. More...
 
void SelectMenu (string fpsFunctionalname)
 Selects the given menu item. More...
 
void SelectMenu (string fpsFunctionalname, string fpsValue)
 Selects the given menu item. More...
 
void SelectTablecell (string fpsFunctionalname, string fpsCol, string fpsRow)
 Selects the given table cell. More...
 
void SelectTablecell (string fpsFunctionalname, string fpsCol, string fpsRow, string fpsClickType)
 Selects the given table cell. More...
 
void SelectWindow (string fpsFunctionalname)
 Setting the context for the given window and ensuring that the window is active and in the foreground. More...
 
void Sequence (string fpsObjectName, string fpsSequenceName, string SEQ_ID)
 Calls the sequence of the window. More...
 
void SetFocus (string fpsFunctionalname)
 Setting the focus to the given window object. More...
 
void SetLanguage (string Language)
 
void SetValue (string fpsFunctionalname, string fpsValue)
 Setting the value of the given window object to the given value. More...
 
void StartApp (string fps_ApplikationName)
 Starts the given application. More...
 
void StopApp (string fps_ApplikationName)
 Ends a given application. More...
 
void TypeKey (string fpsFunctionalname, string fpsValue)
 Keyboard inputs of data in the active windows object. More...
 
void TypeKeyTablecell (string fpsFunctionalname, string fpsCol, string fpsRow, string fpsValue)
 Input of date to a given tablecell by the keyboard. More...
 
void TypeKeyWindow (string fpsFunctionalname, string fpsValue)
 Keyboard input to a particular window object. More...
 
void VerifyCaption (string fpsFunctionalname, string fpsExpected)
 No description for "VerifyCaption" available. More...
 
void VerifyExists (string fpsFunctionalname, string fpsExpectedValue)
 Checks the existence of the given object.
Example #1: Check if the object MyObject exists:
More...
 
void VerifyHasFocus (string fpsFunctionalname, string fpsExpectedValue)
 Compares the focus status of the given object with the expected value. More...
 
void VerifyIsActive (string fpsFunctionalname, string fpsExpectedValue)
 Compares the focus status of the given object with the expected value. More...
 
void VerifyLabel (string fpsFunctionalname, string fpsExpectedValue)
 No description for "VerifyLabel" available. More...
 
void VerifySelectedValue (string fpsFunctionalname, string fpsExpectedValue)
 Compares the selected value of the given listobject with the expected value. More...
 
void VerifyTablecellValue (string fpsFunctionalname, string fpsCol, string fpsRow, string fpsExpectedValue)
 Compares the content of the given table cell with the expected value. More...
 
void VerifyTooltip (string fpsFunctionalname, string fpsExpectedValue)
 No description for "VerifyTooltip" available. More...
 
void VerifyValue (string fpsFunctionalname, string fpsExpectedValue)
 Checks the standard value of an object (in most cases this is the displayed text). More...
 

Private Member Functions

void HandleException (Exception e)
 

Private Attributes

OKWLanguage AL = OKWLanguage.Instance
 
LogMessenger LM = null
 
OKWDocu MyOKWDocu = OKWDocu.Instance
 
bool UNITTEST = true
 
Core _Kernel
 

Detailed Description

Author
Zoltán Hrabovszki
Date
2013.03.02

Constructor & Destructor Documentation

OKW.OK.OK ( Core  fp_OKW)
Author
Zoltán Hrabovszki
Date
09.01.2014
85  {
86  this._Kernel = fp_OKW;
87  this.LM = new LogMessenger(this.GetType().Name);
88  }

Member Function Documentation

void OKW.OK.BeginTest ( string  fpsTestname)

Begins a test.

Description of the allgorithm

Note
Additional remarks to the key-word

/param fpsTestname No explanation available

Author
Zoltan Hrabovszki
Date
2014-09-18/jnic

Implements OKW.IOKW_State.

100  {
101  Logger.Instance.LogFunctionStart("BeginTest",
102  "fpsTestname", fpsTestname);
103 
104  Logger.Instance.LogFunctionEnd();
105  }
void OKW.OK.ClickOn ( string  fpsFunctionalname)

Clicks on given object.

Example: Click on the object with the name "My Object":

click on: "MyObject"

/param fpsFunctionalname Functional name of the object

Example: Click on "My Object":

click on: "MyObject"

/param fpsFunctionalname Functional name of the object

Author
Zoltan Hrabovszki
Date
2014-09-18/jnic

Implements OKW.IOKW_State.

113  {
114  Logger.Instance.LogFunctionStart("ClickOn", "fpsFunctionalname", fpsFunctionalname);
115 
116  try {
117  CurrentObject.Instance.SetChildName(fpsFunctionalname);
118  CurrentObject.Instance.CallMethod("ClickOn");
119  } catch (Exception e) {
120  this.HandleException(e);
121  } finally {
122  Logger.Instance.LogFunctionEnd();
123  }
124  }
void OKW.OK.ClickOn ( string  fpsFunctionalname,
string  fpsClickType 
)

Clicks on given object.

Example: Click on the object with the name "My Object":

click on: "MyObject"

/param fpsFunctionalname Functional name of the object /param fpsClickType Doubleclick" to select via doubleclick, "Singleclick" to select via singleclick (default)

Author
Zoltan Hrabovszki
Date
2014-09-18/jnic

Implements OKW.IOKW_State.

132  {
133  Logger.Instance.LogFunctionStart("ClickOn", "fpsFunctionalname", fpsFunctionalname, "fpsClickType", fpsClickType);
134 
135  try {
136  CurrentObject.Instance.SetChildName(fpsFunctionalname);
137  CurrentObject.Instance.CallMethod("ClickOn_Clicktype", fpsClickType);
138  } catch (Exception e) {
139  this.HandleException(e);
140  } finally {
141  Logger.Instance.LogFunctionEnd();
142  }
143  }
void OKW.OK.EndTest ( )

Terminates the test respectively the testcase.

Description of the mode of operation.

Note
Additional remark to the keyword
Author
Zoltan Hrabovszki
Date
2014-09-18/jnic

Implements OKW.IOKW_State.

151  {
152  Logger.Instance.LogFunctionStart("EndTest");
153 
154  Logger.Instance.LogFunctionEnd();
155  }
void OKW.OK.HandleException ( Exception  e)
private
Author
Zoltán Hrabovszki
Date
02.03.2013
1465  {
1466  Logger.Instance.LogPrint("==========================================================================");
1467  Logger.Instance.LogException(string.Format("{0}", e.Message));
1468  Logger.Instance.LogPrint("--------");
1469 
1470  // Das ist nicht schön aber Notwendig. LogObjektData ist
1471  if (!e.GetType().IsAssignableFrom(typeof(OKWFrameObjectWindowNotFoundException))) {
1472  CurrentObject.Instance.LogObjectData();
1473  }
1474 
1475  Logger.Instance.LogPrint("--------");
1476  Logger.Instance.LogPrint(" Stack:");
1477  Logger.Instance.LogException(string.Format("{0}", e.StackTrace));
1478 
1479  Logger.Instance.LogPrint("-------");
1480  Logger.Instance.LogPrint(" Source:");
1481  Logger.Instance.LogException(string.Format("{0}", e.Source));
1482 
1483  Logger.Instance.LogPrint("-------");
1484  Logger.Instance.LogPrint(" TargetSite:");
1485  Logger.Instance.LogException(string.Format("{0}", e.TargetSite));
1486 
1487  Logger.Instance.LogPrint("==========================================================================");
1488 
1489  // Change State to NOK
1490  this._Kernel.SetCurrentState(new NOK(this._Kernel));
1491 
1492  if (this.UNITTEST) {
1493  throw e;
1494  }
1495  }
void OKW.OK.LogCaption ( string  fpsFunctionalname)

No description for "LogCaption" available.

/param fpsFunctionalname Functional name of the object

Author
Zoltan Hrabovszki
Date
2014-09-18/jnic
Todo:
jnic–>keine Beschreibung vorhanden

Implements OKW.IOKW_State.

163  {
164  Logger.Instance.LogFunctionStart("LogCaption",
165  "fpsFunctionalname", fpsFunctionalname);
166 
167  try {
168  CurrentObject.Instance.SetChildName(fpsFunctionalname);
169  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("LogCaption");
170 
171  Logger.Instance.ResOpenList("Log... ");
172 
173  foreach (string Value in ActualValues) {
174  Logger.Instance.LogPrint(">>" + Value + "<<");
175  }
176 
177  Logger.Instance.ResCloseList();
178  } catch (Exception e) {
179  this.HandleException(e);
180  } finally {
181  Logger.Instance.LogFunctionEnd();
182  }
183  }
void OKW.OK.LogExists ( string  fpsFunctionalname)

Logs whether the given object is existing.

Example: Logs whether the object with the name "My Object" is existing:

log exists: "MyObject"

/param fpsFunctionalname Functional name of the object

Author
Zoltan Hrabovszki
Date
2014-09-18/jnic

Implements OKW.IOKW_State.

191  {
192  Logger.Instance.LogFunctionStart("LogExists",
193  "fpsFunctionalname", fpsFunctionalname);
194 
195  try {
196  CurrentObject.Instance.SetChildName(fpsFunctionalname);
197  bool lvbActual = CurrentObject.Instance.CallMethodReturn_Boolean("LogExists");
198  string lvsActual = OKWConst.Instance.Boolean2YesNo(lvbActual);
199 
200  string lvsLM = this.LM.GetMessage("LogExists", "LogValue", lvsActual);
201 
202  Logger.Instance.LogPrint(lvsLM);
203  } catch (Exception e) {
204  this.HandleException(e);
205  } finally {
206  Logger.Instance.LogFunctionEnd();
207  }
208  }
void OKW.OK.LogHasFocus ( string  fpsFunctionalname)

Logs the focus status of the given object.

Example: Logs the focus status of "My Object":

LoghasFocus: "MyObject"

/param fpsFunctionalname Functional name of the object

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

216  {
217  Logger.Instance.LogFunctionStart("LogHasFocus",
218  "fpsFunctionalname", fpsFunctionalname);
219 
220  try {
221  CurrentObject.Instance.SetChildName(fpsFunctionalname);
222  bool lvbActual = CurrentObject.Instance.CallMethodReturn_Boolean("LogHasFocus");
223  string lvsActual = OKWConst.Instance.Boolean2YesNo(lvbActual);
224 
225  string lvsLM = this.LM.GetMessage("LogIsActive", "LogValue", lvsActual);
226 
227  Logger.Instance.LogPrint(lvsLM);
228  } catch (Exception e) {
229  this.HandleException(e);
230  } finally {
231  Logger.Instance.LogFunctionEnd();
232  }
233  }
void OKW.OK.LogIsActive ( string  fpsFunctionalname)

Logs the status of the given object.

Example: Logs the active status of "My Object":

LogIsActive: "MyObject"

/param fpsFunctionalname Functional name of the object

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

241  {
242  Logger.Instance.LogFunctionStart("LogIsActive",
243  "fpsFunctionalname", fpsFunctionalname);
244 
245  try {
246  CurrentObject.Instance.SetChildName(fpsFunctionalname);
247  bool lvbActual = CurrentObject.Instance.CallMethodReturn_Boolean("LogIsActive");
248 
249  string lvsActual = OKWConst.Instance.Boolean2YesNo(lvbActual);
250 
251  string lvsLM = this.LM.GetMessage("LogIsActive", "LogValue", lvsActual);
252 
253  Logger.Instance.LogPrint(lvsLM);
254  } catch (Exception e) {
255  this.HandleException(e);
256  } finally {
257  Logger.Instance.LogFunctionEnd();
258  }
259  }
void OKW.OK.LogLabel ( string  fpsFunctionalname)

No description for "LogLabel" available.

/param fpsFunctionalname Functional name of the object

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic
Todo:
jnic–>keine Beschreibung vorhanden

Implements OKW.IOKW_State.

267  {
268  Logger.Instance.LogFunctionStart("LogLabel",
269  "fpsFunctionalname", fpsFunctionalname);
270 
271  try {
272  CurrentObject.Instance.SetChildName(fpsFunctionalname);
273  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("LogLabel");
274 
275  Logger.Instance.ResOpenList("Log... ");
276 
277  foreach (string Value in ActualValues) {
278  Logger.Instance.LogPrint(">>" + Value + "<<");
279  }
280 
281  Logger.Instance.ResCloseList();
282  } catch (Exception e) {
283  this.HandleException(e);
284  } finally {
285  Logger.Instance.LogFunctionEnd();
286  }
287  }
void OKW.OK.LogSelected ( string  fpsFunctionalname)

Logs the marked text of the given object.

/param fpsFunctionalname Functional name of the object

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

295  {
296  Logger.Instance.LogFunctionStart(
297  "LogSelected",
298  "fpsFunctionalname",
299  fpsFunctionalname);
300 
301  try {
302  CurrentObject.Instance.SetChildName(fpsFunctionalname);
303  List<string> actualValues = CurrentObject.Instance.CallMethodReturn_ListString("LogSelected");
304 
305  string lvsLM = this.LM.GetMessage("LogSelected", "LogValue");
306 
307  Logger.Instance.LogPrint(lvsLM);
308 
309  Logger.Instance.ResOpenList(lvsLM);
310 
311  foreach (string Value in actualValues) {
312  Logger.Instance.LogPrint("'" + Value + "'");
313  }
314 
315  Logger.Instance.ResCloseList();
316  } catch (Exception e) {
317  this.HandleException(e);
318  } finally {
319  Logger.Instance.LogFunctionEnd();
320  }
321  }
void OKW.OK.LogTablecellValue ( string  fpsFunctionalname,
string  fpsCol,
string  fpsRow 
)

Logs the value of the selected tablecell.

/param fpsFunctionalname Functional name of the object /param fpsCol Column number of cell to be selected, starting with 1. /param fpsRow Row number of cell to be selected, starting with 1.

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic
Todo:
jnic–>Beschreibung überprüfen

Implements OKW.IOKW_State.

329  {
330  Logger.Instance.LogFunctionStart(
331  "LogTablecellValue",
332  "fpsCol", fpsCol,
333  "fpsRow", fpsRow,
334  "fpsFunctionalname", fpsFunctionalname);
335 
336  try {
337  CurrentObject.Instance.SetChildName(fpsFunctionalname);
338  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("LogTablecellValue", fpsCol, fpsRow);
339 
340  Logger.Instance.ResOpenList("Log... ");
341 
342  foreach (string Value in ActualValues) {
343  Logger.Instance.LogPrint(">>" + Value + "<<");
344  }
345 
346  Logger.Instance.ResCloseList();
347  } catch (Exception e) {
348  this.HandleException(e);
349  } finally {
350  Logger.Instance.LogFunctionEnd();
351  }
352  }
void OKW.OK.LogTooltip ( string  fpsFunctionalname)

Logs the Tooltip of the given object.

Example: Logs the tooltip text of "My Object":

LogToolip: "MyObject"

/param fpsFunctionalname Functional name of the object

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

360  {
361  Logger.Instance.LogFunctionStart("LogTooltip",
362  "fpsFunctionalname", fpsFunctionalname);
363 
364  try {
365  CurrentObject.Instance.SetChildName(fpsFunctionalname);
366  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("LogTooltip");
367 
368  Logger.Instance.ResOpenList("Log... ");
369 
370  foreach (string Value in ActualValues) {
371  Logger.Instance.LogPrint(">>" + Value + "<<");
372  }
373 
374  Logger.Instance.ResCloseList();
375  } catch (Exception e) {
376  this.HandleException(e);
377  } finally {
378  Logger.Instance.LogFunctionEnd();
379  }
380  }
void OKW.OK.LogValue ( string  fpsFunctionalname)

Logs the standard value of an object.

The standard value of the object (in most cases the visible text) is detected and returned in the actual log-file
Example: Check if the value (text) of object "MyObject" equals the expected value "Django":

Verify Value: "MyObject", "Django"

/param fpsFunctionalname Functional name of the object

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

388  {
389  Logger.Instance.LogFunctionStart("LogValue",
390  "fpsFunctionalname", fpsFunctionalname);
391 
392  try {
393  CurrentObject.Instance.SetChildName(fpsFunctionalname);
394  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("LogValue");
395 
396  Logger.Instance.ResOpenList("Log... ");
397 
398  foreach (string Value in ActualValues) {
399  Logger.Instance.LogPrint(">>" + Value + "<<");
400  }
401 
402  Logger.Instance.ResCloseList();
403  } catch (Exception e) {
404  this.HandleException(e);
405  } finally {
406  Logger.Instance.LogFunctionEnd();
407  }
408  }
void OKW.OK.MemorizeCaption ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

No description for "MemorizeCaptione" available.

/param fpsFunctionalname Functional name of the object /param fpsMemKeyName Name of the key

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic
Todo:
jnic–>keine Beschreibung vorhanden

Implements OKW.IOKW_State.

416  {
417  Logger.Instance.LogFunctionStart("MemorizeCaption",
418  "fpsFunctionalname", fpsFunctionalname,
419  "fps_MemKeyName", fps_MemKeyName);
420 
421  try {
422  CurrentObject.Instance.SetChildName(fpsFunctionalname);
423  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("MemorizeCaption");
424 
425  string lvsToMemorize = OKWConst.Instance.ConcatSEP(ActualValues);
426 
427  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsToMemorize);
428  } catch (Exception e) {
429  this.HandleException(e);
430  } finally {
431  Logger.Instance.LogFunctionEnd();
432  }
433  }
void OKW.OK.MemorizeExists ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

Memorizes the actual existing Status of the object.

The value is stored under the key returned as parameter.
Example: Memorizes the existent state of the object "My Object" under the key "My Key":

Memorize Exists: "MyObject", "MyKey"

/param fpsFunctionalname Functional name of the object /param fpsMemKeyName Name of the key

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

441  {
442  Logger.Instance.LogFunctionStart("MemorizeExists",
443  "fpsFunctionalname", fpsFunctionalname,
444  "fps_MemKeyName", fps_MemKeyName);
445 
446  try {
447  CurrentObject.Instance.SetChildName(fpsFunctionalname);
448  bool lvbActual = CurrentObject.Instance.CallMethodReturn_Boolean("MemorizeExists");
449 
450  string lvsActual = OKWConst.Instance.Boolean2YesNo(lvbActual);
451 
452  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsActual);
453  } catch (Exception e) {
454  this.HandleException(e);
455  } finally {
456  Logger.Instance.LogFunctionEnd();
457  }
458  }
void OKW.OK.MemorizeHasFocus ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

No description for "MemorizeHasFocus" available.

/param fpsFunctionalname Functional name of the object /param fpsMemKeyName Name of the key

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic
Todo:
jnic–>keine Beschreibung vorhanden

Implements OKW.IOKW_State.

466  {
467  Logger.Instance.LogFunctionStart("MemorizeHasFocus",
468  "fpsFunctionalname", fpsFunctionalname,
469  "fps_MemKeyName", fps_MemKeyName);
470 
471  try {
472  CurrentObject.Instance.SetChildName(fpsFunctionalname);
473  bool lvbActual = CurrentObject.Instance.CallMethodReturn_Boolean("MemorizeHasFocus");
474 
475  string lvsActual = OKWConst.Instance.Boolean2YesNo(lvbActual);
476 
477  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsActual);
478  } catch (Exception e) {
479  this.HandleException(e);
480  } finally {
481  Logger.Instance.LogFunctionEnd();
482  }
483  }
void OKW.OK.MemorizeIsActive ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

Memorizes the state of the given object.

The value is stored under the key which is given as parameter.
Example Memorizes the object-state of MyObject under the key "MyKey":

Memorize Is Active: "MyObject", "MyKey"

/param fpsFunctionalname Functional name of the object /param fpsMemKeyName Name of the key

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

491  {
492  Logger.Instance.LogFunctionStart("MemorizeIsActive",
493  "fpsFunctionalname", fpsFunctionalname,
494  "fps_MemKeyName", fps_MemKeyName);
495 
496  try {
497  CurrentObject.Instance.SetChildName(fpsFunctionalname);
498  bool lvbActual = CurrentObject.Instance.CallMethodReturn_Boolean("MemorizeIsActive");
499 
500  string lvsActual = OKWConst.Instance.Boolean2YesNo(lvbActual);
501 
502  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsActual);
503  } catch (Exception e) {
504  this.HandleException(e);
505  } finally {
506  Logger.Instance.LogFunctionEnd();
507  }
508  }
void OKW.OK.MemorizeLabel ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

No description for "MemorizeLabel" available.

/param fpsFunctionalname Functional name of the object /param fpsMemKeyName Name of the key

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic
Todo:
jnic–>keine Beschreibung vorhanden

Implements OKW.IOKW_State.

516  {
517  Logger.Instance.LogFunctionStart("MemorizeLabel",
518  "fpsFunctionalname", fpsFunctionalname,
519  "fps_MemKeyName", fps_MemKeyName);
520 
521  try {
522  CurrentObject.Instance.SetChildName(fpsFunctionalname);
523  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("MemorizeLabel");
524 
525  string lvsToMemorize = OKWConst.Instance.ConcatSEP(ActualValues);
526 
527  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsToMemorize);
528  } catch (Exception e) {
529  this.HandleException(e);
530  } finally {
531  Logger.Instance.LogFunctionEnd();
532  }
533  }
void OKW.OK.MemorizeSelectedValue ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

No description for "MemorizeSelectedValue" available.

/param fpsFunctionalname Functional name of the object /param fpsMemKeyName Name of the key

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic
Todo:
jnic–>keine Beschreibung vorhanden

Implements OKW.IOKW_State.

541  {
542  Logger.Instance.LogFunctionStart("MemorizeSelectedValue",
543  "fpsFunctionalname", fpsFunctionalname,
544  "fps_MemKeyName", fps_MemKeyName);
545 
546  try {
547  CurrentObject.Instance.SetChildName(fpsFunctionalname);
548  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("MemorizeSelectedValue");
549 
550  string lvsToMemorize = OKWConst.Instance.ConcatSEP(ActualValues);
551 
552  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsToMemorize);
553  } catch (Exception e) {
554  this.HandleException(e);
555  } finally {
556  Logger.Instance.LogFunctionEnd();
557  }
558  }
void OKW.OK.MemorizeTablecellValue ( string  fpsFunctionalname,
string  fpsCol,
string  fpsRow,
string  fps_MemKeyName 
)

Memorizes the value of the given tablecell.

/param fpsFunctionalname Functional name of the object /param fpsMemKeyName Name of the key /param fpsCol Column number of cell to be selected, starting with 1. /param fpsRow Row number of cell to be selected, starting with 1.

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

566  {
567  Logger.Instance.LogFunctionStart("MemorizeTablecellValue",
568  "fpsFunctionalname", fpsFunctionalname,
569  "fpsCol", fpsCol,
570  "fpsRow", fpsRow,
571  "fps_MemKeyName", fps_MemKeyName);
572 
573  try {
574  CurrentObject.Instance.SetChildName(fpsFunctionalname);
575  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("MemorizeTablecellValue", fpsCol, fpsRow);
576 
577  string lvsToMemorize = OKWConst.Instance.ConcatSEP(ActualValues);
578 
579  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsToMemorize);
580  } catch (Exception e) {
581  this.HandleException(e);
582  } finally {
583  Logger.Instance.LogFunctionEnd();
584  }
585  }
void OKW.OK.MemorizeTooltip ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

Logs the tooltip-text of the given object.

Example logs the tooltip text of the given object "my object"

Logge Tooltip: "MeinObjekt"

/param fpsFunctionalname Functional name of the object /param fpsMemKeyName Name of the key

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

593  {
594  Logger.Instance.LogFunctionStart("MemorizeTooltip",
595  "fpsFunctionalname", fpsFunctionalname,
596  "fps_MemKeyName", fps_MemKeyName);
597 
598  try {
599  CurrentObject.Instance.SetChildName(fpsFunctionalname);
600  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("MemorizeTooltip");
601 
602  string lvsToMemorize = OKWConst.Instance.ConcatSEP(ActualValues);
603 
604  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsToMemorize);
605  } catch (Exception e) {
606  this.HandleException(e);
607  } finally {
608  Logger.Instance.LogFunctionEnd();
609  }
610  }
void OKW.OK.MemorizeValue ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

No description for "MemorizeLabel" available.

/param fpsFunctionalname Functional name of the object /param fpsMemKeyName Name of the key

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic
Todo:
jnic–>keine Beschreibung vorhanden

Implements OKW.IOKW_State.

618  {
619  Logger.Instance.LogFunctionStart("MemorizeValue",
620  "fpsFunctionalname", fpsFunctionalname,
621  "fpsMemKeyName", fps_MemKeyName);
622 
623  try {
624  CurrentObject.Instance.SetChildName(fpsFunctionalname);
625  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("MemorizeValue");
626 
627  string lvsToMemorize = OKWConst.Instance.ConcatSEP(ActualValues);
628 
629  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsToMemorize);
630  } catch (Exception e) {
631  this.HandleException(e);
632  } finally {
633  Logger.Instance.LogFunctionEnd();
634  }
635  }
void OKW.OK.Select ( string  fpsFunctionalname,
string  fpsValue 
)

Select all rows in a list/chart, which contain the given data.

Chart columns are merged row by row to process lists and charts identical. The first row which contains the given data will be selected. The row is selected by a single click. The delivery of an additional parameter "Doubleclick" leads to the use of a doubleclick. The {HSEP}-constant can be used, if defined values in multiple columns are required.
Example #1: Select all rows which contain the text "Value":

Select: "MyTable", "Value"


Example #2: Select all rows which contain the text "Value1" in the first column, followed by the text "Value2" in any of the remaining columns: 

Select: "MyTable", "Value1{HSEP}Value2"


Example #3: Select all rows which contain the text "Value1", followed by any (or no) text in the first column, followed by an empty column, followed by the text "Value2" in the third column: 

Select: "MyTable", "Value1{HSEP}{HSEP}Value2"

/param fpsFunctionalname Functional name of the object /param fpsValue Resulting value

Author
Zoltan Hrabovszki
Date
2014-09-19

Implements OKW.IOKW_State.

643  {
644  Logger.Instance.LogFunctionStart("Select",
645  "fpsFunctionalname", fpsFunctionalname,
646  "fpsValue", fpsValue);
647  try {
648  // Prüfen ob ignoriert werden muss...
649  if (fpsValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsValue == String.Empty) {
650  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
651  // \todo TODO: Meldung sprachabhägig auslagern!
652  Logger.Instance.LogPrintDebug("Ignore...");
653  } else {
654  // Sonst Methode des Objektes aufrufen....
655  List<string> lvlsValue = OKWConst.Instance.SplitSEP(fpsValue);
656 
657  lvlsValue = MyParser.ParseMe(lvlsValue);
658 
659  CurrentObject.Instance.SetChildName(fpsFunctionalname);
660  CurrentObject.Instance.CallMethod("Select", lvlsValue);
661  }
662  } catch (Exception e) {
663  this.HandleException(e);
664  } finally {
665  Logger.Instance.LogFunctionEnd();
666  }
667 
668  return;
669  }
void OKW.OK.Select ( string  fpsFunctionalname,
string  fpsValue,
string  fpsClickType 
)

Select all rows in a list/chart, which contain the given data.

Chart columns are merged row by row to process lists and charts identical. The first row which contains the given data will be selected. The row is selected by a single click. The delivery of an additional parameter "Doubleclick" leads to the use of a doubleclick. The {HSEP}-constant can be used, if defined values in multiple columns are required.
Example #1: Select all rows which contain the text "Value":

Select: "MyTable", "Value"


Example #2: Select all rows which contain the text "Value1" in the first column, followed by the text "Value2" in any of the remaining columns: 

Select: "MyTable", "Value1{HSEP}Value2"


Example #3: Select all rows which contain the text "Value1", followed by any (or no) text in the first column, followed by an empty column, followed by the text "Value2" in the third column: 

Select: "MyTable", "Value1{HSEP}{HSEP}Value2"

/param fpsFunctionalname Functional name of the object /param fpsValue Resulting value /param fpsClickType Doubleclick" to select via doubleclick, "Singleclick" to select via singleclick (default)

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

677  {
678  Logger.Instance.LogFunctionStart("Select",
679  "fpsFunctionalname", fpsFunctionalname,
680  "fpsValue", fpsValue,
681  "fpsClickType", fpsClickType);
682  try {
683  // Prüfen ob ignoriert werden muss...
684  if (fpsValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsValue == String.Empty) {
685  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
686  // \todo TODO: Meldung sprachabhägig auslagern!
687  Logger.Instance.LogPrintDebug("Ignore...");
688  } else {
689  List<string> lvlsValue = OKWConst.Instance.SplitSEP(fpsValue);
690 
691  lvlsValue = MyParser.ParseMe(lvlsValue);
692 
693  CurrentObject.Instance.SetChildName(fpsFunctionalname);
694 
695  // TODO: Select - Sprachabhängigkeit von KlickType einbauen...
696  CurrentObject.Instance.CallMethod("Select_Clicktype", lvlsValue, fpsClickType);
697  }
698  } catch (Exception e) {
699  this.HandleException(e);
700  } finally {
701  Logger.Instance.LogFunctionEnd();
702  }
703  }
void OKW.OK.SelectMenu ( string  fpsFunctionalname)

Selects the given menu item.

Example Select menu item with name "MyMenu": 

Select menu: "MyMenu"

/param fpsFunctionalname Functional name of the object

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

711  {
712  Logger.Instance.LogFunctionStart("SelectMenu",
713  "fpsFunctionalname", fpsFunctionalname);
714 
715  try {
716  CurrentObject.Instance.SetChildName(fpsFunctionalname);
717  CurrentObject.Instance.CallMethod("SelectMenu");
718  } catch (Exception e) {
719  this.HandleException(e);
720  } finally {
721  Logger.Instance.LogFunctionEnd();
722  }
723  }
void OKW.OK.SelectMenu ( string  fpsFunctionalname,
string  fpsValue 
)

Selects the given menu item.

Example Select menu item with name "MyMenu": 

Select menu: "MyMenu"

/param fpsFunctionalname Functional name of the object /param fpsValue Resulting value

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

731  {
732  Logger.Instance.LogFunctionStart("SelectMenu",
733  "fpsFunctionalname", fpsFunctionalname,
734  "fpsValue", fpsValue);
735 
736  List<string> lvlsValue = OKWConst.Instance.SplitSEP(fpsValue);
737 
738  try {
739  CurrentObject.Instance.SetChildName(fpsFunctionalname);
740  CurrentObject.Instance.CallMethod("SelectMenu_Value", lvlsValue);
741  } catch (Exception e) {
742  this.HandleException(e);
743  } finally {
744  Logger.Instance.LogFunctionEnd();
745  }
746  }
void OKW.OK.SelectTablecell ( string  fpsFunctionalname,
string  fpsCol,
string  fpsRow 
)

Selects the given table cell.

The column and row positions are always entered as strings. If such a parameter is starting with a hash (#) the string is interpreted as an index number, e.g. "#1"). If a hash sign should be interpreted as text it must signed with a backslash, e.g. "\#1 text with leading number").

The header row is addressed with the index "0". The first data row starts with the index 1. For tables with multiline headers the offset to the first data row can be set The column index starts with the number 1.
Example #1: Select cell at first column with text "Toni" and row with number 3: 

Select Tablecell: "MyTable", "Toni", "#3"

Example #2: Select cell at column with number 1 and row with name "Address": 

Select Tablecell: "MyTable", "#1", "Address"

Example #3: Select cell at column number 1 and row 1: 

Select Tablecell: "MyTable", "#1", "#1"

Example #4: Select cell at col number 1 and first row with text "42": 

Select Tablecell: "MyTable", "#1", "42"

/param fpsFunctionalname Functional name of the object /param fpsCol Column number of cell to be selected, starting with 1. /param fpsRow Row number of cell to be selected, starting with 1.

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

754  {
755  Logger.Instance.LogFunctionStart("SelectTablecell",
756  "fpsFunctionalname", fpsFunctionalname,
757  "fpsCol", fpsCol,
758  "fpsRow", fpsRow);
759 
761 
762  try {
763  CurrentObject.Instance.SetChildName(fpsFunctionalname);
764  CurrentObject.Instance.CallMethod("SelectTablecell", fpsCol, fpsRow);
765  } catch (Exception e) {
766  this.HandleException(e);
767  } finally {
768  Logger.Instance.LogFunctionEnd();
769  }
770  }
void OKW.OK.SelectTablecell ( string  fpsFunctionalname,
string  fpsCol,
string  fpsRow,
string  fpsClickType 
)

Selects the given table cell.

The column and row positions are always entered as strings. If such a parameter is starting with a hash (#) the string is interpreted as an index number, e.g. "#1"). If a hash sign should be interpreted as text it must signed with a backslash, e.g. "\#1 text with leading number"). The header row is addressed with the index "0". The first data row starts with the index 1. For tables with multiline headers the offset to the first data row can be set The column index starts with the number 1.
Example #1: Select cell at first column with text "Toni" and row with number 3: 

Select Tablecell: "MyTable", "Toni", "#3"

Example #2: Select cell at column with number 1 and row with name "Address": 

Select Tablecell: "MyTable", "#1", "Address"

Example #3: Select cell at column number 1 and row 1: 

Select Tablecell: "MyTable", "#1", "#1"

Example #4: Select cell at col number 1 and first row with text "42": 

Select Tablecell: "MyTable", "#1", "42"

/param fpsFunctionalname Functional name of the object /param fpsClickType Doubleclick" to select via doubleclick, "Singleclick" to select via singleclick (default) /param fpsRow Row number of cell to be selected, starting with 1. /param fpsCol Column number of cell to be selected, starting with 1.

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

778  {
779  Logger.Instance.LogFunctionStart(
780  "SelectTablecell",
781  "fpsFunctionalname",
782  fpsFunctionalname,
783  "fpsCol",
784  fpsCol,
785  "fpsRow",
786  fpsRow,
787  "fpsClickType",
788  fpsClickType);
789 
790  try {
791  CurrentObject.Instance.SetChildName(fpsFunctionalname);
792  CurrentObject.Instance.CallMethod("SelectTablecell_Clicktype", fpsCol, fpsRow, fpsClickType);
793  } catch (Exception e) {
794  this.HandleException(e);
795  } finally {
796  Logger.Instance.LogFunctionEnd();
797  }
798  }
void OKW.OK.SelectWindow ( string  fpsFunctionalname)

Setting the context for the given window and ensuring that the window is active and in the foreground.

Example: Select window with name "MyWindow": 

Select Window: "MyWindow"

/param fpsFunctionalname Functional name of the object

Author
Zoltan Hrabovszki
Date
2014-09-19/jnic

Implements OKW.IOKW_State.

806  {
807  Logger.Instance.LogFunctionStart("SelectWindow",
808  "fpsFunctionalname", fpsFunctionalname);
809 
810  try {
811  CurrentObject.Instance.SetWindowName(fpsFunctionalname);
812  CurrentObject.Instance.CallMethod("SelectWindow");
813  } finally {
814  Logger.Instance.LogFunctionEnd();
815  }
816 
817  return;
818  }
void OKW.OK.Sequence ( string  fpsObjectName,
string  fpsSequenceName,
string  SEQ_ID 
)

Calls the sequence of the window.

Sequences are defined per window and have a unique sequence name within the window. Entered records are referenced with the sequence ID.

Example: Calling the sequence _Login of the window Login with the record Administrator:_ 

Sequence: "Login", "Login" = "Administrator"

/param fpsFunctionalname Functional name of the object /param fpsSequenceName No explanation available /param SEQ_ID No explanation available

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic
Todo:
jnic–>Beschreibung erledigt 2014-10-26

Implements OKW.IOKW_State.

826  {
827  Logger.Instance.LogFunctionStart("Sequence",
828  "fpsObjectName", fpsObjectName,
829  "fpsSequenceName", fpsSequenceName,
830  "SEQ_ID", SEQ_ID);
831 
832  try {
833  // Prüfen ob ignoriert werden muss...
834  if (SEQ_ID == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || SEQ_ID == String.Empty) {
835  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
836  // \todo TODO: Meldung sprachabhägig auslagern!
837  Logger.Instance.LogPrintDebug("Ignore...");
838  } else {
839  CurrentObject.Instance.SetWindowName(fpsObjectName);
840  CurrentObject.Instance.CallMethod(fpsSequenceName, SEQ_ID);
841  }
842  } catch (Exception e) {
843  this.HandleException(e);
844  } finally {
845  Logger.Instance.LogFunctionEnd();
846  }
847  }
void OKW.OK.SetFocus ( string  fpsFunctionalname)

Setting the focus to the given window object.

/param fpsFunctionalname Functional name of the object

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic

Implements OKW.IOKW_State.

855  {
856  Logger.Instance.LogFunctionStart("SetFocus",
857  "fpsFunctionalname", fpsFunctionalname);
858 
859  try {
860  CurrentObject.Instance.SetChildName(fpsFunctionalname);
861  CurrentObject.Instance.CallMethod("SetFocus");
862  } catch (Exception e) {
863  this.HandleException(e);
864  } finally {
865  Logger.Instance.LogFunctionEnd();
866  }
867  }
void OKW.OK.SetLanguage ( string  Language)
Author
Zoltán Hrabovszki
Date
02.03.2013

Implements OKW.IOKW_State.

875  {
876  this.AL.Language = Language;
877  }
void OKW.OK.SetValue ( string  fpsFunctionalname,
string  fpsValue 
)

Setting the value of the given window object to the given value.

The input is not working with the simulation of single keyboard inputs, but with High-Level Setter-Methods of the objects:
Inputs of the object are written over with "fpsValue".

Example: Set the value of the objekt "MyWindow" to "Hello": 

Set Value: "MyWindow", "Hello"

/param fpsFunctionalname Functional name of the object /param fpsValue Resulting value

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic
Todo:
–>jnic - Beschreibung bearbeitet 2014-10-26

Implements OKW.IOKW_State.

885  {
886  Logger.Instance.LogFunctionStart("SetValue",
887  "fpsFunctionalname", fpsFunctionalname);
888 
889  List<string> lvlsValue;
890 
891  try {
892  // Prüfen ob ignoriert werden muss...
893  if (fpsValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsValue == String.Empty) {
894  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
895  // \todo TODO: Meldung sprachabhägig auslagern!
896  Logger.Instance.LogPrintDebug("Ignore...");
897  } else {
898  lvlsValue = OKWConst.Instance.SplitSEP(fpsValue);
899 
900  lvlsValue = MyParser.ParseMe(lvlsValue);
901 
902  CurrentObject.Instance.SetChildName(fpsFunctionalname);
903  CurrentObject.Instance.CallMethod("SetValue", lvlsValue);
904  }
905  } catch (Exception e) {
906  this.HandleException(e);
907  } finally {
908  Logger.Instance.LogFunctionEnd();
909  }
910  }
void OKW.OK.StartApp ( string  fps_ApplikationName)

Starts the given application.

Example: Order to start the application "InternetExplorer": 

Start Application: "InternetExplorer"
Remarks
Te method "StartApp()" must be implemented in the class "fpsApplikatioName". The technical identifier must not inevitably be identical to the name of the exe file: here we hav e a mapping between the technical identifier and the invoked "*.exe"
An example how a full Implementation can look at, is to be find in SeInternetExplorerApp.StartApp

/param fpsApplicationName No explanation available

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic
Todo:
jnic–>Beschreibung angepasst 2014-10-26

Implements OKW.IOKW_State.

918  {
919  Logger.Instance.LogFunctionStart("StartApp",
920  "fps_ApplikationName", fps_ApplikationName);
921 
922  try {
923  CurrentObject.Instance.SetWindowName(fps_ApplikationName);
924  CurrentObject.Instance.CallMethod("StartApp");
925  } catch (Exception e) {
926  this.HandleException(e);
927  } finally {
928  Logger.Instance.LogFunctionEnd();
929  }
930  }
void OKW.OK.StopApp ( string  fps_ApplikationName)

Ends a given application.

Example: Order to start the application "InternetExplorer": 

End Application: "InternetExplorer"
Remarks
The method "StopApp()" must be implemented in the class "fpsApplikatioName" The framework is not able to know, how a specific application is to be closed. The must be fully implemented specific to the project.
An example, how the full implementation can look at is to be find at SeInternetExplorerApp.StopApp.

/param fpsApplicationName The technical name of the application

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic todo jnic–>Beschreibung angepasst 2014-10-26

Implements OKW.IOKW_State.

938  {
939  Logger.Instance.LogFunctionStart("StopApp",
940  "fps_ApplikationName", fps_ApplikationName);
941 
942  try {
943  CurrentObject.Instance.SetWindowName(fps_ApplikationName);
944  CurrentObject.Instance.CallMethod("StopApp");
945  } catch (Exception e) {
946  this.HandleException(e);
947  } finally {
948  Logger.Instance.LogFunctionEnd();
949  }
950  }
void OKW.OK.TypeKey ( string  fpsFunctionalname,
string  fpsValue 
)

Keyboard inputs of data in the active windows object.

The data are sent as keyboard inputs to the child object of the active window. This enables the use of hot keys and function keys as input data. If with help of the valueseparator (SEP) multiple values are passed in the parameter, ​​then all values ​​are sent as keyboard input to the window object, separated by a line break.

Example: "Simple Input":

Type Key: "MyWindowObjekt", "InputValue"

Example: "Input of constant value":

Type Key: "MainWindow", "{F2}"

Example: "Input of more than one value":

Type Key: "MyWindowObjekt", "InputValue1{SEP}InputValue2"

/param fpsFunctionalname Functional name of the object /param fpsValue Resulting value

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic

Implements OKW.IOKW_State.

958  {
959  Logger.Instance.LogFunctionStart("TypeKey",
960  "fpsFunctionalname", fpsFunctionalname,
961  "fpsValue", fpsValue);
962 
963  List<string> lvlsValue;
964 
965  try {
966  // Prüfen ob ignoriert werden muss...
967  if (fpsValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsValue == String.Empty) {
968  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
969  // \todo TODO: Meldung sprachabhägig auslagern!
970  Logger.Instance.LogPrintDebug("Ignore...");
971  } else {
972  lvlsValue = OKWConst.Instance.SplitSEP(fpsValue);
973 
974  lvlsValue = MyParser.ParseMe(lvlsValue);
975 
976  CurrentObject.Instance.SetChildName(fpsFunctionalname);
977  CurrentObject.Instance.CallMethod("TypeKey", lvlsValue);
978  }
979  } catch (Exception e) {
980  this.HandleException(e);
981  } finally {
982  Logger.Instance.LogFunctionEnd();
983  }
984  }
void OKW.OK.TypeKeyTablecell ( string  fpsFunctionalname,
string  fpsCol,
string  fpsRow,
string  fpsValue 
)

Input of date to a given tablecell by the keyboard.

The data are sent as keyboard inputs to the given tablecell. This ensures the use of hotkeys and functional tabs as input data. The parameters of the row and column positions are always set as strings. If such a parameter is starting with a hash (#) the string is interpreted as an index number, e.g. "#1"). If a hash sign should be interpreted as text it must signed with a backslash, e.g. "\#1 text with leading number"). The header row is adressed with the index "0". The first data row starts with the index 1. For tables with multiline headers the offset to the first data row can be set The column index starts with the number 1.
Example #1: Simple Input in cell at column 2 and row 5: 

Type Key Tablecell: "MyTable", 2, 5, "InputValue"

Example #2: Simple Input in cell at first column with text "Toni" and row with name "Tester": 

Type Key Tablecell: "MyTable", "Toni", "Tester", "InputValue"

Example #3: Simple Input in cell at first column with text "Toni" and row with number 3: 

Type Key Tablecell: "MyTable", "Toni", 3, "InputValue"

Example #4: Simple Input in cell at column with number 1 and row with name "Address": 

Type Key Tablecell: "MyTable", 1, "Address", "InputValue"

Example #5: Input of constant value named "F2" in cell at column number 1 and row 1: 

Type Key Tablecell: "MyTable", 1, 1, "{F2}"

Example #6: Input of more than one value in cell at first column with text "Ernie" and third row: 

Type Key Tablecell: "MyTable", "Ernie", 3, "InputValue1{SEP}InputValue2"

Example #7: Input of value "Hiho" into cell at column number 1 and first row with text "42": 

Type Key Tablecell: "MyTable", "#1", "42", "HiHo"

/param fpsFunctionalname Functional name of the object /param fpsValue Resulting value /param fpsRow Row number of cell to be selected, starting with 1. /param fpsCol Column number of cell to be selected, starting with 1.

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic

Implements OKW.IOKW_State.

992  {
993  Logger.Instance.LogFunctionStart("TypeKeyTablecell",
994  "fpsFunctionalname", fpsFunctionalname,
995  "fpsColl", fpsCol,
996  "fpsRow", fpsRow,
997  "fpsValue", fpsValue);
998 
999  List<string> lvlsValue;
1000 
1001  try {
1002  // Prüfen ob ignoriert werden muss...
1003  if (fpsValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsValue == String.Empty) {
1004  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1005  // \todo TODO: Meldung sprachabhägig auslagern!
1006  Logger.Instance.LogPrintDebug("Ignore...");
1007  } else {
1008  // Werte in fpsValue separieren
1009  lvlsValue = OKWConst.Instance.SplitSEP(fpsValue);
1010 
1011  lvlsValue = MyParser.ParseMe(lvlsValue);
1012 
1013  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1014  CurrentObject.Instance.CallMethod("TypeKeyTablecell", fpsCol, fpsRow, lvlsValue);
1015  }
1016  } catch (Exception e) {
1017  this.HandleException(e);
1018  } finally {
1019  Logger.Instance.LogFunctionEnd();
1020  }
1021  }
void OKW.OK.TypeKeyWindow ( string  fpsFunctionalname,
string  fpsValue 
)

Keyboard input to a particular window object.

The data will be sent as keyboard inputs to the window object. This ensures the use of hotkeys an functional keys as input data. Multiple values can be given as input by help of the constant {SEP} (see examples). The values are divided with tabstops with the input.
Example #1: Simple Input: 

Type Key Window: "MyWindowObjekt", "InputValue"

Example #2: Input of constant value: 

Type Key Window: "MainWindow", "{F2}"

Example #3: Input of more than one value: 

Type Key Window: "MyWindowObjekt", "InputValue1{SEP}InputValue2"

/param fpsFunctionalname Functional name of the object /param fpsValue Resulting value

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic

Implements OKW.IOKW_State.

1029  {
1030  Logger.Instance.LogFunctionStart("TypeKeyWindow",
1031  "fpsFunctionalname", fpsFunctionalname,
1032  "fpsValue", fpsValue);
1033 
1034  try {
1035  // Prüfen ob ignoriert werden muss...
1036  if (fpsValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsValue == String.Empty) {
1037  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1038  // \todo TODO: Meldung sprachabhägig auslagern!
1039  Logger.Instance.LogPrintDebug("Ignore...");
1040  } else {
1041  List<string> lvlsValue = OKWConst.Instance.SplitSEP(fpsValue);
1042  lvlsValue = MyParser.ParseMe(lvlsValue);
1043 
1044  CurrentObject.Instance.SetWindowName(fpsFunctionalname);
1045  CurrentObject.Instance.CallMethod("TypeKey", lvlsValue);
1046  }
1047  } catch (Exception e) {
1048  this.HandleException(e);
1049  } finally {
1050  Logger.Instance.LogFunctionEnd();
1051  }
1052  }
void OKW.OK.VerifyCaption ( string  fpsFunctionalname,
string  fpsExpected 
)

No description for "VerifyCaption" available.

/param fpsFunctionalname Functional name of the object /param fpsExpectedValue Expected value

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic
Todo:
jnic–>keine Beschreibung vorhanden

Implements OKW.IOKW_State.

1060  {
1061  Logger.Instance.LogFunctionStart("VerifyCaption",
1062  "fpsFunctionalname", fpsFunctionalname,
1063  "fpsExpected", fpsExpected);
1064 
1065  try {
1066  // Prüfen ob ignoriert werden muss...
1067  if (fpsExpected == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpected == String.Empty) {
1068  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1069  // \todo TODO: Meldung sprachabhägig auslagern!
1070  Logger.Instance.LogPrintDebug("Ignore...");
1071  } else {
1072  // Split giveneExpected Value
1073  List<string> lvlsExpected = OKWConst.Instance.SplitSEP(fpsExpected);
1074 
1075  // Get the actuel value from object
1076  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1077  List<string> Actual = CurrentObject.Instance.CallMethodReturn_ListString("VerifyCaption", lvlsExpected);
1078 
1079  // Verify:
1080  // 1. are the length of the lists equal?
1081  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyCaption", "VerifyListCount"));
1082  Logger.Instance.LogVerify(Actual.Count.ToString(), lvlsExpected.Count.ToString());
1083 
1084  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyCaption", "VerifyValues"));
1085 
1086  for (int i = 0; i < Actual.Count; i++) {
1087  Logger.Instance.LogVerify(Actual[i], lvlsExpected[i]);
1088  }
1089  }
1090  } catch (Exception e) {
1091  this.HandleException(e);
1092  } finally {
1093  Logger.Instance.LogFunctionEnd();
1094  }
1095  }
void OKW.OK.VerifyExists ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Checks the existence of the given object.
Example #1: Check if the object MyObject exists: 

Verify Exists: "MyObject", "YES"

Example #2: Check if the object MyObject does not exist: 

Verify Exists: "MyObject", "NO"

/param fpsFunctionalname Functional name of the object /param fpsExpectedValue Expected value

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic

Implements OKW.IOKW_State.

1103  {
1104  Logger.Instance.LogFunctionStart("VerifyExists",
1105  "fpsFunctionalname", fpsFunctionalname,
1106  "fpsExpectedValue", fpsExpectedValue);
1107 
1108  try {
1109  //Hier sind nur drei werte erlaubt: YES/NO/IGNORE
1110 
1111  // Prüfen ob ignoriert werden muss...
1112  if (fpsExpectedValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1113  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1114  // \todo TODO: Meldung sprachabhägig auslagern!
1115  Logger.Instance.LogPrintDebug("Ignore...");
1116  }
1117  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
1118  else if (fpsExpectedValue == OKW.OKWConst.Instance.GetConst4Internalname("YES") || fpsExpectedValue == OKW.OKWConst.Instance.GetConst4Internalname("NO")) {
1119  // Sprachabhängiges YES/NO nach bool transformieren
1120  bool lvsbExpectedValue = OKWConst.Instance.YesNo2Boolean(fpsExpectedValue);
1121 
1122  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1123  bool lvbActual = CurrentObject.Instance.CallMethodReturn_BooleanPb("VerifyExists", lvsbExpectedValue);
1124 
1125  string lvsActual = OKWConst.Instance.Boolean2YesNo(lvbActual);
1126 
1127  // Soll/Ist Vergleich...
1128  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyExists", "VerifyValue"));
1129 
1130  // LANGUAGE: Prüfen: Sprachabhängigen string-vergleich durchführen...
1131  Logger.Instance.LogVerify(lvsActual, fpsExpectedValue);
1132  }
1133  // Beide Bedingungen sind nicht erfüllt -> Exception da keinanderer Wert hier erlaubt ist.
1134  else {
1135  throw new OKWNotAllowedValueException("Value Not Allowed here! Only YES/NO/IGNORE is a possible Value");
1136  }
1137  } catch (Exception e) {
1138  this.HandleException(e);
1139  } finally {
1140  Logger.Instance.LogFunctionEnd();
1141  }
1142  }
void OKW.OK.VerifyHasFocus ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Compares the focus status of the given object with the expected value.

Example #1: Verify if the object MyObject has the focus: 

Verify Has Focus: "MyObject", "YES"

Example #2: Verify if the object MyObject has NOT the focus: 

Verify Has Focus: "MyObject", "NO"

/param fpsFunctionalname Functional name of the object /param fpsExpectedValue Expected value. Following values are Allowed here: "YES, "NO", and "IGNORE".

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic

Implements OKW.IOKW_State.

1150  {
1151  Logger.Instance.LogFunctionStart("VerifyHasFocus",
1152  "fpsFunctionalname", fpsFunctionalname,
1153  "fpsExpectedValue", fpsExpectedValue);
1154 
1155  try {
1156  // Prüfen ob ignoriert werden muss...
1157  if (fpsExpectedValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1158  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1159  // \todo TODO: Meldung sprachabhägig auslagern!
1160  Logger.Instance.LogPrintDebug("Ignore...");
1161  }
1162  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
1163  else if (fpsExpectedValue == OKW.OKWConst.Instance.GetConst4Internalname("YES") || fpsExpectedValue == OKW.OKWConst.Instance.GetConst4Internalname("NO")) {
1164  // Sprachabhängiges YES/NO nach bool transformieren
1165  bool lvsbExpectedValue = OKWConst.Instance.YesNo2Boolean(fpsExpectedValue);
1166 
1167  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1168  bool lvbActual = CurrentObject.Instance.CallMethodReturn_BooleanPb("VerifyHasFocus", lvsbExpectedValue);
1169 
1170  string lvsActual = OKWConst.Instance.Boolean2YesNo(lvbActual);
1171 
1172  // Soll/Ist Vergleich...
1173  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyHasFocus", "VerifyValue"));
1174  Logger.Instance.LogVerify(lvsActual, fpsExpectedValue);
1175 
1176  // \todo LANGUAGE: Püfen aws dieser eintrag soll: Sprachabhängigen string-vergleich durchführen...
1177  }
1178  // Beide Bedingungen sind nicht erfüllt -> Exception da keinanderer Wert hier erlaubt ist.
1179  else {
1180  throw new OKWNotAllowedValueException("Value Not Allowed here! Only YES/NO/IGNORE is a possible Value");
1181  }
1182  } catch (Exception e) {
1183  this.HandleException(e);
1184  } finally {
1185  Logger.Instance.LogFunctionEnd();
1186  }
1187  }
void OKW.OK.VerifyIsActive ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Compares the focus status of the given object with the expected value.

Example: Verify if the object MyObject is in the state "active": 

Verify Is Active: "MyObject", "YES"

/param fpsFunctionalname Functional name of the object /param fpsExpectedValue Expected value. Following values are Allowed here: "YES, "NO", and "IGNORE".

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic

Implements OKW.IOKW_State.

1195  {
1196  Logger.Instance.LogFunctionStart("VerifyIsActive",
1197  "fpsFunctionalname", fpsFunctionalname,
1198  "fpsExpectedValue", fpsExpectedValue);
1199  try {
1200  // Prüfen ob ignoriert werden muss...
1201  if (fpsExpectedValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1202  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1203  // \todo TODO: Meldung sprachabhägig auslagern!
1204  Logger.Instance.LogPrintDebug("Ignore...");
1205  }
1206  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
1207  else if (fpsExpectedValue == OKW.OKWConst.Instance.GetConst4Internalname("YES") || fpsExpectedValue == OKW.OKWConst.Instance.GetConst4Internalname("NO")) {
1208  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1209 
1210  // Erwarteten Wert(YES/NO, Sprachabhänging) nach bool wandelen
1211  bool lvbExpectedValue = OKWConst.Instance.YesNo2Boolean(fpsExpectedValue);
1212 
1213  // Aktuellen Wert holen...
1214  bool lvbActual = CurrentObject.Instance.CallMethodReturn_BooleanPb("VerifyIsActive", lvbExpectedValue);
1215 
1216  // Aktuellen Wert nach YES/NO, Sprachabhänging, wandel...
1217  string lvsActual = OKWConst.Instance.Boolean2YesNo(lvbActual);
1218 
1219  // Soll/Ist Vergleich...
1220  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyIsActive", "VerifyValue"));
1221  Logger.Instance.LogVerify(lvsActual, fpsExpectedValue);
1222  }
1223  // Beide Bedingungen sind nicht erfüllt -> Exception da kein anderer Wert hier erlaubt ist.
1224  else {
1225  throw new OKWNotAllowedValueException("Value Not Allowed here! Only YES/NO/IGNORE is a possible Value");
1226  }
1227  } catch (Exception e) {
1228  this.HandleException(e);
1229  } finally {
1230  Logger.Instance.LogFunctionEnd();
1231  }
1232  }
void OKW.OK.VerifyLabel ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

No description for "VerifyLabel" available.

/param fpsFunctionalname Functional name of the object /param fpsExpectedValue Expected value. Following values are Allowed here: "YES, "NO", and "IGNORE".

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic
Todo:
TODO: jnic–>keine Beschreibung vorhanden

Implements OKW.IOKW_State.

1240  {
1241  Logger.Instance.LogFunctionStart("VerifyLabel",
1242  "fpsFunctionalname", fpsFunctionalname,
1243  "fpsExpected", fpsExpectedValue);
1244 
1245  try {
1246  // Prüfen ob ignoriert werden muss...
1247  if (fpsExpectedValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1248  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1249  // \todo TODO: Meldung sprachabhägig auslagern!
1250  Logger.Instance.LogPrintDebug("Ignore...");
1251  } else {
1252  // Split giveneExpected Value
1253  List<string> lvlsExpected = OKWConst.Instance.SplitSEP(fpsExpectedValue);
1254 
1255  // Get the actuel value from object
1256  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1257  List<string> Actual = CurrentObject.Instance.CallMethodReturn_ListString("VerifyLabel", lvlsExpected);
1258 
1259  // Verify:
1260  // 1. are the List length equal?
1261  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyLabel", "VerifyListCount"));
1262  Logger.Instance.LogVerify(Actual.Count.ToString(), lvlsExpected.Count.ToString());
1263 
1264  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyLabel", "VerifyValues"));
1265 
1266  for (int i = 0; i < Actual.Count; i++) {
1267  Logger.Instance.LogVerify(Actual[i], lvlsExpected[i]);
1268  }
1269  }
1270  } catch (Exception e) {
1271  this.HandleException(e);
1272  } finally {
1273  Logger.Instance.LogFunctionEnd();
1274  }
1275  }
void OKW.OK.VerifySelectedValue ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Compares the selected value of the given listobject with the expected value.

A list can be a simple list, a table or a tree-view. Expected values in tree-views are indicated with the whole hierarchy (see example). With this the hierarchical elements are divided with the separator {SEP}.
Example #1: Check if the list entry "Henry" is selected in the list "MyList": 

Verify Selected Value: "MyList", "Henry"

Example #2: Check if the entry "Names{SEP}Henry" is selected in the treeview "MyTreeview": 

Verify Selected Value: "MyTreeview", "Names{SEP}Henry"

/param fpsFunctionalname Functional name of the object /param fpsExpectedValue Expected value

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic

Implements OKW.IOKW_State.

1283  {
1284  Logger.Instance.LogFunctionStart("VerifySelectedValue",
1285  "fpsFunctionalname", fpsFunctionalname,
1286  "fpsExpected", fpsExpectedValue);
1287 
1288  try {
1289  // Prüfen ob ignoriert werden muss...
1290  if (fpsExpectedValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1291  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1292  // \todo TODO: Meldung sprachabhägig auslagern!
1293  Logger.Instance.LogPrintDebug("Ignore...");
1294  } else {
1295  // Split giveneExpected Value
1296  List<string> lvlsExpected = OKWConst.Instance.SplitSEP(fpsExpectedValue);
1297 
1298  // Get the actuel value from object
1299  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1300  List<string> Actual = CurrentObject.Instance.CallMethodReturn_ListString("VerifySelectedValue", lvlsExpected);
1301 
1302  // Verify:
1303  // 1. are the List length equal?
1304  Logger.Instance.LogPrint(this.LM.GetMessage("VerifySelectedValue", "VerifyListCount"));
1305  Logger.Instance.LogVerify(Actual.Count.ToString(), lvlsExpected.Count.ToString());
1306 
1307  Logger.Instance.LogPrint(this.LM.GetMessage("VerifySelectedValue", "VerifyValues"));
1308 
1309  for (int i = 0; i < Actual.Count; i++) {
1310  Logger.Instance.LogVerify(Actual[i], lvlsExpected[i]);
1311  }
1312  }
1313  } catch (Exception e) {
1314  this.HandleException(e);
1315  } finally {
1316  Logger.Instance.LogFunctionEnd();
1317  }
1318  }
void OKW.OK.VerifyTablecellValue ( string  fpsFunctionalname,
string  fpsCol,
string  fpsRow,
string  fpsExpectedValue 
)

Compares the content of the given table cell with the expected value.

/param fpsFunctionalname Functional name of the object /param fpsExpectedValue Expected value /param fpsRow Row number of cell to be selected, starting with 1. /param fpsCol Column number of cell to be selected, starting with 1.

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic

Implements OKW.IOKW_State.

1326  {
1327  Logger.Instance.LogFunctionStart("VerifyTablecellValue",
1328  "fpsFunctionalname", fpsFunctionalname,
1329  "fpsCol", fpsCol,
1330  "fpsRow", fpsRow,
1331  "fpsExpected", fpsExpectedValue);
1332 
1333  try {
1334  // Prüfen ob ignoriert werden muss...
1335  if (fpsExpectedValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1336  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1337  // \todo TODO: Meldung sprachabhägig auslagern!
1338  Logger.Instance.LogPrintDebug("Ignore...");
1339  } else {
1340  // Split giveneExpected Value
1341  List<string> lvlsExpected = OKWConst.Instance.SplitSEP(fpsExpectedValue);
1342 
1343  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1344  List<string> Actual = CurrentObject.Instance.CallMethodReturn_ListString("VerifyTablecellValue", fpsCol, fpsRow, lvlsExpected);
1345 
1346  // Verify:
1347  // 1. are the List length equal?
1348  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyTablecellValue", "VerifyListCount"));
1349  Logger.Instance.LogVerify(Actual.Count.ToString(), lvlsExpected.Count.ToString());
1350 
1351  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyTablecellValue", "VerifyValues"));
1352 
1353  for (int i = 0; i < Actual.Count; i++) {
1354  Logger.Instance.LogVerify(Actual[i], lvlsExpected[i]);
1355  }
1356  }
1357  } catch (Exception e) {
1358  this.HandleException(e);
1359  } finally {
1360  Logger.Instance.LogFunctionEnd();
1361  }
1362  }
void OKW.OK.VerifyTooltip ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

No description for "VerifyTooltip" available.

/param fpsFunctionalname Functional name of the object /param fpsExpectedValue Expected value

Author
Zoltan Hrabovszki
Date
2014-09-21/jnic
Todo:
TODO: jnic–>keine Beschreibung vorhanden

Implements OKW.IOKW_State.

1370  {
1371  Logger.Instance.LogFunctionStart("VerifyTooltip",
1372  "fpsFunctionalname", fpsFunctionalname,
1373  "fpsExpected", fpsExpectedValue);
1374 
1375  try {
1376  // Prüfen ob ignoriert werden muss...
1377  if (fpsExpectedValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1378  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1379  // \todo TODO: Meldung sprachabhägig auslagern!
1380  Logger.Instance.LogPrintDebug("Ignore...");
1381  } else {
1382  // Split giveneExpected Value
1383  List<string> lvlsExpected = OKWConst.Instance.SplitSEP(fpsExpectedValue);
1384 
1385  // Get the actuel value from object
1386  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1387  List<string> Actual = CurrentObject.Instance.CallMethodReturn_ListString("VerifyTooltip", lvlsExpected);
1388 
1389  // Verify:
1390  // 1. are the List length equal?
1391  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyTooltip", "VerifyListCount"));
1392  Logger.Instance.LogVerify(Actual.Count.ToString(), lvlsExpected.Count.ToString());
1393 
1394  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyTooltip", "VerifyValues"));
1395 
1396  for (int i = 0; i < Actual.Count; i++) {
1397  Logger.Instance.LogVerify(Actual[i], lvlsExpected[i]);
1398  }
1399  }
1400  } catch (Exception e) {
1401  this.HandleException(e);
1402  } finally {
1403  Logger.Instance.LogFunctionEnd();
1404  }
1405  }
void OKW.OK.VerifyValue ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Checks the standard value of an object (in most cases this is the displayed text).

Example: Check if the value (text) of object "MyObject" equals the expected value "Django":

Verify Value: "MyObject", "Django"

/param fpsFunctionalname Functional name of the object /param fpsExpectedValue Expected value

Author
Zoltan Hrabovszki
Date
2014-09-21/ jnic

Implements OKW.IOKW_State.

1413  {
1414  Logger.Instance.LogFunctionStart("VerifyValue",
1415  "fpsFunctionalname", fpsFunctionalname,
1416  "fpsExpected", fpsExpectedValue);
1417 
1418  try {
1419  // Prüfen ob ignoriert werden muss...
1420  if (fpsExpectedValue == OKW.OKWConst.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1421  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
1422  // \todo TODO: Meldung sprachabhägig auslagern!
1423  Logger.Instance.LogPrintDebug("Ignore...");
1424  } else {
1425  // Split giveneExpected Value
1426  List<string> lvlsExpected = OKWConst.Instance.SplitSEP(fpsExpectedValue);
1427 
1428  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1429  List<string> Actual = CurrentObject.Instance.CallMethodReturn_ListString("VerifyValue", lvlsExpected);
1430 
1431  // Verify:
1432  // 1. are the List length equal?
1433  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyValue", "VerifyListCount"));
1434  Logger.Instance.LogVerify(Actual.Count.ToString(), lvlsExpected.Count.ToString());
1435 
1436  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyValue", "VerifyValues"));
1437 
1438  for (int i = 0; i < Actual.Count; i++) {
1439  Logger.Instance.LogVerify(Actual[i], lvlsExpected[i]);
1440  }
1441  }
1442  } catch (Exception e) {
1443  this.HandleException(e);
1444  } finally {
1445  Logger.Instance.LogFunctionEnd();
1446  }
1447  }
The documentation for this class was generated from the following file: