testautomation/global/tools/includes/optional/t_key_tools.inc

   1 'encoding UTF-8  Do not remove or change this line!
   2 '**************************************************************************
   3 '* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4 '*
   5 '* Copyright 2008 by Sun Microsystems, Inc.
   6 '*
   7 '* OpenOffice.org - a multi-platform office productivity suite
   8 '*
   9 '* $RCSfile: t_key_tools.inc,v $
  10 '*
  11 '* $Revision: 1.1 $
  12 '*
  13 '* last change: $Author: jsk $ $Date: 2008-06-20 07:58:19 $
  14 '*
  15 '* This file is part of OpenOffice.org.
  16 '*
  17 '* OpenOffice.org is free software: you can redistribute it and/or modify
  18 '* it under the terms of the GNU Lesser General Public License version 3
  19 '* only, as published by the Free Software Foundation.
  20 '*
  21 '* OpenOffice.org is distributed in the hope that it will be useful,
  22 '* but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 '* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 '* GNU Lesser General Public License version 3 for more details
  25 '* (a copy is included in the LICENSE file that accompanied this code).
  26 '*
  27 '* You should have received a copy of the GNU Lesser General Public License
  28 '* version 3 along with OpenOffice.org.  If not, see
  29 '* <http://www.openoffice.org/license.html>
  30 '* for a copy of the LGPLv3 License.
  31 '*
  32 '/************************************************************************
  33 '*
  34 '* owner : joerg.skottke@sun.com
  35 '*
  36 '* short description : tools for evaluation of key=value datalists
  37 '*
  38 '*******************************************************************************
  39 ' **
  40 ' #1 hGetDataPairAsString     ' retrieve key=value from a list
  41 ' #1 hGetValueForPairAsString ' retrieve value from a key=value as string
  42 ' #1 hGetValueForPairAsLong   ' retrieve value from a key=value as long integer
  43 ' #1 hGetValueForKeyAsInt     ' retrieve value for a specified key as integer
  44 ' #1 hGetValueForKeyAsLong    ' retrieve value for a specified key as long integer
  45 ' #1 hGetKeyForPairAsString   ' retrieve key from key=value as string
  46 ' #1 hGetKeyForValueAsString  ' retrieve key for a specified value as string
  47 ' #1 hGetKeyForValueAsInt     ' retrieve key for a specified value as int
  48 ' #1 hGetIndexForKeyAsInt     ' retrieve the index for a key in a list
  49 ' #1 KeyCompare               ' compare two keys
  50 ' **
  51 '\******************************************************************************
  52
  53 ' Some variables explained:
  54 '
  55 ' cComp is the KEY belonging to the VALUE above for reverse test
  56 '
  57 ' NOTE: Other related functions can be found in global/tools/inc/t_filters.inc
  58
  59 '*******************************************************************************
  60
  61 function hGetDataPairAsString( sKey as string, sVal as long ) as string
  62
  63     '///<h3>Concatenate two strings and insert an = sign</h3>
  64     '///<i>About &quot;KEY&quot;-functions: <br>
  65     '///These functions are used whenever
  66     '///+ data is to be processed that is stored in a key=value format.<br>
  67     '///+ They handle a single string or a list of strings
  68     '///+ to e.g. isolate a key, a value or to just retrieve the pair.</i><br><br>
  69
  70     '///<u>Input</u>:
  71     '///<ol>
  72
  73     '///+<li>KEY (string)</li>
  74     '///<ul>
  75     '///+<li>Anything but should not contain # or '</li>
  76     '///</ul>
  77
  78     '///+<li>VALUE (string)</li>
  79     '///<ul>
  80     '///+<li>Anything but should not contain # or '</li>
  81     '///</ul>
  82
  83     '///</ol>
  84
  85     '///<u>Returns</u>:
  86     '///<ol>
  87
  88     '///+<li>KEY=VALUE pair (string)</li>
  89
  90     '///</ol>
  91
  92     '///<u>Description</u>:
  93     '///<ul>
  94
  95     '///+<li>Returns string1=string2</li>
  96     hGetDataPairAsString() = sKey & "=" & sVal
  97
  98     '///</ul>
  99
 100 end function
 101
 102 '*******************************************************************************
 103
 104 function hGetValueForPairAsString( cLine as string ) as string
 105
 106     '///<h3>Retrieve value from a key=value string</h3>
 107     '///<i>About &quot;KEY&quot;-functions: <br>
 108     '///These functions are used whenever
 109     '///+ data is to be processed that is stored in a key=value format.<br>
 110     '///+ They handle a single string or a list of strings
 111     '///+ to e.g. isolate a key, a value or to just retrieve the pair.</i><br><br>
 112
 113     '///<u>Input</u>:
 114     '///<ol>
 115
 116     '///+<li>KEY=VALUE pair (string)</li>
 117
 118     '///</ol>
 119
 120     '///<u>Returns</u>:
 121     '///<ol>
 122
 123     '///+<li>VALUE (string)</li>
 124     '///<ul>
 125     '///+<li>Anything after the = character</li>
 126     '///</ul>
 127
 128     '///</ol>
 129
 130     '///<u>Description</u>:
 131     '///<ul>
 132
 133     dim iCharPos as integer
 134
 135     '///+<li>Locate the equal sign</li>
 136     iCharPos = instr( cLine , "=" )
 137     iCharPos = len( cLine ) - iCharPos
 138
 139     '///+<li>Isolate everything to the right of the equal sign</li>
 140     '///+<li>Return the value as string</li>
 141     hGetValueForPairAsString() = right( cLine , iCharPos )
 142
 143     '///</ul>
 144
 145 end function
 146
 147 '*******************************************************************************
 148
 149 function hGetValueForPairAsLong( cLine as string ) as long
 150
 151     '///<h3>Retrieve the value from a key=value pair as long</h3>
 152     '///<i>About &quot;KEY&quot;-functions: <br>
 153     '///These functions are used whenever
 154     '///+ data is to be processed that is stored in a key=value format.<br>
 155     '///+ They handle a single string or a list of strings
 156     '///+ to e.g. isolate a key, a value or to just retrieve the pair.</i><br><br>
 157
 158     '///<u>Input</u>:
 159     '///<ol>
 160
 161     '///+<li>KEY=VALUE pair (string)</li>
 162
 163     '///</ol>
 164
 165     '///<u>Returns</u>:
 166     '///<ol>
 167
 168     '///+<li>VALUE (long)</li>
 169     '///<ul>
 170     '///+<li>Anything after the = character as long integer value</li>
 171     '///</ul>
 172
 173     '///</ol>
 174
 175     '///<u>Description</u>:
 176     '///<ul>
 177
 178     dim iCharPos as integer
 179
 180     '///+<li>Locate the equal sign</li>
 181     iCharPos = instr( cLine , "=" )
 182     iCharPos = len( cLine ) - iCharPos
 183
 184     '///+<li>Isolate and return the Value as long datatype</li>
 185     hGetValueForPairAsLong = val( right( cLine , iCharPos ))
 186
 187     '///</ul>
 188
 189 end function
 190
 191 '*******************************************************************************
 192
 193 function hGetValueForKeyAsInt( lsList() as string, sKey as string ) as integer
 194
 195     '///<h3>Retrieve the value of a key=value pair as integer</h3>
 196     '///<i>About &quot;KEY&quot;-functions: <br>
 197     '///These functions are used whenever
 198     '///+ data is to be processed that is stored in a key=value format.<br>
 199     '///+ They handle a single string or a list of strings
 200     '///+ to e.g. isolate a key, a value or to just retrieve the pair.</i><br><br>
 201     '///<i>Prerequisite: Array compatible to listfuncs, known, valid key</i><br><br>
 202
 203     '///<u>Input</u>:
 204     '///<ol>
 205
 206     '///+<li>List of KEY=VALUE pairs (string)</li>
 207     '///<ul>
 208     '///+<li>List must be compatible to listfunctions (see t_listfuncs.inc)</li>
 209     '///</ul>
 210     '///+<li>Key to be searched for within the list (string)</li>
 211     '///<ul>
 212     '///+<li>Key must be valid</li>
 213     '///</ul>
 214
 215     '///</ol>
 216
 217     '///<u>Returns</u>:
 218     '///<ol>
 219
 220     '///+<li>VALUE (integer)</li>
 221     '///<ul>
 222     '///+<li>The value for a given key</li>
 223     '///</ul>
 224
 225     '///</ol>
 226
 227     '///<u>Description</u>:
 228     '///<ul>
 229
 230     dim iItem as integer
 231     dim cString as string
 232     dim cComp as string
 233
 234     hGetValueForKeyAsInt() = 0
 235
 236     ' Scan through the list and look for sKey. If found, return the Value
 237     ' (everything to the right of the '=')
 238     '///+<li>Search the list for the key</li>
 239     for iItem = 1 to listcount( lsList() )
 240         if( instr( lsList( iItem ) , sKey ) <> 0 ) then
 241
 242             '///+<li>Verify that this is really the correct key by reverse-checking</li>
 243             cComp = hGetKeyforPairAsString( lsList( iItem ) )
 244
 245             '///+<li>Retrieve the value for the key as string</li>
 246             if( sKey = cComp ) then
 247                 cString = hGetValueForPairAsString( lsList( iItem ) )
 248                 iItem = listcount( lsList() ) + 1
 249             endif
 250
 251         endif
 252     next iItem
 253
 254     '///+<li>Convert the stringvalue to integer and return it</li>
 255     hGetValueForKeyAsInt() = val( cString )
 256
 257     '///</ul>
 258
 259 end function
 260
 261 '*******************************************************************************
 262
 263 function hGetValueForKeyAsLong( lsList() as string, sKey as string ) as long
 264
 265     '///<h3>Retrieve the value of a key=value pair as integer</h3>
 266     '///<i>About &quot;KEY&quot;-functions: <br>
 267     '///These functions are used whenever
 268     '///+ data is to be processed that is stored in a key=value format.<br>
 269     '///+ They handle a single string or a list of strings
 270     '///+ to e.g. isolate a key, a value or to just retrieve the pair.</i><br><br>
 271     '///<i>Prerequisite: Array compatible to listfuncs, known, valid key</i><br><br>
 272
 273     '///<u>Input</u>:
 274     '///<ol>
 275
 276     '///+<li>List of KEY=VALUE pairs (string)</li>
 277     '///<ul>
 278     '///+<li>List must be compatible to listfunctions (see t_listfuncs.inc)</li>
 279     '///</ul>
 280     '///+<li>Key to be searched for within the list (string)</li>
 281     '///<ul>
 282     '///+<li>Key must be valid</li>
 283     '///</ul>
 284
 285     '///</ol>
 286
 287     '///<u>Returns</u>:
 288     '///<ol>
 289
 290     '///+<li>VALUE (long integer)</li>
 291     '///<ul>
 292     '///+<li>The value for a given key</li>
 293     '///</ul>
 294
 295     '///</ol>
 296
 297     '///<u>Description</u>:
 298     '///<ul>
 299
 300     dim iItem as integer
 301     dim cString as string
 302     dim cComp as string
 303
 304     hGetValueForKeyAsInt() = 0
 305
 306     ' Scan through the list and look for sKey. If found, return the Value
 307     ' (everything to the right of the '=')
 308     '///+<li>Search the list for the key</li>
 309     for iItem = 1 to listcount( lsList() )
 310         if( instr( lsList( iItem ) , sKey ) <> 0 ) then
 311
 312             '///+<li>Verify that this is really the correct key by reverse-checking</li>
 313             cComp = hGetKeyforPairAsString( lsList( iItem ) )
 314
 315             '///+<li>Retrieve the value for the key as string</li>
 316             if( sKey = cComp ) then
 317                 cString = hGetValueForPairAsString( lsList( iItem ) )
 318                 iItem = listcount( lsList() ) + 1
 319             endif
 320
 321         endif
 322     next iItem
 323
 324     '///+<li>Convert the stringvalue to long integer and return it</li>
 325     hGetValueForKeyAsInt() = val( cString )
 326
 327     '///</ul>
 328
 329 end function
 330
 331 '*******************************************************************************
 332
 333 function hGetKeyForPairAsString( cLine as string ) as string
 334
 335     '///<h3>Retrieve the KEY from a key=value pair</h3>
 336     '///<i>About &quot;KEY&quot;-functions: <br>
 337     '///These functions are used whenever
 338     '///+ data is to be processed that is stored in a key=value format.<br>
 339     '///+ They handle a single string or a list of strings
 340     '///+ to e.g. isolate a key, a value or to just retrieve the pair.</i><br><br>
 341
 342     '///<u>Input</u>:
 343     '///<ol>
 344
 345     '///+<li>KEY=VALUE pair (string)</li>
 346
 347     '///</ol>
 348
 349     '///<u>Returns</u>:
 350     '///<ol>
 351
 352     '///+<li>KEY (string)</li>
 353     '///<ul>
 354     '///+<li>Anything before the = character</li>
 355     '///</ul>
 356
 357     '///</ol>
 358
 359     '///<u>Description</u>:
 360     '///<ul>
 361
 362     dim iCharPos as integer
 363
 364     iCharPos = instr( cLine , "=" )
 365
 366     '///+<li>get the string to the left of the = char</li>
 367     if ( iCharPos > 0 ) then
 368         hGetKeyForPairAsString() = left( cLine , iCharPos -1 )
 369     else
 370         warnlog( "Invalid string passed to hGetKeyForPairAsString" )
 371         printlog( "It was: " & cLine )
 372     endif
 373     '///+<li>Return the key</li>
 374     '///</ul>
 375
 376 end function
 377
 378 '*******************************************************************************
 379
 380 function hGetKeyForValueAsString( lsList() as string, sVal as string ) as string
 381
 382     '///<h3>Retrieve the KEY for a known VALUE from a key=value pair</h3>
 383     '///<i>About &quot;KEY&quot;-functions: <br>
 384     '///These functions are used whenever
 385     '///+ data is to be processed that is stored in a key=value format.<br>
 386     '///+ They handle a single string or a list of strings
 387     '///+ to e.g. isolate a key, a value or to just retrieve the pair.</i><br><br>
 388     '///<i>Prerequisite: List compatible to listfuncs, known VALUE for pair</i><br><br>
 389
 390     '///<u>Input</u>:
 391     '///<ol>
 392
 393     '///+<li>List of KEY=VALUE pairs (string)</li>
 394     '///<ul>
 395     '///+<li></li>
 396     '///</ul>
 397
 398     '///+<li>VALUE (string)</li>
 399     '///<ul>
 400     '///+<li>Absolute match required.</li>
 401     '///</ul>
 402
 403     '///</ol>
 404
 405     '///<u>Returns</u>:
 406     '///<ol>
 407
 408     '///+<li>KEY (string)</li>
 409
 410     '///</ol>
 411
 412     '///<u>Description</u>:
 413     '///<ul>
 414
 415     ' This function returns the value of a key as string.
 416     ' The form of the input strings is 'key=value', the list is parsed
 417     ' The key for the first occurrence of sVal is returned
 418
 419     dim iCurrentValue as integer
 420     dim iListItems as integer
 421     iListItems = listcount( lsList() )
 422     dim cLine as string
 423
 424     ' preset a default return string
 425     hGetKeyForValueAsString() = "Error: No matching KEY found for VALUE"
 426
 427     '///+<li>scan through a list to find an entry that matches sKey. Return the Key.</li>
 428     for iCurrentValue = 1 to iListItems
 429
 430         cLine = lsList( iCurrentValue )
 431
 432         if( instr( cLine , sVal ) <> 0 ) then
 433             hGetKeyForValueAsString() = hGetKeyForPairAsString( cLine )
 434             iCurrentValue = iListItems + 1
 435         end if
 436
 437     next iCurrentValue
 438     '///+<li>Return the key from the first matching value</li>
 439     '///</ul>
 440
 441 end function
 442
 443 '*******************************************************************************
 444
 445 function hGetKeyForValueAsInt( lsList() as string, sVal as string ) as integer
 446
 447     '///<h3>Retrieve the KEY for a known VALUE from a key=value pair</h3>
 448     '///<i>About &quot;KEY&quot;-functions: <br>
 449     '///These functions are used whenever
 450     '///+ data is to be processed that is stored in a key=value format.<br>
 451     '///+ They handle a single string or a list of strings
 452     '///+ to e.g. isolate a key, a value or to just retrieve the pair.</i><br><br>
 453     '///<i>Prerequisite: List compatible to listfuncs, known VALUE for pair</i><br><br>
 454
 455     '///<u>Input</u>:
 456     '///<ol>
 457
 458     '///+<li>List of KEY=VALUE pairs (string)</li>
 459
 460     '///+<li>VALUE (string)</li>
 461     '///<ul>
 462     '///+<li>Absolute match required.</li>
 463     '///</ul>
 464
 465     '///</ol>
 466
 467     '///<u>Returns</u>:
 468     '///<ol>
 469
 470     '///+<li>KEY (integer)</li>
 471
 472     '///</ol>
 473
 474     '///<u>Description</u>:
 475     '///<ul>
 476
 477     '///+<li>Use hgetKeyForValueAsString, convert result to integer, return it.</li>
 478     hGetKeyForValueAsInt() = val( hGetKeyForValueAsString( lsList() , sVal ) )
 479     '///</ul>
 480
 481 end function
 482
 483 '*******************************************************************************
 484
 485 function hGetIndexForKeyAsInt( lsList() as string, sKey as string ) as integer
 486
 487     '///<h3>Search a list of key=value pairs for a key and return its index</h3>
 488     '///<i>About &quot;KEY&quot;-functions: <br>
 489     '///These functions are used whenever
 490     '///+ data is to be processed that is stored in a key=value format.<br>
 491     '///+ They handle a single string or a list of strings
 492     '///+ to e.g. isolate a key, a value or to just retrieve the pair.</i><br><br>
 493     '///<i>Prerequisite: List compatible to listfuncs, known VALUE for pair</i><br><br>
 494
 495     '///<u>Input</u>:
 496     '///<ol>
 497
 498     '///+<li>List of KEY=VALUE pairs (string)</li>
 499
 500     '///+<li>KEY to search for (string)</li>
 501
 502     '///</ol>
 503
 504     '///<u>Returns</u>:
 505     '///<ol>
 506
 507     '///+<li>Index of the KEY in the list (integer)</li>
 508     '///<ul>
 509     '///+<li>0 if not found</li>
 510     '///+<li>Any number &gt; 0 and &le; listcount( List() )</li>
 511     '///</ul>
 512
 513     '///</ol>
 514
 515     '///<u>Description</u>:
 516     '///<ul>
 517
 518     dim iItem as integer
 519     dim cComp as string
 520
 521     hGetIndexForNamedKeyAsInt() = 0
 522
 523     ' Scan through the list and look for sKey. If found, return the Value
 524     ' (everything to the right of the '=')
 525     '///+<li>Scan through the list for the KEY</li>
 526     for iItem = 1 to listcount( lsList() )
 527         if( instr( lsList( iItem ) , sKey ) <> 0 ) then
 528
 529             '///+<li>if found, perform reverse checking</li>
 530             cComp = hGetKeyforValueAsString( lsList( iItem ) )
 531
 532             '///+<li>get the index of the item</li>
 533             if( sKey = cComp ) then
 534                 hGetIndexForKeyAsInt() = iItem
 535                 iItem = listcount( lsList() ) + 1
 536             endif
 537
 538         endif
 539     next iItem
 540     '///+<li>Return the index</li>
 541     '///</ul>
 542
 543 end function
 544
 545 '*******************************************************************************
 546
 547 function keycompare( found as string, expected as string, sKey as string, optional cBugID as string) as boolean
 548
 549     '///<h3>Function to compare two keys with each other</h3>
 550     '///<u>Deprecated, do not use</u>
 551
 552     if ( isMissing( cBugID ) ) then
 553         cBugID = ""
 554     endif
 555
 556     if ( lcase(found) = lcase(expected) ) then
 557         printlog( "     * '" & sKey & "': ok" )
 558         keycompare = true
 559     else
 560         warnlog( "#" + cBugID + "# Control has incorrect value: '" & sKey & "'")
 561         printlog( " > Found...: '" & found  & "'" )
 562         printlog( " > Expected: '" & expected & "'" )
 563         keycompare = false
 564     endif
 565
 566 end function
 567
 568
 569