Test Management

Test Management is nothing but managing the affairs of Software testing. It ensures that the testing is is done effectively and efficiently for software projects. Testing is usually accounts for a substantial section part of the overall project budget. Therefore, it is very much important that the Testing activity should be managed in a systematic way.It includes different aspects. We will go through them 

Test Management includes:

• Test Organisation and Independence
• Test Planning and Estimation
• Test Progress Monitoring and Control
• Configuration Management
• Risk management 
• Incident Management

Test Organisation and Independence:

The approach in order to organize a test team depends upon the organisational structure of an organisation. how they plan to organize a team and all. Generally any organization needs to create an environment where testers can conduct testing and deliver an independent, objective in assessment of the quality of SUT or AUT.

Test Planning and Estimation:

In this scenario  we are going to plan how much effort we are going to keep for the testing but we are not going to write the Test plan . It asses the software risk and then it develops a plan accordingly to determine if the software might reduce or minimize those risks. The goal of the Test plan is It guides us in the testing activity and helps us to confront challenges associated with the testing. It serves a s medium for us to communicate with the other members and helps to manage changes.

Entry Criteria:

Entry Criteria defines when to start the testing such as at the beginning of the test level or when set of tests are ready for the execution

Exit Criteria:

Exit Criteria defines when to stop testing such as at the end of the test level or when a set of tests have been achieved their goal.

Test Progress Monitoring and Control:

Test Monitoring and Test Control is basically a management activity. Test monitoring is a process of evaluating and providing feedback of the “currently in progress” testing phase and Test control is an activity of guiding and taking corrective action based on some metrics or information to improve the efficiency and quality. Test monitoring and control goes hand in hand. Being primarily a manager’s activity, a Test Analyst contributes towards this activity by gathering and calculating the metrics which will be eventually used for monitoring and control.

Test monitoring activity includes:

• Providing feed back to the team and the other required stakeholders about the progress of the testing efforts.
• Broadcasting the results of testing to associated members.
• Finding and tracking the test metrics.  
• Planning and estimation and deciding the future course of action based on the metrics calculated.
• Test coverage metric
• Test execution metrics (Number of test cases pass, fail, blocked, on hold)
• Defect metrics
• Requirement traceability metrics
• Miscellaneous metrics like level of confidence of testers, dates milestones, cost, schedule and turnaround time.

Test control activity include:

• Prioritizing the testing efforts
• Revisiting the test schedules and dates
• Reorganizing the test environment
• Re prioritizing the test cases / conditions

Configuration Management:

Configuration management involves in focusing on establishing and maintaining consistency of one system’s performance, functional and physical attributes with its requirements throughout its life time. It controls the changes by identifying the work Products that are likely to establish change, establish relationships among them. It is the management of security features and assurances like through the control of changes that are made to hardware, software, firmware, documentation, test fixtures throughout the information system’s life cycle.It also verifies the completeness and correctness of the configuration items.

Risk Management:

Risk management is a critical activity in software test planning and tracking. It includes the identification, prioritization/ analysis and treatment fo risks faced by the business. Risk management is performed at various levels like project level, product level organization level and even national or international level. Risk management provide a disciplined approach to assess  what can go wrong and  what can go safe. To determine what risks are important to deal with and also implement actions to deal with those risks. Identify new risks with the help of testing.

Incident Management:

An incident is any unplanned event occurring that requires further investigation. Incidents can be raised at any time throughout the software development life cycle, from reviews of the test basis (requirements, specifications, etc.) to test specification and test execution. 

Incident management, according to IEEE 1044 is ‘The process of recognizing, investigating, taking action and disclosing of incidents.’ It involves recording incidents, classifying them and identifying the impact of those incidents. The process of incident management ensures that incidents are tracked from recognition to correction, and finally through retest and closure. It is important that organizations document their incident management process and ensure they have appointed someone (often called an incident manager/coordinator) to manage or identify  the process. 

How to write Descriptive Programming

We can use Descriptive programming in two ways

• Static Method
• Dynamic Method

Static Method:

In Static Method , for object identification we specify an objects property in the following format “property:=values”,

This format is called property value pair and is enclosed in inverted commas “”. If our object uses multiple descriptions for identification, we can specify those objects using commas. So if we take an example of login page of Flight reservation application then in that case, the description for Agent Name will be in this way

