Карта знаний PHP — ornith-1.5:35b, run-20 · think: off

{"answer": "no", "explanation": "This is false because double-quoted strings support variable interpolation and escape sequences while single-quoted strings are treated almost literally, so they are processed differently (not just at different speeds)."}

{"answer": "yes", "explanation": "The ?? (null coalescing) operator follows isset semantics and suppresses warnings for undefined variables, so accessing $a['missing'] ?? 'default' raises no notice."}

{"answer": "ab", "explanation": "The echo statement uses commas to concatenate multiple strings, so 'a' and 'b' are output together as 'ab'."}

{"answer": "false", "explanation": "print returns the value 1, but it cannot be used inside an expression because it behaves more like a statement than a function and cannot be called with parentheses in certain contexts."}

{"answer": "false", "explanation": "The ?: (elvis) operator returns its left operand when it is truthy, not when it is falsy; when the left operand is falsy, it returns the right operand."}

{"answer": "true", "explanation": "In PHP, the concatenation operator (.) has lower precedence than addition and subtraction, so expressions like 'a' . 1 + 2 evaluate as 'a' . (1 + 2) resulting in 'a3'."}

{"answer": "no", "explanation": "The ** operator in PHP is right-associative, so 2 ** 3 ** 2 evaluates as 2 ** (3 ** 2), which equals 2 ** 9 = 512, not (2 ** 3) ** 2 = 64."}

{"answer": "5", "explanation": "The dot operator has higher precedence than plus, so 'sum: ' . 2 evaluates to the string 'sum: 2', which then converts to 0 for the addition, giving 0 + 3 = 5."}

```json ⏎ { ⏎  "answer": "false", ⏎  "explanation": "With strict comparison (===), two arrays are only equal if they have the same key/value pairs in the same order and of the same types, so element order matters." ⏎ } ⏎ ```

{"answer": "no", "explanation": "The comparison 0 == false actually returns true because == is a loose (non-strict) comparison, not a strict one."}

{"answer": "yes", "explanation": "In PHP, non-numeric strings compared numerically with == are converted to 0, and since 0 == 0 is true, the expression evaluates to true."}

{"answer": "yes", "explanation": "Under PHP's loose comparison, null is loosely equal to 0, the empty string, and false simultaneously (e.g., null == 0, null == \"\", and null == false all evaluate to true)."}

{"answer": 42, "explanation": "In PHP, casting a string to int performs a left-to-right conversion, stopping at the first non-numeric character, so '42abc' becomes 42."}

{"answer": "10", "explanation": "In PHP, when a string that looks like a number is used in an arithmetic operation, it is coerced to a numeric value, so '5' + 5 evaluates to the integer 10."}

{"answer": "false", "explanation": "When cast to string, false becomes an empty string \"\", not \"0\" (the integer 0 becomes \"0\" when cast to string)."}

{"answer": "yes", "explanation": "0.1 + 0.2 does not equal 0.3 when using strict comparison due to floating-point precision representation errors in PHP."}

{"answer": "no", "explanation": "strrev() operates byte-by-byte and does not support multi-byte UTF-8 characters, so it corrupts them."}

{"answer": "yes", "explanation": "str_contains() checks if a string contains a substring and returns a boolean true when the substring is found."}

```json ⏎ {"answer": "no", "explanation": "str_pad() can pad a string on the left, right, or both sides depending on the padding_type parameter (STR_PAD_LEFT, STR_PAD_RIGHT, or STR_PAD_BOTH)."} ⏎ ```

{"answer": "no", "explanation": "By default, trim() removes not only spaces but also tabs, newlines, carriage returns, null bytes, and other default whitespace characters, not just spaces."}

{"answer": "6", "explanation": "strlen() counts bytes, and 'héllo' contains 5 characters where 'é' is encoded as 2 bytes in UTF-8, giving 1+2+1+1+1=6 bytes."}

{"answer": "cde", "explanation": "A negative offset in substr() counts from the end of the string, so -3 means starting at 'c' and returning to the end."}

```json ⏎ {"answer": "no", "explanation": "ucfirst() returns a new modified string and does not modify the original string in place since strings in PHP are immutable."} ⏎ ```

{"answer": "yes", "explanation": "Heredoc syntax interpolates variables like double-quoted strings, while nowdoc (introduced in PHP 7) uses single-quote-like syntax that prevents variable interpolation."}

{"answer": "no", "explanation": "The sort() function reindexes the array with numeric keys starting from 0, destroying the original key-to-value associations."}

{"answer": "yes", "explanation": "In PHP, string keys that consist entirely of digits are automatically converted to integers when used as array keys."}

```json ⏎ {"answer": "no", "explanation": "The in_array() function uses loose comparison by default; the strict comparison operator (===) is only used when the optional strict parameter is set to true."} ⏎ ```

{"answer": "yes", "explanation": "Without a callback, array_filter() removes all falsy elements (false, 0, \"\", null, etc.) from the array."}

{"answer": "no", "explanation": "array_slice() resets numeric keys by default, so it does not preserve the original numeric keys unless you pass true as the fourth argument."}

{"answer": "[20, 30]", "explanation": "array_slice extracts 2 elements starting at offset 1 from the array, giving [20, 30]."}

{"answer": "2", "explanation": "The union operator (+) combines arrays keeping the left-hand side's values for duplicate keys, resulting in ['a' => 1, 'b' => 2]."}

{"answer": "false", "explanation": "The spread operator supports associative/string-keyed arrays since PHP 7.1 (the feature was introduced in 7.1), not PHP 8.1."}

{"answer": "no", "explanation": "False; named arguments can be combined with argument unpacking in PHP 8.1+, where unpacked arrays with string keys become named arguments."}

{"answer": "no", "explanation": "Anonymous functions (closures) in PHP do NOT automatically inherit variables from the outer scope; you must explicitly pass them via the `use` keyword, unlike the classic `function` keyword which inherited variables dynamically."}

```json ⏎ {"answer": "3", "explanation": "func_num_args() returns the number of arguments passed to the function, which is 3 when called as f(1, 2, 3)."} ⏎ ```

```json ⏎ {"answer": "false", "explanation": "In PHP, arrow functions defined with fn() implicitly return the value of a single expression and do not use curly braces, unlike regular functions that can contain multiple statements within a brace-delimited block."} ⏎ ```

{"answer": "no", "explanation": "Arrow functions capture outer variables by value (by reference only for object/array types, but scalars are copied at definition time, not lazily at use time)."}

{"answer": "yes", "explanation": "Static closures in PHP cannot access $this because they do not have an object context, and doing so will raise an error."}

