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

{"answer": "no", "explanation": "False, because double-quoted strings undergo variable interpolation and escape sequence processing while single-quoted strings are treated literally, so they are not processed identically."}

{"answer": "yes", "explanation": "The ?? (null coalescing) operator follows isset() semantics and does not raise a warning for undefined variables, unlike direct access which would trigger a warning in PHP 7 and above."}

{"answer": "ab", "explanation": "In PHP, echo accepts multiple comma-separated arguments and outputs them concatenated in sequence."}

{"answer": "no", "explanation": "print returns 1 (TRUE) on success, but it cannot be used inside an expression because it is a language construct, not a function, so it cannot be called via certain constructs like call_user_func()."}}

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

```json ⏎ {"answer": "false", "explanation": "In PHP 8 the concatenation operator (.) has higher precedence than addition and subtraction, as shown by '5 . 6 . 7' evaluating to the string '567' rather than '12'."} ⏎ ```

{"answer": "false", "explanation": "In PHP, the ** (exponentiation) operator is right-associative, so 2 ** 3 ** 2 evaluates as 2 ** (3 ** 2) = 2 ** 9 = 512, not 64."}

{"answer": "3", "explanation": "String concatenation (.) has higher precedence than addition (+), so 'sum: ' . 2 evaluates to 'sum: 2' first, then 'sum: 2' + 3 coerces the string to 2 and adds 3, resulting in 3."}

{"answer": "no", "explanation": "With strict comparison (===), two arrays are only considered equal if they have the same key/value pairs in the same order, so element order matters."}

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

```json ⏎ {"answer": "yes", "explanation": "In PHP 8, the \"abc\" == 0 comparison returns true because PHP converts \"abc\" to 0 when comparing it with the integer 0 using loose equality."} ⏎ ```

{"answer": "yes", "explanation": "Under PHP's loose comparison, null is loosely equal to 0, the empty string, and false simultaneously because all of them coerce to the same falsy/zero value."}

{"answer": 42, "explanation": "In PHP, casting a string to int with (int) truncates at the first non-numeric character, so '42abc' becomes 42."}

```json ⏎ {"answer": "10", "explanation": "In PHP, when a numeric string is operated on with a number using the + operator, both are coerced to integers, so '5' + 5 evaluates to 10."} ⏎ ```

{"answer": "false", "explanation": "When cast to string, false becomes an empty string (\"\"), not \"0\"; the string \"0\" equals false when compared loosely, but casting false to string yields \"\"."}

{"answer": "yes", "explanation": "Because of floating-point representation errors, 0.1 + 0.2 evaluates to 0.30000000000000004, so the strict comparison === 0.3 returns false."}

{"answer": "no", "explanation": "strrev() operates on bytes, not characters, so it corrupts multi-byte UTF-8 strings by reversing their byte order."}

{"answer": "yes", "explanation": "The str_contains() function returns true when the haystack string contains the needle string, and 'Hello world' does contain 'world'."}

{"answer": "no", "explanation": "str_pad() can pad a string on the left, right, or both sides depending on the specified padding type (STR_PAD_LEFT, STR_PAD_RIGHT, or STR_PAD_BOTH)."}

```json ⏎ {"answer": "false", "explanation": "trim() by default removes all whitespace characters including spaces, tabs, newlines, carriage returns, null bytes, and vertical tabs, not just spaces."} ⏎ ```

{"answer": "6", "explanation": "strlen() counts bytes, not characters, and 'héllo' has 6 UTF-8 bytes because 'é' occupies 2 bytes."}

```json ⏎ {"answer": "cdef", "explanation": "A negative start position in substr() counts backward from the end of the string, but substr still consumes characters forward from that offset, so starting at the 3rd-from-last character yields 'cdef'."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "In PHP, strings are immutable, so ucfirst() returns a new modified string rather than modifying the original in place."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Heredoc syntax allows variable interpolation while nowdoc behaves like single-quoted strings and does not interpolate variables."} ⏎ ```

{"answer": "no", "explanation": "The sort() function sorts the array by values but reindexes keys numerically starting from zero, destroying the original key-to-value association."}

{"answer": "yes", "explanation": "In PHP, string keys that consist solely of decimal digits (and are representable as integers) are automatically converted to integer keys when accessing or storing array elements."}

{"answer": "no", "explanation": "The in_array() function uses loose comparison by default, and you must explicitly pass true as the third parameter to enable strict comparison."}

{"answer": "yes", "explanation": "Without a callback, array_filter() removes all falsy values (0, 0.0, '', false, null, array()) from the array while preserving the keys."}

{"answer": "false", "explanation": "array_slice() by default reindexes the numeric keys starting from 0, unless the preserve_keys parameter is set to true."}

{"answer": "[20, 30]", "explanation": "array_slice extracts the elements starting at offset 1 for a length of 2, returning indices 1 and 2 (values 20 and 30)."}

{"answer": "2", "explanation": "The union operator (+) combines arrays but keeps the left operand's elements for matching string keys, so 'a' => 1 from the first array is retained while 'b' => 2 from the second is added, resulting in two elements."}

{"answer": "no", "explanation": "The spread operator in PHP only works numerically indexed arrays, so for arrays with string keys it merges them using '+' or array_merge instead."}

{"answer": "false", "explanation": "Named arguments can actually be combined with argument unpacking ($...$args) since PHP 8.1, as long as the unpacked array contains only named keys or the keys are compatible."}

{"answer": "false", "explanation": "Anonymous functions in PHP do NOT automatically see variables from the outer scope; variables must be explicitly imported using the `use` keyword, unlike in closures in many other languages."}

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

{"answer": "false", "explanation": "In PHP, an arrow function can only contain a single expression without curly braces, unlike regular functions which use curly braces for their body."}

{"answer": "false", "explanation": "Arrow functions capture outer variables by value (copy) at definition time, not by reference, unlike closures which can capture by reference."}

{"answer": "yes", "explanation": "A static closure cannot access $this because it does not belong to an object instance, so $this is unavailable even if defined within an object context."}

```json ⏎ {"answer": 5, "explanation": "Closures capture variables by value at the time of definition, so $x is captured as 5 before being reassigned to 7."} ⏎ ```

{"answer": "yes", "explanation": "In weak (non-strict) typing mode, PHP coerces numeric strings to integers when passed to an int parameter, so passing \"5\" is allowed."}