"nativeclass:=Edit", "attached text:=Agent Name:"

Dynamic Method:

The second method of doing the same action is using Dynamic Descriptive programming. In case if our script uses the descriptive programming object candidate multiple times, it will be very difficult to specify all the property value pairs for each statement. In such cases we can make use of Description Class provided by QTP Syntax for creating an description object. Set is used to create object and define them.

Syntax:

Set MyDescription = Description.Create();

MyDescription("property").Value = "property-value";

This is the Dynamic Method

For example if we take a web application and we want to write a descriptive programming code for that in QTP

Browser(“brGoogle”).Page(“pgGoogle”).WebEdit(“q”).Set “google”

We have to consider the Object hierarchy while we are writing Descriptive programming and also first when we write a descriptive programming and try to Execute it the QTP will  first go through the Object repository and find out whether that object is present in that OR or not

So when we say that we want to write our script in a such a manner that it doesn’t use object repository, it actually means that we have to write the object part of our statement in a different way such that it doesn’t go to Object Repository to find the object properties. 

Now we understand that in descriptive programming, we only need to modify the Object part of our code. In order to do that we take the help of Object repository only. Why does QTP refer to Object Repository while running a statement because QTP can find the properties associated with the object using this Object Repository only. So if we directly provide the properties of the object in the code itself QTP finds the object properties in the code itself and therefore, there is no need for it to go and refer the Object Repository. And this is the way, we write our Descriptive Programming Code.

Why Use Descriptive Programming?

• The million dollar question is why we use DP when the Object Identification process is handled by QTP
• Suppose if we are assigned to test a job portal. We enter a search query into the portal and
• The test expects we to select all available jobs .and click the apply job
• But the number of jobs reflected will depend upon the search query and jobs available at time of script execution but there is no way to predict in advance the no of jobs that would be reflected
• In such cases, we can use descriptive programming. Even though we do not know the number and names of the checkboxes we do know the class for the objects as "WebCheckBox"
• We can use the ChildObject method to return objects belonging to a particular parent
• A line of code like -
• Set allObjects = Browser("Jobs").Page("QTP").ChildObjects()
• Will return all child objects for this page.
• But we want only WebCheckBox objects.To do so we can create a filter creation object and set its property as WebcheckBox and pass this filter as an argument for the ChildObjects method
• In this case only the checkboxes are returned.
• Next we can write a code like this which access the entire collection of checkboxes starting from zero and sets all checkboxes ON.
• Next we can click apply button to complete the test
• We can also use Descriptive Programming to run objects which are difficult to record like Auto-Hide Panels, Objects with changing hierarchies, Nested Inner Objects ,Sub-menus.
• We can also do advanced string manipulations using descriptive programming
• In conjunction with index property, descriptive programming could be very useful in identifying difficult objects.
• If we use programmatic description for an object in object hierarchy we will need to use description programming for succeeding child objects
• For example, for page object descriptive programming was used but for succeeding child object WinEdit Object Repository is used which is incorrect
• On the contrary here for both Page and WinEdit descriptive programming is used which is correct
•  

When we use Descriptive Programming

Descriptive Programming which is also known as Programmatic Description provides a way to perform operations on objects that are not present in object repository. The words Descriptive Programming and Programmatic Description can be used interchangeably. We will be using Descriptive Programming.

When and Where to use Descriptive Programming?

We generally use this descriptive programming for the following reason given below

• Handling Dynamic Object Property
• Using External Function Library
• Huge Object Repository
• When Application is Not Ready Yet
• Object Repository in read only or shared mode
• Several Identical Objects needing Same Operations

Handling Dynamic Object Property:

One of the very useful place where we can use Descriptive Programming is when the object properties in the Application Under Test (AUT) are dynamic in nature and need special handling to identify the object. The best example would be of clicking a link which changes according to the user of the application.

For example if we consider a scenario of unsuccessful login then the values of  username changes repeatedly, I mean the text property of Link object above changes according to the username. It is easier to handle such properties with descriptive programming.

Using External Function Library:

Another place where DP can be of significantly important is when we have to create functions in an external file. We can use these functions in various actions directly, on eliminating the need of adding object(s) in object repository for each action. [If you use local object repository]. This forms the basis of keyword driven framework approach.

Huge Object Repository:

