Getting the Length of a String and the Size of a List

Keeping with the theme of working with Strings, there are many times when you need to know the length of that string. For example, when using substring, you want to know how many characters are in the text you just read from the site. Of you want to make sure the text actually has a length or else there is nothing to act upon.

For example, take this small snippet of code:

String address=”1650 E WASHINGTON AVE, NORTH LITTLE ROCK, AR 72114″

println(address.length())

The result would be 50 as there are 50 characters in the line. The length includes the commas.

This could be used to verify the length of a state abbreviation is 2 characters. It could also be used to verify a phone number is 10 digits or that a name is less than 25 characters, such as:

if (address.length()==0)

if (address.length()<2)

In conjunction with the length of a string, it’s possible to get the size of a list. In Groovy, a List is the same as a one dimensional array. A simple List can be set up as:

months=[‘January’, ‘February’, ‘March’, ‘April’, ‘May’, ‘June’, ‘July’, ‘August’, ‘September’, ‘October’, ‘November’, ‘December’]

The variable “months” is the name of my List and it has multiple elements. Each element is within single quotes and separated by a comma. The List also contains an opening and closing bracket.

Another familiar type of List would be state abbreviations. A List of states would be:

states=[‘AL’,’AK’,’AZ’,’AR’,’CA’,’CO’,’CT’,’DE’,’FL’,’GA’,’HI’,

‘ID’,’IL’,’IN’,’IA’,’KS’,’KY’,’LA’,’ME’,’MD’,’MA’,’MI’,’MN’,’MS’,

‘MO’,’MT’,’NE’,’NV’,’NH’,’NJ’,’NM’,’NY’,’NC’,’ND’,’OH’,’OK’,’OR’,

‘PA’,’RI’,’SC’,’SD’,’TN’,’TX’,’UT’,’VT’,’VA’,’WA’,’WV’,’WI’,’WY’]

Although these are static Lists, we can still get the size. The following command can return how many elements are within each list.

println(months.size()) – Would return 12.

println(states.size()) – Would return 50.

Building on this theme, we could then create a list of cities:

cities=[‘Dentsville’,’Woodcreek’,’Las Lomitas’,’Kings Park’,’Willisville’]

And then street names:

streetName=[‘James Kaur’,’Grace Burns’,’Alfie Robertson’,’Harry Wilson’]

And keep going until we created the building blocks to generate a random contact name. This was done within my code to create a random user including name, address, city, state, zip, phone number, email address and company. The length of each list is different, but using the .size() method, I can generate a random number and pick an element from the list.

For example, to pick a random streetName:

number=Math.abs(new Random().nextInt(streetName.size()))

customerStreetName=streetName[number]

The idea would repeat for setting up all the other parts of the customer data.

Other articles of interest:

Convert from String to Integer to Float and back again

As you read values off a site, there will come a time when you need to manipulate them, such as performing calculations or making comparisons. That doesn’t seem to be problem until you end up with Strings being compared to Integers.

For the most part, a value read off a page will be a string because you don’t always know what it contains. For example, “New Sales Company” is a string of characters. On the other side, 537273 is a number. However, $537,273, which you can identify as numbers is actually a  String value as far as the code is concerned.

Even after you remove the dollar sign and comma, the value type will still be treated as a string because that’s how it was initially read. Comparing a string to an integer will cause a mismatch, but there is a simple way to handle that.

The ValueOf() statement allows the comparison of values as a certain type. Taking the example above, it would be read from the site as a string. We would then remove the $ and , with the ReplaceAll statement – replaceAll(“[\$,]”, “”)

As noted, that would give 537273, but it is still a string. If we wanted to see if the value was greater than 500000 or add another number to it, we can use Integer.valueOf() as in – siteDailyGrossProfit=Integer.valueOf(tempText).

This would set the variable siteDailyGrossProfit to the Integer value of tempText, which would be the dollar figure we read from the site. Because the result will be an integer, this will set siteDailyGrossProfit as an Integer.

The same would be done within an IF statement to verify if the value read is less than or equal to 0. In my test case, if a value is $0, there is an issue and I want to do something about it. Once the value is read, an IF statement would be set up as:

if (Integer.valueOf(dailySalesFigure)<=0)

The same type of conversion holds true for String and Float values. As an example, calculatedMargin=(((Float.valueOf(GP) / Float.valueOf(sales)) * 100).round(1)) – calculates a percentage and rounds the result to 1 decimal place. The values were read as string, but can be multiplied and divided as Float values.

String works the same way, such as the random number example we used earlier:

WebUI.setText(findTestObject(‘Page_/Sales Plan Budget/New Prospect/Category Margin Column’, [(‘Variable’) : loop]), String.valueOf(randomNumber))

A variant is to use .toInteger, .toFloat() and .toString. In this case, the variable tempText reads the value 123456 off the site. Converting to the different types would look like:

intValue = tempText.toInteger() – Would return 123456 as an Integer

stringValue = tempText.toString() – Would return 123456 as a String

floatValue = tempText.toFloat() – Would return 123456.0 as a Float

As a final example, using a command similar to the Selenium IDE, the following will convert a value to a Integer:

intValue = Integer.parseInt(strnumber)

Other articles of interest:

Filling forms with random numbers in Katalon Studio

If you’re filling in forms, inevitably there will be a need to use random numbers. For me, since I’m dealing with a sales dashboard, this means entering dollar figures and percentage values. It’s certainly possible to enter the same figure over and over again, but it’s just as easy to use a few lines of code and generate some random data.

A basic form of the random number command can look like this:

randomNumber=rnd.nextInt(10) – A random number between 0 and 10

This will create a simple random number between 0 and 10. That unto itself is quite fine and can be used for any number of applications. It could be appended to the end of text to make a Title, Subject or similar a little more random. It’s a good start, but there is certainly more that can be done.

To return my example, I want to enter sales figures that range from 100,000 to 250,000. I also want to enter percentages that range from 3 to 15 percent.

random-numbers

There are basically two lines to creating a random number. The first is to initialize the random number. The next is to define the random number within the range. To create the two numbers I want for the form, I can use these lines:

Random rnd = new Random() – Initialize the random number generator

randomNumber = (10000 + rnd.nextInt(250000)) – Pick a number between 10,000 and 250,000. This is my sales figure.

randomNumber = (1 + rnd.nextInt(15)) – Pick a number between 1 and 15. This is my margin figure.

When I want to fill down the table, I can use a SetText command similar to the following: WebUI.setText(findTestObject(‘Page_/Sales Plan Budget/New Prospect/Category Margin Column’, [(‘Variable’) : loop]), String.valueOf(randomNumber))

To break down the parts of the command.

We first have the SetText command

Next comes the Object with the reference to where the fields exists on the page

Since I have two columns of numbers, I will use a loop (from 1-10) to go down the page. This is followed by passing the value of the loop counter into the XPath reference, for example (tr[loop]td[1])

Finally, the text of the random number is passed. For the site I’m working with, I need to convert this to a string in order for it be accepted correctly. The String.ValueOf() passes the random number as a string.

There are dozens and dozens of variations on how to create a random number. Some examples use functions while others are set up to create “more randomness”. For entering a number into a sales field, this example is more than sufficient and while those other examples are neat, they overly complicate the matter.

Other articles of interest:

Working with Dates and Date Formatting in Katalon Studio

Working with dates in Groovy is actually quite easy, once you understand the proper formatting. For my tests, I use the date to check when an import was run. Another use is to append the date to company names, prospect names and task subjects so I know when they were created and give each entry a slight bit of uniqueness.

To start, a variable needs to be set to the Date.

mydate = new Date() – Returns a full string of – Sun Jan 28 11:45:13 EST 2018

Once the date has been calculated from the system, it’s time to parse it into it’s competent pieces. The formatting looks similar to those used in spreadsheets.

Here are some examples and the returned results.

formattedDate = mydate.format(“MM/dd/yyyy”) – month, day, year

01/28/2018

formattedDate = mydate.format(“dd”) – Day

28

formattedDate = mydate.format(“MM”) – Month

01

formattedDate = mydate.format(“yyyy”) – Year

2018

formattedDate = mydate.format(“EEEE”) – Day as Text