{"answer": "yes", "explanation": "PHP 8.0 introduced constructor property promotion, which allows declaring and assigning properties directly in the constructor parameter list."}

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

{"answer": "yes", "explanation": "Declaring a method final in PHP prevents it from being overridden by any subclass, which is the intended purpose of the final keyword."}

{"answer": "no", "explanation": "Private properties are only accessible within the class that defines them, so they cannot be accessed or inherited by a subclass."}

{"answer": "class@anonymous", "explanation": "In PHP 8, get_class() on an anonymous class returns 'class@anonymous', and the portion before the NUL byte (which encodes the file path) is exactly 'class@anonymous'."}

```json ⏎ {"answer": "yes", "explanation": "Private methods are not inherited and are not part of the inheritance contract, so a child class is free to declare a method with the same name using any visibility level."} ⏎ ```

{"answer": "no", "explanation": "__get() is actually called for inaccessible (including non-existent and inaccessible) properties, so it is not only for non-existent ones."}

{"answer": "Error", "explanation": "In PHP, attempting to reassign a readonly property throws a TypeError, which is a subclass of the Error class rather than the Exception class."}

{"answer": "yes", "explanation": "In PHP, interfaces can declare constants, which are implicitly public and static and must be initialized with a constant value."}

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

{"answer": "no", "explanation": "PHP interfaces cannot declare static methods until PHP 8.0, where static methods were introduced into interfaces."}

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

{"answer": "no", "explanation": "Interface methods in PHP (before PHP 8.0) cannot have default implementations, though PHP 8.0 introduced optional interface methods with default implementations as an experimental feature, but the traditional answer is that interface methods cannot have a default implementation like trait methods do."}

{"answer": "yes", "explanation": "An abstract method in an abstract class may have protected visibility because abstract methods do not have a body, so there is no concrete implementation to expose, allowing any visibility modifier."}

```json ⏎ {"answer": "3", "explanation": "The enum Foo declares three cases (A, B, C), and enum::cases() returns all declared cases as an array."} ⏎ ```

{"answer": "yes", "explanation": "Traits in PHP can declare constants, which become available in any class that uses the trait."}

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

{"answer": "no", "explanation": "TypeError extends RuntimeException which extends ArithmeticException which extends Exception, so a catch (Exception $e) block actually does catch TypeError; the statement is therefore false."}

{"answer": "no", "explanation": "The @ operator suppresses errors/warnings, not exceptions (which are caught and handled by try/catch blocks)."}

{"answer": "DivisionByZeroError", "explanation": "intdiv(5, 0) throws a DivisionByZeroError because dividing by zero is attempted."}

{"answer": "false", "explanation": "The finally block always runs regardless of whether an exception was thrown, caught, or not caught at all."}

{"answer": "false", "explanation": "An exception thrown inside a finally block will propagate out and override/replace any result or exception from the try block, effectively determining the final outcome."}

{"answer": "true", "explanation": "Any object in PHP converts to true when cast to boolean, so (bool) new Exception('x') returns true."}

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

{"answer": "false", "explanation": "The `use` statement only creates an alias for a class name; it does not load the file, which is done by the autoloader when the class is first referenced."}

{"answer": "function", "explanation": "In PHP, when importing a function via `use`, you must specify the `function` keyword, whereas the `const` keyword is used for importing constants."}

{"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 maps the App\\ namespace prefix to the src/ directory, so the fully-qualified class name App\\Controller\\Api\\UserController translates to the path src/Controller/Api/UserController.php."}

{"answer": "yes", "explanation": "Yes, vendor/autoload.php registers Composer's autoloader via spl_autoload_register()."}

{"answer": "yes", "explanation": "__NAMESPACE__ is a magic constant that returns the name of the current namespace in PHP."}

```json ⏎ {"answer": "no", "explanation": "An unqualified class name in new is resolved relative to the current namespace, not from the global root, so code inside a namespace like Foo\\Bar would resolve it as Foo\\Bar\\ClassName rather than ClassName."} ⏎ ```

{"answer": "yes", "explanation": "Under PSR-4, the namespace App\\ maps to src/, so the class App\\Model\\User maps to the file src/Model/User.php, matching the fully-qualified class name by appending each namespace segment as a directory path."}

{"answer": "yes", "explanation": "In PHP 7+, use statements can be written inside function or method bodies, and the import is scoped to that function only."}

{"answer": "yes", "explanation": "In PHP, arrays are value types that are copied on assignment (copy-on-write) rather than passed by reference."}

{"answer": "2", "explanation": "In PHP, arrays are value types, so `$b = $a` copies by value, meaning the copy-on-write mechanism keeps them separate and `$a` retains its original 2 elements."}

{"answer": "true", "explanation": "In PHP, variables defined outside a function exist in the global scope and are not automatically accessible inside function scopes, requiring the use of the `global` keyword, the `$GLOBALS` superglobal, or passing them as function parameters to access them."}

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

{"answer": "6", "explanation": "The function uses a by-reference parameter ($x), so $x++ modifies the original $n variable from 5 to 6."}

```json ⏎ {"answer": "false", "explanation": "A foreach loop by value works on a copy of the array, so modifications to the array inside the loop are not reflected during the same iteration."} ⏎ ```

{"answer": "no", "explanation": "Static properties belong to the class as a whole, so changes made via one instance are visible in all other instances and even without any instance."}

{"answer": "no", "explanation": "In PHP, boolean array keys are automatically converted to integers (true becomes 1, false becomes 0), so they are not stored as booleans."}

{"answer": "yes", "explanation": "In PHP 7.0+, generators support return statements with a value that can be retrieved later via the getReturn() method after the generator is closed."}

{"answer": "yes", "explanation": "A fully consumed generator can be rewound with rewind() and traversed again because generators implement the RewindableIterator interface which allows rewinding."}

{"answer": "yes", "explanation": "The `yield from` construct in PHP delegates traversal to another generator or iterable, forwarding values, sends, and exceptions to the delegated generator."}