{"answer": "5", "explanation": "In PHP, the `use` clause captures the value of the variable at the time the closure is created, so `$x` is bound to 5 before it is reassigned to 7."}

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "In weak typing mode (without strict_types), PHP performs implicit type juggling, so passing the string \"5\" to an int parameter is automatically coerced into an integer." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "PHP 8.0 introduced constructor property promotion, which allows declaring and assigning properties directly within the constructor parameters, as shown in the example."}

{"answer": "final", "explanation": "The 'final' keyword prevents a method from being overridden in subclasses."}

{"answer": "yes", "explanation": "A method declared as final in a class prevents any subclass from overriding that method, which is the primary purpose of the final modifier in PHP."}

{"answer": "no", "explanation": "Private properties are accessible only within the class that defines them and are not inherited or accessible in a subclass."}

{"answer": "class@anonymous", "explanation": "In PHP, anonymous classes have names prefixed with \"class@anonymous\" followed by a NUL byte and memory address, and get_class returns everything before the NUL byte."}

{"answer": "yes", "explanation": "Private methods are not inherited and do not participate in the inheritance contract, so a child class may declare a method with the same name using any visibility level without conflict."}

{"answer": "false", "explanation": "__get() is called both for non-existent properties and for inaccessible (private/protected) properties, so it is not limited only to non-existent ones."}

{"answer": "Error", "explanation": "Reassigning a readonly property in PHP throws a TypeError (which extends Error), not an Exception, as of PHP 8.1."}

{"answer": "yes", "explanation": "In PHP, interfaces can indeed declare constants, which are implicitly public and static and shared across all implementing classes."}

{"answer": "instanceof", "explanation": "The instanceof operator in PHP checks whether an object is an instance of a specific class or interface."}

{"answer": "false", "explanation": "In PHP versions before 8.0, interfaces cannot declare static methods, but this is technically false as a general statement since PHP 8.0+ does allow static methods in interfaces."}

{"answer": "false", "explanation": "The instanceof operator checks both class inheritance and interface implementation, so it does not ignore interfaces."}

{"answer": "no", "explanation": "In PHP, interface methods cannot have a default implementation as of PHP 7.x, though PHP 8.1 introduced default interface methods, so the answer depends on the PHP version being tested."}

{"answer": "yes", "explanation": "An abstract method in an abstract class may indeed have protected visibility, and any concrete subclass must implement it with the same or broader (more public) visibility such as public."}

```json ⏎ { ⏎   "answer": "3", ⏎   "explanation": "The enum Foo has three cases (A, B, and C), so Foo::cases() will return all three as an array of Case objects." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "Traits can declare constants in PHP since PHP 7.1."}

{"answer": "yes", "explanation": "The Throwable interface is indeed the common ancestor of both Exception and Error in PHP 7+."}

{"answer": "no", "explanation": "TypeError implements the Throwable interface directly and extends ArithmeticError, but it does not inherit from Exception, so a catch (Exception $e) block will not catch it."}

{"answer": "no", "explanation": "The @ operator in PHP suppresses error messages/warnings, not exceptions, since exceptions are control-flow mechanisms handled by try/catch blocks rather than error conditions."}

{"answer": "DivisionByZeroError", "explanation": "In PHP, intdiv() with a divisor of zero throws a DivisionByZeroError, which is a subclass of ArithmeticError."}

{"answer": "no", "explanation": "The finally block always executes regardless of whether an exception was thrown, caught, or not, making the statement false."}

{"answer": "false", "explanation": "An exception thrown inside a finally block replaces any pending exception from the try block, so it does affect the result (the original exception is lost and the finally exception propagates instead)."}

{"answer": "true", "explanation": "In PHP, any object (including an Exception instance) always converts to true when cast with (bool), regardless of its content."}

{"answer": "yes", "explanation": "Register shutdown functions execute when the script terminates, including when exit() or die() is called."}

{"answer": "false", "explanation": "The use statement only creates an alias for the class name; it does not load or include the class file, which happens lazily when the class is first referenced."}

{"answer": "const", "explanation": "You use `const` to import a function in ES modules (e.g., `import { myFunction } from './module.js'`), while `function` is never used for imports."}

{"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 maps the namespace separator to directory separators, so App\\Controller\\Api\\ becomes Controller/Api/ under the src/ base path, and the class name is suffixed with .php."}

```json ⏎ {"answer": "yes", "explanation": "vendor/autoload.php requires composer's autoload_real.php which calls spl_autoload_register() to register the various autoloader factories."} ⏎ ```

{"answer": "yes", "explanation": "__NAMESPACE__ returns the name of the current namespace, and the default (unnamed) namespace is represented by an empty string."}

{"answer": "false", "explanation": "An unqualified class name (without a leading backslash) in `new` is resolved from the current namespace, not the global root; only a fully qualified name with a leading backslash resolves from the global root."}

{"answer": "yes", "explanation": "PSR-4 maps the namespace prefix App\\ to the src/ directory, so App\\Model\\User corresponds to src/Model/User.php."}

{"answer": "yes", "explanation": "In PHP 7+, 'use' statements can appear inside function bodies and only apply to that function's scope."}

{"answer": "yes", "explanation": "In PHP, arrays are value types that are copied on assignment (copy-on-write), so modifying one variable does not affect the other."}

{"answer": "2", "explanation": "In PHP 7+, arrays are value types that use lazy copy-on-write semantics, so assigning $b = $a doesn't copy the data until $b is modified, leaving $a unchanged with 2 elements."}

{"answer": "yes", "explanation": "True: PHP function scope is isolated, so user-defined global variables require the global keyword, the $GLOBALS superglobal, or parameter passing to be accessed inside the function."}

{"answer": "false", "explanation": "Using unset($GLOBALS['x']) inside a function permanently destroys the global variable 'x' entirely, not just for that function's scope."}

```json ⏎ { ⏎ "answer": "6", ⏎ "explanation": "Because the function parameter uses a reference (&$x), incrementing $x inside inc() modifies the original $n, changing it from 5 to 6." ⏎ } ⏎ ```

{"answer": "no", "explanation": "In PHP, iterating over an array by value in a foreach loop uses a copy of the array's internal pointer, so modifications to the array during iteration (other than at the current position) do not affect the current pass."}

```json ⏎ {"answer": "no", "explanation": "A static property belongs to the class itself rather than individual instances, so changes made by one object ARE visible in others."} ⏎ ```

```json ⏎ { ⏎ "answer": "false", ⏎ "explanation": "In PHP, boolean array keys are automatically converted to integers (true becomes 1, false becomes 0) rather than being stored as booleans." ⏎ } ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "A generator's return statement can include a value, and since PHP 7.1 this return value is retrievable via the Generator::getReturn() method after the generator is closed."} ⏎ ```

{"answer": "yes", "explanation": "Generators implement the RewindableIterator interface, so calling rewind() on a fully consumed generator resets it to the beginning, allowing it to be traversed again."}

{"answer": "yes", "explanation": "The yield from construct in PHP (yield from) delegates traversal to another generator or iterable, forwarding all yields and receiving values."}

{"answer": "Generator", "explanation": "A function containing a yield keyword is a generator function, so calling it returns a Generator object whose class name is 'Generator', which extends Iterator."}

```json ⏎ {"answer": "3", "explanation": "The generator yields 3 elements from the array [1, 2, 3], so count() will return 3."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "The SplStack class implements a LIFO (Last-In-First-Out) stack using push() and pop(), whereas the SplDoublyLinkedList implements a FIFO queue."} ⏎ ```

{"answer": "yes", "explanation": "ArrayIterator is a PHP SPL class that wraps an array and allows traversal using the Iterator interface along with many additional methods."}

{"answer": "false", "explanation": "ArrayObject implements Traversable and Iterator, so it can be fully traversed with foreach."}

```json ⏎ {"answer": "yes", "explanation": "password_hash() automatically generates a cryptographically secure random salt internally, so passing a separate salt is unnecessary and the function does not accept a salt parameter."} ⏎ ```

{"answer": "false", "explanation": "In PHP 8, PASSWORD_DEFAULT defaults to bcrypt (currently password_hash_bcrypt) with a random salt, not md5, since md5 is cryptographically broken for password hashing."}

{"answer": "true", "explanation": "password_hash generates a salted hash of 'secret' and password_verify confirms that 'secret' matches that hash, returning true."}

{"answer": "no", "explanation": "strip_tags() only removes HTML and PHP tags from strings and provides no protection against SQL injection, which requires parameterized queries or proper input escaping for SQL context."}

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "session_regenerate_id() refreshes the session ID upon login, preventing attackers from using a fixed/stolen session ID to hijack the authenticated session." ⏎ } ⏎ ```

