Subversion-Projekte lars-tiefland.laravel_shop

Revision

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