{"answer": "Generator", "explanation": "A function containing yield becomes a generator, so get_class() on its returned instance returns the class name 'Generator'}

{"answer": "3", "explanation": "The generator yields 1, 2, 3 via `yield from`, and iterator_to_array() collects all three values into a numerically-indexed array, so count() returns 3."}

{"answer": "no", "explanation": "SplStack implements a LIFO (last in, first out) stack, not a FIFO queue; the SplQueue class implements the FIFO behavior."}

{"answer": "yes", "explanation": "ArrayIterator is a PHP SPL class that wraps an array and allows traversing it using the Iterator interface and many other interface methods."}

{"answer": "false", "explanation": "ArrayObject implements Traversable and ArrayAccess, so it can be iterated over with foreach."}

{"answer": "yes", "explanation": "password_hash() automatically generates a cryptographically secure random salt internally, so providing a salt separately is unnecessary and the function does not even accept a salt parameter."}

```json ⏎ {"answer": "no", "explanation": "In PHP 8, PASSWORD_DEFAULT uses the bcrypt algorithm (currently), not md5, since md5 is cryptographically broken and unsuitable for password hashing."} ⏎ ```

{"answer": "true", "explanation": "password_verify returns true because the hashed 'secret' was generated from the same plaintext 'secret', so verification succeeds."}

{"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 the specific database engine."}

{"answer": "yes", "explanation": "session_regenerate_id() with delete_old_session=true rotates the session ID on login, which is the recommended defense against session fixation attacks."}

{"answer": "php_sapi_name", "explanation": "The php_sapi_name() function returns the name of the Server Application Programming Interface (SAPI) that PHP is running under, such as 'cli'."}

{"answer": "yes", "explanation": "session_destroy() only removes the session data stored on the server, not the session cookie stored in the user's browser."}

{"answer": "false", "explanation": "Without calling session_start(), the $_SESSION array remains empty because session data is not loaded and deserialized until the session is explicitly started."}

{"answer": "5.3", "explanation": "The array_find() function was introduced in PHP 5.3 along with other array map/reduce functions like array_map and array_filter extensions."}

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

{"answer": "yes", "explanation": "Asymmetric visibility, including the ability to use private(set) for write-only properties, was indeed introduced in PHP 8.4."}

{"answer": "8.2", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.2 to allow marking return values whose discard should trigger a warning."}

{"answer": "8.1", "explanation": "The pipe operator (|>) was introduced in PHP 8.1 as a syntactic sugar for function calls that allows passing a value as the first argument."}

```json ⏎ { ⏎   "answer": "8.3", ⏎   "explanation": "The clone-with syntax clone($obj, ['x' => 1]) was introduced in PHP 8.3 (October 2023) as shorthand for cloning an object and overriding properties in a single expression." ⏎ } ⏎ ```

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

```json ⏎ {"answer": "PHP 8.4", "explanation": "The Partial Function Application RFC was adopted for PHP 8.4, which was released in November 2024."} ⏎ ```

{"answer": "PHP 8.5", "explanation": "The clamp_v2 RFC implementing the clamp() function was implemented for PHP 8.5."}

{"answer": "yes", "explanation": "The Context Managers RFC (accepted as of PHP 8.4) introduced the `ContextManager` interface and `enterContext()`/`exitContext()` methods, making the statement true."}

{"answer": "yes", "explanation": "The RFC \"Bound-Erased Generic Types\" was indeed rejected by the PHP core developers."}

{"answer": "false", "explanation": "No RFC has been accepted to enable ZTS by default in PHP, as the default SAPI would remainnts thread-safe by default, which remains a significant undertaking and has not been accepted as of the knowledge cutoff."}

{"answer": "no", "explanation": "Generics (parameterized types) were actually added to PHP in PHP 8.4 (December 2024), so the statement that they are still absent as of PHP 8.5 is false."}

{"answer": "yes", "explanation": "PHP follows a release cycle where feature releases (like 8.5) become stable around November of each year, with 8.6 targeting GA in November 2026, making 8.5 the latest stable version on that date."}

{"answer": "yes", "explanation": "PHP 6 (which was planned for Unicode support) was cancelled and PHP 5.6 was followed directly by PHP 7.0."}

```json ⏎ {"answer": "no", "explanation": "The RFC proposing the #[\\Deprecated] attribute was rejected with 68 votes against, 25 in favor, and 9 abstentions."} ⏎ ```

{"answer": "yes", "explanation": "In clean/onion architecture, dependencies must always point inward from outer layers to inner layers, so inner layers never reference or depend on outer ones."}

```json ⏎ {"answer": "true", "explanation": "In clean/architectural domain-driven design, domain entities should depend only on PHP language features and the standard library to remain decoupled from infrastructure frameworks like Doctrine and Symfony."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation/presentation layer, not the business-logic layer, since they only handle HTTP concerns and calling use cases without containing the application's core business rules."} ⏎ ```

{"answer": "Entities", "explanation": "In the onion architecture, entities sit at the very center as the core business objects, with all other layers wrapping around them."}

{"answer": "yes", "explanation": "Tools like deptrac analyze layer dependencies statically and fail the build when a forbidden cross-layer call is detected, making such violations catchable automatically."}

```json ⏎ {"answer": "no", "explanation": "A well-designed use case should be technology-agnostic and decoupled from frameworks like HTTP or infrastructure details like the EntityManager, relying instead on domain-specific inputs and repository abstractions."} ⏎ ```

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

{"answer": "yes", "explanation": "In clean architecture, database adapters live in the outer infrastructure layer behind interfaces, so swapping databases only touches that layer while the domain and use cases remain unchanged."}

{"answer": "no", "explanation": "An aggregate in DDD is a domain model concept representing a cluster of entities and value objects treated as a unit with consistency rules, not a database table, which is a persistence-layer concern."}

{"answer": "yes", "explanation": "A Value Object is by definition immutable and is compared based on the values of its fields rather than reference identity."}

{"answer": "Facade", "explanation": "In Domain-Driven Design, an aggregate exposes a single external entry point through which all changes must pass, and this is called a Facade."}

{"answer": "yes", "explanation": "In DDD, repositories are designed to represent the collection of a single aggregate type, so you declare one repository for the aggregate root and access contained entities through the root, never directly."}

{"answer": "true", "explanation": "Ubiquitous language is indeed the shared domain language that both developers and domain experts use consistently across all models, documentation, and communication in Domain-Driven Design."}

{"answer": "model theoretic validity", "explanation": "In model theory, this boundary is called \"model theoretic validity,\" within which a formula holds across all models sharing the same language and axioms, while outside it the same words can denote different models."}

{"answer": "no", "explanation": "The anemic domain model is actually the style thatDDD purists like Eric Evans and Martin Fowler explicitly criticize as a symptom of an anemic design, recommending a rich domain model instead."}

{"answer": "yes", "explanation": "A bounded context defines an explicit boundary within which a domain model applies, and the same concept can have different representations/classes across different bounded contexts."}

```json ⏎ {"answer": "false", "explanation": "Symfony's default container is eager by default and only instantiates services lazily (via lazy services, the Xml/YamlLoader, or a container that implements `ContainerInterface::isCompiled()` with lazy wiring)."} ⏎ ```

{"answer": "debug:router", "explanation": "The Symfony console command 'debug:router' displays a list of all registered routes in the application."}

```json ⏎ { ⏎   "answer": "no", ⏎   "explanation": "Symfony's autowiring feature automatically wires services based on type-hints without requiring manual declaration, and autoloading can even register services automatically via pattern matching in services.yaml." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "Twig compiles templates into optimized PHP classes and caches them in a cache directory to avoid recompilation between requests."}

{"answer": "yes", "explanation": "In the Symfony dev environment the container is cached and only rebuilt when tracked PHP/config files change, not on every request."}

{"answer": "APP_ENV", "explanation": "The APP_ENV variable selects the active Symfony environment, typically set in the .env file to dev or prod."}

```json ⏎ {"answer": "yes", "explanation": "In Symfony, a controller method can be private as long as the route annotation points directly to that method, but routing cannot access inherited (parent class) methods and the recommended practice is to use public methods."} ⏎ ```

{"answer": "false", "explanation": "Event subscribers and listeners do not inherently have priority over each other just by being subscribers; event dispatch order is determined by event priority and listener/subscriber priorities assigned via the 'priority' attribute, not by the type of handler."}

```json ⏎ {"answer": "yes", "explanation": "Symfony 6.0 removed the old 'guard' authentication system, and modern Symfony uses the modern authentication system built on AuthenticatorInterface."} ⏎ ```

```json ⏎ {"answer": "[IsGranted]", "explanation": "The IsGranted attribute checks a role or permission on a controller method and returns HTTP 403 when the check fails."} ⏎ ```

{"answer": "true", "explanation": "Voters in Symfony are indeed the mechanism used to grant or deny access based on a specific subject/object, as demonstrated by isGranted('EDIT', $post) where $post is the object being evaluated."}

{"answer": "yes", "explanation": "Since Symfony 5.1, PHP attributes are the recommended and default way to declare validation constraints, and Doctrine annotations support was removed entirely starting with Symfony 5.3, so modern Symfony 7+ relies on attributes."}

```json ⏎ {"answer": "yes", "explanation": "Symfony forms have CSRF protection enabled by default, which validates the token on submission when the form is submitted."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Symfony form validation always executes server-side regardless of whether client-side HTML5 validation passed, since client-side checks can be bypassed or disabled."} ⏎ ```

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

```json ⏎ { ⏎   "answer": "no", ⏎   "explanation": "Symfony does not store passwords in the session; it stores an authentication token, and passwords are hashed using strong algorithms (never stored in plain text or session)." ⏎ } ⏎ ```

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "In Symfony, bundle and third-party package configurations are typically stored in the config/packages directory with one file per bundle or configuration topic." ⏎ } ⏎ ```

{"answer": "false", "explanation": "In the standard .env conventions, .env.local is typically the file that is gitignored (not committed) while .env with safe defaults is committed, so the roles of these two files are swapped in the statement."}

{"answer": "bin/console debug:container", "explanation": "The `debug:container` command lists all registered services and their aliases in a Symfony application's dependency injection container."}

{"answer": "false", "explanation": "In Symfony, the service container is frozen (compiled) after boot, so calling setParameter() at runtime from a controller has no effect on the already-compiled container."}

{"answer": "no", "explanation": "In modern Symfony versions, services are private by default, not public, to encourage proper dependency injection rather than fetching services directly from the container."}

```json ⏎ { ⏎   "answer": "false", ⏎   "explanation": "Bundles work fine without a config file in config/packages because Symfony bundles ship default configuration values via their Extension class's load() method, so configuration is only necessary when you need to customize the bundle's behavior." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "In Symfony, environment variables can be injected into services.yaml using the %env(VAR_NAME)% syntax."}

{"answer": "APP_ENV" or "debug", "explanation": ...} ⏎  ⏎ Let me think about this carefully. In Symfony, debug mode is controlled by the `APP_DEBUG` environment variable (which sets the `kernel.debug` parameter). The `APP_ENV` variable controls the environment (dev, prod, etc.), and debug mode affects whether the profiler is enabled and whether Twig debugging (like the `{{ dump() }}` function and template syntax checking) is active. ⏎  ⏎ The question asks which environment variable enables debug mode - that's `APP_DEBUG`. ⏎  ⏎ {"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable controls Symfony's kernel.debug parameter, which enables the profiler and Twig debugging features."}

{"answer": "no", "explanation": "A single message in Symfony Messenger can be handled by multiple handlers, as you can register several handlers for the same message type to perform different side effects."}

{"answer": "no", "explanation": "In Symfony Messenger, the sync transport sends the message synchronously (immediately in the current process) without queuing it for a worker, unlike the async transport which dispatches messages to consumers/workers."}

```json ⏎ { ⏎   "answer": "php bin/console messenger:consume", ⏎   "explanation": "In Symfony's Messenger component, the `messenger:consume` console command starts the worker that processes messages from the queue using a specified transport and receiver." ⏎ } ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "In Symfony's Messenger component, retry strategies (retry_strategy) are indeed configured per transport in the messenger.yaml configuration."} ⏎ ```

{"answer": "no", "explanation": "Messenger uses PHP's native serialization by default, not JSON, and the JSON encoding must be explicitly configured using the JsonSerializableEncoder."}

{"answer": "no", "explanation": "The Symfony Scheduler component generates scheduled tasks/events (crons) via `schedule()` but does not use Messenger; it directly invokes closures or commands on a schedule."}

{"answer": "DoctrineMessengerTransport", "explanation": "The DoctrineMessengerTransport is Symfony's built-in Messenger transport that stores messages in database tables managed through Doctrine."}

{"answer": "yes", "explanation": "The Messenger pipeline in Symfony supports custom middleware that can be placed before or after built-in ones by implementing the MiddlewareInterface and registering it in the messenger.bus with the desired order."}

```json ⏎ {"answer": "yes", "explanation": "Symfony follows this exact release schedule, with major releases every two years and minor releases in May and November."} ⏎ ```

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

```json ⏎ {"answer": "false", "explanation": "Symfony 7.0 dropped support for PHP docblock annotations, making PHP attributes the only supported metadata format."} ⏎ ```

{"answer": "yes", "explanation": "Symfony's AssetMapper package manages CSS/JS assets directly through importmap.php without requiring Node.js or webpack."}

{"answer": "false", "explanation": "Symfony 6.4 is an LTS (Long-Term Support) release, lasting 5 years total (2 years of new features plus 3 years of bug/security fixes), while non-LTS releases like 7.x only receive bug fixes for 3 months and security fixes for 1 year."}

{"answer": "no", "explanation": "When moving to a new Symfony major version, deprecations from the previous branch are typically removed (not kept working), as major releases are when deprecated code is finally cleaned up."}

{"answer": "false", "explanation": "Not every Symfony major release includes a UPGRADE guide, as some releases (like 5.0) had no breaking changes and thus no UPGRADE documentation."}

{"answer": "symfony/asset", "explanation": "The Symfony Asset component manages asset versions and, since Symfony 6.3, handles JavaScript/CSS importmaps without requiring Node or Webpack."}

{"answer": "false", "explanation": "Symfony releases follow an annual cycle with new major versions in the second half of the year, and Symfony 8.2 would not be released until late 2028, well after the 2026-11-07 date."}

```json ⏎ { ⏎ "answer":"No", ⏎ "explanation":"As of November 2026, Symfony 7.2 would be the current stable release, since version 7.0 was already released in November 2024, and version 8.0 would be scheduled for November 2025, not November 2026." ⏎ } ⏎ ```

```json ⏎ { ⏎     "answer": "8.2", ⏎     "explanation": "Symfony 8.1 was released in November 2025, and the next version in the release cycle is 8.2." ⏎ } ⏎ ```

{"answer": "no", "explanation": "Symfony follows semantic versioning where even minor versions (like 8.2) are stable releases with backward-compatible changes, so no application rewrite is required."}

```json ⏎ {"answer": "yes", "explanation": "PHP maintains backward compatibility within major branches, so upgrading from 8.1 to 8.2 is designed to be a source-compatible release without requiring code changes."} ⏎ ```

{"answer": "8.4", "explanation": "Following Symfony's LTS release policy, the last minor version of the 8.x branch released before Symfony 9.0 is 8.4, which is scheduled as an LTS release in November 2025."}

{"answer": "false", "explanation": "Symfony 6.4 and 7.x follow the LTS model with PHP requirements matching the current LTS releases (PHP 8.1 for 6.4, PHP 8.2+ for 7.x), but there is no Symfony 8.2 release, and the Symfony project does not follow a 2-year LTS cycle with mandatory PHP upgrades tied to PHP releases in the way described."}

```json ⏎ { ⏎     "answer": "yes", ⏎     "explanation": "Per the Symfony SemVer policy, any deprecation introduced in an 8.x branch will not be removed until Symfony 9.0, as deprecations require two major versions to be removed." ⏎ } ⏎ ```

{"answer": "false", "explanation": "In Twig, {{ }} is the output tag used to echo/express values, while executing arbitrary PHP code is done with {% %} tags, not inside {{ }}."}

{"answer": "yes", "explanation": "Twig automatically escapes output using the HTML escaping strategy by default unless escaping is explicitly disabled or changed."}

{"answer": "yes", "explanation": "The Twig |e (escape) filter escapes a string for safe output, with HTML being the default escaping strategy."}

```json ⏎ { ⏎   "answer": "number_format", ⏎   "explanation": "In the twig/intl-extra package, the number_format filter uses the ICU NumberFormatter class to format a number according to a specified locale." ⏎ } ⏎ ```

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

{"answer": "yes", "explanation": "This is correct because in Twig, {{ }} is used for outputting/echoing expression values while {% %} is used for executing tags like if, for, and set."}

```json ⏎ {"answer": "no", "explanation": "Twig templates can declare their own variables using the set tag, so values are not limited to those passed from the controller."} ⏎ ```

{"answer": "dump", "explanation": "The Twig `dump` function is used to display the debug structure of a variable such as an array or object."}

{"answer": "yes", "explanation": "Bootstrap is indeed a front-end framework providing pre-built CSS and JavaScript UI components like navbars, modals, and carousels, but it is not a single-page application framework like React, Angular, or Vue."}

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

{"answer": "no", "explanation": "Modern Bootstrap (v4 and v5) is built on CSS Flexbox and uses a 12-column grid, not CSS floats with 16 columns."}

{"answer": "yes", "explanation": "Bootstrap 5's named breakpoints are indeed sm, md, lg, xl, and xxl, giving five breakpoints."}

{"answer": "yes", "explanation": "Bootstrap's spacing utilities (.mt-3, .px-2, etc.) use the spacing scale where each step corresponds to $spacer (1rem) multiplied by the utility number."}

{"answer": "data-bs-toggle", "explanation": "Bootstrap 5 uses the `data-bs-toggle` attribute (with a value like \"dropdown\" or \"modal\") to enable interactive components on an element."}

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "Bootstrap 5 dropped jQuery as a dependency and reimplements all components using plain JavaScript, unlike Bootstrap 4 which relied on jQuery." ⏎ } ⏎ ```

{"answer": "false", "explanation": "In Bootstrap 5.3+, dark mode is enabled using the data-bs-theme=\"dark\" attribute on the root element, not a .dark class."}

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

{"answer": "persist", "explanation": "The persist() method marks a new object as managed and defers SQL execution until flush() is called."}

{"answer": "no", "explanation": "In Doctrine ORM 3, EntityManager::merge() was removed and no longer exists."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is entity-oriented, using entity names and their property/field names rather than database table and column names."}

{"answer": "null", "explanation": "When no record with the given id exists, Doctrine's repository find() method returns null.", "explanation": "When no record with the given id exists, Doctrine's repository find() method returns null."}

{"answer": "no", "explanation": "DoctrineBundle does not automatically call flush(); developers must explicitly call EntityManager::flush() to persist changes to the database."}

{"answer": "yes", "explanation": "For a managed entity, Doctrine's Unit of Work tracks changes via its change detection mechanism, so a subsequent flush() will persist the modification without needing an explicit persist() call."}

{"answer": "false", "explanation": "In Doctrine ORM, remove() only marks the entity for deletion and schedules the DELETE; the actual SQL is executed during flush(), not immediately."}

{"answer": "no", "explanation": "PostgreSQL's MVCC allows readers and writers to proceed concurrently without blocking each other, which is one of its key advantages."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command (or EXPLAIN ANALYZE variations like EXPLAIN FORMAT=JSON) displays a query's execution plan without actually running it."}

{"answer": "no", "explanation": "SERIAL uses a sequence under the hood with explicit column defaults, while GENERATED ALWAYS/BY DEFAULT AS IDENTITY is the standard SQL identity column feature that does not expose the underlying sequence name the same way, so they are similar but not identical mechanisms."}

{"answer": "no", "explanation": "In PostgreSQL, a UNIQUE constraint allows multiple NULL values in a column because NULLs are considered distinct from each other, so the statement that it allows only one NULL row is false."}

{"answer": "STRING_AGG", "explanation": "STRING_AGG is the PostgreSQL aggregate function that concatenates string values from multiple rows with a specified separator using the WITHIN GROUP clause."}

{"answer": "no", "explanation": "Plain VACUUM in PostgreSQL does not return the space occupied by dead tuples to the operating system; only VACUUM FULL (or the equivalent for other systems) actually reclaims and returns space to the OS."}

{"answer": "PARTITION BY", "explanation": "The PARTITION BY clause in a window function divides rows into groups (partitions) that the function is computed over separately."}

{"answer": "no", "explanation": "The READ COMMITTED isolation level does not protect against non-repeatable reads; it only protects against dirty reads, while REPEATABLE READ is the level that guards against non-repeatable reads."}

{"answer": "yes", "explanation": "By default PostgreSQL runs in autocommit mode, so each single SQL statement is automatically wrapped in its own implicit transaction that is committed immediately."}

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

{"answer": "yes", "explanation": "Indexes speed up UPDATE and DELETE operations because they allow the database to locate the rows to modify or remove via the index rather than scanning the entire table."}

{"answer": "yes", "explanation": "SAVEPOINT allows you to create a marker within a transaction that you can later ROLL BACK TO, effectively reverting only the statements executed after that point while keeping the transaction open."}

```json ⏎ {"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query (in read-only mode) and reports both the plan and the measured execution time, unlike plain EXPLAIN which only shows the plan without executing."} ⏎ ```

{"answer": "pgvector", "explanation": "pgvector is the PostgreSQL extension that adds vector data types and indexes (IVFFAT, HNSW) for vector similarity search used in embedding-based and semantic search."}

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

```json ⏎ {"answer": "no", "explanation": "SERIALIZABLE in PostgreSQL is implemented using SERIALIZABLE violations detected via the MVCC mechanism and the SERIALIZABLE failure, not by locking the rows a transaction reads."} ⏎ ```

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

{"answer": "204", "explanation": "HTTP 204 No Content indicates a successful request that returns no response body, commonly used after DELETE operations."}

{"answer": "yes", "explanation": "DELETE is idempotent per the HTTP specification because repeating the request results in the same resource state (deleted), regardless of how many times it is sent."}

```json ⏎ { ⏎   "answer": "no", ⏎   "explanation": "The Access-Control-Allow-Origin header is sent by the server, not the client, to indicate which origins are permitted to access its resources via CORS." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "HTTP status 429 Too Many Requests is specifically defined by the RFC to indicate that a user has sent too many requests in a given amount of time, signaling a rate limit has been exceeded."}

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

```json ⏎ { ⏎   "answer": "Content-Type", ⏎   "explanation": "The Content-Type HTTP header specifies the MIME type of the request or response body, telling the client (or server) what format and kind of data is being transmitted." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not required to be idempotent, unlike PUT which is defined as idempotent in RFC 7231."}

{"answer": "false", "explanation": "Using == to compare hashes is vulnerable to timing attacks and type-juggling (where hashes starting with 0e followed by digits can evaluate as equal to 0 in PHP's loose comparison), so a constant-time comparison like hash_equals() must be used instead."}

{"answer": "yes", "explanation": "A CSRF token is indeed generated by the server, associated with the user's session, and validated server-side on state-changing requests to prevent cross-site request forgery attacks."}

```json ⏎ { ⏎   "answer": "Content-Security-Policy", ⏎   "explanation": "The Content-Security-Policy HTTP header allows site administrators to control the resources a user agent is allowed to load, enabling browser-side enforcement of the CSP policy." ⏎ } ⏎ ```

```json ⏎ {"answer": "no", "explanation": "OAuth 2.0 is an authorization framework, not an authentication protocol, because an access token grants access to resources rather than verifiably identifying who the user is."} ⏎ ```

{"answer": "no", "explanation": "XSS is prevented by output encoding/escaping when rendering data in the browser, not by validating input on the server, since storing unescaped input in a database does not itself cause XSS—vulnerability occurs at output, not input."}

{"answer": "code", "explanation": "In the OAuth 2.0 authorization code flow, the authorization code (code parameter) is returned to the redirect_uri and then exchanged for an access token via the token endpoint."}

```json ⏎ {"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": "false", "explanation": "Password salts do not need to be kept secret; they are designed to be public, and security relies on using unique salts per password to prevent rainbow table attacks, not on secrecy."}

{"answer": "false", "explanation": "PHPUnit requires test classes to extend PHPUnit\\Framework\\TestCase (or use the #[Test] attribute) so that its test lifecycle, assertions, and runner integration work properly."}

{"answer": "false", "explanation": "setUp() runs before each individual test method, not once before all tests; the one-time setup is done via a static setUpBeforeClass() method."}

{"answer": "false", "explanation": "A data provider in PHPUnit is specifically designed to supply multiple sets of arguments, allowing a single test to run multiple times with different data."}

{"answer": "expectException()", "explanation": "The expectException() method declares an expectation that an exception of the given class is thrown during a test."}

```json ⏎ { ⏎   "answer": "no", ⏎   "explanation": "The statement has it backwards: a mock verifies which methods were called on it, while a stub only returns predefined data." ⏎ } ⏎ ```

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

{"answer": "no", "explanation": "PHPUnit does allow tests to depend on other tests via the '@depends' annotation, though it is a discouraged feature."}

{"answer": "--order-by=random", "explanation": "The --order-by=random option tells PHPUnit to execute tests in a randomized order to help detect hidden test dependencies."}

{"answer": "3-4", "explanation": "intdiv(7, 2) returns 3 (truncated toward zero) and intdiv(-7, 2) returns -4, concatenating to 3-4."}

```json ⏎ {"answer": "9", "explanation": "In PHP, the exponentiation operator ** follows mathematical convention where -3 ** 2 evaluates to -9... wait, actually PHP parses this as (negation) applied: -3 ** 2 yields 9 because the ** operator has higher precedence than the unary minus... let me correct: PHP's ** operator has higher precedence than unary minus, so it computes (-3) ** 2 = 9."} ⏎ ``` ⏎  ⏎ Wait, let me verify this carefully. ⏎  ⏎ ```json ⏎ {"answer": "-9", "explanation": "In PHP, the unary minus binds tighter than the ** operator, so -3 ** 2 is parsed as -(3 ** 2) = -9."} ⏎ ```

{"answer": "false", "explanation": "The string '1e1' is treated as a numeric string (10), but since '10' is a non-numeric-looking string in this comparison context with a numeric string, PHP converts '10' to the integer 10, making them equal, so the ternary should output 'true', but '1e1' compared with '10' where one is numeric triggers float comparison making 10==10 true; however, the actual result is false because '10' is treated as string and '1e1' as numeric triggering a string-to-number conversion where '1e1' becomes 10.0 and equals 10."}

```json ⏎ {"answer": "other", "explanation": "Since 'a' is a non-numeric string, strict comparison fails against 0, and loose comparison also fails because 0 == 'a' evaluates to false, so the default case executes."} ⏎ ```

{"answer": "1bc", "explanation": "When the replacement array has string keys, strtr processes the longest matching prefix first, so 'ab' is not a prefix match at position 0 because 'a' matches first and is replaced by '1', yielding '1bc'."}

{"answer": "[hello]", "explanation": "The substr() function with a negative offset beyond the string length returns the entire string, so substr('hello', -10) returns 'hello'."}

{"answer": "k,n,m","explanation": "The array union operator (+) keeps keys from the left array ($a) and appends only the new keys from the right array ($b), so array_keys yields k, n, m."}

```json ⏎ {"answer": "yzx", "explanation": "The array is sorted by the third element (index 2) ascending: [2,'y',1], [3,'z',2], [1,'x',2], so the second-column values become y, z, x."} ⏎ ```

```json ⏎ {"answer": "4", "explanation": "The spread operator unpacks the associative array by key name, so $a=5 and $b=1, making f() return 5-1=4."} ⏎ ```

```json ⏎ {"answer": "3", "explanation": "The arrow function $f captures $p by reference (implicitly binding outer variables), and when called after $p is set to null, PHP re-binds $this to the re-created P instance at call time, so $this->v returns 3."} ⏎ ```

```json ⏎ {"answer": "B", "explanation": "The who() method uses static::class which resolves to the class at runtime, so calling it from instance B returns 'B'."} ⏎ ```

```json ⏎ { ⏎   "answer": "10", ⏎   "explanation": "The code uses property hooks (set/get) which are a PHP 8.4+ feature, and assigning 5 triggers the set hook which stores 5*2=10, then the default get hook returns it." ⏎ } ⏎ ```

```json ⏎ {"answer": "BA", "explanation": "The conflict between TA::f and TB::f is resolved so that f() uses TB's implementation (returning 'B'), while TA's f() is aliased as g() (returning 'A')."} ⏎ ```

```json ⏎ {"answer": "0", "explanation": "Each class that uses a trait gets its own independent copy of the trait's static property, so setting CX::$n does not affect CY::$n."} ⏎ ```

{"answer": "2", "explanation": "In PHP, when a finally block contains a return statement, it overrides the return value from the try block.", "explanation": "In PHP, 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, but the finally block throws a LogicException which overrides it and is then caught by the catch block, printing 'second'."}

```json ⏎ { ⏎   "answer": "N|Baz", ⏎   "explanation": "Within namespace N, Baz::class resolves to the imported App\\Foo as N\\App\\Foo is wrong—it resolves to N\\Baz (the namespace-qualified name), while \\Baz::class resolves to the root-level B\\az which doesn't exist as a class but the ::class operator just returns the string path as written, giving N for the first and B for the second, but actually Baz::class in namespace N gives N\\Baz and \\Baz::class gives B\\az so the output is N\\Baz|B\\az." ⏎ } ⏎ ```

{"answer": "noyes", "explanation": "First call: `class_exists('Foo')` resolves within namespace Ns to Ns\\Foo, which is defined, so it outputs 'yes'; second call: `class_exists('Ns\\Foo')` uses the fully-qualified name, also matching the defined class, so it outputs 'yes'."}

{"answer": "1,2,99", "explanation": "The reference $v remains bound to the last array element (index 2) after the loop, so $v = 99 overwrites $a[2]."}

```json ⏎ {"answer": "1", "explanation": "Static local variables in a method belong to the method's defining class (A), so calling inc() through B still uses A's static $n, giving the sequence 1, 2, and a final echo of 1."} ⏎ ```

```json ⏎ {"answer": "11", "explanation": "When $g->send(10) is called, the yield expression receives the value 10, so $x becomes 10, and the function returns 10 + 1 = 11, which getReturn() retrieves."} ⏎ ```

{"answer": "1,2,ok","explanation": "The yield from passes through the yielded values 1 and 2, and the return value 'ok' is captured into $r and then yielded by outer()."}

```json ⏎ {"answer": "noyes", "explanation": "The hash is created with cost 4, so password_needs_rehash returns false (no) when comparing with the same cost 4, but true (yes) when comparing with a higher cost 5."} ⏎ ```

```json ⏎ {"answer": "strict-out", "explanation": "The E_STRICT constant was removed in PHP 8.4, so the constant evaluates to 0, and (0 & 2048) === 0 is true."} ⏎ ```

```json ⏎ { ⏎   "answer": "mapped", ⏎   "explanation": "Symfony's HeaderBag normalizes header names by converting underscores to hyphens, so the HTTP_X_TOKEN request header becomes the X-Token header, which can then be retrieved with $r->headers->get('X-Token')." ⏎ } ⏎ ```

```json ⏎ {"answer": "BAC", "explanation": "Listeners execute in ascending priority order (10, then default 0, then 5), so B prints first, then A, then C."} ⏎ ```

{"answer": "same", "explanation": "The EntityManager caches managed entities by identity in its first-level cache, so two find() calls for the same identifier return the identical object instance."}

```json ⏎ {"answer": "0", "explanation": "The entity is persisted then removed before flush, so the Unit of Work schedules a delete that executes on flush, leaving the table empty."} ⏎ ```

{"answer": "1", "explanation": "count(x) counts only non-NULL values of x, and since NULL is excluded, only the value 1 is counted, returning 1."}

{"answer": "10,30,60", "explanation": "The window function computes cumulative sums of x (10, 30, 60), and string_agg concatenates them ordered by id with commas."}

{"answer": "M1M2", "explanation": "Each middleware echoes its tag before delegating to the next, so M1 runs first then M2, outputting them concatenated as M1M2."}

```json ⏎ {"answer": "11", "explanation": "Both handlers registered for Ping::class are invoked by the HandleMessageMiddleware (the second argument to HandlerDescriptor is treated as handler metadata, not a stop-propagation flag, so neither handler is skipped, yielding 1 + 10 = 11)."} ⏎ ```

```json ⏎ { ⏎   "answer": "1", ⏎   "explanation": "The first insert adds the row with a=1, and the second insert conflicts with the unique index so it does nothing, leaving exactly 1 row." ⏎ } ⏎ ```

```json ⏎ { ⏎   "answer": "2", ⏎   "explanation": "Because the unique constraint is deferrable and initially deferred, the duplicate INSERT is only checked at COMMIT time (which never happens since there's no COMMIT), so both rows remain in the uncommitted transaction and count(*) returns 2." ⏎ } ⏎ ```

```json ⏎ { ⏎   "answer": "4", ⏎   "explanation": "The filter `test_sum` matches both `test_sum` and `test_sum_abs` via regex prefix matching, each running with 3 data providers, totaling 4 test invocations." ⏎ } ⏎ ```

```json ⏎ {"answer": "2, 1", "explanation": "The test provider returns two data sets ([1] and [-1]), so both tests run; the assertion assertTrue($x > 0) passes for x=1 and fails for x=-1, resulting in exactly one failure."} ⏎ ```

{"answer": "POST", "explanation": "The -d/--data option in curl implicitly sends an HTTP POST request with the application/x-www-form-urlencoded content type."}

```json ⏎ {"answer": "GET", "explanation": "The -G flag in curl appends the -d data as query string parameters to the URL while forcing the HTTP method to GET instead of the default POST."} ⏎ ```

```json ⏎ {"answer": "invalid_client", "explanation": "Per RFC 6749 Section 5.2, when authentication fails or is unavailable (including a non-existent or unknown client_id), the authorization server returns the error code 'invalid_client'."} ⏎ ```

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

```json ⏎ {"answer": "0", "explanation": "The default filter returns false (empty) because false is considered empty by default, so 0 multiplied by 3 equals 0."} ⏎ ```

```json ⏎ {"answer": "Twig\\Error\\RuntimeError", "explanation": "The expression 'a' ~ 1 + 2 parses as ('a' ~ 1) + 2, which attempts to add an integer to the string 'a1', causing a "Cannot concat" runtime error in Twig 3.x."} ⏎ ```

```json ⏎ {"answer": "1", "explanation": "An empty string violates the NotBlank constraint, so validation returns a ConstraintViolationList containing 1 violation."} ⏎ ```

```json ⏎ {"answer": "Symfony\\Component\\Form\\FormException", "explanation": "Calling isValid() on a form before submitting any data throws a Symfony\\Component\\Form\\FormException because the form has not been submitted, so the catch block echoes the exception class name."} ⏎ ```

{"answer": "same", "explanation": "The singleton 'a' service is cached in the container, so both get() calls return the identical instance."}

```json ⏎ { ⏎   "answer": "hi Bob!", ⏎   "explanation": "The container recursively parameter substitutions: %message% resolves %greeting% which resolves %name%, producing the string 'hi Bob!'." ⏎ } ⏎ ```

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

{"answer": "text-primary", "explanation": "When two conflicting text color utility classes are applied, the one that appears later in the source order (text-primary) wins due to CSS source order specificity."}

```json ⏎ { ⏎   "answer": "2", ⏎   "explanation": "OrderService (Domain) imports PlaceOrder (Application, forbidden by Domain→Domain only) and Db (Infrastructure, forbidden by the same rule), producing 2 violations." ⏎ } ⏎ ```

```json ⏎ {"answer": "0", "explanation": "Application is allowed to use Domain, Infrastructure is allowed to use both Domain and Application, and the internal Logger reference stays within Infrastructure, so none of the deptrac rules are violated."} ⏎ ```

```json ⏎ {"answer": "10,15","explanation": "The code creates a Money instance with amount 10, adds a Money(5) to it, and outputs the original amount (10) and the summed amount (15)."} ⏎ ```

```json ⏎ { ⏎   "answer": "0", ⏎   "explanation": "The code adds 'a', then remove('a') throws a DomainException which is caught, but the unset() line after the throw never executes, so items remains with 1 element and count() returns 1." ⏎ } ⏎ ```

```json ⏎ {"answer": "hi", "explanation": "The code instantiates class C, calls the hi() method which returns the string 'hi', and echoes the result, producing 'hi'."} ⏎ ```

```json ⏎ {"answer": "yesno", "explanation": "isUninitializedLazyObject returns 'yes' while the ghost is uninitialized, and 'no' after $o->v accesses the property, which triggers the initializer and marks it initialized."} ⏎ ```

```json ⏎ { ⏎     "answer": "yes", ⏎     "explanation": "AbstractGuardAuthenticator exists in Symfony 8.x as a deprecated-but-still-present class for BC purposes, so class_exists() returns true." ⏎ } ⏎ ```

```json ⏎ {"answer": "noyes", "explanation": "In Symfony 8.1, the legacy AnnotationClassLoader was removed (annotations loading was deprecated in 6.1 and dropped in 7.0, then the class itself in 8.0), while the modern AttributeClassLoader remains available."} ⏎ ```