Subversion-Projekte lars-tiefland.laravel_shop

Revision

Details | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
148 lars 1
<?php declare(strict_types=1);
2
/*
3
 * This file is part of PHPUnit.
4
 *
5
 * (c) Sebastian Bergmann <sebastian@phpunit.de>
6
 *
7
 * For the full copyright and license information, please view the LICENSE
8
 * file that was distributed with this source code.
9
 */
10
namespace PHPUnit\TextUI\CliArguments;
11
 
12
use PHPUnit\TextUI\XmlConfiguration\Extension;
13
 
14
/**
15
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
16
 *
17
 * @psalm-immutable
18
 */
19
final class Configuration
20
{
21
    /**
22
     * @var ?string
23
     */
24
    private $argument;
25
 
26
    /**
27
     * @var ?string
28
     */
29
    private $atLeastVersion;
30
 
31
    /**
32
     * @var ?bool
33
     */
34
    private $backupGlobals;
35
 
36
    /**
37
     * @var ?bool
38
     */
39
    private $backupStaticAttributes;
40
 
41
    /**
42
     * @var ?bool
43
     */
44
    private $beStrictAboutChangesToGlobalState;
45
 
46
    /**
47
     * @var ?bool
48
     */
49
    private $beStrictAboutResourceUsageDuringSmallTests;
50
 
51
    /**
52
     * @var ?string
53
     */
54
    private $bootstrap;
55
 
56
    /**
57
     * @var ?bool
58
     */
59
    private $cacheResult;
60
 
61
    /**
62
     * @var ?string
63
     */
64
    private $cacheResultFile;
65
 
66
    /**
67
     * @var ?bool
68
     */
69
    private $checkVersion;
70
 
71
    /**
72
     * @var ?string
73
     */
74
    private $colors;
75
 
76
    /**
77
     * @var null|int|string
78
     */
79
    private $columns;
80
 
81
    /**
82
     * @var ?string
83
     */
84
    private $configuration;
85
 
86
    /**
87
     * @var null|string[]
88
     */
89
    private $coverageFilter;
90
 
91
    /**
92
     * @var ?string
93
     */
94
    private $coverageClover;
95
 
96
    /**
97
     * @var ?string
98
     */
99
    private $coverageCobertura;
100
 
101
    /**
102
     * @var ?string
103
     */
104
    private $coverageCrap4J;
105
 
106
    /**
107
     * @var ?string
108
     */
109
    private $coverageHtml;
110
 
111
    /**
112
     * @var ?string
113
     */
114
    private $coveragePhp;
115
 
116
    /**
117
     * @var ?string
118
     */
119
    private $coverageText;
120
 
121
    /**
122
     * @var ?bool
123
     */
124
    private $coverageTextShowUncoveredFiles;
125
 
126
    /**
127
     * @var ?bool
128
     */
129
    private $coverageTextShowOnlySummary;
130
 
131
    /**
132
     * @var ?string
133
     */
134
    private $coverageXml;
135
 
136
    /**
137
     * @var ?bool
138
     */
139
    private $pathCoverage;
140
 
141
    /**
142
     * @var ?string
143
     */
144
    private $coverageCacheDirectory;
145
 
146
    /**
147
     * @var ?bool
148
     */
149
    private $warmCoverageCache;
150
 
151
    /**
152
     * @var ?bool
153
     */
154
    private $debug;
155
 
156
    /**
157
     * @var ?int
158
     */
159
    private $defaultTimeLimit;
160
 
161
    /**
162
     * @var ?bool
163
     */
164
    private $disableCodeCoverageIgnore;
165
 
166
    /**
167
     * @var ?bool
168
     */
169
    private $disallowTestOutput;
170
 
171
    /**
172
     * @var ?bool
173
     */
174
    private $disallowTodoAnnotatedTests;
175
 
176
    /**
177
     * @var ?bool
178
     */
179
    private $enforceTimeLimit;
180
 
181
    /**
182
     * @var null|string[]
183
     */
184
    private $excludeGroups;
185
 
186
    /**
187
     * @var ?int
188
     */
189
    private $executionOrder;
190
 
191
    /**
192
     * @var ?int
193
     */
194
    private $executionOrderDefects;
195
 
196
    /**
197
     * @var null|Extension[]
198
     */
199
    private $extensions;
200
 
201
    /**
202
     * @var null|string[]
203
     */
204
    private $unavailableExtensions;
205
 
206
    /**
207
     * @var ?bool
208
     */
209
    private $failOnEmptyTestSuite;
210
 
211
    /**
212
     * @var ?bool
213
     */
214
    private $failOnIncomplete;
215
 
216
    /**
217
     * @var ?bool
218
     */
219
    private $failOnRisky;
220
 
221
    /**
222
     * @var ?bool
223
     */
224
    private $failOnSkipped;
225
 
226
    /**
227
     * @var ?bool
228
     */
229
    private $failOnWarning;
230
 
231
    /**
232
     * @var ?string
233
     */
234
    private $filter;
235
 
236
    /**
237
     * @var ?bool
238
     */
239
    private $generateConfiguration;
240
 
241
    /**
242
     * @var ?bool
243
     */
244
    private $migrateConfiguration;
245
 
246
    /**
247
     * @var null|string[]
248
     */
249
    private $groups;
250
 
251
    /**
252
     * @var null|string[]
253
     */
254
    private $testsCovering;
255
 
256
    /**
257
     * @var null|string[]
258
     */
259
    private $testsUsing;
260
 
261
    /**
262
     * @var ?bool
263
     */
264
    private $help;
265
 
266
    /**
267
     * @var ?string
268
     */
269
    private $includePath;
270
 
271
    /**
272
     * @var null|string[]
273
     */
274
    private $iniSettings;
275
 
276
    /**
277
     * @var ?string
278
     */
279
    private $junitLogfile;
280
 
281
    /**
282
     * @var ?bool
283
     */
284
    private $listGroups;
285
 
286
    /**
287
     * @var ?bool
288
     */
289
    private $listSuites;
290
 
291
    /**
292
     * @var ?bool
293
     */
294
    private $listTests;
295
 
296
    /**
297
     * @var ?string
298
     */
299
    private $listTestsXml;
300
 
301
    /**
302
     * @var ?string
303
     */
304
    private $loader;
305
 
306
    /**
307
     * @var ?bool
308
     */
309
    private $noCoverage;
310
 
311
    /**
312
     * @var ?bool
313
     */
314
    private $noExtensions;
315
 
316
    /**
317
     * @var ?bool
318
     */
319
    private $noInteraction;
320
 
321
    /**
322
     * @var ?bool
323
     */
324
    private $noLogging;
325
 
326
    /**
327
     * @var ?string
328
     */
329
    private $printer;
330
 
331
    /**
332
     * @var ?bool
333
     */
334
    private $processIsolation;
335
 
336
    /**
337
     * @var ?int
338
     */
339
    private $randomOrderSeed;
340
 
341
    /**
342
     * @var ?int
343
     */
344
    private $repeat;
345
 
346
    /**
347
     * @var ?bool
348
     */
349
    private $reportUselessTests;
350
 
351
    /**
352
     * @var ?bool
353
     */
354
    private $resolveDependencies;
355
 
356
    /**
357
     * @var ?bool
358
     */
359
    private $reverseList;
360
 
361
    /**
362
     * @var ?bool
363
     */
364
    private $stderr;
365
 
366
    /**
367
     * @var ?bool
368
     */
369
    private $strictCoverage;
370
 
371
    /**
372
     * @var ?bool
373
     */
374
    private $stopOnDefect;
375
 
376
    /**
377
     * @var ?bool
378
     */
379
    private $stopOnError;
380
 
381
    /**
382
     * @var ?bool
383
     */
384
    private $stopOnFailure;
385
 
386
    /**
387
     * @var ?bool
388
     */
389
    private $stopOnIncomplete;
390
 
391
    /**
392
     * @var ?bool
393
     */
394
    private $stopOnRisky;
395
 
396
    /**
397
     * @var ?bool
398
     */
399
    private $stopOnSkipped;
400
 
401
    /**
402
     * @var ?bool
403
     */
404
    private $stopOnWarning;
405
 
406
    /**
407
     * @var ?string
408
     */
409
    private $teamcityLogfile;
410
 
411
    /**
412
     * @var null|string[]
413
     */
414
    private $testdoxExcludeGroups;
415
 
416
    /**
417
     * @var null|string[]
418
     */
419
    private $testdoxGroups;
420
 
421
    /**
422
     * @var ?string
423
     */
424
    private $testdoxHtmlFile;
425
 
426
    /**
427
     * @var ?string
428
     */
429
    private $testdoxTextFile;
430
 
431
    /**
432
     * @var ?string
433
     */
434
    private $testdoxXmlFile;
435
 
436
    /**
437
     * @var null|string[]
438
     */
439
    private $testSuffixes;
440
 
441
    /**
442
     * @var ?string
443
     */
444
    private $testSuite;
445
 
446
    /**
447
     * @var string[]
448
     */
449
    private $unrecognizedOptions;
450
 
451
    /**
452
     * @var ?string
453
     */
454
    private $unrecognizedOrderBy;
455
 
456
    /**
457
     * @var ?bool
458
     */
459
    private $useDefaultConfiguration;
460
 
461
    /**
462
     * @var ?bool
463
     */
464
    private $verbose;
465
 
466
    /**
467
     * @var ?bool
468
     */
469
    private $version;
470
 
471
    /**
472
     * @var ?string
473
     */
474
    private $xdebugFilterFile;
475
 
476
    /**
477
     * @param null|int|string $columns
478
     */
479
    public function __construct(?string $argument, ?string $atLeastVersion, ?bool $backupGlobals, ?bool $backupStaticAttributes, ?bool $beStrictAboutChangesToGlobalState, ?bool $beStrictAboutResourceUsageDuringSmallTests, ?string $bootstrap, ?bool $cacheResult, ?string $cacheResultFile, ?bool $checkVersion, ?string $colors, $columns, ?string $configuration, ?string $coverageClover, ?string $coverageCobertura, ?string $coverageCrap4J, ?string $coverageHtml, ?string $coveragePhp, ?string $coverageText, ?bool $coverageTextShowUncoveredFiles, ?bool $coverageTextShowOnlySummary, ?string $coverageXml, ?bool $pathCoverage, ?string $coverageCacheDirectory, ?bool $warmCoverageCache, ?bool $debug, ?int $defaultTimeLimit, ?bool $disableCodeCoverageIgnore, ?bool $disallowTestOutput, ?bool $disallowTodoAnnotatedTests, ?bool $enforceTimeLimit, ?array $excludeGroups, ?int $executionOrder, ?int $executionOrderDefects, ?array $extensions, ?array $unavailableExtensions, ?bool $failOnEmptyTestSuite, ?bool $failOnIncomplete, ?bool $failOnRisky, ?bool $failOnSkipped, ?bool $failOnWarning, ?string $filter, ?bool $generateConfiguration, ?bool $migrateConfiguration, ?array $groups, ?array $testsCovering, ?array $testsUsing, ?bool $help, ?string $includePath, ?array $iniSettings, ?string $junitLogfile, ?bool $listGroups, ?bool $listSuites, ?bool $listTests, ?string $listTestsXml, ?string $loader, ?bool $noCoverage, ?bool $noExtensions, ?bool $noInteraction, ?bool $noLogging, ?string $printer, ?bool $processIsolation, ?int $randomOrderSeed, ?int $repeat, ?bool $reportUselessTests, ?bool $resolveDependencies, ?bool $reverseList, ?bool $stderr, ?bool $strictCoverage, ?bool $stopOnDefect, ?bool $stopOnError, ?bool $stopOnFailure, ?bool $stopOnIncomplete, ?bool $stopOnRisky, ?bool $stopOnSkipped, ?bool $stopOnWarning, ?string $teamcityLogfile, ?array $testdoxExcludeGroups, ?array $testdoxGroups, ?string $testdoxHtmlFile, ?string $testdoxTextFile, ?string $testdoxXmlFile, ?array $testSuffixes, ?string $testSuite, array $unrecognizedOptions, ?string $unrecognizedOrderBy, ?bool $useDefaultConfiguration, ?bool $verbose, ?bool $version, ?array $coverageFilter, ?string $xdebugFilterFile)
480
    {
481
        $this->argument                                   = $argument;
482
        $this->atLeastVersion                             = $atLeastVersion;
483
        $this->backupGlobals                              = $backupGlobals;
484
        $this->backupStaticAttributes                     = $backupStaticAttributes;
485
        $this->beStrictAboutChangesToGlobalState          = $beStrictAboutChangesToGlobalState;
486
        $this->beStrictAboutResourceUsageDuringSmallTests = $beStrictAboutResourceUsageDuringSmallTests;
487
        $this->bootstrap                                  = $bootstrap;
488
        $this->cacheResult                                = $cacheResult;
489
        $this->cacheResultFile                            = $cacheResultFile;
490
        $this->checkVersion                               = $checkVersion;
491
        $this->colors                                     = $colors;
492
        $this->columns                                    = $columns;
493
        $this->configuration                              = $configuration;
494
        $this->coverageFilter                             = $coverageFilter;
495
        $this->coverageClover                             = $coverageClover;
496
        $this->coverageCobertura                          = $coverageCobertura;
497
        $this->coverageCrap4J                             = $coverageCrap4J;
498
        $this->coverageHtml                               = $coverageHtml;
499
        $this->coveragePhp                                = $coveragePhp;
500
        $this->coverageText                               = $coverageText;
501
        $this->coverageTextShowUncoveredFiles             = $coverageTextShowUncoveredFiles;
502
        $this->coverageTextShowOnlySummary                = $coverageTextShowOnlySummary;
503
        $this->coverageXml                                = $coverageXml;
504
        $this->pathCoverage                               = $pathCoverage;
505
        $this->coverageCacheDirectory                     = $coverageCacheDirectory;
506
        $this->warmCoverageCache                          = $warmCoverageCache;
507
        $this->debug                                      = $debug;
508
        $this->defaultTimeLimit                           = $defaultTimeLimit;
509
        $this->disableCodeCoverageIgnore                  = $disableCodeCoverageIgnore;
510
        $this->disallowTestOutput                         = $disallowTestOutput;
511
        $this->disallowTodoAnnotatedTests                 = $disallowTodoAnnotatedTests;
512
        $this->enforceTimeLimit                           = $enforceTimeLimit;
513
        $this->excludeGroups                              = $excludeGroups;
514
        $this->executionOrder                             = $executionOrder;
515
        $this->executionOrderDefects                      = $executionOrderDefects;
516
        $this->extensions                                 = $extensions;
517
        $this->unavailableExtensions                      = $unavailableExtensions;
518
        $this->failOnEmptyTestSuite                       = $failOnEmptyTestSuite;
519
        $this->failOnIncomplete                           = $failOnIncomplete;
520
        $this->failOnRisky                                = $failOnRisky;
521
        $this->failOnSkipped                              = $failOnSkipped;
522
        $this->failOnWarning                              = $failOnWarning;
523
        $this->filter                                     = $filter;
524
        $this->generateConfiguration                      = $generateConfiguration;
525
        $this->migrateConfiguration                       = $migrateConfiguration;
526
        $this->groups                                     = $groups;
527
        $this->testsCovering                              = $testsCovering;
528
        $this->testsUsing                                 = $testsUsing;
529
        $this->help                                       = $help;
530
        $this->includePath                                = $includePath;
531
        $this->iniSettings                                = $iniSettings;
532
        $this->junitLogfile                               = $junitLogfile;
533
        $this->listGroups                                 = $listGroups;
534
        $this->listSuites                                 = $listSuites;
535
        $this->listTests                                  = $listTests;
536
        $this->listTestsXml                               = $listTestsXml;
537
        $this->loader                                     = $loader;
538
        $this->noCoverage                                 = $noCoverage;
539
        $this->noExtensions                               = $noExtensions;
540
        $this->noInteraction                              = $noInteraction;
541
        $this->noLogging                                  = $noLogging;
542
        $this->printer                                    = $printer;
543
        $this->processIsolation                           = $processIsolation;
544
        $this->randomOrderSeed                            = $randomOrderSeed;
545
        $this->repeat                                     = $repeat;
546
        $this->reportUselessTests                         = $reportUselessTests;
547
        $this->resolveDependencies                        = $resolveDependencies;
548
        $this->reverseList                                = $reverseList;
549
        $this->stderr                                     = $stderr;
550
        $this->strictCoverage                             = $strictCoverage;
551
        $this->stopOnDefect                               = $stopOnDefect;
552
        $this->stopOnError                                = $stopOnError;
553
        $this->stopOnFailure                              = $stopOnFailure;
554
        $this->stopOnIncomplete                           = $stopOnIncomplete;
555
        $this->stopOnRisky                                = $stopOnRisky;
556
        $this->stopOnSkipped                              = $stopOnSkipped;
557
        $this->stopOnWarning                              = $stopOnWarning;
558
        $this->teamcityLogfile                            = $teamcityLogfile;
559
        $this->testdoxExcludeGroups                       = $testdoxExcludeGroups;
560
        $this->testdoxGroups                              = $testdoxGroups;
561
        $this->testdoxHtmlFile                            = $testdoxHtmlFile;
562
        $this->testdoxTextFile                            = $testdoxTextFile;
563
        $this->testdoxXmlFile                             = $testdoxXmlFile;
564
        $this->testSuffixes                               = $testSuffixes;
565
        $this->testSuite                                  = $testSuite;
566
        $this->unrecognizedOptions                        = $unrecognizedOptions;
567
        $this->unrecognizedOrderBy                        = $unrecognizedOrderBy;
568
        $this->useDefaultConfiguration                    = $useDefaultConfiguration;
569
        $this->verbose                                    = $verbose;
570
        $this->version                                    = $version;
571
        $this->xdebugFilterFile                           = $xdebugFilterFile;
572
    }
573
 
574
    public function hasArgument(): bool
575
    {
576
        return $this->argument !== null;
577
    }
578
 
579
    /**
580
     * @throws Exception
581
     */
582
    public function argument(): string
583
    {
584
        if ($this->argument === null) {
585
            throw new Exception;
586
        }
587
 
588
        return $this->argument;
589
    }
590
 
591
    public function hasAtLeastVersion(): bool
592
    {
593
        return $this->atLeastVersion !== null;
594
    }
595
 
596
    /**
597
     * @throws Exception
598
     */
599
    public function atLeastVersion(): string
600
    {
601
        if ($this->atLeastVersion === null) {
602
            throw new Exception;
603
        }
604
 
605
        return $this->atLeastVersion;
606
    }
607
 
608
    public function hasBackupGlobals(): bool
609
    {
610
        return $this->backupGlobals !== null;
611
    }
612
 
613
    /**
614
     * @throws Exception
615
     */
616
    public function backupGlobals(): bool
617
    {
618
        if ($this->backupGlobals === null) {
619
            throw new Exception;
620
        }
621
 
622
        return $this->backupGlobals;
623
    }
624
 
625
    public function hasBackupStaticAttributes(): bool
626
    {
627
        return $this->backupStaticAttributes !== null;
628
    }
629
 
630
    /**
631
     * @throws Exception
632
     */
633
    public function backupStaticAttributes(): bool
634
    {
635
        if ($this->backupStaticAttributes === null) {
636
            throw new Exception;
637
        }
638
 
639
        return $this->backupStaticAttributes;
640
    }
641
 
642
    public function hasBeStrictAboutChangesToGlobalState(): bool
643
    {
644
        return $this->beStrictAboutChangesToGlobalState !== null;
645
    }
646
 
647
    /**
648
     * @throws Exception
649
     */
650
    public function beStrictAboutChangesToGlobalState(): bool
651
    {
652
        if ($this->beStrictAboutChangesToGlobalState === null) {
653
            throw new Exception;
654
        }
655
 
656
        return $this->beStrictAboutChangesToGlobalState;
657
    }
658
 
659
    public function hasBeStrictAboutResourceUsageDuringSmallTests(): bool
660
    {
661
        return $this->beStrictAboutResourceUsageDuringSmallTests !== null;
662
    }
663
 
664
    /**
665
     * @throws Exception
666
     */
667
    public function beStrictAboutResourceUsageDuringSmallTests(): bool
668
    {
669
        if ($this->beStrictAboutResourceUsageDuringSmallTests === null) {
670
            throw new Exception;
671
        }
672
 
673
        return $this->beStrictAboutResourceUsageDuringSmallTests;
674
    }
675
 
676
    public function hasBootstrap(): bool
677
    {
678
        return $this->bootstrap !== null;
679
    }
680
 
681
    /**
682
     * @throws Exception
683
     */
684
    public function bootstrap(): string
685
    {
686
        if ($this->bootstrap === null) {
687
            throw new Exception;
688
        }
689
 
690
        return $this->bootstrap;
691
    }
692
 
693
    public function hasCacheResult(): bool
694
    {
695
        return $this->cacheResult !== null;
696
    }
697
 
698
    /**
699
     * @throws Exception
700
     */
701
    public function cacheResult(): bool
702
    {
703
        if ($this->cacheResult === null) {
704
            throw new Exception;
705
        }
706
 
707
        return $this->cacheResult;
708
    }
709
 
710
    public function hasCacheResultFile(): bool
711
    {
712
        return $this->cacheResultFile !== null;
713
    }
714
 
715
    /**
716
     * @throws Exception
717
     */
718
    public function cacheResultFile(): string
719
    {
720
        if ($this->cacheResultFile === null) {
721
            throw new Exception;
722
        }
723
 
724
        return $this->cacheResultFile;
725
    }
726
 
727
    public function hasCheckVersion(): bool
728
    {
729
        return $this->checkVersion !== null;
730
    }
731
 
732
    /**
733
     * @throws Exception
734
     */
735
    public function checkVersion(): bool
736
    {
737
        if ($this->checkVersion === null) {
738
            throw new Exception;
739
        }
740
 
741
        return $this->checkVersion;
742
    }
743
 
744
    public function hasColors(): bool
745
    {
746
        return $this->colors !== null;
747
    }
748
 
749
    /**
750
     * @throws Exception
751
     */
752
    public function colors(): string
753
    {
754
        if ($this->colors === null) {
755
            throw new Exception;
756
        }
757
 
758
        return $this->colors;
759
    }
760
 
761
    public function hasColumns(): bool
762
    {
763
        return $this->columns !== null;
764
    }
765
 
766
    /**
767
     * @throws Exception
768
     */
769
    public function columns()
770
    {
771
        if ($this->columns === null) {
772
            throw new Exception;
773
        }
774
 
775
        return $this->columns;
776
    }
777
 
778
    public function hasConfiguration(): bool
779
    {
780
        return $this->configuration !== null;
781
    }
782
 
783
    /**
784
     * @throws Exception
785
     */
786
    public function configuration(): string
787
    {
788
        if ($this->configuration === null) {
789
            throw new Exception;
790
        }
791
 
792
        return $this->configuration;
793
    }
794
 
795
    public function hasCoverageFilter(): bool
796
    {
797
        return $this->coverageFilter !== null;
798
    }
799
 
800
    /**
801
     * @throws Exception
802
     */
803
    public function coverageFilter(): array
804
    {
805
        if ($this->coverageFilter === null) {
806
            throw new Exception;
807
        }
808
 
809
        return $this->coverageFilter;
810
    }
811
 
812
    public function hasCoverageClover(): bool
813
    {
814
        return $this->coverageClover !== null;
815
    }
816
 
817
    /**
818
     * @throws Exception
819
     */
820
    public function coverageClover(): string
821
    {
822
        if ($this->coverageClover === null) {
823
            throw new Exception;
824
        }
825
 
826
        return $this->coverageClover;
827
    }
828
 
829
    public function hasCoverageCobertura(): bool
830
    {
831
        return $this->coverageCobertura !== null;
832
    }
833
 
834
    /**
835
     * @throws Exception
836
     */
837
    public function coverageCobertura(): string
838
    {
839
        if ($this->coverageCobertura === null) {
840
            throw new Exception;
841
        }
842
 
843
        return $this->coverageCobertura;
844
    }
845
 
846
    public function hasCoverageCrap4J(): bool
847
    {
848
        return $this->coverageCrap4J !== null;
849
    }
850
 
851
    /**
852
     * @throws Exception
853
     */
854
    public function coverageCrap4J(): string
855
    {
856
        if ($this->coverageCrap4J === null) {
857
            throw new Exception;
858
        }
859
 
860
        return $this->coverageCrap4J;
861
    }
862
 
863
    public function hasCoverageHtml(): bool
864
    {
865
        return $this->coverageHtml !== null;
866
    }
867
 
868
    /**
869
     * @throws Exception
870
     */
871
    public function coverageHtml(): string
872
    {
873
        if ($this->coverageHtml === null) {
874
            throw new Exception;
875
        }
876
 
877
        return $this->coverageHtml;
878
    }
879
 
880
    public function hasCoveragePhp(): bool
881
    {
882
        return $this->coveragePhp !== null;
883
    }
884
 
885
    /**
886
     * @throws Exception
887
     */
888
    public function coveragePhp(): string
889
    {
890
        if ($this->coveragePhp === null) {
891
            throw new Exception;
892
        }
893
 
894
        return $this->coveragePhp;
895
    }
896
 
897
    public function hasCoverageText(): bool
898
    {
899
        return $this->coverageText !== null;
900
    }
901
 
902
    /**
903
     * @throws Exception
904
     */
905
    public function coverageText(): string
906
    {
907
        if ($this->coverageText === null) {
908
            throw new Exception;
909
        }
910
 
911
        return $this->coverageText;
912
    }
913
 
914
    public function hasCoverageTextShowUncoveredFiles(): bool
915
    {
916
        return $this->coverageTextShowUncoveredFiles !== null;
917
    }
918
 
919
    /**
920
     * @throws Exception
921
     */
922
    public function coverageTextShowUncoveredFiles(): bool
923
    {
924
        if ($this->coverageTextShowUncoveredFiles === null) {
925
            throw new Exception;
926
        }
927
 
928
        return $this->coverageTextShowUncoveredFiles;
929
    }
930
 
931
    public function hasCoverageTextShowOnlySummary(): bool
932
    {
933
        return $this->coverageTextShowOnlySummary !== null;
934
    }
935
 
936
    /**
937
     * @throws Exception
938
     */
939
    public function coverageTextShowOnlySummary(): bool
940
    {
941
        if ($this->coverageTextShowOnlySummary === null) {
942
            throw new Exception;
943
        }
944
 
945
        return $this->coverageTextShowOnlySummary;
946
    }
947
 
948
    public function hasCoverageXml(): bool
949
    {
950
        return $this->coverageXml !== null;
951
    }
952
 
953
    /**
954
     * @throws Exception
955
     */
956
    public function coverageXml(): string
957
    {
958
        if ($this->coverageXml === null) {
959
            throw new Exception;
960
        }
961
 
962
        return $this->coverageXml;
963
    }
964
 
965
    public function hasPathCoverage(): bool
966
    {
967
        return $this->pathCoverage !== null;
968
    }
969
 
970
    /**
971
     * @throws Exception
972
     */
973
    public function pathCoverage(): bool
974
    {
975
        if ($this->pathCoverage === null) {
976
            throw new Exception;
977
        }
978
 
979
        return $this->pathCoverage;
980
    }
981
 
982
    public function hasCoverageCacheDirectory(): bool
983
    {
984
        return $this->coverageCacheDirectory !== null;
985
    }
986
 
987
    /**
988
     * @throws Exception
989
     */
990
    public function coverageCacheDirectory(): string
991
    {
992
        if ($this->coverageCacheDirectory === null) {
993
            throw new Exception;
994
        }
995
 
996
        return $this->coverageCacheDirectory;
997
    }
998
 
999
    public function hasWarmCoverageCache(): bool
1000
    {
1001
        return $this->warmCoverageCache !== null;
1002
    }
1003
 
1004
    /**
1005
     * @throws Exception
1006
     */
1007
    public function warmCoverageCache(): bool
1008
    {
1009
        if ($this->warmCoverageCache === null) {
1010
            throw new Exception;
1011
        }
1012
 
1013
        return $this->warmCoverageCache;
1014
    }
1015
 
1016
    public function hasDebug(): bool
1017
    {
1018
        return $this->debug !== null;
1019
    }
1020
 
1021
    /**
1022
     * @throws Exception
1023
     */
1024
    public function debug(): bool
1025
    {
1026
        if ($this->debug === null) {
1027
            throw new Exception;
1028
        }
1029
 
1030
        return $this->debug;
1031
    }
1032
 
1033
    public function hasDefaultTimeLimit(): bool
1034
    {
1035
        return $this->defaultTimeLimit !== null;
1036
    }
1037
 
1038
    /**
1039
     * @throws Exception
1040
     */
1041
    public function defaultTimeLimit(): int
1042
    {
1043
        if ($this->defaultTimeLimit === null) {
1044
            throw new Exception;
1045
        }
1046
 
1047
        return $this->defaultTimeLimit;
1048
    }
1049
 
1050
    public function hasDisableCodeCoverageIgnore(): bool
1051
    {
1052
        return $this->disableCodeCoverageIgnore !== null;
1053
    }
1054
 
1055
    /**
1056
     * @throws Exception
1057
     */
1058
    public function disableCodeCoverageIgnore(): bool
1059
    {
1060
        if ($this->disableCodeCoverageIgnore === null) {
1061
            throw new Exception;
1062
        }
1063
 
1064
        return $this->disableCodeCoverageIgnore;
1065
    }
1066
 
1067
    public function hasDisallowTestOutput(): bool
1068
    {
1069
        return $this->disallowTestOutput !== null;
1070
    }
1071
 
1072
    /**
1073
     * @throws Exception
1074
     */
1075
    public function disallowTestOutput(): bool
1076
    {
1077
        if ($this->disallowTestOutput === null) {
1078
            throw new Exception;
1079
        }
1080
 
1081
        return $this->disallowTestOutput;
1082
    }
1083
 
1084
    public function hasDisallowTodoAnnotatedTests(): bool
1085
    {
1086
        return $this->disallowTodoAnnotatedTests !== null;
1087
    }
1088
 
1089
    /**
1090
     * @throws Exception
1091
     */
1092
    public function disallowTodoAnnotatedTests(): bool
1093
    {
1094
        if ($this->disallowTodoAnnotatedTests === null) {
1095
            throw new Exception;
1096
        }
1097
 
1098
        return $this->disallowTodoAnnotatedTests;
1099
    }
1100
 
1101
    public function hasEnforceTimeLimit(): bool
1102
    {
1103
        return $this->enforceTimeLimit !== null;
1104
    }
1105
 
1106
    /**
1107
     * @throws Exception
1108
     */
1109
    public function enforceTimeLimit(): bool
1110
    {
1111
        if ($this->enforceTimeLimit === null) {
1112
            throw new Exception;
1113
        }
1114
 
1115
        return $this->enforceTimeLimit;
1116
    }
1117
 
1118
    public function hasExcludeGroups(): bool
1119
    {
1120
        return $this->excludeGroups !== null;
1121
    }
1122
 
1123
    /**
1124
     * @throws Exception
1125
     */
1126
    public function excludeGroups(): array
1127
    {
1128
        if ($this->excludeGroups === null) {
1129
            throw new Exception;
1130
        }
1131
 
1132
        return $this->excludeGroups;
1133
    }
1134
 
1135
    public function hasExecutionOrder(): bool
1136
    {
1137
        return $this->executionOrder !== null;
1138
    }
1139
 
1140
    /**
1141
     * @throws Exception
1142
     */
1143
    public function executionOrder(): int
1144
    {
1145
        if ($this->executionOrder === null) {
1146
            throw new Exception;
1147
        }
1148
 
1149
        return $this->executionOrder;
1150
    }
1151
 
1152
    public function hasExecutionOrderDefects(): bool
1153
    {
1154
        return $this->executionOrderDefects !== null;
1155
    }
1156
 
1157
    /**
1158
     * @throws Exception
1159
     */
1160
    public function executionOrderDefects(): int
1161
    {
1162
        if ($this->executionOrderDefects === null) {
1163
            throw new Exception;
1164
        }
1165
 
1166
        return $this->executionOrderDefects;
1167
    }
1168
 
1169
    public function hasFailOnEmptyTestSuite(): bool
1170
    {
1171
        return $this->failOnEmptyTestSuite !== null;
1172
    }
1173
 
1174
    /**
1175
     * @throws Exception
1176
     */
1177
    public function failOnEmptyTestSuite(): bool
1178
    {
1179
        if ($this->failOnEmptyTestSuite === null) {
1180
            throw new Exception;
1181
        }
1182
 
1183
        return $this->failOnEmptyTestSuite;
1184
    }
1185
 
1186
    public function hasFailOnIncomplete(): bool
1187
    {
1188
        return $this->failOnIncomplete !== null;
1189
    }
1190
 
1191
    /**
1192
     * @throws Exception
1193
     */
1194
    public function failOnIncomplete(): bool
1195
    {
1196
        if ($this->failOnIncomplete === null) {
1197
            throw new Exception;
1198
        }
1199
 
1200
        return $this->failOnIncomplete;
1201
    }
1202
 
1203
    public function hasFailOnRisky(): bool
1204
    {
1205
        return $this->failOnRisky !== null;
1206
    }
1207
 
1208
    /**
1209
     * @throws Exception
1210
     */
1211
    public function failOnRisky(): bool
1212
    {
1213
        if ($this->failOnRisky === null) {
1214
            throw new Exception;
1215
        }
1216
 
1217
        return $this->failOnRisky;
1218
    }
1219
 
1220
    public function hasFailOnSkipped(): bool
1221
    {
1222
        return $this->failOnSkipped !== null;
1223
    }
1224
 
1225
    /**
1226
     * @throws Exception
1227
     */
1228
    public function failOnSkipped(): bool
1229
    {
1230
        if ($this->failOnSkipped === null) {
1231
            throw new Exception;
1232
        }
1233
 
1234
        return $this->failOnSkipped;
1235
    }
1236
 
1237
    public function hasFailOnWarning(): bool
1238
    {
1239
        return $this->failOnWarning !== null;
1240
    }
1241
 
1242
    /**
1243
     * @throws Exception
1244
     */
1245
    public function failOnWarning(): bool
1246
    {
1247
        if ($this->failOnWarning === null) {
1248
            throw new Exception;
1249
        }
1250
 
1251
        return $this->failOnWarning;
1252
    }
1253
 
1254
    public function hasFilter(): bool
1255
    {
1256
        return $this->filter !== null;
1257
    }
1258
 
1259
    /**
1260
     * @throws Exception
1261
     */
1262
    public function filter(): string
1263
    {
1264
        if ($this->filter === null) {
1265
            throw new Exception;
1266
        }
1267
 
1268
        return $this->filter;
1269
    }
1270
 
1271
    public function hasGenerateConfiguration(): bool
1272
    {
1273
        return $this->generateConfiguration !== null;
1274
    }
1275
 
1276
    /**
1277
     * @throws Exception
1278
     */
1279
    public function generateConfiguration(): bool
1280
    {
1281
        if ($this->generateConfiguration === null) {
1282
            throw new Exception;
1283
        }
1284
 
1285
        return $this->generateConfiguration;
1286
    }
1287
 
1288
    public function hasMigrateConfiguration(): bool
1289
    {
1290
        return $this->migrateConfiguration !== null;
1291
    }
1292
 
1293
    /**
1294
     * @throws Exception
1295
     */
1296
    public function migrateConfiguration(): bool
1297
    {
1298
        if ($this->migrateConfiguration === null) {
1299
            throw new Exception;
1300
        }
1301
 
1302
        return $this->migrateConfiguration;
1303
    }
1304
 
1305
    public function hasGroups(): bool
1306
    {
1307
        return $this->groups !== null;
1308
    }
1309
 
1310
    /**
1311
     * @throws Exception
1312
     */
1313
    public function groups(): array
1314
    {
1315
        if ($this->groups === null) {
1316
            throw new Exception;
1317
        }
1318
 
1319
        return $this->groups;
1320
    }
1321
 
1322
    public function hasTestsCovering(): bool
1323
    {
1324
        return $this->testsCovering !== null;
1325
    }
1326
 
1327
    /**
1328
     * @throws Exception
1329
     */
1330
    public function testsCovering(): array
1331
    {
1332
        if ($this->testsCovering === null) {
1333
            throw new Exception;
1334
        }
1335
 
1336
        return $this->testsCovering;
1337
    }
1338
 
1339
    public function hasTestsUsing(): bool
1340
    {
1341
        return $this->testsUsing !== null;
1342
    }
1343
 
1344
    /**
1345
     * @throws Exception
1346
     */
1347
    public function testsUsing(): array
1348
    {
1349
        if ($this->testsUsing === null) {
1350
            throw new Exception;
1351
        }
1352
 
1353
        return $this->testsUsing;
1354
    }
1355
 
1356
    public function hasHelp(): bool
1357
    {
1358
        return $this->help !== null;
1359
    }
1360
 
1361
    /**
1362
     * @throws Exception
1363
     */
1364
    public function help(): bool
1365
    {
1366
        if ($this->help === null) {
1367
            throw new Exception;
1368
        }
1369
 
1370
        return $this->help;
1371
    }
1372
 
1373
    public function hasIncludePath(): bool
1374
    {
1375
        return $this->includePath !== null;
1376
    }
1377
 
1378
    /**
1379
     * @throws Exception
1380
     */
1381
    public function includePath(): string
1382
    {
1383
        if ($this->includePath === null) {
1384
            throw new Exception;
1385
        }
1386
 
1387
        return $this->includePath;
1388
    }
1389
 
1390
    public function hasIniSettings(): bool
1391
    {
1392
        return $this->iniSettings !== null;
1393
    }
1394
 
1395
    /**
1396
     * @throws Exception
1397
     */
1398
    public function iniSettings(): array
1399
    {
1400
        if ($this->iniSettings === null) {
1401
            throw new Exception;
1402
        }
1403
 
1404
        return $this->iniSettings;
1405
    }
1406
 
1407
    public function hasJunitLogfile(): bool
1408
    {
1409
        return $this->junitLogfile !== null;
1410
    }
1411
 
1412
    /**
1413
     * @throws Exception
1414
     */
1415
    public function junitLogfile(): string
1416
    {
1417
        if ($this->junitLogfile === null) {
1418
            throw new Exception;
1419
        }
1420
 
1421
        return $this->junitLogfile;
1422
    }
1423
 
1424
    public function hasListGroups(): bool
1425
    {
1426
        return $this->listGroups !== null;
1427
    }
1428
 
1429
    /**
1430
     * @throws Exception
1431
     */
1432
    public function listGroups(): bool
1433
    {
1434
        if ($this->listGroups === null) {
1435
            throw new Exception;
1436
        }
1437
 
1438
        return $this->listGroups;
1439
    }
1440
 
1441
    public function hasListSuites(): bool
1442
    {
1443
        return $this->listSuites !== null;
1444
    }
1445
 
1446
    /**
1447
     * @throws Exception
1448
     */
1449
    public function listSuites(): bool
1450
    {
1451
        if ($this->listSuites === null) {
1452
            throw new Exception;
1453
        }
1454
 
1455
        return $this->listSuites;
1456
    }
1457
 
1458
    public function hasListTests(): bool
1459
    {
1460
        return $this->listTests !== null;
1461
    }
1462
 
1463
    /**
1464
     * @throws Exception
1465
     */
1466
    public function listTests(): bool
1467
    {
1468
        if ($this->listTests === null) {
1469
            throw new Exception;
1470
        }
1471
 
1472
        return $this->listTests;
1473
    }
1474
 
1475
    public function hasListTestsXml(): bool
1476
    {
1477
        return $this->listTestsXml !== null;
1478
    }
1479
 
1480
    /**
1481
     * @throws Exception
1482
     */
1483
    public function listTestsXml(): string
1484
    {
1485
        if ($this->listTestsXml === null) {
1486
            throw new Exception;
1487
        }
1488
 
1489
        return $this->listTestsXml;
1490
    }
1491
 
1492
    public function hasLoader(): bool
1493
    {
1494
        return $this->loader !== null;
1495
    }
1496
 
1497
    /**
1498
     * @throws Exception
1499
     */
1500
    public function loader(): string
1501
    {
1502
        if ($this->loader === null) {
1503
            throw new Exception;
1504
        }
1505
 
1506
        return $this->loader;
1507
    }
1508
 
1509
    public function hasNoCoverage(): bool
1510
    {
1511
        return $this->noCoverage !== null;
1512
    }
1513
 
1514
    /**
1515
     * @throws Exception
1516
     */
1517
    public function noCoverage(): bool
1518
    {
1519
        if ($this->noCoverage === null) {
1520
            throw new Exception;
1521
        }
1522
 
1523
        return $this->noCoverage;
1524
    }
1525
 
1526
    public function hasNoExtensions(): bool
1527
    {
1528
        return $this->noExtensions !== null;
1529
    }
1530
 
1531
    /**
1532
     * @throws Exception
1533
     */
1534
    public function noExtensions(): bool
1535
    {
1536
        if ($this->noExtensions === null) {
1537
            throw new Exception;
1538
        }
1539
 
1540
        return $this->noExtensions;
1541
    }
1542
 
1543
    public function hasExtensions(): bool
1544
    {
1545
        return $this->extensions !== null;
1546
    }
1547
 
1548
    /**
1549
     * @throws Exception
1550
     */
1551
    public function extensions(): array
1552
    {
1553
        if ($this->extensions === null) {
1554
            throw new Exception;
1555
        }
1556
 
1557
        return $this->extensions;
1558
    }
1559
 
1560
    public function hasUnavailableExtensions(): bool
1561
    {
1562
        return $this->unavailableExtensions !== null;
1563
    }
1564
 
1565
    /**
1566
     * @throws Exception
1567
     */
1568
    public function unavailableExtensions(): array
1569
    {
1570
        if ($this->unavailableExtensions === null) {
1571
            throw new Exception;
1572
        }
1573
 
1574
        return $this->unavailableExtensions;
1575
    }
1576
 
1577
    public function hasNoInteraction(): bool
1578
    {
1579
        return $this->noInteraction !== null;
1580
    }
1581
 
1582
    /**
1583
     * @throws Exception
1584
     */
1585
    public function noInteraction(): bool
1586
    {
1587
        if ($this->noInteraction === null) {
1588
            throw new Exception;
1589
        }
1590
 
1591
        return $this->noInteraction;
1592
    }
1593
 
1594
    public function hasNoLogging(): bool
1595
    {
1596
        return $this->noLogging !== null;
1597
    }
1598
 
1599
    /**
1600
     * @throws Exception
1601
     */
1602
    public function noLogging(): bool
1603
    {
1604
        if ($this->noLogging === null) {
1605
            throw new Exception;
1606
        }
1607
 
1608
        return $this->noLogging;
1609
    }
1610
 
1611
    public function hasPrinter(): bool
1612
    {
1613
        return $this->printer !== null;
1614
    }
1615
 
1616
    /**
1617
     * @throws Exception
1618
     */
1619
    public function printer(): string
1620
    {
1621
        if ($this->printer === null) {
1622
            throw new Exception;
1623
        }
1624
 
1625
        return $this->printer;
1626
    }
1627
 
1628
    public function hasProcessIsolation(): bool
1629
    {
1630
        return $this->processIsolation !== null;
1631
    }
1632
 
1633
    /**
1634
     * @throws Exception
1635
     */
1636
    public function processIsolation(): bool
1637
    {
1638
        if ($this->processIsolation === null) {
1639
            throw new Exception;
1640
        }
1641
 
1642
        return $this->processIsolation;
1643
    }
1644
 
1645
    public function hasRandomOrderSeed(): bool
1646
    {
1647
        return $this->randomOrderSeed !== null;
1648
    }
1649
 
1650
    /**
1651
     * @throws Exception
1652
     */
1653
    public function randomOrderSeed(): int
1654
    {
1655
        if ($this->randomOrderSeed === null) {
1656
            throw new Exception;
1657
        }
1658
 
1659
        return $this->randomOrderSeed;
1660
    }
1661
 
1662
    public function hasRepeat(): bool
1663
    {
1664
        return $this->repeat !== null;
1665
    }
1666
 
1667
    /**
1668
     * @throws Exception
1669
     */
1670
    public function repeat(): int
1671
    {
1672
        if ($this->repeat === null) {
1673
            throw new Exception;
1674
        }
1675
 
1676
        return $this->repeat;
1677
    }
1678
 
1679
    public function hasReportUselessTests(): bool
1680
    {
1681
        return $this->reportUselessTests !== null;
1682
    }
1683
 
1684
    /**
1685
     * @throws Exception
1686
     */
1687
    public function reportUselessTests(): bool
1688
    {
1689
        if ($this->reportUselessTests === null) {
1690
            throw new Exception;
1691
        }
1692
 
1693
        return $this->reportUselessTests;
1694
    }
1695
 
1696
    public function hasResolveDependencies(): bool
1697
    {
1698
        return $this->resolveDependencies !== null;
1699
    }
1700
 
1701
    /**
1702
     * @throws Exception
1703
     */
1704
    public function resolveDependencies(): bool
1705
    {
1706
        if ($this->resolveDependencies === null) {
1707
            throw new Exception;
1708
        }
1709
 
1710
        return $this->resolveDependencies;
1711
    }
1712
 
1713
    public function hasReverseList(): bool
1714
    {
1715
        return $this->reverseList !== null;
1716
    }
1717
 
1718
    /**
1719
     * @throws Exception
1720
     */
1721
    public function reverseList(): bool
1722
    {
1723
        if ($this->reverseList === null) {
1724
            throw new Exception;
1725
        }
1726
 
1727
        return $this->reverseList;
1728
    }
1729
 
1730
    public function hasStderr(): bool
1731
    {
1732
        return $this->stderr !== null;
1733
    }
1734
 
1735
    /**
1736
     * @throws Exception
1737
     */
1738
    public function stderr(): bool
1739
    {
1740
        if ($this->stderr === null) {
1741
            throw new Exception;
1742
        }
1743
 
1744
        return $this->stderr;
1745
    }
1746
 
1747
    public function hasStrictCoverage(): bool
1748
    {
1749
        return $this->strictCoverage !== null;
1750
    }
1751
 
1752
    /**
1753
     * @throws Exception
1754
     */
1755
    public function strictCoverage(): bool
1756
    {
1757
        if ($this->strictCoverage === null) {
1758
            throw new Exception;
1759
        }
1760
 
1761
        return $this->strictCoverage;
1762
    }
1763
 
1764
    public function hasStopOnDefect(): bool
1765
    {
1766
        return $this->stopOnDefect !== null;
1767
    }
1768
 
1769
    /**
1770
     * @throws Exception
1771
     */
1772
    public function stopOnDefect(): bool
1773
    {
1774
        if ($this->stopOnDefect === null) {
1775
            throw new Exception;
1776
        }
1777
 
1778
        return $this->stopOnDefect;
1779
    }
1780
 
1781
    public function hasStopOnError(): bool
1782
    {
1783
        return $this->stopOnError !== null;
1784
    }
1785
 
1786
    /**
1787
     * @throws Exception
1788
     */
1789
    public function stopOnError(): bool
1790
    {
1791
        if ($this->stopOnError === null) {
1792
            throw new Exception;
1793
        }
1794
 
1795
        return $this->stopOnError;
1796
    }
1797
 
1798
    public function hasStopOnFailure(): bool
1799
    {
1800
        return $this->stopOnFailure !== null;
1801
    }
1802
 
1803
    /**
1804
     * @throws Exception
1805
     */
1806
    public function stopOnFailure(): bool
1807
    {
1808
        if ($this->stopOnFailure === null) {
1809
            throw new Exception;
1810
        }
1811
 
1812
        return $this->stopOnFailure;
1813
    }
1814
 
1815
    public function hasStopOnIncomplete(): bool
1816
    {
1817
        return $this->stopOnIncomplete !== null;
1818
    }
1819
 
1820
    /**
1821
     * @throws Exception
1822
     */
1823
    public function stopOnIncomplete(): bool
1824
    {
1825
        if ($this->stopOnIncomplete === null) {
1826
            throw new Exception;
1827
        }
1828
 
1829
        return $this->stopOnIncomplete;
1830
    }
1831
 
1832
    public function hasStopOnRisky(): bool
1833
    {
1834
        return $this->stopOnRisky !== null;
1835
    }
1836
 
1837
    /**
1838
     * @throws Exception
1839
     */
1840
    public function stopOnRisky(): bool
1841
    {
1842
        if ($this->stopOnRisky === null) {
1843
            throw new Exception;
1844
        }
1845
 
1846
        return $this->stopOnRisky;
1847
    }
1848
 
1849
    public function hasStopOnSkipped(): bool
1850
    {
1851
        return $this->stopOnSkipped !== null;
1852
    }
1853
 
1854
    /**
1855
     * @throws Exception
1856
     */
1857
    public function stopOnSkipped(): bool
1858
    {
1859
        if ($this->stopOnSkipped === null) {
1860
            throw new Exception;
1861
        }
1862
 
1863
        return $this->stopOnSkipped;
1864
    }
1865
 
1866
    public function hasStopOnWarning(): bool
1867
    {
1868
        return $this->stopOnWarning !== null;
1869
    }
1870
 
1871
    /**
1872
     * @throws Exception
1873
     */
1874
    public function stopOnWarning(): bool
1875
    {
1876
        if ($this->stopOnWarning === null) {
1877
            throw new Exception;
1878
        }
1879
 
1880
        return $this->stopOnWarning;
1881
    }
1882
 
1883
    public function hasTeamcityLogfile(): bool
1884
    {
1885
        return $this->teamcityLogfile !== null;
1886
    }
1887
 
1888
    /**
1889
     * @throws Exception
1890
     */
1891
    public function teamcityLogfile(): string
1892
    {
1893
        if ($this->teamcityLogfile === null) {
1894
            throw new Exception;
1895
        }
1896
 
1897
        return $this->teamcityLogfile;
1898
    }
1899
 
1900
    public function hasTestdoxExcludeGroups(): bool
1901
    {
1902
        return $this->testdoxExcludeGroups !== null;
1903
    }
1904
 
1905
    /**
1906
     * @throws Exception
1907
     */
1908
    public function testdoxExcludeGroups(): array
1909
    {
1910
        if ($this->testdoxExcludeGroups === null) {
1911
            throw new Exception;
1912
        }
1913
 
1914
        return $this->testdoxExcludeGroups;
1915
    }
1916
 
1917
    public function hasTestdoxGroups(): bool
1918
    {
1919
        return $this->testdoxGroups !== null;
1920
    }
1921
 
1922
    /**
1923
     * @throws Exception
1924
     */
1925
    public function testdoxGroups(): array
1926
    {
1927
        if ($this->testdoxGroups === null) {
1928
            throw new Exception;
1929
        }
1930
 
1931
        return $this->testdoxGroups;
1932
    }
1933
 
1934
    public function hasTestdoxHtmlFile(): bool
1935
    {
1936
        return $this->testdoxHtmlFile !== null;
1937
    }
1938
 
1939
    /**
1940
     * @throws Exception
1941
     */
1942
    public function testdoxHtmlFile(): string
1943
    {
1944
        if ($this->testdoxHtmlFile === null) {
1945
            throw new Exception;
1946
        }
1947
 
1948
        return $this->testdoxHtmlFile;
1949
    }
1950
 
1951
    public function hasTestdoxTextFile(): bool
1952
    {
1953
        return $this->testdoxTextFile !== null;
1954
    }
1955
 
1956
    /**
1957
     * @throws Exception
1958
     */
1959
    public function testdoxTextFile(): string
1960
    {
1961
        if ($this->testdoxTextFile === null) {
1962
            throw new Exception;
1963
        }
1964
 
1965
        return $this->testdoxTextFile;
1966
    }
1967
 
1968
    public function hasTestdoxXmlFile(): bool
1969
    {
1970
        return $this->testdoxXmlFile !== null;
1971
    }
1972
 
1973
    /**
1974
     * @throws Exception
1975
     */
1976
    public function testdoxXmlFile(): string
1977
    {
1978
        if ($this->testdoxXmlFile === null) {
1979
            throw new Exception;
1980
        }
1981
 
1982
        return $this->testdoxXmlFile;
1983
    }
1984
 
1985
    public function hasTestSuffixes(): bool
1986
    {
1987
        return $this->testSuffixes !== null;
1988
    }
1989
 
1990
    /**
1991
     * @throws Exception
1992
     */
1993
    public function testSuffixes(): array
1994
    {
1995
        if ($this->testSuffixes === null) {
1996
            throw new Exception;
1997
        }
1998
 
1999
        return $this->testSuffixes;
2000
    }
2001
 
2002
    public function hasTestSuite(): bool
2003
    {
2004
        return $this->testSuite !== null;
2005
    }
2006
 
2007
    /**
2008
     * @throws Exception
2009
     */
2010
    public function testSuite(): string
2011
    {
2012
        if ($this->testSuite === null) {
2013
            throw new Exception;
2014
        }
2015
 
2016
        return $this->testSuite;
2017
    }
2018
 
2019
    public function unrecognizedOptions(): array
2020
    {
2021
        return $this->unrecognizedOptions;
2022
    }
2023
 
2024
    public function hasUnrecognizedOrderBy(): bool
2025
    {
2026
        return $this->unrecognizedOrderBy !== null;
2027
    }
2028
 
2029
    /**
2030
     * @throws Exception
2031
     */
2032
    public function unrecognizedOrderBy(): string
2033
    {
2034
        if ($this->unrecognizedOrderBy === null) {
2035
            throw new Exception;
2036
        }
2037
 
2038
        return $this->unrecognizedOrderBy;
2039
    }
2040
 
2041
    public function hasUseDefaultConfiguration(): bool
2042
    {
2043
        return $this->useDefaultConfiguration !== null;
2044
    }
2045
 
2046
    /**
2047
     * @throws Exception
2048
     */
2049
    public function useDefaultConfiguration(): bool
2050
    {
2051
        if ($this->useDefaultConfiguration === null) {
2052
            throw new Exception;
2053
        }
2054
 
2055
        return $this->useDefaultConfiguration;
2056
    }
2057
 
2058
    public function hasVerbose(): bool
2059
    {
2060
        return $this->verbose !== null;
2061
    }
2062
 
2063
    /**
2064
     * @throws Exception
2065
     */
2066
    public function verbose(): bool
2067
    {
2068
        if ($this->verbose === null) {
2069
            throw new Exception;
2070
        }
2071
 
2072
        return $this->verbose;
2073
    }
2074
 
2075
    public function hasVersion(): bool
2076
    {
2077
        return $this->version !== null;
2078
    }
2079
 
2080
    /**
2081
     * @throws Exception
2082
     */
2083
    public function version(): bool
2084
    {
2085
        if ($this->version === null) {
2086
            throw new Exception;
2087
        }
2088
 
2089
        return $this->version;
2090
    }
2091
 
2092
    public function hasXdebugFilterFile(): bool
2093
    {
2094
        return $this->xdebugFilterFile !== null;
2095
    }
2096
 
2097
    /**
2098
     * @throws Exception
2099
     */
2100
    public function xdebugFilterFile(): string
2101
    {
2102
        if ($this->xdebugFilterFile === null) {
2103
            throw new Exception;
2104
        }
2105
 
2106
        return $this->xdebugFilterFile;
2107
    }
2108
}