Best Tosca Interview Questions and Answers for 2021 - IQCode

Overview of Tricentis Tosca

Tricentis Tosca is a comprehensive end-to-end software testing tool that helps in automating software testing. Tosca combines different aspects of software testing such as test case design, test data design, test automation, etc. and supports CLI, API, integrated test management, and GUI testing. Tosca is developed by Tricentis, a software testing company. Tosca has very unique features that make it one of the most popular automation tools in the market today.

Features of Tricentis Tosca

Tricentis Tosca has the following features:

  • Script-less and no-code automation support
  • End-to-end automation of the testing process
  • Integrated test management
  • Supports responsive and regression testing
  • Automates testing of all types of applications
  • Supports every phase of a testing project

Tosca has become an important tool in the field of software testing due to its ability to automate software testing. This saves project time and makes the job of testers easier. In this article, we have compiled some of the top interview questions for Tosca, which would be helpful for those who are looking for a job opportunity.

Main Components of Tosca Testsuite

Tosca Testsuite is a comprehensive test automation tool that comprises the following main components:

1. Tricentis Tosca Commander:

A graphical user interface (GUI) that allows users to design and execute test cases. It provides a central location for managing test modules, test cases, and test data.

2. Tricentis Tosca Repository:

It serves as a centralized storage system for all testing artifacts, including test cases, test modules, test data, and test results. It enables collaboration among team members and simplifies version control.

3. Tricentis Tosca Engines:

These are the automation engines that execute test scripts and perform test activities. It includes modules such as Test Case Design, Test Data Management, and Test Execution, among others.

4. Tricentis Tosca Analytics:

It provides users with real-time insights into test results, including pass/fail status, test trend analysis, and defect tracking. It helps users optimize their testing efforts and improve overall software quality.

Benefits of Using Tosca as a Test Automation Tool

Tosca is a powerful test automation tool that offers several benefits to software development and testing teams. Some of the benefits are listed below:

- User-friendly interface that simplifies test automation and reduces the learning curve for new testers. - Supports end-to-end testing, including functional, regression, and performance testing. - Offers a model-based approach that minimizes the need for maintaining complex scripts and ensures easy maintenance and scalability. - Enables continuous testing by integrating with DevOps tools and providing real-time feedback. - Provides risk-based testing that optimizes testing efforts and resources by identifying high-risk areas in the application. - Supports parallel test execution, reducing the overall test time and improving the efficiency of testing. - Enables cross-functional collaboration by providing a centralized platform for teams to collaborate, manage, and execute tests. - Provides comprehensive reporting and analytics that help teams to track progress, identify bottlenecks, and make data-driven decisions.

Overall, using Tosca as a test automation tool can significantly improve the testing process, reduce costs, and deliver high-quality software with faster time-to-market.

Different Types of Errors in TOSCA


is a testing tool with a broad range of error types. Some of the most common error types are:

  • Syntax errors: These types of errors occur when there is a mistake in the language's syntax. They are usually easy to spot and fix by carefully reviewing the code.
  • Compile-time errors: These errors happen during the compilation process, often caused by issues with missing or duplicate libraries. They need to be resolved before the program can run.
  • Run-time errors: These errors occur while the program is executing, such as when division by zero or invalid user input occurs.
  • Logic errors: These happen when a program runs without syntax or compilation errors, but the output is incorrect. They are typically caused by mistakes in the program's logic.
  • Environmental errors: These are issues that arise from the environment in which the program is running. They are typically related to connectivity, such as when a network connection is lost.

Running Tests with Tosca Execution Lists

To run tests using Tosca Execution Lists, follow these steps:

  1. Create an Execution List in the Tosca Commander module by selecting the desired test cases from the Test Case Design section and adding them to the Execution List.
  2. Open the Execution List in Tosca Executor module.
  3. Click on the "Start" button to initiate the execution of the selected test cases.
  4. During the execution, Tosca automatically captures the test results, such as Pass/Fail status, execution time, and any errors encountered.
  5. Once the execution is complete, Tosca generates a TestReport that summarizes the execution results for each test case in the Execution List.

