• Home
• UiPath Exams
• UiRPA - UiPath Certified RPA Associate v1.0

UiRPA UiPath Practice Test Questions and Exam Dumps

Question 1

A developer wants a new data table, dt_Result, that is only populated with common rows found in two data tables, dt_PreviousEmployees and dt_NewEmployees. Which activity should be used to perform this operation?

A. Sort Data Table
B. Merge Data Table
C. Join Data Table
D. Filter Data Table

Answer: C

Explanation:
To extract only the common rows that exist in two separate data tables — in this case, dt_PreviousEmployees and dt_NewEmployees — the most appropriate activity to use is Join Data Table. The Join Data Table activity is designed specifically to identify relationships between rows in two data tables based on a common column or set of columns, much like SQL joins.

In this scenario, the developer wants to retain only those rows that are found in both data tables. This type of join is known as an inner join, where only matching rows from both tables based on a specified key are returned. When the Join Data Table activity is configured to perform an inner join, it compares rows using a key column (or columns) and includes only those rows in the output where a match is found in both the left and right data tables.

Let’s examine why the other options are incorrect:

A. Sort Data Table is used to arrange rows in a data table based on values in one or more columns, either in ascending or descending order. While useful for organizing data, it does not compare two tables or filter rows based on mutual presence.

B. Merge Data Table is typically used to combine all rows from two data tables into one, regardless of whether the rows are unique or duplicated. This activity appends the contents of one table to another but does not check for matching entries. As a result, it cannot be used to isolate only the common rows.

D. Filter Data Table is useful when you want to extract rows from a single table based on specific conditions or expressions applied to column values. While it can be powerful for filtering based on internal logic within one table, it is not intended to compare two separate data tables directly. Therefore, it cannot identify common rows across both tables on its own unless combined with custom logic.

The Join Data Table activity allows the developer to define keys (like "EmployeeID" or "Name") on which the join is based. After performing the inner join, the result will be a new data table, dt_Result, containing only those employees who appear in both dt_PreviousEmployees and dt_NewEmployees.

Therefore, based on the operation's requirement — finding the intersection of two data tables — the correct choice is C.

Question 2

A developer is working with a string variable and wants to determine the number of characters it contains. What is the correct way to retrieve this information?

A. variable.Length
B. variable.Count
C. variable.Max
D. variable.Chars

Answer: A

Explanation:
In many programming languages such as C#, Java, and others, strings are treated as sequences of characters, and each string object provides a built-in method or property to return the number of characters it contains. The most common and direct way to determine the length of a string is through the .Length property.

