assertFalse example

  public function testSupportsNormalization($primitive_data, $expected) {
    $this->assertTrue($this->normalizer->supportsNormalization($primitive_data));
  }

  /** * @covers ::supportsNormalization */
  public function testSupportsNormalizationFail() {
    // Test that an object not implementing PrimitiveInterface fails.     $this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
  }

  /** * @covers ::normalize * @dataProvider dataProviderPrimitiveData */
  public function testNormalize($primitive_data, $expected) {
    $this->assertSame($expected, $this->normalizer->normalize($primitive_data));
  }

  /** * Data provider for testNormalize(). */

JS;
    $this->assertJsCondition($javascript);

    // Ensure that \Drupal\Tests\UiHelperTrait::isTestUsingGuzzleClient() works     // as expected.     $this->assertFalse($this->isTestUsingGuzzleClient());
  }

  public function testAssertJsCondition() {
    $this->drupalGet('<front>');
    $session = $this->getSession();

    $session->resizeWindow(500, 300);
    $javascript = <<<JS (function(){ var w = window, d = document, e = d.documentElement, g = d.getElementsByTagName('body')[0], x = w.innerWidth || e.clientWidth || g.clientWidth, y = w.innerHeight || e.clientHeight|| g.clientHeight; return x == 400 && y == 300; }())

$this->getAppLifecycle()->install($manifest, false, $context);

        $criteria = (new Criteria())
            ->addFilter(new EqualsFilter('name', 'test'));

        /** @var AppEntity $app */
        $app = $this->getAppRepository()
            ->search($criteria, $context)
            ->first();

        static::assertFalse((new DomainsDeltaProvider())->hasDelta($manifest, $app));

        $app->setAllowedHosts([]);

        static::assertTrue((new DomainsDeltaProvider())->hasDelta($manifest, $app));
    }

    private function getAppLifecycle(): AppLifecycle
    {
        return $this->getContainer()->get(AppLifecycle::class);
    }

    

$input->bind(new InputDefinition([new InputOption('bar', 'b', InputOption::VALUE_NONE), new InputOption('foo', 'f', InputOption::VALUE_OPTIONAL), new InputArgument('arg')]));
        $this->assertSame('argval', $input->getFirstArgument());
    }

    public function testHasParameterOption()
    {
        $input = new ArgvInput(['cli.php', '-f', 'foo']);
        $this->assertTrue($input->hasParameterOption('-f'), '->hasParameterOption() returns true if the given short option is in the raw input');

        $input = new ArgvInput(['cli.php', '-etest']);
        $this->assertTrue($input->hasParameterOption('-e'), '->hasParameterOption() returns true if the given short option is in the raw input');
        $this->assertFalse($input->hasParameterOption('-s'), '->hasParameterOption() returns true if the given short option is in the raw input');

        $input = new ArgvInput(['cli.php', '--foo', 'foo']);
        $this->assertTrue($input->hasParameterOption('--foo'), '->hasParameterOption() returns true if the given short option is in the raw input');

        $input = new ArgvInput(['cli.php', 'foo']);
        $this->assertFalse($input->hasParameterOption('--foo'), '->hasParameterOption() returns false if the given short option is not in the raw input');

        $input = new ArgvInput(['cli.php', '--foo=bar']);
        $this->assertTrue($input->hasParameterOption('--foo'), '->hasParameterOption() returns true if the given option with provided value is in the raw input');
    }

    

$this->createFieldWithStorage('_rev', 'entity_test_rev', 'entity_test_rev');
  }

  /** * Makes sure a field definition is exposed for a configurable field. */
  public function testBundleFieldDefinition() {
    $definitions = \Drupal::service('entity_field.manager')->getFieldDefinitions($this->entityType, $this->bundle);
    $this->assertTrue(isset($definitions[$this->fieldTestData->field->getName()]));
    $this->assertInstanceOf(FieldDefinitionInterface::class, $definitions[$this->fieldTestData->field->getName()]);
    // Make sure fields on other entity types are not exposed.     $this->assertFalse(isset($definitions[$this->fieldTestData->field_rev->getName()]));
  }

  /** * Makes sure a field storage definition is exposed for a configurable field. */
  public function testFieldStorageDefinition() {
    $field_storage_definitions = \Drupal::service('entity_field.manager')->getFieldStorageDefinitions($this->entityType);
    $this->assertTrue(isset($field_storage_definitions[$this->fieldTestData->field->getName()]));
    $this->assertInstanceOf(FieldStorageDefinitionInterface::class, $field_storage_definitions[$this->fieldTestData->field->getName()]);
    // Make sure storages on other entity types are not exposed.     $this->assertFalse(isset($field_storage_definitions[$this->fieldTestData->field_rev->getName()]));
  }

    // see: https://www.drupal.org/node/2484991     $session = new Session();
    $request->setSession($session);

    $token = 'VALID_TOKEN';
    $session->set('pass_reset_1', $token);

    // Set token in query string.     $request->query->set('pass-reset-token', $token);
    $form = $this->buildAccountForm('default');
    // User shouldn't see current password field.     $this->assertFalse($form['account']['current_pass']['#access']);

    $request->query->set('pass-reset-token', NULL);
    $request->attributes->set('pass-reset-token', $token);
    $form = $this->buildAccountForm('default');
    $this->assertTrue($form['account']['current_pass']['#access']);
  }

  /** * Builds the user account form for a given operation. * * @param string $operation * The entity operation; one of 'register' or 'default'. * * @return array * The form array. */