Note that Tosca also provides features to schedule the Execution Lists to run at specific times or frequencies, and to distribute the execution across multiple machines for faster execution times.

Guide to Running/Executing Tests with Tosca Scratchbook

To run tests using Tosca Scratchbook, follow these steps:

1. Open the Tosca Scratchbook application on your computer. 2. In the navigation pane, select the TestCases module. 3. Click on the Add button to create a new test case. 4. Give a name and description to your test case and click on the Save button. 5. On the right side of the application window, you can see the ExecutionList module. Select it and click on the Add button to add your newly created test case to the ExecutionList. 6. Click on the ExecutionList and select the newly added test case. 7. Right-click on the test case and select the "Execute" option. 8. A dialog will appear. Select the Test Configuration and Environment in which you want to run the test. 9. Click on the Execute button to start the test execution.

Tosca Scratchbook will now run your test case and show you the results. You can view the detailed report of the test execution in the Tosca Commander.

Performing API Testing in Tosca

To perform API testing in Tosca, follow these steps:

1. First, create a new test case in Tosca for API testing.

2. Add the necessary objects and actions required to perform the API test. For example, you may need to include objects such as API URLs, HTTP requests, and response assertions.

3. Once you have added the necessary objects and actions, configure your API endpoint. This may involve setting the endpoint URL, HTTP method, and headers.

4. After configuring your endpoint, you can begin creating the test steps. The test steps will typically involve sending an HTTP request to the API endpoint and validating the response.

5. You can use Tosca's built-in reporting features to generate detailed reports for your API tests.

6. Finally, execute your test case and review the generated report to ensure that your API endpoint is functioning as expected.

By following these steps, you can easily perform API testing in Tosca and ensure that your API endpoints are functioning correctly.

What is TOSCA Test Data Service?

TOSCA Test Data Service (TDS) is a feature of the TOSCA testing tool that allows for the generation and management of test data for automated testing. TDS enables users to create, modify, and maintain test data sets that can be used across multiple test cases. This ensures that the same data is used for testing, improving consistency and reliability of testing results. With TDS, testers can also easily create and manage large volumes of test data, which can be especially useful in scenarios where testing requires high-volume data processing such as performance testing.

String Operations in Tosca Testsuite

In Tosca Testsuite, string operations are used to manipulate or compare strings. The following are some examples of string operations:



- this function returns the length of the string.


concat(string1, string2)

- this function concatenates two strings.


subString(string, startIndex, endIndex)

- this function returns a substring of the given string, starting from the startIndex and ending at the endIndex.


replace(string, oldString, newString)

- this function replaces all occurrences of oldString in the given string with newString.


equals(string1, string2)

- this function compares two strings and returns true if they are equal, otherwise it returns false.


contains(string1, string2)

- this function returns true if the first string contains the second string, otherwise it returns false.

These string operations can be used in Tosca Testsuite to perform various tasks such as data validation, data manipulation, and data comparison.

Comparison of Selenium and Tosca

Selenium and Tosca are both used for automated testing but there are some differences between the two.

  • Selenium is an open-source tool whereas Tosca requires a license and is a proprietary tool.
  • Selenium supports multiple programming languages such as Java, Python, and C# while Tosca has its own scripting language called TOSCA Commander.
  • Selenium is mainly used for functional testing for web applications while Tosca can be used for both functional and non-functional testing.
  • Selenium requires technical skills and knowledge of programming languages to write automated tests whereas Tosca has a user-friendly interface and does not require programming knowledge.
  • Selenium is more suitable for small to mid-sized projects, while Tosca is better for large-scale testing projects.

Creating a TestSheet in Tosca

To create a TestSheet in Tosca, follow these steps:

1. Open the Tosca Commander window.

2. Create a new TestSheet by clicking on the "New File" button.

3. Choose "TestSheet" as the file type.

4. Name the TestSheet.