Option A is the correct answer because variable.Length returns the total number of characters in the string, including letters, digits, whitespace, and special characters. This is a property that is widely available in .NET languages (like C#), Java, and other object-oriented languages. For example, in C#:

string example = "ChatGPT";

int length = example.Length; // returns 7

Here, Length accesses a built-in property of the string that returns an integer representing how many characters are in the string.

Option B, variable.Count, is incorrect in this context. Although Count is a method or property used with collections like arrays, lists, and other enumerable types in LINQ (Language Integrated Query), it is not a direct property of a string object. Trying to use .Count directly on a string without importing additional libraries or converting the string to a collection would result in an error.

Option C, variable.Max, is also incorrect. The Max function is used to return the maximum value from a collection of items, such as the highest number in an array. It does not return the number of characters and does not apply to string objects in this way.

Option D, variable.Chars, refers to accessing individual characters by index in some languages, such as C#. For example, variable[0] or variable.Chars[0] would return the first character of the string. However, Chars is not used to determine the number of characters in a string—it is used to reference a specific character at a given position. Therefore, while Chars may help inspect parts of a string, it does not provide information about the string’s total length.

To summarize, the .Length property is the most straightforward and correct method to determine the number of characters in a string variable. It is universally recognized in major programming languages and provides an efficient way to assess string size without iteration or conversion.

Question 3

When is the Anchor Base activity used to automate interaction with an application?

A. When all the element selectors in the application are reliable
B. When the element selector is reliable but the element's position on the screen changes
C. When no element selectors are available in the automated application
D. When the element selector is not reliable and the element's position on the screen changes

Answer: D

Explanation:
The Anchor Base activity is specifically designed for scenarios where a target UI element may not have a reliable selector or where its position on the screen might vary dynamically. This situation often arises in applications where the UI is not built using standard controls or where the layout changes frequently based on user interaction or system behavior.

Anchor Base works by using two components: an anchor and an action. The anchor is a stable, nearby UI element that has a consistent and reliable selector, while the action is the activity that interacts with the desired but potentially unstable UI element. For example, if the "Username" field on a login form moves around based on screen resolution or layout changes, but the "Username" label next to it is always present and in a predictable location, the "Username" label can serve as the anchor. The automation tool then finds the label first and locates the input field relative to it.

Option A is incorrect because if all selectors are reliable, standard UI automation activities like Click, Type Into, or Get Text would suffice. There would be no need to introduce the Anchor Base activity.

Option B refers to a situation where selectors are reliable but the element's position changes. However, reliable selectors typically include attributes that are independent of screen position, such as element ID or name, so changing position should not affect the selector's functionality. In this case, the Anchor Base activity is not required.

Option C is incorrect because if there are truly no selectors available at all, other approaches such as image-based automation or OCR might be more appropriate. Anchor Base still requires at least one reliable selector to function — that of the anchor element.

Option D correctly identifies the condition under which Anchor Base is most useful: when the selector for the target element is unreliable and the element’s position may change. In this case, the anchor provides a point of reference that the automation can use to consistently locate the desired UI element.

In conclusion, Anchor Base is most effectively used in unstable UI environments where the location of elements can change and selectors cannot be fully trusted, making D the correct answer.

Question 4

While working on a project linked to a GIT version control system, which context menu option allows you to upload your local file changes to the remote repository?

A. Push
B. Pull (rebase)
C. Set As Main
D. Show History

Answer: A

Explanation:
In Git-based version control systems, there is a clearly defined process for synchronizing changes between a local repository and a remote repository. When a developer makes changes to files locally and wants to share or synchronize those changes with the remote repository (usually hosted on platforms like GitHub, GitLab, or Bitbucket), they must use the Push operation.

Option A, Push, is the correct answer because this command sends committed changes from the local Git repository to the associated branch in the remote repository. This is typically done after a developer has made and committed changes locally. The process generally follows these steps:

1. Modify files in the working directory.

2. Stage changes with git add.

3. Commit changes to the local repository with git commit.

4. Use git push (or the Push option in GUI tools) to send those changes to the remote repository.

This operation updates the remote repository so that others can access the latest changes and integrate them into their own copies of the codebase.

Option B, Pull (rebase), is incorrect in this context. Pulling with rebase is used to update your local branch with the latest changes from the remote branch. It integrates remote changes into the local repository but does not send local changes to the remote server. This is the inverse of what the question is asking.

Option C, Set As Main, is unrelated to synchronizing code. This action might change the default branch designation in some Git tools, such as marking a particular branch as the primary working branch. However, it does not upload or share local file changes to the remote repository.

Option D, Show History, allows users to view the commit history of a file or project. It’s useful for tracking changes over time and seeing what modifications were made and by whom. However, it does not actually transfer any data to the remote repository.

To recap, only the Push command fulfills the requirement of sending or providing local changes to the remote repository in a Git-based version control system. Without pushing, other users or systems would not see any updates made locally. Therefore, it is a critical part of collaborative development and continuous integration workflows.

Question 5

A developer needs to create a process that identifies and then processes background verification documents from 10 separate vendors. Each vendor has a different document format that must be processed in a unique way. Based on best practices, 

Which activity is recommended for creating a different set of actions for each vendor?

A. Flow Switch
B. Do While
C. Flow Decision
D. For Each

Answer: A

Explanation:
When a process must execute different actions based on multiple distinct conditions — in this case, different document formats from 10 vendors — the most suitable approach is to use a control structure that allows branching into several possible execution paths. This is exactly what the Flow Switch activity provides.

The Flow Switch activity is designed for cases where a variable (such as a vendor name or document type) can take on multiple known values, and each value requires a separate set of instructions. It operates similarly to a switch-case statement in traditional programming languages, making it ideal for handling multiple branches based on a single condition.

In this scenario, the developer will likely extract or identify a vendor ID or name from each incoming document. The Flow Switch can then evaluate this identifier and direct the process to the appropriate branch designed to handle that specific vendor’s document structure. This allows the process to remain organized, scalable, and easy to maintain, especially as more vendors might be added in the future.

Option B, Do While, is used when you need to repeat a set of actions based on a condition being true. It is useful for loops, not for conditionally branching to different logic paths based on distinct values.

Option C, Flow Decision, is used for binary conditions — when there are only two paths to choose from, typically "True" and "False." It is not optimal for handling 10 separate branches, as it would require nesting multiple Flow Decisions, which can make the workflow more complex and less readable.

Option D, For Each, is used for iterating over a collection of items. While it could be used to loop through a list of documents, it does not provide the branching capability required to process different formats based on vendor-specific logic. You might use a For Each in conjunction with Flow Switch, but on its own, it cannot handle the conditionally different actions.

Therefore, following best practices for clarity and scalability, the Flow Switch activity is the most appropriate for this scenario, making A the correct answer.

Question 6

In UiPath Orchestrator version 2020.10, under what condition is a transaction item marked with the status “Abandoned”?

A. When the item did not meet a business or application requirement within the project
B. When the item was processed with the Get Transaction Item activity
C. When the item was “In Progress” but the transaction status was not set to “Successful” or “Failed”
D. When the item has been manually selected from the Transactions page and marked as “Deleted”

Answer: C

Explanation:
In UiPath Orchestrator, transaction items go through various status changes during their lifecycle. These statuses are important for tracking the progress and result of the items processed by robots, especially when using queues in conjunction with robotic process automation (RPA) workflows.

The Abandoned status in UiPath is specifically applied under the following condition: if a transaction item is retrieved by a robot (marked In Progress) using the Get Transaction Item activity but never explicitly marked as either Successful or Failed (using Set Transaction Status) within a set time window, then Orchestrator considers the item as "Abandoned." This typically happens when:

• A robot picks up a transaction but crashes before completing the process.

• The process encounters a fatal error or is terminated unexpectedly.

• The transaction remains stuck in an "In Progress" state for a period longer than the system-defined threshold (default is 24 hours).

Let's review the options:

Option A is incorrect because whether a transaction meets a business or application requirement is typically reflected in the Failed status, not Abandoned. A developer sets the transaction status based on logic and rules coded into the workflow.

Option B is misleading. The transaction is marked In Progress when retrieved using the Get Transaction Item activity, but retrieving it alone does not cause it to be marked as Abandoned. It will only become Abandoned if its status is not later set to Successful or Failed.

Option C is correct. A transaction retrieved by a robot becomes In Progress. If the robot fails to update the transaction's status (either to Success or Failure) within a certain timeframe, Orchestrator automatically sets it to Abandoned to indicate that the item was not properly processed and requires attention.

Option D is incorrect. Manually deleting a transaction or marking it as Deleted is not the same as it being Abandoned. "Deleted" is a different status category and reflects a user-initiated change, not an automated system classification due to inaction.

In summary, the "Abandoned" status is a safeguard feature in UiPath Orchestrator designed to flag transaction items that were picked up but not processed to completion. This helps identify and troubleshoot workflows that may have failed or halted mid-execution, ensuring accountability and system robustness.

Question 7

Which activity will return a Boolean value?

A. Find Image
B. Wait Element Vanish
C. Element Scope
D. Image Exists

Answer: D

Explanation:
In automation workflows, especially when working with user interfaces, it's often necessary to check for the presence or absence of certain elements, such as images or UI components. Among the options listed, the Image Exists activity is specifically designed to return a Boolean value — either True or False — depending on whether the specified image is found on the screen at the time the activity runs.

The Image Exists activity works by scanning the screen or a defined UI element for an image provided by the user. If the image is present and matches, the activity returns True. If the image is not found, it returns False. This Boolean result is particularly useful in conditional logic, such as in If activities or Flow Decisions, where further steps depend on whether the image is available.

Option A, Find Image, is designed to locate an image on the screen and returns a UI element reference, not a Boolean. It is used when you need to interact with the image or its position after locating it, not merely to check for its presence.

Option B, Wait Element Vanish, waits for a specific UI element to disappear from the screen. While it does result in success or timeout, it does not directly return a Boolean value; instead, it is used for synchronization purposes, not for condition evaluation.

Option C, Element Scope, is not a standalone activity that returns a result. Instead, it is used to define a container for other UI activities, helping to scope the search for elements within a particular part of the user interface. It does not return any value by itself, Boolean or otherwise.

In summary, among all the options, only Image Exists is explicitly designed to return a Boolean value indicating the presence or absence of a visual element on the screen. This makes D the correct answer.

Question 8

A developer is designing a process that should operate in the background without showing Excel on the screen, while still using Excel activities. Which property of the Excel Application Scope activity needs to be set for this background execution to work correctly?

A. Read-only
B. Private
C. Save Changes
D. Visible

Answer: D

Explanation:
In UiPath, the Excel Application Scope activity is used to work with Excel files using Microsoft Excel installed on the machine. This activity provides a number of properties that determine how Excel is launched and behaves during execution. One of the common scenarios developers face is running Excel automation in the background, so the user does not see the Excel interface opening, updating, or closing during the automation process.

To achieve this background execution, the most relevant and effective setting is the Visible property. When this property is unchecked or set to false, Excel runs in the background—meaning the user will not see any Excel windows pop up on the screen during automation. This is especially helpful in attended or unattended automation scenarios where user experience or desktop cleanliness is a concern.

Let’s go through the options:

Option A: Read-only
This property, when checked, opens the Excel file in read-only mode. It is helpful when the developer wants to ensure that the file is not accidentally altered during execution. However, it has no bearing on whether Excel appears on the screen or runs in the background. Therefore, this does not satisfy the requirement stated in the question.

Option B: Private
The Private property is used to hide sensitive data in logs. If marked as true, the activity’s details won’t appear in the logs generated by the Orchestrator. This is important for security, especially when dealing with passwords or confidential information, but it does not affect whether Excel runs visibly or in the background.

Option C: Save Changes
This property, when enabled, allows the automation to save any changes made to the Excel file before closing the session. It's crucial for ensuring data is written back to the file but, again, it has no impact on the visibility of the Excel window during execution.

Option D: Visible
This is the correct answer. When the Visible property is set to false, Excel runs in the background without any UI being displayed to the user. This is exactly what the developer needs in order to run the automation in the screen’s background.

To summarize, if a developer wants to use Excel Application Scope activities without showing Excel on the screen, they must configure the Visible property to be unchecked or set to false. This allows the process to execute silently in the background, improving performance and minimizing user distraction or interference.

Question 9

If an argument is renamed from the Arguments panel, what happens?

A. Argument name must be manually updated only in UI Automation activities that use that argument
B. Argument direction will be updated to “In/Out” when renamed
C. Argument name must be manually updated in all activities that use that argument
D. Argument name is automatically updated in all activities that use that argument

Answer: D

Explanation:
In UiPath, arguments are used to pass data between workflows. They are defined and managed in the Arguments panel, and when used in workflows, they often appear in expressions, assignments, conditions, and as input/output parameters in activities. When an argument is renamed directly from the Arguments panel, the change is automatically reflected throughout the workflow wherever that argument is used.

This functionality is part of UiPath Studio’s intelligent design environment, which includes a built-in refactoring capability. The development environment ensures consistency by updating all references to the renamed argument so that the user doesn't have to manually find and replace every instance where the old argument name was used. This not only saves time but also reduces the chance of errors that could arise from mismatched or outdated references.

Option A incorrectly implies that manual updates are needed only for UI Automation activities, but in reality, no manual update is required in any activity — all references are automatically updated.

Option B is unrelated to renaming. The direction of an argument (In, Out, In/Out) is set manually and remains unchanged when the argument name is changed. Renaming does not affect its directionality.

Option C also incorrectly suggests that the user must manually update all activities using the argument. This was true in older or less sophisticated environments, but UiPath Studio has evolved to automatically propagate changes in argument names.

Only option D accurately reflects UiPath Studio’s behavior — renaming an argument in the Arguments panel triggers an automatic update of all instances where that argument is referenced in the workflow. This ensures the project remains functional and consistent without requiring extra effort from the developer.

Question 10

Which method allows you to generate a static selector for an activity in UiPath?

A. Indicating a UI element
B. Including variables in a selector
C. Replacing an attribute value with a wildcard
D. Using an Anchor Base activity

Answer: A

Explanation:
In UiPath, selectors are XML fragments used to identify and interact with UI elements. A static selector is a fixed, unchanging string that directly references a specific UI element. It does not include variables, wildcards, or dynamic expressions. These selectors are most often used when the UI layout is predictable and doesn't change between automation runs.

Option A: Indicating a UI element is the correct answer because this action captures a fixed path to the UI element and generates a static selector. When a developer uses the "Indicate on Screen" feature in UiPath Studio, the selector created is based on the current structure and attributes of the indicated UI element. This selector is stored as a constant string and does not vary unless manually modified. For example:

<wnd app='notepad.exe' cls='Notepad' title='Untitled - Notepad' />

This selector will remain static and will only work if the target application and window title match exactly.

Option B: Including variables in a selector leads to a dynamic selector, not a static one. Variables are used when part of the selector needs to be flexible, such as when window titles or table rows change at runtime. This approach is useful for automation that needs to adapt to changing data, but it no longer qualifies as a static selector.

Option C: Replacing an attribute value with a wildcard introduces flexibility into the selector and again creates a dynamic selector. Wildcards like * or ? are used when exact matches are not reliable or known. For example, using title='*Notepad' would match multiple window titles, and hence, this is not static.

Option D: Using an Anchor Base activity relates to the strategy of finding UI elements based on their relationship with other elements on the screen. While the Anchor Base activity can use selectors internally, its primary function is positional logic rather than selector creation. Therefore, it does not directly result in a static selector.

In conclusion, only Option A—Indicating a UI element—produces a truly static selector, since it results in a hard-coded reference to the specific UI structure at the time the element is captured. This is the most straightforward and reliable method for generating static selectors in UiPath Studio, especially for beginner-level automation where UI consistency is assumed.