Free UIPATH-ADAV1 Practice Test Questions and Answers (2026)

The Object Repository is designed for creating reusable UI elements. When an element from the repository is used in an activity, it creates a link. Modifying the element via any linked activity will update the central object in the repository, affecting all other activities that use it. To make a change to a selector for a single, specific activity without impacting others, you must first sever this connection. The "Unlink from Object Repository" option achieves this by converting the linked element into a local, inline selector within that activity's properties. Once unlinked, it can be edited independently.

A: Editing the target of a linked element will modify the shared object in the repository, which is the opposite of the desired outcome.

B: This option only highlights the element in the Object Repository panel and does not enable isolated editing.

C: Re-indicating the target on screen updates the linked repository element, propagating the change to all its usages.

1. UiPath Studio Documentation. (2023). Object Repository - Edit a Descriptor in an Activity. UiPath. Retrieved from https://docs.uipath.com/studio/standalone/2023.10/user-guide/object-repository#edit-a-descriptor-in-an-activity. "To edit the descriptor only for a specific activity, you must first unlink the activity from the Object Repository. Right-click the descriptor in the activity and select Unlink from Object Repository."

2. UiPath Academy. (2023). Automation Developer Associate Course - The Object Repository. "If you need to make a one-off change to a selector for a single activity, you must first unlink it. This makes the selector local to the activity, so changes won't affect the central repository object."

In the Robotic Enterprise Framework (REFramework), exceptions are categorized as either Business Rule Exceptions or Application Exceptions. A Business Rule Exception signifies an issue with the transaction data itself (e.g., invalid input), not a failure of the application. The framework is designed to handle this by logging the failure, marking the transaction item's status as "Failed," and then transitioning to the "Get Transaction Data" state to fetch and process the next item in the queue. This ensures the robot continues processing other valid transactions.

B. The process only transitions to the Initialization state at the very beginning or after a critical system error that requires a restart.

C. The process transitions to the End Process state only when there is no more transaction data or after an unrecoverable system exception.

D. The process is already in the Process Transaction state when the exception occurs; it transitions from this state, not back to it in this scenario.

1. UiPath Documentation, "Robotic Enterprise Framework Guide - 4 - The Process State". The state machine diagram and logic description show that after a Business Rule Exception is caught in the Process Transaction state, the transition leads directly to the Get Transaction Data state. The guide explains this is the designed behavior for handling non-system errors.

The 'FullText' method is the only scraping option that can extract hidden text from a UI element, including a PDF. It works by reading the application's underlying text information directly from the UI framework's accessibility or text buffer, rather than relying on what is visually rendered on the screen. Because it doesn't depend on visual elements, it can access text that is not visible to the user. Native and OCR methods can only extract text that is visible on the screen.

A: The Native method cannot extract hidden text; it relies on the application's visible text rendering engine.

B: The Native method only works on visible text and cannot extract hidden information from a PDF.

C: OCR (Optical Character Recognition) works by taking a screenshot of the UI and converting the image to text, so it can only extract visible text.

1. UiPath Studio Documentation, "UI Automation". The section on "Input and Output Methods" compares Full Text, Native, and OCR. It explicitly states, "Full Text -... Can also extract hidden text."

2. UiPath Academy, "UI Automation with Classic Experience". The module on "Data Scraping and Screen Scraping" details the capabilities of each method. It highlights that FullText is the fastest method and is capable of extracting hidden text, unlike Native or OCR.

To filter Outlook emails in the Get Outlook Mail Messages activity, a developer uses the Filter property. The value for this property should be a string representing a DASL (DAV Searching and Locating) query. To find all emails containing the word "UiPath" anywhere in the subject, the correct schema is @SQL="urn:schemas:httpmail:subject" like '%UiPath%'. The % characters act as wildcards, matching any sequence of characters before or after "UiPath". The option presents FilterSchema as the property, which is likely a misnomer for the Filter property where this schema is entered.

A. The schema like 'UiPath%' would only retrieve emails where the subject starts with "UiPath", not contains it anywhere.

C. This schema is incorrect as it only matches subjects that start with "UiPath", and the property name is also likely a distractor.

D. While the schema is correct, the property name FilterByMessageldsSchema is incorrect and not a valid property for this activity.

1. UiPath Activities Guide, "Get Outlook Mail Messages". The documentation for this activity describes the Filter property, stating it is "A string used for filtering messages. (Supports DASL queries)."

2. Microsoft Docs, "Filtering Items Using a String Comparison". This official Microsoft documentation explains the use of the like keyword and the % wildcard in DASL queries for partial string matches, which is the underlying technology used by the UiPath activity. The example ... LIKE '%sometext%' is shown for a "contains" search.

Following standard Robotic Process Automation (RPA) design principles, specifically within UiPath Studio, variables must be scoped to the innermost container (Sequence or Flowchart) where they are required. This optimizes memory allocation and prevents unintended variable manipulation.

• dt_NamesBirthdays: This DataTable holds the initial collection of data that the entire process relies upon. It must be scoped to the outermost sequence, Voter Registration, so it can be populated and subsequently passed to the loop activities.
• Age and TimeOnThePlanet: These variables are calculated and evaluated on a per-row basis for each individual person. Their utility is isolated to the logic that checks eligibility. Therefore, they should be scoped to the Determine Age and Eligibility to Vote sequence to adhere to the principle of least privilege and narrowest scope.

UiPath Studio Official Documentation. "Variables Management and Scoping." UiPath Docs, UiPath, 2023. (Section: Managing Variables -> Variable Scope).

