CRT-450 Salesforce Certified Platform Developer 1 (SP25) Free Practice Exam Questions (2025 Updated)

To test Apex code that makes HTTP callouts, Salesforce provides theHTTPCalloutMockinterface. Developers create a test class that implementsHTTPCalloutMockto define the fake response that will be returned when the callout is executed during the test.

This ensures that tests do not depend on the availability or behavior of the external system.

Why not other options?

BandC: These are not relevant for testing HTTP callouts.

D: There is no concept of extendingHTTPCalloutMock. It is implemented, not extended.

Apex Testing for HTTP Callouts

Creating test classes ensures that the Apex class works according to specifications by validating the functionality under various scenarios and edge cases. Running tests in the Developer Console provides detailed feedback on whether the class meets requirements.

Comprehensive and Detailed Explanation From Exact Extract:

To implement an interface in Apex, the implements keyword is used in the class definition. This ensures that the class provides concrete implementations of the interface’s methods.

Lightning Web Components (LWCs) are the best choice for creating custom UI components in Salesforce. They provide robust features such as event handling and server-side communication, allowing for validation of user input before saving data.

Why Data Export Scheduled Job?

Salesforce provides an out-of-the-boxData Exportfeature that allows organizations to back up their data, including attachments.

This feature can be scheduled to run automatically on a monthly basis, fulfilling the requirement.

Why Not Other Options?

A. Schedule a Report: Does not export attachments and is limited to reportable data.

B. Data Loader Command Line: Requires manual setup and scripting, which is unnecessary for this requirement.

D. Create a Schedulable Apex class: Not suitable, as the Data Export tool is more efficient for full data and attachment backup.

A. Debug logs can be set for specific users, classes, and triggers:

Debug logs can be configured for users, classes, and triggers by setting trace flags.

C. Only the 20 most recent debug logs for a user are kept:

Salesforce retains only the 20 most recent debug logs per user. Older logs are overwritten.

E. The maximum size of a debug log is 5 MB:

Debug logs are capped at 5 MB. If this limit is exceeded, logging stops for that transaction.

Why Not B and D?

B: Debug logs are retained for7 days, not 24 hours.

D: Debug log levels are not cumulative. Each level is independent.

Pagination using aStandardSetControllerhelps manage large datasets by loading only a subset of records at a time. This approach minimizes view state size, which is critical for handling large datasets like 10,000+ records.

The@TestVisibleannotation allows private methods or variables to be accessed in test classes. This ensures that the private method can be adequately tested without changing its access modifier.

ThedoWorkmethod inserts an account for every iteration of theforloop, which runs fromi = 0toi <= 200, inclusive.

This results in 201 iterations, and hence 201 accounts are inserted into the org.

Explanation of Code Behavior:

The loop conditioni <= 200runs 201 times (0 to 200).

Theinsert acct;statement is executed 201 times.

Apex Developer Guide - Loop Constructs

Lightning Web Components (LWC):

Fully responsive and designed to handle touch events.

Executes on stateful clients with high performance.

Aura Components:

Supports responsive designs and touch events but is slightly less efficient than LWC.

Why Not Other Options?

B. Visualforce Components: Not designed for responsiveness or touch event handling.

C. Visualforce Pages: Primarily server-rendered and not stateful for touch interactions.

In Visualforce, to specify a standard controller for a custom object, the syntax iscontroller="ObjectName__c".

To add custom functionality, you can use anextensionsattribute to include a controller extension.

Why not other options?

A: The correct syntax iscontroller, notstandardController, for custom objects.

BandC: These are syntactically incorrect.

Visualforce Pages Documentation

Advantages of Lightning Web Components (LWC):

A. Rich component ecosystem:

LWCs have a modern, rich component library designed for modular and reusable development.

D. Self-contained and reusable units:

LWCs are designed to be modular, reusable, and self-contained, reducing duplication and enhancing maintainability.

Why Not Other Options?

B. Log capturing via Debug Logs Setup page: This is unrelated to LWC and is a debugging feature.

C. Built-in standard and custom set controllers: Relevant to Visualforce, not LWCs.

Salesforce CLI allows developers to automate deployments and run unit tests as part of a continuous integration (CI) pipeline. It is the most efficient tool for scripting these processes.

Salesforce requires that every trigger must have at least 1% test coverage to be deployed. Since the trigger in question has 0% test coverage, the deployment will fail even if the helper method and related classes meet the coverage requirement.

To make an LWC available for use on a record page:

Target Configuration:

Addlightning__RecordPagein the component's.js-meta.xmlfile to specify where the component can be used.

Expose the Component:

SetisExposedtotruein the.js-meta.xmlfile to make the component available for use.

Example.js-meta.xmlFile:

57.0

true

lightning__RecordPage

A: Incorrect placement. Thetag must be in the.js-meta.xmlfile, not the JavaScript file.

D: Thetag is used for metadata labeling, not for exposing or targeting a component.

UsingSecurity.stripInaccessibleensures compliance with field-level security (FLS) and prevents users from accessing fields they do not have permission to view. In this scenario:

The commission field is inaccessible to Sales Assistants, andSecurity.stripInaccessiblewill automatically remove this field from the result set.

It prevents runtime errors when a user without proper access attempts to retrieve restricted fields.

Comprehensive and Detailed Explanation From Exact Extract:

To determine how a developer can use the OrderRequest class within the CustomerOrder class, we need to evaluate the options based on Apex syntax for inheritance, focusing on the fact that OrderRequest is a virtual class. Let’s analyze the problem and each option systematically, referencing Salesforce’s official Apex Developer Guide.

Understanding Virtual Classes and Inheritance in Apex:

Virtual Class: In Apex, a virtual class allows other classes to extend it and inherit its methods and properties. It can also define methods that can be overridden by subclasses. The Apex Developer Guide states: “A virtual class can be extended by another class, allowing the subclass to inherit its methods and properties, and override virtual methods if needed” (Salesforce Apex Developer Guide, Classes).

Inheritance: Apex supports single inheritance using the extends keyword, where a subclass inherits from a single parent class. The Apex Developer Guide notes: “Use the extends keyword to create a subclass that inherits from a parent class” (Salesforce Apex Developer Guide, Inheritance).

Virtual vs. Interface:

A virtual class can contain method implementations and is extended using extends.

An interface defines method signatures without implementations and is implemented using implements. The question specifies OrderRequest as a virtual class, not an interface.

Requirement: The CustomerOrder class needs to use OrderRequest, which likely means inheriting its functionality, as OrderRequest is a virtual class.

Evaluating the Options:

A. extends (class="OrderRequest")public class CustomerOrder

Syntax: This option attempts to use extends followed by (class="OrderRequest") and then public class CustomerOrder.

Analysis: The syntax is incorrect. In Apex, the extends keyword is followed directly by the name of the class to extend, with no parentheses or class= notation. The correct syntax would be public class CustomerOrder extends OrderRequest. The Apex Developer Guide specifies: “The extends keyword is followed by the name of the parent class, without additional attributes or parentheses” (Salesforce Apex Developer Guide, Inheritance). The (class="OrderRequest") syntax resembles annotations or markup, but it’s not valid in Apex for inheritance.

Conclusion: Incorrect due to invalid syntax.

B. public class CustomerOrder implements Order

Syntax: Uses the implements keyword to implement an interface named Order.

Analysis: The implements keyword is used to implement an interface, not to extend a class. The question states that OrderRequest is a virtual class, not an interface, so implements is inappropriate. Additionally, the option references Order, not OrderRequest, which appears to be a mismatch with the class name provided in the question. The Apex Developer Guide clarifies: “The implements keyword is used for interfaces, while extends is used for classes, including virtual classes” (Salesforce Apex Developer Guide, Interfaces). Even if Order were intended to be OrderRequest, implements would still be incorrect for a virtual class.

Conclusion: Incorrect, as implements is for interfaces, not virtual classes, and Order does not match OrderRequest.

C. public class CustomerOrder extends OrderRequest

Syntax: Declares CustomerOrder as a subclass of OrderRequest using the extends keyword.

Analysis: This is the correct syntax for inheritance in Apex. Since OrderRequest is a virtual class, CustomerOrder can extend it to inherit its methods and properties. The extends keyword allows CustomerOrder to use (inherit) the functionality of OrderRequest. The Apex Developer Guide confirms: “A class can extend a virtual class using the extends keyword, inheriting its methods and properties” (Salesforce Apex Developer Guide, Inheritance). This matches the question’s intent of “using” OrderRequest within CustomerOrder, which typically means inheritance when dealing with a virtual class.

Conclusion: Correct, as it uses the proper extends keyword to inherit from the virtual OrderRequest class.

D. @Implements (class="OrderRequest")public class CustomerOrder

Syntax: Uses an @Implements annotation with (class="OrderRequest") before the class declaration.

Analysis: Apex does not have an @Implements annotation. The implements keyword (without @) is used for interfaces, and annotations in Apex (e.g., @AuraEnabled, @TestVisible) do not use this format for inheritance or interface implementation. The Apex Developer Guide does not define @Implements as a valid annotation (Salesforce Apex Developer Guide, Annotations). The correct way to extend a virtual class is with extends, as in option C.

Conclusion: Incorrect due to invalid syntax (@Implements is not a valid Apex annotation).

Why Option C is Correct:

Option C is correct because:

It uses the extends keyword to properly declare CustomerOrder as a subclass of OrderRequest, which is a virtual class.

This allows CustomerOrder to inherit and use the methods and properties defined in OrderRequest, fulfilling the requirement to “use” the OrderRequest class within CustomerOrder.

The syntax aligns with Apex best practices for inheritance as outlined in the Salesforce Apex Developer Guide.

Example for Clarity:

Here’s how the correct implementation (option C) would look:

apex

Copy

public virtual class OrderRequest {

public String getOrderDetails() {

return 'Order Details';

}

}

public class CustomerOrder extends OrderRequest {

public String getCustomerOrderInfo() {

// Inherit and use OrderRequest's method

String orderDetails = getOrderDetails();

return 'Customer Order: ' + orderDetails;

}

}

CustomerOrder extends OrderRequest, inheriting getOrderDetails().

The developer can use OrderRequest’s functionality (e.g., call its methods) within CustomerOrder.

Handling Typos:

The question’s code snippet and options are mostly clear, but option B references Order instead of OrderRequest, which appears to be a typo. The analysis assumes the intended class is OrderRequest, as stated in the question stem.

Option D has a typo in the class name: Customerorder should be CustomerOrder (capital O). This does not affect the analysis, as the syntax error (@Implements) is the primary issue.

Why Usefinal?

Thefinalkeyword ensures that a variable's value can only be assigned once.

Option B: Assigning the value in the constructor is valid as it allows for flexibility when creating class instances.

Option C: Assigning the value directly when declaring the variable is also valid for constants.

Why Not Other Options?

A: Static variables can have their values reassigned unless marked as final.

D: Static variables cannot be assigned within a class constructor.

Option A: Using variable binding eliminates the need for concatenating dynamic values in the query, which is the safest approach.

Option B: UsingString.escapeSingleQuotesensures special characters are handled safely, reducing the risk of SOQL injection.

Not Suitable:

Option C: Whilewith sharingensures sharing rules are applied, it does not prevent SOQL injection.

Option D: Regular expressions are not a reliable method for sanitizing input.

Preventing SOQL Injection