5. Add the necessary TestCases to the TestSheet using the drag-and-drop functionality.

6. Assign Requirements to the TestSheet using the "Assign Requirement" functionality.

7. Save the TestSheet.

You can now execute the TestSheet by right-clicking on it and choosing the "Execute TestSheet" option.

What is included in the XL reference in Tosca?

The XL reference in Tosca refers to the Excel reference which contains test case information such as test data, expected results, and test steps. It serves as a mapping tool between the test cases and the requirements they cover, allowing for easy traceability and reporting. The XL reference is a crucial component of the Tosca Test Suite and allows for streamlined test management and execution.

Explanation of Web Services in Tosca

Tosca is a model-based testing tool that supports testing of web services. A web service is a software system that can be accessed through the internet. It uses a standardized approach such as HTTP/HTTPS, XML, SOAP, REST or WSDL for communication. Web services are widely used in modern applications to exchange data between different systems.

Tosca has a built-in module called the Tosca Web Services Engine (TWE) that allows users to test web services effectively. This module enables users to test web services using a graphical user interface and automate test cases.

Tosca also supports the testing of both RESTful and SOAP based web services. It provides a user-friendly interface for the users to define the endpoints, messages and operations required for the test. Users can also import WSDL files and use them to generate test cases quickly.

In conclusion, Tosca's support for web services testing with its built-in module TWE, makes it an excellent tool for testing modern applications that rely heavily on web services for data exchange.

Importance of TOSCA API Scan

TOSCA API Scan is a crucial testing tool for ensuring the quality of APIs. It helps to detect any vulnerabilities, security threats, and errors that could lead to system failures or data breaches. This tool makes sure that APIs perform as intended and meet the required standards of functionality and security. It also helps to reduce the overall testing time by automating the test process and providing comprehensive documentation for each test. The TOSCA API Scan allows developers and testers to analyze the response times, load capacity, and performance of APIs before deploying them to production environments. This feature helps to prevent any potential issues that could affect the system's stability and performance. Proper utilization of this tool can help organizations to ensure that their APIs are secure, reliable, and functional while lowering the costs and risks associated with manual testing and debugging.

Tosca Interview Questions for Experienced

Question 16: Can you explain how Tosca supports model-based and risk-based testing?



supports model-based testing through its use of TOSCA Commander, which enables users to create models of applications and systems. These models can then be used to generate automated tests, allowing for faster and more accurate testing processes.

In terms of risk-based testing,


has a built-in risk assessment module which allows users to identify and prioritize potential risks related to the system being tested. This information can then be used to develop and execute test cases that focus on the highest priority risks, ensuring that critical functionality is thoroughly tested.

Exploring Business Parameters in Tosca

In Tosca, there are various Business Parameters used to enhance the testing process. Here are some of the most commonly used parameters:

1. Input Parameters - These are used to provide input values to the test case.

2. Expected Result Parameters - These are used to define the expected values of the test case.

3. Output Parameters - These are used to capture the output from the test case.

4. Global Parameters - These are used to make large-scale changes across multiple test cases without manually changing each one.

5. Environment Parameters - These are used to define the environment setup for test execution.

6. Configuration Parameters - These are used to configure the test case to perform specific actions.

By effectively utilizing these parameters, testers can achieve more efficient and effective testing results.

Synchronization in Tosca

In Tosca, synchronization refers to the coordination and timing of test steps and actions. It ensures that the application under test and the test automation tool are synchronized properly. Synchronization in Tosca is achieved through various methods, such as wait statements, delays, timeouts, and checkpoints. These methods ensure that the application has completed a task or action before proceeding with the next step in the test case. Synchronization plays a crucial role in ensuring the accuracy and reliability of automated tests.

What does the Test Configuration Parameter mean in TOSCA?

In TOSCA, the Test Configuration Parameter refers to the input values required for executing tests on a specific test configuration. Test Configuration is a set of parameters defined to test an application. These parameters include device configurations, operating system details, browser, etc. The Test Configuration Parameter ensures that the test is executed on the correct platform, environment, or application configuration. By defining these parameters, TOSCA becomes capable of running tests on a wide variety of test configurations.

