Comprehensive and Detailed Explanation:
The lightning-layout grid system uses a 12-column model. To achieve a responsive design, developers use attributes that target different screen breakpoints.
* size: Defines the default size (usually targeting the smallest devices if no other attributes are present).
* medium-device-size: Targets tablets and small desktops.
* large-device-size: Targets large monitors.
To show one column on a phone, an item must occupy all 12 columns (size="12"). To show two columns on a tablet/desktop, each item must occupy 6 columns (medium-device-size="6").
Option A correctly implements this. While small-device-size exists, the size attribute itself typically serves as the baseline for small devices. If you set size="12" and medium-device-size="6", the component will "stack" on phones and sit side-by-side on anything larger.

To expose an Apex method to a Lightning Web Component (LWC) and specifically use the @wire service, the method must meet two strict criteria: it must be public or global, and it must be annotated with
@AuraEnabled(cacheable=true).
In the provided snippet, line 04 defines the method as static but lacks an access modifier. In Apex, the default access modifier is private, which prevents the LWC framework from accessing the method. Changing line 04 to public static List<Contact> (Option A) makes the method visible to the component.
Additionally, the @wire service requires the method to be "cacheable" to optimize performance by storing results on the client-side. This is achieved by adding the @AuraEnabled(cacheable=true) annotation. Placing this on line 03 (Option D) ensures the method is registered with the Lightning Data Service as an invokable, cacheable action. Modifying line 08 (Option B) is incorrect because that is a private helper method that the component does not call directly. By making the primary method public and cacheable, the LWC can successfully bind its property to the data returned by the Apex controller.

123
To properly test a Visualforce Controller Extension in Apex, the developer must replicate the instantiation process used by the Lightning Platform at runtime. A4 controller extension is a class whose constructor is specifically defined to accept a single parameter of the type ApexPages.StandardController. 5The standard controller acts as the bridge b6etween the custom extension logic and the underlying Salesforce record (in this case, an Account).
In the provided test method, a record acet has been inserted into the database. To create the extension object, the developer must first instantiate the StandardController by passing the acet SObject record into its constructor. Once the standard controller instance (e.g., sc) is created, it is then passed into the constructor of the AccountControllerExt class. Option B is the correct implementation of this two-step pattern. Option C is incorrect because the StandardController constructor requires a full SObject record, not just an ID string.
Options A and D are incorrect because extension classes do not support constructors that take an SObject or an ID directly; they specifically require the StandardController object to provide the necessary context for standard actions and fields. Following the correct pattern ensures the test accurately simulates the page execution context.

For high-volume data processing (such as seeding 100,000 records) involving complex logic, Batch Apex (Option A) is the standard and most robust solution. Batch Apex is designed to handle up to 50 million records by breaking the total set into smaller, manageable chunks (defaulting to 200 records per batch).
Each batch execution gets its own set of governor limits. This is crucial for "complex logic," as it prevents the transaction from hitting CPU time or heap size limits that would occur if one tried to process all 100,000 records in a single synchronous transaction. Batch Apex also provides built-in state management and error handling (via Database.RaisesPlatformEvents or the finish method).
Option B (Queueable) is better suited for smaller, chained tasks; while it can handle some volume, it is not optimized for 100,000 records in the same way the QueryLocator in Batch Apex is. Option C is a syntactical impossibility as executeBatch only accepts Batchable classes. Option D (Schedulable) is used for timing, but the actual heavy lifting for 100,000 records would still need to be handed off to a Batch class to avoid timeout errors. Therefore, Database.Batchable is the optimal tool for large-scale data seeding.

The most effective way to optimize test performance when multiple test methods require the same set of records is to use the @testSetup annotation (Option C).
When a method is marked with @testSetup, Salesforce executes it exactly once before any test methods in the class run. The platform then creates a "database snapshot" of those records. For every individual test method in the class, Salesforce simply rolls back the database to that snapshot rather than re-executing the DML operations required to create the records. This dramatically reduces the total number of DML statements and CPU time consumed during the test run.
In contrast, calling a TestDataFactory (Option D) from within every test method results in the same records being inserted and deleted repeatedly for every test case. If a class has 50 test methods, the records are created
50 times. With @testSetup, they are created once. Option A is not possible (you cannot programmatically disable these during a test run), and Option B is incorrect as test classes do not use constructors in this manner. Using @testSetup is the platform-recommended pattern for efficient, high-performance unit testing.