The function:
async function functionUnderTest(isOK) {
if (isOK) return ' OK ' ;
throw new Error( ' not OK ' );
}
Behavior:
* If isOK is true:
* The function resolves (fulfills the promise) with value ' OK ' .
* If isOK is false:
* The function throws, which in an async function becomes a rejected promise with Error( ' not OK ' ).
We want an assertion that accurately tests the successful path for isOK === true.
Key points about console.assert:
* Signature: console.assert(condition, message?)
* If condition is falsy , it logs message as an assertion failure.
* If condition is truthy , nothing is logged.
We also must understand await:
* await functionUnderTest(true) will resolve to the string ' OK ' .
Now evaluate options.
Option A:
console.assert(await functionUnderTest(true), ' OK ' );
* await functionUnderTest(true) # ' OK ' (truthy).
* console.assert( ' OK ' , ' OK ' );
* Condition is ' OK ' (truthy), so assertion passes.
* The message ' OK ' is only shown if the condition is falsy, which it is not.
This correctly verifies that the promise resolved (i.e., did not reject). Among the given options, this is the only one that both:
* Uses await properly on the async function, and
* Associates the message with the expected success " OK " .
Option B:
console.assert(await (functionUnderTest(true), ' not OK ' ));
* Inside the parentheses, the comma operator (a, b) evaluates a, discards it, and returns b.
* So (functionUnderTest(true), ' not OK ' ):
* Calls functionUnderTest(true) (returns a promise, but its result is discarded),
* The expression evaluates to the string ' not OK ' .
* Then await ' not OK ' just resolves to ' not OK ' immediately (not a promise).
* console.assert( ' not OK ' );
* Condition is ' not OK ' (truthy), so the assertion passes regardless of what functionUnderTest actually does.
* This does not meaningfully test the function and is misleading.
Option C:
console.assert(functionUnderTest(true), ' OK ' );
* functionUnderTest(true) returns a Promise , not the string ' OK ' directly.
* A Promise object is always truthy.
* So console.assert(promise, ' OK ' ) will pass, even if the promise later rejects.
* Also, there is no await, so we are not actually waiting for the async result.
* This is not a correct way to assert on an async function's resolved value.
Option D:
console.assert(await functionUnderTest(true), ' not OK ' );
* await functionUnderTest(true) still resolves to ' OK ' (truthy).
* console.assert( ' OK ' , ' not OK ' ); passes.
* However, the message ' not OK ' is the opposite of what we expect for the success case and is only used when the condition fails.
* This makes the assertion logically inconsistent with the function behavior (it would show " not OK " if the assertion failed).
Therefore, the only assertion that:
* Properly waits on the async function, and
* Has expectation text that matches the successful behavior ( ' OK ' )
is:
The answer: A
Study Guide / Concept References (no links):
* async and await behavior in JavaScript
* Promises resolving vs rejecting in async functions
* console.assert(condition, message) usage
* Truthy and falsy values in JavaScript
* Comma operator (a, b) semantics

The correct answers are B, C, D, and E .
JavaScript browser consoles support string substitution in several console output methods. String substitution means using placeholders such as:
%s
%d
%i
%f
%o
%O
%c
Example:
console.log( " User name is %s and age is %d " , " Alex " , 25);
Output:
User name is Alex and age is 25
The valid console methods from the given options are:
Option
Method
Correct?
Reason
A
message
No
console.message() is not a standard console method.
B
log
Yes
console.log() supports formatted string substitution.
C
assert
Yes
console.assert() can output a formatted message when the assertion is false.
D
info
Yes
console.info() supports formatted output like console.log().
E
error
Yes
console.error() supports formatted output and displays an error-style message.
Example with these valid methods:
console.log( " Name: %s " , " John " );
console.info( " Score: %d " , 95);
console.error( " Error code: %d " , 500);
console.assert(false, " Failed check for user: %s " , " Admin " );
So the verified answers are B, C, D, and E .

The correct answer is C .
The browser provides the History API through:
window.history
To add a new entry to the browser's session history without refreshing the page, JavaScript uses:
window.history.pushState(state, title, url);
So the valid statement is:
window.history.pushState(newStateObject, ' ' , null);
This updates the browser history stack without forcing a full page reload. It is commonly used in single-page applications when changing views or routes dynamically.
The method accepts three arguments:
window.history.pushState(stateObject, title, url);
stateObject stores custom data associated with the history entry.
title is usually passed as an empty string because many browsers ignore it.
url optionally changes the displayed URL. Passing null means no new URL is provided.
Option A is incorrect because:
window.customHistory
is not the standard browser History API object.
Option B is incorrect because:
createState()
is not a valid History API method.
Option D is incorrect because:
updateState()
is not a valid History API method.
The correct browser API method is:
window.history.pushState()
Therefore, the verified answer is C .

In JavaScript, ES modules (files imported using import / export) have special semantics:
* All code inside a module is automatically executed in strict mode .
* This is specified by the ECMAScript standard and does not require the explicit " use strict " ; directive.
Effects:
* You do not need to write " use strict " ; at the top of a module file.
* You cannot turn strict mode off for module code.
* All module top-level code is treated as strict.
Now evaluate each option:
Option A:
Add the statement use non-strict; before any other statements in the module to enable notstrict mode.
* There is no use non-strict; directive in JavaScript.
* The only directive recognized by engines is " use strict " ;.
* You cannot explicitly enable a "non-strict" mode with such a string.
Option B:
Imported modules are in strict mode whether you declare them as such or not.
* This matches the language specification.
* ES modules are always in strict mode, automatically.
* This is true.
Option C:
Add the statement use strict = false; before any other statements in the module to enable notstrict mode.
* use strict = false; is not a directive; it is parsed as a normal expression, and does not affect strict mode.
* There is no supported way to disable strict mode in modules.
Option D:
A developer can only reference notStrict() functions from the imported module.
* There is no special notStrict() restriction in modules.
* Functions exported/imported in modules are simply subject to strict mode rules like the rest of the module's code.
Therefore, the only correct statement is:
The answer: B
Study Guide / Concept References (no links):
* ES modules (import / export)
* Automatic strict mode in modules
* " use strict " ; directive for scripts vs modules
* Inability to disable strict mode in ES module code

Comprehensive and Detailed Explanation:
Evaluate step by step:
* ' 15 ' + 10
* + with a string operand performs string concatenation.
* 10 is coerced to ' 10 ' .
* Result: ' 1510 ' .
* ' 1510 ' * 2
* * always performs numeric multiplication.
* ' 1510 ' is converted to the number 1510.
* 1510 * 2 = 3020.
So x is 3020.