Understanding Tosca Templates

In the context of software testing, a Tosca template is a standardized document that outlines how a particular test case should be executed using the Tosca automation tool. This template typically includes information about the system under test, the specific test scenario being executed, the expected results, and any relevant test data. The use of Tosca templates can help streamline the testing process and ensure that all test cases are executed in a consistent and repeatable manner.

Explanation of TOSCA QC/ALM Integration

TOSCA is a test automation tool that integrates with Quality Center (QC)/Application Lifecycle Management (ALM). The integration enables the seamless execution of TOSCA tests from QC/ALM and provides test status updates to the respective tool.

Once the integration is set up, you can trigger TOSCA test execution from QC/ALM by creating a TOSCA test in QC/ALM and linking it to a TOSCA test case in TOSCA Commander. When the TOSCA test is executed from QC/ALM, the test results are automatically updated in QC/ALM.

This integration improves the efficiency and visibility of the testing process, allowing for better collaboration between the testing and development teams. It also enables easy reporting of test results, reducing the time and effort required for manual reporting.

Using Multiple Browsers in Tosca for the Same Test Case

To use multiple browsers in Tosca for the same test case, you can create multiple test configurations in the TestCases module. Each test configuration can have a different browser specified. Once you have created the test configurations, you can execute them in parallel using the ExecutionLists module. This will allow you to run the same test case across multiple browsers simultaneously.

Identifying Objects in Tosca Testsuite

In Tosca Testsuite, there are several ways to identify objects. One way is to use the "XScan" feature, which allows you to scan the application and automatically generate new objects based on their attributes. Another way is to manually identify objects by using the "Create New Object" functionality and specifying the object's attributes such as name, type, and location.

Once objects have been identified, they can be stored in the Tosca repository and used in test cases. It is important to ensure that object identification is accurate and consistent across multiple test cases to avoid errors in test execution.

Understanding the Tosca Query Language

Tosca Query Language is a scripting language used in Tricentis Tosca to filter and select specific data within a module. It allows users to search for information by using various criteria such as property keys, values, and types. This language can also be used to search for data across multiple modules. Tosca Query Language is an efficient tool for managing and manipulating data in Tosca and can significantly reduce manual effort and time required for data analysis.

Comparing PDF Files with TOSCA

To compare PDF files using TOSCA, you can use the TOSCA Commander PDF Engine module. This module allows you to extract data from PDFs and then compare the values to verify if they match.

First, you'll need to install the PDF Engine module. Then, you can use the "PDF Extractor" action block in TOSCA to extract the data from the PDF, followed by the "Compare Excel" action block to compare the extracted data between the PDF files.

Additionally, you can also use the "PDF to Text" action block to convert the PDF to a text file and then compare the text using TOSCA's standard text comparison methods.

By using the TOSCA Commander PDF Engine module and associated action blocks, you can automate the process of comparing PDF files and ensure that they match according to your specific criteria.

Importance of Rescan in TOSCA

In TOSCA, a rescan is a vital process that is used to update any changes made to the source code, test cases, or test environment. It helps to ensure that all the test cases are up-to-date and valid.

Rescanning is crucial because if the changes made in the source code were not updated in the test cases, the automated test case may not work correctly. This could lead to false results and, in turn, cause any issues or bugs in the application to be missed.

Moreover, rescanning eliminates the need to create additional test cases or modify existing test cases manually when changes are done in the source code or test environment. By rescanning, TOSCA automatically updates test cases, enabling the testing team to save time and increase productivity.

In summary, rescanning is an essential feature in TOSCA that ensures test cases remain accurate and effective.

Explanation of Test Data Management (TDM)

Test Data Management (TDM) is the process of creating, optimizing, and maintaining test data that is necessary for software testing. It involves identifying, creating, and managing data for use in testing scenarios and ensuring that data is accurate, relevant, and up-to-date.

