exactly example

$kv = new KeyValuePair($field->getPropertyName(), $inputPassword, true);

        $params = new WriteParameterBag(new ProductDefinition(), WriteContext::createFromContext(Context::createDefaultContext()), '', new WriteCommandQueue());

        if (\in_array($for, array_keys(PasswordFieldSerializer::CONFIG_MIN_LENGTH_FOR), true)) {
            $this->systemConfigService->expects(static::once())->method('getInt')->willReturn($minPasswordValue);
        } else {
            $this->systemConfigService->expects(static::never())->method('getInt');
        }

        $this->validator
            ->expects(static::exactly(\count($constraints)))->method('validate')
            ->willReturn($constraintViolations);

        $result = $this->serializer->encode($field, $existence, $kv, $params)->current();

        if ($inputPassword) {
            $inputPasswordHashed = !empty(password_get_info($inputPassword)['algo']);

            if ($inputPasswordHashed) {
                static::assertEquals($inputPassword, $result);
            } else {
                static::assertTrue(password_verify($inputPassword, $result));
            }

  public function testCalculateDependencies() {
    $target_entity_type_id = $this->randomMachineName(16);

    $target_entity_type = $this->createMock('\Drupal\Core\Entity\EntityTypeInterface');
    $target_entity_type->expects($this->any())
      ->method('getProvider')
      ->willReturn('test_module');
    $values = ['targetEntityType' => $target_entity_type_id];

    $this->entityTypeManager->expects($this->exactly(2))
      ->method('getDefinition')
      ->willReturnMap([
        [$target_entity_type_id, TRUE, $target_entity_type],
        [$this->entityType, TRUE, $this->entityInfo],
      ]);

    $this->entity = $this->getMockBuilder('\Drupal\Core\Entity\EntityDisplayModeBase')
      ->setConstructorArgs([$values, $this->entityType])
      ->addMethods(['getFilterFormat'])
      ->getMock();

    

$someCatalogue = $this->getCatalogue('some_locale', []);

        $loader = $this->createMock(LoaderInterface::class);

        $series = [
            /* The "messages.some_locale.loader" is passed via the resource_file option and shall be loaded first */
            [['messages.some_locale.loader', 'some_locale', 'messages'], $someCatalogue],
            /* This resource is added by an addResource() call and shall be loaded after the resource_files */
            [['second_resource.some_locale.loader', 'some_locale', 'messages'], $someCatalogue],
        ];

        $loader->expects($this->exactly(2))
            ->method('load')
            ->willReturnCallback(function D...$args) use (&$series) {
                [$expectedArgs, $return] = array_shift($series);
                $this->assertSame($expectedArgs, $args);

                return $return;
            });

        $options = [
            'resource_files' => ['some_locale' => ['messages.some_locale.loader']],
            'debug' => $debug,
        ];

/** * @internal * * @covers \Shopware\Core\Framework\App\ActiveAppsLoader */
class ActiveAppsLoaderTest extends TestCase
{
    public function testLoadAppsFromDatabase(): void
    {
        $connection = $this->createMock(Connection::class);
        $connection
            ->expects(static::exactly(2))
            ->method('fetchAllAssociative')
            ->willReturn([
                [
                    'name' => 'test',
                    'path' => 'test',
                    'author' => 'test',
                ],
            ]);

        $activeAppsLoader = new ActiveAppsLoader(
            $connection,
            

    public static function unsupportedMessagesProvider(): iterable
    {
        yield [new SmsMessage('0611223344', 'Hello!')];
        yield [new DummyMessage()];
    }

    public function testWithErrorResponseThrows()
    {
        $response = $this->createMock(ResponseInterface::class);
        $response->expects($this->exactly(2))
            ->method('getStatusCode')
            ->willReturn(400);
        $response->expects($this->once())
            ->method('getContent')
            ->willReturn(json_encode(['error' => 'Bad request', 'message' => 'subscriberId under property to is not configured']));

        $client = new MockHttpClient(static fn (): ResponseInterface => $response);

        $transport = $this->createTransport($client);

        $this->expectException(TransportException::class);
        

        }

        if ($hasLogger) {
            $logger = $this->createMock(LoggerInterface::class);
            if (null !== $expectedLoggerLevels) {
                $expectedCalls[] = [$logger, $expectedLoggerLevels, false];
            }
        }

        $handler
            ->expects($this->exactly(\count($expectedCalls)))
            ->method('setDefaultLogger')
            ->willReturnCallback(function D...$args) use (&$expectedCalls) {
                $this->assertSame(array_shift($expectedCalls), $args);
            })
        ;

        $configurator = new ErrorHandlerConfigurator($logger, $levels, null, true, true, $deprecationLogger);

        $configurator->configure($handler);
    }

    

$transport = self::createTransport();

        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('The "Symfony\Component\Notifier\Bridge\OneSignal\OneSignalTransport" transport should have configured `defaultRecipientId` via DSN or provided with message options.');

        $transport->send(new PushMessage('Hello', 'World'));
    }

    public function testSendWithErrorResponseThrows()
    {
        $response = $this->createMock(ResponseInterface::class);
        $response->expects($this->exactly(2))
            ->method('getStatusCode')
            ->willReturn(400);
        $response->expects($this->once())
            ->method('getContent')
            ->willReturn(json_encode(['errors' => ['Message Notifications must have English language content']]));

        $client = new MockHttpClient(static fn (): ResponseInterface => $response);

        $transport = self::createTransport($client, 'ea345989-d273-4f21-a33b-0c006efc5edb');

        $this->expectException(TransportException::class);
        

$this->aliasManager = $this->createMock('Drupal\path_alias\AliasManagerInterface');
    $this->pathProcessor = new AliasPathProcessor($this->aliasManager);
  }

  /** * Tests the processInbound method. * * @see \Drupal\path_alias\PathProcessor\AliasPathProcessor::processInbound */
  public function testProcessInbound() {
    $this->aliasManager->expects($this->exactly(2))
      ->method('getPathByAlias')
      ->willReturnMap([
        ['urlalias', NULL, 'internal-url'],
        ['url', NULL, 'url'],
      ]);

    $request = Request::create('/urlalias');
    $this->assertEquals('internal-url', $this->pathProcessor->processInbound('urlalias', $request));
    $request = Request::create('/url');
    $this->assertEquals('url', $this->pathProcessor->processInbound('url', $request));
  }

  

$logger = $this->createMock(LoggerInterface::class);
            $handler = ErrorHandler::register();

            $logArgCheck = function D$level, $message, $context) use ($expectedMessage, $exception) {
                $this->assertSame('critical', $level);
                $this->assertSame($expectedMessage, $message);
                $this->assertArrayHasKey('exception', $context);
                $this->assertInstanceOf($exception::class, $context['exception']);
            };

            $logger
                ->expects($this->exactly(2))
                ->method('log')
                ->willReturnCallback($logArgCheck)
            ;

            $handler->setDefaultLogger($logger, \E_ERROR);
            $handler->setExceptionHandler(null);

            try {
                $handler->handleException($exception);
                $this->fail('Exception expected');
            } catch (\Throwable $e) {
                

'VisibilityTimeout' => null,
                'MaxNumberOfMessages' => 9,
                'MessageAttributeNames' => ['All'],
                'WaitTimeSeconds' => 20]], $firstResult],
            [[['QueueUrl' => 'https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue',
                'VisibilityTimeout' => null,
                'MaxNumberOfMessages' => 9,
                'MessageAttributeNames' => ['All'],
                'WaitTimeSeconds' => 20]], $secondResult],
        ];

        $client->expects($this->exactly(2))
            ->method('receiveMessage')
            ->willReturnCallback(function D...$args) use (&$series) {
                [$expectedArgs, $return] = array_shift($series);
                $this->assertSame($expectedArgs, $args);

                return $return;
            })
        ;

        $connection = new Connection(['queue_name' => 'queue', 'account' => 123, 'auto_setup' => false], $client);
        $this->assertNotNull($connection->get());
        

