For verifying the functionality of a new process and its associated UI elements, the combination of

creating scenario tests and adding explicit assertions is most effective.

A . Add explicit assertions on the UI elements: Assertions are used in testing to verify that a UI

element is in the expected state or contains the expected value after certain interactions have

occurred. They are crucial for ensuring that the UI behaves as intended, making them an integral part

of thorough testing strategies.

D . Create a scenario test for the case type: Scenario tests allow you to record a sequence of

interactions within your application to simulate real-world usage. Creating a scenario test for a case

type enables the recording and playback of interactions, including navigating through the process

and inputting data into fields, to verify that the entire case behaves as expected from start to finish.

Both options, when used together, provide a powerful approach to testing by allowing you to define

and verify the expected behavior of UI elements within the context of the complete process flow of a

case type.

Reference: Pega Academy materials on scenario testing, which include instructions for creating

scenario tests and adding assertions to ensure the accuracy of both the process flow and the UI

element interactions.

To test a report, specifically the recent hire training report within a human resources application, the

most direct and effective method is to run the report definition against actual data. This approach

allows for the evaluation of the report's functionality, ensuring it meets the requirements and

accurately reflects the data.

D . Run the report definition using the contents of a database table: This option involves executing

the report definition to generate the report using data stored in a database table. It allows for the

assessment of how well the report handles real data, including the correctness of the information

displayed, the performance of the report, and whether it meets the product manager's requirements

for reviewing hiring practices.

Creating a copy of the rule (A) and initializing the rule with test data using the run rule window (B)

can be part of the development or debugging process but might not fully test the report under

realistic conditions. Identifying a data test page to unit test the rule (C) is more applicable to testing

rule logic rather than report output.

Reference: Pega's documentation on report testing emphasizes the importance of evaluating report

definitions with real or representative data to ensure accuracy and performance before deployment.

To create a custom status named Open-Review in Pega, applicable to assignments in a specific

application:

C . Create a field value record named Open-Review for .pyStatusWork with the Apply To class set to

the class group. This solution involves creating a field value for the custom status within the context

of the specific application's class group. This approach ensures that the custom status is recognized

and used correctly within the application, maintaining consistency and clarity in status handling

across the application.

The Localization Wizard in Pega is designed to facilitate the localization of various rule types that

involve user-facing text:

B . Paragraph. Paragraph rules, which contain blocks of text used in user interfaces, are often

localized to cater to different languages, making them accessible and understandable to users in

various regions.

C . Correspondence Fragment. Correspondence fragments are parts of larger correspondence

templates and typically contain text that needs to be presented in the user's language, making them

crucial candidates for localization using the wizard.

pyWorkPage is a central concept in Pega, serving as the primary page that contains all the data

associated with a particular case as it is being created and processed:

D . pyWorkPage contains all the case data generated while creating and processing a case. This page

acts as the primary clipboard page for a case, holding all data entered by the user, data generated by

the system, and data that might be populated from other sources or data pages throughout the case

lifecycle. It essentially serves as the working memory for the case instance.

To validate the minimum age of a potential customer in a specific assignment step within Pega:

B . Reference the Edit Validate rule on the Collect Account Information flow action. Although

typically, an Edit Validate rule would be used to check formats rather than conditions like age,

referencing a validation rule within the flow action is the right approach to ensure data correctness

before the user progresses past this step.

F . Create a Validate rule to check the customer age. A Validate rule is suited for checking conditions

such as age requirements, ensuring that only eligible individuals can proceed. It checks that the age

meets a specified minimum before allowing the process to continue.

Field values in Pega are specifically designed to support localization of content, which is ideal for

displaying static content in multiple languages:

B . A global hotel chain application can display current amenities in 23 languages. This requirement is

perfectly aligned with the purpose of field values, which is to provide localized text for labels, button

texts, tooltips, and other interface elements across different locales. Using field values, a hotel chain

application can manage and display amenity descriptions in multiple languages, enhancing the user

experience for international customers.

Field Value rules in Pega are used primarily for localizing user interface elements:

A . Labels and drop-down values on a section rule. Localizing these elements ensures that

applications can adapt to different languages and regional settings, enhancing user accessibility and

usability across diverse geographical locations.

For the requirement that a credit check must be completed for a credit card to be approved,

incorporating the credit check as part of the credit card application process is necessary. The most

straightforward way to model this is by using case type relationships.

C . Make credit check a child case of credit card request: This configuration establishes the credit

check as an integral step within the credit card request process, ensuring that the credit check is

completed before the credit card can be approved. Making the credit check a child case means it is

directly associated with and dependent on the parent credit card request case, aligning perfectly

with the requirement.

Making both the loan request and credit check top cases (A) does not establish the necessary

dependency. Creating a spin-off case (B) suggests a parallel or subsequent process not inherently

dependent on the completion of the credit check for the credit card request, which could misalign

with the requirement. Making the credit card request a child case of credit check (D) inverts the

intended relationship and does not accurately represent the process flow described in the

requirement.

Reference: Pega's case management documentation provides insights into designing case hierarchies

and relationships, including the use of child cases to model dependent processes within an

overarching case.

In Pega, when configuring data pages to source UI controls such as drop-down lists, it's crucial to

select the configuration that optimally uses memory and efficiently serves the data to the users. For

this scenario, the correct answer is Option F: List, ACME-Products-Data-Color, ReadOnly, Node.

List vs. Page: Choosing 'List' is appropriate because the requirement is to populate a drop-down list

with multiple entries (colors in this case). 'Page' would be used for single record data, which is not

the case here.

Object Type: 'ACME-Products-Data-Color' is chosen because the data represents a list of color

options provided by the manufacturer, which is typically static reference data, fitting the 'Data' class

layer rather than the 'Work' layer which is used for case management or the 'Work-ColorFeedback'

which would be used for storing feedback or interactions specific to colors.

Edit Mode: 'ReadOnly' is the correct mode since users are selecting a color from a pre-defined list

and are not expected to edit these values directly.

Scope: 'Node' is selected to minimize memory usage. By setting the scope to 'Node', the data page is

loaded once per node (server instance) and shared across all requestors (users) on that node, which

is memory efficient for data that doesn't change often and is applicable across all users, such as a list

of colors.

This configuration ensures that the data page is loaded efficiently in a read-only list format at the

node level, reducing the overall memory footprint while making the color selections available across

the application.

Reference: Pega Academy's Data Pages module, which covers data page types, scopes, and best

practices for optimizing application performance and memory usage.