www.aleph1.co.uk Git - yaffs-website/blob - web/core/tests/Drupal/Tests/Core/Form/FormStateDecoratorBaseTest.php

   1 <?php
   2
   3 namespace Drupal\Tests\Core\Form;
   4
   5 use Drupal\Core\Form\FormInterface;
   6 use Drupal\Core\Form\FormStateDecoratorBase;
   7 use Drupal\Core\Form\FormStateInterface;
   8 use Drupal\Core\Url;
   9 use Drupal\Tests\UnitTestCase;
  10 use Symfony\Component\HttpFoundation\RedirectResponse;
  11 use Symfony\Component\HttpFoundation\Response;
  12
  13 /**
  14  * @coversDefaultClass \Drupal\Core\Form\FormStateDecoratorBase
  15  *
  16  * @group Form
  17  */
  18 class FormStateDecoratorBaseTest extends UnitTestCase {
  19
  20   /**
  21    * The decorated form state.
  22    *
  23    * @var \Drupal\Core\Form\FormStateInterface|\Prophecy\Prophecy\ObjectProphecy
  24    */
  25   protected $decoratedFormState;
  26
  27   /**
  28    * The form state decorator base under test.
  29    *
  30    * @var \Drupal\Core\Form\FormStateDecoratorBase
  31    */
  32   protected $formStateDecoratorBase;
  33
  34   /**
  35    * {@inheritdoc}
  36    */
  37   public function setUp() {
  38     parent::setUp();
  39
  40     $this->decoratedFormState = $this->prophesize(FormStateInterface::class);
  41
  42     $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($this->decoratedFormState->reveal());
  43   }
  44
  45   /**
  46    * Provides data to test methods that take a single boolean argument.
  47    */
  48   public function providerSingleBooleanArgument() {
  49     return [
  50       [TRUE],
  51       [FALSE],
  52     ];
  53   }
  54
  55   /**
  56    * @covers ::setFormState
  57    */
  58   public function testSetFormState() {
  59     $form_state_additions = [
  60       'foo' => 'bar',
  61     ];
  62
  63     $this->decoratedFormState->setFormState($form_state_additions)
  64       ->shouldBeCalled();
  65
  66     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setFormState($form_state_additions));
  67   }
  68
  69   /**
  70    * @covers ::setAlwaysProcess
  71    *
  72    * @dataProvider providerSingleBooleanArgument
  73    *
  74    * @param bool $always_process
  75    */
  76   public function testSetAlwaysProcess($always_process) {
  77     $this->decoratedFormState->setAlwaysProcess($always_process)
  78       ->shouldBeCalled();
  79
  80     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setAlwaysProcess($always_process));
  81   }
  82
  83   /**
  84    * @covers ::getAlwaysProcess
  85    *
  86    * @dataProvider providerSingleBooleanArgument
  87    *
  88    * @param bool $always_process
  89    */
  90   public function testGetAlwaysProcess($always_process) {
  91     $this->decoratedFormState->getAlwaysProcess()
  92       ->willReturn($always_process)
  93       ->shouldBeCalled();
  94
  95     $this->assertSame($always_process, $this->formStateDecoratorBase->getAlwaysProcess());
  96   }
  97
  98   /**
  99    * @covers ::setButtons
 100    */
 101   public function testSetButtons() {
 102     $buttons = [
 103       'FOO' => 'BAR',
 104     ];
 105
 106     $this->decoratedFormState->setButtons($buttons)
 107       ->shouldBeCalled();
 108
 109     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setButtons($buttons));
 110   }
 111
 112   /**
 113    * @covers ::getButtons
 114    */
 115   public function testGetButtons() {
 116     $buttons = [
 117       'FOO' => 'BAR',
 118     ];
 119
 120     $this->decoratedFormState->getButtons()
 121       ->willReturn($buttons)
 122       ->shouldBeCalled();
 123
 124     $this->assertSame($buttons, $this->formStateDecoratorBase->getButtons());
 125   }
 126
 127   /**
 128    * @covers ::setCached
 129    *
 130    * @dataProvider providerSingleBooleanArgument
 131    *
 132    * @param bool $cache
 133    */
 134   public function testSetCached($cache) {
 135     $this->decoratedFormState->setCached($cache)
 136       ->shouldBeCalled();
 137
 138     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setCached($cache));
 139   }
 140
 141   /**
 142    * @covers ::isCached
 143    *
 144    * @dataProvider providerSingleBooleanArgument
 145    *
 146    * @param bool $cache
 147    */
 148   public function testIsCached($cache) {
 149     $this->decoratedFormState->isCached()
 150       ->willReturn($cache)
 151       ->shouldBeCalled();
 152     $this->assertSame($cache, $this->formStateDecoratorBase->isCached());
 153   }
 154
 155   /**
 156    * @covers ::setCached
 157    *
 158    * @dataProvider providerSingleBooleanArgument
 159    *
 160    * @param bool $cache
 161    */
 162   public function testSetCachedWithLogicException($cache) {
 163     $this->decoratedFormState->setCached($cache)
 164       ->willThrow(\LogicException::class);
 165     $this->setExpectedException(\LogicException::class);
 166     $this->formStateDecoratorBase->setCached($cache);
 167   }
 168
 169   /**
 170    * @covers ::disableCache
 171    */
 172   public function testDisableCache() {
 173     $this->decoratedFormState->disableCache()
 174       ->shouldBeCalled();
 175
 176     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->disableCache());
 177   }
 178
 179   /**
 180    * @covers ::setExecuted
 181    */
 182   public function testSetExecuted() {
 183     $this->decoratedFormState->setExecuted()
 184       ->shouldBecalled();
 185
 186     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setExecuted());
 187   }
 188
 189   /**
 190    * @covers ::isExecuted
 191    *
 192    * @dataProvider providerSingleBooleanArgument
 193    *
 194    * @param bool $executed
 195    */
 196   public function testIsExecuted($executed) {
 197     $this->decoratedFormState->isExecuted()
 198       ->willReturn($executed)
 199       ->shouldBeCalled();
 200
 201     $this->assertSame($executed, $this->formStateDecoratorBase->isExecuted());
 202   }
 203
 204   /**
 205    * @covers ::setGroups
 206    */
 207   public function testSetGroups() {
 208     $groups = [
 209       'FOO' => 'BAR',
 210     ];
 211
 212     $this->decoratedFormState->setGroups($groups)
 213       ->shouldBeCalled();
 214
 215     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setGroups($groups));
 216   }
 217
 218   /**
 219    * @covers ::getGroups
 220    */
 221   public function testGetGroups() {
 222     $groups = [
 223       'FOO' => 'BAR',
 224     ];
 225
 226     // Use PHPUnit for mocking, because Prophecy cannot mock methods that return
 227     // by reference. See \Prophecy\Doubler\Generator\Node::getCode().
 228     $decorated_form_state = $this->getMock(FormStateInterface::class);
 229     $decorated_form_state->expects($this->once())
 230       ->method('getGroups')
 231       ->willReturn($groups);
 232
 233     $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
 234
 235     $this->assertSame($groups, $this->formStateDecoratorBase->getGroups());
 236   }
 237
 238   /**
 239    * @covers ::setHasFileElement
 240    *
 241    * @dataProvider providerSingleBooleanArgument
 242    *
 243    * @param bool $has_file_element
 244    */
 245   public function testSetHasFileElement($has_file_element) {
 246     $this->decoratedFormState->setHasFileElement($has_file_element)
 247       ->shouldBeCalled();
 248
 249     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setHasFileElement($has_file_element));
 250   }
 251
 252   /**
 253    * @covers ::hasFileElement
 254    *
 255    * @dataProvider providerSingleBooleanArgument
 256    *
 257    * @param bool $has_file_element
 258    */
 259   public function testHasFileElement($has_file_element) {
 260     $this->decoratedFormState->hasFileElement()
 261       ->willReturn($has_file_element)
 262       ->shouldBeCalled();
 263
 264     $this->assertSame($has_file_element, $this->formStateDecoratorBase->hasFileElement());
 265   }
 266
 267   /**
 268    * @covers ::setLimitValidationErrors
 269    *
 270    * @dataProvider providerLimitValidationErrors
 271    *
 272    * @param array[]|null $limit_validation_errors
 273    *   Any valid value for
 274    *   \Drupal\Core\Form\FormStateInterface::setLimitValidationErrors()'s
 275    *   $limit_validation_errors argument;
 276    */
 277   public function testSetLimitValidationErrors($limit_validation_errors) {
 278     $this->decoratedFormState->setLimitValidationErrors($limit_validation_errors)
 279       ->shouldBecalled();
 280
 281     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setLimitValidationErrors($limit_validation_errors));
 282   }
 283
 284   /**
 285    * @covers ::getLimitValidationErrors
 286    *
 287    * @dataProvider providerLimitValidationErrors
 288    *
 289    * @param array[]|null $limit_validation_errors
 290    *   Any valid vlaue for
 291    *   \Drupal\Core\Form\FormStateInterface::getLimitValidationErrors()'s
 292    *   return value;
 293    */
 294   public function testGetLimitValidationErrors($limit_validation_errors) {
 295     $this->decoratedFormState->getLimitValidationErrors()
 296       ->willReturn($limit_validation_errors)
 297       ->shouldBeCalled();
 298
 299     $this->assertSame($limit_validation_errors, $this->formStateDecoratorBase->getLimitValidationErrors());
 300   }
 301
 302   /**
 303    * Provides data to self::testGetLimitValidationErrors() and self::testGetLimitValidationErrors().
 304    */
 305   public function providerLimitValidationErrors() {
 306     return [
 307       [NULL],
 308       [
 309         [
 310           ['foo', 'bar', 'baz'],
 311         ],
 312       ],
 313     ];
 314   }
 315
 316   /**
 317    * @covers ::setMethod
 318    *
 319    * @dataProvider providerSingleBooleanArgument
 320    *
 321    * @param bool $method
 322    */
 323   public function testSetMethod($method) {
 324     $this->decoratedFormState->setMethod($method)
 325       ->shouldBecalled();
 326
 327     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setMethod($method));
 328   }
 329
 330   /**
 331    * @covers ::isMethodType
 332    *
 333    * @dataProvider providerIsMethodType
 334    *
 335    * @param bool $expected_return_value
 336    * @param string $method_type
 337    *   Either "GET" or "POST".
 338    */
 339   public function testIsMethodType($expected_return_value, $method_type) {
 340     $this->decoratedFormState->isMethodType($method_type)
 341       ->willReturn($expected_return_value)
 342       ->shouldBecalled();
 343
 344     $this->assertSame($expected_return_value, $this->formStateDecoratorBase->isMethodType($method_type));
 345   }
 346
 347   /**
 348    * Provides data to self::testIsMethodType().
 349    */
 350   public function providerIsMethodType() {
 351     return [
 352       [TRUE, 'GET'],
 353       [TRUE, 'POST'],
 354       [FALSE, 'GET'],
 355       [FALSE, 'POST'],
 356     ];
 357   }
 358
 359   /**
 360    * @covers ::setRequestMethod
 361    *
 362    * @dataProvider providerSetRequestMethod
 363    *
 364    * @param bool $method
 365    */
 366   public function testSetRequestMethod($method) {
 367     $this->decoratedFormState->setRequestMethod($method)
 368       ->shouldBeCalled();
 369
 370     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setRequestMethod($method));
 371   }
 372
 373   /**
 374    * Provides data to self::testSetMethod().
 375    */
 376   public function providerSetRequestMethod() {
 377     return [
 378       ['GET'],
 379       ['POST'],
 380     ];
 381   }
 382
 383   /**
 384    * @covers ::setValidationEnforced
 385    *
 386    * @dataProvider providerSingleBooleanArgument
 387    *
 388    * @param bool $must_validate
 389    */
 390   public function testSetValidationEnforced($must_validate) {
 391     $this->decoratedFormState->setValidationEnforced($must_validate)
 392       ->shouldBeCalled();
 393
 394     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValidationEnforced($must_validate));
 395   }
 396
 397   /**
 398    * @covers ::isValidationEnforced
 399    *
 400    * @dataProvider providerSingleBooleanArgument
 401    *
 402    * @param bool $must_validate
 403    */
 404   public function testIsValidationEnforced($must_validate) {
 405     $this->decoratedFormState->isValidationEnforced()
 406       ->willReturn($must_validate)
 407       ->shouldBecalled();
 408
 409     $this->assertSame($must_validate, $this->formStateDecoratorBase->isValidationEnforced());
 410   }
 411
 412   /**
 413    * @covers ::disableRedirect
 414    *
 415    * @dataProvider providerSingleBooleanArgument
 416    *
 417    * @param bool $no_redirect
 418    */
 419   public function testDisableRedirect($no_redirect) {
 420     $this->decoratedFormState->disableRedirect($no_redirect)
 421       ->shouldBeCalled();
 422
 423     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->disableRedirect($no_redirect));
 424   }
 425
 426   /**
 427    * @covers ::isRedirectDisabled
 428    *
 429    * @dataProvider providerSingleBooleanArgument
 430    *
 431    * @param bool $no_redirect
 432    */
 433   public function testIsRedirectDisabled($no_redirect) {
 434     $this->decoratedFormState->isRedirectDisabled()
 435       ->willReturn($no_redirect)
 436       ->shouldBeCalled();
 437
 438     $this->assertSame($no_redirect, $this->formStateDecoratorBase->isRedirectDisabled());
 439   }
 440
 441   /**
 442    * @covers ::setProcessInput
 443    *
 444    * @dataProvider providerSingleBooleanArgument
 445    *
 446    * @param bool $process_input
 447    */
 448   public function testSetProcessInput($process_input) {
 449     $this->decoratedFormState->setProcessInput($process_input)
 450       ->shouldBeCalled();
 451
 452     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setProcessInput($process_input));
 453   }
 454
 455   /**
 456    * @covers ::isProcessingInput
 457    *
 458    * @dataProvider providerSingleBooleanArgument
 459    *
 460    * @param bool $process_input
 461    */
 462   public function testIsProcessingInput($process_input) {
 463     $this->decoratedFormState->isProcessingInput()
 464       ->willReturn($process_input)
 465       ->shouldBecalled();
 466
 467     $this->assertSame($process_input, $this->formStateDecoratorBase->isProcessingInput());
 468   }
 469
 470   /**
 471    * @covers ::setProgrammed
 472    *
 473    * @dataProvider providerSingleBooleanArgument
 474    *
 475    * @param bool $programmed
 476    */
 477   public function testSetProgrammed($programmed) {
 478     $this->decoratedFormState->setProgrammed($programmed)
 479       ->shouldBecalled();
 480
 481     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setProgrammed($programmed));
 482   }
 483
 484   /**
 485    * @covers ::isProgrammed
 486    *
 487    * @dataProvider providerSingleBooleanArgument
 488    *
 489    * @param bool $programmed
 490    */
 491   public function testIsProgrammed($programmed) {
 492     $this->decoratedFormState->isProgrammed()
 493       ->willReturn($programmed)
 494       ->shouldBecalled();
 495
 496     $this->assertSame($programmed, $this->formStateDecoratorBase->isProgrammed());
 497   }
 498
 499   /**
 500    * @covers ::setProgrammedBypassAccessCheck
 501    *
 502    * @dataProvider providerSingleBooleanArgument
 503    *
 504    * @param bool $programmed_bypass_access_check
 505    */
 506   public function testSetProgrammedBypassAccessCheck($programmed_bypass_access_check) {
 507     $this->decoratedFormState->setProgrammedBypassAccessCheck($programmed_bypass_access_check)
 508       ->shouldBecalled();
 509
 510     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setProgrammedBypassAccessCheck($programmed_bypass_access_check));
 511   }
 512
 513   /**
 514    * @covers ::isBypassingProgrammedAccessChecks
 515    *
 516    * @dataProvider providerSingleBooleanArgument
 517    *
 518    * @param bool $programmed_bypass_access_check
 519    */
 520   public function testIsBypassingProgrammedAccessChecks($programmed_bypass_access_check) {
 521     $this->decoratedFormState->isBypassingProgrammedAccessChecks()
 522       ->willReturn($programmed_bypass_access_check)
 523       ->shouldBeCalled();
 524
 525     $this->assertSame($programmed_bypass_access_check, $this->formStateDecoratorBase->isBypassingProgrammedAccessChecks());
 526   }
 527
 528   /**
 529    * @covers ::setRebuildInfo
 530    */
 531   public function testSetRebuildInfo() {
 532     $rebuild_info = [
 533       'FOO' => 'BAR',
 534     ];
 535
 536     $this->decoratedFormState->setRebuildInfo($rebuild_info)
 537       ->shouldBeCalled();
 538
 539     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setRebuildInfo($rebuild_info));
 540   }
 541
 542   /**
 543    * @covers ::getRebuildInfo
 544    */
 545   public function testGetRebuildInfo() {
 546     $rebuild_info = [
 547       'FOO' => 'BAR',
 548     ];
 549
 550     $this->decoratedFormState->getRebuildInfo()
 551       ->willReturn($rebuild_info)
 552       ->shouldBeCalled();
 553
 554     $this->assertSame($rebuild_info, $this->formStateDecoratorBase->getRebuildInfo());
 555   }
 556
 557   /**
 558    * @covers ::addRebuildInfo
 559    */
 560   public function testAddRebuildInfo() {
 561     $property = 'FOO';
 562     $value = 'BAR';
 563
 564     $this->decoratedFormState->addRebuildInfo($property, $value);
 565
 566     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->addRebuildInfo($property, $value));
 567   }
 568
 569   /**
 570    * @covers ::setStorage
 571    */
 572   public function testSetStorage() {
 573     $storage = [
 574       'FOO' => 'BAR',
 575     ];
 576
 577     $this->decoratedFormState->setStorage($storage)
 578       ->shouldBeCalled();
 579
 580     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setStorage($storage));
 581   }
 582
 583   /**
 584    * @covers ::getStorage
 585    */
 586   public function testGetStorage() {
 587     $storage = [
 588       'FOO' => 'BAR',
 589     ];
 590
 591     // Use PHPUnit for mocking, because Prophecy cannot mock methods that return
 592     // by reference. See \Prophecy\Doubler\Generator\Node::getCode().
 593     $decorated_form_state = $this->getMock(FormStateInterface::class);
 594     $decorated_form_state->expects($this->once())
 595       ->method('getStorage')
 596       ->willReturn($storage);
 597
 598     $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
 599
 600     $this->assertSame($storage, $this->formStateDecoratorBase->getStorage());
 601   }
 602
 603   /**
 604    * @covers ::setSubmitHandlers
 605    */
 606   public function testSetSubmitHandlers() {
 607     $submit_handlers = [
 608       'FOO' => 'BAR',
 609     ];
 610
 611     $this->decoratedFormState->setSubmitHandlers($submit_handlers)
 612       ->shouldBeCalled();
 613
 614     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setSubmitHandlers($submit_handlers));
 615   }
 616
 617   /**
 618    * @covers ::getSubmitHandlers
 619    */
 620   public function testGetSubmitHandlers() {
 621     $submit_handlers = [
 622       'FOO' => 'BAR',
 623     ];
 624
 625     $this->decoratedFormState->getSubmitHandlers()
 626       ->willReturn($submit_handlers)
 627       ->shouldBeCalled();
 628
 629     $this->assertSame($submit_handlers, $this->formStateDecoratorBase->getSubmitHandlers());
 630   }
 631
 632   /**
 633    * @covers ::setSubmitted
 634    */
 635   public function testSetSubmitted() {
 636     $this->decoratedFormState->setSubmitted()
 637       ->shouldBeCalled();
 638
 639     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setSubmitted());
 640   }
 641
 642   /**
 643    * @covers ::isSubmitted
 644    *
 645    * @dataProvider providerSingleBooleanArgument
 646    *
 647    * @param bool $submitted
 648    */
 649   public function testIsSubmitted($submitted) {
 650     $this->decoratedFormState->isSubmitted()
 651       ->willReturn($submitted);
 652
 653     $this->assertSame($submitted, $this->formStateDecoratorBase->isSubmitted());
 654   }
 655
 656   /**
 657    * @covers ::setTemporary
 658    */
 659   public function testSetTemporary() {
 660     $temporary = [
 661       'FOO' => 'BAR',
 662     ];
 663
 664     $this->decoratedFormState->setTemporary($temporary)
 665       ->shouldBeCalled();
 666
 667     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setTemporary($temporary));
 668   }
 669
 670   /**
 671    * @covers ::getTemporary
 672    */
 673   public function testGetTemporary() {
 674     $temporary = [
 675       'FOO' => 'BAR',
 676     ];
 677
 678     $this->decoratedFormState->getTemporary()
 679       ->willReturn($temporary)
 680       ->shouldBeCalled();
 681
 682     $this->assertSame($temporary, $this->formStateDecoratorBase->getTemporary());
 683   }
 684
 685   /**
 686    * @covers ::setTemporaryValue
 687    *
 688    * @dataProvider providerSetTemporaryValue
 689    *
 690    * @param string $key
 691    * @param mixed $value
 692    */
 693   public function testSetTemporaryValue($key, $value) {
 694     $this->decoratedFormState->setTemporaryValue($key, $value)
 695       ->shouldBeCalled();
 696
 697     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setTemporaryValue($key, $value));
 698   }
 699
 700   /**
 701    * Provides data to self::testSetTemporaryValue().
 702    */
 703   public function providerSetTemporaryValue() {
 704     return [
 705       ['FOO', 'BAR'],
 706       ['FOO', NULL],
 707     ];
 708   }
 709
 710   /**
 711    * @covers ::getTemporaryValue
 712    *
 713    * @dataProvider providerGetTemporaryValue
 714    *
 715    * @param string $key
 716    * @param mixed $value
 717    */
 718   public function testGetTemporaryValue($key, $value = NULL) {
 719     // Use PHPUnit for mocking, because Prophecy cannot mock methods that return
 720     // by reference. See \Prophecy\Doubler\Generator\Node::getCode().
 721     $decorated_form_state = $this->getMock(FormStateInterface::class);
 722     $decorated_form_state->expects($this->once())
 723       ->method('getTemporaryValue')
 724       ->with($key)
 725       ->willReturn($value);
 726
 727     $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
 728
 729     $this->assertSame($value, $this->formStateDecoratorBase->getTemporaryValue($key));
 730   }
 731
 732   /**
 733    * Provides data to self::testGetTemporaryValue().
 734    */
 735   public function providerGetTemporaryValue() {
 736     return [
 737       [TRUE, 'FOO', 'BAR'],
 738       [TRUE, 'FOO', NULL],
 739     ];
 740   }
 741
 742   /**
 743    * @covers ::hasTemporaryValue
 744    *
 745    * @dataProvider providerHasTemporaryValue
 746    *
 747    * @param bool $exists
 748    * @param string $key
 749    */
 750   public function testHasTemporaryValue($exists, $key) {
 751     $this->decoratedFormState->hasTemporaryValue($key)
 752       ->willReturn($exists)
 753       ->shouldBeCalled();
 754
 755     $this->assertSame($exists, $this->formStateDecoratorBase->hasTemporaryValue($key));
 756   }
 757
 758   /**
 759    * Provides data to self::testHasTemporaryValue().
 760    */
 761   public function providerHasTemporaryValue() {
 762     return [
 763       [TRUE, 'FOO'],
 764       [FALSE, 'FOO'],
 765     ];
 766   }
 767
 768   /**
 769    * @covers ::setTriggeringElement
 770    */
 771   public function testSetTriggeringElement() {
 772     $triggering_element = [
 773       'FOO' => 'BAR',
 774     ];
 775
 776     $this->decoratedFormState->setTriggeringElement($triggering_element)
 777       ->shouldBeCalled();
 778
 779     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setTriggeringElement($triggering_element));
 780   }
 781
 782   /**
 783    * @covers ::getTriggeringElement
 784    */
 785   public function testGetTriggeringElement() {
 786     $triggering_element = [
 787       'FOO' => 'BAR',
 788     ];
 789
 790     // Use PHPUnit for mocking, because Prophecy cannot mock methods that return
 791     // by reference. See \Prophecy\Doubler\Generator\Node::getCode().
 792     $decorated_form_state = $this->getMock(FormStateInterface::class);
 793     $decorated_form_state->expects($this->once())
 794       ->method('getTriggeringElement')
 795       ->willReturn($triggering_element);
 796
 797     $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
 798
 799     $this->assertSame($triggering_element, $this->formStateDecoratorBase->getTriggeringElement());
 800   }
 801
 802   /**
 803    * @covers ::setValidateHandlers
 804    */
 805   public function testSetValidateHandlers() {
 806     $validate_handlers = [
 807       'FOO' => 'BAR',
 808     ];
 809
 810     $this->decoratedFormState->setValidateHandlers($validate_handlers)
 811       ->shouldBeCalled();
 812
 813     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValidateHandlers($validate_handlers));
 814   }
 815
 816   /**
 817    * @covers ::getValidateHandlers
 818    */
 819   public function testGetValidateHandlers() {
 820     $validate_handlers = [
 821       'FOO' => 'BAR',
 822     ];
 823
 824     $this->decoratedFormState->getValidateHandlers()
 825       ->willReturn($validate_handlers)
 826       ->shouldBecalled();
 827
 828     $this->assertSame($validate_handlers, $this->formStateDecoratorBase->getValidateHandlers());
 829   }
 830
 831   /**
 832    * @covers ::setValidationComplete
 833    *
 834    * @dataProvider providerSingleBooleanArgument
 835    *
 836    * @param bool $complete
 837    */
 838   public function testSetValidationComplete($complete) {
 839     $this->decoratedFormState->setValidationComplete($complete)
 840       ->shouldBeCalled();
 841
 842     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValidationComplete($complete));
 843   }
 844
 845   /**
 846    * @covers ::isValidationComplete
 847    *
 848    * @dataProvider providerSingleBooleanArgument
 849    *
 850    * @param bool $complete
 851    */
 852   public function testIsValidationComplete($complete) {
 853     $this->decoratedFormState->isValidationComplete()
 854       ->willReturn($complete)
 855       ->shouldBeCalled();
 856
 857     $this->assertSame($complete, $this->formStateDecoratorBase->isValidationComplete());
 858   }
 859
 860   /**
 861    * @covers ::loadInclude
 862    *
 863    * @dataProvider providerLoadInclude
 864    *
 865    * @param string|false $expected
 866    * @param string $module
 867    * @param string $type
 868    * @param string|null $name
 869    */
 870   public function testLoadInclude($expected, $module, $type, $name) {
 871     $this->decoratedFormState->loadInclude($module, $type, $name)
 872       ->willReturn($expected)
 873       ->shouldBeCalled();
 874
 875     $this->assertSame($expected, $this->formStateDecoratorBase->loadInclude($module, $type, $name));
 876   }
 877
 878   /**
 879    * Provides data to self::testLoadInclude().
 880    */
 881   public function providerLoadInclude() {
 882     return [
 883       // Existing files.
 884       [__FILE__, 'foo', 'inc', 'foo'],
 885       [__FILE__, 'foo', 'inc', 'foo.admin'],
 886       [__FILE__, 'bar', 'inc', 'bar'],
 887       // Non-existent files.
 888       [FALSE, 'foo', 'php', 'foo'],
 889       [FALSE, 'bar', 'php', 'foo'],
 890     ];
 891   }
 892
 893   /**
 894    * @covers ::getCacheableArray
 895    */
 896   public function testGetCacheableArray() {
 897     $cacheable_array = [
 898       'foo' => 'bar',
 899     ];
 900
 901     $this->decoratedFormState->getCacheableArray()
 902       ->willReturn($cacheable_array)
 903       ->shouldBeCalled();
 904
 905     $this->assertSame($cacheable_array, $this->formStateDecoratorBase->getCacheableArray());
 906   }
 907
 908   /**
 909    * @covers ::setCompleteForm
 910    */
 911   public function testSetCompleteForm() {
 912     $complete_form = [
 913       'FOO' => 'BAR',
 914     ];
 915
 916     $this->decoratedFormState->setCompleteForm($complete_form)
 917       ->shouldBeCalled();
 918
 919     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setCompleteForm($complete_form));
 920   }
 921
 922   /**
 923    * @covers ::getCompleteForm
 924    */
 925   public function testGetCompleteForm() {
 926     $complete_form = [
 927       'FOO' => 'BAR',
 928     ];
 929
 930     // Use PHPUnit for mocking, because Prophecy cannot mock methods that return
 931     // by reference. See \Prophecy\Doubler\Generator\Node::getCode().
 932     $decorated_form_state = $this->getMock(FormStateInterface::class);
 933     $decorated_form_state->expects($this->once())
 934       ->method('getCompleteForm')
 935       ->willReturn($complete_form);
 936
 937     $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
 938
 939     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setCompleteForm($complete_form));
 940     $this->assertSame($complete_form, $this->formStateDecoratorBase->getCompleteForm());
 941   }
 942
 943   /**
 944    * @covers ::set
 945    *
 946    * @dataProvider providerSet
 947    *
 948    * @param string $key
 949    * @param mixed $value
 950    */
 951   public function testSet($key, $value) {
 952     $this->decoratedFormState->set($key, $value)
 953       ->shouldBeCalled();
 954
 955     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->set($key, $value));
 956   }
 957
 958   /**
 959    * Provides data to self::testSet().
 960    */
 961   public function providerSet() {
 962     return [
 963       ['FOO', 'BAR'],
 964       ['FOO', NULL],
 965     ];
 966   }
 967
 968   /**
 969    * @covers ::get
 970    *
 971    * @dataProvider providerGet
 972    *
 973    * @param string $key
 974    * @param mixed $value
 975    */
 976   public function testGet($key, $value = NULL) {
 977
 978     // Use PHPUnit for mocking, because Prophecy cannot mock methods that return
 979     // by reference. See \Prophecy\Doubler\Generator\Node::getCode().
 980     $decorated_form_state = $this->getMock(FormStateInterface::class);
 981     $decorated_form_state->expects($this->once())
 982       ->method('get')
 983       ->with($key)
 984       ->willReturn($value);
 985
 986     $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
 987
 988     $this->assertSame($value, $this->formStateDecoratorBase->get($key));
 989   }
 990
 991   /**
 992    * Provides data to self::testGet().
 993    */
 994   public function providerGet() {
 995     return [
 996       ['FOO', 'BAR'],
 997       ['FOO', NULL],
 998     ];
 999   }