When object repository is getting huge due to the number of objects being added. Bulky object repository may decrease the performance of QTP while recognizing an object.

When Application is Not Ready Yet:

Suppose we have a web application that has not been developed yet. Now for QTP to record the script and add the objects to repository, needs the application to be up, that would mean waiting for the application to be deployed before we can start making QTP scripts. But if we know the descriptions of the objects that will be created, we can start-off with the scripts using Descriptive Programming.

Object Repository in read only or shared mode:

If we want to modify QTP script but the Object repository for the same is read-only or in shared mode i.e. changes may affect other scripts as well. In such a case, you may use Descriptive Programming approach.

Several Identical Objects needing Same Operations:

For example on a web application on the same page we have 15 textboxes on a web page and there names are in the form txt_1, txt_2, txt_3 and so on. Now adding all 15 objects in the Object repository would not be a good programming approach (since the object description would be the same except the index ordinal identifier.). We can simply go for Descriptive Programming.

For example If in different pages of a web application with several pages has 3 navigation buttons on each page. Let the buttons be “Cancel”, “Back” and “Next”. Now recording action on these buttons would add 3 objects per page in the repository. For a 10 page flow, it would mean 30 objects which could have been represented just by using 3 objects. So instead of adding these 30 objects to the repository, we can write 3 descriptions for the object and use those descriptions on any page.

Recovery Scenarios in QTP

While executing the QTP scripts, we might get some unexpected errors. In order to overcome these errors and recover the test and continue executing the rest of the script from these unexpected errors, we use Recovery Scenarios in QTP. The Recovery Scenario Manager can be accessed by Navigating to "Resources" → Recovery Scenario Manager. Generally a recovery scenario consists of the following

• Trigger event
• Recovery operations
• Post recovery Test Run Object

Trigger Event:

The event that interrupts your run session like there may be a window pop up on the screen or an advertisement

Recovery operations:

The operations which performs to enable QTP to continue running the test after the trigger event interrupts the Run session are called as Recovery operations. For example if there is trigger event like a pop up window has been apprered on the screen if click Ok or Cancel button the window gets closed, So the Ok and Cancel buttons are known as recovery operations

Post recovery Test Run Object:

The instructions on how QTP should proceed after the recovery operations have been performed and from which point in the test the QTP should continue and all will be handled by this option. For example, if we want to restart a test from the beginning, or skip a step entirely and continue with the next step in the test. Recovery scenarios are saved in the recovery scenario files and they have an extension .qrs. A recovery scenario files is a logical collection of recovery scenarios, grouped according to our specific requirements.

Recovery scenario manager can handle the following four events

• Pop Up windows: It handles unwanted pop ups
• Object State: It handles object related errors during the runtime.
• Test run error: It handles Vb script statement errors at runtime
• Application Crash: It handles crashed applications at runtime

Recovery scenario become crucial for large tests, which run unattended and are paused until recovery operation, is performed increasing the test execution time.

There are 6 steps involved in creating a recovery scenario

1. Step 1) In QTP , Select Resources > Recovery Scenario Manager .Create new Scenario
2. Step 2) Specify the Trigger Event.  A Trigger Event is an event that interrupts our run session
3. Step 3) Specify the  Recovery Operation which is the corrective action we take when trigger happens
4. Step 4) Specify Post-recovery test run options which can specify how to continue the run session after Quick Test  Professional has identified the event and performed all of the specified recovery operations.
5. Step 5) Check and verify Summary of the scenario we created.
6. Step 6) Add Recovery Scenario to our test using  File > Settings > Recovery. The test results window show the details of the recovery scenario
7. We can also use statements

·         On Error Resume Next :

·         On Error Go to 0 :

In order to handle errors in our script

Object Repository

QTP uses a "human brain" like technology for identification of objects. During record time QTP tries to learn all the properties of a GUI object on which operation is performed. During Run-Time, QTP compares the stored object properties with actual properties of the object available on screen and it identifies the object uniquely independent of its location on the screen. The stored object along with its properties is called TEST Object. During Run-Time, the actual object which is available on the application under test is called Run-Time Object. This is known as Quick Tests "Test Object Model". Information about the Test Objects is stored in Object Repository. Add-ins help in  instructing Quick Test in advance of the nature of object to be recorded so it has to reduce the time required to learn its properties. So it used Object repositories. Simply this object repository acts as a brain for QTP.