$this->extension = new DataCollectorTypeExtension(new FormDataCollector(new FormDataExtractor()));
    }

    public function testGetExtendedType()
    {
        $this->assertEquals(['Symfony\Component\Form\Extension\Core\Type\FormType'], $this->extension::getExtendedTypes());
    }

    public function testBuildForm()
    {
        $eventDispatcher = new EventDispatcher();
        $this->assertFalse($eventDispatcher->hasListeners(FormEvents::PRE_SET_DATA));
        $this->assertFalse($eventDispatcher->hasListeners(FormEvents::POST_SET_DATA));
        $this->assertFalse($eventDispatcher->hasListeners(FormEvents::PRE_SUBMIT));
        $this->assertFalse($eventDispatcher->hasListeners(FormEvents::SUBMIT));
        $this->assertFalse($eventDispatcher->hasListeners(FormEvents::POST_SUBMIT));

        $this->extension->buildForm(new FormBuilder(null, null, $eventDispatcher, new FormFactory(new FormRegistry([], new ResolvedFormTypeFactory()))), []);

        $this->assertFalse($eventDispatcher->hasListeners(FormEvents::PRE_SET_DATA));
        $this->assertTrue($eventDispatcher->hasListeners(FormEvents::POST_SET_DATA));
        $this->assertFalse($eventDispatcher->hasListeners(FormEvents::PRE_SUBMIT));
        $this->assertFalse($eventDispatcher->hasListeners(FormEvents::SUBMIT));
        

$this->dispatcher,
            new StockUpdateFilterProvider([]),
        );

        $writeContextMock = $this->getMockBuilder(WriteContext::class)
            ->disableOriginalConstructor()
            ->getMock();

        $event = new PreWriteValidationEvent($writeContextMock, $commands);
        $stockSubscriber->triggerChangeSet($event);

        static::assertFalse($commands[0]->requiresChangeSet());
    }

    public function testTriggerChangeSetWithNonChangeSetAwareCommand(): void
    {
        $nonChangeSetAwareCommand = $this->createMock(WriteCommand::class);

        $commands = [$nonChangeSetAwareCommand];

        $writeContextMock = $this->getMockBuilder(WriteContext::class)
            ->disableOriginalConstructor()
            ->getMock();

        

$this->drupalGet('node/add');
    $this->assertSession()->statusCodeEquals(200);

    // Ensure that there are no pending updates after installation.     $this->drupalLogin($this->rootUser);
    $this->drupalGet('update.php/selection');
    $this->updateRequirementsProblem();
    $this->drupalGet('update.php/selection');
    $this->assertSession()->pageTextContains('No pending updates.');

    // Ensure that there are no pending entity updates after installation.     $this->assertFalse($this->container->get('entity.definition_update_manager')->needsUpdates(), 'After installation, entity schema is up to date.');

    // Make sure the optional image styles are not installed.     $this->drupalGet('admin/config/media/image-styles');
    $this->assertSession()->pageTextNotContains('Max 325x325');
    $this->assertSession()->pageTextNotContains('Max 650x650');
    $this->assertSession()->pageTextNotContains('Max 1300x1300');
    $this->assertSession()->pageTextNotContains('Max 2600x2600');

    // Make sure the optional image styles are installed after enabling     // the responsive_image module.     \Drupal::service('module_installer')->install(['responsive_image']);
    

// Save the entity to invalidate caches.     $this->entity->save();
    $uuid = $this->entity->uuid();
    $language = $this->entity->language()->getId();
    $cache = \Drupal::service('render_cache')->get([
      '#cache' => [
        'keys' => ['node--camelids', $uuid, $language],
        'bin' => 'jsonapi_normalizations',
      ],
    ]);
    // After saving the entity the normalization should not be cached.     $this->assertFalse($cache);
    // @todo Remove line below in favor of commented line in https://www.drupal.org/project/drupal/issues/2878463.     $url = Url::fromRoute(sprintf('jsonapi.%s.individual', static::$resourceTypeName), ['entity' => $uuid]);
    // $url = $this->entity->toUrl('jsonapi');     $request_options = $this->getAuthenticationRequestOptions();
    $request_options[RequestOptions::QUERY] = ['fields' => ['node--camelids' => 'title']];
    $this->request('GET', $url, $request_options);
    // Ensure the normalization cache is being incrementally built. After     // requesting the title, only the title is in the cache.     $this->assertNormalizedFieldsAreCached(['title']);
    $request_options[RequestOptions::QUERY] = ['fields' => ['node--camelids' => 'field_rest_test']];
    $this->request('GET', $url, $request_options);
    

public function testAllFeatureFlagsAreActivated(): void
    {
        $_SERVER['V6_5_0_0'] = false;

        $this->extension->executeBeforeTest(__METHOD__);

        static::assertTrue(Feature::isActive('v6.5.0.0'));

        $this->extension->executeAfterTest(__METHOD__, 0.1);

        static::assertArrayHasKey('V6_5_0_0', $_SERVER);
        static::assertFalse($_SERVER['V6_5_0_0']);
    }

    public function testIsDoesNotAffectNonPureUnitTests(): void
    {
        $testMethod = '\Shopware\Tests\Integration\Core\BasicOrderProductTest::testBasicOrderFlow';

        $featureFlagConfig = Feature::getRegisteredFeatures();
        $server = $_SERVER;

        $this->extension->executeBeforeTest($testMethod);

        

  /** * @covers ::accepts * @dataProvider dataSetProvider */
  public function testAccepts($expected, $actual, bool $accepts_result, $equals_result): void {
    if ($accepts_result) {
      $this->assertTrue($this->comparator->accepts($expected, $actual));
    }
    else {
      $this->assertFalse($this->comparator->accepts($expected, $actual));
    }
  }

  /** * @covers ::assertEquals * @dataProvider dataSetProvider */
  public function testAssertEquals($expected, $actual, bool $accepts_result, $equals_result): void {
    try {
      $this->assertNull($this->comparator->assertEquals($expected, $actual));
      $this->assertTrue($equals_result);
    }

->willReturn(new StockDataCollection([$stock1, $stock2]));

        $event = new SalesChannelEntityLoadedEvent(
            $this->createMock(SalesChannelProductDefinition::class),
            [$p1, $p2],
            $this->createMock(SalesChannelContext::class)
        );

        $subscriber->salesChannelLoaded($event);

        static::assertEquals(10, $p1->getStock());
        static::assertFalse($p1->getAvailable());
        static::assertEquals(5, $p1->getMinPurchase());
        static::assertTrue($p1->hasExtension('stock_data'));
        static::assertSame($stock1, $p1->getExtension('stock_data'));

        static::assertEquals(12, $p2->getStock());
        static::assertTrue($p2->getAvailable());
        static::assertNull($p2->getMinPurchase());
        static::assertTrue($p2->hasExtension('stock_data'));
        static::assertSame($stock2, $p2->getExtension('stock_data'));
    }

    

// We need to clear the statically cached field definitions to account for     // fields that have been created by API calls in this test, since they exist     // in a separate memory space from the web server.     $this->container->get('entity_field.manager')->clearCachedFieldDefinitions();
    // Assert that the field and field storage were created.     $media_type = MediaType::load($machine_name);
    $source = $media_type->getSource();
    /** @var \Drupal\field\FieldConfigInterface $source_field */
    $source_field = $source->getSourceFieldDefinition($media_type);
    $this->assertInstanceOf(FieldConfigInterface::class, $source_field);
    $this->assertFalse($source_field->isNew(), 'Source field was saved.');
    /** @var \Drupal\field\FieldStorageConfigInterface $storage */
    $storage = $source_field->getFieldStorageDefinition();
    $this->assertFalse($storage->isNew(), 'Source field storage definition was saved.');
    $this->assertFalse($storage->isLocked(), 'Source field storage definition was not locked.');

    /** @var \Drupal\media\MediaTypeInterface $media_type_storage */
    $media_type_storage = $this->container->get('entity_type.manager')->getStorage('media_type');
    $this->testMediaType = $media_type_storage->load(strtolower($name));

    // Check if all action links exist.     $assert_session->linkByHrefExists('admin/structure/media/add');
    

/** * @dataProvider getData */
    public function test(string $requestScheme, array|string $matcherScheme, bool $isMatch)
    {
        $httpRequest = Request::create('');
        $httpsRequest = Request::create('', 'get', [], [], [], ['HTTPS' => 'on']);

        if ($isMatch) {
            if ('https' === $requestScheme) {
                $matcher = new SchemeRequestMatcher($matcherScheme);
                $this->assertFalse($matcher->matches($httpRequest));
                $this->assertTrue($matcher->matches($httpsRequest));
            } else {
                $matcher = new SchemeRequestMatcher($matcherScheme);
                $this->assertFalse($matcher->matches($httpsRequest));
                $this->assertTrue($matcher->matches($httpRequest));
            }
        } else {
            $matcher = new SchemeRequestMatcher($matcherScheme);
            $this->assertFalse($matcher->matches($httpRequest));
            $this->assertFalse($matcher->matches($httpsRequest));
        }
    }