class FormStateDecoratorBaseTest
Same name in other branches
- 9 core/tests/Drupal/Tests/Core/Form/FormStateDecoratorBaseTest.php \Drupal\Tests\Core\Form\FormStateDecoratorBaseTest
- 8.9.x core/tests/Drupal/Tests/Core/Form/FormStateDecoratorBaseTest.php \Drupal\Tests\Core\Form\FormStateDecoratorBaseTest
- 11.x core/tests/Drupal/Tests/Core/Form/FormStateDecoratorBaseTest.php \Drupal\Tests\Core\Form\FormStateDecoratorBaseTest
@coversDefaultClass \Drupal\Core\Form\FormStateDecoratorBase
@group Form
Hierarchy
- class \Drupal\Tests\UnitTestCase extends \PHPUnit\Framework\TestCase uses \Drupal\Tests\Traits\PhpUnitWarnings, \Drupal\Tests\PhpUnitCompatibilityTrait, \Prophecy\PhpUnit\ProphecyTrait, \Symfony\Bridge\PhpUnit\ExpectDeprecationTrait, \Drupal\Tests\RandomGeneratorTrait
- class \Drupal\Tests\Core\Form\FormStateDecoratorBaseTest extends \Drupal\Tests\UnitTestCase
Expanded class hierarchy of FormStateDecoratorBaseTest
File
-
core/
tests/ Drupal/ Tests/ Core/ Form/ FormStateDecoratorBaseTest.php, line 21
Namespace
Drupal\Tests\Core\FormView source
class FormStateDecoratorBaseTest extends UnitTestCase {
/**
* The decorated form state.
*
* @var \Drupal\Core\Form\FormStateInterface|\Prophecy\Prophecy\ObjectProphecy
*/
protected $decoratedFormState;
/**
* The form state decorator base under test.
*
* @var \Drupal\Core\Form\FormStateDecoratorBase
*/
protected $formStateDecoratorBase;
/**
* {@inheritdoc}
*/
protected function setUp() : void {
parent::setUp();
$this->decoratedFormState = $this->prophesize(FormStateInterface::class);
$this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($this->decoratedFormState
->reveal());
}
/**
* Provides data to test methods that take a single boolean argument.
*/
public static function providerSingleBooleanArgument() {
return [
[
TRUE,
],
[
FALSE,
],
];
}
/**
* @covers ::setFormState
*/
public function testSetFormState() : void {
$form_state_additions = [
'foo' => 'bar',
];
$this->decoratedFormState
->setFormState($form_state_additions)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setFormState($form_state_additions));
}
/**
* @covers ::setAlwaysProcess
*
* @dataProvider providerSingleBooleanArgument
*/
public function testSetAlwaysProcess($always_process) : void {
$this->decoratedFormState
->setAlwaysProcess($always_process)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setAlwaysProcess($always_process));
}
/**
* @covers ::getAlwaysProcess
*
* @dataProvider providerSingleBooleanArgument
*/
public function testGetAlwaysProcess($always_process) : void {
$this->decoratedFormState
->getAlwaysProcess()
->willReturn($always_process)
->shouldBeCalled();
$this->assertSame($always_process, $this->formStateDecoratorBase
->getAlwaysProcess());
}
/**
* @covers ::setButtons
*/
public function testSetButtons() : void {
$buttons = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->setButtons($buttons)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setButtons($buttons));
}
/**
* @covers ::getButtons
*/
public function testGetButtons() : void {
$buttons = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->getButtons()
->willReturn($buttons)
->shouldBeCalled();
$this->assertSame($buttons, $this->formStateDecoratorBase
->getButtons());
}
/**
* @covers ::setCached
*
* @dataProvider providerSingleBooleanArgument
*/
public function testSetCached($cache) : void {
$this->decoratedFormState
->setCached($cache)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setCached($cache));
}
/**
* @covers ::isCached
*
* @dataProvider providerSingleBooleanArgument
*/
public function testIsCached($cache) : void {
$this->decoratedFormState
->isCached()
->willReturn($cache)
->shouldBeCalled();
$this->assertSame($cache, $this->formStateDecoratorBase
->isCached());
}
/**
* @covers ::setCached
*
* @dataProvider providerSingleBooleanArgument
*/
public function testSetCachedWithLogicException($cache) : void {
$this->decoratedFormState
->setCached($cache)
->willThrow(\LogicException::class);
$this->expectException(\LogicException::class);
$this->formStateDecoratorBase
->setCached($cache);
}
/**
* @covers ::disableCache
*/
public function testDisableCache() : void {
$this->decoratedFormState
->disableCache()
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->disableCache());
}
/**
* @covers ::setExecuted
*/
public function testSetExecuted() : void {
$this->decoratedFormState
->setExecuted()
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setExecuted());
}
/**
* @covers ::isExecuted
*
* @dataProvider providerSingleBooleanArgument
*
* @param bool $executed
* Any valid value for \Drupal\Core\Form\FormStateInterface::isExecuted()'s
* return value.
*/
public function testIsExecuted($executed) : void {
$this->decoratedFormState
->isExecuted()
->willReturn($executed)
->shouldBeCalled();
$this->assertSame($executed, $this->formStateDecoratorBase
->isExecuted());
}
/**
* @covers ::setGroups
*/
public function testSetGroups() : void {
$groups = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->setGroups($groups)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setGroups($groups));
}
/**
* @covers ::getGroups
*/
public function testGetGroups() : void {
$groups = [
'FOO' => 'BAR',
];
// Use PHPUnit for mocking, because Prophecy cannot mock methods that return
// by reference. See \Prophecy\Doubler\Generator\Node::getCode().
$decorated_form_state = $this->createMock(FormStateInterface::class);
$decorated_form_state->expects($this->once())
->method('getGroups')
->willReturn($groups);
$this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
$this->assertSame($groups, $this->formStateDecoratorBase
->getGroups());
}
/**
* @covers ::setHasFileElement
*
* @dataProvider providerSingleBooleanArgument
*/
public function testSetHasFileElement($has_file_element) : void {
$this->decoratedFormState
->setHasFileElement($has_file_element)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setHasFileElement($has_file_element));
}
/**
* @covers ::hasFileElement
*
* @dataProvider providerSingleBooleanArgument
*/
public function testHasFileElement($has_file_element) : void {
$this->decoratedFormState
->hasFileElement()
->willReturn($has_file_element)
->shouldBeCalled();
$this->assertSame($has_file_element, $this->formStateDecoratorBase
->hasFileElement());
}
/**
* @covers ::setLimitValidationErrors
*
* @dataProvider providerLimitValidationErrors
*/
public function testSetLimitValidationErrors($limit_validation_errors) : void {
$this->decoratedFormState
->setLimitValidationErrors($limit_validation_errors)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setLimitValidationErrors($limit_validation_errors));
}
/**
* @covers ::getLimitValidationErrors
*
* @dataProvider providerLimitValidationErrors
*/
public function testGetLimitValidationErrors($limit_validation_errors) : void {
$this->decoratedFormState
->getLimitValidationErrors()
->willReturn($limit_validation_errors)
->shouldBeCalled();
$this->assertSame($limit_validation_errors, $this->formStateDecoratorBase
->getLimitValidationErrors());
}
/**
* Provides data to self::testGetLimitValidationErrors() and self::testGetLimitValidationErrors().
*/
public static function providerLimitValidationErrors() {
return [
[
NULL,
],
[
[
[
'foo',
'bar',
'baz',
],
],
],
];
}
/**
* @covers ::setMethod
*
* @dataProvider providerSingleBooleanArgument
*/
public function testSetMethod($method) : void {
$this->decoratedFormState
->setMethod($method)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setMethod($method));
}
/**
* @covers ::isMethodType
*
* @dataProvider providerIsMethodType
*/
public function testIsMethodType($expected_return_value, $method_type) : void {
$this->decoratedFormState
->isMethodType($method_type)
->willReturn($expected_return_value)
->shouldBeCalled();
$this->assertSame($expected_return_value, $this->formStateDecoratorBase
->isMethodType($method_type));
}
/**
* Provides data to self::testIsMethodType().
*/
public static function providerIsMethodType() {
return [
[
TRUE,
'GET',
],
[
TRUE,
'POST',
],
[
FALSE,
'GET',
],
[
FALSE,
'POST',
],
];
}
/**
* @covers ::setRequestMethod
*
* @dataProvider providerSetRequestMethod
*/
public function testSetRequestMethod($method) : void {
$this->decoratedFormState
->setRequestMethod($method)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setRequestMethod($method));
}
/**
* Provides data to self::testSetMethod().
*/
public static function providerSetRequestMethod() {
return [
[
'GET',
],
[
'POST',
],
];
}
/**
* @covers ::setValidationEnforced
*
* @dataProvider providerSingleBooleanArgument
*/
public function testSetValidationEnforced($must_validate) : void {
$this->decoratedFormState
->setValidationEnforced($must_validate)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setValidationEnforced($must_validate));
}
/**
* @covers ::isValidationEnforced
*
* @dataProvider providerSingleBooleanArgument
*/
public function testIsValidationEnforced($must_validate) : void {
$this->decoratedFormState
->isValidationEnforced()
->willReturn($must_validate)
->shouldBeCalled();
$this->assertSame($must_validate, $this->formStateDecoratorBase
->isValidationEnforced());
}
/**
* @covers ::disableRedirect
*
* @dataProvider providerSingleBooleanArgument
*/
public function testDisableRedirect($no_redirect) : void {
$this->decoratedFormState
->disableRedirect($no_redirect)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->disableRedirect($no_redirect));
}
/**
* @covers ::isRedirectDisabled
*
* @dataProvider providerSingleBooleanArgument
*/
public function testIsRedirectDisabled($no_redirect) : void {
$this->decoratedFormState
->isRedirectDisabled()
->willReturn($no_redirect)
->shouldBeCalled();
$this->assertSame($no_redirect, $this->formStateDecoratorBase
->isRedirectDisabled());
}
/**
* @covers ::setProcessInput
*
* @dataProvider providerSingleBooleanArgument
*/
public function testSetProcessInput($process_input) : void {
$this->decoratedFormState
->setProcessInput($process_input)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setProcessInput($process_input));
}
/**
* @covers ::isProcessingInput
*
* @dataProvider providerSingleBooleanArgument
*/
public function testIsProcessingInput($process_input) : void {
$this->decoratedFormState
->isProcessingInput()
->willReturn($process_input)
->shouldBeCalled();
$this->assertSame($process_input, $this->formStateDecoratorBase
->isProcessingInput());
}
/**
* @covers ::setProgrammed
*
* @dataProvider providerSingleBooleanArgument
*/
public function testSetProgrammed($programmed) : void {
$this->decoratedFormState
->setProgrammed($programmed)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setProgrammed($programmed));
}
/**
* @covers ::isProgrammed
*
* @dataProvider providerSingleBooleanArgument
*/
public function testIsProgrammed($programmed) : void {
$this->decoratedFormState
->isProgrammed()
->willReturn($programmed)
->shouldBeCalled();
$this->assertSame($programmed, $this->formStateDecoratorBase
->isProgrammed());
}
/**
* @covers ::setProgrammedBypassAccessCheck
*
* @dataProvider providerSingleBooleanArgument
*/
public function testSetProgrammedBypassAccessCheck($programmed_bypass_access_check) : void {
$this->decoratedFormState
->setProgrammedBypassAccessCheck($programmed_bypass_access_check)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setProgrammedBypassAccessCheck($programmed_bypass_access_check));
}
/**
* @covers ::isBypassingProgrammedAccessChecks
*
* @dataProvider providerSingleBooleanArgument
*/
public function testIsBypassingProgrammedAccessChecks($programmed_bypass_access_check) : void {
$this->decoratedFormState
->isBypassingProgrammedAccessChecks()
->willReturn($programmed_bypass_access_check)
->shouldBeCalled();
$this->assertSame($programmed_bypass_access_check, $this->formStateDecoratorBase
->isBypassingProgrammedAccessChecks());
}
/**
* @covers ::setRebuildInfo
*/
public function testSetRebuildInfo() : void {
$rebuild_info = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->setRebuildInfo($rebuild_info)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setRebuildInfo($rebuild_info));
}
/**
* @covers ::getRebuildInfo
*/
public function testGetRebuildInfo() : void {
$rebuild_info = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->getRebuildInfo()
->willReturn($rebuild_info)
->shouldBeCalled();
$this->assertSame($rebuild_info, $this->formStateDecoratorBase
->getRebuildInfo());
}
/**
* @covers ::addRebuildInfo
*/
public function testAddRebuildInfo() : void {
$property = 'FOO';
$value = 'BAR';
$this->decoratedFormState
->addRebuildInfo($property, $value);
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->addRebuildInfo($property, $value));
}
/**
* @covers ::setStorage
*/
public function testSetStorage() : void {
$storage = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->setStorage($storage)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setStorage($storage));
}
/**
* @covers ::getStorage
*/
public function testGetStorage() : void {
$storage = [
'FOO' => 'BAR',
];
// Use PHPUnit for mocking, because Prophecy cannot mock methods that return
// by reference. See \Prophecy\Doubler\Generator\Node::getCode().
$decorated_form_state = $this->createMock(FormStateInterface::class);
$decorated_form_state->expects($this->once())
->method('getStorage')
->willReturn($storage);
$this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
$this->assertSame($storage, $this->formStateDecoratorBase
->getStorage());
}
/**
* @covers ::setSubmitHandlers
*/
public function testSetSubmitHandlers() : void {
$submit_handlers = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->setSubmitHandlers($submit_handlers)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setSubmitHandlers($submit_handlers));
}
/**
* @covers ::getSubmitHandlers
*/
public function testGetSubmitHandlers() : void {
$submit_handlers = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->getSubmitHandlers()
->willReturn($submit_handlers)
->shouldBeCalled();
$this->assertSame($submit_handlers, $this->formStateDecoratorBase
->getSubmitHandlers());
}
/**
* @covers ::setSubmitted
*/
public function testSetSubmitted() : void {
$this->decoratedFormState
->setSubmitted()
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setSubmitted());
}
/**
* @covers ::isSubmitted
*
* @dataProvider providerSingleBooleanArgument
*
* @param bool $submitted
* Any valid value for
* \Drupal\Core\Form\FormStateInterface::isSubmitted()'s return
* value.
*/
public function testIsSubmitted($submitted) : void {
$this->decoratedFormState
->isSubmitted()
->willReturn($submitted);
$this->assertSame($submitted, $this->formStateDecoratorBase
->isSubmitted());
}
/**
* @covers ::setTemporary
*/
public function testSetTemporary() : void {
$temporary = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->setTemporary($temporary)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setTemporary($temporary));
}
/**
* @covers ::getTemporary
*/
public function testGetTemporary() : void {
$temporary = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->getTemporary()
->willReturn($temporary)
->shouldBeCalled();
$this->assertSame($temporary, $this->formStateDecoratorBase
->getTemporary());
}
/**
* @covers ::setTemporaryValue
*
* @dataProvider providerSetTemporaryValue
*
* @param string $key
* Any valid value for
* \Drupal\Core\Form\FormStateInterface::setTemporaryValue()'s $key
* argument.
* @param mixed $value
* Any valid value for
* \Drupal\Core\Form\FormStateInterface::setTemporaryValue()'s $value
* argument.
*/
public function testSetTemporaryValue($key, $value) : void {
$this->decoratedFormState
->setTemporaryValue($key, $value)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setTemporaryValue($key, $value));
}
/**
* Provides data to self::testSetTemporaryValue().
*/
public static function providerSetTemporaryValue() {
return [
[
'FOO',
'BAR',
],
[
'FOO',
NULL,
],
];
}
/**
* @covers ::getTemporaryValue
*
* @dataProvider providerGetTemporaryValue
*
* @param string $key
* Any valid value for
* \Drupal\Core\Form\FormStateInterface::getTemporaryValue()'s $key
* argument.
* @param mixed $value
* (optional) Any valid value for
* \Drupal\Core\Form\FormStateInterface::getTemporaryValue()'s return
* value.
*/
public function testGetTemporaryValue($key, $value = NULL) : void {
// Use PHPUnit for mocking, because Prophecy cannot mock methods that return
// by reference. See \Prophecy\Doubler\Generator\Node::getCode().
$decorated_form_state = $this->createMock(FormStateInterface::class);
$decorated_form_state->expects($this->once())
->method('getTemporaryValue')
->with($key)
->willReturn($value);
$this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
$this->assertSame($value, $this->formStateDecoratorBase
->getTemporaryValue($key));
}
/**
* Provides data to self::testGetTemporaryValue().
*/
public static function providerGetTemporaryValue() {
return [
[
TRUE,
'FOO',
'BAR',
],
[
TRUE,
'FOO',
NULL,
],
];
}
/**
* @covers ::hasTemporaryValue
*
* @dataProvider providerHasTemporaryValue
*
* @param bool $exists
* Any valid value for
* \Drupal\Core\Form\FormStateInterface::hasTemporaryValue()'s return
* value.
* @param string $key
* Any valid value for
* \Drupal\Core\Form\FormStateInterface::hasTemporaryValue()'s $key
* argument.
*/
public function testHasTemporaryValue($exists, $key) : void {
$this->decoratedFormState
->hasTemporaryValue($key)
->willReturn($exists)
->shouldBeCalled();
$this->assertSame($exists, $this->formStateDecoratorBase
->hasTemporaryValue($key));
}
/**
* Provides data to self::testHasTemporaryValue().
*/
public static function providerHasTemporaryValue() {
return [
[
TRUE,
'FOO',
],
[
FALSE,
'FOO',
],
];
}
/**
* @covers ::setTriggeringElement
*/
public function testSetTriggeringElement() : void {
$triggering_element = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->setTriggeringElement($triggering_element)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setTriggeringElement($triggering_element));
}
/**
* @covers ::getTriggeringElement
*/
public function testGetTriggeringElement() : void {
$triggering_element = [
'FOO' => 'BAR',
];
// Use PHPUnit for mocking, because Prophecy cannot mock methods that return
// by reference. See \Prophecy\Doubler\Generator\Node::getCode().
$decorated_form_state = $this->createMock(FormStateInterface::class);
$decorated_form_state->expects($this->once())
->method('getTriggeringElement')
->willReturn($triggering_element);
$this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
$this->assertSame($triggering_element, $this->formStateDecoratorBase
->getTriggeringElement());
}
/**
* @covers ::setValidateHandlers
*/
public function testSetValidateHandlers() : void {
$validate_handlers = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->setValidateHandlers($validate_handlers)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setValidateHandlers($validate_handlers));
}
/**
* @covers ::getValidateHandlers
*/
public function testGetValidateHandlers() : void {
$validate_handlers = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->getValidateHandlers()
->willReturn($validate_handlers)
->shouldBeCalled();
$this->assertSame($validate_handlers, $this->formStateDecoratorBase
->getValidateHandlers());
}
/**
* @covers ::setValidationComplete
*
* @dataProvider providerSingleBooleanArgument
*
* @param bool $complete
* Any valid value for
* \Drupal\Core\Form\FormStateInterface::setValidationComplete()'s $complete
* argument.
*/
public function testSetValidationComplete($complete) : void {
$this->decoratedFormState
->setValidationComplete($complete)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setValidationComplete($complete));
}
/**
* @covers ::isValidationComplete
*
* @dataProvider providerSingleBooleanArgument
*
* @param bool $complete
* Any valid value for
* \Drupal\Core\Form\FormStateInterface::isValidationComplete()'s return
* value.
*/
public function testIsValidationComplete($complete) : void {
$this->decoratedFormState
->isValidationComplete()
->willReturn($complete)
->shouldBeCalled();
$this->assertSame($complete, $this->formStateDecoratorBase
->isValidationComplete());
}
/**
* @covers ::loadInclude
*
* @dataProvider providerLoadInclude
*
* @param string|false $expected
* Any valid value for \Drupal\Core\Form\FormStateInterface::loadInclude()'s
* return value.
* @param string $module
* Any valid value for \Drupal\Core\Form\FormStateInterface::loadInclude()'s
* $module argument.
* @param string $type
* Any valid value for \Drupal\Core\Form\FormStateInterface::loadInclude()'s
* $type argument.
* @param string|null $name
* Any valid value for \Drupal\Core\Form\FormStateInterface::loadInclude()'s
* $name argument.
*/
public function testLoadInclude($expected, $module, $type, $name) : void {
$this->decoratedFormState
->loadInclude($module, $type, $name)
->willReturn($expected)
->shouldBeCalled();
$this->assertSame($expected, $this->formStateDecoratorBase
->loadInclude($module, $type, $name));
}
/**
* Provides data to self::testLoadInclude().
*/
public static function providerLoadInclude() {
return [
// Existing files.
[
__FILE__,
'foo',
'inc',
'foo',
],
[
__FILE__,
'foo',
'inc',
'foo.admin',
],
[
__FILE__,
'bar',
'inc',
'bar',
],
// Non-existent files.
[
FALSE,
'foo',
'php',
'foo',
],
[
FALSE,
'bar',
'php',
'foo',
],
];
}
/**
* @covers ::getCacheableArray
*/
public function testGetCacheableArray() : void {
$cacheable_array = [
'foo' => 'bar',
];
$this->decoratedFormState
->getCacheableArray()
->willReturn($cacheable_array)
->shouldBeCalled();
$this->assertSame($cacheable_array, $this->formStateDecoratorBase
->getCacheableArray());
}
/**
* @covers ::setCompleteForm
*/
public function testSetCompleteForm() : void {
$complete_form = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->setCompleteForm($complete_form)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setCompleteForm($complete_form));
}
/**
* @covers ::getCompleteForm
*/
public function testGetCompleteForm() : void {
$complete_form = [
'FOO' => 'BAR',
];
// Use PHPUnit for mocking, because Prophecy cannot mock methods that return
// by reference. See \Prophecy\Doubler\Generator\Node::getCode().
$decorated_form_state = $this->createMock(FormStateInterface::class);
$decorated_form_state->expects($this->once())
->method('getCompleteForm')
->willReturn($complete_form);
$this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setCompleteForm($complete_form));
$this->assertSame($complete_form, $this->formStateDecoratorBase
->getCompleteForm());
}
/**
* @covers ::set
*
* @dataProvider providerSet
*
* @param string $key
* Any valid value for \Drupal\Core\Form\FormStateInterface::set()'s $key
* argument.
* @param mixed $value
* Any valid value for \Drupal\Core\Form\FormStateInterface::set()'s $value
* argument.
*/
public function testSet($key, $value) : void {
$this->decoratedFormState
->set($key, $value)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->set($key, $value));
}
/**
* Provides data to self::testSet().
*/
public static function providerSet() : array {
return [
[
'FOO',
'BAR',
],
[
'FOO',
NULL,
],
];
}
/**
* @covers ::get
*
* @dataProvider providerGet
*
* @param string $key
* Any valid value for \Drupal\Core\Form\FormStateInterface::get()'s $key
* argument.
* @param mixed $value
* (optional) Any valid value for
* \Drupal\Core\Form\FormStateInterface::get()'s return value.
*/
public function testGet($key, $value = NULL) : void {
// Use PHPUnit for mocking, because Prophecy cannot mock methods that return
// by reference. See \Prophecy\Doubler\Generator\Node::getCode().
$decorated_form_state = $this->createMock(FormStateInterface::class);
$decorated_form_state->expects($this->once())
->method('get')
->with($key)
->willReturn($value);
$this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
$this->assertSame($value, $this->formStateDecoratorBase
->get($key));
}
/**
* Provides data to self::testGet().
*/
public static function providerGet() : array {
return [
[
'FOO',
'BAR',
],
[
'FOO',
NULL,
],
];
}
/**
* @covers ::has
*
* @dataProvider providerHas
*
* @param bool $exists
* Any valid value for \Drupal\Core\Form\FormStateInterface::has()'s return
* value.
* @param string $key
* Any valid value for \Drupal\Core\Form\FormStateInterface::has()'s $key
* argument.
*/
public function testHas($exists, $key) : void {
$this->decoratedFormState
->has($key)
->willReturn($exists)
->shouldBeCalled();
$this->assertSame($exists, $this->formStateDecoratorBase
->has($key));
}
/**
* Provides data to self::testHas().
*/
public static function providerHas() : array {
return [
[
TRUE,
'FOO',
],
[
FALSE,
'FOO',
],
];
}
/**
* @covers ::setBuildInfo
*/
public function testSetBuildInfo() : void {
$build_info = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->setBuildInfo($build_info)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setBuildInfo($build_info));
}
/**
* @covers ::getBuildInfo
*/
public function testGetBuildInfo() : void {
$build_info = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->getBuildInfo()
->willReturn($build_info)
->shouldBeCalled();
$this->assertSame($build_info, $this->formStateDecoratorBase
->getBuildInfo());
}
/**
* @covers ::addBuildInfo
*/
public function testAddBuildInfo() : void {
$property = 'FOO';
$value = 'BAR';
$this->decoratedFormState
->addBuildInfo($property, $value)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->addBuildInfo($property, $value));
}
/**
* @covers ::setUserInput
*/
public function testSetUserInput() : void {
$user_input = [
'FOO' => 'BAR',
];
$this->decoratedFormState
->setUserInput($user_input)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setUserInput($user_input));
}
/**
* @covers ::getUserInput
*/
public function testGetUserInput() : void {
$user_input = [
'FOO' => 'BAR',
];
// Use PHPUnit for mocking, because Prophecy cannot mock methods that return
// by reference. See \Prophecy\Doubler\Generator\Node::getCode().
$decorated_form_state = $this->createMock(FormStateInterface::class);
$decorated_form_state->expects($this->once())
->method('getUserInput')
->willReturn($user_input);
$this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
$this->assertSame($user_input, $this->formStateDecoratorBase
->getUserInput());
}
/**
* @covers ::getValues
*/
public function testGetValues() : void {
$values = [
'FOO' => 'BAR',
];
// Use PHPUnit for mocking, because Prophecy cannot mock methods that return
// by reference. See \Prophecy\Doubler\Generator\Node::getCode().
$decorated_form_state = $this->createMock(FormStateInterface::class);
$decorated_form_state->expects($this->once())
->method('getValues')
->willReturn($values);
$this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
$this->assertSame($values, $this->formStateDecoratorBase
->getValues());
}
/**
* @covers ::getValue
*/
public function testGetValue() : void {
$key = 'FOO';
$value = 'BAR';
// Use PHPUnit for mocking, because Prophecy cannot mock methods that return
// by reference. See \Prophecy\Doubler\Generator\Node::getCode().
$decorated_form_state = $this->createMock(FormStateInterface::class);
$decorated_form_state->expects($this->once())
->method('getValue')
->with($key, $value)
->willReturn($value);
$this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
$this->assertSame($value, $this->formStateDecoratorBase
->getValue($key, $value));
}
/**
* @covers ::setValues
*/
public function testSetValues() : void {
$values = [
'foo' => 'Foo',
'bar' => [
'Bar',
],
];
$this->decoratedFormState
->setValues($values)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setValues($values));
}
/**
* @covers ::setValue
*/
public function testSetValue() : void {
$key = 'FOO';
$value = 'BAR';
$this->decoratedFormState
->setValue($key, $value)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setValue($key, $value));
}
/**
* @covers ::unsetValue
*/
public function testUnsetValue() : void {
$key = 'FOO';
$this->decoratedFormState
->unsetValue($key)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->unsetValue($key));
}
/**
* @covers ::hasValue
*/
public function testHasValue() : void {
$key = [
'foo',
'bar',
];
$has = TRUE;
$this->decoratedFormState
->hasValue($key)
->willReturn($has)
->shouldBeCalled();
$this->assertSame($has, $this->formStateDecoratorBase
->hasValue($key));
}
/**
* @covers ::isValueEmpty
*/
public function testIsValueEmpty() : void {
$key = [
'foo',
'bar',
];
$is_empty = TRUE;
$this->decoratedFormState
->isValueEmpty($key)
->willReturn($is_empty)
->shouldBeCalled();
$this->assertSame($is_empty, $this->formStateDecoratorBase
->isValueEmpty($key));
}
/**
* @covers ::setValueForElement
*/
public function testSetValueForElement() : void {
$element = [
'#type' => 'foo',
];
$value = 'BAR';
$this->decoratedFormState
->setValueForElement($element, $value)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setValueForElement($element, $value));
}
/**
* @covers ::setResponse
*/
public function testSetResponse() : void {
$response = $this->createMock(Response::class);
$this->decoratedFormState
->setResponse($response)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setResponse($response));
}
/**
* @covers ::getResponse
*/
public function testGetResponse() : void {
$response = $this->createMock(Response::class);
$this->decoratedFormState
->getResponse()
->willReturn($response)
->shouldBeCalled();
$this->assertSame($response, $this->formStateDecoratorBase
->getResponse());
}
/**
* @covers ::setRedirect
*/
public function testSetRedirect() : void {
$route_name = 'foo';
$route_parameters = [
'bar' => 'baz',
];
$options = [
'qux' => 'foo',
];
$this->decoratedFormState
->setRedirect($route_name, $route_parameters, $options)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setRedirect($route_name, $route_parameters, $options));
}
/**
* @covers ::setRedirectUrl
*/
public function testSetRedirectUrl() : void {
$url = new Url('foo');
$this->decoratedFormState
->setRedirectUrl($url)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setRedirectUrl($url));
}
/**
* @covers ::getRedirect
*
* @dataProvider providerGetRedirect
*
* @param bool $expected
* Any valid value for \Drupal\Core\Form\FormStateInterface::getRedirect()'s
* return value.
*/
public function testGetRedirect($expected) : void {
$this->decoratedFormState
->getRedirect()
->willReturn($expected)
->shouldBeCalled();
$this->assertSame($expected, $this->formStateDecoratorBase
->getRedirect());
}
/**
* Provides data to self::testGetRedirect().
*/
public static function providerGetRedirect() {
return [
[
NULL,
],
[
FALSE,
],
[
new Url('foo'),
],
[
new RedirectResponse('http://example.com'),
],
];
}
/**
* @covers ::setErrorByName
*/
public function testSetErrorByName() : void {
$name = 'foo';
$message = 'bar';
$this->decoratedFormState
->setErrorByName($name, $message)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setErrorByName($name, $message));
}
/**
* @covers ::setError
*/
public function testSetError() : void {
$element = [
'#foo' => 'bar',
];
$message = 'bar';
$this->decoratedFormState
->setError($element, $message)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setError($element, $message));
}
/**
* @covers ::clearErrors
*/
public function testClearErrors() : void {
$this->decoratedFormState
->clearErrors()
->shouldBeCalled();
$this->formStateDecoratorBase
->clearErrors();
}
/**
* @covers ::getError
*/
public function testGetError() : void {
$element = [
'#foo' => 'bar',
];
$message = 'bar';
$this->decoratedFormState
->getError($element)
->willReturn($message)
->shouldBeCalled();
$this->assertSame($message, $this->formStateDecoratorBase
->getError($element));
}
/**
* @covers ::getErrors
*/
public function testGetErrors() : void {
$errors = [
'foo' => 'bar',
];
$this->decoratedFormState
->getErrors()
->willReturn($errors)
->shouldBeCalled();
$this->assertSame($errors, $this->formStateDecoratorBase
->getErrors());
}
/**
* @covers ::setRebuild
*
* @dataProvider providerSingleBooleanArgument
*
* @param bool $rebuild
* Any valid value for \Drupal\Core\Form\FormStateInterface::setRebuild()'s
* $rebuild argument.
*/
public function testSetRebuild($rebuild) : void {
$this->decoratedFormState
->setRebuild($rebuild)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setRebuild($rebuild));
}
/**
* @covers ::isRebuilding
*
* @dataProvider providerSingleBooleanArgument
*/
public function testIsRebuilding($rebuild) : void {
$this->decoratedFormState
->isRebuilding()
->willReturn($rebuild)
->shouldBeCalled();
$this->assertSame($rebuild, $this->formStateDecoratorBase
->isRebuilding());
}
/**
* @covers ::setInvalidToken
*
* @dataProvider providerSingleBooleanArgument
*/
public function testSetInvalidToken($expected) : void {
$this->decoratedFormState
->setInvalidToken($expected)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setInvalidToken($expected));
}
/**
* @covers ::hasInvalidToken
*
* @dataProvider providerSingleBooleanArgument
*/
public function testHasInvalidToken($expected) : void {
$this->decoratedFormState
->hasInvalidToken()
->willReturn($expected)
->shouldBeCalled();
$this->assertSame($expected, $this->formStateDecoratorBase
->hasInvalidToken());
}
/**
* @covers ::prepareCallback
*
* @dataProvider providerPrepareCallback
*/
public function testPrepareCallback($unprepared_callback, callable $prepared_callback) : void {
$this->decoratedFormState
->prepareCallback(Argument::is($unprepared_callback))
->willReturn($prepared_callback)
->shouldBeCalled();
$this->assertSame($prepared_callback, $this->formStateDecoratorBase
->prepareCallback($unprepared_callback));
}
/**
* Provides data to self::testPrepareCallback().
*/
public static function providerPrepareCallback() : array {
$function = 'sleep';
$shorthand_form_method = '::submit()';
$closure = function () {
};
$static_method_string = __METHOD__;
$static_method_array = [
__CLASS__,
__FUNCTION__,
];
$object_method_array = [
new static(),
__FUNCTION__,
];
return [
// A shorthand form method is generally expanded to become a method on an
// object.
[
$shorthand_form_method,
$object_method_array,
],
// Functions, closures, and static method calls generally remain the same.
[
$function,
$function,
],
[
$closure,
$closure,
],
[
$static_method_string,
$static_method_string,
],
[
$static_method_array,
$static_method_array,
],
];
}
/**
* @covers ::setFormObject
*/
public function testSetFormObject() : void {
$form = $this->createMock(FormInterface::class);
$this->decoratedFormState
->setFormObject($form)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setFormObject($form));
}
/**
* @covers ::getFormObject
*/
public function testGetFormObject() : void {
$form = $this->createMock(FormInterface::class);
$this->decoratedFormState
->getFormObject()
->willReturn($form)
->shouldBeCalled();
$this->assertSame($form, $this->formStateDecoratorBase
->getFormObject());
}
/**
* @covers ::setCleanValueKeys
*/
public function testSetCleanValueKeys() : void {
$keys = [
'BAR',
];
$this->decoratedFormState
->setCleanValueKeys($keys)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->setCleanValueKeys($keys));
}
/**
* @covers ::getCleanValueKeys
*/
public function testGetCleanValueKeys() : void {
$keys = [
'BAR',
];
$this->decoratedFormState
->getCleanValueKeys()
->willReturn($keys)
->shouldBeCalled();
$this->assertSame($keys, $this->formStateDecoratorBase
->getCleanValueKeys());
}
/**
* @covers ::addCleanValueKey
*/
public function testAddCleanValueKey() : void {
$key = 'BAR';
$this->decoratedFormState
->addCleanValueKey($key)
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->addCleanValueKey($key));
}
/**
* @covers ::cleanValues
*/
public function testCleanValues() : void {
$this->decoratedFormState
->cleanValues()
->shouldBeCalled();
$this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase
->cleanValues());
}
}
Members
Title Sort descending | Deprecated | Modifiers | Object type | Summary | Overriden Title | Overrides |
---|---|---|---|---|---|---|
FormStateDecoratorBaseTest::$decoratedFormState | protected | property | The decorated form state. | |||
FormStateDecoratorBaseTest::$formStateDecoratorBase | protected | property | The form state decorator base under test. | |||
FormStateDecoratorBaseTest::providerGet | public static | function | Provides data to self::testGet(). | |||
FormStateDecoratorBaseTest::providerGetRedirect | public static | function | Provides data to self::testGetRedirect(). | |||
FormStateDecoratorBaseTest::providerGetTemporaryValue | public static | function | Provides data to self::testGetTemporaryValue(). | |||
FormStateDecoratorBaseTest::providerHas | public static | function | Provides data to self::testHas(). | |||
FormStateDecoratorBaseTest::providerHasTemporaryValue | public static | function | Provides data to self::testHasTemporaryValue(). | |||
FormStateDecoratorBaseTest::providerIsMethodType | public static | function | Provides data to self::testIsMethodType(). | |||
FormStateDecoratorBaseTest::providerLimitValidationErrors | public static | function | Provides data to self::testGetLimitValidationErrors() and self::testGetLimitValidationErrors(). | |||
FormStateDecoratorBaseTest::providerLoadInclude | public static | function | Provides data to self::testLoadInclude(). | |||
FormStateDecoratorBaseTest::providerPrepareCallback | public static | function | Provides data to self::testPrepareCallback(). | |||
FormStateDecoratorBaseTest::providerSet | public static | function | Provides data to self::testSet(). | |||
FormStateDecoratorBaseTest::providerSetRequestMethod | public static | function | Provides data to self::testSetMethod(). | |||
FormStateDecoratorBaseTest::providerSetTemporaryValue | public static | function | Provides data to self::testSetTemporaryValue(). | |||
FormStateDecoratorBaseTest::providerSingleBooleanArgument | public static | function | Provides data to test methods that take a single boolean argument. | |||
FormStateDecoratorBaseTest::setUp | protected | function | Overrides UnitTestCase::setUp | |||
FormStateDecoratorBaseTest::testAddBuildInfo | public | function | @covers ::addBuildInfo | |||
FormStateDecoratorBaseTest::testAddCleanValueKey | public | function | @covers ::addCleanValueKey | |||
FormStateDecoratorBaseTest::testAddRebuildInfo | public | function | @covers ::addRebuildInfo | |||
FormStateDecoratorBaseTest::testCleanValues | public | function | @covers ::cleanValues | |||
FormStateDecoratorBaseTest::testClearErrors | public | function | @covers ::clearErrors | |||
FormStateDecoratorBaseTest::testDisableCache | public | function | @covers ::disableCache | |||
FormStateDecoratorBaseTest::testDisableRedirect | public | function | @covers ::disableRedirect | |||
FormStateDecoratorBaseTest::testGet | public | function | @covers ::get | |||
FormStateDecoratorBaseTest::testGetAlwaysProcess | public | function | @covers ::getAlwaysProcess | |||
FormStateDecoratorBaseTest::testGetBuildInfo | public | function | @covers ::getBuildInfo | |||
FormStateDecoratorBaseTest::testGetButtons | public | function | @covers ::getButtons | |||
FormStateDecoratorBaseTest::testGetCacheableArray | public | function | @covers ::getCacheableArray | |||
FormStateDecoratorBaseTest::testGetCleanValueKeys | public | function | @covers ::getCleanValueKeys | |||
FormStateDecoratorBaseTest::testGetCompleteForm | public | function | @covers ::getCompleteForm | |||
FormStateDecoratorBaseTest::testGetError | public | function | @covers ::getError | |||
FormStateDecoratorBaseTest::testGetErrors | public | function | @covers ::getErrors | |||
FormStateDecoratorBaseTest::testGetFormObject | public | function | @covers ::getFormObject | |||
FormStateDecoratorBaseTest::testGetGroups | public | function | @covers ::getGroups | |||
FormStateDecoratorBaseTest::testGetLimitValidationErrors | public | function | @covers ::getLimitValidationErrors | |||
FormStateDecoratorBaseTest::testGetRebuildInfo | public | function | @covers ::getRebuildInfo | |||
FormStateDecoratorBaseTest::testGetRedirect | public | function | @covers ::getRedirect | |||
FormStateDecoratorBaseTest::testGetResponse | public | function | @covers ::getResponse | |||
FormStateDecoratorBaseTest::testGetStorage | public | function | @covers ::getStorage | |||
FormStateDecoratorBaseTest::testGetSubmitHandlers | public | function | @covers ::getSubmitHandlers | |||
FormStateDecoratorBaseTest::testGetTemporary | public | function | @covers ::getTemporary | |||
FormStateDecoratorBaseTest::testGetTemporaryValue | public | function | @covers ::getTemporaryValue | |||
FormStateDecoratorBaseTest::testGetTriggeringElement | public | function | @covers ::getTriggeringElement | |||
FormStateDecoratorBaseTest::testGetUserInput | public | function | @covers ::getUserInput | |||
FormStateDecoratorBaseTest::testGetValidateHandlers | public | function | @covers ::getValidateHandlers | |||
FormStateDecoratorBaseTest::testGetValue | public | function | @covers ::getValue | |||
FormStateDecoratorBaseTest::testGetValues | public | function | @covers ::getValues | |||
FormStateDecoratorBaseTest::testHas | public | function | @covers ::has | |||
FormStateDecoratorBaseTest::testHasFileElement | public | function | @covers ::hasFileElement | |||
FormStateDecoratorBaseTest::testHasInvalidToken | public | function | @covers ::hasInvalidToken | |||
FormStateDecoratorBaseTest::testHasTemporaryValue | public | function | @covers ::hasTemporaryValue | |||
FormStateDecoratorBaseTest::testHasValue | public | function | @covers ::hasValue | |||
FormStateDecoratorBaseTest::testIsBypassingProgrammedAccessChecks | public | function | @covers ::isBypassingProgrammedAccessChecks | |||
FormStateDecoratorBaseTest::testIsCached | public | function | @covers ::isCached | |||
FormStateDecoratorBaseTest::testIsExecuted | public | function | @covers ::isExecuted | |||
FormStateDecoratorBaseTest::testIsMethodType | public | function | @covers ::isMethodType | |||
FormStateDecoratorBaseTest::testIsProcessingInput | public | function | @covers ::isProcessingInput | |||
FormStateDecoratorBaseTest::testIsProgrammed | public | function | @covers ::isProgrammed | |||
FormStateDecoratorBaseTest::testIsRebuilding | public | function | @covers ::isRebuilding | |||
FormStateDecoratorBaseTest::testIsRedirectDisabled | public | function | @covers ::isRedirectDisabled | |||
FormStateDecoratorBaseTest::testIsSubmitted | public | function | @covers ::isSubmitted | |||
FormStateDecoratorBaseTest::testIsValidationComplete | public | function | @covers ::isValidationComplete | |||
FormStateDecoratorBaseTest::testIsValidationEnforced | public | function | @covers ::isValidationEnforced | |||
FormStateDecoratorBaseTest::testIsValueEmpty | public | function | @covers ::isValueEmpty | |||
FormStateDecoratorBaseTest::testLoadInclude | public | function | @covers ::loadInclude | |||
FormStateDecoratorBaseTest::testPrepareCallback | public | function | @covers ::prepareCallback | |||
FormStateDecoratorBaseTest::testSet | public | function | @covers ::set | |||
FormStateDecoratorBaseTest::testSetAlwaysProcess | public | function | @covers ::setAlwaysProcess | |||
FormStateDecoratorBaseTest::testSetBuildInfo | public | function | @covers ::setBuildInfo | |||
FormStateDecoratorBaseTest::testSetButtons | public | function | @covers ::setButtons | |||
FormStateDecoratorBaseTest::testSetCached | public | function | @covers ::setCached | |||
FormStateDecoratorBaseTest::testSetCachedWithLogicException | public | function | @covers ::setCached | |||
FormStateDecoratorBaseTest::testSetCleanValueKeys | public | function | @covers ::setCleanValueKeys | |||
FormStateDecoratorBaseTest::testSetCompleteForm | public | function | @covers ::setCompleteForm | |||
FormStateDecoratorBaseTest::testSetError | public | function | @covers ::setError | |||
FormStateDecoratorBaseTest::testSetErrorByName | public | function | @covers ::setErrorByName | |||
FormStateDecoratorBaseTest::testSetExecuted | public | function | @covers ::setExecuted | |||
FormStateDecoratorBaseTest::testSetFormObject | public | function | @covers ::setFormObject | |||
FormStateDecoratorBaseTest::testSetFormState | public | function | @covers ::setFormState | |||
FormStateDecoratorBaseTest::testSetGroups | public | function | @covers ::setGroups | |||
FormStateDecoratorBaseTest::testSetHasFileElement | public | function | @covers ::setHasFileElement | |||
FormStateDecoratorBaseTest::testSetInvalidToken | public | function | @covers ::setInvalidToken | |||
FormStateDecoratorBaseTest::testSetLimitValidationErrors | public | function | @covers ::setLimitValidationErrors | |||
FormStateDecoratorBaseTest::testSetMethod | public | function | @covers ::setMethod | |||
FormStateDecoratorBaseTest::testSetProcessInput | public | function | @covers ::setProcessInput | |||
FormStateDecoratorBaseTest::testSetProgrammed | public | function | @covers ::setProgrammed | |||
FormStateDecoratorBaseTest::testSetProgrammedBypassAccessCheck | public | function | @covers ::setProgrammedBypassAccessCheck | |||
FormStateDecoratorBaseTest::testSetRebuild | public | function | @covers ::setRebuild | |||
FormStateDecoratorBaseTest::testSetRebuildInfo | public | function | @covers ::setRebuildInfo | |||
FormStateDecoratorBaseTest::testSetRedirect | public | function | @covers ::setRedirect | |||
FormStateDecoratorBaseTest::testSetRedirectUrl | public | function | @covers ::setRedirectUrl | |||
FormStateDecoratorBaseTest::testSetRequestMethod | public | function | @covers ::setRequestMethod | |||
FormStateDecoratorBaseTest::testSetResponse | public | function | @covers ::setResponse | |||
FormStateDecoratorBaseTest::testSetStorage | public | function | @covers ::setStorage | |||
FormStateDecoratorBaseTest::testSetSubmitHandlers | public | function | @covers ::setSubmitHandlers | |||
FormStateDecoratorBaseTest::testSetSubmitted | public | function | @covers ::setSubmitted | |||
FormStateDecoratorBaseTest::testSetTemporary | public | function | @covers ::setTemporary | |||
FormStateDecoratorBaseTest::testSetTemporaryValue | public | function | @covers ::setTemporaryValue | |||
FormStateDecoratorBaseTest::testSetTriggeringElement | public | function | @covers ::setTriggeringElement | |||
FormStateDecoratorBaseTest::testSetUserInput | public | function | @covers ::setUserInput | |||
FormStateDecoratorBaseTest::testSetValidateHandlers | public | function | @covers ::setValidateHandlers | |||
FormStateDecoratorBaseTest::testSetValidationComplete | public | function | @covers ::setValidationComplete | |||
FormStateDecoratorBaseTest::testSetValidationEnforced | public | function | @covers ::setValidationEnforced | |||
FormStateDecoratorBaseTest::testSetValue | public | function | @covers ::setValue | |||
FormStateDecoratorBaseTest::testSetValueForElement | public | function | @covers ::setValueForElement | |||
FormStateDecoratorBaseTest::testSetValues | public | function | @covers ::setValues | |||
FormStateDecoratorBaseTest::testUnsetValue | public | function | @covers ::unsetValue | |||
PhpUnitWarnings::$deprecationWarnings | private static | property | Deprecation warnings from PHPUnit to raise with @trigger_error(). | |||
PhpUnitWarnings::addWarning | public | function | Converts PHPUnit deprecation warnings to E_USER_DEPRECATED. | |||
RandomGeneratorTrait::getRandomGenerator | protected | function | Gets the random generator for the utility methods. | |||
RandomGeneratorTrait::randomMachineName | protected | function | Generates a unique random string containing letters and numbers. | |||
RandomGeneratorTrait::randomObject | public | function | Generates a random PHP object. | |||
RandomGeneratorTrait::randomString | public | function | Generates a pseudo-random string of ASCII characters of codes 32 to 126. | |||
RandomGeneratorTrait::randomStringValidate | Deprecated | public | function | Callback for random string validation. | ||
UnitTestCase::$root | protected | property | The app root. | 1 | ||
UnitTestCase::getClassResolverStub | protected | function | Returns a stub class resolver. | |||
UnitTestCase::getConfigFactoryStub | public | function | Returns a stub config factory that behaves according to the passed array. | |||
UnitTestCase::getConfigStorageStub | public | function | Returns a stub config storage that returns the supplied configuration. | |||
UnitTestCase::getContainerWithCacheTagsInvalidator | protected | function | Sets up a container with a cache tags invalidator. | |||
UnitTestCase::getStringTranslationStub | public | function | Returns a stub translation manager that just returns the passed string. | |||
UnitTestCase::setUpBeforeClass | public static | function | ||||
UnitTestCase::__get | public | function |
Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.