There are 2 Types of Object Repository in QTP

• Local Object Repository
• Shared Object Repository

Local Object Repository

Local Object Repository is the default object repository. It is specifically records according to actions and can be used only for a particular action. Local Object Repository is preferable when application is not dynamic I mean if the actions or methods are not changing for an object with respect to time. Local Object Repository  cannot be reused. You can perform many operations in the local object repository such as we can Highlight an object stored in repository on the application under test. We can check whether a particular object in our AUT is stored in the Object Repository or not. We can  Cut , Copy , Paste  , Modify and Delete Objects in Local repository. In case if we have accidentally modified the value of a property we can update its description from the application using update function.

Shared Object Repository

Global or Shared Object  Repository is preferable when application is dynamic and object description change frequently. Between Shared and local object repository, shared object repository is more commonly used in automation projects. However, it has maintenance and administration as compared to local object repository. 

                           

To create and use a shared object repository you need to perform three broad steps

• Creating a Shared Object Repository
• Associating a Shared Object Repository
• Editing a Shared Object Repository

Step 1) Creating a Shared Object Repository

• All repositories are local by default.  To create a Shared Object Repository, in the Object Repository Dialog Box, Click File > Export Local Objects
• Repository files always have an extension called ".tsr". Give a suitable name as  "yash" and save it.
• The Shared Repository File is created

Step 2)Associating a Shared Object Repository

• Next step is we have to associate the repository to our test, which enables us to use it
• To associate repository with a test, Click Resources > Associate Repository
• We can select the Repository to associate with Actions available in your test.
• Now we can now use this shared repository to develop our test

Step 3) Editing a Shared Object Repository

• We can use the Object Repository Manager to Edit a Share Repository.
• Select Resources > Object Repository Manager .Open the Object Repository which we created as "yash" before.
• By Default, Repository is opened in Read-only mode. To enable editing click File > Enable Editing
• Once editing is enabled we can do all the operations like cut, copy, paste, rename objects etc and we can also do in Object Repository
• Using  Object Repository Manager  is we can compare two Object Repositories. QTP will give us a static's of what's most unique and common in both the repositories
• We can use the Object repository merge tool to merge two repositories into one

Actions in QTP

QTP Action is a placeholder or a component in which you can write your scripts or code. You can write your code in QTP actions in the same way you do in a function library or scripted business component. Actions help divide your test into "logical units" or "Business Processes". Actions help to create a script which is more modular and efficient. When a script is newly created it consists of only one action. But you can add more Actions to your QTP Script as per requirements.  In fact, a QTP test script is itself a collection of one or more actions.

There are four types of Actions

• External Actions
• Internal Actions
• Reusable actions
• Non Reusable actions

Reusable Actions: The actions that can be used in other Tests are called as reusable actions. They can also be used in the same Test Script multiple times.

Non-Reusable Actions: The actions which can not be used in other Tests are called as Non-Reusable . They can be called in the same script only once.

External Actions: A reusable action stored with another test is called External actions. These are read-only in the calling test, but you can choose to use a local, editable copy of the Data Table information for the external action.

Internal Actions: With reference to a QTP test case, an internal action is one that is stored within that test case. This action can be reusable as well as non-reusable depends upon the requirement.

At times, if an action becomes big, its a nice practise to split it. You can split an existing action in two ways

• Independent Actions
• Nested Actions

Independent Actions:  These actions are independent of each other which splits the selected action into two sibling actions

Nested Action: These are the actions which splits the selected action into a parent action whose last step calls the second, child action

Actions can access test-data stored in datasheets. QTP provides 2 type of datasheets 

• GLOBAL Datasheet: It is Unique for the entire test. Any Action can access and write data into Global Datasheet. Sheet is named "GLOBAL"
• LOCAL Datasheet: Equal to number of Actions in the sheet. An Action can read and write data into its own local Datasheet only. Sheet name =  "ACTION NAME". 

The entire purpose of creating Actions is to use them in other Test Scripts. There are two methods to import Actions into a Test