TDM facilitates better testing by providing high-quality data that is representative of real-world scenarios, covering all possible test scenarios, and ensuring that test cases work as expected. This helps in improving the quality and efficiency of testing, reducing the risk of application failure, and decreasing the time and cost associated with testing.

Furthermore, TDM ensures that data privacy and security are maintained by protecting sensitive data and complying with regulations. It also helps in meeting the requirements of stakeholders by ensuring that testing scenarios are aligned with business objectives.

In conclusion, Test Data Management is an important aspect of software testing that helps in improving the quality and efficiency of testing, reducing costs and risks, and meeting the requirements of stakeholders.

Recovery Scenario in Tosca

In Tosca, a Recovery Scenario is a set of actions that are automatically executed in case of a test step failure. This allows for the automation of recovery actions that would be traditionally performed manually.

For example, suppose a test case involves entering data into a field, clicking a button, and verifying that the correct output is displayed. If the button click fails, the Recovery Scenario can automatically attempt to refresh the page, navigate to the screen again, and try clicking the button again.

If the Recovery Scenario fails or is not defined, the test case will fail, and the user will be notified of the failure, just like in any other testing framework. Therefore, it is essential to define precise and comprehensive Recovery Scenarios to minimize the impact of test case failures.

Understanding TOSCA CI (Continuous Integration) and its Implementation

TOSCA (Topology and Orchestration Specification for Cloud Applications) is an open-source standard for defining and building cloud-based applications. Continuous Integration (CI) refers to the practice of merging code changes from multiple sources into a single project, verifying them, and delivering them to a shared repository on a regular basis.

In the context of TOSCA, Continuous Integration involves implementing a workflow that ensures consistent testing, validation, and verification of cloud application artifacts in a TOSCA environment. This includes the validation of TOSCA templates, artifacts, and instances, as well as the deployment of the application in a continuous manner.

To implement TOSCA CI, you can make use of automation tools like Jenkins, Travis CI, or CircleCI. These tools allow you to automate the entire workflow, from code commits to deployment, making it easier and faster to deliver error-free applications.

In summary, implementing TOSCA CI involves setting up an automated workflow that ensures consistent validation and verification of cloud application artifacts in a TOSCA environment, thereby enabling faster and more reliable delivery of error-free applications.

How to Retrieve Data from Excel using TOSCA?


import com.tricentis.tosca.interactions.*;

public class ExcelReader {

