Explanation:
In AL, extensibility is designed for specific object types to allow adding functionality without altering the base application's source code. The principle is to enable safe, upgradable customizations.

A. Codeunit:
YES. You can create a codeunit extension to add new procedures, global variables, and triggers to an existing codeunit. This is fundamental for injecting custom business logic into existing processes.

E. Enum:
YES. You can create an enum extension to add new members (values) to an existing enumeration. This is a common and critical practice for adding new options without breaking existing logic that depends on the original enum values.

Why the Other Options Are Incorrect:
B. Report:
NO. Reports are not extended using a simple extend keyword. Instead, you create a report extension object, which is a separate artifact. This allows for adding new controls or modifying certain properties but is a different, more limited mechanism than the core extension types.

C. Query:
NO. Query objects are not extensible. To modify a query's data structure or sources, you must create an entirely new query object. There is no concept of a query extension.

D. API Page:
NO. API pages are a specialized type of page object optimized for OData and API endpoints. They are locked down for consistency in web services and cannot be extended. You must create a new API page to expose additional data.

Reference:
Microsoft Learn Documentation: "Extending Application Objects"

This core documentation explicitly details the process for creating Table Extensions, Page Extensions, Codeunit Extensions, and Enum Extensions. The absence of Query, Report, and API Page from this list confirms they are not directly extensible in the same manner. Report extensions are covered under a separate "Report Extension Object" topic, which is a distinct concept.

Explanation:

✅ Correct Debugging Steps (in order):
Locate the report extension in Visual Studio Code Open your workspace and find Ext Standard Sales - Invoice (ID = 50100). This is where the custom logic resides.

Search where NewTotalVATBaseLCY is assigned and set a breakpoint Find the assignment line inside the OnAfterGetRecord() trigger and set a breakpoint to inspect runtime values.

Start the debug session Launch the Business Central debugger from Visual Studio Code to begin tracking execution.

Use the step-over functionality Step over the GetTotalVATBaseLCY(...) call to inspect the returned value and verify input parameters.

🔍 Why this sequence works:
It isolates the extension logic first.
It targets the exact assignment line for inspection.
It avoids stepping into unnecessary base code unless needed.
It allows you to validate whether incorrect values stem from parameter issues or the GetTotalVATBaseLCY function itself.

📚 Reference:

Debugging AL Code in Business Central
Report Extensions Overview

Explanation:
To save user-entered values on a report's Request Page so they are pre-populated the next time the report is run, you must use the SaveValues property.

D. Set the SaveValues property to true:
This is the direct and correct solution. When you set the SaveValues property to true on the report object, the system automatically persists the values a user enters in the filters and controls on the Request Page. These values are stored in the Report Settings table and are automatically restored the next time the same user opens the report.

Why the Other Options Are Incorrect:
A. Set the Transact-SQL on Type property to Update:
This property does not exist for Report objects in AL. It is not relevant to saving Request Page values.

B. Declare a SaveValues variable and assign it to true on the OnOpenPage() trigger:
The SaveValues functionality is a built-in property of the report runtime engine, not a variable that can be controlled by AL code. Manually declaring a variable named SaveValues will have no effect.

C. Set the Use Request Page property to true:
This property determines whether a Request Page is shown to the user at all. It must be set to true to have a Request Page, but it does not control whether the values on that page are saved between sessions.

Reference:

Microsoft Learn Documentation: Report Properties

You can find the official documentation by searching for "Report Object" in the AL Language reference. The SaveValues property is specifically described with its purpose: "Determines whether the user's input on the request page is saved for the next time the report is run."

Explanation:
Business Central application layers define where objects reside and who can modify them. The Base layer contains Microsoft-delivered objects that are protected and cannot be directly modified. The System layer contains system tables and core application objects. The Customer/Extension layer (represented by the empty bracket) is where developers create modifications and extensions without altering base objects.

Correct Option:

Language table – System layer
Language table is a system table that stores language codes and is part of the System application layer. It is not intended for customer modification and is maintained by Microsoft. It is available across all countries and used for multilanguage functionality.

Activities Cue table – System layer
Activities Cue tables are part of the Role Center framework and stored in the System layer. These tables store user-specific activity counts and cues. They are system-managed and should not be modified directly in the Base layer.

Extension Management codeunit – System layer
Extension Management codeunit handles extension lifecycle operations such as install, uninstall, and update. It is a system codeunit in the System layer. It manages extensions but is not itself part of the extension layer.

Business Unit Card page – Base layer
Business Unit Card page is a standard page in the Base application layer. It is delivered by Microsoft and part of the core finance module. Extensions should use page extension objects to modify it instead of altering the base object.

Incorrect Options:

Language table – Base layer –
Language table is not in the Base layer; it is a system table. Base layer contains business objects like sales documents, items, and journals. Language table is cross-functional system data.