• Call to COPY of an Action: When you make a Copy of an Action , the action is copied in its entirety, including checkpoints, parameterization, and the corresponding action tab in the Data Table into the calling test . When you insert a copy of an existing action, you can make changes to the copied action, and your changes will not affect nor be affected by any other test. You can insert copies of both reusable and non-reusable actions
• Call to an EXISTING Action: Calls to actions are read-only in the calling test. They can only be modified in the test in which they were created. It enables you to use the same action in several tests and makes it easy to maintain tests. You can  make  calls to only "Reusable" actions.

Just like functions or methods in programming languages you can also create input and output parameters for an action. This parameter has no relation with Test Data Parameterization

If required you can use the following statement to exit an Action

• ExitAction.
• ExitActionIteration
• ExitRun
• ExitGlobalIteration

Output Values in QTP

An output value step, is a step in which an object property value is captured at a specific point in your test and stored at a desired location. The stored values can be used as input at a different points in test script. It is simply a value that is retrieved during the application is in run session and entered in our data table or stored in the form of a variable or a parameter. To extract these property values to the data table which can be used later as input to some other steps, testers use output values option. There are various categories or types of output values.

Types of Output Values

• Standard output value
• Text /Text Area output value
• Data base output value
• Xml output value (from application/resources)

Creating an Output Value is very similar to creating a Checkpoint. A  Standard output value can be used on any object to output value of any of its properties. You can select one or many properties from the same object as output.

Standard Output Values

We can use standard output values to output the property values of most objects. For example after reserving a ticket, it must be confirmed. In this case confirming the ticket number is required which is generated during run time. you could create an outpuut value in your test to store the ticket number after it is generated during run time. Steps to create standard output value:

• Select Insert>Output Value>Standard Output Value.
• Click the object for which output value must be generated.
• In the Object Selection dialog box, select the object for which you want to specify an output value, and click OK. The output value properties dialog box opens for the selected object.
• Specify the property value and their settings.
• When you finish defining the output value details, click OK. QTP inserts an output value step in your test.

 

Text Output Values 

We can create a text output value from a text string displayed on the screen, we can define the output value as part of the displayed text and you can specify the text before or after the output text.

Steps to create a text output value while recording:

• Select Test>Record.
• Choose Insert>Output Value>Text output Value.
• Click the text string for which you want to specify a text output value.
• Select the object for which you want to specify a text output value and click OK.
• The Text Output Value Properties dialog box opens.
• Specify the setting for the output value.
• when you have finished  defining the text output value details, click OK. QTP inserts an output value step in the test.

 

 Database Output Values 

you can use the database output values to output the value of the contents of database cell.

Steps to create database output values

• Select Insert>Output value>Database Output value.
• Use the wizard to define the query to retrieve the data that you want to output.
• Specify the values to output and their settings.
• When you have finished defining the output value details, Click OK.
• QTP inserts an output value step in your script.

XML Values Output

You can create XML output values from any XML document contained in an XML Web page or frame, or directly from an XML file. you can output element and/or attribute values in an XML output value step.

Steps to create XML output values from XML file:

• Select Insert>Output Value>XML Output Value.
• In the XML file box , enter the path of the XML file.
• Click OK. The XML Output Value Properties Dialog box opens.
• Specify the values to output.
• Click OK, QTP inserts n Output value step in your test.

Parameterization

We can use the parameter feature in Quick test to enhance our test by parameterizing the values that it uses. A parameter is a variable that is assigned a value from an external data source such as XL sheets .Word docs etc.The re-execution of single script with multiple data is called parameterization or data driven testing. There are following ways to parameterize

• Test\check Parameter
• Data driven Parameter
• Environment Variable Parameter
• Random Parameter 

Test\Check Parameterization:

Sequetially:

Test parameter enable testers to use values passed from keyboard by writing for....next loop statement

"for---next " loop instructs Quick test to perform one or more statements a specified number of times. It has the following syntax.

Syntax : 

For counter = start to end [step steno]

vbScript statement 

Next

Example :

For i=1 to 3 Step1

Window("Flight Reservation").WinMenu("Menu").Select"File;Open Order...."

Window("Flight Reservation").Dialog ("Open Order").WinCheckbox("order No.").Set "ON"

Window ("Flight Reservation").Dialog("Open Order").Winedit("edit").Set X

Window("Flight Reservation").Dialog("Open Order").WinButton("OK").Click

Next

Randomly:

During randomly execution, testers dynamically submit specific values from keyboard. In this execution. Testers use "Input Box" function to execution on specific value. It has the following syntax.

Syntax:

For Counter= Start to end [step Steno]

X= Input box ("string ", Title ).

VbScript Statement 

Next

Example:

For i= 1 to 3

X= Input box("enter order no',"order no")

window

Next. 

Data Driven Parameter:

Enable testers to create a data driven test, that runs several times using the data which is maintain in external documents such as data sheet. In each repetition , or iteration Quick Test uses a different value from the data table. There are value from the data table. There re different ways to data driven test

• DDT with test data by maintaining in DataTable 
• DDT with the test data by import from external sheets 
• DDT with the test data from Database 
• DDT with test data from Keyword

DDT with test data by maintaining in DataTable:

During this, testers are creating appropriate script maintain test data in to the data table and with the help of data driver tool. Paramerize the data to the script . So that the QTP will execute that script on the application for number of times.

DDT with the test data by import from external sheets:

During this, testers are creating appripriate script by importing test data from other excel sheets into QTP data sheet table with the help of Data drive tool. They parametrize the data to the script. So that the QTP will execute that script on the application for number of times.

DDT with the test data from Database :

During this, testers are creating appropriate script by importing test data from database into QTP Data Table with the help of Data Drive tool. They parameterize the data to the script. So that the QTP will execute the script on the application for number of times

DDT with test data from Keyword:

During this testers are creating appropriate Script maintain data into QTP . Data table an without using data driver tool, Parameterize the data to the script, so  that QTP will execute that script on the application for number of times.

Record Operations on application using QTP 10.0

Testers generally perform operations on application to check the functionality , so Quick Test  record these operations in the form of vb scripting. With the help of recording, testers convert all test procedures or test steps into automation scripts. It's nothing but record helps to generate test scripts using Vb scripting. 

Record Operations: 

QTP generates test steps by recording the typical procedure that we perform n the application . A step is anything which a user does on the application, that changes the content of a page or object in the application. QTP supports three kind of recording modes 

• Normal/ High level Recording/ Context sensitive recording
• Analog Recording 
• Low Level recording

Normal Recording:

In this mode of recording QTP records the mouse and keyboard operations with respect to the Object or window , Simply it records the GUI objects. By default the QTP is always in normal mode. The Shortcut key to record is F3.

Record and Run Setting Wizard:

The purpose of this wizard is to choose the technology which we want to record . I mean which type of application we want to record . It has two technical environments 

• Web Environment
• Windows Environment

Testers can chose any one of the following environment. 

When this operation is selected QTP records operation on any opened application .

• Step 1 In QTP click the record button.The Record and Run settings Dialog Box Opens.This box opens automatically each time you  begin recording a new test
• Step 2 Record & Run settings shows a tabs corresponding to add-ins installed and loaded for your test.So, for example if you have SAP Add-in Installed and loaded you will see a SAP tab. The Windows Application tab is always available and be used for  environments, such as  Visual Basic, ActiveX, and terminal emulators.
• For any Environment, the Record and Run settings can be classified into two generic groups
• 1) Record & Run on ANY window belonging to that particular environment
• 2)Record & Run on a SPECIFIC window belonging to that particular environment - which is the recommended Option
• For the time being , lets stick to default settings .Once settings are done , QTP remembers and uses the same settings for additional record sessions on the same test, unless you manually open the Record and Run Settings dialog box to modify the settings.
• Step 3 Click okay. QTP Starts Recording Mode
• Step 4 Record the 5 test steps. In QTP , Stop recording. Save the script as "LogIn" 

Analog Mode of recording:

In this mode, QTP records mouse pointer movement. It has two types of analog recordings one is  related to the screen and the second is relative to the specific window. If we record the analog relative to the screen then when we move the window from that location and if we run still the QTP records the mouse pointer movements at the previous location of the screen only. If we record the analog recording relative to the Window , then it will identify the location of the window moved and it will run accordingly. Short cut key for this analog recording is Shift+ Alt + F3.This  is an optional recordng mode . The testers use this mode when they required to draw , paint and signature.This recording can be recorded only when we are recording an application. generally this key will be disabled.

Low Level Recording:

In this mode QTP records advanced tech objects or unrecognized objects. It particularly records all the movements of mouse pointer. QTP generally uses this mode and normal recording automatically depending upon the object properties. The Shortcut key to record in Low level Mode is Ctrl+ Shift+ F3