  //Method to read data from Excel
  public static String readDataFromExcel(String fileName, String sheetName, int rowNum, int colNum) throws IOException {
    //Creating an object of FileInputStream class to read the Excel file
    FileInputStream inputStream = new FileInputStream(new File(fileName));
    //Creating an object of Workbook class to read the Sheet
    XSSFWorkbook workBook = new XSSFWorkbook(inputStream);
    //Creating an object of Worksheet class to read the Rows
    XSSFSheet workSheet = workBook.getSheet(sheetName);
    //Getting the cell value
    XSSFRow row = workSheet.getRow(rowNum);
    XSSFCell cell = row.getCell(colNum);
    String cellValue = cell.getStringCellValue();
    //Closing the workbook and inputStream
    //Returning the cell value
    return cellValue;

Above code demonstrates how to retrieve data from an Excel sheet using TOSCA. It uses XSSFWorkbook class to read the Excel file, XSSFSheet class to read the Sheet, XSSFRow class to read the Rows and XSSFCell class to get the cell value.

The readDataFromExcel method reads data from the specified Excel file, sheet, row, and column numbers and returns the cell value. The method throws an IOException to handle any errors while reading the file.

You can call this method in your TOSCA test case to retrieve data from an Excel sheet.

How to Create a Test Case Template Manually

To create a test case template manually, follow these steps:

1. Open a new Microsoft Excel spreadsheet and create column headings for the following fields: Test Case ID, Test Case Description, Test Steps, Expected Results, and Actual Results. 2. Fill in the Test Case ID and Test Case Description fields with appropriate values. The Test Case ID should be an alpha-numeric identifier that can be used to uniquely identify the test case. The Test Case Description should provide a brief overview of the test case objective. 3. In the Test Steps column, enter a step-by-step procedure for executing the test case. 4. In the Expected Results column, describe the expected outcome for each step of the test case. 5. Execute the test case and document the actual outcome for each step in the Actual Results column.

By following these simple steps and maintaining a consistent format, you can easily create a test case template that can be used for multiple test cases.

Instantiating Test Cases with Excel

To instantiate test cases with Excel, the following steps can be followed:

1. Create an Excel worksheet with test case data, including the test case name, preconditions, steps, expected results, and any other relevant information.

2. Save the Excel worksheet as a ".csv" file.

3. Write a script to read the ".csv" file and extract the test data for each test case.

4. Use the extracted test data to instantiate the test cases for execution.

5. Execute the test cases and log the results.

6. Analyze the test results and report any issues or defects found.

It is worth noting that there are many frameworks available for test case instantiation and execution, such as TestNG, JUnit, and NUnit, which can greatly simplify the process and provide additional features such as data-driven testing and parallel test execution.

Steps for Integrating Tosca Connect and HP ALM (Application Lifecycle Management)

  1. Open Tosca Connect and select Settings.
  2. Select Integration and choose HP ALM as the integration type.
  3. Enter the connection details for your HP ALM instance, including URL, username, and password. Click Test Connection to ensure that Tosca can connect to the HP ALM instance.
  4. Next, select the project within HP ALM that you want to integrate with Tosca.
  5. Under Requirements, select the checkbox next to Import Requirements and choose the corresponding field in HP ALM that maps to the Tosca requirements field.
  6. Then, under Test Cases, select the checkbox next to Import Test Cases and choose the corresponding field in HP ALM that maps to the Tosca test case field.
  7. Lastly, under Execution Results, select the checkbox next to Export Execution Results and choose the corresponding field in HP ALM that maps to the Tosca execution results field.
  8. Click Save to complete the integration.

Note: Please ensure that Tosca Connect and HP ALM are both properly configured and set up before attempting integration.

Checking if a File Exists in a Specific Directory in TOSCA

To check if a file exists in a specific directory in TOSCA, you can use the "FileExists" function. Here's an example of how to use it:

let $filePath := "C:\Users\Username\Documents\file.txt"

if(FileExists($filePath)) then LogInfo("File exists in the directory") else LogError("File does not exist in the directory")

In this example, we first set the path of the file we want to check using a variable called "$filePath". We then use the "FileExists" function to check if the file exists in the specified directory.

If the file exists, we log an information message using the "LogInfo" function. If the file does not exist, we log an error message using the "LogError" function.

This is a simple and effective way to check if a file exists in a specific directory in TOSCA.

Technical Interview Guides

Here are guides for technical interviews, categorized from introductory to advanced levels.

View All

Best MCQ

As part of their written examination, numerous tech companies necessitate candidates to complete multiple-choice questions (MCQs) assessing their technical aptitude.

View MCQ's
Made with love
This website uses cookies to make IQCode work for you. By using this site, you agree to our cookie policy

Welcome Back!

Sign up to unlock all of IQCode features:
  • Test your skills and track progress
  • Engage in comprehensive interactive courses
  • Commit to daily skill-enhancing challenges
  • Solve practical, real-world issues
  • Share your insights and learnings
Create an account
Sign in
Recover lost password
Or log in with

Create a Free Account

Sign up to unlock all of IQCode features:
  • Test your skills and track progress
  • Engage in comprehensive interactive courses
  • Commit to daily skill-enhancing challenges
  • Solve practical, real-world issues
  • Share your insights and learnings
Create an account
Sign up
Or sign up with
By signing up, you agree to the Terms and Conditions and Privacy Policy. You also agree to receive product-related marketing emails from IQCode, which you can unsubscribe from at any time.