Sunday

//Shows whether it is AM or PM

formattedDate = mydate.format(“a”)

AM

//Adds AM or PM to the end of the time

dateHour=mydate.format(“hh:mm:ss a”)

11:52:23 AM

dateHour=mydate.format(“HH:mm:ss”)

11:52:23

As noted, the date can be used at the end of names to make them unique. The following lines are used to get the current date and time, then append to the company name so it’s not the same name over and over again.

Note the / and : are separators and can be left out to form complete numbers.

//The date is appended to the name of the company to create randomness and show when the Prospect was created

mydate = new Date()

formattedDate = mydate.format(“MMddyyy”)

dateHour=mydate.format(“HHmmss”)

WebUI.setText(findTestObject(‘Page_/Prospect Page Objects/New Prospect Fields/Prospect-Company Name’), ‘Amazing New Company ‘ + formattedDate + dateHour)

This creates an entry with the text:

Amazing New Company – 01162018162000

The Date command can also be used in calculations. For example, you can get the date for today and determine the date for yesterday, or three days ago. The code below is used to check when the last import was run based on today’s date.

It first gets today’s date – today = new Date()

That is then used to calculate yesterday’s date – yesterday = today.previous()

If today is “Monday” the report should have run on “Friday” – 3 days ago (today -3)

— Going back three days without having to use calculations —

today = new Date()

yesterday = today.previous()

todayDate = today.format(‘MM/dd/yyyy’)

reportDate = yesterday.format(‘MM/dd/yyyy’)

dayOfWeek = today.format(‘EEEE’)

if (dayOfWeek == ‘Monday’) {

    yesterday = (today – 3)

    print(‘Yesterday is:’ + yesterday)

    reportDate = yesterday.format(‘MM/dd/yyyy’)

    println(‘The new import date is:’ + reportDate)

}

Other articles of interest:

Stripping away characters with ReplaceAll in Katalon Studio

After reading in text, it’s a common need to replace some of the text or get rid of it entirely. There may be a need to remove a comma, a dollar sign, take off a parenthesis etc.

While ReplaceAll is a simple command, there are some tricks to it, especially when using special characters like $ and ().

As an example, almost all the values on the site I’m working with have $ , and % in the number. In order to manipulate them, those characters need to be removed. It’s common that after a GetText command, there is a ReplaceAll command. Since the $ is a special character, the Groovy interpreter needs to know it’s coming by using a \ before the $

To remove a $ and , from a dollar figure, the following ReplaceAll will work.

tempText=tempText.replaceAll(“[\$,]”, “”) – The $ must have a single \ in front.

The same will be true for other characters like a line feed or return.

In the following table, the text for sales and the figure are read as a single cell, but are really separated by a line feed. When I try to print the result, it comes out as two separate lines. In order to put them together as single entry, the ReplaceAll will remove those characters and put in a hyphen.

line-feed

//Replace the CR LF from a line of text so it can be printed on one line. Text will be separated by a hyphen

variable = variable.replaceAll(‘\\n|\\r’, ‘ – ‘) – Note the | between the two “escape” sequences.

Another example that’s come up is the parenthesis, as in:

(1/26/2018 – DAY 19 OF 22)

To remove the open and close, it could be done as two commands:

// The first part of the string is the import date with the opening parenthesis removed

importDate = parsedDate.replaceAll(‘\\)’, ”)

importDate = parsedDate.replaceAll(‘\\(‘, ”)

Or, using the syntax above, use the pipe | to separate the sequence

importDate = parsedDate.replaceAll(‘\\(|\\)’, ”)

Note the ” is two single quotes, rather than the opening double quote. This is the null string and means to remove the characters stated and replace them with nothing.

Another use for ReplaceAll is to get the number of results found. On several pages we display the number of results as 56 Results found.

results-found

It’s easy to get the number by using:

returnedResults = returnedResults.replaceAll(‘ Results found’, ”)

This gets rid of the space and the text, leaving just a number.

Since Katalon uses Groovy, the ReplaceAll command is very well documented, but these special cases took a little time to find yet are probably the most common to use.

Other articles of interest:

Recent Comments