* Validation Rule (A):A validation rule can restrict the modification of Opportunity records when the stage is set to Closed/Won. This ensures data consistency without requiring code.

* A. Junction object between Applicant and Job:
* Since an Applicant can apply for multiple Jobs and each Job can have multiple Applicants, this is a many-to-many relationship.
* Salesforce requires a junction object to represent many-to-many relationships. The junction object will have two master-detail relationships: one to the Applicant object and one to the Job object.
* The junction object could be named something like JobApplication__c, which would represent the specific instance of an applicant applying for a particular job.
* Why this is the correct approach?
* A junction object allows for robust data management and reporting capabilities in a many-to- many relationship.
* This design ensures that each combination of applicant and job is captured as a unique record in the JobApplication__c junction object.
* It also allows storing additional details about the application, such as application date, status, and feedback.
Why not the other options?
* B. Lookup field from Applicant to Job:
* A lookup field creates a one-to-many relationship. While an Applicant could reference one Job, it does not support the many-to-many relationship required in this scenario.
* C. Master-detail field from Applicant to Job:
* A master-detail relationship is a one-to-many relationship, which is unsuitable for a many-to- many relationship. Additionally, you cannot have two master-detail fields on a single object to connect Applicant and Job directly.
* D. Formula field on Applicant that references Job:
* A formula field cannot establish relationships between records or represent a many-to-many relationship. It is only for computed fields.
References:
* Creating Many-to-Many Relationships with Junction Objects
* Master-Detail and Lookup Relationship Details

* Trigger.old in a before insert trigger:
* The Trigger.old context variable contains the old version of the records being processed in the trigger.
* In a before insert trigger, the records being processed are new and have no prior state in the database, so Trigger.old is null.
* This behavior is specific to insert triggers because there is no "old" record to reference before the record is created.
* Why is it null?
* The Trigger.old variable is only populated for triggers that handle updates or deletions (e.g., before update, after update, before delete, after delete). For insert operations, no previous state of the record exists.
* Why not the other options?
* A. An empty list of sObjects:
* This is incorrect because Trigger.old is not initialized as an empty list for insert triggers-it is simply null.
* B. Undefined:
* Trigger.old is defined in the trigger context, but it is null for insert operations. Undefined is not a valid Apex state.
* D. A list of newly created sObjects without IDs:
* This describes Trigger.new in a before insert trigger, not Trigger.old. Trigger.new contains the new records being inserted.
References:
* Apex Triggers Documentation
* Trigger Context Variables

* Roll-Up Summary Field:
* Since the relationship between Order and Order Line Item is a Master-Detail, a Roll-Up Summary field can be used on the Order object.
* The MAX function in a Roll-Up Summary field calculates the latest date (the maximum value) among all the availability dates on the Order Line Items.
* Why MAX Roll-Up Summary Field Works:
* The latest availability date among the Order Line Items will determine when the entire Order can be shipped.
* Why Not Other Options?
* A and B: There is no such formula called "LATEST" or "CEILING" applicable to date fields.
* C: A COUNT Roll-Up Summary is irrelevant for calculating dates.
* Roll-Up Summary Fields: https://developer.salesforce.com/docs/atlas.en-us.object_reference.meta
/object_reference/roll_up_summary_fields.htm
References:

* Option A: Using a Test Data Factory class is a recommended approach to create test records programmatically. This ensures that the test is independent of existing data and can be executed in isolation.
* Option B: The @IsTest(SeeAllData=true) annotation allows the test to access existing records in the database, including Pricing_Structure__c. However, this is less recommended as it creates a dependency on existing org data.
* Not Suitable:
* Option C: Test.loadData is used to load records from a static resource (CSV) but doesn't suit the requirement directly.
* Option D: Adding without sharing to a class impacts sharing rules but does not create or ensure the existence of test data.