Activities Cue table – Base layer –
This is incorrect. Activities Cue tables are part of the System application layer, not the Base layer. Base layer does not contain user-specific cue tracking tables.

Extension Management codeunit – Base layer –
This is incorrect. The Extension Management codeunit is in the System layer, not the Base layer. Base layer does not manage extension installation logic.

Business Unit Card page – System layer –
This is incorrect. Business Unit Card is a standard business page in the Base layer. System layer contains tables like Permission, User, and Access Control, not business entity cards.

Reference:
Application Layers in Business Central

Explanation:
When developing an app for Microsoft AppSource in Business Central, specific code analyzers must be enabled to ensure compliance with Microsoft’s validation and certification requirements. These analyzers enforce best practices, UI guidelines, and technical rules that are mandatory for AppSource submission. Three specific analyzers are required for this purpose.

Correct Options:

B. UICop –
UICop enforces rules related to the user interface, such as page controls, actions, and patterns. It ensures that the extension's UI components follow Microsoft's design guidelines and do not break existing UI behavior. This is mandatory for AppSource apps to provide a consistent and accessible user experience.

D. PerTenantExtensionCop –
PerTenantExtensionCop validates that the extension is compatible with per-tenant deployment scenarios. It checks for issues like missing tooltips, breaking changes, and proper use of events. While primarily for per-tenant extensions, many of its rules are also relevant and enforced for AppSource apps.

E. AppSourceCop –
AppSourceCop is the primary analyzer for AppSource submissions. It enforces technical and commercial validation rules specific to the AppSource ecosystem. It checks for breaking changes, proper object naming, affix requirements, and other criteria required for Microsoft certification and listing.

Incorrect Options:

A. CodeCop –
CodeCop enforces general AL coding best practices such as variable naming, code complexity, and performance. While highly recommended, it is not a mandatory requirement for AppSource submission. Developers should still use it to maintain code quality.

C. a custom rule set –
Custom rule sets are not required or recognized for AppSource certification. Microsoft requires the use of their official, predefined analyzers. Custom rules cannot replace the mandatory validation performed by UICop, AppSourceCop, and PerTenantExtensionCop.

Reference:
Code Analysis for AL

Explanation:
For Business Central apps published to Microsoft AppSource, object IDs must be assigned from a specific licensed range to avoid conflicts with other apps and Microsoft objects. Developers cannot use free or custom ranges arbitrarily. Microsoft requires a dedicated range that is requested and assigned per app to ensure global uniqueness and compliance.

Correct Option:

D. an object range within the range of 7000000 to 74999999 that is requested from Microsoft
Apps published to AppSource must use object IDs in the range 7,000,000 to 74,999,999. This range is reserved exclusively for AppSource apps. Developers must submit a request to Microsoft to obtain a unique, assigned range for their solution. This prevents ID collisions across different apps and ensures certification compliance.

Incorrect Options:

A. custom object within the range 50000 to 59999 –
This range is reserved for per-tenant customizations and development sandboxes. It is not allowed for AppSource apps because it is not globally unique and can cause conflicts when multiple apps are installed.

B. custom object within the range 50000 to 99999 –
The 50000–99999 range is designated for customer-specific and per-tenant extensions. AppSource apps cannot use this range. Microsoft certification requires objects to be in the licensed 7,000,000+ range.

C. divided by countries and use specific a country within the range 100000 to 999999 –
The 100,000–999,999 range is reserved for Microsoft's country/region-specific localization and regulatory features. It is not available for AppSource apps or partner extensions.

E. free object within the standard range 1 to 49999 –
The 1–49,999 range is reserved for Microsoft's base application objects. Partners cannot create objects in this range. Extensions must never modify or create objects in this protected range.

Reference:
Microsoft Learn:Object Ranges in Business Central

Explanation:
This question tests your understanding of interface implementation rules in AL for Business Central. When a codeunit implements an interface, it must implement all methods defined in that interface with exact signatures. Additional methods are allowed, but the implemented methods must match the interface definition precisely.

Correct Option:

Codeunit "Discount Mgmt." compiles successfully. – No
The codeunit will NOT compile successfully. The method signature for GetDiscount() in the implementation (line 20) includes an extra parameter name "DiscountAmount" after the return type. The correct syntax should be procedure GetDiscount(): Decimal. Additionally, the parameter name in GetLine() is "VariantLine" but the interface expects "Line". While parameter names are not required to match, the syntax error in GetDiscount() will cause compilation failure.

Incorrect Options:

VariantLine in line 17 must be changed to Line and the DiscountAmount removed for the codeunit to compile. – Yes
This statement is partially accurate. The VariantLine parameter name does not need to match the interface name; parameter names are not validated for equality. However, the DiscountAmount after the return type in line 20 is invalid syntax and must be removed. The statement correctly identifies the DiscountAmount issue, though the parameter name requirement is technically incorrect.