UiPath Center of Excellence (CoE). "RPA Developer Best Practices: Workflow Design." UiPath Documentation Portal, UiPath, 2023. (Section: Memory Management and State).

In the provided UiPath UI Explorer exhibit, the current generated selector uses an anchor (the LABEL with aaname='First Name'), navigates up the DOM tree (<nav up='1' />), and then attempts to identify the target element using only the class and parentclass attributes. Because web forms frequently apply identical validation classes (like ng-untouched, ng-pristine) to both a label's container and the input field itself, the selector becomes overly broad and targets both. To ensure the selector strictly interacts with the text entry field, the developer must check the tag property in the "Unselected Items" pane. This appends tag='INPUT' to the target node of the selector, explicitly filtering out LABEL or DIV elements and reliably targeting the text field. Note that checking id or name would be incorrect for the RPA Challenge, as those values (e.g., choXw) are dynamically generated upon every page refresh.

UiPath Studio Official Documentation, "About Selectors" (Studio Guide). Details how selectors are constructed using XML fragments and how omitting the tag attribute can lead to overly broad identification.

UiPath Studio Official Documentation, "UI Explorer" (Studio Guide). Explains the function of the Property Explorer and Unselected Items panes, specifically outlining how adding the tag attribute forces strict HTML element matching during UI automation.

UiPath Academy, "RPA Developer Foundation", Selectors in Studio Module. Demonstrates the specific "RPA Challenge" use case, explicitly teaching developers to avoid dynamic id and name attributes and instead rely on stable anchors combined with tag='INPUT' to identify target text fields.

In the UiPath Robotic Enterprise Framework (REFramework), the TransactionItem variable represents the single unit of work being processed in the current iteration. By default, this is set to a QueueItem for Orchestrator queues. However, when the process relies on a DataTable to hold the collection of transactions (the TransactionData variable), each individual transaction extracted from that table is a single row. Therefore, the TransactionItem must be updated to the DataRow (System.Data.DataRow) variable type to successfully iterate through the vendor names and addresses.

UiPath Studio Official Documentation, Robotic Enterprise Framework Template > Using the Framework with Tabular Data, Variable configurations section.

UiPath Academy Courseware (Advanced RPA Developer Certification Prep), State Machines and the REFramework, Sub-module: Adapting REFramework for non-Queue items.

In UiPath Studio, publishing an automation project follows a specific wizard-driven sequence. First, the user must initiate the process by clicking the Publish button located in the Design ribbon. This action opens the "Publish" window. In the first section of this window (Package Properties), the user fills in the project's metadata, including the package name, version, and release notes or description. Next, the user advances to the "Publish options" section to select the destination target, such as an Orchestrator Tenant, a local machine folder, or a Custom NuGet feed. Finally, to execute and finalize the deployment, the user clicks the final Publish button at the bottom of the dialog.

UiPath Studio Official Documentation: "Publishing Automation Projects." Section: To publish a project. This document outlines the exact GUI steps, from selecting the ribbon button to filling out the Package Properties and configuring the Publish Options before final execution.

URL: https://docs.uipath.com/studio/standalone/2023.10/user-guide/about-publishing-automation-projects (Applicable across modern Studio versions).

UiPath Academy: "RPA Developer Foundation." Module: Project Organization and Publishing. Courseware details the deployment lifecycle and the step-by-step UI interaction required to package and push a .nupkg file from Studio to Orchestrator or local feeds.

According to standard RPA debugging workflows, resolving a broken automation begins with identifying the precise point of failure by examining execution logs to isolate the faulted activity. Once the activity is pinpointed, the developer inspects the current state (verifying selector accuracy) and inserts a breakpoint to pause execution prior to the crash. During this paused state, the developer can securely analyze the application's UI structure and modify the problematic selector using tools like UI Explorer, adding wildcards or variables to ensure resilience against future UI changes. Finally, the modified process is executed in Debug mode to validate the fix and confirm the process runs smoothly without throwing the previous exception.

UiPath Studio Official Documentation Document: Studio Guide - Debugging

Section: Debugging Actions and Tools / Breakpoints

Details: Outlines the standard operating procedure for pausing execution, identifying faulting activities, and inspecting localized element states during runtime.

UiPath Studio Official Documentation Document: Studio Guide - UI Automation

Section: About Selectors & Fine-Tuning Selectors

Details: Details best practices for enhancing selector flexibility and resilience using wildcards and dynamic variables when application UIs are updated or altered.

UiPath Robot Official Documentation Document: Robot Guide - Logging

Section: Execution Logs and Error Troubleshooting

Details: Describes how error logs generate trace details to identify the exact activity source causing an execution exception.

To install the UiPath extension for Chrome directly from UiPath Studio, the developer must first navigate to the "Home" view (also known as the Studio Backstage view). From this menu, clicking the "Tools" tab reveals the "UiPath Extensions" list. The developer then locates "Chrome" and clicks "Install". Once the installation is triggered, a background process attempts to add the extension to the browser. Finally, the developer must open Google Chrome and click "Enable extension" in the browser's confirmation prompt to authorize the native messaging host and activate the add-on for UI automation.

UiPath Studio Official Documentation. Section: "UI Automation" -> "Extensions" -> "Extension for Chrome". Sub-section: "Install from UiPath Studio". Paragraph 1-3 details the step-by-step navigation from Home > Tools > UiPath Extensions > Chrome, followed by the browser-side enablement.