Subversion-Projekte lars-tiefland.laravel_shop

Revision

Zur aktuellen 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 function array_map;
13
use function array_merge;
14
use function class_exists;
15
use function explode;
16
use function is_numeric;
17
use function str_replace;
18
use PHPUnit\Runner\TestSuiteSorter;
19
use PHPUnit\TextUI\DefaultResultPrinter;
20
use PHPUnit\TextUI\XmlConfiguration\Extension;
21
use PHPUnit\Util\Log\TeamCity;
22
use PHPUnit\Util\TestDox\CliTestDoxPrinter;
23
use SebastianBergmann\CliParser\Exception as CliParserException;
24
use SebastianBergmann\CliParser\Parser as CliParser;
25
 
26
/**
27
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
28
 */
29
final class Builder
30
{
31
    private const LONG_OPTIONS = [
32
        'atleast-version=',
33
        'prepend=',
34
        'bootstrap=',
35
        'cache-result',
36
        'do-not-cache-result',
37
        'cache-result-file=',
38
        'check-version',
39
        'colors==',
40
        'columns=',
41
        'configuration=',
42
        'coverage-cache=',
43
        'warm-coverage-cache',
44
        'coverage-filter=',
45
        'coverage-clover=',
46
        'coverage-cobertura=',
47
        'coverage-crap4j=',
48
        'coverage-html=',
49
        'coverage-php=',
50
        'coverage-text==',
51
        'coverage-xml=',
52
        'path-coverage',
53
        'debug',
54
        'disallow-test-output',
55
        'disallow-resource-usage',
56
        'disallow-todo-tests',
57
        'default-time-limit=',
58
        'enforce-time-limit',
59
        'exclude-group=',
60
        'extensions=',
61
        'filter=',
62
        'generate-configuration',
63
        'globals-backup',
64
        'group=',
65
        'covers=',
66
        'uses=',
67
        'help',
68
        'resolve-dependencies',
69
        'ignore-dependencies',
70
        'include-path=',
71
        'list-groups',
72
        'list-suites',
73
        'list-tests',
74
        'list-tests-xml=',
75
        'loader=',
76
        'log-junit=',
77
        'log-teamcity=',
78
        'migrate-configuration',
79
        'no-configuration',
80
        'no-coverage',
81
        'no-logging',
82
        'no-interaction',
83
        'no-extensions',
84
        'order-by=',
85
        'printer=',
86
        'process-isolation',
87
        'repeat=',
88
        'dont-report-useless-tests',
89
        'random-order',
90
        'random-order-seed=',
91
        'reverse-order',
92
        'reverse-list',
93
        'static-backup',
94
        'stderr',
95
        'stop-on-defect',
96
        'stop-on-error',
97
        'stop-on-failure',
98
        'stop-on-warning',
99
        'stop-on-incomplete',
100
        'stop-on-risky',
101
        'stop-on-skipped',
102
        'fail-on-empty-test-suite',
103
        'fail-on-incomplete',
104
        'fail-on-risky',
105
        'fail-on-skipped',
106
        'fail-on-warning',
107
        'strict-coverage',
108
        'disable-coverage-ignore',
109
        'strict-global-state',
110
        'teamcity',
111
        'testdox',
112
        'testdox-group=',
113
        'testdox-exclude-group=',
114
        'testdox-html=',
115
        'testdox-text=',
116
        'testdox-xml=',
117
        'test-suffix=',
118
        'testsuite=',
119
        'verbose',
120
        'version',
121
        'whitelist=',
122
        'dump-xdebug-filter=',
123
    ];
124
 
125
    private const SHORT_OPTIONS = 'd:c:hv';
126
 
127
    public function fromParameters(array $parameters, array $additionalLongOptions): Configuration
128
    {
129
        try {
130
            $options = (new CliParser)->parse(
131
                $parameters,
132
                self::SHORT_OPTIONS,
133
                array_merge(self::LONG_OPTIONS, $additionalLongOptions)
134
            );
135
        } catch (CliParserException $e) {
136
            throw new Exception(
137
                $e->getMessage(),
138
                $e->getCode(),
139
                $e
140
            );
141
        }
142
 
143
        $argument                                   = null;
144
        $atLeastVersion                             = null;
145
        $backupGlobals                              = null;
146
        $backupStaticAttributes                     = null;
147
        $beStrictAboutChangesToGlobalState          = null;
148
        $beStrictAboutResourceUsageDuringSmallTests = null;
149
        $bootstrap                                  = null;
150
        $cacheResult                                = null;
151
        $cacheResultFile                            = null;
152
        $checkVersion                               = null;
153
        $colors                                     = null;
154
        $columns                                    = null;
155
        $configuration                              = null;
156
        $coverageCacheDirectory                     = null;
157
        $warmCoverageCache                          = null;
158
        $coverageFilter                             = null;
159
        $coverageClover                             = null;
160
        $coverageCobertura                          = null;
161
        $coverageCrap4J                             = null;
162
        $coverageHtml                               = null;
163
        $coveragePhp                                = null;
164
        $coverageText                               = null;
165
        $coverageTextShowUncoveredFiles             = null;
166
        $coverageTextShowOnlySummary                = null;
167
        $coverageXml                                = null;
168
        $pathCoverage                               = null;
169
        $debug                                      = null;
170
        $defaultTimeLimit                           = null;
171
        $disableCodeCoverageIgnore                  = null;
172
        $disallowTestOutput                         = null;
173
        $disallowTodoAnnotatedTests                 = null;
174
        $enforceTimeLimit                           = null;
175
        $excludeGroups                              = null;
176
        $executionOrder                             = null;
177
        $executionOrderDefects                      = null;
178
        $extensions                                 = [];
179
        $unavailableExtensions                      = [];
180
        $failOnEmptyTestSuite                       = null;
181
        $failOnIncomplete                           = null;
182
        $failOnRisky                                = null;
183
        $failOnSkipped                              = null;
184
        $failOnWarning                              = null;
185
        $filter                                     = null;
186
        $generateConfiguration                      = null;
187
        $migrateConfiguration                       = null;
188
        $groups                                     = null;
189
        $testsCovering                              = null;
190
        $testsUsing                                 = null;
191
        $help                                       = null;
192
        $includePath                                = null;
193
        $iniSettings                                = [];
194
        $junitLogfile                               = null;
195
        $listGroups                                 = null;
196
        $listSuites                                 = null;
197
        $listTests                                  = null;
198
        $listTestsXml                               = null;
199
        $loader                                     = null;
200
        $noCoverage                                 = null;
201
        $noExtensions                               = null;
202
        $noInteraction                              = null;
203
        $noLogging                                  = null;
204
        $printer                                    = null;
205
        $processIsolation                           = null;
206
        $randomOrderSeed                            = null;
207
        $repeat                                     = null;
208
        $reportUselessTests                         = null;
209
        $resolveDependencies                        = null;
210
        $reverseList                                = null;
211
        $stderr                                     = null;
212
        $strictCoverage                             = null;
213
        $stopOnDefect                               = null;
214
        $stopOnError                                = null;
215
        $stopOnFailure                              = null;
216
        $stopOnIncomplete                           = null;
217
        $stopOnRisky                                = null;
218
        $stopOnSkipped                              = null;
219
        $stopOnWarning                              = null;
220
        $teamcityLogfile                            = null;
221
        $testdoxExcludeGroups                       = null;
222
        $testdoxGroups                              = null;
223
        $testdoxHtmlFile                            = null;
224
        $testdoxTextFile                            = null;
225
        $testdoxXmlFile                             = null;
226
        $testSuffixes                               = null;
227
        $testSuite                                  = null;
228
        $unrecognizedOptions                        = [];
229
        $unrecognizedOrderBy                        = null;
230
        $useDefaultConfiguration                    = null;
231
        $verbose                                    = null;
232
        $version                                    = null;
233
        $xdebugFilterFile                           = null;
234
 
235
        if (isset($options[1][0])) {
236
            $argument = $options[1][0];
237
        }
238
 
239
        foreach ($options[0] as $option) {
240
            switch ($option[0]) {
241
                case '--colors':
242
                    $colors = $option[1] ?: DefaultResultPrinter::COLOR_AUTO;
243
 
244
                    break;
245
 
246
                case '--bootstrap':
247
                    $bootstrap = $option[1];
248
 
249
                    break;
250
 
251
                case '--cache-result':
252
                    $cacheResult = true;
253
 
254
                    break;
255
 
256
                case '--do-not-cache-result':
257
                    $cacheResult = false;
258
 
259
                    break;
260
 
261
                case '--cache-result-file':
262
                    $cacheResultFile = $option[1];
263
 
264
                    break;
265
 
266
                case '--columns':
267
                    if (is_numeric($option[1])) {
268
                        $columns = (int) $option[1];
269
                    } elseif ($option[1] === 'max') {
270
                        $columns = 'max';
271
                    }
272
 
273
                    break;
274
 
275
                case 'c':
276
                case '--configuration':
277
                    $configuration = $option[1];
278
 
279
                    break;
280
 
281
                case '--coverage-cache':
282
                    $coverageCacheDirectory = $option[1];
283
 
284
                    break;
285
 
286
                case '--warm-coverage-cache':
287
                    $warmCoverageCache = true;
288
 
289
                    break;
290
 
291
                case '--coverage-clover':
292
                    $coverageClover = $option[1];
293
 
294
                    break;
295
 
296
                case '--coverage-cobertura':
297
                    $coverageCobertura = $option[1];
298
 
299
                    break;
300
 
301
                case '--coverage-crap4j':
302
                    $coverageCrap4J = $option[1];
303
 
304
                    break;
305
 
306
                case '--coverage-html':
307
                    $coverageHtml = $option[1];
308
 
309
                    break;
310
 
311
                case '--coverage-php':
312
                    $coveragePhp = $option[1];
313
 
314
                    break;
315
 
316
                case '--coverage-text':
317
                    if ($option[1] === null) {
318
                        $option[1] = 'php://stdout';
319
                    }
320
 
321
                    $coverageText                   = $option[1];
322
                    $coverageTextShowUncoveredFiles = false;
323
                    $coverageTextShowOnlySummary    = false;
324
 
325
                    break;
326
 
327
                case '--coverage-xml':
328
                    $coverageXml = $option[1];
329
 
330
                    break;
331
 
332
                case '--path-coverage':
333
                    $pathCoverage = true;
334
 
335
                    break;
336
 
337
                case 'd':
338
                    $tmp = explode('=', $option[1]);
339
 
340
                    if (isset($tmp[0])) {
341
                        if (isset($tmp[1])) {
342
                            $iniSettings[$tmp[0]] = $tmp[1];
343
                        } else {
344
                            $iniSettings[$tmp[0]] = '1';
345
                        }
346
                    }
347
 
348
                    break;
349
 
350
                case '--debug':
351
                    $debug = true;
352
 
353
                    break;
354
 
355
                case 'h':
356
                case '--help':
357
                    $help = true;
358
 
359
                    break;
360
 
361
                case '--filter':
362
                    $filter = $option[1];
363
 
364
                    break;
365
 
366
                case '--testsuite':
367
                    $testSuite = $option[1];
368
 
369
                    break;
370
 
371
                case '--generate-configuration':
372
                    $generateConfiguration = true;
373
 
374
                    break;
375
 
376
                case '--migrate-configuration':
377
                    $migrateConfiguration = true;
378
 
379
                    break;
380
 
381
                case '--group':
382
                    $groups = explode(',', $option[1]);
383
 
384
                    break;
385
 
386
                case '--exclude-group':
387
                    $excludeGroups = explode(',', $option[1]);
388
 
389
                    break;
390
 
391
                case '--covers':
392
                    $testsCovering = array_map('strtolower', explode(',', $option[1]));
393
 
394
                    break;
395
 
396
                case '--uses':
397
                    $testsUsing = array_map('strtolower', explode(',', $option[1]));
398
 
399
                    break;
400
 
401
                case '--test-suffix':
402
                    $testSuffixes = explode(',', $option[1]);
403
 
404
                    break;
405
 
406
                case '--include-path':
407
                    $includePath = $option[1];
408
 
409
                    break;
410
 
411
                case '--list-groups':
412
                    $listGroups = true;
413
 
414
                    break;
415
 
416
                case '--list-suites':
417
                    $listSuites = true;
418
 
419
                    break;
420
 
421
                case '--list-tests':
422
                    $listTests = true;
423
 
424
                    break;
425
 
426
                case '--list-tests-xml':
427
                    $listTestsXml = $option[1];
428
 
429
                    break;
430
 
431
                case '--printer':
432
                    $printer = $option[1];
433
 
434
                    break;
435
 
436
                case '--loader':
437
                    $loader = $option[1];
438
 
439
                    break;
440
 
441
                case '--log-junit':
442
                    $junitLogfile = $option[1];
443
 
444
                    break;
445
 
446
                case '--log-teamcity':
447
                    $teamcityLogfile = $option[1];
448
 
449
                    break;
450
 
451
                case '--order-by':
452
                    foreach (explode(',', $option[1]) as $order) {
453
                        switch ($order) {
454
                            case 'default':
455
                                $executionOrder        = TestSuiteSorter::ORDER_DEFAULT;
456
                                $executionOrderDefects = TestSuiteSorter::ORDER_DEFAULT;
457
                                $resolveDependencies   = true;
458
 
459
                                break;
460
 
461
                            case 'defects':
462
                                $executionOrderDefects = TestSuiteSorter::ORDER_DEFECTS_FIRST;
463
 
464
                                break;
465
 
466
                            case 'depends':
467
                                $resolveDependencies = true;
468
 
469
                                break;
470
 
471
                            case 'duration':
472
                                $executionOrder = TestSuiteSorter::ORDER_DURATION;
473
 
474
                                break;
475
 
476
                            case 'no-depends':
477
                                $resolveDependencies = false;
478
 
479
                                break;
480
 
481
                            case 'random':
482
                                $executionOrder = TestSuiteSorter::ORDER_RANDOMIZED;
483
 
484
                                break;
485
 
486
                            case 'reverse':
487
                                $executionOrder = TestSuiteSorter::ORDER_REVERSED;
488
 
489
                                break;
490
 
491
                            case 'size':
492
                                $executionOrder = TestSuiteSorter::ORDER_SIZE;
493
 
494
                                break;
495
 
496
                            default:
497
                                $unrecognizedOrderBy = $order;
498
                        }
499
                    }
500
 
501
                    break;
502
 
503
                case '--process-isolation':
504
                    $processIsolation = true;
505
 
506
                    break;
507
 
508
                case '--repeat':
509
                    $repeat = (int) $option[1];
510
 
511
                    break;
512
 
513
                case '--stderr':
514
                    $stderr = true;
515
 
516
                    break;
517
 
518
                case '--stop-on-defect':
519
                    $stopOnDefect = true;
520
 
521
                    break;
522
 
523
                case '--stop-on-error':
524
                    $stopOnError = true;
525
 
526
                    break;
527
 
528
                case '--stop-on-failure':
529
                    $stopOnFailure = true;
530
 
531
                    break;
532
 
533
                case '--stop-on-warning':
534
                    $stopOnWarning = true;
535
 
536
                    break;
537
 
538
                case '--stop-on-incomplete':
539
                    $stopOnIncomplete = true;
540
 
541
                    break;
542
 
543
                case '--stop-on-risky':
544
                    $stopOnRisky = true;
545
 
546
                    break;
547
 
548
                case '--stop-on-skipped':
549
                    $stopOnSkipped = true;
550
 
551
                    break;
552
 
553
                case '--fail-on-empty-test-suite':
554
                    $failOnEmptyTestSuite = true;
555
 
556
                    break;
557
 
558
                case '--fail-on-incomplete':
559
                    $failOnIncomplete = true;
560
 
561
                    break;
562
 
563
                case '--fail-on-risky':
564
                    $failOnRisky = true;
565
 
566
                    break;
567
 
568
                case '--fail-on-skipped':
569
                    $failOnSkipped = true;
570
 
571
                    break;
572
 
573
                case '--fail-on-warning':
574
                    $failOnWarning = true;
575
 
576
                    break;
577
 
578
                case '--teamcity':
579
                    $printer = TeamCity::class;
580
 
581
                    break;
582
 
583
                case '--testdox':
584
                    $printer = CliTestDoxPrinter::class;
585
 
586
                    break;
587
 
588
                case '--testdox-group':
589
                    $testdoxGroups = explode(',', $option[1]);
590
 
591
                    break;
592
 
593
                case '--testdox-exclude-group':
594
                    $testdoxExcludeGroups = explode(',', $option[1]);
595
 
596
                    break;
597
 
598
                case '--testdox-html':
599
                    $testdoxHtmlFile = $option[1];
600
 
601
                    break;
602
 
603
                case '--testdox-text':
604
                    $testdoxTextFile = $option[1];
605
 
606
                    break;
607
 
608
                case '--testdox-xml':
609
                    $testdoxXmlFile = $option[1];
610
 
611
                    break;
612
 
613
                case '--no-configuration':
614
                    $useDefaultConfiguration = false;
615
 
616
                    break;
617
 
618
                case '--extensions':
619
                    foreach (explode(',', $option[1]) as $extensionClass) {
620
                        if (!class_exists($extensionClass)) {
621
                            $unavailableExtensions[] = $extensionClass;
622
 
623
                            continue;
624
                        }
625
 
626
                        $extensions[] = new Extension($extensionClass, '', []);
627
                    }
628
 
629
                    break;
630
 
631
                case '--no-extensions':
632
                    $noExtensions = true;
633
 
634
                    break;
635
 
636
                case '--no-coverage':
637
                    $noCoverage = true;
638
 
639
                    break;
640
 
641
                case '--no-logging':
642
                    $noLogging = true;
643
 
644
                    break;
645
 
646
                case '--no-interaction':
647
                    $noInteraction = true;
648
 
649
                    break;
650
 
651
                case '--globals-backup':
652
                    $backupGlobals = true;
653
 
654
                    break;
655
 
656
                case '--static-backup':
657
                    $backupStaticAttributes = true;
658
 
659
                    break;
660
 
661
                case 'v':
662
                case '--verbose':
663
                    $verbose = true;
664
 
665
                    break;
666
 
667
                case '--atleast-version':
668
                    $atLeastVersion = $option[1];
669
 
670
                    break;
671
 
672
                case '--version':
673
                    $version = true;
674
 
675
                    break;
676
 
677
                case '--dont-report-useless-tests':
678
                    $reportUselessTests = false;
679
 
680
                    break;
681
 
682
                case '--strict-coverage':
683
                    $strictCoverage = true;
684
 
685
                    break;
686
 
687
                case '--disable-coverage-ignore':
688
                    $disableCodeCoverageIgnore = true;
689
 
690
                    break;
691
 
692
                case '--strict-global-state':
693
                    $beStrictAboutChangesToGlobalState = true;
694
 
695
                    break;
696
 
697
                case '--disallow-test-output':
698
                    $disallowTestOutput = true;
699
 
700
                    break;
701
 
702
                case '--disallow-resource-usage':
703
                    $beStrictAboutResourceUsageDuringSmallTests = true;
704
 
705
                    break;
706
 
707
                case '--default-time-limit':
708
                    $defaultTimeLimit = (int) $option[1];
709
 
710
                    break;
711
 
712
                case '--enforce-time-limit':
713
                    $enforceTimeLimit = true;
714
 
715
                    break;
716
 
717
                case '--disallow-todo-tests':
718
                    $disallowTodoAnnotatedTests = true;
719
 
720
                    break;
721
 
722
                case '--reverse-list':
723
                    $reverseList = true;
724
 
725
                    break;
726
 
727
                case '--check-version':
728
                    $checkVersion = true;
729
 
730
                    break;
731
 
732
                case '--coverage-filter':
733
                case '--whitelist':
734
                    if ($coverageFilter === null) {
735
                        $coverageFilter = [];
736
                    }
737
 
738
                    $coverageFilter[] = $option[1];
739
 
740
                    break;
741
 
742
                case '--random-order':
743
                    $executionOrder = TestSuiteSorter::ORDER_RANDOMIZED;
744
 
745
                    break;
746
 
747
                case '--random-order-seed':
748
                    $randomOrderSeed = (int) $option[1];
749
 
750
                    break;
751
 
752
                case '--resolve-dependencies':
753
                    $resolveDependencies = true;
754
 
755
                    break;
756
 
757
                case '--ignore-dependencies':
758
                    $resolveDependencies = false;
759
 
760
                    break;
761
 
762
                case '--reverse-order':
763
                    $executionOrder = TestSuiteSorter::ORDER_REVERSED;
764
 
765
                    break;
766
 
767
                case '--dump-xdebug-filter':
768
                    $xdebugFilterFile = $option[1];
769
 
770
                    break;
771
 
772
                default:
773
                    $unrecognizedOptions[str_replace('--', '', $option[0])] = $option[1];
774
            }
775
        }
776
 
777
        if (empty($extensions)) {
778
            $extensions = null;
779
        }
780
 
781
        if (empty($unavailableExtensions)) {
782
            $unavailableExtensions = null;
783
        }
784
 
785
        if (empty($iniSettings)) {
786
            $iniSettings = null;
787
        }
788
 
789
        if (empty($coverageFilter)) {
790
            $coverageFilter = null;
791
        }
792
 
793
        return new Configuration(
794
            $argument,
795
            $atLeastVersion,
796
            $backupGlobals,
797
            $backupStaticAttributes,
798
            $beStrictAboutChangesToGlobalState,
799
            $beStrictAboutResourceUsageDuringSmallTests,
800
            $bootstrap,
801
            $cacheResult,
802
            $cacheResultFile,
803
            $checkVersion,
804
            $colors,
805
            $columns,
806
            $configuration,
807
            $coverageClover,
808
            $coverageCobertura,
809
            $coverageCrap4J,
810
            $coverageHtml,
811
            $coveragePhp,
812
            $coverageText,
813
            $coverageTextShowUncoveredFiles,
814
            $coverageTextShowOnlySummary,
815
            $coverageXml,
816
            $pathCoverage,
817
            $coverageCacheDirectory,
818
            $warmCoverageCache,
819
            $debug,
820
            $defaultTimeLimit,
821
            $disableCodeCoverageIgnore,
822
            $disallowTestOutput,
823
            $disallowTodoAnnotatedTests,
824
            $enforceTimeLimit,
825
            $excludeGroups,
826
            $executionOrder,
827
            $executionOrderDefects,
828
            $extensions,
829
            $unavailableExtensions,
830
            $failOnEmptyTestSuite,
831
            $failOnIncomplete,
832
            $failOnRisky,
833
            $failOnSkipped,
834
            $failOnWarning,
835
            $filter,
836
            $generateConfiguration,
837
            $migrateConfiguration,
838
            $groups,
839
            $testsCovering,
840
            $testsUsing,
841
            $help,
842
            $includePath,
843
            $iniSettings,
844
            $junitLogfile,
845
            $listGroups,
846
            $listSuites,
847
            $listTests,
848
            $listTestsXml,
849
            $loader,
850
            $noCoverage,
851
            $noExtensions,
852
            $noInteraction,
853
            $noLogging,
854
            $printer,
855
            $processIsolation,
856
            $randomOrderSeed,
857
            $repeat,
858
            $reportUselessTests,
859
            $resolveDependencies,
860
            $reverseList,
861
            $stderr,
862
            $strictCoverage,
863
            $stopOnDefect,
864
            $stopOnError,
865
            $stopOnFailure,
866
            $stopOnIncomplete,
867
            $stopOnRisky,
868
            $stopOnSkipped,
869
            $stopOnWarning,
870
            $teamcityLogfile,
871
            $testdoxExcludeGroups,
872
            $testdoxGroups,
873
            $testdoxHtmlFile,
874
            $testdoxTextFile,
875
            $testdoxXmlFile,
876
            $testSuffixes,
877
            $testSuite,
878
            $unrecognizedOptions,
879
            $unrecognizedOrderBy,
880
            $useDefaultConfiguration,
881
            $verbose,
882
            $version,
883
            $coverageFilter,
884
            $xdebugFilterFile
885
        );
886
    }
887
}