1000
1001   /**
1002    * @covers ::has
1003    *
1004    * @dataProvider providerHas
1005    *
1006    * @param bool $exists
1007    * @param string $key
1008    */
1009   public function testHas($exists, $key) {
1010     $this->decoratedFormState->has($key)
1011       ->willReturn($exists)
1012       ->shouldBeCalled();
1013
1014     $this->assertSame($exists, $this->formStateDecoratorBase->has($key));
1015   }
1016
1017   /**
1018    * Provides data to self::testHas().
1019    */
1020   public function providerHas() {
1021     return [
1022       [TRUE, 'FOO'],
1023       [FALSE, 'FOO'],
1024     ];
1025   }
1026
1027   /**
1028    * @covers ::setBuildInfo
1029    */
1030   public function testSetBuildInfo() {
1031     $build_info = [
1032       'FOO' => 'BAR',
1033     ];
1034
1035     $this->decoratedFormState->setBuildInfo($build_info)
1036       ->shouldBeCalled();
1037
1038     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setBuildInfo($build_info));
1039   }
1040
1041   /**
1042    * @covers ::getBuildInfo
1043    */
1044   public function testGetBuildInfo() {
1045     $build_info = [
1046       'FOO' => 'BAR',
1047     ];
1048
1049     $this->decoratedFormState->getBuildInfo()
1050       ->willReturn($build_info)
1051       ->shouldBeCalled();
1052
1053     $this->assertSame($build_info, $this->formStateDecoratorBase->getBuildInfo());
1054   }
1055
1056   /**
1057    * @covers ::addBuildInfo
1058    */
1059   public function testAddBuildInfo() {
1060     $property = 'FOO';
1061     $value = 'BAR';
1062
1063     $this->decoratedFormState->addBuildInfo($property, $value)
1064       ->shouldBeCalled();
1065
1066     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->addBuildInfo($property, $value));
1067   }
1068
1069   /**
1070    * @covers ::setUserInput
1071    */
1072   public function testSetUserInput() {
1073     $user_input = [
1074       'FOO' => 'BAR',
1075     ];
1076
1077     $this->decoratedFormState->setUserInput($user_input)
1078       ->shouldBeCalled();
1079
1080     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setUserInput($user_input));
1081   }
1082
1083   /**
1084    * @covers ::getUserInput
1085    */
1086   public function testGetUserInput() {
1087     $user_input = [
1088       'FOO' => 'BAR',
1089     ];
1090
1091     // Use PHPUnit for mocking, because Prophecy cannot mock methods that return
1092     // by reference. See \Prophecy\Doubler\Generator\Node::getCode().
1093     $decorated_form_state = $this->getMock(FormStateInterface::class);
1094     $decorated_form_state->expects($this->once())
1095       ->method('getUserInput')
1096       ->willReturn($user_input);
1097
1098     $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
1099
1100     $this->assertSame($user_input, $this->formStateDecoratorBase->getUserInput());
1101   }
1102
1103   /**
1104    * @covers ::getValues
1105    */
1106   public function testGetValues() {
1107     $values = [
1108       'FOO' => 'BAR',
1109     ];
1110
1111     // Use PHPUnit for mocking, because Prophecy cannot mock methods that return
1112     // by reference. See \Prophecy\Doubler\Generator\Node::getCode().
1113     $decorated_form_state = $this->getMock(FormStateInterface::class);
1114     $decorated_form_state->expects($this->once())
1115       ->method('getValues')
1116       ->willReturn($values);
1117
1118     $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
1119
1120     $this->assertSame($values, $this->formStateDecoratorBase->getValues());
1121   }
1122   /**
1123    * @covers ::getValue
1124    */
1125   public function testGetValue() {
1126     $key = 'FOO';
1127     $value = 'BAR';
1128
1129     // Use PHPUnit for mocking, because Prophecy cannot mock methods that return
1130     // by reference. See \Prophecy\Doubler\Generator\Node::getCode().
1131     $decorated_form_state = $this->getMock(FormStateInterface::class);
1132     $decorated_form_state->expects($this->once())
1133       ->method('getValue')
1134       ->with($key, $value)
1135       ->willReturn($value);
1136
1137     $this->formStateDecoratorBase = new NonAbstractFormStateDecoratorBase($decorated_form_state);
1138
1139     $this->assertSame($value, $this->formStateDecoratorBase->getValue($key, $value));
1140   }
1141
1142   /**
1143    * @covers ::setValues
1144    */
1145   public function testSetValues() {
1146     $values = [
1147       'foo' => 'Foo',
1148       'bar' => ['Bar'],
1149     ];
1150
1151     $this->decoratedFormState->setValues($values)
1152       ->shouldBeCalled();
1153
1154     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValues($values));
1155   }
1156
1157   /**
1158    * @covers ::setValue
1159    */
1160   public function testSetValue() {
1161     $key = 'FOO';
1162     $value = 'BAR';
1163
1164     $this->decoratedFormState->setValue($key, $value)
1165       ->shouldBeCalled();
1166
1167     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValue($key, $value));
1168   }
1169
1170   /**
1171    * @covers ::unsetValue
1172    */
1173   public function testUnsetValue() {
1174     $key = 'FOO';
1175
1176     $this->decoratedFormState->unsetValue($key)
1177       ->shouldBeCalled();
1178
1179     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->unsetValue($key));
1180   }
1181
1182   /**
1183    * @covers ::hasValue
1184    */
1185   public function testHasValue() {
1186     $key = ['foo', 'bar'];
1187     $has = TRUE;
1188
1189     $this->decoratedFormState->hasValue($key)
1190       ->willReturn($has)
1191       ->shouldBeCalled();
1192
1193     $this->assertSame($has, $this->formStateDecoratorBase->hasValue($key));
1194   }
1195
1196   /**
1197    * @covers ::isValueEmpty
1198    */
1199   public function testIsValueEmpty() {
1200     $key = ['foo', 'bar'];
1201     $is_empty = TRUE;
1202
1203     $this->decoratedFormState->isValueEmpty($key)
1204       ->willReturn($is_empty)
1205       ->shouldBeCalled();
1206
1207     $this->assertSame($is_empty, $this->formStateDecoratorBase->isValueEmpty($key));
1208   }
1209
1210   /**
1211    * @covers ::setValueForElement
1212    */
1213   public function testSetValueForElement() {
1214     $element = [
1215       '#type' => 'foo',
1216     ];
1217     $value = 'BAR';
1218
1219     $this->decoratedFormState->setValueForElement($element, $value)
1220       ->shouldBeCalled();
1221
1222     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setValueForElement($element, $value));
1223   }
1224
1225   /**
1226    * @covers ::setResponse
1227    */
1228   public function testSetResponse() {
1229     $response = $this->getMock(Response::class);
1230
1231     $this->decoratedFormState->setResponse($response)
1232       ->shouldBeCalled();
1233
1234     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setResponse($response));
1235   }
1236
1237   /**
1238    * @covers ::getResponse
1239    */
1240   public function testGetResponse() {
1241     $response = $this->getMock(Response::class);
1242
1243     $this->decoratedFormState->getResponse()
1244       ->willReturn($response)
1245       ->shouldBeCalled();
1246
1247     $this->assertSame($response, $this->formStateDecoratorBase->getResponse());
1248   }
1249
1250   /**
1251    * @covers ::setRedirect
1252    */
1253   public function testSetRedirect() {
1254     $route_name = 'foo';
1255     $route_parameters = [
1256       'bar' => 'baz'
1257     ];
1258     $options = [
1259       'qux' => 'foo',
1260     ];
1261
1262     $this->decoratedFormState->setRedirect($route_name, $route_parameters, $options)
1263       ->shouldBeCalled();
1264
1265     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setRedirect($route_name, $route_parameters, $options));
1266   }
1267
1268   /**
1269    * @covers ::setRedirectUrl
1270    */
1271   public function testSetRedirectUrl() {
1272     $url = new Url('foo');
1273
1274     $this->decoratedFormState->setRedirectUrl($url)
1275       ->shouldBeCalled();
1276
1277     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setRedirectUrl($url));
1278   }
1279
1280   /**
1281    * @covers ::getRedirect
1282    *
1283    * @dataProvider providerGetRedirect
1284    *
1285    * @param bool $expected
1286    */
1287   public function testGetRedirect($expected) {
1288     $this->decoratedFormState->getRedirect()
1289       ->willReturn($expected)
1290       ->shouldBeCalled();
1291
1292     $this->assertSame($expected, $this->formStateDecoratorBase->getRedirect());
1293   }
1294
1295   /**
1296    * Provides data to self::testGetRedirect().
1297    */
1298   public function providerGetRedirect() {
1299     return [
1300       [NULL],
1301       [FALSE],
1302       [new Url('foo')],
1303       [new RedirectResponse('http://example.com')],
1304     ];
1305   }
1306
1307   /**
1308    * @covers ::setErrorByName
1309    */
1310   public function testSetErrorByName() {
1311     $name = 'foo';
1312     $message = 'bar';
1313
1314     $this->decoratedFormState->setErrorByName($name, $message)
1315       ->shouldBeCalled();
1316
1317     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setErrorByName($name, $message));
1318   }
1319
1320   /**
1321    * @covers ::setError
1322    */
1323   public function testSetError() {
1324     $element = [
1325       '#foo' => 'bar',
1326     ];
1327     $message = 'bar';
1328
1329     $this->decoratedFormState->setError($element, $message)
1330       ->shouldBeCalled();
1331
1332     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setError($element, $message));
1333   }
1334
1335   /**
1336    * @covers ::clearErrors
1337    */
1338   public function testClearErrors() {
1339     $this->decoratedFormState->clearErrors()
1340       ->shouldBeCalled();
1341
1342     $this->formStateDecoratorBase->clearErrors();
1343   }
1344
1345   /**
1346    * @covers ::getError
1347    */
1348   public function testGetError() {
1349     $element = [
1350       '#foo' => 'bar',
1351     ];
1352     $message = 'bar';
1353
1354     $this->decoratedFormState->getError($element)
1355       ->willReturn($message)
1356       ->shouldBeCalled();
1357
1358     $this->assertSame($message, $this->formStateDecoratorBase->getError($element));
1359   }
1360
1361   /**
1362    * @covers ::getErrors
1363    */
1364   public function testGetErrors() {
1365     $errors = [
1366       'foo' => 'bar',
1367     ];
1368     $this->decoratedFormState->getErrors()
1369       ->willReturn($errors)
1370       ->shouldBeCalled();
1371
1372     $this->assertSame($errors, $this->formStateDecoratorBase->getErrors());
1373   }
1374
1375   /**
1376    * @covers ::setRebuild
1377    *
1378    * @dataProvider providerSingleBooleanArgument
1379    *
1380    * @param bool $rebuild
1381    */
1382   public function testSetRebuild($rebuild) {
1383     $this->decoratedFormState->setRebuild($rebuild)
1384       ->shouldBeCalled();
1385
1386     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setRebuild($rebuild));
1387   }
1388
1389   /**
1390    * @covers ::isRebuilding
1391    *
1392    * @dataProvider providerSingleBooleanArgument
1393    *
1394    * @param bool $rebuild
1395    */
1396   public function testIsRebuilding($rebuild) {
1397     $this->decoratedFormState->isRebuilding()
1398       ->willReturn($rebuild)
1399       ->shouldBeCalled();
1400
1401     $this->assertSame($rebuild, $this->formStateDecoratorBase->isRebuilding());
1402   }
1403
1404   /**
1405    * @covers ::setInvalidToken
1406    *
1407    * @dataProvider providerSingleBooleanArgument
1408    *
1409    * @param bool $expected
1410    */
1411   public function testSetInvalidToken($expected) {
1412     $this->decoratedFormState->setInvalidToken($expected)
1413       ->shouldBeCalled();
1414
1415     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setInvalidToken($expected));
1416   }
1417
1418   /**
1419    * @covers ::hasInvalidToken
1420    *
1421    * @dataProvider providerSingleBooleanArgument
1422    *
1423    * @param bool $expected
1424    */
1425   public function testHasInvalidToken($expected) {
1426     $this->decoratedFormState->hasInvalidToken()
1427       ->willReturn($expected)
1428       ->shouldBeCalled();
1429
1430     $this->assertSame($expected, $this->formStateDecoratorBase->hasInvalidToken());
1431   }
1432
1433   /**
1434    * @covers ::prepareCallback
1435    *
1436    * @dataProvider providerPrepareCallback
1437    *
1438    * @param string|callable $unprepared_callback
1439    * @param callable $prepared_callback
1440    */
1441   public function testPrepareCallback($unprepared_callback, callable $prepared_callback) {
1442     $this->decoratedFormState->prepareCallback($unprepared_callback)
1443       ->willReturn($prepared_callback)
1444       ->shouldBeCalled();
1445
1446     $this->assertSame($prepared_callback, $this->formStateDecoratorBase->prepareCallback($unprepared_callback));
1447   }
1448
1449   /**
1450    * Provides data to self::testPrepareCallback().
1451    */
1452   public function providerPrepareCallback() {
1453     $function = 'sleep';
1454     $shorthand_form_method = '::submit()';
1455     $closure = function () {};
1456     $static_method_string = __METHOD__;
1457     $static_method_array = [__CLASS__, __FUNCTION__];
1458     $object_method_array = [$this, __FUNCTION__];
1459
1460     return [
1461       // A shorthand form method is generally expanded to become a method on an
1462       // object.
1463       [$shorthand_form_method, $object_method_array],
1464       // Functions, closures, and static method calls generally remain the same.
1465       [$function, $function],
1466       [$closure, $closure],
1467       [$static_method_string, $static_method_string],
1468       [$static_method_array, $static_method_array],
1469     ];
1470   }
1471
1472   /**
1473    * @covers ::setFormObject
1474    */
1475   public function testSetFormObject() {
1476     $form = $this->getMock(FormInterface::class);
1477
1478     $this->decoratedFormState->setFormObject($form)
1479       ->shouldBeCalled();;
1480
1481     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setFormObject($form));
1482   }
1483
1484   /**
1485    * @covers ::getFormObject
1486    */
1487   public function testGetFormObject() {
1488     $form = $this->getMock(FormInterface::class);
1489
1490     $this->decoratedFormState->getFormObject()
1491       ->willReturn($form)
1492       ->shouldBeCalled();
1493
1494     $this->assertSame($form, $this->formStateDecoratorBase->getFormObject());
1495   }
1496
1497   /**
1498    * @covers ::setCleanValueKeys
1499    */
1500   public function testSetCleanValueKeys() {
1501     $keys = ['BAR'];
1502
1503     $this->decoratedFormState->setCleanValueKeys($keys)
1504       ->shouldBeCalled();
1505
1506     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->setCleanValueKeys($keys));
1507   }
1508
1509   /**
1510    * @covers ::getCleanValueKeys
1511    */
1512   public function testGetCleanValueKeys() {
1513     $keys = ['BAR'];
1514
1515     $this->decoratedFormState->getCleanValueKeys()
1516       ->willReturn($keys)
1517       ->shouldBeCalled();
1518
1519     $this->assertSame($keys, $this->formStateDecoratorBase->getCleanValueKeys());
1520   }
1521
1522   /**
1523    * @covers ::addCleanValueKey
1524    */
1525   public function testAddCleanValueKey() {
1526     $key = 'BAR';
1527
1528     $this->decoratedFormState->addCleanValueKey($key)
1529       ->shouldBeCalled();
1530
1531     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->addCleanValueKey($key));
1532   }
1533
1534   /**
1535    * @covers ::cleanValues
1536    */
1537   public function testCleanValues() {
1538     $this->decoratedFormState->cleanValues()
1539       ->shouldBeCalled();
1540
1541     $this->assertSame($this->formStateDecoratorBase, $this->formStateDecoratorBase->cleanValues());
1542   }
1543
1544 }
1545
1546 /**
1547  * Provides a non-abstract version of the class under test.
1548  */
1549 class NonAbstractFormStateDecoratorBase extends FormStateDecoratorBase {
1550
1551   /**
1552    * Creates a new instance.
1553    *
1554    * @param \Drupal\Core\Form\FormStateInterface $decorated_form_state
1555    *   The decorated form state.
1556    */
1557   public function __construct(FormStateInterface $decorated_form_state) {
1558     $this->decoratedFormState = $decorated_form_state;
1559   }
1560
1561 }