The DiscountIsValid method must be defined in the interface for the code to compile. – No
This statement is false. A codeunit implementing an interface may contain additional methods beyond those defined in the interface. The DiscountIsValid method is an extra method not defined in the interface, and this is perfectly valid. Only the methods defined in the interface must be implemented; additional methods are optional and allowed.

Reference:
Microsoft Learn: Interfaces in AL

Explanation:
In Business Central, a wizard that guides users through a sequence of steps to complete a task is implemented using a NavigatePage. This page type is specifically designed for assisted setup wizards and guided task flows, providing a step-by-step interface with navigation controls like Next, Back, and Finish.

Correct Option:

A. NavigatePage –
NavigatePage is the correct page type for creating wizards and assisted setup experiences in Business Central. It provides a structured layout with instructional text, step indicators, and navigation buttons. This page type is optimized for infrequent, procedure-driven tasks where users need guidance through a defined sequence of steps.

Incorrect Options:

B. Card –
A Card page is used to view and edit a single record, such as a customer or item. It is not designed for multi-step wizard workflows. Card pages lack the built-in step navigation and instructional framework required for guided procedures.

C. RoleCenter –
A RoleCenter page serves as a personalized dashboard for a specific user role. It displays KPIs, charts, and activity tiles. It is not intended for step-by-step task completion wizards and cannot provide sequential guided navigation.

D. List –
A List page displays multiple records in a tabular format for viewing and selection. It is used for browsing, filtering, and opening individual records. List pages do not support the wizard-style, step-by-step interaction pattern.

Reference:
Microsoft Learn: Page Types in Business Central

Explanation:
The error occurs because the user lacks read permissions on the Logistics Setup table. The procedure GetLogisticsCharge reads the Logistics Charge field from this table. To resolve this without assigning full table permissions, the InherentPermissions attribute can grant specific permissions to the method. The correct attribute must specify TableData, read permission ('r'), and the appropriate scope.

Correct Option:

Configure [InherentPermissions(PermissionObjectType::TableData, Database::"Logistics Setup", 'r', InherentPermissionsScope::Both)] above line 15. – Yes
This statement is correct. InherentPermissions grants the specified permissions to the method without requiring explicit user assignment.

PermissionObjectType::TableData targets data permissions, and 'r' grants read access, which is exactly what this method needs. InherentPermissionsScope::Both applies the permission to both current and future versions, ensuring long-term compatibility.

Incorrect Options:

Configure [InherentPermissions(PermissionObjectType::Table, Database::"Logistics Setup", 'x', InherentPermissionsScope::Both)] above line 15.– No
This statement is incorrect. PermissionObjectType::Table is used for table metadata permissions, not data access. Additionally, 'x' represents execute permission, which is not applicable to tables and does not grant read access to table data. This would not resolve the permission error.

Configure [InherentPermissions(PermissionObjectType::Table, Database::"Logistics Setup", 'x', InherentPermissionsScope::Permissions)] above line 15.– No
This statement is incorrect for multiple reasons. First, Table instead of TableData targets metadata, not data. Second, 'x' does not grant read access. Third, InherentPermissionsScope::Permissions only applies to the permission set itself, not the object, making it insufficient for granting runtime access to table data.

Reference:
Microsoft Learn: InherentPermissions Attribute

Explanation:
To test the sales order posting process in Business Central, you need to control the Post dialog options programmatically and validate the results. The Library – Sales codeunit provides methods to handle posting dialogs and retrieve posted documents. SetPostingOption sets the dialog selection to Invoice. GetPostedSalesInvoiceHeader retrieves the posted invoice for validation. Assert methods verify expected values and results.

Correct Option:

Specify the value of the post options (dialog: Ship, Invoice, Ship & Invoice) as Invoice – SetPostingOption
The SetPostingOption method from the Library – Sales codeunit allows the test to programmatically select the posting option (Ship, Invoice, or Ship & Invoice) without user interaction. Setting this to Invoice ensures the test runs unattended and consistently posts only the invoice portion of the sales order.

Perform calculations and values checking – Assert methods and GetPostedSalesInvoiceHeader
To perform calculations and value checking, the test must retrieve the posted document using GetPostedSalesInvoiceHeader from the Library – Sales codeunit. Once retrieved, Assert methods (such as Assert.AreEqual, Assert.IsTrue) are used to validate field values, totals, VAT, and other calculated amounts against expected results.

Incorrect Options:

Handler methods –
Handler methods (such as ModalPageHandler, MessageHandler) are used to handle UI interactions and confirmations during test execution. While useful for dismissing dialogs, they are not required here because SetPostingOption eliminates the dialog entirely. They do not perform posting or validation.

Normal Test methods –
Normal test methods execute the test logic itself but do not specifically control the posting option or retrieve posted documents. They would call SetPostingOption and validation methods but are not the direct answer to the two implementation requirements listed.

Reference:
Microsoft Learn: Testing the Application with Test Codeunits