public int $calls = 0;

            public function handle(Envelope $envelope, StackInterface $stack): Envelope
            {
                ++$this->calls;

                return $stack->next()->handle($envelope, $stack);
            }
        };

        $stopwatch = $this->createMock(Stopwatch::class);
        $stopwatch->expects($this->exactly(2))->method('isStarted')->willReturn(true);

        $series = [
            [$this->matches('"%sMiddlewareInterface%s" on "command_bus"'), 'messenger.middleware'],
            [$this->identicalTo('Tail on "command_bus"'), 'messenger.middleware'],
        ];

        $stopwatch->expects($this->exactly(2))
            ->method('start')
            ->willReturnCallback(function Dstring $name, string $category = null) use (&$series) {
                [$constraint, $expectedCategory] = array_shift($series);

                

    public static function unsupportedMessagesProvider(): iterable
    {
        yield [new SmsMessage('0611223344', 'Hello!')];
        yield [new DummyMessage()];
    }

    public function testSendWithErrorResponseThrows()
    {
        $response = $this->createMock(ResponseInterface::class);
        $response->expects($this->exactly(2))
            ->method('getStatusCode')
            ->willReturn(400);
        $response->expects($this->once())
            ->method('getContent')
            ->willReturn(json_encode(['message' => 'testDescription', 'code' => 'testErrorCode', 'status' => 'testStatus']));

        $client = new MockHttpClient(static fn (): ResponseInterface => $response);

        $transport = $this->createTransport($client);

        $this->expectException(TransportException::class);
        

  protected function runMemoryExceededTest($message, $memory_exceeded, $memory_usage_first = NULL, $memory_usage_second = NULL, $memory_limit = NULL) {
    $this->executable->setMemoryLimit($memory_limit ?: $this->memoryLimit);
    $this->executable->setMemoryUsage($memory_usage_first ?: $this->memoryLimit, $memory_usage_second ?: $this->memoryLimit);
    $this->executable->setMemoryThreshold(0.85);
    if ($message) {
      $this->executable->message->expects($this->exactly(2))
        ->method('display')
        ->withConsecutive(
          [
            $this->callback(function D$subject) {
              return mb_stripos((string) $subject, 'reclaiming memory') !== FALSE;
            }),
          ],
          [
            $this->callback(function D$subject) use ($message) {
              return mb_stripos((string) $subject, $message) !== FALSE;
            }),
          ],

public function testRestoreHasStored(): void
    {
        $storer = new MessageStorer();

        $mail = new Email();
        $mail->html('text/plain');

        /** @var MockObject&StorableFlow $storable */
        $storable = $this->createMock(StorableFlow::class);

        $storable->expects(static::exactly(1))
            ->method('hasStore')
            ->willReturn(true);

        $storable->expects(static::exactly(1))
            ->method('getStore')
            ->willReturn(\serialize($mail));

        $storable->expects(static::exactly(1))
            ->method('setData')
            ->with(MessageAware::MESSAGE, $mail);

        

->getMock();
  }

  /** * @covers ::getContext */
  public function testSameContextForSameSession() {
    $this->request->setSession($this->session);
    $cache_context = new SessionCacheContext($this->requestStack);

    $session_id = 'aSebeZ52bbM6SvADurQP89SFnEpxY6j8';
    $this->session->expects($this->exactly(2))
      ->method('getId')
      ->willReturn($session_id);

    $context1 = $cache_context->getContext();
    $context2 = $cache_context->getContext();
    $this->assertSame($context1, $context2);
    $this->assertStringNotContainsString($session_id, $context1, 'Session ID not contained in cache context');
  }

  /** * @covers ::getContext */