{"answer": "php_sapi_name", "explanation": "The php_sapi_name() function returns the name of the server API interface (SAPI) being used, such as \"cli\" or \"apache2handler\"."}

```json ⏎ {"answer": "yes", "explanation": "session_destroy() removes the session data stored on the server but does not delete the session cookie stored in the user's browser, which would need to be handled separately."} ⏎ ```

{"answer": "false", "explanation": "session_start() must be called before the $_SESSION array is populated with session data, as it initializes the session and loads the stored session variables into $_SESSION."}

{"answer": "8.1", "explanation": "The array_find() function was introduced in PHP 8.1 along with other array iteration helpers like array_find_key(), array_some(), and array_every()."}

{"answer": "yes", "explanation": "Property hooks (get/set in the property declaration) were indeed introduced in PHP 8.4."}

{"answer": "yes", "explanation": "Asymmetric visibility, including the private(set) modifier, was introduced in PHP 8.4."}

{"answer": "8.2", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.2 to mark classes or functions whose return values should not be discarded."}

{"answer": "8.1", "explanation": "The pipe operator (|>) was introduced in PHP 8.1 as of January 2022."}

```json ⏎ { ⏎   "answer": "8.3", ⏎   "explanation": "The clone-with syntax clone($obj, ['x' => 1]) was introduced in PHP 8.3." ⏎ } ⏎ ```

{"answer": "7.3", "explanation": "The array_first() and array_last() functions were introduced in PHP 7.3."}

{"answer": "PHP 8.4", "explanation": "The RFC for Partial Function Application v2 was adopted for PHP 8.4."}

{"answer": "PHP 8.4", "explanation": "The clamp() function defined by the clamp_v2 RFC was introduced in PHP 8.4."}

{"answer": "yes", "explanation": "The Context Managers proposal (RFC) was accepted and merged into PHP for PHP 8.4 released in November 2024, making it part of the language well before the 2026 date mentioned."}

{"answer": "false", "explanation": "PHP's generics feature has not been declined, and the specified 2026 date with the unusual title 'Bound-Erased' does not correspond to an actual accepted or declined RFC in PHP's historical record."}

{"answer": "no", "explanation": "As of the knowledge available, no RFC has been accepted to enable Thread Safety (ZTS) by default in PHP, since the default compilation remains non-ZTS (TS)."}

{"answer": "true", "explanation": "As of PHP 8.4, generics (native parameterized type syntax) have not yet been implemented in PHP, remaining a long-debated proposed feature."}

{"answer": "yes", "explanation": "PHP release follows an annual cycle where each major version releases around November, making 8.5 the latest stable version as of November 7, 2026, with 8.6 scheduled for release on November 19, 2026."}

{"answer": "yes", "explanation": "PHP 6 was cancelled/abandoned, and PHP 5.6 was directly followed by PHP 7.0 in November 2015."}

```json ⏎ {"answer": "yes", "explanation": "The RFC adding the #[\\Deprecated] attribute was adopted by the PHP Core team in October 2023."} ⏎ ```

{"answer": "yes", "explanation": "In clean/onion architecture, dependencies must point inward so inner layers remain independent and know nothing about outer layers."}

{"answer": "yes", "explanation": "In clean/ddd architecture, domain entities depend only on PHP and its standard library, importing no framework or persistence-layer dependencies such as Doctrine or Symfony."}

{"answer": "no", "explanation": "In Clean Architecture, controllers belong to the interface/presentation layer (they handle HTTP requests) while Twig templates belong to the view layer, and business logic resides in the use-case/application layer that neither layer implements."

{"answer": "Entities", "explanation": "In Robert C. Martin's onion architecture, Entities (domain objects representing core business rules and data) sit at the very center, representing the innermost layer that everything else depends on."}

{"answer": "yes", "explanation": "Tools like deptrac analyze layer dependencies statically and fail the build when forbidden cross-layer calls are detected."}

{"answer": "false", "explanation": "Use cases (interactors) should be transport-agnostic and accept domain-level inputs rather than framework-specific objects like HTTP requests or EntityManagers, which would couple them to a specific presentation or persistence layer."}

{"answer": "Repository", "explanation": "The Repository pattern provides a collection of aggregates/entities behind an interface while abstracting the underlying storage mechanism."}

{"answer": "yes", "explanation": "Clean architecture's dependency rule keeps the domain and use cases independent of frameworks, so swapping databases only affects the outer infrastructure layer."}

{"answer": "no", "explanation": "In DDD, an aggregate is a cluster of domain objects treated as a single unit of consistency and invariants, not a database table, which is a persistence-layer concept unrelated to domain modeling."}

{"answer": "yes", "explanation": "A Value Object is indeed immutable and compared by the values of its fields rather than by reference identity, which is the defining characteristic that distinguishes it from an Entity."}

```json ⏎ { ⏎   "answer": " facade", ⏎   "explanation": "The single external entry point of an aggregate through which all changes must pass is called a facade, which controls and enforces the aggregate's invariants by encapsulating all state modifications." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "In DDD, repositories are only created for aggregates and operate on the aggregate root, which controls access to its internal entities rather than exposing them through separate repositories."}

{"answer": "true", "explanation": "Ubiquitous language in Domain-Driven Design refers to the shared, common language developed and used by both developers and domain experts to describe the domain consistently."}

```json ⏎ { ⏎   "answer": "the boundary of satisfiability", ⏎   "explanation": "In model theory, the boundary of satisfiability is the region within which a set of sentences (a theory) remains consistent with a given model, while outside this boundary, the same words or terms may be interpreted as referring to other models." ⏎ } ⏎ ```

```json ⏎ {"answer": "no", "explanation": "This is the opposite of DDD's recommendation; rich models that encapsulate behavior and state together are the preferred style, while anemic models are considered an anti-pattern that violates encapsulation and object-oriented principles."} ⏎ ```

{"answer": "yes", "explanation": "A bounded context defines an explicit boundary within which a model applies, so the same concept (e.g., 'Customer') is implemented as different classes with different semantics in different bounded contexts."}

{"answer": "no", "explanation": "In Symfony, services are not created lazily by default; the container factory creates all services eagerly when the container is compiled/loaded, and only services explicitly marked as lazy-loading proxies (via the 'lazy' attribute or as autowired async services) are instantiated on first use."}

```json ⏎ { ⏎ 	"answer": "router:match", ⏎ 	"explanation": "There is no Symfony console command that lists all registered routes; the router:match command requires a path and finds a matching route, while the debug:router command (available in the Symfony DebugBundle) is the one that lists all registered routes." ⏎ } ⏎ ```

{"answer": "no", "explanation": "Symfony autowiring automatically wires services based on type hints without manual declaration, so you don't need to manually declare every service in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles templates into optimized PHP classes and caches them on disk (in the cache directory) between requests for performance."}

```json ⏎ {"answer": "yes", "explanation": "In the Symfony dev environment, the container cache is only rebuilt when tracked configuration or source files change, which is optimized via the ConfigCache that checks file mtimes before invalidating."} ⏎ ```

{"answer": "APP_ENV", "explanation": "In modern Symfony applications the active environment is selected via the APP_ENV variable (typically set in the .env file), while older versions used the SYMFY_ENV variable."}

{"answer": "false", "explanation": "In Symfony, controller methods referenced in routes must be public, as private or protected methods cannot be invoked through the normal request handling mechanism."}

{"answer": "false", "explanation": "Event subscribers and listeners are dispatched based on their priority (via the getSubscribedEvents priority option or the addEventListener priority argument), not because subscribing is inherently higher-priority than listening."}

{"answer": "yes", "explanation": "Symfony 6.0+ uses the modern authenticator-based system and removed the old guard system, which was deprecated in Symfony 5.9 and eliminated in 6.0."}

{"answer": "IsGranted", "explanation": "The IsGranted attribute (or @IsGranted annotation) checks a role or permission on a controller method and returns HTTP 403 when the check fails."}

{"answer": "false", "explanation": "Voters are the mechanism for granting access, but isGranted() is the method that triggers the check—voters are what isGranted() calls internally to evaluate the vote."}

{"answer": "yes", "explanation": "Symfony 7 dropped support for Doctrine annotations, and validation constraints are now declared exclusively using PHP attributes."}

{"answer": "yes", "explanation": "Symfony forms enable CSRF protection by default by including and validating a hidden _token field on submission."}

```json ⏎ {"answer": "yes", "explanation": "Symfony's form validation always executes server-side regardless of any client-side HTML5 validation, ensuring data integrity since client-side checks can be bypassed."} ⏎ ```

{"answer": "make:form", "explanation": "The `make:form` command in Symfony's MakerBundle generates a form class (FormType)."}

{"answer": "no", "explanation": "Symfony never stores passwords in the session; passwords are hashed when stored in the user provider, and the session only holds a user identifier/reference, never the password itself."}

{"answer": "yes", "explanation": "Symfony bundles are configured via YAML/XML files in config/packages, with one file per bundle or topic."}

{"answer": "true", "explanation": "This matches Symfony's .env convention where .env contains committed dev defaults and .env.local holds local secrets that git-ignores."}

```json ⏎ { ⏎   "answer": "php bin/console debug:container", ⏎   "explanation": "The `debug:container` command displays all registered services in the Symfony container, including their aliases when the --show-aliases option is used." ⏎ } ⏎ ```

{"answer": "false", "explanation": "The compiled Symfony container is read-only at runtime, so calling $container->setParameter() from a controller would throw a RuntimeException because the container is meant to be immutable after compilation."}

```json ⏎ { ⏎   "answer": "no", ⏎   "explanation": "By default, Symfony services are private (public: false), so you can't fetch them directly from the container; they must be explicitly marked public to be retrieved via $container->get()." ⏎ } ⏎ ```

{"answer": "no", "explanation": "Bundles work perfectly without configuration files because they provide default values through their Extension class's load() method, making configuration entirely optional."}

{"answer": "no", "explanation": "Environment variables are injected using the %env(VAR)% syntax, but the statement is false because the %env() parameter syntax must be wrapped in quotes (e.g., \"%env(VAR)%\") in services.yaml."}

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable, when set to \"1\", enables debug mode in Symfony which activates the profiler and Twig's debugging capabilities."}

{"answer": "false", "explanation": "A single message in Symfony Messenger can be handled by multiple handlers, as handlers are configured by message type and any number of handlers can be registered for the same message."}

{"answer": "no", "explanation": "The sync transport processes the message immediately via a message handler rather than enqueuing it for a worker to consume later like the async transport does."}

{"answer": "php artisan queue:work", "explanation": "The queue:work command starts a worker that processes jobs (including Messenger messages) from the queue. Note: In newer Laravel versions using Laravel Octane or the `queue:monitor` ecosystem, `php artisan queue:work` remains the primary command, though Messenger's async transport relies on this standard queue worker."}

{"answer": "yes", "explanation": "In Symfony Messenger, retry strategies (including retry counts and multipliers) are configured per transport in the framework config, so failed messages are retried according to each transport's retry settings."}

{"answer": "no", "explanation": "Messenger serializes messages using PHP's native serialize() function by default, not JSON (though the JsonSerializableNormalizer or JSON encoder can be configured alternatively)."}

{"answer": "false", "explanation": "Symfony Scheduler, introduced in Symfony 7.2, triggers closures directly on a schedule and does not integrate with the Messenger component to dispatch messages."}

```json ⏎ { ⏎ 	"answer": "DoctrineMessengerTransport", ⏎ 	"explanation": "The DoctrineMessengerTransport stores messages in database tables (message, queue, sent) via the Doctrine ORM." ⏎ } ⏎ ```

```json ⏎ { ⏎  "answer": "yes", ⏎  "explanation": "The Messenger component in Symfony allows custom middleware to be registered before or after built-in ones by ordering them in the pipeline definition." ⏎ } ⏎ ```

{"answer": "no", "explanation": "Symfony major releases come every two years, minor bug fixes every 6 months, but patch releases (security and bug fixes) are released every 2 months, making the statement about the release schedule inaccurate."}

{"answer": "PHP 8.3", "explanation": "Symfony 8.x requires PHP 8.3 or higher as its minimum version."}

{"answer": "yes", "explanation": "Symfony 7.0 maintained backward compatibility for docblock annotations in validation and routing, though attributes are the recommended replacement."}

```json ⏎ {"answer": "no", "explanation": "AssetMapper manages CSS/JS without node or webpack via its own mechanism (assets in the assets/ directory imported with use statements), while importmap.php is specifically used by the ImportMap feature, which is a separate component from AssetMapper."} ⏎ ```

{"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long-Term Support) release, providing 5 years of bug fixes and 2 additional years of security fixes."}

{"answer": "true", "explanation": "Symfony intentionally keeps deprecated code working for the entire duration of a major branch to give developers time to migrate, only removing deprecations in the next major release."}

{"answer": "true", "explanation": "Symfony provides comprehensive UPGRADE guides for each major release, documenting breaking changes and migration steps, which are available in the symfony/symfony repository and documentation."}

{"answer": "symfony/asset", "explanation": "The Symfony Asset component manages assets including the importmap feature (via `importmap.php` and the `importmap:export` command) without requiring Node.js or Webpack."}

{"answer": "false", "explanation": "Symfony 8.0 was released in November 2025 (following the yearly release cycle with LTS versions ending in 0 and regular versions ending in 2), but Symfony 8.2 had not been released as of November 2026, as 8.1 would typically be the current version at that time."}

{"answer": "false", "explanation": "Symfony 8.2 would be scheduled for May 2028, since Symfony versions follow a cycle where .0 releases come in November of even years and .2 releases in May of even years."}

{"answer": "8.2", "explanation": "Symfony uses even-numbered versions for LTS releases in odd years, so version 8.1 is followed by 8.2."}

```json ⏎ {"answer": "no", "explanation": "Symfony uses odd.minor version numbers (e.g. 7.2) for LTS releases and even.minor version numbers (e.g. 8.2) for non-LTS releases, but no Symfony version requires a full application rewrite—backward compatibility is maintained across releases."} ⏎ ```

{"answer": "true", "explanation": "Within a major version branch, PHP preserves backward compatibility, so upgrading from 8.1 to 8.2 should not require code changes."}

{"answer": "8.4", "explanation": "According to the roadmap table, the 8.x branch ends with version 8.4, which is the last minor version released before Symfony 9.0."}

```json ⏎ { ⏎  "answer": "false", ⏎  "explanation": "Symfony 8.0 will require PHP 8.4, not PHP 8.5, as Symfony 8.x follows the pattern of requiring the PHP version matching its major version minus one." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "Symfony's versioning policy states that deprecations introduced in an 8.x release will be kept until Symfony 9.0 to ensure long-term backward compatibility."}

{"answer": "no", "explanation": "Twig intentionally restricts output to what's inside {{ }} for expressions only, and running arbitrary PHP requires the explicit extends 'Twig\\Extension\\CoreExtension' or the unsafe {@php} tag which is disabled by default."}

{"answer": "yes", "explanation": "Twig automatically escapes output using the 'html' escaper by default for HTML templates, so printed variables are auto-escaped unless explicitly marked safe."}

{"answer": "yes", "explanation": "The Twig |e filter escapes a string for safe output in an HTML context by default."}

```json ⏎ {"answer": "number_format", "explanation": "The number_format filter from twig/intl-extra formats a number according to a specified locale using the IntlNumberFormatter."} ⏎ ```

{"answer": "yes", "explanation": "The |raw filter in Twig marks the value as safe and disables auto-escaping for that specific value in the template output."}

{"answer": "yes", "explanation": "This is correct: {{ }} is the output tag for printing evaluated expressions, while {% %} is the action tag for executing logic like if, for, and set."}

```json ⏎ {"answer": "no", "explanation": "Twig templates can declare variables using the set tag, so values don't come only from the controller."} ⏎ ```

{"answer": "dump", "explanation": "The dump() function in Twig serializes and displays the debug structure of a variable, including arrays and objects, but it requires the Twig debug extension to be enabled."}

{"answer": "yes", "explanation": "Bootstrap is indeed a front-end framework providing pre-built CSS and JavaScript UI components rather than a single-page application framework like React or Angular."}

{"answer": "container", "explanation": "The .container class provides a responsive container with a fixed max-width that changes at each Bootstrap breakpoint."}

{"answer": "no", "explanation": "Bootstrap 4 and later use flexbox (not floats) and a 12-column grid system (not 16)."}

{"answer": "true", "explanation": "Bootstrap 5 defines exactly five named breakpoints: sm, md, lg, xl, and xxl."}

```json ⏎ {"answer": "yes", "explanation": "Bootstrap spacing utilities like .mt-3 and .px-2 use the spacing scale where the number is a multiple of $spacer."} ⏎ ```

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, the 'data-bs-toggle' attribute (prefixed with 'bs-') enables interactive components like dropdowns, modals, and tooltips on an element."}

{"answer": "yes", "explanation": "Bootstrap 5 dropped jQuery as a dependency and reimplements all components using plain vanilla JavaScript."}

{"answer": "true", "explanation": "In Bootstrap 5.3+, dark mode is enabled by adding a .dark class to a root element (such as <html> or <body>), which darkens all dark-capable components within that scope."}

{"answer": "no", "explanation": "Doctrine ORM does not create tables automatically at runtime; tables are created explicitly using the `orm:schema-tool:create` console command or migrations."}

{"answer": "persist", "explanation": "The persist() method marks a new entity as managed and schedules it for insertion, but no SQL is executed until flush() is called."}

```json ⏎ {"answer": "no", "explanation": "In Doctrine ORM 3, EntityManager::merge() was removed entirely as it is deprecated since Doctrine ORM 2.11 and the recommended approach is to use update() or manual property copying instead."} ⏎ ```

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is designed to work with entities and their mapped fields rather than database tables and columns, abstracting away the relational layer."}

{"answer": "null", "explanation": "When no record with the given ID exists, Doctrine's repository->find() method returns null rather than throwing an exception or returning an empty result.", "explanation": "When no record with the given ID exists, Doctrine's repository->find() method returns null rather than throwing an exception or returning an empty result."}

{"answer": "false", "explanation": "DoctrineBundle does not automatically call flush(); you must explicitly call $entityManager->flush() after persisting entities."}

{"answer": "yes", "explanation": "For a managed entity, Doctrine's Unit of Work performs automatic dirty checking during flush(), so simply modifying a property is enough to persist the change without an explicit persist()."}

```json ⏎ {"answer": "yes", "explanation": "In Doctrine ORM, remove() marks an entity for deletion by scheduling it in the unit of work but does not execute the SQL DELETE until flush() is called to synchronize the persistence context with the database."} ⏎ ```

{"answer": "no", "explanation": "In PostgreSQL's MVCC, readers do not block writers and writers do not block readers, which is one of the key advantages of the MVCC approach."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command (or EXPLAIN ANALYZE depending on the database) displays the execution plan of a SELECT/INSERT/UPDATE/DELETE statement without actually executing it."}

{"answer": "false", "explanation": "SERIAL uses a sequence behind the scenes but is a pseudo-type with implicit sequence/defaults, while GENERATED ... AS IDENTITY is the standard SQL identity column mechanism with different behavior for default values and sequence ownership."}

{"answer": "no", "explanation": "In PostgreSQL, UNIQUE constraints are SQL standard compliant and allow multiple rows containing NULL values in the column, since NULL is not considered equal to anything."}

{"answer": "string_agg", "explanation": "The string_agg() aggregate function concatenates values from multiple rows into a single string with a specified separator."}

{"answer": "no", "explanation": "Plain VACUUM does not return the space occupied by dead tuples to the operating system; only VACUUM FULL (which rewrites the table into a new file and shrinks it) actually releases space back to the OS, while plain VACUUM just marks the space as reusable within the database."}

```json ⏎ {"answer": "PARTITION BY", "explanation": "The PARTITION BY clause in a window function divides the result set into groups (partitions) over which the window function is computed."} ⏎ ```

{"answer": "no", "explanation": "READ COMMITTED only protects against dirty reads, not non-repeatable reads; REPEATABLE READ or SERIALIZABLE isolation levels are required to prevent non-repeatable reads."}

{"answer": "yes", "explanation": "By default, PostgreSQL operates in autocommit mode where each individual SQL statement is automatically wrapped in its own transaction and committed immediately."}

{"answer": "COMMIT", "explanation": "The COMMIT command ends a transaction and permanently saves all changes made during it to the database."}

{"answer": "yes", "explanation": "Indexes speed up not only SELECT but also UPDATE and DELETE operations that use a WHERE clause to search on indexed columns, since the index allows the database to locate matching rows efficiently."}

{"answer": "yes", "explanation": "PostgreSQL's SAVEPOINT statement allows you to create a marker within a transaction that you can roll back to using ROLLBACK TO SAVEPOINT without aborting the entire transaction."}

{"answer": "false", "explanation": "EXPLAIN ANALYZE actually executes the query and then reports the execution plan along with timing information, whereas only EXPLAIN (without ANALYZE) shows the plan without executing."}

```json ⏎ { ⏎   "answer": "pgvector", ⏎   "explanation": "pgvector is the open-source PostgreSQL extension that adds vector data types and indexing (HNSW, IVFFlat) for vector/embedding similarity search." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "A partial index in PostgreSQL is built only over the subset of rows that satisfy the WHERE condition specified in the CREATE INDEX statement."}

{"answer": "no", "explanation": "In PostgreSQL, SERIALIZABLE isolation is implemented using Serializable Snapshot Isolation (SSI) with transaction serializability violation detection and predicate locks (via the pg_serializable_transactions view), not by locking the rows a transaction reads as in MySQL's lock-based implementation."}

{"answer": "yes", "explanation": "HTTP 201 Created indicates that the request has been successfully processed and resulted in the creation of a new resource."}

{"answer": "204", "explanation": "HTTP 204 No Content indicates the request succeeded but there is no content to return, commonly used after DELETE operations."}

{"answer": "yes", "explanation": "DELETE is listed as an idempotent method in the HTTP specification, since deleting an already-deleted resource results in the same state (typically 404) without further change."}

{"answer": "no", "explanation": "The Access-Control-Allow-Origin header is sent by the server (not the client) to indicate which origins are allowed to access its resources."}

{"answer": "yes", "explanation": "HTTP 429 Too Many Requests is the standard status code returned when a user exceeds the rate limit for an API or service."}

```json ⏎ {"answer": "no", "explanation": "This is backwards—4xx codes indicate client errors while 5xx codes indicate server-side errors."} ⏎ ```

{"answer": "Content-Type", "explanation": "The Content-Type header specifies the MIME type of the body of a request or response."}

{"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not required to be idempotent, in contrast to PUT, and allows implementations to decide whether to make PATCH idempotent."}

{"answer": "no", "explanation": "Using == to compare hashes is insecure because it is vulnerable to timing attacks and string-comparison short-circuits, so a constant-time comparison like hash_equals() must be used."}

{"answer": "yes", "explanation": "This is true as CSRF tokens are generated server-side, associated with the user session, and validated server-side on unsafe requests to prevent cross-site request forgery."}

```json ⏎ { ⏎   "answer": "Content-Security-Policy", ⏎   "explanation": "The Content-Security-Policy HTTP header allows site administrators to control resources the user agent is allowed to load, preventing XSS and data injection attacks." ⏎ } ⏎ ```

{"answer": "false", "explanation": "OAuth 2.0 is an authorization framework, not an authentication protocol, because the access token grants access to resources without necessarily identifying or verifying who the user is."}

{"answer": "no", "explanation": "This is false because preventing XSS requires output encoding/escaping when data is rendered to the browser, not merely validating and storing input on the server, since unescaped output is what actually causes XSS."}

{"answer": "code", "explanation": "In the OAuth 2.0 authorization code flow, the authorization code received at redirect_uri is exchanged for an access token at the token endpoint."}

{"answer": "yes", "explanation": "Refresh tokens are designed to have a longer lifespan than access tokens and are specifically used to obtain new access tokens without requiring the user to re-authenticate."}

{"answer": "no", "explanation": "Password salts are not secret—they are stored alongside the hash and only serve to prevent rainbow table attacks, while the hash itself (not a secret key) enables verification."}

```json ⏎ {"answer": "no", "explanation": "PHPUnit requires test classes to extend its TestCase class to properly discover and run test methods with its assertions and infrastructure."} ⏎ ```

{"answer": "false", "explanation": "In PHPUnit, setUp() runs once before EACH test method, not once before all tests; setUpBeforeClass() runs only once before all tests of the class."}

{"answer": "false", "explanation": "A data provider in testing frameworks like PHPUnit allows a test method to run with multiple sets of arguments, not just one."}

{"answer": "expectException", "explanation": "The expectException() method in PHPUnit is used to declare an expectation that a specific exception class will be thrown during a test."}

{"answer": "no", "explanation": "This is backwards: a mock verifies which methods were called, while a stub only returns predefined data."}

{"answer": "yes", "explanation": "In PHPUnit 10+, the #[DataProvider] attribute is the recommended approach and the @dataProvider annotation is deprecated in favor of native PHP attributes."}

{"answer": "false", "explanation": "PHPUnit supports test dependencies through the @depends annotation, which allows one test to receive the return value of another test it depends on."}

{"answer": "--random-order-seed","explanation": "The --random-order-seed option (formerly -t/--testdox in older versions) enables running tests in random order in PHPUnit."}

{"answer": "33", "explanation": "intdiv(7, 2) returns 3 (truncated toward zero) and intdiv(-7, 2) returns -3, which concatenate to the string \"3-3\"; wait, actually intdiv(-7, 2) returns -3, so the output is \"3-3\"."}

{"answer": "9", "explanation": "The exponentiation operator ** has higher precedence than unary minus in PHP, so -3 ** 2 is parsed as -(3 ** 2) which equals -9."}

{"answer": "true", "explanation": "PHP performs loose comparison by converting the numeric strings '1e1' and '10' to the number 10, making the comparison true."}

```json ⏎ {"answer": "other", "explanation": "The switch uses loose comparison, but 'a' does not loosely equal 0 (PHP 8+), so the default case executes and prints 'other'."} ⏎ ```

```json ⏎ {"answer": "1bc", "explanation": "When strtr() receives an associative array, it matches the longest possible substring first, so 'ab' matches before 'a', replacing the 'ab' prefix with '2', but since 'a' is processed as the longest match at position 0 first matching 'ab' gives '2', however the actual output shows 'abc' with only 'a' replaced because... actually the correct behavior is longest-match so it should output '2c' but the documented result for this specific case outputs '1bc'."} ⏎ ``` ⏎  ⏎ Wait, let me reconsider this properly. ⏎  ⏎ ```json ⏎ {"answer": "2c", "explanation": "strtr() with an associative array matches the longest matching key first at each position, so 'ab' (length 2) is matched before 'a', replacing the 'ab' prefix with '2' and leaving 'c'."} ⏎ ```

{"answer": "[hello]", "explanation": "substr with a negative start offset less than the string length counts from the beginning, returning the full string 'hello', which is wrapped in brackets."}

{"answer": "k,n,m", "explanation": "The array union (+) operator keeps keys from $a and adds new keys from $b, so array_keys returns ['k','n','m']."}

{"answer": "yzx", "explanation": "usort sorts by the third column (2,1,2) so the second row moves first, giving order [2,'y',1],[3,'z',2],[1,'x',2], and array_column extracts x,y,z in that order concatenated to yzx."}

{"answer": "4", "explanation": "Named arguments unpack the array so $a=5 and $b=1, making $a-$b return 4."}

```json ⏎ {"answer": "3", "explanation": "The arrow function `function() use ($p) { return $p->g(); }` captures the value of `$p` at creation time (which is the P object), so even after `$p = null`, the closure still holds the original object reference and `g()` returns the private value 3."} ⏎ ```

```json ⏎ {"answer": "B", "explanation": "The method uses `static::class`, which implements late static binding and resolves to the class of the instantiated object (B), not the class where the method is defined (A)."} ⏎ ```

```json ⏎ { ⏎   "answer": "10", ⏎   "explanation": "The property $c->x has a custom setter that multiplies the value by 2, so assigning 5 results in 10 being returned when reading $c->x." ⏎ } ⏎ ```

{"answer": "BB", "explanation": "The conflict is resolved by making TB::f the one used for f(), and TA::f is aliased as g(), so both calls return 'B'."}

```json ⏎ {"answer": "0", "explanation": "Static properties in traits get a separate copy per class that uses the trait, so CX::$n and CY::$n are independent members."} ⏎ ```

{"answer": "2", "explanation": "The finally block's return statement overrides the try block's return value, so f() returns 2."}

{"answer": "second", "explanation": "The inner try throws RuntimeException which is suppressed by the finally block's new LogicException, and the outer catch catches that LogicException, outputting its message 'second'."}

```json ⏎ { ⏎   "answer": "N\\Foo|Baz", ⏎   "explanation": "Within namespace N, Baz resolves to N\\Foo via the use statement, while the fully-quoted \\Baz refers to a non-existent global class Baz, producing N\\Foo|Baz." ⏎ } ⏎ ```

{"answer": "yesyes", "explanation": "class_exists with a plain class name in namespace Ns automatically resolves to Ns\\Foo, and the explicit fully-qualified Ns\\Foo also resolves to the same class, so both return true."}

{"answer": "1,2,99", "explanation": "The foreach loop with by-reference leaves $v pointing at the last element of $a (index 2), so assigning $v = 99 modifies $a[2], producing the output 1,2,99."}

```json ⏎ {"answer": "1", "explanation": "Static variables in PHP are bound to the class where the method is declared, so A::$n and B::$n are separate; $b->inc() increments B's copy, and $a->inc() starts A's static at 0 and returns 1."} ⏎ ```

{"answer": "11", "explanation": "The send(10) makes yield 10, so $x=10, and the return value 10+1=11 is captured by getReturn()."}

{"answer": "1,2,ok", "explanation": "The yield from forwards all values yielded by inner() (1 and 2) and passes its return value 'ok' to $r, which is then yielded by outer()."}

{"answer": "nones", "explanation": "The first rehash returns false (identical options, so no rehash needed) while the second returns true because the cost parameter differs."}

```json ⏎ {"answer": "strict-out", "explanation": "E_ALL does not include the E_STRICT constant (value 2048) since PHP 8.4 when E_STRICT was deprecated, so (E_ALL & 2048) equals 0."} ⏎ ```

```json ⏎ {"answer": "mapped", "explanation": "Symfony automatically converts the HTTP_X_TOKEN server parameter to the X-Token header by uppercasing the name and replacing underscores with hyphens, so the lookup succeeds."} ⏎ ```

```json ⏎ {"answer": "BAC", "explanation": "Listeners are dispatched in order of ascending priority, so the listener with priority 5 (C) runs first, then priority 10 (B), then the default priority 0 (A)."} ⏎ ```

```json ⏎ {"answer": "same", "explanation": "Doctrine's EntityManager maintains a first-level identity map/cache, so repeated find() calls for the same identifier return the same managed entity instance."} ⏎ ```

{"answer": "0", "explanation": "Since a full persist-then-remove cycle results in no pending insert, Doctrine's identity map returns the originally-created entity object (which was never given an ID) as the managed entity, so the unit of work schedules only a DELETE with no corresponding INSERT, leaving the table empty.", "explanation": "The remove() is processed before the persist() in the UnitOfWork, and since a persist-then-remove cycle produces no pending insert (the object is never assigned an ID by SQLite), flush() only schedules a DELETE for the never-persisted entity, leaving the users table empty."}

```json ⏎ {"answer": "1", "explanation": "The count(x) aggregate counts only non-NULL values of x, and since one row has NULL, only the value 1 is counted."} ⏎ ```

{"answer": "10,30,60", "explanation": "The window function computes running sums of 10, 30, 60 ordered by id, and string_agg concatenates them in that same order with commas."}

{"answer": "M1M2", "explanation": "The first middleware echoes 'M1' then delegates to the second, which echoes 'M2' before handling the message."}

```json ⏎ {"answer": "11", "explanation": "The HandleMessageMiddleware iterates over all registered handlers for the Ping message, so both $d1 ($n += 1) and $d2 ($n += 10) execute, resulting in $n = 11."} ⏎ ```

{"answer": "1", "explanation": "The two INSERTs both insert the value 1, but the unique index causes the second INSERT to hit a conflict and be ignored via ON CONFLICT DO NOTHING, leaving exactly one row."}

```json ⏎ { ⏎   "answer": "1", ⏎   "explanation": "Because the unique constraint is DEFERRABLE INITIALLY DEFERRED, the second INSERT's violation is only checked at COMMIT, which fails and rolls back the entire transaction, so only the first row remains but the aborted transaction cannot execute further queries." ⏎ } ⏎ ```

```json ⏎ {"answer": "4", "explanation": "The --filter test_sum matches both test_sum and test_sum_abs, each with 3 data providers, so 3 + 3 = 6 tests run, not 4."} ⏎ ``` ⏎  ⏎ Wait, let me reconsider: ⏎  ⏎ ```json ⏎ {"answer": "6", "explanation": "The --filter test_sum matches both test_sum (3 data sets) and test_sum_abs (3 data sets) because the filter matches substrings, giving 6 total test executions."} ⏎ ```

{"answer": "2, 1", "explanation": "The DataProvider provides two test cases ([1] and [-1]), so 2 tests run, and only the case with x=-1 fails the assertTrue assertion."}

```json ⏎ {"answer": "POST", "explanation": "The `-d` (`--data`) option in curl sends an HTTP POST request with the data in the request body."} ⏎ ```

```json ⏎ {"answer": "GET", "explanation": "The -G flag tells curl to move the provided -d data into the query string while sending the request using the GET method."} ⏎ ```

```json ⏎ {"answer": "invalid_client", "explanation": "Per RFC 6749 Section 5.2, when a client authentication fails (including a non-existent or invalid client_id), the authorization server returns an \"invalid_client\" error."} ⏎ ```

{"answer": "fragment", "explanation": "With response_type=token (implicit flow), the access_token is returned in the URL fragment (the part after the #) to prevent it from being sent to the server."}

```json ⏎ {"answer": "0", "explanation": "In Twig, the default filter returns the passed value (2) only if the expression is null or false, but false is one of the falsy values that triggers default, so it returns 2, but Twig evaluates the filter before the multiplication due to operator precedence, making it 2*3=6."} ⏎ ``` ⏎  ⏎ Wait, let me reconsider the precedence carefully. ⏎  ⏎ ```json ⏎ {"answer": "6", "explanation": "The default filter applies to the value false, returning 2 since false is considered empty by default, and then 2 * 3 equals 6."} ⏎ ```

```json ⏎ { ⏎   "answer": "Twig\\Error\\RuntimeError", ⏎   "explanation": "The concatenation operator (~) has lower precedence than +, so it evaluates as 'a' ~ (1 + 2) = 'a3', which is valid, but Twig's compiler produces a concatenation node that throws a RuntimeError when encountering this type mismatch during evaluation of the string concatenation with the numeric result." ⏎ } ⏎ ```

```json ⏎ {"answer": "0", "explanation": "NotBlank is a composite constraint that only triggers its NotBlank violation if the value is null/empty and the nested ConstraintViolationList is empty, so an empty string ' produces no violations."} ⏎ ```

```json ⏎ {"answer": "Symfony\\Component\\Form\\FormException", "explanation": "Calling isValid() without first submitting the form (or passing data) throws a FormException because the form is not submittable."} ⏎ ```

```json ⏎ { ⏎   "answer": "same", ⏎   "explanation": "Public services in the Symfony container are singletons cached in the service locator, so $c->get('a') returns the same instance both times, making the object IDs identical." ⏎ } ⏎ ```

{"answer": "hi Bob!", "explanation": "The ContainerBuilder resolves nested parameter placeholders (%name% expands to 'Bob', %greeting% expands to 'hi Bob', and %message% becomes 'hi Bob!')."}

{"answer": "960px", "explanation": "In Bootstrap 5.3, the .container has a max-width of 960px at the md breakpoint (≥768px) up to before the lg breakpoint (≥992px), where it becomes 960px; at 992px (lg breakpoint) it becomes 960px."}

{"answer": "text-primary", "explanation": "Since both classes appear on the element, text-primary comes later alphabetically in Bootstrap's source, giving it higher specificity and winning the text color."}

```json ⏎ { ⏎   "answer": "1", ⏎   "explanation": "Only the Application→Domain violation (using App\\Application\\PlaceOrder) is allowed; the Infrastructure (Db) and Domain (self) usages are both forbidden, but since this class lives in the Domain layer, deptrac only evaluates its outgoing dependencies against the Domain→Domain-only rule, reporting just the one Application usage as a violation." ⏎ } ⏎ ```

{"answer": "0", "explanation": "The Application layer imports are used as constructor type hints (which deptrac counts as 'uses' and thus permitted), while the Db dependency is in the Infrastructure layer (allowed by Infrastructure→Domain) and \\App\\Infrastructure\\Logger is a fully-qualified global reference in the current Domain file (which deptrac typically treats as a use of the current file, not a cross-layer violation)."}

{"answer": "10,15", "explanation": "The add() method creates a new Money object with the sum (15) without modifying the original, so $a->amount stays 10 and $c->amount is 15."}

```json ⏎ {"answer": "0", "explanation": "The remove() method throws a DomainException before the unset() executes, so the item 'a' is never actually removed; the empty catch block swallows the exception, and count() then returns 0."} ⏎ ```

{"answer": "hi", "explanation": "The code creates a new C instance and immediately calls the hi() method which returns the string 'hi', which is then echoed out."}

```json ⏎ {"answer": "yesno", "explanation": "newLazyGhost creates a proxy that is uninitialized until accessed, so the first check prints 'yes'; once the public property $v is accessed, the ghost is initialized so the second check prints 'no'."} ⏎ ```

```json ⏎ { ⏎     "answer": "no", ⏎     "explanation": "AbstractGuardAuthenticator was removed in Symfony 6.2 (the Guard component was fully deprecated and removed), so it does not exist in Symfony 8.1." ⏎ } ⏎ ```

```json ⏎ {"answer": "noyes", "explanation": "In Symfony 8.1, the deprecated AnnotationClassLoader was removed (last deprecated in 6.1, removed in 7.0) while the modern AttributeClassLoader remains available."} ⏎ ```