Showing preview only (1,487K chars total). Download the full file or copy to clipboard to get everything.
Repository: xunit/xunit.analyzers
Branch: main
Commit: 8da2743cb286
Files: 373
Total size: 1.3 MB
Directory structure:
gitextract_bu8u1mqd/
├── .config/
│ └── dotnet-tools.json
├── .editorconfig
├── .gitattributes
├── .github/
│ ├── FUNDING.yml
│ └── workflows/
│ ├── ci-signed.yaml
│ ├── ci-unsigned.yaml
│ └── pull-request.yaml
├── .gitignore
├── .gitmodules
├── .vscode/
│ ├── launch.json
│ ├── settings.json
│ └── tasks.json
├── BUILDING.md
├── LICENSE
├── NuGet.Config
├── README.md
├── build
├── build.ps1
├── global.json
├── src/
│ ├── Directory.Build.props
│ ├── Directory.Build.targets
│ ├── common/
│ │ ├── CallerArgumentExpressionAttribute.cs
│ │ └── Guard.cs
│ ├── compat/
│ │ ├── Directory.Build.props
│ │ ├── xunit.analyzers.latest/
│ │ │ └── xunit.analyzers.latest.csproj
│ │ ├── xunit.analyzers.latest.fixes/
│ │ │ └── xunit.analyzers.latest.fixes.csproj
│ │ └── xunit.analyzers.latest.tests/
│ │ └── xunit.analyzers.latest.tests.csproj
│ ├── signing.snk
│ ├── xunit.analyzers/
│ │ ├── Properties/
│ │ │ └── AssemblyInfo.cs
│ │ ├── Suppressors/
│ │ │ ├── ConsiderCallingConfigureAwaitSuppressor.cs
│ │ │ ├── MakeTypesInternalSuppressor.cs
│ │ │ ├── NonNullableFieldInitializationSuppressor.cs
│ │ │ └── UseAsyncSuffixForAsyncMethodsSuppressor.cs
│ │ ├── Utility/
│ │ │ ├── AssertUsageAnalyzerBase.cs
│ │ │ ├── Category.cs
│ │ │ ├── CodeAnalysisExtensions.cs
│ │ │ ├── Constants.cs
│ │ │ ├── ConversionChecker.cs
│ │ │ ├── Descriptors.Suppressors.cs
│ │ │ ├── Descriptors.cs
│ │ │ ├── Descriptors.xUnit1xxx.cs
│ │ │ ├── Descriptors.xUnit2xxx.cs
│ │ │ ├── Descriptors.xUnit3xxx.cs
│ │ │ ├── EmptyAssertContext.cs
│ │ │ ├── EmptyCommonContext.cs
│ │ │ ├── EmptyCoreContext.cs
│ │ │ ├── EmptyRunnerUtilityContext.cs
│ │ │ ├── EnumerableExtensions.cs
│ │ │ ├── IAssertContext.cs
│ │ │ ├── ICommonContext.cs
│ │ │ ├── ICoreContext.cs
│ │ │ ├── IRunnerUtilityContext.cs
│ │ │ ├── Serializability.cs
│ │ │ ├── SerializabilityAnalyzer.cs
│ │ │ ├── SerializableTypeSymbols.cs
│ │ │ ├── SymbolExtensions.cs
│ │ │ ├── SyntaxExtensions.cs
│ │ │ ├── TypeHierarchyComparer.cs
│ │ │ ├── TypeSymbolFactory.cs
│ │ │ ├── V2AbstractionsContext.cs
│ │ │ ├── V2AssertContext.cs
│ │ │ ├── V2CoreContext.cs
│ │ │ ├── V2ExecutionContext.cs
│ │ │ ├── V2RunnerUtilityContext.cs
│ │ │ ├── V3AssertContext.cs
│ │ │ ├── V3CommonContext.cs
│ │ │ ├── V3CoreContext.cs
│ │ │ ├── V3RunnerCommonContext.cs
│ │ │ ├── V3RunnerUtilityContext.cs
│ │ │ ├── XunitContext.cs
│ │ │ ├── XunitDiagnosticAnalyzer.cs
│ │ │ ├── XunitDiagnosticSuppressor.cs
│ │ │ ├── XunitV2DiagnosticAnalyzer.cs
│ │ │ ├── XunitV2DiagnosticSuppressor.cs
│ │ │ ├── XunitV3DiagnosticAnalyzer.cs
│ │ │ └── XunitV3DiagnosticSuppressor.cs
│ │ ├── X1000/
│ │ │ ├── ClassDataAttributeMustPointAtValidClass.cs
│ │ │ ├── CollectionDefinitionsMustBePublic.cs
│ │ │ ├── ConstructorsOnFactAttributeSubclassShouldBePublic.cs
│ │ │ ├── DataAttributeShouldBeUsedOnATheory.cs
│ │ │ ├── DoNotUseAsyncVoidForTestMethods.cs
│ │ │ ├── DoNotUseBlockingTaskOperations.cs
│ │ │ ├── DoNotUseConfigureAwait.cs
│ │ │ ├── EnsureFixturesHaveASource.cs
│ │ │ ├── FactMethodMustNotHaveParameters.cs
│ │ │ ├── FactMethodShouldNotHaveTestData.cs
│ │ │ ├── InlineDataMustMatchTheoryParameters.cs
│ │ │ ├── InlineDataShouldBeUniqueWithinTheory.cs
│ │ │ ├── LocalFunctionsCannotBeTestFunctions.cs
│ │ │ ├── MemberDataShouldReferenceValidMember.cs
│ │ │ ├── PublicMethodShouldBeMarkedAsTest.cs
│ │ │ ├── TestClassCannotBeNestedInGenericClass.cs
│ │ │ ├── TestClassMustBePublic.cs
│ │ │ ├── TestClassShouldHaveTFixtureArgument.cs
│ │ │ ├── TestMethodCannotHaveOverloads.cs
│ │ │ ├── TestMethodMustNotHaveMultipleFactAttributes.cs
│ │ │ ├── TestMethodShouldNotBeSkipped.cs
│ │ │ ├── TestMethodSupportedReturnType.cs
│ │ │ ├── TheoryDataRowArgumentsShouldBeSerializable.cs
│ │ │ ├── TheoryDataShouldNotUseTheoryDataRow.cs
│ │ │ ├── TheoryDataTypeArgumentsShouldBeSerializable.cs
│ │ │ ├── TheoryMethodCannotHaveDefaultParameter.cs
│ │ │ ├── TheoryMethodCannotHaveParamsArray.cs
│ │ │ ├── TheoryMethodMustHaveTestData.cs
│ │ │ ├── TheoryMethodShouldHaveParameters.cs
│ │ │ ├── TheoryMethodShouldUseAllParameters.cs
│ │ │ └── UseCancellationToken.cs
│ │ ├── X2000/
│ │ │ ├── AssertCollectionContainsShouldNotUseBoolCheck.cs
│ │ │ ├── AssertEmptyCollectionCheckShouldNotBeUsed.cs
│ │ │ ├── AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecks.cs
│ │ │ ├── AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheck.cs
│ │ │ ├── AssertEqualGenericShouldNotBeUsedForStringValue.cs
│ │ │ ├── AssertEqualLiteralValueShouldBeFirst.cs
│ │ │ ├── AssertEqualPrecisionShoulBeInRange.cs
│ │ │ ├── AssertEqualShouldNotBeUsedForBoolLiteralCheck.cs
│ │ │ ├── AssertEqualShouldNotBeUsedForCollectionSizeCheck.cs
│ │ │ ├── AssertEqualShouldNotBeUsedForNullCheck.cs
│ │ │ ├── AssertEqualsShouldNotBeUsed.cs
│ │ │ ├── AssertIsTypeShouldNotBeUsedForAbstractType.cs
│ │ │ ├── AssertIsTypeShouldUseGenericOverloadType.cs
│ │ │ ├── AssertNullShouldNotBeCalledOnValueTypes.cs
│ │ │ ├── AssertRegexMatchShouldNotUseBoolLiteralCheck.cs
│ │ │ ├── AssertSameShouldNotBeCalledOnValueTypes.cs
│ │ │ ├── AssertSingleShouldBeUsedForSingleParameter.cs
│ │ │ ├── AssertSingleShouldUseTwoArgumentCall.cs
│ │ │ ├── AssertStringEqualityCheckShouldNotUseBoolCheck.cs
│ │ │ ├── AssertSubstringCheckShouldNotUseBoolCheck.cs
│ │ │ ├── AssertThrowsShouldNotBeUsedForAsyncThrowsCheck.cs
│ │ │ ├── AssertThrowsShouldUseGenericOverloadCheck.cs
│ │ │ ├── AssignableFromAssertionIsConfusinglyNamed.cs
│ │ │ ├── AsyncAssertsShouldBeAwaited.cs
│ │ │ ├── BooleanAssertsShouldNotBeNegated.cs
│ │ │ ├── BooleanAssertsShouldNotBeUsedForSimpleEqualityCheck.cs
│ │ │ ├── DoNotUseAssertEmptyWithProblematicTypes.cs
│ │ │ ├── SetEqualityAnalyzer.cs
│ │ │ └── UseAssertFailInsteadOfBooleanAssert.cs
│ │ ├── X3000/
│ │ │ ├── CrossAppDomainClassesMustBeLongLivedMarshalByRefObject.cs
│ │ │ ├── DoNotTestForConcreteTypeOfJsonSerializableTypes.cs
│ │ │ ├── FactAttributeDerivedClassesShouldProvideSourceInformationConstructor.cs
│ │ │ └── SerializableClassMustHaveParameterlessConstructor.cs
│ │ ├── xunit.analyzers.csproj
│ │ └── xunit.analyzers.nuspec
│ ├── xunit.analyzers.fixes/
│ │ ├── Properties/
│ │ │ └── AssemblyInfo.cs
│ │ ├── Utility/
│ │ │ ├── AsyncHelper.cs
│ │ │ ├── CodeAnalysisExtensions.cs
│ │ │ ├── ConvertAttributeCodeAction.cs
│ │ │ ├── RemoveAttributesOfTypeCodeAction.cs
│ │ │ ├── XunitCodeAction.cs
│ │ │ ├── XunitCodeFixProvider.cs
│ │ │ └── XunitMemberFixProvider.cs
│ │ ├── X1000/
│ │ │ ├── ClassDataAttributeMustPointAtValidClassFixer.cs
│ │ │ ├── CollectionDefinitionClassesMustBePublicFixer.cs
│ │ │ ├── ConvertToFactFix.cs
│ │ │ ├── ConvertToTheoryFix.cs
│ │ │ ├── DataAttributeShouldBeUsedOnATheoryFixer.cs
│ │ │ ├── DoNotUseAsyncVoidForTestMethodsFixer.cs
│ │ │ ├── DoNotUseConfigureAwaitFixer.cs
│ │ │ ├── FactMethodMustNotHaveParametersFixer.cs
│ │ │ ├── FactMethodShouldNotHaveTestDataFixer.cs
│ │ │ ├── InlineDataMustMatchTheoryParameters_ExtraValueFixer.cs
│ │ │ ├── InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForIncompatibleParameterFixer.cs
│ │ │ ├── InlineDataMustMatchTheoryParameters_TooFewValuesFixer.cs
│ │ │ ├── InlineDataShouldBeUniqueWithinTheoryFixer.cs
│ │ │ ├── LocalFunctionsCannotBeTestFunctionsFixer.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_ExtraValueFixer.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_NameOfFixer.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_NullShouldNotBeUsedForIncompatibleParameterFixer.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_ParamsForNonMethodFixer.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_ReturnTypeFixer.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_StaticFixer.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_VisibilityFixer.cs
│ │ │ ├── PublicMethodShouldBeMarkedAsTestFixer.cs
│ │ │ ├── RemoveMethodParameterFix.cs
│ │ │ ├── TestClassCannotBeNestedInGenericClassFixer.cs
│ │ │ ├── TestClassMustBePublicFixer.cs
│ │ │ ├── TestClassShouldHaveTFixtureArgumentFixer.cs
│ │ │ ├── TestMethodMustNotHaveMultipleFactAttributesFixer.cs
│ │ │ ├── TestMethodShouldNotBeSkippedFixer.cs
│ │ │ ├── TheoryDataShouldNotUseTheoryDataRowFixer.cs
│ │ │ ├── TheoryMethodCannotHaveDefaultParameterFixer.cs
│ │ │ └── UseCancellationTokenFixer.cs
│ │ ├── X2000/
│ │ │ ├── AssertCollectionContainsShouldNotUseBoolCheckFixer.cs
│ │ │ ├── AssertEmptyCollectionCheckShouldNotBeUsedFixer.cs
│ │ │ ├── AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksFixer.cs
│ │ │ ├── AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckFixer.cs
│ │ │ ├── AssertEqualGenericShouldNotBeUsedForStringValueFixer.cs
│ │ │ ├── AssertEqualLiteralValueShouldBeFirstFixer.cs
│ │ │ ├── AssertEqualPrecisionShouldBeInRangeFixer.cs
│ │ │ ├── AssertEqualShouldNotBeUsedForBoolLiteralCheckFixer.cs
│ │ │ ├── AssertEqualShouldNotBeUsedForCollectionSizeCheckFixer.cs
│ │ │ ├── AssertEqualShouldNotBeUsedForNullCheckFixer.cs
│ │ │ ├── AssertEqualsShouldNotBeUsedFixer.cs
│ │ │ ├── AssertIsTypeShouldNotBeUsedForAbstractTypeFixer.cs
│ │ │ ├── AssertNullShouldNotBeCalledOnValueTypesFixer.cs
│ │ │ ├── AssertRegexMatchShouldNotUseBoolLiteralCheckFixer.cs
│ │ │ ├── AssertSameShouldNotBeCalledOnValueTypesFixer.cs
│ │ │ ├── AssertSingleShouldBeUsedForSingleParameterFixer.cs
│ │ │ ├── AssertSingleShouldUseTwoArgumentCallFixer.cs
│ │ │ ├── AssertStringEqualityCheckShouldNotUseBoolCheckFixer.cs
│ │ │ ├── AssertSubstringCheckShouldNotUseBoolCheckFixer.cs
│ │ │ ├── AssertThrowsShouldNotBeUsedForAsyncThrowsCheckFixer.cs
│ │ │ ├── AssignableFromAssertionIsConfusinglyNamedFixer.cs
│ │ │ ├── AsyncAssertsShouldBeAwaitedFixer.cs
│ │ │ ├── BooleanAssertsShouldNotBeNegatedFixer.cs
│ │ │ ├── BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckBooleanFixer.cs
│ │ │ ├── BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckNonBooleanFixer.cs
│ │ │ ├── UseAssertFailInsteadOfBooleanAssertFixer.cs
│ │ │ └── UseGenericOverloadFix.cs
│ │ ├── X3000/
│ │ │ ├── CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectFixer.cs
│ │ │ └── SerializableClassMustHaveParameterlessConstructorFixer.cs
│ │ ├── tools/
│ │ │ ├── install.ps1
│ │ │ └── uninstall.ps1
│ │ └── xunit.analyzers.fixes.csproj
│ └── xunit.analyzers.tests/
│ ├── Analyzers/
│ │ ├── X1000/
│ │ │ ├── ClassDataAttributeMustPointAtValidClassTests.cs
│ │ │ ├── CollectionDefinitionClassesMustBePublicTests.cs
│ │ │ ├── ConstructorsOnFactAttributeSubclassShouldBePublicTests.cs
│ │ │ ├── DataAttributeShouldBeUsedOnATheoryTests.cs
│ │ │ ├── DoNotUseAsyncVoidForTestMethodsTests.cs
│ │ │ ├── DoNotUseBlockingTaskOperationsTests.cs
│ │ │ ├── DoNotUseConfigureAwaitTests.cs
│ │ │ ├── EnsureFixturesHaveASourceTests.cs
│ │ │ ├── FactMethodMustNotHaveParametersTests.cs
│ │ │ ├── FactMethodShouldNotHaveTestDataTests.cs
│ │ │ ├── InlineDataMustMatchTheoryParametersTests.cs
│ │ │ ├── InlineDataShouldBeUniqueWithinTheoryTests.cs
│ │ │ ├── LocalFunctionsCannotBeTestFunctionsTests.cs
│ │ │ ├── MemberDataShouldReferenceValidMemberTests.cs
│ │ │ ├── PublicMethodShouldBeMarkedAsTestTests.cs
│ │ │ ├── TestClassCannotBeNestedInGenericClassTests.cs
│ │ │ ├── TestClassMustBePublicTests.cs
│ │ │ ├── TestClassShouldHaveTFixtureArgumentTests.cs
│ │ │ ├── TestMethodCannotHaveOverloadsTests.cs
│ │ │ ├── TestMethodMustNotHaveMultipleFactAttributesTests.cs
│ │ │ ├── TestMethodShouldNotBeSkippedTests.cs
│ │ │ ├── TestMethodSupportedReturnTypeTests.cs
│ │ │ ├── TheoryDataRowArgumentsShouldBeSerializableTests.cs
│ │ │ ├── TheoryDataShouldNotUseTheoryDataRowTests.cs
│ │ │ ├── TheoryDataTypeArgumentsShouldBeSerializableTests.cs
│ │ │ ├── TheoryMethodCannotHaveDefaultParameterTests.cs
│ │ │ ├── TheoryMethodCannotHaveParamsArrayTests.cs
│ │ │ ├── TheoryMethodMustHaveTestDataTests.cs
│ │ │ ├── TheoryMethodShouldHaveParametersTests.cs
│ │ │ ├── TheoryMethodShouldUseAllParametersTests.cs
│ │ │ └── UseCancellationTokenTests.cs
│ │ ├── X2000/
│ │ │ ├── AssertCollectionContainsShouldNotUseBoolCheckTests.cs
│ │ │ ├── AssertEmptyCollectionCheckShouldNotBeUsedTests.cs
│ │ │ ├── AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksTests.cs
│ │ │ ├── AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckTests.cs
│ │ │ ├── AssertEqualGenericShouldNotBeUsedForStringValueTests.cs
│ │ │ ├── AssertEqualLiteralValueShouldBeFirstTests.cs
│ │ │ ├── AssertEqualPrecisionShouldBeInRangeTest.cs
│ │ │ ├── AssertEqualShouldNotBeUsedForBoolLiteralCheckTests.cs
│ │ │ ├── AssertEqualShouldNotBeUsedForCollectionSizeCheckTests.cs
│ │ │ ├── AssertEqualShouldNotBeUsedForNullCheckTests.cs
│ │ │ ├── AssertEqualsShouldNotBeUsedTests.cs
│ │ │ ├── AssertIsTypeShouldNotBeUsedForAbstractTypeTests.cs
│ │ │ ├── AssertIsTypeShouldUseGenericOverloadTypeTests.cs
│ │ │ ├── AssertNullShouldNotBeCalledOnValueTypesTests.cs
│ │ │ ├── AssertRegexMatchShouldNotUseBoolLiteralCheckTests.cs
│ │ │ ├── AssertSameShouldNotBeCalledOnValueTypesTests.cs
│ │ │ ├── AssertSingleShouldBeUsedForSingleParameterTests.cs
│ │ │ ├── AssertSingleShouldUseTwoArgumentCallTests.cs
│ │ │ ├── AssertStringEqualityCheckShouldNotUseBoolCheckTest.cs
│ │ │ ├── AssertSubstringCheckShouldNotUseBoolCheckTests.cs
│ │ │ ├── AssertThrowsShouldNotBeUsedForAsyncThrowsCheckTests.cs
│ │ │ ├── AssertThrowsShouldUseGenericOverloadCheckTests.cs
│ │ │ ├── AssignableFromAssertionIsConfusinglyNamedTests.cs
│ │ │ ├── AsyncAssertsShouldBeAwaitedTests.cs
│ │ │ ├── BooleanAssertsShouldNotBeNegatedTests.cs
│ │ │ ├── BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckTests.cs
│ │ │ ├── DoNotUseAssertEmptyWithProblematicTypesTests.cs
│ │ │ ├── SetEqualityAnalyzerTests.cs
│ │ │ └── UseAssertFailInsteadOfBooleanAssertTests.cs
│ │ └── X3000/
│ │ ├── CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectTests.cs
│ │ ├── DoNotTestForConcreteTypeOfJsonSerializableTypesTests.cs
│ │ ├── FactAttributeDerivedClassesShouldProvideSourceInformationConstructorTests.cs
│ │ └── SerializableClassMustHaveParameterlessConstructorTests.cs
│ ├── Fixes/
│ │ ├── X1000/
│ │ │ ├── ClassDataAttributeMustPointAtValidClassFixerTests.cs
│ │ │ ├── CollectionDefinitionClassesMustBePublicFixerTests.cs
│ │ │ ├── ConvertToFactFixTests.cs
│ │ │ ├── ConvertToTheoryFixTests.cs
│ │ │ ├── DataAttributeShouldBeUsedOnATheoryFixerTests.cs
│ │ │ ├── DoNotUseAsyncVoidForTestMethodsFixerTests.cs
│ │ │ ├── DoNotUseConfigureAwaitFixerTests.cs
│ │ │ ├── FactMethodMustNotHaveParametersFixerTests.cs
│ │ │ ├── FactMethodShouldNotHaveTestDataFixerTests.cs
│ │ │ ├── InlineDataMustMatchTheoryParameters_ExtraValueFixerTests.cs
│ │ │ ├── InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForIncompatibleParameterFixerTests.cs
│ │ │ ├── InlineDataMustMatchTheoryParameters_TooFewValuesFixerTests.cs
│ │ │ ├── InlineDataShouldBeUniqueWithinTheoryFixerTests.cs
│ │ │ ├── LocalFunctionsCannotBeTestFunctionsFixerTests.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_ExtraValueFixerTests.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_NameOfFixerTests.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_NullShouldNotBeUsedForIncompatibleParameterFixerTests.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_ParamsForNonMethodFixerTests.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_ReturnTypeFixerTests.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_StaticFixerTests.cs
│ │ │ ├── MemberDataShouldReferenceValidMember_VisibilityFixerTests.cs
│ │ │ ├── PublicMethodShouldBeMarkedAsTestFixerTests.cs
│ │ │ ├── RemoveMethodParameterFixTests.cs
│ │ │ ├── TestClassCannotBeNestedInGenericClassFixerTests.cs
│ │ │ ├── TestClassMustBePublicFixerTests.cs
│ │ │ ├── TestClassShouldHaveTFixtureArgumentFixerTests.cs
│ │ │ ├── TestMethodMustNotHaveMultipleFactAttributesFixerTests.cs
│ │ │ ├── TestMethodShouldNotBeSkippedFixerTests.cs
│ │ │ ├── TheoryDataShouldNotUseTheoryDataRowFixerTests.cs
│ │ │ ├── TheoryMethodCannotHaveDefaultParameterFixerTests.cs
│ │ │ └── UseCancellationTokenFixerTests.cs
│ │ ├── X2000/
│ │ │ ├── AssertCollectionContainsShouldNotUseBoolCheckFixerTests.cs
│ │ │ ├── AssertEmptyCollectionCheckShouldNotBeUsedFixerTests.cs
│ │ │ ├── AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksFixerTests.cs
│ │ │ ├── AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckFixerTests.cs
│ │ │ ├── AssertEqualGenericShouldNotBeUsedForStringValueFixerTests.cs
│ │ │ ├── AssertEqualLiteralValueShouldBeFirstFixerTests.cs
│ │ │ ├── AssertEqualPrecisionShouldBeInRangeFixerTests.cs
│ │ │ ├── AssertEqualShouldNotBeUsedForBoolLiteralCheckFixerTests.cs
│ │ │ ├── AssertEqualShouldNotBeUsedForCollectionSizeCheckFixerTests.cs
│ │ │ ├── AssertEqualShouldNotBeUsedForNullCheckFixerTests.cs
│ │ │ ├── AssertEqualsShouldNotBeUsedFixerTests.cs
│ │ │ ├── AssertIsTypeShouldNotBeUsedForAbstractTypeFixerTests.cs
│ │ │ ├── AssertNullShouldNotBeCalledOnValueTypesFixerTests.cs
│ │ │ ├── AssertRegexMatchShouldNotUseBoolLiteralCheckFixerTests.cs
│ │ │ ├── AssertSameShouldNotBeCalledOnValueTypesFixerTests.cs
│ │ │ ├── AssertSingleShouldBeUsedForSingleParameterFixerTests.cs
│ │ │ ├── AssertSingleShouldUseTwoArgumentCallFixerTests.cs
│ │ │ ├── AssertStringEqualityCheckShouldNotUseBoolCheckFixerTests.cs
│ │ │ ├── AssertSubstringCheckShouldNotUseBoolCheckFixerTests.cs
│ │ │ ├── AssertThrowsShouldNotBeUsedForAsyncThrowsCheckFixerTests.cs
│ │ │ ├── AssignableFromAssertionIsConfusinglyNamedFixerTests.cs
│ │ │ ├── AsyncAssertsShouldBeAwaitedFixerTests.cs
│ │ │ ├── BooleanAssertsShouldNotBeNegatedFixerTests.cs
│ │ │ ├── BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckBooleanFixerTests.cs
│ │ │ ├── BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckNonBooleanFixerTests.cs
│ │ │ ├── UseAssertFailInsteadOfBooleanAssertFixerTests.cs
│ │ │ └── UseGenericOverloadFixTests.cs
│ │ └── X3000/
│ │ ├── CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectFixerTests.cs
│ │ └── SerializableClassMustHaveParameterlessConstructorFixerTests.cs
│ ├── Suppressors/
│ │ ├── ConsiderCallingConfigureAwaitSuppressorTests.cs
│ │ ├── MakeTypesInternalSuppressorTests.cs
│ │ ├── NonNullableFieldInitializationSuppressorTests.cs
│ │ └── UseAsyncSuffixForAsyncMethodsSuppressorTests.cs
│ ├── Utility/
│ │ ├── 3rdPartyAnalyzers/
│ │ │ ├── AnalyzerLoaderBase.cs
│ │ │ ├── CodeAnalysisNetAnalyzers.cs
│ │ │ └── VsThreadingAnalyzers.cs
│ │ ├── AssertsExtensions/
│ │ │ ├── EmptyException.cs
│ │ │ ├── EqualException.cs
│ │ │ └── NotEmptyException.cs
│ │ ├── CSharpVerifier.Analyzers.RunnerUtility.cs
│ │ ├── CSharpVerifier.Analyzers.cs
│ │ ├── CSharpVerifier.CodeFixes.RunnerUtility.cs
│ │ ├── CSharpVerifier.CodeFixes.cs
│ │ ├── CSharpVerifier.Suppressors.cs
│ │ ├── CSharpVerifier.cs
│ │ ├── CodeAnalyzerHelper.cs
│ │ ├── CodeFixProviderDiscovery.cs
│ │ ├── XunitVerifier.cs
│ │ ├── XunitVerifierV2.cs
│ │ └── XunitVerifierV3.cs
│ ├── xunit.analyzers.tests.csproj
│ └── xunit.runner.json
├── tools/
│ ├── SignClient/
│ │ └── appsettings.json
│ └── builder/
│ ├── .vscode/
│ │ ├── launch.json
│ │ ├── settings.json
│ │ └── tasks.json
│ ├── Program.cs
│ ├── build.csproj
│ ├── models/
│ │ └── BuildContext.cs
│ └── targets/
│ ├── Build.cs
│ ├── Packages.cs
│ ├── SignAssemblies.cs
│ └── Test.cs
├── version.json
└── xunit.analyzers.sln
================================================
FILE CONTENTS
================================================
================================================
FILE: .config/dotnet-tools.json
================================================
{
"version": 1,
"isRoot": true,
"tools": {
"sign": {
"version": "0.9.1-beta.25330.2",
"commands": [
"sign"
],
"rollForward": false
}
}
}
================================================
FILE: .editorconfig
================================================
# top-most EditorConfig file
root = true
[*]
charset = utf-8
end_of_line = lf
insert_final_newline = true
indent_style = tab
[*.{ps1,sln}]
end_of_line = crlf
# Visual Studio demands 2-spaced project files
# Tabs are not legal whitespace for YAML files
[*.{csproj,json,props,targets,xslt,yaml,yml}]
indent_style = space
indent_size = 2
[*.cs]
# Organize usings
dotnet_separate_import_directive_groups = false
dotnet_sort_system_directives_first = true
file_header_template = unset
# this. and Me. preferences
dotnet_style_qualification_for_event = false
dotnet_style_qualification_for_field = false
dotnet_style_qualification_for_method = false
dotnet_style_qualification_for_property = false
# Language keywords vs BCL types preferences
dotnet_style_predefined_type_for_locals_parameters_members = true
dotnet_style_predefined_type_for_member_access = true
# Parentheses preferences
dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity
dotnet_style_parentheses_in_other_binary_operators = always_for_clarity
dotnet_style_parentheses_in_other_operators = never_if_unnecessary
dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity
# Modifier preferences
dotnet_style_require_accessibility_modifiers = for_non_interface_members
# Expression-level preferences
dotnet_style_coalesce_expression = true
dotnet_style_collection_initializer = true
dotnet_style_explicit_tuple_names = true
dotnet_style_namespace_match_folder = false
dotnet_style_null_propagation = true
dotnet_style_object_initializer = true
dotnet_style_operator_placement_when_wrapping = beginning_of_line
dotnet_style_prefer_auto_properties = true
dotnet_style_prefer_compound_assignment = true
dotnet_style_prefer_conditional_expression_over_assignment = true
dotnet_style_prefer_conditional_expression_over_return = false
dotnet_style_prefer_foreach_explicit_cast_in_source = when_strongly_typed
dotnet_style_prefer_inferred_anonymous_type_member_names = true
dotnet_style_prefer_inferred_tuple_names = true
dotnet_style_prefer_is_null_check_over_reference_equality_method = true
dotnet_style_prefer_simplified_boolean_expressions = true
dotnet_style_prefer_simplified_interpolation = true
# Field preferences
dotnet_style_readonly_field = true
# Parameter preferences
dotnet_code_quality_unused_parameters = all
# Suppression preferences
dotnet_remove_unnecessary_suppression_exclusions = none
# New line preferences
dotnet_style_allow_multiple_blank_lines_experimental = true
dotnet_style_allow_statement_immediately_after_block_experimental = true
#### C# Coding Conventions ####
# var preferences
csharp_style_var_elsewhere = true
csharp_style_var_for_built_in_types = true
csharp_style_var_when_type_is_apparent = true
# Expression-bodied members
csharp_style_expression_bodied_accessors = true
csharp_style_expression_bodied_constructors = false
csharp_style_expression_bodied_indexers = true
csharp_style_expression_bodied_lambdas = true
csharp_style_expression_bodied_local_functions = false
csharp_style_expression_bodied_methods = false
csharp_style_expression_bodied_operators = false
csharp_style_expression_bodied_properties = true
# Pattern matching preferences
csharp_style_pattern_matching_over_as_with_null_check = true
csharp_style_pattern_matching_over_is_with_cast_check = true
csharp_style_prefer_extended_property_pattern = true
csharp_style_prefer_not_pattern = true
csharp_style_prefer_pattern_matching = true
csharp_style_prefer_switch_expression = true
# Null-checking preferences
csharp_style_conditional_delegate_call = true
# Modifier preferences
csharp_prefer_static_local_function = true
csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,required,volatile,async
# Code-block preferences
csharp_prefer_braces = false
csharp_prefer_simple_using_statement = true
csharp_style_namespace_declarations = file_scoped
# Expression-level preferences
csharp_prefer_simple_default_expression = true
csharp_style_deconstructed_variable_declaration = true
csharp_style_implicit_object_creation_when_type_is_apparent = true
csharp_style_inlined_variable_declaration = true
csharp_style_pattern_local_over_anonymous_function = true
csharp_style_prefer_index_operator = true
csharp_style_prefer_null_check_over_type_check = true
csharp_style_prefer_range_operator = true
csharp_style_throw_expression = true
csharp_style_unused_value_assignment_preference = discard_variable
csharp_style_unused_value_expression_statement_preference = discard_variable
# 'using' directive preferences
csharp_using_directive_placement = outside_namespace:warning
# New line preferences
csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = true
csharp_style_allow_blank_lines_between_consecutive_braces_experimental = true
csharp_style_allow_embedded_statements_on_same_line_experimental = true
#### C# Formatting Rules ####
# New line preferences
csharp_new_line_before_catch = true
csharp_new_line_before_else = true
csharp_new_line_before_finally = true
csharp_new_line_before_members_in_anonymous_types = true
csharp_new_line_before_members_in_object_initializers = true
csharp_new_line_before_open_brace = all
csharp_new_line_between_query_expression_clauses = true
# Indentation preferences
csharp_indent_block_contents = true
csharp_indent_braces = false
csharp_indent_case_contents = true
csharp_indent_case_contents_when_block = true
csharp_indent_labels = one_less_than_current
csharp_indent_switch_labels = true
# Space preferences
csharp_space_after_cast = false
csharp_space_after_colon_in_inheritance_clause = true
csharp_space_after_comma = true
csharp_space_after_dot = false
csharp_space_after_keywords_in_control_flow_statements = true
csharp_space_after_semicolon_in_for_statement = true
csharp_space_around_binary_operators = before_and_after
csharp_space_around_declaration_statements = false
csharp_space_before_colon_in_inheritance_clause = true
csharp_space_before_comma = false
csharp_space_before_dot = false
csharp_space_before_open_square_brackets = false
csharp_space_before_semicolon_in_for_statement = false
csharp_space_between_empty_square_brackets = false
csharp_space_between_method_call_empty_parameter_list_parentheses = false
csharp_space_between_method_call_name_and_opening_parenthesis = false
csharp_space_between_method_call_parameter_list_parentheses = false
csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
csharp_space_between_method_declaration_name_and_open_parenthesis = false
csharp_space_between_method_declaration_parameter_list_parentheses = false
csharp_space_between_parentheses = false
csharp_space_between_square_brackets = false
# Wrapping preferences
csharp_preserve_single_line_blocks = true
csharp_preserve_single_line_statements = true
#### Naming styles ####
# Naming rules
dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion
dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.types_should_be_pascal_case.symbols = types
dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
# Symbol specifications
dotnet_naming_symbols.interface.applicable_kinds = interface
dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
dotnet_naming_symbols.interface.required_modifiers =
dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
dotnet_naming_symbols.types.required_modifiers =
dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
dotnet_naming_symbols.non_field_members.required_modifiers =
# Naming styles
dotnet_naming_style.pascal_case.required_prefix =
dotnet_naming_style.pascal_case.required_suffix =
dotnet_naming_style.pascal_case.word_separator =
dotnet_naming_style.pascal_case.capitalization = pascal_case
dotnet_naming_style.begins_with_i.required_prefix = I
dotnet_naming_style.begins_with_i.required_suffix =
dotnet_naming_style.begins_with_i.word_separator =
dotnet_naming_style.begins_with_i.capitalization = pascal_case
#### Roslyn diagnostics ####
dotnet_diagnostic.CA1000.severity = none # Do not declare static members on generic types
dotnet_diagnostic.CA1002.severity = none # Do not expose generic lists
dotnet_diagnostic.CA1014.severity = none # Mark assemblies with CLSCompliantAttribute
dotnet_diagnostic.CA1034.severity = none # Do not nest types
dotnet_diagnostic.CA1050.severity = none # Declare types in namespaces
dotnet_diagnostic.CA1200.severity = none # Avoid using cref tags with a prefix
dotnet_diagnostic.CA1303.severity = none # Do not pass literals as localized parameters
dotnet_diagnostic.CA1707.severity = none # Remove the underscores from type name
dotnet_diagnostic.CA1720.severity = none # Identifier contains type name
dotnet_diagnostic.CA1724.severity = none # Type names should not match namespaces
dotnet_diagnostic.CA1859.severity = none # Use concrete types when possible for improved performance
dotnet_diagnostic.CA1861.severity = none # Avoid constant arrays as arguments
dotnet_diagnostic.CA2211.severity = none # Non-constant fields should not be visible
dotnet_diagnostic.CA2241.severity = error # Provide correct arguments to formatting methods/The format argument is not a valid string
dotnet_diagnostic.CS1591.severity = none # Missing XML comment
dotnet_diagnostic.IDE0010.severity = none # Populate switch
dotnet_diagnostic.IDE0021.severity = none # Use block body for method
dotnet_diagnostic.IDE0022.severity = none # Use block body for method
dotnet_diagnostic.IDE0040.severity = none # Add accessibility modifiers
dotnet_diagnostic.IDE0058.severity = none # Remove unnecessary expression value
dotnet_diagnostic.IDE0072.severity = none # Populate switch
dotnet_diagnostic.IDE1006.severity = none # Naming rule violation
================================================
FILE: .gitattributes
================================================
* text=auto eol=lf
*.cs text diff=csharp
*.csproj text merge=union
*.ico binary
*.resx text merge=union
*.ps1 eol=crlf
*.sln text eol=crlf merge=union
*.snk binary
*.vbproj text merge=union
*.xls binary
================================================
FILE: .github/FUNDING.yml
================================================
github: xunit
================================================
FILE: .github/workflows/ci-signed.yaml
================================================
name: xUnit.net Analyzers CI Build (signed)
on:
push:
branches:
- main
- 'rel/**'
workflow_dispatch:
jobs:
deployment:
name: "Build"
runs-on: windows-latest
environment: signing
permissions:
id-token: write # Required for Azure CLI Login
env:
DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE: true
DOTNET_NOLOGO: true
steps:
- name: Clone source
uses: actions/checkout@v4
with:
fetch-depth: 0
submodules: true
- name: Install .NET SDK
uses: actions/setup-dotnet@v4
with:
dotnet-version: |
8.0.x
10.0.x
- name: Get .NET information
run: dotnet --info
- name: "Build target: BuildAll"
run: dotnet run --project tools/builder --no-launch-profile -- BuildAll --timing
- name: Login to Azure CLI
uses: azure/login@v2
with:
client-id: ${{ vars.KEYVAULT_APP_ID }}
tenant-id: ${{ vars.KEYVAULT_TENANT_ID }}
subscription-id: ${{ vars.KEYVAULT_SUBSCRIPTION_ID }}
- name: "Build target: PublishPackages"
env:
PUSH_APIKEY: ${{ secrets.FEEDZ_PUSH_KEY }}
PUSH_URI: ${{ vars.FEEDZ_PUSH_URL }}
SIGN_APP_ID: ${{ vars.KEYVAULT_APP_ID }}
SIGN_CERT_NAME: ${{ vars.KEYVAULT_CERT_NAME }}
SIGN_TIMESTAMP_URI: ${{ vars.KEYVAULT_TIMESTAMP_URL }}
SIGN_VAULT_URI: ${{ vars.KEYVAULT_URL }}
run: dotnet run --project tools/builder --no-launch-profile -- PublishPackages --timing
- name: "Upload artifact: build"
uses: actions/upload-artifact@v4
with:
name: build
path: artifacts/build
compression-level: 9
if: always()
- name: "Upload artifact: test"
uses: actions/upload-artifact@v4
with:
name: test
path: artifacts/test
compression-level: 9
if: always()
- name: "Upload artifact: packages"
uses: actions/upload-artifact@v4
with:
name: packages
path: artifacts/packages
compression-level: 0
if: always()
- name: Publish Test Report
uses: ctrf-io/github-test-reporter@v1
with:
report-path: './artifacts/test/*.ctrf'
github-report: true
if: always()
================================================
FILE: .github/workflows/ci-unsigned.yaml
================================================
name: xUnit.net Analyzers CI Build (unsigned)
on:
push:
branches-ignore:
- main
- 'rel/**'
workflow_dispatch:
jobs:
build:
name: "Build"
runs-on: windows-latest
env:
DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE: true
DOTNET_NOLOGO: true
steps:
- name: Clone source
uses: actions/checkout@v4
with:
fetch-depth: 0
submodules: true
- name: Install .NET SDK
uses: actions/setup-dotnet@v4
with:
dotnet-version: |
8.0.x
10.0.x
- name: Get .NET information
run: dotnet --info
- name: "Build target: BuildAll"
run: dotnet run --project tools/builder --no-launch-profile -- BuildAll --timing
- name: "Upload artifact: test"
uses: actions/upload-artifact@v4
with:
name: test
path: artifacts/test
compression-level: 9
if: always()
- name: "Upload artifact: packages"
uses: actions/upload-artifact@v4
with:
name: packages
path: artifacts/packages
compression-level: 0
if: always()
- name: Publish Test Report
uses: ctrf-io/github-test-reporter@v1
with:
report-path: './artifacts/test/*.ctrf'
github-report: true
if: always()
================================================
FILE: .github/workflows/pull-request.yaml
================================================
name: xUnit.net Analyzers PR Build
on:
- pull_request
- workflow_dispatch
jobs:
build:
name: "Build"
runs-on: ${{ matrix.os }}
env:
DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE: true
DOTNET_NOLOGO: true
strategy:
fail-fast: false
matrix:
os: [windows-latest, ubuntu-latest, macOS-latest]
steps:
- name: Clone source
uses: actions/checkout@v4
with:
fetch-depth: 0
submodules: true
- name: Install .NET SDK
uses: actions/setup-dotnet@v4
with:
dotnet-version: |
8.0.x
10.0.x
- name: Get .NET information
run: dotnet --info
- name: Install Mono (Ubuntu)
run: >
sudo apt-get -y install apt-transport-https dirmngr gnupg ca-certificates software-properties-common &&
curl 'https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x3fa7e0328081bff6a14da29aa6a19b38d3d831ef' | sudo tee /etc/apt/trusted.gpg.d/mono-official-stable.asc &&
sudo apt-add-repository -y --no-update 'deb https://download.mono-project.com/repo/ubuntu stable-focal main' &&
sudo apt-get update &&
sudo apt-get -y install mono-complete mono-vbnc
if: ${{ matrix.os == 'ubuntu-latest' }}
- name: Install Mono (macOS)
run: brew install mono
if: ${{ matrix.os == 'macOS-latest' }}
- name: Get Mono information
run: mono --version
if: ${{ matrix.os != 'windows-latest' }}
- name: "Build target: BuildAll"
run: dotnet run --project tools/builder --no-launch-profile -- BuildAll
- name: "Upload artifact: test-${{ matrix.os }}"
uses: actions/upload-artifact@v4
with:
name: test-${{ matrix.os }}
path: artifacts/test
compression-level: 9
if: always()
- name: Publish Test Report
uses: ctrf-io/github-test-reporter@v1
with:
report-path: './artifacts/test/*.ctrf'
github-report: true
pull-request: true
update-comment: true
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
if: always()
================================================
FILE: .gitignore
================================================
# Visual Studio
launchSettings.json
# NCrunch
*.ncrunchsolution
*.ncrunchsolution.user
*.ncrunchproject
# Mono's local registry
.mono
##### Copied from https://github.com/github/gitignore/blob/7b22f8ab6c85b4ef1469d72a8ba96462e2a44853/VisualStudio.gitignore
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
##
## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore
# User-specific files
*.rsuser
*.suo
*.user
*.userosscache
*.sln.docstates
# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs
# Mono auto generated files
mono_crash.*
# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
[Ww][Ii][Nn]32/
[Aa][Rr][Mm]/
[Aa][Rr][Mm]64/
bld/
[Bb]in/
[Oo]bj/
[Ll]og/
[Ll]ogs/
# Visual Studio 2015/2017 cache/options directory
.vs/
# Uncomment if you have tasks that create the project's static files in wwwroot
#wwwroot/
# Visual Studio 2017 auto generated files
Generated\ Files/
# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*
# NUnit
*.VisualState.xml
TestResult.xml
nunit-*.xml
# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c
# Benchmark Results
BenchmarkDotNet.Artifacts/
# .NET Core
project.lock.json
project.fragment.lock.json
artifacts/
# ASP.NET Scaffolding
ScaffoldingReadMe.txt
# StyleCop
StyleCopReport.xml
# Files built by Visual Studio
*_i.c
*_p.c
*_h.h
*.ilk
*.meta
*.obj
*.iobj
*.pch
*.pdb
*.ipdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*_wpftmp.csproj
*.log
*.tlog
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc
# Chutzpah Test files
_Chutzpah*
# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opendb
*.opensdf
*.sdf
*.cachefile
*.VC.db
*.VC.VC.opendb
# Visual Studio profiler
*.psess
*.vsp
*.vspx
*.sap
# Visual Studio Trace Files
*.e2e
# TFS 2012 Local Workspace
$tf/
# Guidance Automation Toolkit
*.gpState
# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user
# TeamCity is a build add-in
_TeamCity*
# DotCover is a Code Coverage Tool
*.dotCover
# AxoCover is a Code Coverage Tool
.axoCover/*
!.axoCover/settings.json
# Coverlet is a free, cross platform Code Coverage Tool
coverage*.json
coverage*.xml
coverage*.info
# Visual Studio code coverage results
*.coverage
*.coveragexml
# NCrunch
_NCrunch_*
.*crunch*.local.xml
nCrunchTemp_*
# MightyMoose
*.mm.*
AutoTest.Net/
# Web workbench (sass)
.sass-cache/
# Installshield output folder
[Ee]xpress/
# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html
# Click-Once directory
publish/
# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
# Note: Comment the next line if you want to checkin your web deploy settings,
# but database connection strings (with potential passwords) will be unencrypted
*.pubxml
*.publishproj
# Microsoft Azure Web App publish settings. Comment the next line if you want to
# checkin your Azure Web App publish settings, but sensitive information contained
# in these scripts will be unencrypted
PublishScripts/
# NuGet Packages
*.nupkg
# NuGet Symbol Packages
*.snupkg
# The packages folder can be ignored because of Package Restore
**/[Pp]ackages/*
# except build/, which is used as an MSBuild target.
!**/[Pp]ackages/build/
# Uncomment if necessary however generally it will be regenerated when needed
#!**/[Pp]ackages/repositories.config
# NuGet v3's project.json files produces more ignorable files
*.nuget.props
*.nuget.targets
# Microsoft Azure Build Output
csx/
*.build.csdef
# Microsoft Azure Emulator
ecf/
rcf/
# Windows Store app package directories and files
AppPackages/
BundleArtifacts/
Package.StoreAssociation.xml
_pkginfo.txt
*.appx
*.appxbundle
*.appxupload
# Visual Studio cache files
# files ending in .cache can be ignored
*.[Cc]ache
# but keep track of directories ending in .cache
!?*.[Cc]ache/
# Others
ClientBin/
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.jfm
*.pfx
*.publishsettings
orleans.codegen.cs
# Including strong name files can present a security risk
# (https://github.com/github/gitignore/pull/2483#issue-259490424)
#*.snk
# Since there are multiple workflows, uncomment next line to ignore bower_components
# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
#bower_components/
# RIA/Silverlight projects
Generated_Code/
# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
ServiceFabricBackup/
*.rptproj.bak
# SQL Server files
*.mdf
*.ldf
*.ndf
# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings
*.rptproj.rsuser
*- [Bb]ackup.rdl
*- [Bb]ackup ([0-9]).rdl
*- [Bb]ackup ([0-9][0-9]).rdl
# Microsoft Fakes
FakesAssemblies/
# GhostDoc plugin setting file
*.GhostDoc.xml
# Node.js Tools for Visual Studio
.ntvs_analysis.dat
node_modules/
# Visual Studio 6 build log
*.plg
# Visual Studio 6 workspace options file
*.opt
# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
*.vbw
# Visual Studio 6 auto-generated project file (contains which files were open etc.)
*.vbp
# Visual Studio 6 workspace and project file (working project files containing files to include in project)
*.dsw
*.dsp
# Visual Studio 6 technical files
*.ncb
*.aps
# Visual Studio LightSwitch build output
**/*.HTMLClient/GeneratedArtifacts
**/*.DesktopClient/GeneratedArtifacts
**/*.DesktopClient/ModelManifest.xml
**/*.Server/GeneratedArtifacts
**/*.Server/ModelManifest.xml
_Pvt_Extensions
# Paket dependency manager
.paket/paket.exe
paket-files/
# FAKE - F# Make
.fake/
# CodeRush personal settings
.cr/personal
# Python Tools for Visual Studio (PTVS)
__pycache__/
*.pyc
# Cake - Uncomment if you are using it
# tools/**
# !tools/packages.config
# Tabs Studio
*.tss
# Telerik's JustMock configuration file
*.jmconfig
# BizTalk build output
*.btp.cs
*.btm.cs
*.odx.cs
*.xsd.cs
# OpenCover UI analysis results
OpenCover/
# Azure Stream Analytics local run output
ASALocalRun/
# MSBuild Binary and Structured Log
*.binlog
# NVidia Nsight GPU debugger configuration file
*.nvuser
# MFractors (Xamarin productivity tool) working folder
.mfractor/
# Local History for Visual Studio
.localhistory/
# Visual Studio History (VSHistory) files
.vshistory/
# BeatPulse healthcheck temp database
healthchecksdb
# Backup folder for Package Reference Convert tool in Visual Studio 2017
MigrationBackup/
# Ionide (cross platform F# VS Code tools) working folder
.ionide/
# Fody - auto-generated XML schema
FodyWeavers.xsd
# VS Code files for those working on multiple tools
.vscode/*
!.vscode/settings.json
!.vscode/tasks.json
!.vscode/launch.json
!.vscode/extensions.json
*.code-workspace
# Local History for Visual Studio Code
.history/
# Windows Installer files from build outputs
*.cab
*.msi
*.msix
*.msm
*.msp
# JetBrains Rider
*.sln.iml
.idea/
================================================
FILE: .gitmodules
================================================
[submodule "tools/media"]
path = tools/media
url = https://github.com/xunit/media
[submodule "tools/builder/common"]
path = tools/builder/common
url = https://github.com/xunit/build-tools-v3
================================================
FILE: .vscode/launch.json
================================================
{
"version": "0.2.0",
"configurations": []
}
================================================
FILE: .vscode/settings.json
================================================
{
"cSpell.words": [
"LLMBRO",
"MBRO",
"app",
"nuget",
"nupkg",
"parallelization",
"veyor"
],
"files.exclude": {
"**/.git": true,
"**/.DS_Store": true,
"**/bin": true,
"**/obj": true,
"artifacts": true,
"packages": true
}
}
================================================
FILE: .vscode/tasks.json
================================================
{
"version": "2.0.0",
"tasks": [
{
"label": "Build",
"type": "process",
"command": "dotnet",
"args": [
"run",
"--project",
"tools/builder",
"--no-launch-profile",
"--",
"Build"
],
"options": {
"cwd": "${workspaceRoot}"
},
"group": "build",
"presentation": {
"focus": true
},
"problemMatcher": []
},
{
"label": "Pre-PR Validation",
"type": "process",
"command": "dotnet",
"args": [
"run",
"--project",
"tools/builder",
"--no-launch-profile",
"--",
"Packages"
],
"options": {
"cwd": "${workspaceRoot}"
},
"group": "build",
"presentation": {
"focus": true
},
"problemMatcher": []
},
{
"label": "Unit Tests (.NET Core)",
"type": "process",
"command": "dotnet",
"args": [
"run",
"--project",
"tools/builder",
"--no-launch-profile",
"--",
"TestCore"
],
"options": {
"cwd": "${workspaceRoot}"
},
"group": "build",
"presentation": {
"focus": true
},
"problemMatcher": []
},
{
"label": "Unit Tests (.NET Framework)",
"type": "process",
"command": "dotnet",
"args": [
"run",
"--project",
"tools/builder",
"--no-launch-profile",
"--",
"TestFx"
],
"options": {
"cwd": "${workspaceRoot}"
},
"group": "build",
"presentation": {
"focus": true
},
"problemMatcher": []
}
]
}
================================================
FILE: BUILDING.md
================================================
# Building xUnit.net Analyzers
The primary build system for xUnit.net Analyzers is done via command line, and officially supports Linux and Windows. Users running macOS can generally follow the Linux instructions (while installing the macOS equivalents of the dependencies).
# Pre-Requisites
You will need the following software installed (regardless of OS):
* [.NET SDK 8.0](https://dotnet.microsoft.com/download/dotnet/8.0)
* [git](https://git-scm.com/downloads)
## Linux Pre-Requisites
Linux users will additionally need:
* [Mono](https://www.mono-project.com/download/stable/) 6.12+
* [bash](https://www.gnu.org/software/bash/)
Note: Linux users cannot run the .NET Framework tests, as they are incompatible. For this reason, we recommend that users either work primarily in Windows, or verify their tests work as expected in a Windows VM, before submitting PRs.
## Windows Pre-Requisites
Windows users will additionally need:
* .NET Framework 4.7.2 or later (part of the Windows OS)
* [PowerShell 7+](https://learn.microsoft.com/powershell/scripting/install/installing-powershell-on-windows)
Ensure that you have configured PowerShell to be able to run local unsigned scripts (either by running `Set-ExecutionPolicy RemoteSigned` from within PowerShell, or by launching PowerShell with the `-ExecutionPolicy RemoteSigned` command line switch).
_Note that the built-in version of PowerShell may work, but is unsupported by us. If you have PowerShell-related issues, please make sure you have installed PowerShell 7+ and the command prompt you opened is for PowerShell 7+, and not the built-in version of PowerShell._
# Command-Line Build
1. **Linux users:** Open a terminal to your favorite shell.
**Windows users:** Open PowerShell 7+.
1. From the root folder of the source repo, this command will build the code & run all tests:
`./build`
To build a specific target (or multiple targets):
`./build [target [target...]]`
The common targets (case-insensitive) include:
* `Restore`: Perform package restore
* `Build`: Build the source
* `Test`: Run all unit tests
You can get a list of options:
`./build --help`
# Editing source
The primary projects for editing are:
* `xunit.analyzers` (for code analysis)
* `xunit.analyzers.fixes` (for automated fixes for issues raised in code analysis)
* `xunit.analyzers.tests` (for unit tests of both above projects)
These are targeting our lowest common denominator for Roslyn (current version 3.11, the version that's supported in Visual Studio 2019 16.11).
There are also three projects which build against the latest version of Roslyn:
* `xunit.analyzers.latest`
* `xunit.analyzers.latest.fixes`
* `xunit.analyzers.latest.tests`
When running a command line build, we run a matrix of 4 test projects: Roslyn 3.11 vs. latest, and .NET Framework vs. .NET. It's important that you run `./build` (or `./build test`) from Windows before submitting PRs, because some bugs are often found only in one of the four combinations (and Mono cannot run the .NET Framework tests).
You will also occasionally see tests which only run in specific environments. Common `#if` statements you may see (or may need to use) include:
* `#if NETFRAMEWORK` (only runs for .NET Framework)
* `#if NETCOREAPP` (only runs for .NET)
* `#if ROSLYN_LATEST` (only runs with latest Roslyn, which includes getting analysis test support to C# language > version 9)
In production code, we try to minimize these when possible, and prefer to fall back to use dynamic runtime environment detection when we can (as we'd like to light up features in newer versions of Roslyn when available). While this isn't always possible, it is generally a goal we try to achieve. In test code, we tend to use these to more frequently to ensure we have complete coverage of features that should be available dynamically (whether they are lit up based on `#if` or by runtime environment detection).
================================================
FILE: LICENSE
================================================
Unless otherwise noted, the source code here is covered by the following license:
Copyright (c) .NET Foundation and Contributors
All Rights Reserved
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
The source in src/xunit.analyzers.tests/Utilities/XunitVerifier.cs was adapted from code
that is covered the following license (copied from
https://github.com/dotnet/roslyn-sdk/blob/35d5e46fd5c403194692c645d912a17d36ed74f5/LICENSE.txt):
The MIT License (MIT)
Copyright (c) .NET Foundation and Contributors
All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: NuGet.Config
================================================
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<packageSources>
<clear />
<add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
<add key="feedz.io/xunit/xunit" value="https://f.feedz.io/xunit/xunit/nuget/index.json" protocolVersion="3" />
</packageSources>
</configuration>
================================================
FILE: README.md
================================================
# About This Project
This project contains source code analysis and cleanup rules for xUnit.net. Analysis and fixes are only supported with C#.
**Requirements**: xUnit.net v2 or v3. Supported in Visual Studio 2019, 2022, and 2026 (as well as via command line builds with Roslyn 3.11+). Other environments (such as Mono or JetBrains Rider) may be able to use these analyzers as well; support and issue resolution will be provided by those third parties and not by xUnit.net itself.
**Documentation**: a list of supported rules is available at https://xunit.net/xunit.analyzers/rules/
**Bugs and issues**: please visit the [core xUnit.net project issue tracker](https://github.com/xunit/xunit/issues).
**Building**: see [BUILDING.md](https://github.com/xunit/xunit.analyzers/blob/main/BUILDING.md).
> _**Note:** Our minimum supported versions of Visual Studio 2019, 2022, and 2026 align with the "Baseline" column of the "Support for Older Versions" table of [Visual Studio Product Lifecycle and Servicing](https://learn.microsoft.com/visualstudio/releases/2026/servicing-vs#support-for-older-versions), as these are the minimum versions supported by Microsoft. If you are experiencing issues with an older version of Visual Studio, please upgrade and verify the issue still exists before opening issues._
## How to install
- xUnit.net v3: the analyzer package is referenced by the main [`xunit.v3` NuGet package](https://www.nuget.org/packages/xunit.v3) out of the box. If you choose to reference [`xunit.v3.core`](https://www.nuget.org/packages/xunit.v3.core) instead, you can reference [`xunit.analyzers`](https://www.nuget.org/packages/xunit.analyzers) explicitly.
- xUnit.net v2 2.3.0 and higher: the analyzer package is referenced by the main [`xunit` NuGet package](https://www.nuget.org/packages/xunit) out of the box. If you choose to reference [`xunit.core`](https://www.nuget.org/packages/xunit.core) instead, you can reference [`xunit.analyzers`](https://www.nuget.org/packages/xunit.analyzers) explicitly.
- xUnit.net v2 2.2.0 and earlier: you have to install the [`xunit.analyzers` NuGet package](https://www.nuget.org/packages/xunit.analyzers) explicitly.
## How to uninstall
- If you are using xUnit.net v3 and do not wish to use the analyzers package, replace the package reference to [`xunit.v3`](https://www.nuget.org/packages/xunit.v3) with the corresponding versions of [`xunit.v3.core`](https://www.nuget.org/packages/xunit.v3.core) and [`xunit.v3.assert`](https://www.nuget.org/packages/xunit.v3.assert).
- If you are using xUnit.net v2 2.3.0 or higher and do not wish to use the analyzers package, replace the package reference to [`xunit`](https://www.nuget.org/packages/xunit) with the corresponding versions of [`xunit.core`](https://www.nuget.org/packages/xunit.core) and [`xunit.assert`](https://www.nuget.org/packages/xunit.assert).
- If you are using xUnit.net v2 v2.2.0 or earlier: remove the reference to the [`xunit.analyzers` NuGet package](https://www.nuget.org/packages/xunit.analyzers).
## Analysis and Code Fix in Action
# About xUnit.net
xUnit.net is a free, open source, community-focused unit testing tool for C#, F#, and Visual Basic.
xUnit.net works with the [.NET SDK](https://dotnet.microsoft.com/download) command line tools, [Visual Studio](https://visualstudio.microsoft.com/), [Visual Studio Code](https://code.visualstudio.com/), [JetBrains Rider](https://www.jetbrains.com/rider/), [NCrunch](https://www.ncrunch.net/), and any development environment compatible with [Microsoft Testing Platform](https://learn.microsoft.com/dotnet/core/testing/microsoft-testing-platform-intro) (xUnit.net v3) or [VSTest](https://github.com/microsoft/vstest) (all versions of xUnit.net).
xUnit.net is part of the [.NET Foundation](https://www.dotnetfoundation.org/) and operates under their [code of conduct](https://www.dotnetfoundation.org/code-of-conduct). It is licensed under [Apache 2](https://opensource.org/licenses/Apache-2.0) (an OSI approved license). The project is [governed](https://xunit.net/governance) by a Project Lead.
For project documentation, please visit the [xUnit.net project home](https://xunit.net/).
* _New to xUnit.net? Get started with the [.NET SDK](https://xunit.net/docs/getting-started/v3/getting-started)._
* _Need some help building the source? See [BUILDING.md](https://github.com/xunit/xunit/tree/main/BUILDING.md)._
* _Want to contribute to the project? See [CONTRIBUTING.md](https://github.com/xunit/.github/tree/main/CONTRIBUTING.md)._
* _Want to contribute to the assertion library? See the [suggested contribution workflow](https://github.com/xunit/assert.xunit/tree/main/README.md#suggested-contribution-workflow) in the assertion library project, as it is slightly more complex due to code being spread across two GitHub repositories._
## Latest Builds
| | Latest stable | Latest CI ([how to use](https://xunit.net/docs/using-ci-builds)) | Build status
| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------
| `xunit.v3` | [](https://www.nuget.org/packages/xunit.v3) | [](https://feedz.io/org/xunit/repository/xunit/packages/xunit.v3) | [](https://actions-badge.atrox.dev/xunit/xunit/goto?ref=main)
| `xunit` | [](https://www.nuget.org/packages/xunit) | [](https://feedz.io/org/xunit/repository/xunit/packages/xunit) | [](https://actions-badge.atrox.dev/xunit/xunit/goto?ref=v2)
| `xunit.analyzers` | [](https://www.nuget.org/packages/xunit.analyzers) | [](https://feedz.io/org/xunit/repository/xunit/packages/xunit.analyzers) | [](https://actions-badge.atrox.dev/xunit/xunit.analyzers/goto?ref=main)
| `xunit.runner.visualstudio` | [](https://www.nuget.org/packages/xunit.runner.visualstudio) | [](https://feedz.io/org/xunit/repository/xunit/packages/xunit.runner.visualstudio) | [](https://actions-badge.atrox.dev/xunit/visualstudio.xunit/goto?ref=main)
*For complete CI package lists, please visit the [feedz.io package search](https://feedz.io/org/xunit/repository/xunit/search). A free login is required.*
## Sponsors
Help support this project by becoming a sponsor through [GitHub Sponsors](https://github.com/sponsors/xunit).
================================================
FILE: build
================================================
#!/usr/bin/env bash
set -euo pipefail
PUSHED=0
cleanup () {
if [[ $PUSHED == 1 ]]; then
popd >/dev/null
PUSHED=0
fi
}
trap cleanup EXIT ERR INT TERM
if which git > /dev/null; then
git submodule status | while read line; do
if [ "$(echo $line | cut -b1)" == "-" ]; then
pieces=( $line )
git submodule update --init ${pieces[1]}
echo ""
fi
done
else
echo "error(1): Could not find 'git'; please install the Git CLI" 2>&1
exit 1
fi
if which dotnet > /dev/null; then
if [ $(dotnet --version | cut -d. -f1) -lt 8 ]; then
echo "error(1): .NET SDK version $(dotnet --version) is too low; please install 8.0 or later"
exit 1
fi
if [ `uname -o` = Msys ] || which mono > /dev/null ; then
pushd $( cd "$(dirname "$0")" ; pwd -P ) >/dev/null
PUSHED=1
dotnet run --project tools/builder --no-launch-profile -- "$@"
else
echo "error(1): Could not find 'mono'; please install Mono" 2>&1
exit 1
fi
else
echo "error(1): Could not find 'dotnet'; please install the .NET Core SDK" 2>&1
exit 1
fi
================================================
FILE: build.ps1
================================================
#!/usr/bin/env pwsh
#Requires -Version 5.1
Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"
if ($null -eq (Get-Command "git" -ErrorAction Ignore)) {
throw "Could not find 'git'; please install the Git command line tooling"
}
& git submodule status | ForEach-Object {
if ($_[0] -eq '-') {
$pieces = $_.Split(' ')
& git submodule update --init "$($pieces[1])"
Write-Host ""
}
}
if ($null -eq (Get-Command "dotnet" -ErrorAction Ignore)) {
throw "Could not find 'dotnet'; please install the .NET Core SDK"
}
$version = [Version]$([regex]::matches((&dotnet --version), '^(\d+\.)?(\d+\.)?(\*|\d+)').value)
if ($version.Major -lt 8) {
throw ".NET SDK version ($version) is too low; please install version 8.0 or later"
}
Push-Location (Split-Path $MyInvocation.MyCommand.Definition)
try {
& dotnet run --project tools/builder --no-launch-profile -- $args
}
finally {
Pop-Location
}
================================================
FILE: global.json
================================================
{
"sdk": {
"version": "10.0.100",
"rollForward": "latestMinor"
}
}
================================================
FILE: src/Directory.Build.props
================================================
<Project>
<!-- ============================== -->
<!-- Universal properties and items -->
<PropertyGroup>
<AnnotatedReferenceAssemblyVersion>8.0.10</AnnotatedReferenceAssemblyVersion>
<ContinuousIntegrationBuild Condition=" '$(GITHUB_ACTIONS)' == 'true' ">true</ContinuousIntegrationBuild>
<DebugType>embedded</DebugType>
<EmbedUntrackedSources>true</EmbedUntrackedSources>
<GenerateAssemblyDescriptionAttribute>false</GenerateAssemblyDescriptionAttribute>
<GenerateAssemblyFileVersionAttribute>false</GenerateAssemblyFileVersionAttribute>
<GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
<GenerateAssemblyCopyrightAttribute>false</GenerateAssemblyCopyrightAttribute>
<GenerateAssemblyInformationalVersionAttribute>false</GenerateAssemblyInformationalVersionAttribute>
<GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
<GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
<GenerateAssemblyVersionAttribute>false</GenerateAssemblyVersionAttribute>
<GenerateDocumentationFile>true</GenerateDocumentationFile>
<LangVersion>14.0</LangVersion>
<MicrosoftCodeAnalysisVersion Condition=" '$(MicrosoftCodeAnalysisVersion)' == '' ">3.11</MicrosoftCodeAnalysisVersion>
<MSBuildCopyContentTransitively>false</MSBuildCopyContentTransitively>
<Nullable>enable</Nullable>
<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
</PropertyGroup>
<ItemGroup>
<Compile Include="$(MSBuildThisFileDirectory)common\*.cs" LinkBase="Utility\Common" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="[$(MicrosoftCodeAnalysisVersion)]" />
<PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="[$(MicrosoftCodeAnalysisVersion)]" />
<PackageReference Include="Microsoft.SourceLink.GitHub" Version="10.0.102" PrivateAssets="all" />
<PackageReference Include="Nerdbank.GitVersioning" Version="3.9.50">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
</ItemGroup>
<!-- ======================================== -->
<!-- Production-specific properties and items -->
<Choose>
<When Condition=" !$(MSBuildProjectName.Contains('.tests')) ">
<PropertyGroup>
<AnalysisLevel>latest-All</AnalysisLevel>
<AssemblyOriginatorKeyFile>$(MSBuildThisFileDirectory)signing.snk</AssemblyOriginatorKeyFile>
<EnableNETAnalyzers>true</EnableNETAnalyzers>
<EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
<EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
<SignAssembly>true</SignAssembly>
</PropertyGroup>
</When>
</Choose>
<!-- ================================== -->
<!-- Test-specific properties and items -->
<Choose>
<When Condition=" $(MSBuildProjectName.Contains('.tests')) ">
<PropertyGroup>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
<CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
<CopyNuGetImplementations>true</CopyNuGetImplementations>
<DefineConstants>$(DefineConstants);XUNIT_NULLABLE;XUNIT_POINTERS;XUNIT_VISIBILITY_INTERNAL</DefineConstants>
<GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
<GenerateDependencyFile>true</GenerateDependencyFile>
<GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
</PropertyGroup>
<ItemGroup>
<Content Include="$(MSBuildThisFileDirectory)xunit.analyzers.tests\xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing" Version="1.1.3" />
<PackageReference Include="NSubstitute" Version="5.3.0" />
<PackageReference Include="System.ValueTuple" Version="4.6.1" />
<PackageReference Include="xunit.v3.assert.source" Version="[3.2.2-pre.18, 3.99.0)" />
<PackageReference Include="xunit.v3.core" Version="[3.2.2-pre.18, 3.99.0)" />
</ItemGroup>
</When>
</Choose>
</Project>
================================================
FILE: src/Directory.Build.targets
================================================
<Project>
<!-- Enable building .NET Framework on non-Windows machines -->
<ItemGroup Condition=" '$(TargetFrameworkIdentifier)' == '.NETFramework' ">
<PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
</ItemGroup>
<!-- Enable nullable support for older targets -->
<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' OR '$(TargetFrameworkIdentifier)' == '.NETFramework' ">
<PackageReference Include="TunnelVisionLabs.ReferenceAssemblyAnnotator" Version="1.0.0-alpha.160">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
<PackageDownload Include="Microsoft.NETCore.App.Ref" Version="[$(AnnotatedReferenceAssemblyVersion)]" />
</ItemGroup>
<!-- Supplement Nerdbank.GitVersioning version calculations -->
<Target Name="UpdateAssemblyVersionInfo" BeforeTargets="GenerateAssemblyNBGVVersionInfo" DependsOnTargets="GetBuildVersion">
<PropertyGroup>
<!-- Local builds should have a '-dev' suffix on the build number -->
<PrereleaseSuffix Condition=" '$(GITHUB_ACTIONS)' != 'true' ">-dev</PrereleaseSuffix>
<!-- AssemblyVersion and AssemblyFileVersion should be x.y.z.0 -->
<AssemblyVersion>$(BuildVersionSimple)</AssemblyVersion>
<AssemblyFileVersion>$(BuildVersionSimple)</AssemblyFileVersion>
<!-- Always put the Git hash in the informational version, even for non-pre-release versions -->
<AssemblyInformationalVersion>$(BuildVersionSimple)$(PrereleaseVersion)$(PrereleaseSuffix)+$(GitCommitIdShort)</AssemblyInformationalVersion>
</PropertyGroup>
</Target>
<Target Name="UpdateNuSpecProperties" BeforeTargets="GenerateNuspec" DependsOnTargets="GetBuildVersion">
<PropertyGroup>
<SignedPath />
<SignedPath Condition=" '$(SIGN_APP_ID)' != '' ">signed\</SignedPath>
<!-- Local builds should have a '-dev' suffix on the build number -->
<PrereleaseSuffix Condition=" '$(GITHUB_ACTIONS)' != 'true' ">-dev</PrereleaseSuffix>
<!-- Never put the Git hash in the package version -->
<PackageVersion>$(BuildVersionSimple)$(PrereleaseVersion)$(PrereleaseSuffix)</PackageVersion>
<PackageReleaseNotes>https://xunit.net/releases/analyzers/$(PackageVersion)</PackageReleaseNotes>
<!-- Pass through values we don't know ahead of time for any hand-crafted .nuspec files -->
<NuspecProperties>
Configuration=$(Configuration);
GitCommitId=$(GitCommitId);
PackageVersion=$(PackageVersion);
SignedPath=$(SignedPath);
</NuspecProperties>
</PropertyGroup>
</Target>
</Project>
================================================
FILE: src/common/CallerArgumentExpressionAttribute.cs
================================================
#if !NETCOREAPP
namespace System.Runtime.CompilerServices;
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
internal sealed class CallerArgumentExpressionAttribute(string parameterName) :
Attribute
{
public string ParameterName { get; } = parameterName;
}
#endif
================================================
FILE: src/common/Guard.cs
================================================
using System;
using System.Collections;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
namespace Xunit;
/// <summary>
/// Helper class for guarding value arguments and valid state.
/// </summary>
static class Guard
{
/// <summary>
/// Ensures that a nullable reference type argument is not null.
/// </summary>
/// <typeparam name="T">The argument type</typeparam>
/// <param name="argValue">The value of the argument</param>
/// <param name="argName">The name of the argument</param>
/// <returns>The argument value as a non-null value</returns>
/// <exception cref="ArgumentNullException">Thrown when the argument is null</exception>
public static T ArgumentNotNull<T>(
[NotNull] T? argValue,
[CallerArgumentExpression(nameof(argValue))] string? argName = null)
where T : class
{
if (argValue is null)
throw new ArgumentNullException(argName?.TrimStart('@'));
return argValue;
}
/// <summary>
/// Ensures that a nullable enumerable type argument is not null or empty.
/// </summary>
/// <typeparam name="T">The argument type</typeparam>
/// <param name="argValue">The value of the argument</param>
/// <param name="argName">The name of the argument</param>
/// <returns>The argument value as a non-null, non-empty value</returns>
/// <exception cref="ArgumentException">Thrown when the argument is null or empty</exception>
public static T ArgumentNotNullOrEmpty<T>(
[NotNull] T? argValue,
[CallerArgumentExpression(nameof(argValue))] string? argName = null)
where T : class, IEnumerable
{
ArgumentNotNull(argValue, argName);
if (!argValue.GetEnumerator().MoveNext())
throw new ArgumentException("Argument was empty", argName?.TrimStart('@'));
return argValue;
}
/// <summary>
/// Ensures that an argument is valid.
/// </summary>
/// <param name="message">The exception message to use when the argument is not valid</param>
/// <param name="test">The validity test value</param>
/// <param name="argName">The name of the argument</param>
/// <returns>The argument value as a non-null value</returns>
/// <exception cref="ArgumentException">Thrown when the argument is not valid</exception>
public static void ArgumentValid(
string message,
bool test,
string? argName = null)
{
if (!test)
throw new ArgumentException(message, argName);
}
/// <summary>
/// Ensures that an argument is valid.
/// </summary>
/// <param name="messageFunc">The creator for an exception message to use when the argument is not valid</param>
/// <param name="test">The validity test value</param>
/// <param name="argName">The name of the argument</param>
/// <returns>The argument value as a non-null value</returns>
/// <exception cref="ArgumentException">Thrown when the argument is not valid</exception>
public static void ArgumentValid(
Func<string> messageFunc,
bool test,
string? argName = null)
{
if (!test)
throw new ArgumentException(messageFunc?.Invoke(), argName);
}
}
================================================
FILE: src/compat/Directory.Build.props
================================================
<Project>
<PropertyGroup>
<DefineConstants>$(DefineConstants);ROSLYN_LATEST</DefineConstants>
<MicrosoftCodeAnalysisVersion>4.14.0</MicrosoftCodeAnalysisVersion>
</PropertyGroup>
<Import Project="..\Directory.Build.props"/>
</Project>
================================================
FILE: src/compat/xunit.analyzers.latest/xunit.analyzers.latest.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<RootNamespace>Xunit.Analyzers</RootNamespace>
<TargetFramework>netstandard2.0</TargetFramework>
</PropertyGroup>
<ItemGroup>
<Compile Include="..\..\xunit.analyzers\**\*.cs" Exclude="**\obj\**" />
</ItemGroup>
</Project>
================================================
FILE: src/compat/xunit.analyzers.latest.fixes/xunit.analyzers.latest.fixes.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<RootNamespace>Xunit.Analyzers.Fixes</RootNamespace>
<TargetFramework>netstandard2.0</TargetFramework>
</PropertyGroup>
<ItemGroup>
<Compile Include="..\..\xunit.analyzers.fixes\**\*.cs" Exclude="**\obj\**" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\xunit.analyzers.latest\xunit.analyzers.latest.csproj" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="[$(MicrosoftCodeAnalysisVersion)]" />
</ItemGroup>
</Project>
================================================
FILE: src/compat/xunit.analyzers.latest.tests/xunit.analyzers.latest.tests.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<AssemblyName>xunit.analyzers.latest.tests.$(TargetFramework)</AssemblyName>
<OutputType>Exe</OutputType>
<PackageId>xunit.analyzers.latest.tests</PackageId>
<RootNamespace>Xunit.Analyzers</RootNamespace>
<TargetFrameworks>net8.0;net472</TargetFrameworks>
</PropertyGroup>
<ItemGroup>
<Compile Include="..\..\xunit.analyzers.tests\**\*.cs" Exclude="**\obj\**" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\xunit.analyzers.latest\xunit.analyzers.latest.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="true" />
<ProjectReference Include="..\xunit.analyzers.latest.fixes\xunit.analyzers.latest.fixes.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="true" />
</ItemGroup>
</Project>
================================================
FILE: src/xunit.analyzers/Properties/AssemblyInfo.cs
================================================
using System.Reflection;
[assembly: AssemblyCompany(".NET Foundation")]
[assembly: AssemblyProduct("xUnit.net Testing Framework")]
[assembly: AssemblyCopyright("Copyright (C) .NET Foundation")]
[assembly: AssemblyTitle("xUnit.net Code Analysis (Analyzers)")]
================================================
FILE: src/xunit.analyzers/Suppressors/ConsiderCallingConfigureAwaitSuppressor.cs
================================================
using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
using Xunit.Analyzers;
namespace Xunit.Suppressors;
[DiagnosticAnalyzer(LanguageNames.CSharp)]
public sealed class ConsiderCallingConfigureAwaitSuppressor : XunitDiagnosticSuppressor
{
public ConsiderCallingConfigureAwaitSuppressor() :
base(Descriptors.CA2007_Suppression)
{ }
protected override bool ShouldSuppress(
Diagnostic diagnostic,
SuppressionAnalysisContext context,
XunitContext xunitContext)
{
if (diagnostic.Location.SourceTree is null)
return false;
var factAttributeType = xunitContext.Core.FactAttributeType;
var theoryAttributeType = xunitContext.Core.TheoryAttributeType;
if (factAttributeType is null || theoryAttributeType is null)
return false;
var root = diagnostic.Location.SourceTree.GetRoot(context.CancellationToken);
if (root?.FindNode(diagnostic.Location.SourceSpan) is not InvocationExpressionSyntax invocationSyntax)
return false;
var current = invocationSyntax.Parent;
while (true)
{
if (current is null or LocalFunctionStatementSyntax or LambdaExpressionSyntax)
return false;
if (current is MethodDeclarationSyntax)
break;
current = current.Parent;
}
var semanticModel = context.GetSemanticModel(diagnostic.Location.SourceTree);
var methodSymbol = semanticModel.GetDeclaredSymbol(current);
if (methodSymbol is null)
return false;
var attributes = ImmutableHashSet.Create(SymbolEqualityComparer.Default, factAttributeType, theoryAttributeType);
return
methodSymbol
.GetAttributes()
.Any(a => attributes.Contains(a.AttributeClass));
}
}
================================================
FILE: src/xunit.analyzers/Suppressors/MakeTypesInternalSuppressor.cs
================================================
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
using Xunit.Analyzers;
namespace Xunit.Suppressors;
[DiagnosticAnalyzer(LanguageNames.CSharp)]
public sealed class MakeTypesInternalSuppressor : XunitDiagnosticSuppressor
{
public MakeTypesInternalSuppressor() :
base(Descriptors.CA1515_Suppression)
{ }
protected override bool ShouldSuppress(
Diagnostic diagnostic,
SuppressionAnalysisContext context,
XunitContext xunitContext)
{
if (diagnostic.Location.SourceTree is null)
return false;
var root = diagnostic.Location.SourceTree.GetRoot(context.CancellationToken);
if (root?.FindNode(diagnostic.Location.SourceSpan) is not ClassDeclarationSyntax classDeclaration)
return false;
var semanticModel = context.GetSemanticModel(diagnostic.Location.SourceTree);
var classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration) as ITypeSymbol;
return classSymbol.IsTestClass(xunitContext, strict: false);
}
}
================================================
FILE: src/xunit.analyzers/Suppressors/NonNullableFieldInitializationSuppressor.cs
================================================
using System.Globalization;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
using Xunit.Analyzers;
namespace Xunit.Suppressors;
[DiagnosticAnalyzer(LanguageNames.CSharp)]
public sealed class NonNullableFieldInitializationSuppressor : XunitDiagnosticSuppressor
{
public NonNullableFieldInitializationSuppressor() :
base(Descriptors.CS8618_Suppression)
{ }
protected override bool ShouldSuppress(
Diagnostic diagnostic,
SuppressionAnalysisContext context,
XunitContext xunitContext)
{
if (diagnostic.Location.SourceTree is null)
return false;
var asyncLifetimeType = TypeSymbolFactory.IAsyncLifetime(context.Compilation);
if (asyncLifetimeType is null)
return false;
var root = diagnostic.Location.SourceTree.GetRoot(context.CancellationToken);
var node = root?.FindNode(diagnostic.Location.SourceSpan);
if (node is null)
return false;
var semanticModel = context.GetSemanticModel(diagnostic.Location.SourceTree);
var memberSymbol = ResolveMemberSymbol(diagnostic, node, semanticModel, context);
if (memberSymbol is null)
return false;
var containingType = memberSymbol.ContainingType;
if (containingType is null)
return false;
if (!containingType.AllInterfaces.Contains(asyncLifetimeType, SymbolEqualityComparer.Default))
return false;
// Find the InitializeAsync method implementation
var initializeAsyncInterfaceMethod = asyncLifetimeType.GetMembers("InitializeAsync").FirstOrDefault();
if (initializeAsyncInterfaceMethod is null)
return false;
var initializeAsyncImpl = containingType.FindImplementationForInterfaceMember(initializeAsyncInterfaceMethod);
if (initializeAsyncImpl is null)
return false;
return IsMemberAssignedInMethod(initializeAsyncImpl, memberSymbol, context);
}
static ISymbol? ResolveMemberSymbol(
Diagnostic diagnostic,
SyntaxNode node,
SemanticModel semanticModel,
SuppressionAnalysisContext context)
{
// CS8618 can target field variable declarators or property declarations directly
ISymbol? memberSymbol = node switch
{
VariableDeclaratorSyntax variableDeclarator => semanticModel.GetDeclaredSymbol(variableDeclarator),
PropertyDeclarationSyntax propertyDeclaration => semanticModel.GetDeclaredSymbol(propertyDeclaration),
_ => null,
};
if (memberSymbol is not null)
return memberSymbol;
// Check AdditionalLocations (some compiler versions include member location here)
foreach (var additionalLocation in diagnostic.AdditionalLocations)
{
if (additionalLocation.SourceTree is null)
continue;
var addRoot = additionalLocation.SourceTree.GetRoot(context.CancellationToken);
var addNode = addRoot.FindNode(additionalLocation.SourceSpan);
var addModel = context.GetSemanticModel(additionalLocation.SourceTree);
var symbol = addModel.GetDeclaredSymbol(addNode, context.CancellationToken);
if (symbol is IFieldSymbol or IPropertySymbol)
return symbol;
}
// Fallback: CS8618 on a constructor — extract member name from diagnostic message
var declaredSymbol = semanticModel.GetDeclaredSymbol(node, context.CancellationToken);
if (declaredSymbol is IMethodSymbol { MethodKind: MethodKind.Constructor } constructorSymbol)
{
var message = diagnostic.GetMessage(CultureInfo.InvariantCulture);
var startQuote = message.IndexOf('\'');
if (startQuote >= 0)
{
var endQuote = message.IndexOf('\'', startQuote + 1);
if (endQuote > startQuote)
{
var memberName = message.Substring(startQuote + 1, endQuote - startQuote - 1);
return constructorSymbol.ContainingType
.GetMembers(memberName)
.FirstOrDefault(m => m is IFieldSymbol or IPropertySymbol);
}
}
}
return null;
}
static bool IsMemberAssignedInMethod(
ISymbol methodSymbol,
ISymbol targetMember,
SuppressionAnalysisContext context)
{
foreach (var syntaxRef in methodSymbol.DeclaringSyntaxReferences)
{
var methodSyntax = syntaxRef.GetSyntax(context.CancellationToken);
if (methodSyntax is not MethodDeclarationSyntax methodDecl)
continue;
var methodSemanticModel = context.GetSemanticModel(methodSyntax.SyntaxTree);
foreach (var assignment in methodDecl.DescendantNodes().OfType<AssignmentExpressionSyntax>())
{
var assignedSymbol = methodSemanticModel.GetSymbolInfo(assignment.Left).Symbol;
if (assignedSymbol is not null && SymbolEqualityComparer.Default.Equals(assignedSymbol, targetMember))
return true;
}
}
return false;
}
}
================================================
FILE: src/xunit.analyzers/Suppressors/UseAsyncSuffixForAsyncMethodsSuppressor.cs
================================================
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
using Xunit.Analyzers;
namespace Xunit.Suppressors;
[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class UseAsyncSuffixForAsyncMethodsSuppressor : XunitDiagnosticSuppressor
{
public UseAsyncSuffixForAsyncMethodsSuppressor() :
base(Descriptors.VSTHRD200_Suppression)
{ }
protected override bool ShouldSuppress(
Diagnostic diagnostic,
SuppressionAnalysisContext context,
XunitContext xunitContext)
{
var attributeUsageType = TypeSymbolFactory.AttributeUsageAttribute(context.Compilation);
if (attributeUsageType is null)
return false;
if (diagnostic?.Location.SourceTree is null)
return false;
if (diagnostic.Location.SourceTree.GetRoot().FindNode(diagnostic.Location.SourceSpan) is not MethodDeclarationSyntax methodDeclaration)
return false;
var semanticModel = context.GetSemanticModel(diagnostic.Location.SourceTree);
var methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration) as IMethodSymbol;
return methodSymbol.IsTestMethod(xunitContext, attributeUsageType, strict: false);
}
}
================================================
FILE: src/xunit.analyzers/Utility/AssertUsageAnalyzerBase.cs
================================================
using System;
using System.Collections.Generic;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Operations;
namespace Xunit.Analyzers;
public abstract class AssertUsageAnalyzerBase(
DiagnosticDescriptor[] descriptors,
IEnumerable<string> methods) :
XunitDiagnosticAnalyzer(descriptors)
{
readonly HashSet<string> targetMethods = new(methods, StringComparer.Ordinal);
protected AssertUsageAnalyzerBase(
DiagnosticDescriptor descriptor,
IEnumerable<string> methods)
: this([descriptor], methods)
{ }
public sealed override void AnalyzeCompilation(
CompilationStartAnalysisContext context,
XunitContext xunitContext)
{
Guard.ArgumentNotNull(context);
Guard.ArgumentNotNull(xunitContext);
var assertType = TypeSymbolFactory.Assert(context.Compilation);
if (assertType is null)
return;
context.RegisterOperationAction(context =>
{
if (context.Operation is IInvocationOperation invocationOperation)
{
var methodSymbol = invocationOperation.TargetMethod;
if (methodSymbol.MethodKind != MethodKind.Ordinary || !SymbolEqualityComparer.Default.Equals(methodSymbol.ContainingType, assertType) || !targetMethods.Contains(methodSymbol.Name))
return;
AnalyzeInvocation(context, xunitContext, invocationOperation, methodSymbol);
}
}, OperationKind.Invocation);
}
protected abstract void AnalyzeInvocation(
OperationAnalysisContext context,
XunitContext xunitContext,
IInvocationOperation invocationOperation,
IMethodSymbol method);
}
================================================
FILE: src/xunit.analyzers/Utility/Category.cs
================================================
namespace Xunit.Analyzers;
public enum Category
{
// 1xxx
Usage,
// 2xxx
Assertions,
// 3xxx
Extensibility,
}
================================================
FILE: src/xunit.analyzers/Utility/CodeAnalysisExtensions.cs
================================================
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Operations;
namespace Xunit.Analyzers;
static class CodeAnalysisExtensions
{
public static INamedTypeSymbol? FindNamedType(
this IAssemblySymbol assembly,
Func<INamedTypeSymbol, bool> selector)
{
Guard.ArgumentNotNull(assembly);
Guard.ArgumentNotNull(selector);
var visitor = new NamedTypeVisitor(selector);
visitor.Visit(assembly);
return visitor.MatchingType;
}
public static ImmutableArray<AttributeData> GetAttributesWithInheritance(
this IMethodSymbol method,
ITypeSymbol? attributeUsageType)
{
var result = new Dictionary<INamedTypeSymbol, List<AttributeData>>(SymbolEqualityComparer.Default);
foreach (var attribute in method.GetAttributes())
if (attribute.AttributeClass is not null)
result.Add(attribute.AttributeClass, attribute);
if (method.IsOverride && attributeUsageType is not null)
for (var baseMethod = method.OverriddenMethod; baseMethod != null; baseMethod = baseMethod.OverriddenMethod)
foreach (var attribute in baseMethod.GetAttributes())
{
if (attribute.AttributeClass is null || result.ContainsKey(attribute.AttributeClass))
continue;
var inherited = true;
var allowMultiple = false;
var usageAttribute = attribute.AttributeClass.GetAttributes().FirstOrDefault(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, attributeUsageType));
if (usageAttribute is not null)
{
var inheritedNamedArgument =
usageAttribute
.NamedArguments
.FirstOrDefault(n => n.Key == nameof(AttributeUsageAttribute.Inherited));
if (inheritedNamedArgument.Value.Value is not null)
inherited = (bool)inheritedNamedArgument.Value.Value;
var allowMultipleNamedArgument =
usageAttribute
.NamedArguments
.FirstOrDefault(n => n.Key == nameof(AttributeUsageAttribute.AllowMultiple));
if (allowMultipleNamedArgument.Value.Value is not null)
allowMultiple = (bool)allowMultipleNamedArgument.Value.Value;
}
if ((allowMultiple || !result.ContainsKey(attribute.AttributeClass)) && inherited)
result.Add(attribute.AttributeClass, attribute);
}
return result.Values.SelectMany(x => x).ToImmutableArray();
}
public static (bool isInTestMethod, IOperation? lambdaOwner) IsInTestMethod(
this IOperation operation,
XunitContext xunitContext)
{
Guard.ArgumentNotNull(operation);
Guard.ArgumentNotNull(xunitContext);
if (xunitContext.Core.FactAttributeType is null || xunitContext.Core.TheoryAttributeType is null)
return (false, null);
var semanticModel = operation.SemanticModel;
if (semanticModel is null)
return (false, null);
IOperation? lambdaOwner = null;
for (var parent = operation.Parent; parent is not null; parent = parent.Parent)
{
if (parent is IAnonymousFunctionOperation)
{
if (lambdaOwner is null)
{
lambdaOwner = parent;
if (parent.Parent is IDelegateCreationOperation)
for (var target = parent.Parent.Parent; target is not null; target = target.Parent)
if (target is IArgumentOperation && target.Parent is IInvocationOperation invocationOperation)
{
lambdaOwner = invocationOperation;
break;
}
}
continue;
}
if (parent is ILocalFunctionOperation)
{
lambdaOwner = parent;
continue;
}
if (parent is not IMethodBodyOperation methodBodyOperation)
continue;
if (methodBodyOperation.Syntax is not MethodDeclarationSyntax methodSyntax)
continue;
var insideTestMethod = methodSyntax.AttributeLists.SelectMany(list => list.Attributes).Any(attr =>
{
var typeInfo = semanticModel.GetTypeInfo(attr);
if (typeInfo.Type is null)
return false;
return
SymbolEqualityComparer.Default.Equals(typeInfo.Type, xunitContext.Core.FactAttributeType) ||
SymbolEqualityComparer.Default.Equals(typeInfo.Type, xunitContext.Core.TheoryAttributeType);
});
if (!insideTestMethod)
return (false, null);
return (true, lambdaOwner);
}
return (false, null);
}
public static bool IsPointer(
this ExpressionSyntax expression,
SemanticModel? semanticModel) =>
semanticModel?.GetTypeInfo(expression).Type?.TypeKind == TypeKind.Pointer;
public static bool IsTestClass(
this ITypeSymbol? type,
XunitContext xunitContext,
bool strict)
{
Guard.ArgumentNotNull(xunitContext);
if (type is null)
return false;
if (strict)
return IsTestClassStrict(type, xunitContext);
else
return IsTestClassNonStrict(type, xunitContext);
}
static bool IsTestClassNonStrict(
ITypeSymbol type,
XunitContext xunitContext)
{
var factAttributeType = xunitContext.Core.FactAttributeType;
if (factAttributeType is null)
return false;
return
type
.GetMembers()
.OfType<IMethodSymbol>()
.Any(method =>
method
.GetAttributes()
.Select(a => a.AttributeClass)
.Any(t => factAttributeType.IsAssignableFrom(t))
);
}
static bool IsTestClassStrict(
ITypeSymbol type,
XunitContext xunitContext)
{
var factAttributeType = xunitContext.Core.FactAttributeType;
var theoryAttributeType = xunitContext.Core.TheoryAttributeType;
if (factAttributeType is null || theoryAttributeType is null)
return false;
var testMethodAttributes =
new[] { factAttributeType, theoryAttributeType }
.ToImmutableHashSet(SymbolEqualityComparer.Default);
return
type
.GetMembers()
.OfType<IMethodSymbol>()
.Any(method =>
method
.GetAttributes()
.Select(a => a.AttributeClass)
.Any(t => testMethodAttributes.Contains(t, SymbolEqualityComparer.Default))
);
}
public static bool IsTestMethod(
this IMethodSymbol? method,
XunitContext xunitContext,
ITypeSymbol attributeUsageType,
bool strict)
{
Guard.ArgumentNotNull(xunitContext);
if (method is null)
return false;
var factAttributeType = xunitContext.Core.FactAttributeType;
var theoryAttributeType = xunitContext.Core.TheoryAttributeType;
if (factAttributeType is null || theoryAttributeType is null)
return false;
var attributes = method.GetAttributesWithInheritance(attributeUsageType);
var comparer = SymbolEqualityComparer.Default;
return
strict
? attributes.Any(a => comparer.Equals(a.AttributeClass, factAttributeType) || comparer.Equals(a.AttributeClass, theoryAttributeType))
: attributes.Any(a => factAttributeType.IsAssignableFrom(a.AttributeClass));
}
public static IOperation WalkDownImplicitConversions(this IOperation operation)
{
Guard.ArgumentNotNull(operation);
var current = operation;
while (current is IConversionOperation conversion && conversion.Conversion.IsImplicit)
current = conversion.Operand;
return current;
}
sealed class NamedTypeVisitor(Func<INamedTypeSymbol, bool> selector) :
SymbolVisitor
{
readonly Func<INamedTypeSymbol, bool> selector = Guard.ArgumentNotNull(selector);
public INamedTypeSymbol? MatchingType { get; private set; }
public override void VisitAssembly(IAssemblySymbol symbol) =>
Guard.ArgumentNotNull(symbol).GlobalNamespace.Accept(this);
public override void VisitNamespace(INamespaceSymbol symbol)
{
Guard.ArgumentNotNull(symbol);
if (MatchingType is not null)
return;
foreach (var member in symbol.GetMembers())
member.Accept(this);
}
public override void VisitNamedType(INamedTypeSymbol symbol)
{
Guard.ArgumentNotNull(symbol);
if (MatchingType is not null)
return;
if (selector(symbol))
{
MatchingType = symbol;
return;
}
foreach (var nestedType in symbol.GetTypeMembers())
nestedType.Accept(this);
}
}
}
================================================
FILE: src/xunit.analyzers/Utility/Constants.cs
================================================
namespace Xunit.Analyzers;
public static class Constants
{
/// <summary>
/// Argument names for Assert methods
/// </summary>
public static class AssertArguments
{
public const string Actual = "actual";
public const string Expected = "expected";
public const string IgnoreCase = "ignoreCase";
}
/// <summary>
/// Method names from Assert
/// </summary>
public static class Asserts
{
public const string All = nameof(All);
public const string AllAsync = nameof(AllAsync);
public const string Collection = nameof(Collection);
public const string CollectionAsync = nameof(CollectionAsync);
public const string Contains = nameof(Contains);
public const string Distinct = nameof(Distinct);
public const string DoesNotContain = nameof(DoesNotContain);
public const string DoesNotMatch = nameof(DoesNotMatch);
public const string Empty = nameof(Empty);
public const string EndsWith = nameof(EndsWith);
public const string Equal = nameof(Equal);
public const string Equivalent = nameof(Equivalent);
public const string Fail = nameof(Fail);
public const string False = nameof(False);
public const string InRange = nameof(InRange);
public const string IsAssignableFrom = nameof(IsAssignableFrom);
public const string IsNotAssignableFrom = nameof(IsNotAssignableFrom);
public const string IsNotType = nameof(IsNotType);
public const string IsType = nameof(IsType);
public const string Matches = nameof(Matches);
public const string Multiple = nameof(Multiple);
public const string NotEmpty = nameof(NotEmpty);
public const string NotEqual = nameof(NotEqual);
public const string NotInRange = nameof(NotInRange);
public const string NotNull = nameof(NotNull);
public const string NotSame = nameof(NotSame);
public const string NotStrictEqual = nameof(NotStrictEqual);
public const string Null = nameof(Null);
public const string ProperSubset = nameof(ProperSubset);
public const string ProperSuperset = nameof(ProperSuperset);
public const string PropertyChanged = nameof(PropertyChanged);
public const string PropertyChangedAsync = nameof(PropertyChangedAsync);
public const string Raises = nameof(Raises);
public const string RaisesAny = nameof(RaisesAny);
public const string RaisesAnyAsync = nameof(RaisesAnyAsync);
public const string RaisesAsync = nameof(RaisesAsync);
public const string Same = nameof(Same);
public const string Single = nameof(Single);
public const string StartsWith = nameof(StartsWith);
public const string StrictEqual = nameof(StrictEqual);
public const string Subset = nameof(Subset);
public const string Superset = nameof(Superset);
public const string Throws = nameof(Throws);
public const string ThrowsAny = nameof(ThrowsAny);
public const string ThrowsAnyAsync = nameof(ThrowsAnyAsync);
public const string ThrowsAsync = nameof(ThrowsAsync);
public const string True = nameof(True);
}
/// <summary>
/// Attribute names (without the Attribute suffix unless otherwise noted)
/// </summary>
public static class Attributes
{
public const string Fact = nameof(Fact);
public const string Theory = nameof(Theory);
}
/// <summary>
/// Property names from xUnit.net attributes
/// </summary>
public static class AttributeProperties
{
public const string DeclaringType = nameof(DeclaringType);
public const string MemberName = nameof(MemberName);
public const string MemberType = nameof(MemberType);
}
/// <summary>
/// Properties placed into diagnostics to be picked up by fixes
/// </summary>
public static class Properties
{
public const string ArgumentValue = nameof(ArgumentValue);
public const string AssertMethodName = nameof(AssertMethodName);
public const string DataAttributeTypeName = nameof(DataAttributeTypeName);
public const string DeclaringType = nameof(DeclaringType);
public const string IgnoreCase = nameof(IgnoreCase);
public const string IsCtorObsolete = nameof(IsCtorObsolete);
public const string IsStatic = nameof(IsStatic);
public const string IsStaticMethodCall = nameof(IsStaticMethodCall);
public const string LiteralValue = nameof(LiteralValue);
public const string MemberName = nameof(MemberName);
public const string MethodName = nameof(MethodName);
public const string NewBaseType = nameof(NewBaseType);
public const string ParameterArrayStyle = nameof(ParameterArrayStyle);
public const string ParameterIndex = nameof(ParameterIndex);
public const string ParameterName = nameof(ParameterName);
public const string ParameterSpecialType = nameof(ParameterSpecialType);
public const string Replacement = nameof(Replacement);
public const string SizeValue = nameof(SizeValue);
public const string SubstringMethodName = nameof(SubstringMethodName);
public const string TestClassName = nameof(TestClassName);
public const string TFixtureDisplayName = nameof(TFixtureDisplayName);
public const string TFixtureName = nameof(TFixtureName);
public const string TypeName = nameof(TypeName);
public const string UseExactMatch = nameof(UseExactMatch);
}
/// <summary>
/// Type names as strings for runtime lookup
/// </summary>
public static class Types
{
public static class System
{
public const string ObsoleteAttribute = "System.ObsoleteAttribute";
}
public static class Xunit
{
public const string AssemblyFixtureAttribute_V3 = "Xunit.AssemblyFixtureAttribute";
public const string Assert = "Xunit.Assert";
public const string ClassDataAttribute = "Xunit.ClassDataAttribute";
public const string ClassDataAttributeOfT_V3 = "Xunit.ClassDataAttribute`1";
public const string CollectionAttribute = "Xunit.CollectionAttribute";
public const string CollectionAttributeOfT_V3 = "Xunit.CollectionAttribute`1";
public const string CollectionDefinitionAttribute = "Xunit.CollectionDefinitionAttribute";
public const string DataAttribute_V2 = "Xunit.Sdk.DataAttribute";
public const string DataAttribute_V3 = "Xunit.v3.DataAttribute";
public const string FactAttribute = "Xunit.FactAttribute";
public const string IAssemblyInfo_V2 = "Xunit.Abstractions.IAssemblyInfo";
public const string IAsyncLifetime = "Xunit.IAsyncLifetime";
public const string IAttributeInfo_V2 = "Xunit.Abstractions.IAttributeInfo";
public const string IClassFixtureOfT = "Xunit.IClassFixture`1";
public const string ICollectionFixtureOfT = "Xunit.ICollectionFixture`1";
public const string IDataAttribute_V3 = "Xunit.v3.IDataAttribute";
public const string IMessageSink_V2 = "Xunit.Abstractions.IMessageSink";
public const string IMessageSink_V3 = "Xunit.Sdk.IMessageSink";
public const string IMessageSinkMessage_V2 = "Xunit.Abstractions.IMessageSinkMessage";
public const string IMethodInfo_V2 = "Xunit.Abstractions.IMethodInfo";
public const string IParameterInfo_V2 = "Xunit.Abstractions.IParameterInfo";
public const string InlineDataAttribute = "Xunit.InlineDataAttribute";
public const string IRunnerReporter_V3 = "Xunit.Runner.Common.IRunnerReporter";
public const string ISourceInformation_V2 = "Xunit.Abstractions.ISourceInformation";
public const string ISourceInformationProvider_V2 = "Xunit.Abstractions.ISourceInformationProvider";
public const string ISourceInformationProvider_V3 = "Xunit.Runner.Common.ISourceInformationProvider";
public const string ITest_V2 = "Xunit.Abstractions.ITest";
public const string ITest_V3 = "Xunit.Sdk.ITest";
public const string ITestAssembly_V2 = "Xunit.Abstractions.ITestAssembly";
public const string ITestAssembly_V3 = "Xunit.Sdk.ITestAssembly";
public const string ITestCase_V2 = "Xunit.Abstractions.ITestCase";
public const string ITestCase_V3 = "Xunit.Sdk.ITestCase";
public const string ITestClass_V2 = "Xunit.Abstractions.ITestClass";
public const string ITestClass_V3 = "Xunit.Sdk.ITestClass";
public const string ITestCollection_V2 = "Xunit.Abstractions.ITestCollection";
public const string ITestCollection_V3 = "Xunit.Sdk.ITestCollection";
public const string ITestContextAccessor_V3 = "Xunit.ITestContextAccessor";
public const string ITestFramework_V2 = "Xunit.Abstractions.ITestFramework";
public const string ITestFramework_V3 = "Xunit.v3.ITestFramework";
public const string ITestFrameworkDiscoverer_V2 = "Xunit.Abstractions.ITestFrameworkDiscoverer";
public const string ITestFrameworkDiscoverer_V3 = "Xunit.v3.ITestFrameworkDiscoverer";
public const string ITestFrameworkExecutor_V2 = "Xunit.Abstractions.ITestFrameworkExecutor";
public const string ITestFrameworkExecutor_V3 = "Xunit.v3.ITestFrameworkExecutor";
public const string ITestMethod_V2 = "Xunit.Abstractions.ITestMethod";
public const string ITestMethod_V3 = "Xunit.Sdk.ITestMethod";
public const string ITestOutputHelper_V2 = "Xunit.Abstractions.ITestOutputHelper";
public const string ITestOutputHelper_V3 = "Xunit.ITestOutputHelper";
public const string ITheoryDataRow_V3 = "Xunit.ITheoryDataRow";
public const string ITypeInfo_V2 = "Xunit.Abstractions.ITypeInfo";
public const string IXunitSerializable_V2 = "Xunit.Abstractions.IXunitSerializable";
public const string IXunitSerializable_V3 = "Xunit.Sdk.IXunitSerializable";
public const string IXunitSerializer_V3 = "Xunit.Sdk.IXunitSerializer";
public const string JsonTypeIDAttribute_V3 = "Xunit.Sdk.JsonTypeIDAttribute";
public const string LongLivedMarshalByRefObject_Execution_V2 = "Xunit.LongLivedMarshalByRefObject";
public const string LongLivedMarshalByRefObject_RunnerUtility = "Xunit.Sdk.LongLivedMarshalByRefObject";
public const string MemberDataAttribute = "Xunit.MemberDataAttribute";
public const string Record = "Xunit.Record";
public const string RegisterXunitSerializerAttribute_V3 = "Xunit.Sdk.RegisterXunitSerializerAttribute";
public const string TestContext_V3 = "Xunit.TestContext";
public const string TheoryAttribute = "Xunit.TheoryAttribute";
public const string TheoryData = "Xunit.TheoryData";
public const string TheoryDataRow_V3 = "Xunit.TheoryDataRow";
}
}
}
================================================
FILE: src/xunit.analyzers/Utility/ConversionChecker.cs
================================================
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
namespace Xunit.Analyzers;
static class ConversionChecker
{
static readonly HashSet<SpecialType> SignedIntegralTypes = [
SpecialType.System_SByte,
SpecialType.System_Int16,
SpecialType.System_Int32,
SpecialType.System_Int64,
];
static readonly HashSet<SpecialType> UnsignedIntegralTypes = [
SpecialType.System_Byte,
SpecialType.System_UInt16,
SpecialType.System_UInt32,
SpecialType.System_UInt64,
];
public static bool IsConvertible(
Compilation compilation,
ITypeSymbol source,
ITypeSymbol destination,
XunitContext xunitContext,
object? valueSource = null)
{
Guard.ArgumentNotNull(compilation);
Guard.ArgumentNotNull(source);
Guard.ArgumentNotNull(destination);
Guard.ArgumentNotNull(xunitContext);
if (destination.TypeKind == TypeKind.Array)
{
var destinationElementType = ((IArrayTypeSymbol)destination).ElementType;
if (destinationElementType.TypeKind == TypeKind.TypeParameter)
return IsConvertibleTypeParameter(source, (ITypeParameterSymbol)destinationElementType);
}
if (destination.TypeKind == TypeKind.TypeParameter)
return IsConvertibleTypeParameter(source, (ITypeParameterSymbol)destination);
var conversion = compilation.ClassifyConversion(source, destination);
if (conversion.IsNumeric)
return IsConvertibleNumeric(source, destination, valueSource);
if (destination.SpecialType == SpecialType.System_DateTime
|| (xunitContext.Core.TheorySupportsConversionFromStringToDateTimeOffsetAndGuid && IsDateTimeOffsetOrGuid(destination)))
{
// Allow all conversions from strings. All parsing issues will be reported at runtime.
return source.SpecialType == SpecialType.System_String;
}
// Rules of last resort
return conversion.IsImplicit
|| conversion.IsUnboxing
|| (conversion.IsExplicit && conversion.IsUserDefined)
|| (conversion.IsExplicit && conversion.IsNullable);
}
static bool IsConvertibleTypeParameter(
ITypeSymbol source,
ITypeParameterSymbol destination)
{
if (destination.HasValueTypeConstraint && !source.IsValueType)
return false;
if (destination.HasReferenceTypeConstraint && source.IsValueType)
return false;
return destination.ConstraintTypes.All(c => c.IsAssignableFrom(source));
}
static bool IsConvertibleNumeric(
ITypeSymbol source,
ITypeSymbol destination,
object? valueSource = null)
{
var isIntegral = long.TryParse(valueSource?.ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var integralValue);
if (isIntegral && integralValue < 0 && IsSigned(source) && IsUnsigned(destination))
return false;
if (destination.SpecialType == SpecialType.System_Char
&& (source.SpecialType == SpecialType.System_Double || source.SpecialType == SpecialType.System_Single))
{
// Conversions from float to char (though numeric) do not actually work at runtime, so report them
return false;
}
return true; // Allow all numeric conversions. Narrowing conversion issues will be reported at runtime.
}
static bool IsDateTimeOffsetOrGuid(ITypeSymbol destination)
{
if (destination.ContainingNamespace?.Name != nameof(System))
return false;
return destination.MetadataName is (nameof(DateTimeOffset)) or (nameof(Guid));
}
static bool IsSigned(ITypeSymbol typeSymbol) =>
SignedIntegralTypes.Contains(typeSymbol.SpecialType);
static bool IsUnsigned(ITypeSymbol typeSymbol) =>
UnsignedIntegralTypes.Contains(typeSymbol.SpecialType);
}
================================================
FILE: src/xunit.analyzers/Utility/Descriptors.Suppressors.cs
================================================
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public static partial class Descriptors
{
public static SuppressionDescriptor CA1515_Suppression { get; } =
Suppression("CA1515", "xUnit.net's test classes must be public.");
public static SuppressionDescriptor CA2007_Suppression { get; } =
Suppression("CA2007", "xUnit.net test methods should not call ConfigureAwait");
public static SuppressionDescriptor CS8618_Suppression { get; } =
Suppression("CS8618", "Non-nullable member is initialized in IAsyncLifetime.InitializeAsync");
public static SuppressionDescriptor VSTHRD200_Suppression { get; } =
Suppression("VSTHRD200", "xUnit.net test methods are not directly callable and do not benefit from this naming rule");
}
================================================
FILE: src/xunit.analyzers/Utility/Descriptors.cs
================================================
using System.Collections.Concurrent;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public static partial class Descriptors
{
static readonly ConcurrentDictionary<Category, string> categoryMapping = new();
static DiagnosticDescriptor Diagnostic(
string id,
string title,
Category category,
DiagnosticSeverity defaultSeverity,
string messageFormat)
{
var helpLink = $"https://xunit.net/xunit.analyzers/rules/{id}";
var categoryString = categoryMapping.GetOrAdd(category, c => c.ToString());
return new DiagnosticDescriptor(id, title, messageFormat, categoryString, defaultSeverity, isEnabledByDefault: true, helpLinkUri: helpLink);
}
static SuppressionDescriptor Suppression(
string suppressedDiagnosticId,
string justification) =>
new("xUnitSuppress-" + suppressedDiagnosticId, suppressedDiagnosticId, justification);
}
================================================
FILE: src/xunit.analyzers/Utility/Descriptors.xUnit1xxx.cs
================================================
using Microsoft.CodeAnalysis;
using static Microsoft.CodeAnalysis.DiagnosticSeverity;
using static Xunit.Analyzers.Category;
namespace Xunit.Analyzers;
public static partial class Descriptors
{
public static DiagnosticDescriptor X1000_TestClassMustBePublic { get; } =
Diagnostic(
"xUnit1000",
"Test classes must be public",
Usage,
Error,
"Test classes must be public. Add or change the visibility modifier of the test class to public."
);
public static DiagnosticDescriptor X1001_FactMethodMustNotHaveParameters { get; } =
Diagnostic(
"xUnit1001",
"Fact methods cannot have parameters",
Usage,
Error,
"Fact methods cannot have parameters. Remove the parameters from the method or convert it into a Theory."
);
public static DiagnosticDescriptor X1002_TestMethodMustNotHaveMultipleFactAttributes { get; } =
Diagnostic(
"xUnit1002",
"Test methods cannot have multiple Fact or Theory attributes",
Usage,
Error,
"Test methods cannot have multiple Fact or Theory attributes. Remove all but one of the attributes."
);
public static DiagnosticDescriptor X1003_TheoryMethodMustHaveTestData { get; } =
Diagnostic(
"xUnit1003",
"Theory methods must have test data",
Usage,
Error,
"Theory methods must have test data. Use InlineData, MemberData, or ClassData to provide test data for the Theory."
);
public static DiagnosticDescriptor X1004_TestMethodShouldNotBeSkipped { get; } =
Diagnostic(
"xUnit1004",
"Test methods should not be skipped",
Usage,
Info,
"Test methods should not be skipped. Remove the Skip property to start running the test again."
);
public static DiagnosticDescriptor X1005_FactMethodShouldNotHaveTestData { get; } =
Diagnostic(
"xUnit1005",
"Fact methods should not have test data",
Usage,
Warning,
"Fact methods should not have test data. Remove the test data, or convert the Fact to a Theory."
);
public static DiagnosticDescriptor X1006_TheoryMethodShouldHaveParameters { get; } =
Diagnostic(
"xUnit1006",
"Theory methods should have parameters",
Usage,
Warning,
"Theory methods should have parameters. Add parameter(s) to the theory method."
);
public static DiagnosticDescriptor X1007_ClassDataAttributeMustPointAtValidClass { get; } =
Diagnostic(
"xUnit1007",
"ClassData must point at a valid class",
Usage,
Error,
"ClassData must point at a valid class. The class {0} must be public, not sealed, with an empty constructor, and implement {1}."
);
public static DiagnosticDescriptor X1008_DataAttributeShouldBeUsedOnATheory { get; } =
Diagnostic(
"xUnit1008",
"Test data attribute should only be used on a Theory",
Usage,
Warning,
"Test data attribute should only be used on a Theory. Remove the test data, or add the Theory attribute to the test method."
);
public static DiagnosticDescriptor X1009_InlineDataMustMatchTheoryParameters_TooFewValues { get; } =
Diagnostic(
"xUnit1009",
"InlineData values must match the number of method parameters",
Usage,
Error,
"InlineData values must match the number of method parameters. Remove unused parameters, or add more data for the missing parameters."
);
public static DiagnosticDescriptor X1010_InlineDataMustMatchTheoryParameters_IncompatibleValueType { get; } =
Diagnostic(
"xUnit1010",
"The value is not convertible to the method parameter type",
Usage,
Error,
"The value is not convertible to the method parameter '{0}' of type '{1}'. Use a compatible data value."
);
public static DiagnosticDescriptor X1011_InlineDataMustMatchTheoryParameters_ExtraValue { get; } =
Diagnostic(
"xUnit1011",
"There is no matching method parameter",
Usage,
Error,
"There is no matching method parameter for value: {0}. Remove unused value(s), or add more parameter(s)."
);
public static DiagnosticDescriptor X1012_InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForIncompatibleParameter { get; } =
Diagnostic(
"xUnit1012",
"Null should only be used for nullable parameters",
Usage,
Warning,
"Null should not be used for type parameter '{0}' of type '{1}'. Use a non-null value, or convert the parameter to a nullable type."
);
public static DiagnosticDescriptor X1013_PublicMethodShouldBeMarkedAsTest { get; } =
Diagnostic(
"xUnit1013",
"Public method should be marked as test",
Usage,
Warning,
"Public method '{0}' on test class '{1}' should be marked as a {2}. Reduce the visibility of the method, or add a {2} attribute to the method."
);
public static DiagnosticDescriptor X1014_MemberDataShouldUseNameOfOperator { get; } =
Diagnostic(
"xUnit1014",
"MemberData should use nameof operator for member name",
Usage,
Warning,
"MemberData should use nameof operator to reference member '{0}' on type '{1}'. Replace the constant string with nameof."
);
public static DiagnosticDescriptor X1015_MemberDataMustReferenceExistingMember { get; } =
Diagnostic(
"xUnit1015",
"MemberData must reference an existing member",
Usage,
Error,
"MemberData must reference an existing member '{0}' on type '{1}'. Fix the member reference, or add the missing data member."
);
public static DiagnosticDescriptor X1016_MemberDataMustReferencePublicMember { get; } =
Diagnostic(
"xUnit1016",
"MemberData must reference a public member",
Usage,
Error,
"MemberData must reference a public member. Add or change the visibility of the data member to public."
);
public static DiagnosticDescriptor X1017_MemberDataMustReferenceStaticMember { get; } =
Diagnostic(
"xUnit1017",
"MemberData must reference a static member",
Usage,
Error,
"MemberData must reference a static member. Add the static modifier to the data member."
);
public static DiagnosticDescriptor X1018_MemberDataMustReferenceValidMemberKind { get; } =
Diagnostic(
"xUnit1018",
"MemberData must reference a valid member kind",
Usage,
Error,
"MemberData must reference a property, field, or method. Convert the data member to a compatible member type."
);
public static DiagnosticDescriptor X1019_MemberDataMustReferenceMemberOfValidType { get; } =
Diagnostic(
"xUnit1019",
"MemberData must reference a member providing a valid data type",
Usage,
Error,
"MemberData must reference a data type assignable to {0}. The referenced type '{1}' is not valid."
);
public static DiagnosticDescriptor X1020_MemberDataPropertyMustHaveGetter { get; } =
Diagnostic(
"xUnit1020",
"MemberData must reference a property with a public getter",
Usage,
Error,
"MemberData must reference a property with a public getter. Add a public getter to the data member, or change the visibility of the existing getter to public."
);
public static DiagnosticDescriptor X1021_MemberDataNonMethodShouldNotHaveParameters { get; } =
Diagnostic(
"xUnit1021",
"MemberData should not have parameters if the referenced member is not a method",
Usage,
Warning,
"MemberData should not have parameters if the referenced member is not a method. Remove the parameter values, or convert the data member to a method with parameters."
);
public static DiagnosticDescriptor X1022_TheoryMethodCannotHaveParameterArray { get; } =
Diagnostic(
"xUnit1022",
"Theory methods cannot have a parameter array",
Usage,
Error,
"Theory method '{0}' on test class '{1}' cannot have a parameter array '{2}'. Upgrade to xUnit.net 2.2 or later to enable this feature."
);
public static DiagnosticDescriptor X1023_TheoryMethodCannotHaveDefaultParameter { get; } =
Diagnostic(
"xUnit1023",
"Theory methods cannot have default parameter values",
Usage,
Error,
"Theory method '{0}' on test class '{1}' parameter '{2}' cannot have a default value. Upgrade to xUnit.net 2.2 or later to enable this feature."
);
public static DiagnosticDescriptor X1024_TestMethodCannotHaveOverloads { get; } =
Diagnostic(
"xUnit1024",
"Test methods cannot have overloads",
Usage,
Error,
"Test method '{0}' on test class '{1}' has the same name as another method declared on class '{2}'. Rename method(s) so that there are no overloaded names."
);
public static DiagnosticDescriptor X1025_InlineDataShouldBeUniqueWithinTheory { get; } =
Diagnostic(
"xUnit1025",
"InlineData should be unique within the Theory it belongs to",
Usage,
Warning,
"Theory method '{0}' on test class '{1}' has InlineData duplicate(s). Remove redundant attribute(s) from the theory method."
);
public static DiagnosticDescriptor X1026_TheoryMethodShouldUseAllParameters { get; } =
Diagnostic(
"xUnit1026",
"Theory methods should use all of their parameters",
Usage,
Warning,
"Theory method '{0}' on test class '{1}' does not use parameter '{2}'. Use the parameter, or remove the parameter and associated data."
);
public static DiagnosticDescriptor X1027_CollectionDefinitionClassMustBePublic { get; } =
Diagnostic(
"xUnit1027",
"Collection definition classes must be public",
Usage,
Error,
"Collection definition classes must be public. Add or change the visibility modifier of the collection definition class to public."
);
public static DiagnosticDescriptor X1028_TestMethodHasInvalidReturnType { get; } =
Diagnostic(
"xUnit1028",
"Test method must have valid return type",
Usage,
Error,
"Test methods must have a supported return type. Valid types are: {0}. Change the return type to one of the compatible types."
);
public static DiagnosticDescriptor X1029_LocalFunctionsCannotBeTestFunctions { get; } =
Diagnostic(
"xUnit1029",
"Local functions cannot be test functions",
Usage,
Error,
"Local functions cannot be test functions. Remove '{0}'."
);
public static DiagnosticDescriptor X1030_DoNotUseConfigureAwait { get; } =
Diagnostic(
"xUnit1030",
"Do not call ConfigureAwait(false) in test method",
Usage,
Warning,
"Test methods should not call ConfigureAwait({0}), as it may bypass parallelization limits. {1}"
);
public static DiagnosticDescriptor X1031_DoNotUseBlockingTaskOperations { get; } =
Diagnostic(
"xUnit1031",
"Do not use blocking task operations in test method",
Usage,
Warning,
"Test methods should not use blocking task operations, as they can cause deadlocks. Use an async test method and await instead."
);
public static DiagnosticDescriptor X1032_TestClassCannotBeNestedInGenericClass { get; } =
Diagnostic(
"xUnit1032",
"Test classes cannot be nested within a generic class",
Usage,
Error,
"Test classes cannot be nested within a generic class. Move the test class out of the class it is nested in."
);
public static DiagnosticDescriptor X1033_TestClassShouldHaveTFixtureArgument { get; } =
Diagnostic(
"xUnit1033",
"Test classes decorated with 'Xunit.IClassFixture<TFixture>' or 'Xunit.ICollectionFixture<TFixture>' should add a constructor argument of type TFixture",
Usage,
Info,
"Test class '{0}' does not contain constructor argument of type '{1}'. Add a constructor argument to consume the fixture data."
);
public static DiagnosticDescriptor X1034_MemberDataArgumentsMustMatchMethodParameters_NullShouldNotBeUsedForIncompatibleParameter { get; } =
Diagnostic(
"xUnit1034",
"Null should only be used for nullable parameters",
Usage,
Warning,
"Null should not be used for type parameter '{0}' of type '{1}'. Use a non-null value, or convert the parameter to a nullable type."
);
public static DiagnosticDescriptor X1035_MemberDataArgumentsMustMatchMethodParameters_IncompatibleValueType { get; } =
Diagnostic(
"xUnit1035",
"The value is not convertible to the method parameter type",
Usage,
Error,
"The value is not convertible to the method parameter '{0}' of type '{1}'. Use a compatible data value."
);
public static DiagnosticDescriptor X1036_MemberDataArgumentsMustMatchMethodParameters_ExtraValue { get; } =
Diagnostic(
"xUnit1036",
"There is no matching method parameter",
Usage,
Error,
"There is no matching method parameter for value: {0}. Remove unused value(s), or add more parameter(s)."
);
public static DiagnosticDescriptor X1037_TheoryDataTypeArgumentsMustMatchTestMethodParameters_TooFewTypeParameters { get; } =
Diagnostic(
"xUnit1037",
"There are fewer theory data type arguments than required by the parameters of the test method",
Usage,
Error,
"There are fewer {0} type arguments than required by the parameters of the test method. Add more type parameters to match the method signature, or remove parameters from the test method."
);
public static DiagnosticDescriptor X1038_TheoryDataTypeArgumentsMustMatchTestMethodParameters_ExtraTypeParameters { get; } =
Diagnostic(
"xUnit1038",
"There are more theory data type arguments than allowed by the parameters of the test method",
Usage,
Error,
"There are more {0} type arguments than allowed by the parameters of the test method. Remove unused type arguments, or add more parameters."
);
public static DiagnosticDescriptor X1039_TheoryDataTypeArgumentsMustMatchTestMethodParameters_IncompatibleTypes { get; } =
Diagnostic(
"xUnit1039",
"The type argument to theory data is not compatible with the type of the corresponding test method parameter",
Usage,
Error,
"The type argument {0} from {1} is not compatible with the type of the corresponding test method parameter {2}."
);
public static DiagnosticDescriptor X1040_TheoryDataTypeArgumentsMustMatchTestMethodParameters_IncompatibleNullability { get; } =
Diagnostic(
"xUnit1040",
"The type argument to theory data is nullable, while the type of the corresponding test method parameter is not",
Usage,
Warning,
"The type argument {0} from {1} is nullable, while the type of the corresponding test method parameter {2} is not. Make the theory data type non-nullable, or make the test method parameter nullable."
);
public static DiagnosticDescriptor X1041_EnsureFixturesHaveASource { get; } =
Diagnostic(
"xUnit1041",
"Fixture arguments to test classes must have fixture sources",
Usage,
Warning,
"Fixture argument '{0}' does not have a fixture source (if it comes from a collection definition, ensure the definition is in the same assembly as the test)"
);
public static DiagnosticDescriptor X1042_MemberDataTheoryDataIsRecommendedForStronglyTypedAnalysis { get; } =
Diagnostic(
"xUnit1042",
"The member referenced by the MemberData attribute returns untyped data rows",
Usage,
Info,
"The member referenced by the MemberData attribute returns untyped data rows, such as object[]. Consider using {0} as the return type to provide better type safety."
);
public static DiagnosticDescriptor X1043_ConstructorOnFactAttributeSubclassShouldBePublic { get; } =
Diagnostic(
"xUnit1043",
"Constructors on classes derived from FactAttribute must be public when used on test methods",
Usage,
Error,
"Constructor '{0}' must be public to be used on a test method."
);
public static DiagnosticDescriptor X1044_AvoidUsingTheoryDataTypeArgumentsThatAreNotSerializable { get; } =
Diagnostic(
"xUnit1044",
"Avoid using TheoryData type arguments that are not serializable",
Usage,
Info,
"The type argument {0} is not serializable, which will cause Test Explorer to not enumerate individual data rows. Consider using a type that is known to be serializable."
);
public static DiagnosticDescriptor X1045_AvoidUsingTheoryDataTypeArgumentsThatMightNotBeSerializable { get; } =
Diagnostic(
"xUnit1045",
"Avoid using TheoryData type arguments that might not be serializable",
Usage,
Info,
"The type argument {0} might not be serializable, which may cause Test Explorer to not enumerate individual data rows. Consider using a type that is known to be serializable."
);
public static DiagnosticDescriptor X1046_AvoidUsingTheoryDataRowArgumentsThatAreNotSerializable { get; } =
Diagnostic(
"xUnit1046",
"Avoid using TheoryDataRow arguments that are not serializable",
Usage,
Info,
"The argument '{0}' of type '{1}' is not serializable, which will cause Test Explorer to not enumerate individual data rows. Consider using a value that is known to be serializable."
);
public static DiagnosticDescriptor X1047_AvoidUsingTheoryDataRowArgumentsThatMightNotBeSerializable { get; } =
Diagnostic(
"xUnit1047",
"Avoid using TheoryDataRow arguments that might not be serializable",
Usage,
Info,
"The argument '{0}' of type '{1}' might not be serializable, which may cause Test Explorer to not enumerate individual data rows. Consider using a value that is known to be serializable."
);
public static DiagnosticDescriptor X1048_DoNotUseAsyncVoidForTestMethods_V2 { get; } =
Diagnostic(
"xUnit1048",
"Avoid using 'async void' for test methods as it is deprecated in xUnit.net v3",
Usage,
Warning,
"Support for 'async void' unit tests is being removed from xUnit.net v3. To simplify upgrading, convert the test to 'async Task' instead."
);
public static DiagnosticDescriptor X1049_DoNotUseAsyncVoidForTestMethods_V3 { get; } =
Diagnostic(
"xUnit1049",
"Do not use 'async void' for test methods as it is no longer supported",
Usage,
Error,
"Support for 'async void' unit tests has been removed from xUnit.net v3. Convert the test to 'async Task' or 'async ValueTask' instead."
);
public static DiagnosticDescriptor X1050_ClassDataTheoryDataRowIsRecommendedForStronglyTypedAnalysis { get; } =
Diagnostic(
"xUnit1050",
"The class referenced by the ClassData attribute returns untyped data rows",
Usage,
Info,
"The class referenced by the ClassData attribute returns untyped data rows, such as object[] or ITheoryDataRow. Consider using generic TheoryDataRow<> as the row type to provide better type safety."
);
public static DiagnosticDescriptor X1051_UseCancellationToken { get; } =
Diagnostic(
"xUnit1051",
"Calls to methods which accept CancellationToken should use TestContext.Current.CancellationToken",
Usage,
Warning,
"Calls to methods which accept CancellationToken should use TestContext.Current.CancellationToken to allow test cancellation to be more responsive."
);
public static DiagnosticDescriptor X1052_TheoryDataShouldNotUseITheoryDataRow { get; } =
Diagnostic(
"xUnit1052",
"Avoid using 'TheoryData<...>' with types that implement 'ITheoryDataRow'.",
Usage,
Warning,
"'TheoryData<...>' should not be used with one or more type arguments that implement 'ITheoryDataRow' or a derived variant. This usage is not supported. Use either 'TheoryData' or a type of 'ITheoryDataRow' exclusively."
);
public static DiagnosticDescriptor X1053_MemberDataMemberMustBeStaticallyWrittenTo { get; } =
Diagnostic(
"xUnit1053",
"The static member used as theory data must be statically initialized.",
Usage,
Warning,
"The member {0} referenced by MemberData is not initialized before use. Add an inline initializer or initialize the value in the static constructor."
);
// Placeholder for rule X1054
// Placeholder for rule X1055
// Placeholder for rule X1056
// Placeholder for rule X1057
// Placeholder for rule X1058
// Placeholder for rule X1059
// Placeholder for rule X1060
}
================================================
FILE: src/xunit.analyzers/Utility/Descriptors.xUnit2xxx.cs
================================================
using Microsoft.CodeAnalysis;
using static Microsoft.CodeAnalysis.DiagnosticSeverity;
using static Xunit.Analyzers.Category;
namespace Xunit.Analyzers;
public static partial class Descriptors
{
public static DiagnosticDescriptor X2000_AssertEqualLiteralValueShouldBeFirst { get; } =
Diagnostic(
"xUnit2000",
"Constants and literals should be the expected argument",
Assertions,
Warning,
"The literal or constant value {0} should be passed as the 'expected' argument in the call to '{1}' in method '{2}' on type '{3}'. Swap the parameter values."
);
public static DiagnosticDescriptor X2001_AssertEqualsShouldNotBeUsed { get; } =
Diagnostic(
"xUnit2001",
"Do not use invalid equality check",
Assertions,
Hidden,
"Do not use {0}. Use Assert.{1} instead."
);
public static DiagnosticDescriptor X2002_AssertNullShouldNotBeCalledOnValueTypes { get; } =
Diagnostic(
"xUnit2002",
"Do not use null check on value type",
Assertions,
Warning,
"Do not use {0} on value type '{1}'. Remove this assert."
);
public static DiagnosticDescriptor X2003_AssertEqualShouldNotUsedForNullCheck { get; } =
Diagnostic(
"xUnit2003",
"Do not use equality check to test for null value",
Assertions,
Warning,
"Do not use {0} to check for null value. Use Assert.{1} instead."
);
public static DiagnosticDescriptor X2004_AssertEqualShouldNotUsedForBoolLiteralCheck { get; } =
Diagnostic(
"xUnit2004",
"Do not use equality check to test for boolean conditions",
Assertions,
Warning,
"Do not use {0} to check for boolean conditions. Use Assert.{1} instead."
);
public static DiagnosticDescriptor X2005_AssertSameShouldNotBeCalledOnValueTypes { get; } =
Diagnostic(
"xUnit2005",
"Do not use identity check on value type",
Assertions,
Warning,
"Do not use {0} on value type '{1}'. Value types do not have identity. Use Assert.{2} instead."
);
public static DiagnosticDescriptor X2006_AssertEqualGenericShouldNotBeUsedForStringValue { get; } =
Diagnostic(
"xUnit2006",
"Do not use invalid string equality check",
Assertions,
Warning,
"Do not use {0} to test for string equality. Use {1} instead."
);
public static DiagnosticDescriptor X2007_AssertIsTypeShouldUseGenericOverload { get; } =
Diagnostic(
"xUnit2007",
"Do not use typeof expression to check the type",
Assertions,
Warning,
"Do not use typeof({0}) expression to check the type. Use Assert.IsType<{0}> instead."
);
public static DiagnosticDescriptor X2008_AssertRegexMatchShouldNotUseBoolLiteralCheck { get; } =
Diagnostic(
"xUnit2008",
"Do not use boolean check to match on regular expressions",
Assertions,
Warning,
"Do not use {0} to match on regular expressions. Use Assert.{1} instead."
);
public static DiagnosticDescriptor X2009_AssertSubstringCheckShouldNotUseBoolCheck { get; } =
Diagnostic(
"xUnit2009",
"Do not use boolean check to check for substrings",
Assertions,
Warning,
"Do not use {0} to check for substrings. Use Assert.{1} instead."
);
public static DiagnosticDescriptor X2010_AssertStringEqualityCheckShouldNotUseBoolCheckFixer { get; } =
Diagnostic(
"xUnit2010",
"Do not use boolean check to check for string equality",
Assertions,
Warning,
"Do not use {0} to check for string equality. Use Assert.{1} instead."
);
public static DiagnosticDescriptor X2011_AssertEmptyCollectionCheckShouldNotBeUsed { get; } =
Diagnostic(
"xUnit2011",
"Do not use empty collection check",
Assertions,
Warning,
"Do not use {0} to check for empty collections. Add element inspectors (for non-empty collections), or use Assert.Empty (for empty collections) instead."
);
public static DiagnosticDescriptor X2012_AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheck { get; } =
Diagnostic(
"xUnit2012",
"Do not use boolean check to check if a value exists in a collection",
Assertions,
Warning,
"Do not use {0} to check if a value exists in a collection. Use Assert.{1} instead."
);
public static DiagnosticDescriptor X2013_AssertEqualShouldNotBeUsedForCollectionSizeCheck { get; } =
Diagnostic(
"xUnit2013",
"Do not use equality check to check for collection size.",
Assertions,
Warning,
"Do not use {0} to check for collection size. Use Assert.{1} instead."
);
public static DiagnosticDescriptor X2014_AssertThrowsShouldNotBeUsedForAsyncThrowsCheck { get; } =
Diagnostic(
"xUnit2014",
"Do not use throws check to check for asynchronously thrown exception",
Assertions,
Error,
"Do not use {0} to check for asynchronously thrown exceptions. Use Assert.{1} instead."
);
public static DiagnosticDescriptor X2015_AssertThrowsShouldUseGenericOverload { get; } =
Diagnostic(
"xUnit2015",
"Do not use typeof expression to check the exception type",
Assertions,
Warning,
"Do not use typeof({1}) expression to check the exception type. Use Assert.{0}<{1}> instead."
);
public static DiagnosticDescriptor X2016_AssertEqualPrecisionShouldBeInRange { get; } =
Diagnostic(
"xUnit2016",
"Keep precision in the allowed range when asserting equality of doubles or decimals.",
Assertions,
Error,
"Keep precision in range {0} when asserting equality of {1} typed actual value."
);
public static DiagnosticDescriptor X2017_AssertCollectionContainsShouldNotUseBoolCheck { get; } =
Diagnostic(
"xUnit2017",
"Do not use Contains() to check if a value exists in a collection",
Assertions,
Warning,
"Do not use {0} to check if a value exists in a collection. Use Assert.{1} instead."
);
public static DiagnosticDescriptor X2018_AssertIsTypeShouldNotBeUsedForAbstractType { get; } =
Diagnostic(
"xUnit2018",
"Do not compare an object's exact type to an abstract class or interface",
Assertions,
Warning,
"Do not compare an object's exact type to the {0} '{1}'. Use {2} instead."
);
// Note: X2019 was already covered by X2014, and should not be reused
public static DiagnosticDescriptor X2020_UseAssertFailInsteadOfBooleanAssert { get; } =
Diagnostic(
"xUnit2020",
"Do not use always-failing boolean assertions",
Assertions,
Warning,
"Do not use Assert.{0}({1}, message) to fail a test. Use Assert.Fail(message) instead."
);
public static DiagnosticDescriptor X2021_AsyncAssertionsShouldBeAwaited { get; } =
Diagnostic(
"xUnit2021",
"Async assertions should be awaited",
Assertions,
Error,
"Assert.{0} is async. The resulting task should be awaited (or stored for later awaiting)."
);
public static DiagnosticDescriptor X2022_BooleanAssertionsShouldNotBeNegated { get; } =
Diagnostic(
"xUnit2022",
"Boolean assertions should not be negated",
Assertions,
Info,
"Do not negate your value when calling Assert.{0}. Call Assert.{1} without the negation instead."
);
public static DiagnosticDescriptor X2023_AssertSingleShouldBeUsedForSingleParameter { get; } =
Diagnostic(
"xUnit2023",
"Do not use collection methods for single-item collections",
Assertions,
Info,
"Do not use Assert.{0} if there is one element in the collection. Use Assert.Single instead."
);
public static DiagnosticDescriptor X2024_BooleanAssertionsShouldNotBeUsedForSimpleEqualityCheck { get; } =
Diagnostic(
"xUnit2024",
"Do not use boolean asserts for simple equality tests",
Assertions,
Info,
"Do not use Assert.{0} to test equality against null, numeric, string, or enum literals. Use Assert.{1} instead."
);
public static DiagnosticDescriptor X2025_BooleanAssertionCanBeSimplified { get; } =
Diagnostic(
"xUnit2025",
"The boolean assertion statement can be simplified",
Assertions,
Info,
"The use of Assert.{0} can be simplified to avoid using a boolean literal value in an equality test."
);
public static DiagnosticDescriptor X2026_SetsMustBeComparedWithEqualityComparer { get; } =
Diagnostic(
"xUnit2026",
"Comparison of sets must be done with IEqualityComparer",
Assertions,
Warning,
"Comparison of two sets may produce inconsistent results if GetHashCode() is not overriden. Consider using Assert.{0}(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>) instead."
);
public static DiagnosticDescriptor X2027_SetsShouldNotBeComparedToLinearContainers { get; } =
Diagnostic(
"xUnit2027",
"Comparison of sets to linear containers have undefined results",
Assertions,
Warning,
"Comparing an instance of {0} with an instance of {1} has undefined results, because the order of items in the set is not predictable. Create a stable order for the set (i.e., by using OrderBy from Linq)."
);
public static DiagnosticDescriptor X2028_DoNotUseAssertEmptyWithProblematicTypes { get; } =
Diagnostic(
"xUnit2028",
"Do not use Assert.Empty or Assert.NotEmpty with problematic types",
Assertions,
Warning,
"Using Assert.{0} with an instance of {1} is problematic, because {2}. Check the length with .Count instead."
);
public static DiagnosticDescriptor X2029_AssertEmptyShouldNotBeUsedForCollectionDoesNotContainCheck { get; } =
Diagnostic(
"xUnit2029",
"Do not use Assert.Empty to check if a value does not exist in a collection",
Assertions,
Warning,
"Do not use Assert.Empty to check if a value does not exist in a collection. Use Assert.DoesNotContain instead."
);
public static DiagnosticDescriptor X2030_AssertNotEmptyShouldNotBeUsedForCollectionContainsCheck { get; } =
Diagnostic(
"xUnit2030",
"Do not use Assert.NotEmpty to check if a value exists in a collection",
Assertions,
Warning,
"Do not use Assert.NotEmpty to check if a value exists in a collection. Use Assert.Contains instead."
);
public static DiagnosticDescriptor X2031_AssertSingleShouldUseTwoArgumentCall { get; } =
Diagnostic(
"xUnit2031",
"Do not use Where clause with Assert.Single",
Assertions,
Warning,
"Do not use a Where clause to filter before calling Assert.Single. Use the overload of Assert.Single that accepts a filtering function."
);
public static DiagnosticDescriptor X2032_AssignableFromAssertionIsConfusinglyNamed { get; } =
Diagnostic(
"xUnit2032",
"Type assertions based on 'assignable from' are confusingly named",
Assertions,
Info,
"The naming of Assert.{0} can be confusing. An overload of Assert.{1} is available with an exact match flag which can be set to false to perform the same operation."
);
// Placeholder for rule X2033
// Placeholder for rule X2034
// Placeholder for rule X2035
// Placeholder for rule X2036
// Placeholder for rule X2037
// Placeholder for rule X2038
// Placeholder for rule X2039
}
================================================
FILE: src/xunit.analyzers/Utility/Descriptors.xUnit3xxx.cs
================================================
using Microsoft.CodeAnalysis;
using static Microsoft.CodeAnalysis.DiagnosticSeverity;
using static Xunit.Analyzers.Category;
namespace Xunit.Analyzers;
public static partial class Descriptors
{
public static DiagnosticDescriptor X3000_CrossAppDomainClassesMustBeLongLivedMarshalByRefObject { get; } =
Diagnostic(
"xUnit3000",
"Classes which cross AppDomain boundaries must derive directly or indirectly from LongLivedMarshalByRefObject",
Extensibility,
Error,
"Class {0} must derive directly or indirectly from LongLivedMarshalByRefObject."
);
public static DiagnosticDescriptor X3001_SerializableClassMustHaveParameterlessConstructor { get; } =
Diagnostic(
"xUnit3001",
"Classes that are marked as serializable (or created by the test framework at runtime) must have a public parameterless constructor",
Extensibility,
Error,
"Class {0} must have a public parameterless constructor to support {1}."
);
public static DiagnosticDescriptor X3002_DoNotTestForConcreteTypeOfJsonSerializableTypes { get; } =
Diagnostic(
"xUnit3002",
"Classes which are JSON serializable should not be tested for their concrete type",
Extensibility,
Warning,
"Class {0} is JSON serializable and should not be tested for its concrete type. Test for its primary interface instead."
);
public static DiagnosticDescriptor X3003_ProvideConstructorForFactAttributeOverride { get; } =
Diagnostic(
"xUnit3003",
"Classes which extend FactAttribute (directly or indirectly) should provide a public constructor for source information",
Extensibility,
Warning,
"Class {0} extends FactAttribute. It should include a public constructor for source information."
);
// Placeholder for rule X3004
// Placeholder for rule X3005
// Placeholder for rule X3006
// Placeholder for rule X3007
// Placeholder for rule X3008
// Placeholder for rule X3009
}
================================================
FILE: src/xunit.analyzers/Utility/EmptyAssertContext.cs
================================================
using System;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public class EmptyAssertContext : IAssertContext
{
EmptyAssertContext()
{ }
public INamedTypeSymbol? AssertType => null;
public static EmptyAssertContext Instance { get; } = new();
public bool SupportsAssertFail => false;
public bool SupportsAssertNullWithPointers => false;
public bool SupportsInexactTypeAssertions => false;
public Version Version { get; } = new();
}
================================================
FILE: src/xunit.analyzers/Utility/EmptyCommonContext.cs
================================================
using System;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public class EmptyCommonContext : ICommonContext
{
EmptyCommonContext()
{ }
public static EmptyCommonContext Instance { get; } = new();
public INamedTypeSymbol? IMessageSinkType => null;
public INamedTypeSymbol? ISourceInformationProviderType => null;
public INamedTypeSymbol? ITestAssemblyType => null;
public INamedTypeSymbol? ITestCaseType => null;
public INamedTypeSymbol? ITestClassType => null;
public INamedTypeSymbol? ITestCollectionType => null;
public INamedTypeSymbol? ITestFrameworkDiscovererType => null;
public INamedTypeSymbol? ITestFrameworkExecutorType => null;
public INamedTypeSymbol? ITestFrameworkType => null;
public INamedTypeSymbol? ITestMethodType => null;
public INamedTypeSymbol? ITestType => null;
public INamedTypeSymbol? IXunitSerializableType => null;
public Version Version => new();
}
================================================
FILE: src/xunit.analyzers/Utility/EmptyCoreContext.cs
================================================
using System;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public class EmptyCoreContext : ICoreContext
{
EmptyCoreContext()
{ }
public INamedTypeSymbol? ClassDataAttributeType => null;
public INamedTypeSymbol? CollectionAttributeType => null;
public INamedTypeSymbol? CollectionDefinitionAttributeType => null;
public INamedTypeSymbol? DataAttributeType => null;
public INamedTypeSymbol? FactAttributeType => null;
public INamedTypeSymbol? IClassFixtureType => null;
public INamedTypeSymbol? ICollectionFixtureType => null;
public INamedTypeSymbol? InlineDataAttributeType => null;
public INamedTypeSymbol? ITestOutputHelperType => null;
public static EmptyCoreContext Instance { get; } = new();
public INamedTypeSymbol? MemberDataAttributeType => null;
public INamedTypeSymbol? TheoryAttributeType => null;
public bool TheorySupportsConversionFromStringToDateTimeOffsetAndGuid => false;
public bool TheorySupportsDefaultParameterValues => false;
public bool TheorySupportsParameterArrays => false;
public Version Version { get; } = new();
}
================================================
FILE: src/xunit.analyzers/Utility/EmptyRunnerUtilityContext.cs
================================================
using System;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public class EmptyRunnerUtilityContext : IRunnerUtilityContext
{
EmptyRunnerUtilityContext()
{ }
public static EmptyRunnerUtilityContext Instance { get; } = new();
public INamedTypeSymbol? LongLivedMarshalByRefObjectType => null;
public string Platform => "N/A";
public Version Version { get; } = new();
}
================================================
FILE: src/xunit.analyzers/Utility/EnumerableExtensions.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using Xunit;
/// <summary>
/// Extension methods for <see cref="IEnumerable{T}"/>.
/// </summary>
static partial class EnumerableExtensions
{
static readonly Func<object, bool> notNullTest = x => x is not null;
public static void Add<TKey, TValue>(
this Dictionary<TKey, List<TValue>> dictionary,
TKey key,
TValue value)
where TKey : notnull
{
if (!dictionary.TryGetValue(key, out var list))
{
list = [];
dictionary[key] = list;
}
list.Add(value);
}
public static void AddRange<T>(
this HashSet<T> hashSet,
IEnumerable<T> source)
{
Guard.ArgumentNotNull(hashSet);
Guard.ArgumentNotNull(source);
foreach (var item in source)
hashSet.Add(item);
}
/// <summary>
/// Returns <paramref name="source"/> as an enumerable of <typeparamref name="T"/> with
/// all the <c>null</c> items removed.
/// </summary>
public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T?> source)
where T : class =>
Guard.ArgumentNotNull(source).Where((Func<T?, bool>)notNullTest)!;
}
================================================
FILE: src/xunit.analyzers/Utility/IAssertContext.cs
================================================
using System;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public interface IAssertContext
{
/// <summary>
/// Gets a reference to type <c>Assert</c>, if available.
/// </summary>
INamedTypeSymbol? AssertType { get; }
/// <summary>
/// Gets a flag indicating whether <c>Assert.Fail</c> is supported.
/// </summary>
bool SupportsAssertFail { get; }
/// <summary>
/// Gets a flag indicating whether <c>Assert.Null</c> and <c>Assert.NotNull</c> supports
/// unsafe pointers.
/// </summary>
bool SupportsAssertNullWithPointers { get; }
/// <summary>
/// Gets a flag indicating whether <c>Assert.IsType</c> and <c>Assert.IsNotType</c>
/// support inexact matches (soft-deprecating <c>Assert.IsAssignableFrom</c>
/// and <c>Assert.IsNotAssignableFrom</c>).
/// </summary>
bool SupportsInexactTypeAssertions { get; }
/// <summary>
/// Gets the version number of the assertion assembly.
/// </summary>
Version Version { get; }
}
================================================
FILE: src/xunit.analyzers/Utility/ICommonContext.cs
================================================
using System;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
/// <summary>
/// Context for types that that originated in <c>xunit.abstractions</c> in v2, and moved in v3
/// to one of <c>xunit.v3.common</c>, <c>xunit.v3.core</c>, or <c>xunit.v3.runner.common</c>.
/// </summary>
public interface ICommonContext
{
/// <summary>
/// Gets a reference to type <c>IMessageSink</c>, if available.
/// </summary>
INamedTypeSymbol? IMessageSinkType { get; }
/// <summary>
/// Gets a reference to type <c>ISourceInformationProvider</c>, if available.
/// </summary>
INamedTypeSymbol? ISourceInformationProviderType { get; }
/// <summary>
/// Gets a reference to type <c>ITestAssembly</c>, if available.
/// </summary>
INamedTypeSymbol? ITestAssemblyType { get; }
/// <summary>
/// Gets a reference to type <c>ITestCase</c>, if available.
/// </summary>
INamedTypeSymbol? ITestCaseType { get; }
/// <summary>
/// Gets a reference to type <c>ITestClass</c>, if available.
/// </summary>
INamedTypeSymbol? ITestClassType { get; }
/// <summary>
/// Gets a reference to type <c>ITestCollection</c>, if available.
/// </summary>
INamedTypeSymbol? ITestCollectionType { get; }
/// <summary>
/// Gets a reference to type <c>ITestFrameworkDiscoverer</c>, if available.
/// </summary>
INamedTypeSymbol? ITestFrameworkDiscovererType { get; }
/// <summary>
/// Gets a reference to type <c>ITestFrameworkExecutor</c>, if available.
/// </summary>
INamedTypeSymbol? ITestFrameworkExecutorType { get; }
/// <summary>
/// Gets a reference to type <c>ITestFramework</c>, if available.
/// </summary>
INamedTypeSymbol? ITestFrameworkType { get; }
/// <summary>
/// Gets a reference to type <c>ITestMethod</c>, if available.
/// </summary>
INamedTypeSymbol? ITestMethodType { get; }
/// <summary>
/// Gets a reference to type <c>ITest</c>, if available.
/// </summary>
INamedTypeSymbol? ITestType { get; }
/// <summary>
/// Gets a reference to type <c>IXunitSerializable</c>, if available.
/// </summary>
INamedTypeSymbol? IXunitSerializableType { get; }
/// <summary>
/// Gets the version number of the <c>xunit.abstractions</c> or <c>xunit.v3.common</c> assembly.
/// </summary>
public Version Version { get; }
}
================================================
FILE: src/xunit.analyzers/Utility/ICoreContext.cs
================================================
using System;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public interface ICoreContext
{
/// <summary>
/// Gets a reference to type <c>ClassDataAttribute</c>, if available.
/// </summary>
INamedTypeSymbol? ClassDataAttributeType { get; }
/// <summary>
/// Gets a reference to type <c>CollectionAttribute</c>, if available.
/// </summary>
INamedTypeSymbol? CollectionAttributeType { get; }
/// <summary>
/// Gets a reference to type <c>CollectionDefinitionAttribute</c>, if available.
/// </summary>
INamedTypeSymbol? CollectionDefinitionAttributeType { get; }
/// <summary>
/// Gets a reference to type <c>DataAttribute</c>, if available.
/// </summary>
INamedTypeSymbol? DataAttributeType { get; }
/// <summary>
/// Gets a reference to type <c>FactAttribute</c>, if available.
/// </summary>
INamedTypeSymbol? FactAttributeType { get; }
/// <summary>
/// Gets a reference to type <c>IClassFixture<T></c>, if available.
/// </summary>
INamedTypeSymbol? IClassFixtureType { get; }
/// <summary>
/// Gets a reference to type <c>ICollectionFixture<T></c>, if available.
/// </summary>
INamedTypeSymbol? ICollectionFixtureType { get; }
/// <summary>
/// Gets a reference to type <c>InlineDataAttribute</c>, if available.
/// </summary>
INamedTypeSymbol? InlineDataAttributeType { get; }
/// <summary>
/// Gets a reference to type <c>ITestOutputHelper</c>, if available.
/// </summary>
INamedTypeSymbol? ITestOutputHelperType { get; }
/// <summary>
/// Gets a reference to type <c>MemberDataAttribute</c>, if available.
/// </summary>
INamedTypeSymbol? MemberDataAttributeType { get; }
/// <summary>
/// Gets a reference to type <c>TheoryAttribute</c>, if available.
/// </summary>
INamedTypeSymbol? TheoryAttributeType { get; }
/// <summary>
/// Gets a flag indicating whether theory data can be automatically converted from a <see cref="string"/>
/// value into a <see cref="DateTimeOffset"/> or a <see cref="Guid"/>.
/// </summary>
bool TheorySupportsConversionFromStringToDateTimeOffsetAndGuid { get; }
/// <summary>
/// Gets a flag indicating whether theory methods support default parameter values.
/// </summary>
bool TheorySupportsDefaultParameterValues { get; }
/// <summary>
/// Gets a flag indicating whether theory methods support params arrays.
/// </summary>
bool TheorySupportsParameterArrays { get; }
/// <summary>
/// Gets the version number of the core assembly.
/// </summary>
Version Version { get; }
}
================================================
FILE: src/xunit.analyzers/Utility/IRunnerUtilityContext.cs
================================================
using System;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public interface IRunnerUtilityContext
{
/// <summary>
/// Gets a reference to type <c>Xunit.Sdk.LongLivedMarshalByRefObject</c>, if available.
/// </summary>
INamedTypeSymbol? LongLivedMarshalByRefObjectType { get; }
/// <summary>
/// Gets a description of the target platform for the runner utility (i.e., "net452"). This is
/// typically extracted from the assembly name (i.e., "xunit.runner.utility.net452").
/// </summary>
string Platform { get; }
/// <summary>
/// Gets the version number of the runner utility assembly.
/// </summary>
Version Version { get; }
}
================================================
FILE: src/xunit.analyzers/Utility/Serializability.cs
================================================
namespace Xunit.Analyzers;
public enum Serializability
{
NeverSerializable,
PossiblySerializable,
AlwaysSerializable
}
================================================
FILE: src/xunit.analyzers/Utility/SerializabilityAnalyzer.cs
================================================
using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public sealed class SerializabilityAnalyzer(SerializableTypeSymbols typeSymbols)
{
static readonly Version Version_3_0_1 = new(3, 0, 1);
/// <summary>
/// Analyze the given type to determine whether it is always, possibly, or never serializable.
/// </summary>
/// <remarks>
/// The logic in this method corresponds to the logic in SerializationHelper.IsSerializable
/// and SerializationHelper.Serialize.
/// </remarks>
public Serializability AnalayzeSerializability(
ITypeSymbol type,
XunitContext xunitContext)
{
Guard.ArgumentNotNull(xunitContext);
type = type.UnwrapNullable();
if (GetTypeKindSerializability(type.TypeKind) == Serializability.NeverSerializable)
return Serializability.NeverSerializable;
if (type.TypeKind == TypeKind.Array && type is IArrayTypeSymbol arrayType)
return AnalayzeSerializability(arrayType.ElementType, xunitContext);
if (typeSymbols.Type.IsAssignableFrom(type))
return Serializability.AlwaysSerializable;
if (type.Equals(typeSymbols.TraitDictionary, SymbolEqualityComparer.Default))
return Serializability.AlwaysSerializable;
if (typeSymbols.IXunitSerializable.IsAssignableFrom(type))
return Serializability.AlwaysSerializable;
if (type.SpecialType != SpecialType.None)
return GetSpecialTypeSerializability(type.SpecialType);
if (type.Equals(typeSymbols.BigInteger, SymbolEqualityComparer.Default)
|| type.Equals(typeSymbols.DateTimeOffset, SymbolEqualityComparer.Default)
|| type.Equals(typeSymbols.TimeSpan, SymbolEqualityComparer.Default)
|| type.Equals(typeSymbols.DateOnly, SymbolEqualityComparer.Default)
|| type.Equals(typeSymbols.TimeOnly, SymbolEqualityComparer.Default))
return Serializability.AlwaysSerializable;
if (xunitContext.HasV3References)
{
if (type.Equals(typeSymbols.Guid, SymbolEqualityComparer.Default)
|| type.Equals(typeSymbols.Index, SymbolEqualityComparer.Default)
|| type.Equals(typeSymbols.Range, SymbolEqualityComparer.Default)
|| type.Equals(typeSymbols.Uri, SymbolEqualityComparer.Default)
|| type.Equals(typeSymbols.Version, SymbolEqualityComparer.Default))
return Serializability.AlwaysSerializable;
if (typeSymbols.IFormattable.IsAssignableFrom(type) && typeSymbols.IParsableOfT is not null)
{
var iParsableOfSelf = typeSymbols.IParsableOfT.Construct(type);
if (iParsableOfSelf.IsAssignableFrom(type))
return Serializability.AlwaysSerializable;
}
if (xunitContext.V3Core?.Version >= Version_3_0_1 && typeSymbols.ITuple is not null && typeSymbols.ITuple.IsAssignableFrom(type))
return Serializability.AlwaysSerializable;
}
if (typeSymbols.TypesWithCustomSerializers.Any(t => t.IsAssignableFrom(type)))
return Serializability.AlwaysSerializable;
if (type.TypeKind == TypeKind.Class && !type.IsSealed)
return Serializability.PossiblySerializable;
if (type.TypeKind == TypeKind.Interface)
return Serializability.PossiblySerializable;
if (type.TypeKind == TypeKind.Enum)
return Serializability.PossiblySerializable;
return Serializability.NeverSerializable;
}
static Serializability GetSpecialTypeSerializability(SpecialType type) =>
type switch
{
SpecialType.System_String
or SpecialType.System_Char
or SpecialType.System_Byte
or SpecialType.System_SByte
or SpecialType.System_Int16
or SpecialType.System_UInt16
or SpecialType.System_Int32
or SpecialType.System_UInt32
or SpecialType.System_Int64
or SpecialType.System_UInt64
or SpecialType.System_Single
or SpecialType.System_Double
or SpecialType.System_Decimal
or SpecialType.System_Boolean
or SpecialType.System_DateTime => Serializability.AlwaysSerializable,
SpecialType.None
or SpecialType.System_Object
or SpecialType.System_Array
or SpecialType.System_Enum
or SpecialType.System_ValueType
or SpecialType.System_Nullable_T
or SpecialType.System_Collections_IEnumerable
or SpecialType.System_IDisposable => Serializability.PossiblySerializable,
_ => Serializability.NeverSerializable
};
static Serializability GetTypeKindSerializability(TypeKind kind) =>
kind switch
{
TypeKind.Array
or TypeKind.Class
or TypeKind.Enum
or TypeKind.Interface
or TypeKind.Struct => Serializability.PossiblySerializable,
_ => Serializability.NeverSerializable
};
static bool TypeKindShouldBeIgnored(TypeKind kind) =>
kind switch
{
TypeKind.Unknown
or TypeKind.Enum
or TypeKind.Error
or TypeKind.Module
or TypeKind.TypeParameter
or TypeKind.Submission => true,
_ => false
};
/// <summary>
/// Determine whether the given type should be ignored when analyzing serializability.
/// Types are ignored by type kind (and special type for <see cref="SpecialType.System_Enum"/>).
/// Arrays and generic types are ignored if they are composed of ignored types, recursively.
/// </summary>
/// <remarks>
/// Enumerations are serializable if and only if they are not from the Global Assembly Cache,
/// which exists in .NET Framework only. However, static analysis cannot reliably determine
/// whether a type is from a local assembly or the GAC. Therefore, <see cref="TypeKind.Enum"/>
/// and <see cref="SpecialType.System_Enum"/> are ignored, in order to prevent a diagnostic from
/// being always found for all enumeration types.
/// </remarks>
public bool TypeShouldBeIgnored([NotNullWhen(false)] ITypeSymbol? type)
{
if (type is null)
return true;
if (TypeKindShouldBeIgnored(type.TypeKind) || type.SpecialType == SpecialType.System_Enum)
return true;
if (type is IArrayTypeSymbol arrayType)
return TypeShouldBeIgnored(arrayType.ElementType);
if (type is INamedTypeSymbol namedType && namedType.IsGenericType)
return namedType.TypeArguments.Where(TypeShouldBeIgnored).Any();
return false;
}
}
================================================
FILE: src/xunit.analyzers/Utility/SerializableTypeSymbols.cs
================================================
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public sealed class SerializableTypeSymbols
{
readonly Lazy<INamedTypeSymbol?> bigInteger;
readonly Lazy<INamedTypeSymbol?> dateOnly;
readonly Lazy<INamedTypeSymbol?> dateTimeOffset;
readonly Lazy<INamedTypeSymbol?> guid;
readonly Lazy<INamedTypeSymbol?> iFormattable;
readonly Lazy<INamedTypeSymbol?> index;
readonly Lazy<INamedTypeSymbol?> iParsableOfT;
readonly Lazy<INamedTypeSymbol?> iTuple;
readonly Lazy<INamedTypeSymbol?> iXunitSerializable;
readonly Lazy<INamedTypeSymbol?> range;
readonly Lazy<INamedTypeSymbol?> theoryDataBaseType;
readonly Dictionary<int, INamedTypeSymbol> theoryDataTypes;
readonly Lazy<INamedTypeSymbol?> timeOnly;
readonly Lazy<INamedTypeSymbol?> timeSpan;
readonly Lazy<INamedTypeSymbol?> traitDictionary;
readonly Lazy<INamedTypeSymbol?> type;
readonly Lazy<ImmutableArray<INamedTypeSymbol>> typesWithCustomSerializers;
readonly Lazy<INamedTypeSymbol?> uri;
readonly Lazy<INamedTypeSymbol?> version;
SerializableTypeSymbols(
Compilation compilation,
XunitContext xunitContext,
INamedTypeSymbol classDataAttribute,
INamedTypeSymbol dataAttribute,
INamedTypeSymbol memberDataAttribute,
INamedTypeSymbol theoryAttribute,
Dictionary<int, INamedTypeSymbol> theoryDataTypes)
{
this.theoryDataTypes = theoryDataTypes;
bigInteger = new(() => TypeSymbolFactory.BigInteger(compilation));
dateOnly = new(() => TypeSymbolFactory.DateOnly(compilation));
dateTimeOffset = new(() => TypeSymbolFactory.DateTimeOffset(compilation));
guid = new(() => TypeSymbolFactory.Guid(compilation));
iFormattable = new(() => TypeSymbolFactory.IFormattable(compilation));
index = new(() => TypeSymbolFactory.Index(compilation));
iParsableOfT = new(() => TypeSymbolFactory.IParsableOfT(compilation));
iTuple = new(() => TypeSymbolFactory.ITuple(compilation));
iXunitSerializable = new(() => xunitContext.Common.IXunitSerializableType);
range = new(() => TypeSymbolFactory.Range(compilation));
// For v2 and early versions of v3, the base type is "TheoryData" (non-generic). For later versions
// of v3, it's "TheoryDataBase<TTheoryDataRow, TRawDataRow>". In either case, getting "TheoryData<T>"
// and going up one layer gets us the type we want to be able to search for.
theoryDataBaseType = new(() => TheoryData(arity: 1)?.BaseType);
timeOnly = new(() => TypeSymbolFactory.TimeOnly(compilation));
timeSpan = new(() => TypeSymbolFactory.TimeSpan(compilation));
traitDictionary = new(() => GetTraitDictionary(compilation));
type = new(() => TypeSymbolFactory.Type(compilation));
typesWithCustomSerializers = new(() =>
{
var registerXunitSerializer = TypeSymbolFactory.RegisterXunitSerializerAttribute_V3(compilation);
if (registerXunitSerializer is null)
#pragma warning disable IDE0301 // Cannot convert this due to Roslyn 3.11
return ImmutableArray<INamedTypeSymbol>.Empty;
#pragma warning restore IDE0301
return
compilation
.Assembly
.GetAttributes()
.Where(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, registerXunitSerializer) && a.ConstructorArguments.Length > 1 && a.ConstructorArguments[1].Kind == TypedConstantKind.Array)
.SelectMany(a => a.ConstructorArguments[1].Values.Select(v => v.Value as INamedTypeSymbol))
.WhereNotNull()
.ToImmutableArray();
});
uri = new(() => TypeSymbolFactory.Uri(compilation));
version = new(() => TypeSymbolFactory.Version(compilation));
ClassDataAttribute = classDataAttribute;
DataAttribute = dataAttribute;
MemberDataAttribute = memberDataAttribute;
TheoryAttribute = theoryAttribute;
}
public INamedTypeSymbol? BigInteger => bigInteger.Value;
public INamedTypeSymbol ClassDataAttribute { get; }
public INamedTypeSymbol DataAttribute { get; }
public INamedTypeSymbol? DateOnly => dateOnly.Value;
public INamedTypeSymbol? DateTimeOffset => dateTimeOffset.Value;
public INamedTypeSymbol? Guid => guid.Value;
public INamedTypeSymbol? IFormattable => iFormattable.Value;
public INamedTypeSymbol? Index => index.Value;
public INamedTypeSymbol? IParsableOfT => iParsableOfT.Value;
public INamedTypeSymbol? ITuple => iTuple.Value;
public INamedTypeSymbol? IXunitSerializable => iXunitSerializable.Value;
public INamedTypeSymbol MemberDataAttribute { get; }
public INamedTypeSymbol? Range => range.Value;
public INamedTypeSymbol TheoryAttribute { get; }
public INamedTypeSymbol? TheoryDataBaseType => theoryDataBaseType.Value;
public INamedTypeSymbol? TimeOnly => timeOnly.Value;
public INamedTypeSymbol? TimeSpan => timeSpan.Value;
public INamedTypeSymbol? TraitDictionary => traitDictionary.Value;
public INamedTypeSymbol? Type => type.Value;
public ImmutableArray<INamedTypeSymbol> TypesWithCustomSerializers => typesWithCustomSerializers.Value;
public INamedTypeSymbol? Uri => uri.Value;
public INamedTypeSymbol? Version => version.Value;
public static SerializableTypeSymbols? Create(
Compilation compilation,
XunitContext xunitContext)
{
Guard.ArgumentNotNull(compilation);
Guard.ArgumentNotNull(xunitContext);
if (xunitContext.Core.TheoryAttributeType is not INamedTypeSymbol theoryAttribute)
return null;
if (xunitContext.Core.DataAttributeType is not INamedTypeSymbol dataAttribute)
return null;
if (xunitContext.Core.ClassDataAttributeType is not INamedTypeSymbol classDataAttribute)
return null;
if (xunitContext.Core.MemberDataAttributeType is not INamedTypeSymbol memberDataAttribute)
return null;
return new SerializableTypeSymbols(
compilation,
xunitContext,
classDataAttribute,
dataAttribute,
memberDataAttribute,
theoryAttribute,
TypeSymbolFactory.TheoryData_ByGenericArgumentCount(compilation)
);
}
static INamedTypeSymbol? GetTraitDictionary(Compilation compilation)
{
if (TypeSymbolFactory.DictionaryofTKeyTValue(compilation) is not INamedTypeSymbol dictionaryType)
return null;
if (TypeSymbolFactory.ListOfT(compilation) is not INamedTypeSymbol listType)
return null;
var stringType = compilation.GetSpecialType(SpecialType.System_String);
var listOfStringType = listType.Construct(stringType);
return dictionaryType.Construct(stringType, listOfStringType);
}
public INamedTypeSymbol? TheoryData(int arity)
{
theoryDataTypes.TryGetValue(arity, out var result);
return result;
}
}
================================================
FILE: src/xunit.analyzers/Utility/SymbolExtensions.cs
================================================
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public static class SymbolExtensions
{
public static bool ContainsAttributeType(
this ImmutableArray<AttributeData> attributes,
INamedTypeSymbol attributeType,
bool exactMatch = false) =>
attributes.Any(a => a.IsInstanceOf(attributeType, exactMatch));
/// <summary>
/// If the passed <paramref name="typeSymbol"/> is <see cref="T:System.Collections.Generic.IAsyncEnumerable{T}"/>,
/// then returns the enumerable type (aka, T); otherwise, returns <c>null</c>.
/// </summary>
public static ITypeSymbol? GetAsyncEnumerableType(this ITypeSymbol? typeSymbol)
{
if (typeSymbol is not INamedTypeSymbol namedTypeSymbol)
return null;
// Ideally we'd use symbol comparison here, but that would require threading the
// Compilation object here, and with 44 callers to IsAssignableFrom that seemed
// like an unnecessarily daunting task. We cross fingers that this is good. :)
if (namedTypeSymbol.Name == "IAsyncEnumerable" && namedTypeSymbol.ContainingNamespace.ToString() == "System.Collections.Generic")
return namedTypeSymbol.TypeArguments[0];
return null;
}
/// <summary>
/// If the passed <paramref name="typeSymbol"/> is <see cref="IEnumerable{T}"/>, then returns
/// the enumerable type (aka, T); otherwise, returns <c>null</c>.
/// </summary>
public static ITypeSymbol? GetEnumerableType(this ITypeSymbol? typeSymbol)
{
if (typeSymbol is not INamedTypeSymbol namedTypeSymbol)
return null;
if (namedTypeSymbol.OriginalDefinition.SpecialType != SpecialType.System_Collections_Generic_IEnumerable_T)
return null;
return namedTypeSymbol.TypeArguments[0];
}
public static INamedTypeSymbol? GetGenericInterfaceImplementation(
this ITypeSymbol implementingType,
INamedTypeSymbol openInterfaceType)
{
Guard.ArgumentNotNull(implementingType);
Guard.ArgumentNotNull(openInterfaceType);
if (SymbolEqualityComparer.Default.Equals(implementingType.OriginalDefinition, openInterfaceType))
return implementingType as INamedTypeSymbol;
return implementingType.AllInterfaces.FirstOrDefault(i => SymbolEqualityComparer.Default.Equals(i.OriginalDefinition, openInterfaceType));
}
public static ISymbol? GetMember(
this INamespaceOrTypeSymbol namespaceOrType,
string name) =>
Guard.ArgumentNotNull(namespaceOrType).GetMembers(name).FirstOrDefault();
public static ImmutableArray<ISymbol> GetInheritedAndOwnMembers(
this ITypeSymbol? symbol,
string? name = null)
{
var builder = ImmutableArray.CreateBuilder<ISymbol>();
while (symbol is not null)
{
builder.AddRange(name is null ? symbol.GetMembers() : symbol.GetMembers(name));
symbol = symbol.BaseType;
}
return builder.ToImmutable();
}
public static bool IsAssignableFrom(
this ITypeSymbol? targetType,
ITypeSymbol? sourceType,
bool exactMatch = false)
{
if (targetType is not null)
{
var targetEnumerableType = targetType.GetEnumerableType();
var targetAsyncEnumerableType = targetType.GetAsyncEnumerableType();
while (sourceType is not null)
{
if (SymbolEqualityComparer.Default.Equals(sourceType, targetType))
return true;
if (exactMatch)
return false;
// Special handling for IEnumerable<T> == IEnumerable<T>, because the Ts are covariant and the
// symbol equality comparerer is an exact comparison, not a compatibility test.
if (targetEnumerableType is not null)
{
var sourceEnumerableType = sourceType.GetEnumerableType();
if (sourceEnumerableType is not null)
return IsAssignableFrom(targetEnumerableType, sourceEnumerableType);
}
// Special handling for IAsyncEnumerable<T> == IAsyncEnumerable<T> as well
if (targetAsyncEnumerableType is not null)
{
var sourceAsyncEnumerableType = sourceType.GetAsyncEnumerableType();
if (sourceAsyncEnumerableType is not null)
return IsAssignableFrom(targetAsyncEnumerableType, sourceAsyncEnumerableType);
}
// Special handling for tuples as tuples with differently named fields are still assignable
if (targetType.IsTupleType && sourceType.IsTupleType)
{
var targetTupleType = ((INamedTypeSymbol)targetType).TupleUnderlyingType ?? targetType;
var sourceTupleType = ((INamedTypeSymbol)sourceType).TupleUnderlyingType ?? sourceType;
return SymbolEqualityComparer.Default.Equals(sourceTupleType, targetTupleType);
}
// Special handling for generic types, possibly with type constraints
if (targetType is INamedTypeSymbol namedTargetType && namedTargetType.IsGenericType &&
sourceType is INamedTypeSymbol namedSourceType && namedSourceType.IsGenericType)
{
if (SymbolEqualityComparer.Default.Equals(namedTargetType.OriginalDefinition, namedSourceType.OriginalDefinition))
{
// Unbound generic types (e.g., List<>) are assignable from any open/closed generic of the same definition (e.g., List<int> or List<T>)
if (namedTargetType.IsUnboundGenericType)
return true;
// Open/closed generic types must have compatible type arguments
bool argumentsMatch = true;
for (int i = 0; i < namedTargetType.TypeArguments.Length; i++)
{
var tArg = namedTargetType.TypeArguments[i];
var sArg = namedSourceType.TypeArguments[i];
if (tArg.TypeKind == TypeKind.TypeParameter)
continue;
// Recursively verify nested arguments (e.g., IEnumerable<string> inside Task<IEnumerable<string>>)
if (!IsAssignableFrom(tArg, sArg, exactMatch))
{
argumentsMatch = false;
break;
}
}
if (argumentsMatch)
return true;
}
}
if (targetType.TypeKind == TypeKind.Interface)
return sourceType.AllInterfaces.Any(i => IsAssignableFrom(targetType, i));
sourceType = sourceType.BaseType;
}
}
return false;
}
public static bool IsInstanceOf(
this AttributeData attribute,
INamedTypeSymbol attributeType,
bool exactMatch = false) =>
Guard.ArgumentNotNull(attributeType).IsAssignableFrom(
Guard.ArgumentNotNull(attribute).AttributeClass,
exactMatch
);
public static ITypeSymbol? UnwrapEnumerable(
this ITypeSymbol? type,
Compilation compilation,
bool unwrapArray = false)
{
if (type is null)
return null;
var iEnumerableOfT = TypeSymbolFactory.IEnumerableOfT(compilation);
var result = UnwrapEnumerable(type, iEnumerableOfT, unwrapArray);
if (result is null)
{
var iAsyncEnumerableOfT = TypeSymbolFactory.IAsyncEnumerableOfT(compilation);
if (iAsyncEnumerableOfT is not null)
result = UnwrapEnumerable(type, iAsyncEnumerableOfT, unwrapArray);
}
return result;
}
public static ITypeSymbol? UnwrapEnumerable(
this ITypeSymbol? type,
ITypeSymbol enumerableType,
bool unwrapArray = false)
{
if (type is null)
return null;
if (unwrapArray && type is IArrayTypeSymbol arrayType)
return arrayType.ElementType;
IEnumerable<INamedTypeSymbol> interfaces = type.AllInterfaces;
if (type is INamedTypeSymbol namedType)
interfaces = interfaces.Concat([namedType]);
foreach (var @interface in interfaces)
if (SymbolEqualityComparer.Default.Equals(@interface.OriginalDefinition, enumerableType))
return @interface.TypeArguments[0];
return null;
}
public static ITypeSymbol UnwrapNullable(this ITypeSymbol type)
{
Guard.ArgumentNotNull(type);
if (type is not INamedTypeSymbol namedType)
return type;
if (namedType.IsGenericType && namedType.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T)
return namedType.TypeArguments[0];
return type;
}
}
================================================
FILE: src/xunit.analyzers/Utility/SyntaxExtensions.cs
================================================
using System.Threading;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace Xunit.Analyzers;
public static class SyntaxExtensions
{
public static bool ContainsAttributeType(
this SyntaxList<AttributeListSyntax> attributeLists,
SemanticModel semanticModel,
INamedTypeSymbol attributeType,
bool exactMatch = false)
{
Guard.ArgumentNotNull(semanticModel);
Guard.ArgumentNotNull(attributeType);
foreach (var attributeList in attributeLists)
{
foreach (var attribute in attributeList.Attributes)
{
var type = semanticModel.GetTypeInfo(attribute).Type;
if (attributeType.IsAssignableFrom(type, exactMatch))
return true;
}
}
return false;
}
public static SimpleNameSyntax? GetSimpleName(this InvocationExpressionSyntax invocation) =>
Guard.ArgumentNotNull(invocation).Expression switch
{
MemberAccessExpressionSyntax memberAccess => memberAccess.Name,
SimpleNameSyntax simpleName => simpleName,
_ => null,
};
public static bool IsEnumValueExpression(
this ExpressionSyntax expression,
SemanticModel semanticModel,
CancellationToken cancellationToken = default)
{
Guard.ArgumentNotNull(expression);
Guard.ArgumentNotNull(semanticModel);
if (!expression.IsKind(SyntaxKind.SimpleMemberAccessExpression))
return false;
var symbol = semanticModel.GetSymbolInfo(expression, cancellationToken).Symbol;
return symbol?.Kind == SymbolKind.Field && symbol.ContainingType.TypeKind == TypeKind.Enum;
}
public static bool IsNameofExpression(
this ExpressionSyntax expression,
SemanticModel semanticModel,
CancellationToken cancellationToken = default)
{
Guard.ArgumentNotNull(expression);
Guard.ArgumentNotNull(semanticModel);
if (!expression.IsKind(SyntaxKind.InvocationExpression))
return false;
if (expression is not InvocationExpressionSyntax invocation)
return false;
if (invocation.ArgumentList.Arguments.Count != 1)
return false;
if ((invocation.Expression as IdentifierNameSyntax)?.Identifier.ValueText != "nameof")
return false;
// A real nameof expression doesn't have a matching symbol, but it does have the string type
return
semanticModel.GetSymbolInfo(expression, cancellationToken).Symbol is null
&& semanticModel.GetTypeInfo(expression, cancellationToken).Type?.SpecialType == SpecialType.System_String;
}
}
================================================
FILE: src/xunit.analyzers/Utility/TypeHierarchyComparer.cs
================================================
using System;
using System.Collections.Generic;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public class TypeHierarchyComparer : IComparer<ITypeSymbol>
{
TypeHierarchyComparer()
{ }
public static TypeHierarchyComparer Instance { get; } = new TypeHierarchyComparer();
public int Compare(
ITypeSymbol? x,
ITypeSymbol? y)
{
Guard.ArgumentValid("The argument must be a class", x?.TypeKind == TypeKind.Class, nameof(x));
Guard.ArgumentValid("The argument must be a class", y?.TypeKind == TypeKind.Class, nameof(x));
if (SymbolEqualityComparer.Default.Equals(x, y))
return 0;
if (x.IsAssignableFrom(y))
return -1;
if (y.IsAssignableFrom(x))
return 1;
throw new InvalidOperationException("Encountered types not in a hierarchy");
}
}
================================================
FILE: src/xunit.analyzers/Utility/TypeSymbolFactory.cs
================================================
using System;
using System.Collections.Generic;
using System.Globalization;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public static class TypeSymbolFactory
{
public static INamedTypeSymbol? Action(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Action");
public static INamedTypeSymbol? Action(
Compilation compilation,
int arity = 1) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName($"System.Action`{ValidateArity(arity, min: 1, max: 16)}");
public static INamedTypeSymbol? ArraySegmentOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.ArraySegment`1");
public static INamedTypeSymbol? AssemblyFixtureAttribute_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.AssemblyFixtureAttribute_V3);
public static INamedTypeSymbol? Assert(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.Assert);
public static INamedTypeSymbol? AttributeUsageAttribute(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.AttributeUsageAttribute");
public static INamedTypeSymbol? BigInteger(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Numerics.BigInteger");
public static INamedTypeSymbol? CallerFilePathAttribute(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Runtime.CompilerServices.CallerFilePathAttribute");
public static INamedTypeSymbol? CallerLineNumberAttribute(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Runtime.CompilerServices.CallerLineNumberAttribute");
public static INamedTypeSymbol? CancellationToken(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Threading.CancellationToken");
public static INamedTypeSymbol? ClassDataAttribute(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ClassDataAttribute);
public static INamedTypeSymbol? ClassDataAttributeOfT_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ClassDataAttributeOfT_V3);
public static INamedTypeSymbol? CollectionAttribute(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.CollectionAttribute);
public static INamedTypeSymbol? CollectionAttributeOfT_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.CollectionAttributeOfT_V3);
public static INamedTypeSymbol? CollectionDefinitionAttribute(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.CollectionDefinitionAttribute);
public static INamedTypeSymbol? ConfigureAwaitOptions(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Threading.Tasks.ConfigureAwaitOptions");
public static INamedTypeSymbol? ConfiguredTaskAwaitable(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Runtime.CompilerServices.ConfiguredTaskAwaitable");
public static INamedTypeSymbol? DataAttribute_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.DataAttribute_V2);
public static INamedTypeSymbol? DataAttribute_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.DataAttribute_V3);
public static INamedTypeSymbol? DateOnly(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.DateOnly");
public static INamedTypeSymbol? DateTimeOffset(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.DateTimeOffset");
public static INamedTypeSymbol? DictionaryofTKeyTValue(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Collections.Generic.Dictionary`2");
public static INamedTypeSymbol? FactAttribute(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.FactAttribute);
public static INamedTypeSymbol? Func(
Compilation compilation,
int arity = 1) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName($"System.Func`{ValidateArity(arity, min: 1, max: 17)}");
public static INamedTypeSymbol? Guid(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Guid");
public static INamedTypeSymbol? IAssemblyInfo_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IAssemblyInfo_V2);
public static INamedTypeSymbol? IAsyncEnumerableOfITheoryDataRow(Compilation compilation)
{
var iAsyncEnumerableOfT = IAsyncEnumerableOfT(compilation);
if (iAsyncEnumerableOfT is null)
return null;
var iTheoryDataRow = ITheoryDataRow_V3(compilation);
if (iTheoryDataRow is null)
return null;
return iAsyncEnumerableOfT.Construct(iTheoryDataRow);
}
public static INamedTypeSymbol? IAsyncEnumerableOfObjectArray(Compilation compilation)
{
var iAsyncEnumerableOfT = IAsyncEnumerableOfT(compilation);
if (iAsyncEnumerableOfT is null)
return null;
var objectArray = ObjectArray(compilation);
return iAsyncEnumerableOfT.Construct(objectArray);
}
public static INamedTypeSymbol? IAsyncEnumerableOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Collections.Generic.IAsyncEnumerable`1");
public static INamedTypeSymbol? IAsyncEnumerableOfTuple(Compilation compilation)
{
var iTuple = ITuple(compilation);
if (iTuple is null)
return null;
return IAsyncEnumerableOfT(compilation)?.Construct(iTuple);
}
public static INamedTypeSymbol? IAsyncLifetime(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IAsyncLifetime);
public static INamedTypeSymbol? IAttributeInfo_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IAttributeInfo_V2);
public static INamedTypeSymbol? IClassFixureOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IClassFixtureOfT);
public static INamedTypeSymbol? ICollection(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Collections.ICollection");
public static INamedTypeSymbol? ICollectionFixtureOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ICollectionFixtureOfT);
public static INamedTypeSymbol ICollectionOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetSpecialType(SpecialType.System_Collections_Generic_ICollection_T);
public static INamedTypeSymbol? ICriticalNotifyCompletion(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Runtime.CompilerServices.ICriticalNotifyCompletion");
public static INamedTypeSymbol? IDataAttribute_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IDataAttribute_V3);
public static INamedTypeSymbol IDisposable(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetSpecialType(SpecialType.System_IDisposable);
public static INamedTypeSymbol? IEnumerableOfITheoryDataRow(Compilation compilation)
{
var iTheoryDataRow = ITheoryDataRow_V3(compilation);
if (iTheoryDataRow is null)
return null;
return IEnumerableOfT(compilation).Construct(iTheoryDataRow);
}
public static INamedTypeSymbol IEnumerableOfObjectArray(Compilation compilation) =>
IEnumerableOfT(compilation).Construct(ObjectArray(compilation));
public static INamedTypeSymbol IEnumerableOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T);
public static INamedTypeSymbol? IEnumerableOfTuple(Compilation compilation)
{
var iTuple = ITuple(compilation);
if (iTuple is null)
return null;
return IEnumerableOfT(compilation).Construct(iTuple);
}
public static INamedTypeSymbol? IFormattable(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.IFormattable");
public static INamedTypeSymbol? IMessageSink_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IMessageSink_V2);
public static INamedTypeSymbol? IMessageSink_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IMessageSink_V3);
public static INamedTypeSymbol? IMessageSinkMessage_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IMessageSinkMessage_V2);
public static INamedTypeSymbol? IMethodInfo_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IMethodInfo_V2);
public static INamedTypeSymbol? Index(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Index");
public static INamedTypeSymbol? InlineDataAttribute(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.InlineDataAttribute);
public static INamedTypeSymbol? IParameterInfo_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IParameterInfo_V2);
public static INamedTypeSymbol? IParsableOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.IParsable`1");
public static INamedTypeSymbol IReadOnlyCollectionOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetSpecialType(SpecialType.System_Collections_Generic_IReadOnlyCollection_T);
public static INamedTypeSymbol? IReadOnlySetOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Collections.Generic.IReadOnlySet`1");
public static INamedTypeSymbol? IRunnerReporter_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IRunnerReporter_V3);
public static INamedTypeSymbol? ISetOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Collections.Generic.ISet`1");
public static INamedTypeSymbol? ISourceInformation_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ISourceInformation_V2);
public static INamedTypeSymbol? ISourceInformationProvider_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ISourceInformationProvider_V2);
public static INamedTypeSymbol? ISourceInformationProvider_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ISourceInformationProvider_V3);
public static INamedTypeSymbol? ITest_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITest_V2);
public static INamedTypeSymbol? ITest_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITest_V3);
public static INamedTypeSymbol? ITestAssembly_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestAssembly_V2);
public static INamedTypeSymbol? ITestAssembly_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestAssembly_V3);
public static INamedTypeSymbol? ITestCase_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestCase_V2);
public static INamedTypeSymbol? ITestCase_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestCase_V3);
public static INamedTypeSymbol? ITestClass_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestClass_V2);
public static INamedTypeSymbol? ITestClass_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestClass_V3);
public static INamedTypeSymbol? ITestCollection_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestCollection_V2);
public static INamedTypeSymbol? ITestCollection_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestCollection_V3);
public static INamedTypeSymbol? ITestContextAccessor_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestContextAccessor_V3);
public static INamedTypeSymbol? ITestFramework_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestFramework_V2);
public static INamedTypeSymbol? ITestFramework_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestFramework_V3);
public static INamedTypeSymbol? ITestFrameworkDiscoverer_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestFrameworkDiscoverer_V2);
public static INamedTypeSymbol? ITestFrameworkDiscoverer_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestFrameworkDiscoverer_V3);
public static INamedTypeSymbol? ITestFrameworkExecutor_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestFrameworkExecutor_V2);
public static INamedTypeSymbol? ITestFrameworkExecutor_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestFrameworkExecutor_V3);
public static INamedTypeSymbol? ITestMethod_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestMethod_V2);
public static INamedTypeSymbol? ITestMethod_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestMethod_V3);
public static INamedTypeSymbol? ITestOutputHelper_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestOutputHelper_V2);
public static INamedTypeSymbol? ITestOutputHelper_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITestOutputHelper_V3);
public static INamedTypeSymbol? ITheoryDataRow_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITheoryDataRow_V3);
public static INamedTypeSymbol? ITuple(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Runtime.CompilerServices.ITuple");
public static INamedTypeSymbol? ITypeInfo_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.ITypeInfo_V2);
public static INamedTypeSymbol? IValueTaskSource(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Threading.Tasks.Sources.IValueTaskSource");
public static INamedTypeSymbol? IValueTaskSourceOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Threading.Tasks.Sources.IValueTaskSource`1");
public static INamedTypeSymbol? IXunitSerializable_V2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IXunitSerializable_V2);
public static INamedTypeSymbol? IXunitSerializable_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IXunitSerializable_V3);
public static INamedTypeSymbol? IXunitSerializer_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.IXunitSerializer_V3);
public static INamedTypeSymbol? JsonTypeIDAttribute_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.JsonTypeIDAttribute_V3);
public static INamedTypeSymbol? ListOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Collections.Generic.List`1");
public static INamedTypeSymbol? LongLivedMarshalByRefObject_ExecutionV2(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.LongLivedMarshalByRefObject_Execution_V2);
public static INamedTypeSymbol? LongLivedMarshalByRefObject_RunnerUtility(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.LongLivedMarshalByRefObject_RunnerUtility);
public static INamedTypeSymbol? MemberDataAttribute(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.MemberDataAttribute);
public static INamedTypeSymbol NullableOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetSpecialType(SpecialType.System_Nullable_T);
public static IArrayTypeSymbol ObjectArray(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).CreateArrayTypeSymbol(Guard.ArgumentNotNull(compilation).ObjectType);
public static INamedTypeSymbol? ObsoleteAttribute(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.System.ObsoleteAttribute);
public static INamedTypeSymbol? OptionalAttribute(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Runtime.InteropServices.OptionalAttribute");
public static INamedTypeSymbol? Range(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Range");
public static INamedTypeSymbol? Record(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.Record);
public static INamedTypeSymbol? RegisterXunitSerializerAttribute_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.RegisterXunitSerializerAttribute_V3);
public static INamedTypeSymbol? SortedSetOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Collections.Generic.SortedSet`1");
public static INamedTypeSymbol String(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetSpecialType(SpecialType.System_String);
public static INamedTypeSymbol? StringValues(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("Microsoft.Extensions.Primitives.StringValues");
public static INamedTypeSymbol? Task(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Threading.Tasks.Task");
public static INamedTypeSymbol? TaskOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Threading.Tasks.Task`1");
public static INamedTypeSymbol? TestContext_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.TestContext_V3);
public static INamedTypeSymbol? TheoryAttribute(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.TheoryAttribute);
public static INamedTypeSymbol? TheoryData(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.TheoryData);
// Centralized here so we don't repeat knowledge of how many arities exist
// (in case we decide to add more later).
public static Dictionary<int, INamedTypeSymbol> TheoryData_ByGenericArgumentCount(Compilation compilation)
{
var result = new Dictionary<int, INamedTypeSymbol>();
var type = TheoryData(compilation);
if (type is not null)
result[0] = type;
for (var i = 1; ; i++)
{
type = compilation.GetTypeByMetadataName(Constants.Types.Xunit.TheoryData + "`" + i.ToString(CultureInfo.InvariantCulture));
if (type is not null)
result[i] = type;
else
break;
}
return result;
}
public static INamedTypeSymbol? TheoryDataRow_V3(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName(Constants.Types.Xunit.TheoryDataRow_V3);
// Centralized here so we don't repeat knowledge of how many arities exist
// (in case we decide to add more later).
public static Dictionary<int, INamedTypeSymbol> TheoryDataRow_ByGenericArgumentCount_V3(Compilation compilation)
{
var result = new Dictionary<int, INamedTypeSymbol>();
var type = TheoryDataRow_V3(compilation);
if (type is not null)
result[0] = type;
for (var i = 1; ; i++)
{
type = compilation.GetTypeByMetadataName(Constants.Types.Xunit.TheoryDataRow_V3 + "`" + i.ToString(CultureInfo.InvariantCulture));
if (type is not null)
result[i] = type;
else
break;
}
return result;
}
public static INamedTypeSymbol? TimeOnly(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.TimeOnly");
public static INamedTypeSymbol? TimeSpan(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.TimeSpan");
public static INamedTypeSymbol? Type(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Type");
static int ValidateArity(
int arity,
int min,
int max)
{
if (arity >= min && arity <= max)
return arity;
throw new ArgumentOutOfRangeException(nameof(arity), $"Arity {arity} must be between {min} and {max}.");
}
public static INamedTypeSymbol? Uri(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Uri");
public static INamedTypeSymbol? ValueTask(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Threading.Tasks.ValueTask");
public static INamedTypeSymbol? ValueTaskOfT(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Threading.Tasks.ValueTask`1");
public static INamedTypeSymbol? Version(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetTypeByMetadataName("System.Version");
public static INamedTypeSymbol Void(Compilation compilation) =>
Guard.ArgumentNotNull(compilation).GetSpecialType(SpecialType.System_Void);
}
================================================
FILE: src/xunit.analyzers/Utility/V2AbstractionsContext.cs
================================================
using System;
using System.Linq;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public class V2AbstractionsContext : ICommonContext
{
readonly Lazy<INamedTypeSymbol?> lazyIAssemblyInfoType;
readonly Lazy<INamedTypeSymbol?> lazyIAttributeInfoType;
readonly Lazy<INamedTypeSymbol?> lazyIMessageSinkMessageType;
readonly Lazy<INamedTypeSymbol?> lazyIMessageSinkType;
readonly Lazy<INamedTypeSymbol?> lazyIMethodInfoType;
readonly Lazy<INamedTypeSymbol?> lazyIParameterInfoType;
readonly Lazy<INamedTypeSymbol?> lazyISourceInformationProviderType;
readonly Lazy<INamedTypeSymbol?> lazyISourceInformationType;
readonly Lazy<INamedTypeSymbol?> lazyITestAssemblyType;
readonly Lazy<INamedTypeSymbol?> lazyITestCaseType;
readonly Lazy<INamedTypeSymbol?> lazyITestClassType;
readonly Lazy<INamedTypeSymbol?> lazyITestCollectionType;
readonly Lazy<INamedTypeSymbol?> lazyITestFrameworkDiscovererType;
readonly Lazy<INamedTypeSymbol?> lazyITestFrameworkExecutorType;
readonly Lazy<INamedTypeSymbol?> lazyITestFrameworkType;
readonly Lazy<INamedTypeSymbol?> lazyITestMethodType;
readonly Lazy<INamedTypeSymbol?> lazyITestType;
readonly Lazy<INamedTypeSymbol?> lazyITypeInfoType;
readonly Lazy<INamedTypeSymbol?> lazyIXunitSerializableType;
V2AbstractionsContext(
Compilation compilation,
Version version)
{
Version = version;
lazyIAssemblyInfoType = new(() => TypeSymbolFactory.IAssemblyInfo_V2(compilation));
lazyIAttributeInfoType = new(() => TypeSymbolFactory.IAttributeInfo_V2(compilation));
lazyIMessageSinkMessageType = new(() => TypeSymbolFactory.IMessageSinkMessage_V2(compilation));
lazyIMessageSinkType = new(() => TypeSymbolFactory.IMessageSink_V2(compilation));
lazyIMethodInfoType = new(() => TypeSymbolFactory.IMethodInfo_V2(compilation));
lazyIParameterInfoType = new(() => TypeSymbolFactory.IParameterInfo_V2(compilation));
lazyISourceInformationProviderType = new(() => TypeSymbolFactory.ISourceInformationProvider_V2(compilation));
lazyISourceInformationType = new(() => TypeSymbolFactory.ISourceInformation_V2(compilation));
lazyITestAssemblyType = new(() => TypeSymbolFactory.ITestAssembly_V2(compilation));
lazyITestCaseType = new(() => TypeSymbolFactory.ITestCase_V2(compilation));
lazyITestClassType = new(() => TypeSymbolFactory.ITestClass_V2(compilation));
lazyITestCollectionType = new(() => TypeSymbolFactory.ITestCollection_V2(compilation));
lazyITestFrameworkDiscovererType = new(() => TypeSymbolFactory.ITestFrameworkDiscoverer_V2(compilation));
lazyITestFrameworkExecutorType = new(() => TypeSymbolFactory.ITestFrameworkExecutor_V2(compilation));
lazyITestFrameworkType = new(() => TypeSymbolFactory.ITestFramework_V2(compilation));
lazyITestMethodType = new(() => TypeSymbolFactory.ITestMethod_V2(compilation));
lazyITestType = new(() => TypeSymbolFactory.ITest_V2(compilation));
lazyITypeInfoType = new(() => TypeSymbolFactory.ITypeInfo_V2(compilation));
lazyIXunitSerializableType = new(() => TypeSymbolFactory.IXunitSerializable_V2(compilation));
}
/// <summary>
/// Gets a reference to type <c>IAssemblyInfo</c>, if available.
/// </summary>
public INamedTypeSymbol? IAssemblyInfoType =>
lazyIAssemblyInfoType.Value;
/// <summary>
/// Gets a reference to type <c>IAttributeInfo</c>, if available.
/// </summary>
public INamedTypeSymbol? IAttributeInfoType =>
lazyIAttributeInfoType.Value;
/// <summary>
/// Gets a reference to type <c>IMessageSinkMessage</c>, if available.
/// </summary>
public INamedTypeSymbol? IMessageSinkMessageType =>
lazyIMessageSinkMessageType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? IMessageSinkType =>
lazyIMessageSinkType.Value;
/// <summary>
/// Gets a reference to type <c>IMethodInfo</c>, if available.
/// </summary>
public INamedTypeSymbol? IMethodInfoType =>
lazyIMethodInfoType.Value;
/// <summary>
/// Gets a reference to type <c>IParameterInfo</c>, if available.
/// </summary>
public INamedTypeSymbol? IParameterInfoType =>
lazyIParameterInfoType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? ISourceInformationProviderType =>
lazyISourceInformationProviderType.Value;
/// <summary>
/// Gets a reference to type <c>ISourceInformation</c>, if available.
/// </summary>
public INamedTypeSymbol? ISourceInformationType =>
lazyISourceInformationType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? ITestAssemblyType =>
lazyITestAssemblyType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? ITestCaseType =>
lazyITestCaseType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? ITestClassType =>
lazyITestClassType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? ITestCollectionType =>
lazyITestCollectionType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? ITestFrameworkDiscovererType =>
lazyITestFrameworkDiscovererType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? ITestFrameworkExecutorType =>
lazyITestFrameworkExecutorType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? ITestFrameworkType =>
lazyITestFrameworkType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? ITestMethodType =>
lazyITestMethodType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? ITestType =>
lazyITestType.Value;
/// <summary>
/// Gets a reference to type <c>ITypeInfo</c>, if available.
/// </summary>
public INamedTypeSymbol? ITypeInfoType =>
lazyITypeInfoType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? IXunitSerializableType =>
lazyIXunitSerializableType.Value;
/// <summary>
/// Gets the version number of the <c>xunit.abstractions</c> assembly.
/// </summary>
public Version Version { get; }
public static V2AbstractionsContext? Get(
Compilation compilation,
Version? versionOverride = null)
{
Guard.ArgumentNotNull(compilation);
var version =
versionOverride ??
compilation
.ReferencedAssemblyNames
.FirstOrDefault(a => a.Name.Equals("xunit.abstractions", StringComparison.OrdinalIgnoreCase))
?.Version;
return version is null ? null : new(compilation, version);
}
}
================================================
FILE: src/xunit.analyzers/Utility/V2AssertContext.cs
================================================
using System;
using System.Linq;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public class V2AssertContext : IAssertContext
{
internal static readonly Version Version_2_5_0 = new("2.5.0");
internal static readonly Version Version_2_9_3 = new("2.9.3");
readonly Lazy<INamedTypeSymbol?> lazyAssertType;
V2AssertContext(
Compilation compilation,
Version version)
{
Version = version;
lazyAssertType = new(() => TypeSymbolFactory.Assert(compilation));
}
/// <inheritdoc/>
public INamedTypeSymbol? AssertType =>
lazyAssertType.Value;
/// <inheritdoc/>
public bool SupportsAssertFail =>
Version >= Version_2_5_0;
/// <inheritdoc/>
public bool SupportsAssertNullWithPointers =>
false;
/// <inheritdoc/>
public bool SupportsInexactTypeAssertions =>
Version >= Version_2_9_3;
/// <inheritdoc/>
public Version Version { get; }
public static V2AssertContext? Get(
Compilation compilation,
Version? versionOverride = null)
{
Guard.ArgumentNotNull(compilation);
var version =
versionOverride ??
compilation
.ReferencedAssemblyNames
.FirstOrDefault(a => a.Name.Equals("xunit.assert", StringComparison.OrdinalIgnoreCase) || a.Name.Equals("xunit.assert.source", StringComparison.OrdinalIgnoreCase))
?.Version;
return version is null ? null : new(compilation, version);
}
}
================================================
FILE: src/xunit.analyzers/Utility/V2CoreContext.cs
================================================
using System;
using System.Linq;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public class V2CoreContext : ICoreContext
{
internal static readonly Version Version_2_2_0 = new("2.2.0");
internal static readonly Version Version_2_4_0 = new("2.4.0");
readonly Lazy<INamedTypeSymbol?> lazyClassDataAttributeType;
readonly Lazy<INamedTypeSymbol?> lazyCollectionAttributeType;
readonly Lazy<INamedTypeSymbol?> lazyCollectionDefinitionAttributeType;
readonly Lazy<INamedTypeSymbol?> lazyDataAttributeType;
readonly Lazy<INamedTypeSymbol?> lazyFactAttributeType;
readonly Lazy<INamedTypeSymbol?> lazyIClassFixtureType;
readonly Lazy<INamedTypeSymbol?> lazyICollectionFixtureType;
readonly Lazy<INamedTypeSymbol?> lazyInlineDataAttributeType;
readonly Lazy<INamedTypeSymbol?> lazyITestOutputHelperType;
readonly Lazy<INamedTypeSymbol?> lazyMemberDataAttributeType;
readonly Lazy<INamedTypeSymbol?> lazyTheoryAttributeType;
V2CoreContext(
Compilation compilation,
Version version)
{
Version = version;
lazyClassDataAttributeType = new(() => TypeSymbolFactory.ClassDataAttribute(compilation));
lazyCollectionAttributeType = new(() => TypeSymbolFactory.CollectionAttribute(compilation));
lazyCollectionDefinitionAttributeType = new(() => TypeSymbolFactory.CollectionDefinitionAttribute(compilation));
lazyDataAttributeType = new(() => TypeSymbolFactory.DataAttribute_V2(compilation));
lazyFactAttributeType = new(() => TypeSymbolFactory.FactAttribute(compilation));
lazyIClassFixtureType = new(() => TypeSymbolFactory.IClassFixureOfT(compilation));
lazyICollectionFixtureType = new(() => TypeSymbolFactory.ICollectionFixtureOfT(compilation));
lazyInlineDataAttributeType = new(() => TypeSymbolFactory.InlineDataAttribute(compilation));
lazyITestOutputHelperType = new(() => TypeSymbolFactory.ITestOutputHelper_V2(compilation));
lazyMemberDataAttributeType = new(() => TypeSymbolFactory.MemberDataAttribute(compilation));
lazyTheoryAttributeType = new(() => TypeSymbolFactory.TheoryAttribute(compilation));
}
/// <inheritdoc/>
public INamedTypeSymbol? ClassDataAttributeType =>
lazyClassDataAttributeType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? CollectionAttributeType =>
lazyCollectionAttributeType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? CollectionDefinitionAttributeType =>
lazyCollectionDefinitionAttributeType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? DataAttributeType =>
lazyDataAttributeType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? FactAttributeType =>
lazyFactAttributeType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? IClassFixtureType =>
lazyIClassFixtureType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? ICollectionFixtureType =>
lazyICollectionFixtureType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? InlineDataAttributeType =>
lazyInlineDataAttributeType.Value;
/// <summary>
/// Gets a reference to type <c>Xunit.Abstractions.ITestOutputHelper</c>, if available.
/// </summary>
public INamedTypeSymbol? ITestOutputHelperType =>
lazyITestOutputHelperType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? MemberDataAttributeType =>
lazyMemberDataAttributeType.Value;
/// <inheritdoc/>
public INamedTypeSymbol? TheoryAttributeType =>
lazyTheoryAttributeType.Value;
// See: https://github.com/xunit/xunit/pull/1546
/// <inheritdoc/>
public bool TheorySupportsConversionFromStringToDateTimeOffsetAndGuid =>
Version >= Version_2_4_0;
/// <inheritdoc/>
public bool TheorySupportsDefaultParameterValues =>
Version >= Version_2_2_0;
/// <inheritdoc/>
public bool TheorySupportsParameterArrays =>
Version >= Version_2_2_0;
/// <inheritdoc/>
public Version Version { get; }
public static V2CoreContext? Get(
Compilation compilation,
Version? versionOverride = null)
{
Guard.ArgumentNotNull(compilation);
var version =
versionOverride ??
compilation
.ReferencedAssemblyNames
.FirstOrDefault(a => a.Name.Equals("xunit.core", StringComparison.OrdinalIgnoreCase))
?.Version;
return version is null ? null : new(compilation, version);
}
}
================================================
FILE: src/xunit.analyzers/Utility/V2ExecutionContext.cs
================================================
using System;
using System.Linq;
using Microsoft.CodeAnalysis;
namespace Xunit.Analyzers;
public class V2ExecutionContext
{
const string assemblyPrefix = "xunit.execution.";
readonly Lazy<INamedTypeSymbol?> lazyLongLivedMarshalByRefObjectType;
V2ExecutionContext(
Compilation compilation,
string platform,
Version version)
{
Platform = platform;
Version = version;
lazyLongLivedMarshalByRefObjectType = new(() => TypeSymbolFactory.LongLivedMarshalByRefObject_ExecutionV2(compilation));
}
/// <summary>
/// Gets a reference to type <c>Xunit.LongLivedMarshalByRefObject</c>, if available.
/// </summary>
public INamedTypeSymbol? LongLivedMarshalByRefObjectType =>
lazyLongLivedMarshalByRefObjectType.Value;
/// <summary>
/// Gets a description of the target platform for the execution library (i.e., "desktop"). This is
/// typically extracted from the assembly name (i.e., "xunit.execution.desktop").
/// </summary>
public string Platform { get; }
/// <summary>
/// Gets the version number of the execution assembly.
/// </summary>
public Version Version { get; }
public static V2ExecutionContext? Get(
Compilation compilation,
Version? versionOverride = null)
{
Guard.ArgumentNotNull(compilation);
var assembly =
compilation
.ReferencedAssemblyNames
.FirstOrDefault(a => a.Name.StartsWith(assemblyPrefix, StringComparison.OrdinalIgnoreCase));
gitextract_bu8u1mqd/ ├── .config/ │ └── dotnet-tools.json ├── .editorconfig ├── .gitattributes ├── .github/ │ ├── FUNDING.yml │ └── workflows/ │ ├── ci-signed.yaml │ ├── ci-unsigned.yaml │ └── pull-request.yaml ├── .gitignore ├── .gitmodules ├── .vscode/ │ ├── launch.json │ ├── settings.json │ └── tasks.json ├── BUILDING.md ├── LICENSE ├── NuGet.Config ├── README.md ├── build ├── build.ps1 ├── global.json ├── src/ │ ├── Directory.Build.props │ ├── Directory.Build.targets │ ├── common/ │ │ ├── CallerArgumentExpressionAttribute.cs │ │ └── Guard.cs │ ├── compat/ │ │ ├── Directory.Build.props │ │ ├── xunit.analyzers.latest/ │ │ │ └── xunit.analyzers.latest.csproj │ │ ├── xunit.analyzers.latest.fixes/ │ │ │ └── xunit.analyzers.latest.fixes.csproj │ │ └── xunit.analyzers.latest.tests/ │ │ └── xunit.analyzers.latest.tests.csproj │ ├── signing.snk │ ├── xunit.analyzers/ │ │ ├── Properties/ │ │ │ └── AssemblyInfo.cs │ │ ├── Suppressors/ │ │ │ ├── ConsiderCallingConfigureAwaitSuppressor.cs │ │ │ ├── MakeTypesInternalSuppressor.cs │ │ │ ├── NonNullableFieldInitializationSuppressor.cs │ │ │ └── UseAsyncSuffixForAsyncMethodsSuppressor.cs │ │ ├── Utility/ │ │ │ ├── AssertUsageAnalyzerBase.cs │ │ │ ├── Category.cs │ │ │ ├── CodeAnalysisExtensions.cs │ │ │ ├── Constants.cs │ │ │ ├── ConversionChecker.cs │ │ │ ├── Descriptors.Suppressors.cs │ │ │ ├── Descriptors.cs │ │ │ ├── Descriptors.xUnit1xxx.cs │ │ │ ├── Descriptors.xUnit2xxx.cs │ │ │ ├── Descriptors.xUnit3xxx.cs │ │ │ ├── EmptyAssertContext.cs │ │ │ ├── EmptyCommonContext.cs │ │ │ ├── EmptyCoreContext.cs │ │ │ ├── EmptyRunnerUtilityContext.cs │ │ │ ├── EnumerableExtensions.cs │ │ │ ├── IAssertContext.cs │ │ │ ├── ICommonContext.cs │ │ │ ├── ICoreContext.cs │ │ │ ├── IRunnerUtilityContext.cs │ │ │ ├── Serializability.cs │ │ │ ├── SerializabilityAnalyzer.cs │ │ │ ├── SerializableTypeSymbols.cs │ │ │ ├── SymbolExtensions.cs │ │ │ ├── SyntaxExtensions.cs │ │ │ ├── TypeHierarchyComparer.cs │ │ │ ├── TypeSymbolFactory.cs │ │ │ ├── V2AbstractionsContext.cs │ │ │ ├── V2AssertContext.cs │ │ │ ├── V2CoreContext.cs │ │ │ ├── V2ExecutionContext.cs │ │ │ ├── V2RunnerUtilityContext.cs │ │ │ ├── V3AssertContext.cs │ │ │ ├── V3CommonContext.cs │ │ │ ├── V3CoreContext.cs │ │ │ ├── V3RunnerCommonContext.cs │ │ │ ├── V3RunnerUtilityContext.cs │ │ │ ├── XunitContext.cs │ │ │ ├── XunitDiagnosticAnalyzer.cs │ │ │ ├── XunitDiagnosticSuppressor.cs │ │ │ ├── XunitV2DiagnosticAnalyzer.cs │ │ │ ├── XunitV2DiagnosticSuppressor.cs │ │ │ ├── XunitV3DiagnosticAnalyzer.cs │ │ │ └── XunitV3DiagnosticSuppressor.cs │ │ ├── X1000/ │ │ │ ├── ClassDataAttributeMustPointAtValidClass.cs │ │ │ ├── CollectionDefinitionsMustBePublic.cs │ │ │ ├── ConstructorsOnFactAttributeSubclassShouldBePublic.cs │ │ │ ├── DataAttributeShouldBeUsedOnATheory.cs │ │ │ ├── DoNotUseAsyncVoidForTestMethods.cs │ │ │ ├── DoNotUseBlockingTaskOperations.cs │ │ │ ├── DoNotUseConfigureAwait.cs │ │ │ ├── EnsureFixturesHaveASource.cs │ │ │ ├── FactMethodMustNotHaveParameters.cs │ │ │ ├── FactMethodShouldNotHaveTestData.cs │ │ │ ├── InlineDataMustMatchTheoryParameters.cs │ │ │ ├── InlineDataShouldBeUniqueWithinTheory.cs │ │ │ ├── LocalFunctionsCannotBeTestFunctions.cs │ │ │ ├── MemberDataShouldReferenceValidMember.cs │ │ │ ├── PublicMethodShouldBeMarkedAsTest.cs │ │ │ ├── TestClassCannotBeNestedInGenericClass.cs │ │ │ ├── TestClassMustBePublic.cs │ │ │ ├── TestClassShouldHaveTFixtureArgument.cs │ │ │ ├── TestMethodCannotHaveOverloads.cs │ │ │ ├── TestMethodMustNotHaveMultipleFactAttributes.cs │ │ │ ├── TestMethodShouldNotBeSkipped.cs │ │ │ ├── TestMethodSupportedReturnType.cs │ │ │ ├── TheoryDataRowArgumentsShouldBeSerializable.cs │ │ │ ├── TheoryDataShouldNotUseTheoryDataRow.cs │ │ │ ├── TheoryDataTypeArgumentsShouldBeSerializable.cs │ │ │ ├── TheoryMethodCannotHaveDefaultParameter.cs │ │ │ ├── TheoryMethodCannotHaveParamsArray.cs │ │ │ ├── TheoryMethodMustHaveTestData.cs │ │ │ ├── TheoryMethodShouldHaveParameters.cs │ │ │ ├── TheoryMethodShouldUseAllParameters.cs │ │ │ └── UseCancellationToken.cs │ │ ├── X2000/ │ │ │ ├── AssertCollectionContainsShouldNotUseBoolCheck.cs │ │ │ ├── AssertEmptyCollectionCheckShouldNotBeUsed.cs │ │ │ ├── AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecks.cs │ │ │ ├── AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheck.cs │ │ │ ├── AssertEqualGenericShouldNotBeUsedForStringValue.cs │ │ │ ├── AssertEqualLiteralValueShouldBeFirst.cs │ │ │ ├── AssertEqualPrecisionShoulBeInRange.cs │ │ │ ├── AssertEqualShouldNotBeUsedForBoolLiteralCheck.cs │ │ │ ├── AssertEqualShouldNotBeUsedForCollectionSizeCheck.cs │ │ │ ├── AssertEqualShouldNotBeUsedForNullCheck.cs │ │ │ ├── AssertEqualsShouldNotBeUsed.cs │ │ │ ├── AssertIsTypeShouldNotBeUsedForAbstractType.cs │ │ │ ├── AssertIsTypeShouldUseGenericOverloadType.cs │ │ │ ├── AssertNullShouldNotBeCalledOnValueTypes.cs │ │ │ ├── AssertRegexMatchShouldNotUseBoolLiteralCheck.cs │ │ │ ├── AssertSameShouldNotBeCalledOnValueTypes.cs │ │ │ ├── AssertSingleShouldBeUsedForSingleParameter.cs │ │ │ ├── AssertSingleShouldUseTwoArgumentCall.cs │ │ │ ├── AssertStringEqualityCheckShouldNotUseBoolCheck.cs │ │ │ ├── AssertSubstringCheckShouldNotUseBoolCheck.cs │ │ │ ├── AssertThrowsShouldNotBeUsedForAsyncThrowsCheck.cs │ │ │ ├── AssertThrowsShouldUseGenericOverloadCheck.cs │ │ │ ├── AssignableFromAssertionIsConfusinglyNamed.cs │ │ │ ├── AsyncAssertsShouldBeAwaited.cs │ │ │ ├── BooleanAssertsShouldNotBeNegated.cs │ │ │ ├── BooleanAssertsShouldNotBeUsedForSimpleEqualityCheck.cs │ │ │ ├── DoNotUseAssertEmptyWithProblematicTypes.cs │ │ │ ├── SetEqualityAnalyzer.cs │ │ │ └── UseAssertFailInsteadOfBooleanAssert.cs │ │ ├── X3000/ │ │ │ ├── CrossAppDomainClassesMustBeLongLivedMarshalByRefObject.cs │ │ │ ├── DoNotTestForConcreteTypeOfJsonSerializableTypes.cs │ │ │ ├── FactAttributeDerivedClassesShouldProvideSourceInformationConstructor.cs │ │ │ └── SerializableClassMustHaveParameterlessConstructor.cs │ │ ├── xunit.analyzers.csproj │ │ └── xunit.analyzers.nuspec │ ├── xunit.analyzers.fixes/ │ │ ├── Properties/ │ │ │ └── AssemblyInfo.cs │ │ ├── Utility/ │ │ │ ├── AsyncHelper.cs │ │ │ ├── CodeAnalysisExtensions.cs │ │ │ ├── ConvertAttributeCodeAction.cs │ │ │ ├── RemoveAttributesOfTypeCodeAction.cs │ │ │ ├── XunitCodeAction.cs │ │ │ ├── XunitCodeFixProvider.cs │ │ │ └── XunitMemberFixProvider.cs │ │ ├── X1000/ │ │ │ ├── ClassDataAttributeMustPointAtValidClassFixer.cs │ │ │ ├── CollectionDefinitionClassesMustBePublicFixer.cs │ │ │ ├── ConvertToFactFix.cs │ │ │ ├── ConvertToTheoryFix.cs │ │ │ ├── DataAttributeShouldBeUsedOnATheoryFixer.cs │ │ │ ├── DoNotUseAsyncVoidForTestMethodsFixer.cs │ │ │ ├── DoNotUseConfigureAwaitFixer.cs │ │ │ ├── FactMethodMustNotHaveParametersFixer.cs │ │ │ ├── FactMethodShouldNotHaveTestDataFixer.cs │ │ │ ├── InlineDataMustMatchTheoryParameters_ExtraValueFixer.cs │ │ │ ├── InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForIncompatibleParameterFixer.cs │ │ │ ├── InlineDataMustMatchTheoryParameters_TooFewValuesFixer.cs │ │ │ ├── InlineDataShouldBeUniqueWithinTheoryFixer.cs │ │ │ ├── LocalFunctionsCannotBeTestFunctionsFixer.cs │ │ │ ├── MemberDataShouldReferenceValidMember_ExtraValueFixer.cs │ │ │ ├── MemberDataShouldReferenceValidMember_NameOfFixer.cs │ │ │ ├── MemberDataShouldReferenceValidMember_NullShouldNotBeUsedForIncompatibleParameterFixer.cs │ │ │ ├── MemberDataShouldReferenceValidMember_ParamsForNonMethodFixer.cs │ │ │ ├── MemberDataShouldReferenceValidMember_ReturnTypeFixer.cs │ │ │ ├── MemberDataShouldReferenceValidMember_StaticFixer.cs │ │ │ ├── MemberDataShouldReferenceValidMember_VisibilityFixer.cs │ │ │ ├── PublicMethodShouldBeMarkedAsTestFixer.cs │ │ │ ├── RemoveMethodParameterFix.cs │ │ │ ├── TestClassCannotBeNestedInGenericClassFixer.cs │ │ │ ├── TestClassMustBePublicFixer.cs │ │ │ ├── TestClassShouldHaveTFixtureArgumentFixer.cs │ │ │ ├── TestMethodMustNotHaveMultipleFactAttributesFixer.cs │ │ │ ├── TestMethodShouldNotBeSkippedFixer.cs │ │ │ ├── TheoryDataShouldNotUseTheoryDataRowFixer.cs │ │ │ ├── TheoryMethodCannotHaveDefaultParameterFixer.cs │ │ │ └── UseCancellationTokenFixer.cs │ │ ├── X2000/ │ │ │ ├── AssertCollectionContainsShouldNotUseBoolCheckFixer.cs │ │ │ ├── AssertEmptyCollectionCheckShouldNotBeUsedFixer.cs │ │ │ ├── AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksFixer.cs │ │ │ ├── AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckFixer.cs │ │ │ ├── AssertEqualGenericShouldNotBeUsedForStringValueFixer.cs │ │ │ ├── AssertEqualLiteralValueShouldBeFirstFixer.cs │ │ │ ├── AssertEqualPrecisionShouldBeInRangeFixer.cs │ │ │ ├── AssertEqualShouldNotBeUsedForBoolLiteralCheckFixer.cs │ │ │ ├── AssertEqualShouldNotBeUsedForCollectionSizeCheckFixer.cs │ │ │ ├── AssertEqualShouldNotBeUsedForNullCheckFixer.cs │ │ │ ├── AssertEqualsShouldNotBeUsedFixer.cs │ │ │ ├── AssertIsTypeShouldNotBeUsedForAbstractTypeFixer.cs │ │ │ ├── AssertNullShouldNotBeCalledOnValueTypesFixer.cs │ │ │ ├── AssertRegexMatchShouldNotUseBoolLiteralCheckFixer.cs │ │ │ ├── AssertSameShouldNotBeCalledOnValueTypesFixer.cs │ │ │ ├── AssertSingleShouldBeUsedForSingleParameterFixer.cs │ │ │ ├── AssertSingleShouldUseTwoArgumentCallFixer.cs │ │ │ ├── AssertStringEqualityCheckShouldNotUseBoolCheckFixer.cs │ │ │ ├── AssertSubstringCheckShouldNotUseBoolCheckFixer.cs │ │ │ ├── AssertThrowsShouldNotBeUsedForAsyncThrowsCheckFixer.cs │ │ │ ├── AssignableFromAssertionIsConfusinglyNamedFixer.cs │ │ │ ├── AsyncAssertsShouldBeAwaitedFixer.cs │ │ │ ├── BooleanAssertsShouldNotBeNegatedFixer.cs │ │ │ ├── BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckBooleanFixer.cs │ │ │ ├── BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckNonBooleanFixer.cs │ │ │ ├── UseAssertFailInsteadOfBooleanAssertFixer.cs │ │ │ └── UseGenericOverloadFix.cs │ │ ├── X3000/ │ │ │ ├── CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectFixer.cs │ │ │ └── SerializableClassMustHaveParameterlessConstructorFixer.cs │ │ ├── tools/ │ │ │ ├── install.ps1 │ │ │ └── uninstall.ps1 │ │ └── xunit.analyzers.fixes.csproj │ └── xunit.analyzers.tests/ │ ├── Analyzers/ │ │ ├── X1000/ │ │ │ ├── ClassDataAttributeMustPointAtValidClassTests.cs │ │ │ ├── CollectionDefinitionClassesMustBePublicTests.cs │ │ │ ├── ConstructorsOnFactAttributeSubclassShouldBePublicTests.cs │ │ │ ├── DataAttributeShouldBeUsedOnATheoryTests.cs │ │ │ ├── DoNotUseAsyncVoidForTestMethodsTests.cs │ │ │ ├── DoNotUseBlockingTaskOperationsTests.cs │ │ │ ├── DoNotUseConfigureAwaitTests.cs │ │ │ ├── EnsureFixturesHaveASourceTests.cs │ │ │ ├── FactMethodMustNotHaveParametersTests.cs │ │ │ ├── FactMethodShouldNotHaveTestDataTests.cs │ │ │ ├── InlineDataMustMatchTheoryParametersTests.cs │ │ │ ├── InlineDataShouldBeUniqueWithinTheoryTests.cs │ │ │ ├── LocalFunctionsCannotBeTestFunctionsTests.cs │ │ │ ├── MemberDataShouldReferenceValidMemberTests.cs │ │ │ ├── PublicMethodShouldBeMarkedAsTestTests.cs │ │ │ ├── TestClassCannotBeNestedInGenericClassTests.cs │ │ │ ├── TestClassMustBePublicTests.cs │ │ │ ├── TestClassShouldHaveTFixtureArgumentTests.cs │ │ │ ├── TestMethodCannotHaveOverloadsTests.cs │ │ │ ├── TestMethodMustNotHaveMultipleFactAttributesTests.cs │ │ │ ├── TestMethodShouldNotBeSkippedTests.cs │ │ │ ├── TestMethodSupportedReturnTypeTests.cs │ │ │ ├── TheoryDataRowArgumentsShouldBeSerializableTests.cs │ │ │ ├── TheoryDataShouldNotUseTheoryDataRowTests.cs │ │ │ ├── TheoryDataTypeArgumentsShouldBeSerializableTests.cs │ │ │ ├── TheoryMethodCannotHaveDefaultParameterTests.cs │ │ │ ├── TheoryMethodCannotHaveParamsArrayTests.cs │ │ │ ├── TheoryMethodMustHaveTestDataTests.cs │ │ │ ├── TheoryMethodShouldHaveParametersTests.cs │ │ │ ├── TheoryMethodShouldUseAllParametersTests.cs │ │ │ └── UseCancellationTokenTests.cs │ │ ├── X2000/ │ │ │ ├── AssertCollectionContainsShouldNotUseBoolCheckTests.cs │ │ │ ├── AssertEmptyCollectionCheckShouldNotBeUsedTests.cs │ │ │ ├── AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksTests.cs │ │ │ ├── AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckTests.cs │ │ │ ├── AssertEqualGenericShouldNotBeUsedForStringValueTests.cs │ │ │ ├── AssertEqualLiteralValueShouldBeFirstTests.cs │ │ │ ├── AssertEqualPrecisionShouldBeInRangeTest.cs │ │ │ ├── AssertEqualShouldNotBeUsedForBoolLiteralCheckTests.cs │ │ │ ├── AssertEqualShouldNotBeUsedForCollectionSizeCheckTests.cs │ │ │ ├── AssertEqualShouldNotBeUsedForNullCheckTests.cs │ │ │ ├── AssertEqualsShouldNotBeUsedTests.cs │ │ │ ├── AssertIsTypeShouldNotBeUsedForAbstractTypeTests.cs │ │ │ ├── AssertIsTypeShouldUseGenericOverloadTypeTests.cs │ │ │ ├── AssertNullShouldNotBeCalledOnValueTypesTests.cs │ │ │ ├── AssertRegexMatchShouldNotUseBoolLiteralCheckTests.cs │ │ │ ├── AssertSameShouldNotBeCalledOnValueTypesTests.cs │ │ │ ├── AssertSingleShouldBeUsedForSingleParameterTests.cs │ │ │ ├── AssertSingleShouldUseTwoArgumentCallTests.cs │ │ │ ├── AssertStringEqualityCheckShouldNotUseBoolCheckTest.cs │ │ │ ├── AssertSubstringCheckShouldNotUseBoolCheckTests.cs │ │ │ ├── AssertThrowsShouldNotBeUsedForAsyncThrowsCheckTests.cs │ │ │ ├── AssertThrowsShouldUseGenericOverloadCheckTests.cs │ │ │ ├── AssignableFromAssertionIsConfusinglyNamedTests.cs │ │ │ ├── AsyncAssertsShouldBeAwaitedTests.cs │ │ │ ├── BooleanAssertsShouldNotBeNegatedTests.cs │ │ │ ├── BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckTests.cs │ │ │ ├── DoNotUseAssertEmptyWithProblematicTypesTests.cs │ │ │ ├── SetEqualityAnalyzerTests.cs │ │ │ └── UseAssertFailInsteadOfBooleanAssertTests.cs │ │ └── X3000/ │ │ ├── CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectTests.cs │ │ ├── DoNotTestForConcreteTypeOfJsonSerializableTypesTests.cs │ │ ├── FactAttributeDerivedClassesShouldProvideSourceInformationConstructorTests.cs │ │ └── SerializableClassMustHaveParameterlessConstructorTests.cs │ ├── Fixes/ │ │ ├── X1000/ │ │ │ ├── ClassDataAttributeMustPointAtValidClassFixerTests.cs │ │ │ ├── CollectionDefinitionClassesMustBePublicFixerTests.cs │ │ │ ├── ConvertToFactFixTests.cs │ │ │ ├── ConvertToTheoryFixTests.cs │ │ │ ├── DataAttributeShouldBeUsedOnATheoryFixerTests.cs │ │ │ ├── DoNotUseAsyncVoidForTestMethodsFixerTests.cs │ │ │ ├── DoNotUseConfigureAwaitFixerTests.cs │ │ │ ├── FactMethodMustNotHaveParametersFixerTests.cs │ │ │ ├── FactMethodShouldNotHaveTestDataFixerTests.cs │ │ │ ├── InlineDataMustMatchTheoryParameters_ExtraValueFixerTests.cs │ │ │ ├── InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForIncompatibleParameterFixerTests.cs │ │ │ ├── InlineDataMustMatchTheoryParameters_TooFewValuesFixerTests.cs │ │ │ ├── InlineDataShouldBeUniqueWithinTheoryFixerTests.cs │ │ │ ├── LocalFunctionsCannotBeTestFunctionsFixerTests.cs │ │ │ ├── MemberDataShouldReferenceValidMember_ExtraValueFixerTests.cs │ │ │ ├── MemberDataShouldReferenceValidMember_NameOfFixerTests.cs │ │ │ ├── MemberDataShouldReferenceValidMember_NullShouldNotBeUsedForIncompatibleParameterFixerTests.cs │ │ │ ├── MemberDataShouldReferenceValidMember_ParamsForNonMethodFixerTests.cs │ │ │ ├── MemberDataShouldReferenceValidMember_ReturnTypeFixerTests.cs │ │ │ ├── MemberDataShouldReferenceValidMember_StaticFixerTests.cs │ │ │ ├── MemberDataShouldReferenceValidMember_VisibilityFixerTests.cs │ │ │ ├── PublicMethodShouldBeMarkedAsTestFixerTests.cs │ │ │ ├── RemoveMethodParameterFixTests.cs │ │ │ ├── TestClassCannotBeNestedInGenericClassFixerTests.cs │ │ │ ├── TestClassMustBePublicFixerTests.cs │ │ │ ├── TestClassShouldHaveTFixtureArgumentFixerTests.cs │ │ │ ├── TestMethodMustNotHaveMultipleFactAttributesFixerTests.cs │ │ │ ├── TestMethodShouldNotBeSkippedFixerTests.cs │ │ │ ├── TheoryDataShouldNotUseTheoryDataRowFixerTests.cs │ │ │ ├── TheoryMethodCannotHaveDefaultParameterFixerTests.cs │ │ │ └── UseCancellationTokenFixerTests.cs │ │ ├── X2000/ │ │ │ ├── AssertCollectionContainsShouldNotUseBoolCheckFixerTests.cs │ │ │ ├── AssertEmptyCollectionCheckShouldNotBeUsedFixerTests.cs │ │ │ ├── AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksFixerTests.cs │ │ │ ├── AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckFixerTests.cs │ │ │ ├── AssertEqualGenericShouldNotBeUsedForStringValueFixerTests.cs │ │ │ ├── AssertEqualLiteralValueShouldBeFirstFixerTests.cs │ │ │ ├── AssertEqualPrecisionShouldBeInRangeFixerTests.cs │ │ │ ├── AssertEqualShouldNotBeUsedForBoolLiteralCheckFixerTests.cs │ │ │ ├── AssertEqualShouldNotBeUsedForCollectionSizeCheckFixerTests.cs │ │ │ ├── AssertEqualShouldNotBeUsedForNullCheckFixerTests.cs │ │ │ ├── AssertEqualsShouldNotBeUsedFixerTests.cs │ │ │ ├── AssertIsTypeShouldNotBeUsedForAbstractTypeFixerTests.cs │ │ │ ├── AssertNullShouldNotBeCalledOnValueTypesFixerTests.cs │ │ │ ├── AssertRegexMatchShouldNotUseBoolLiteralCheckFixerTests.cs │ │ │ ├── AssertSameShouldNotBeCalledOnValueTypesFixerTests.cs │ │ │ ├── AssertSingleShouldBeUsedForSingleParameterFixerTests.cs │ │ │ ├── AssertSingleShouldUseTwoArgumentCallFixerTests.cs │ │ │ ├── AssertStringEqualityCheckShouldNotUseBoolCheckFixerTests.cs │ │ │ ├── AssertSubstringCheckShouldNotUseBoolCheckFixerTests.cs │ │ │ ├── AssertThrowsShouldNotBeUsedForAsyncThrowsCheckFixerTests.cs │ │ │ ├── AssignableFromAssertionIsConfusinglyNamedFixerTests.cs │ │ │ ├── AsyncAssertsShouldBeAwaitedFixerTests.cs │ │ │ ├── BooleanAssertsShouldNotBeNegatedFixerTests.cs │ │ │ ├── BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckBooleanFixerTests.cs │ │ │ ├── BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckNonBooleanFixerTests.cs │ │ │ ├── UseAssertFailInsteadOfBooleanAssertFixerTests.cs │ │ │ └── UseGenericOverloadFixTests.cs │ │ └── X3000/ │ │ ├── CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectFixerTests.cs │ │ └── SerializableClassMustHaveParameterlessConstructorFixerTests.cs │ ├── Suppressors/ │ │ ├── ConsiderCallingConfigureAwaitSuppressorTests.cs │ │ ├── MakeTypesInternalSuppressorTests.cs │ │ ├── NonNullableFieldInitializationSuppressorTests.cs │ │ └── UseAsyncSuffixForAsyncMethodsSuppressorTests.cs │ ├── Utility/ │ │ ├── 3rdPartyAnalyzers/ │ │ │ ├── AnalyzerLoaderBase.cs │ │ │ ├── CodeAnalysisNetAnalyzers.cs │ │ │ └── VsThreadingAnalyzers.cs │ │ ├── AssertsExtensions/ │ │ │ ├── EmptyException.cs │ │ │ ├── EqualException.cs │ │ │ └── NotEmptyException.cs │ │ ├── CSharpVerifier.Analyzers.RunnerUtility.cs │ │ ├── CSharpVerifier.Analyzers.cs │ │ ├── CSharpVerifier.CodeFixes.RunnerUtility.cs │ │ ├── CSharpVerifier.CodeFixes.cs │ │ ├── CSharpVerifier.Suppressors.cs │ │ ├── CSharpVerifier.cs │ │ ├── CodeAnalyzerHelper.cs │ │ ├── CodeFixProviderDiscovery.cs │ │ ├── XunitVerifier.cs │ │ ├── XunitVerifierV2.cs │ │ └── XunitVerifierV3.cs │ ├── xunit.analyzers.tests.csproj │ └── xunit.runner.json ├── tools/ │ ├── SignClient/ │ │ └── appsettings.json │ └── builder/ │ ├── .vscode/ │ │ ├── launch.json │ │ ├── settings.json │ │ └── tasks.json │ ├── Program.cs │ ├── build.csproj │ ├── models/ │ │ └── BuildContext.cs │ └── targets/ │ ├── Build.cs │ ├── Packages.cs │ ├── SignAssemblies.cs │ └── Test.cs ├── version.json └── xunit.analyzers.sln
Showing preview only (219K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (2090 symbols across 331 files)
FILE: src/common/CallerArgumentExpressionAttribute.cs
class CallerArgumentExpressionAttribute (line 5) | [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
FILE: src/common/Guard.cs
class Guard (line 11) | static class Guard
method ArgumentNotNull (line 21) | public static T ArgumentNotNull<T>(
method ArgumentNotNullOrEmpty (line 40) | public static T ArgumentNotNullOrEmpty<T>(
method ArgumentValid (line 61) | public static void ArgumentValid(
method ArgumentValid (line 78) | public static void ArgumentValid(
FILE: src/xunit.analyzers.fixes/Utility/AsyncHelper.cs
class AsyncHelper (line 13) | public static class AsyncHelper
method ConvertActionTypeToAsyncFunctionType (line 15) | static TypeSyntax? ConvertActionTypeToAsyncFunctionType(
method ConvertFunctionTypeToAsyncFunctionType (line 42) | static TypeSyntax? ConvertFunctionTypeToAsyncFunctionType(
method GetModifiersWithAsyncKeywordAdded (line 81) | public static SyntaxTokenList GetModifiersWithAsyncKeywordAdded(Syntax...
method GetAsyncReturnType (line 97) | public static async Task<TypeSyntax?> GetAsyncReturnType(
method GetAsyncSystemDelegateType (line 147) | public static async Task<TypeSyntax?> GetAsyncSystemDelegateType(
method IsSystemActionType (line 180) | static bool IsSystemActionType(
method IsSystemFunctionType (line 198) | static bool IsSystemFunctionType(
FILE: src/xunit.analyzers.fixes/Utility/CodeAnalysisExtensions.cs
class CodeAnalysisExtensions (line 13) | public static class CodeAnalysisExtensions
method AddConstructor (line 15) | public static async Task<Document> AddConstructor(
method ChangeAccessibility (line 73) | public static async Task<Document> ChangeAccessibility(
method ChangeMemberAccessibility (line 87) | public static async Task<Solution> ChangeMemberAccessibility(
method ChangeMemberStaticModifier (line 107) | public static async Task<Solution> ChangeMemberStaticModifier(
method ChangeMemberType (line 137) | public static async Task<Solution> ChangeMemberType(
method RemoveNode (line 158) | public static async Task<Document> RemoveNode(
method ExtractNodeFromParent (line 172) | public static async Task<Document> ExtractNodeFromParent(
method SetBaseClass (line 199) | public static async Task<Document> SetBaseClass(
FILE: src/xunit.analyzers.fixes/Utility/ConvertAttributeCodeAction.cs
class ConvertAttributeCodeAction (line 10) | public class ConvertAttributeCodeAction(
method GetChangedDocumentAsync (line 27) | protected override async Task<Document> GetChangedDocumentAsync(Cancel...
FILE: src/xunit.analyzers.fixes/Utility/RemoveAttributesOfTypeCodeAction.cs
class RemoveAttributesOfTypeCodeAction (line 10) | public class RemoveAttributesOfTypeCodeAction(
method GetChangedDocumentAsync (line 26) | protected override async Task<Document> GetChangedDocumentAsync(Cancel...
FILE: src/xunit.analyzers.fixes/Utility/XunitCodeAction.cs
class XunitCodeAction (line 10) | internal static class XunitCodeAction
method Create (line 12) | public static CodeAction Create(
method Create (line 24) | public static CodeAction Create(
method Create (line 35) | public static CodeAction Create(
method Create (line 47) | public static CodeAction Create(
method Create (line 60) | public static CodeAction Create(
method UseDifferentAssertMethod (line 73) | public static CodeAction UseDifferentAssertMethod(
FILE: src/xunit.analyzers.fixes/Utility/XunitCodeFixProvider.cs
class XunitCodeFixProvider (line 6) | public abstract class XunitCodeFixProvider(params string[] diagnostics) :
method GetFixAllProvider (line 13) | public override FixAllProvider? GetFixAllProvider() =>
FILE: src/xunit.analyzers.fixes/Utility/XunitMemberFixProvider.cs
class XunitMemberFixProvider (line 8) | public abstract class XunitMemberFixProvider(params string[] diagnostics) :
method RegisterCodeFixesAsync (line 11) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method RegisterCodeFixesAsync (line 44) | public abstract Task RegisterCodeFixesAsync(
FILE: src/xunit.analyzers.fixes/X1000/ClassDataAttributeMustPointAtValidClassFixer.cs
class ClassDataAttributeMustPointAtValidClassFixer (line 13) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method ClassDataAttributeMustPointAtValidClassFixer (line 18) | public ClassDataAttributeMustPointAtValidClassFixer() :
method RegisterCodeFixesAsync (line 22) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method FixClass (line 62) | static async Task<Solution> FixClass(
FILE: src/xunit.analyzers.fixes/X1000/CollectionDefinitionClassesMustBePublicFixer.cs
class CollectionDefinitionClassesMustBePublicFixer (line 11) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method CollectionDefinitionClassesMustBePublicFixer (line 16) | public CollectionDefinitionClassesMustBePublicFixer() :
method GetFixAllProvider (line 20) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 22) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X1000/ConvertToFactFix.cs
class ConvertToFactFix (line 10) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method ConvertToFactFix (line 15) | public ConvertToFactFix() :
method GetFixAllProvider (line 22) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 24) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X1000/ConvertToTheoryFix.cs
class ConvertToTheoryFix (line 10) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method ConvertToTheoryFix (line 15) | public ConvertToTheoryFix() :
method GetFixAllProvider (line 22) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 24) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X1000/DataAttributeShouldBeUsedOnATheoryFixer.cs
class DataAttributeShouldBeUsedOnATheoryFixer (line 14) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method DataAttributeShouldBeUsedOnATheoryFixer (line 20) | public DataAttributeShouldBeUsedOnATheoryFixer() :
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method MarkAsTheoryAsync (line 64) | static async Task<Document> MarkAsTheoryAsync(
FILE: src/xunit.analyzers.fixes/X1000/DoNotUseAsyncVoidForTestMethodsFixer.cs
class DoNotUseAsyncVoidForTestMethodsFixer (line 10) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method DoNotUseAsyncVoidForTestMethodsFixer (line 16) | public DoNotUseAsyncVoidForTestMethodsFixer() :
method GetFixAllProvider (line 23) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 25) | public override async Task RegisterCodeFixesAsync(
FILE: src/xunit.analyzers.fixes/X1000/DoNotUseConfigureAwaitFixer.cs
class DoNotUseConfigureAwaitFixer (line 13) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method DoNotUseConfigureAwaitFixer (line 19) | public DoNotUseConfigureAwaitFixer() :
method GetFixAllProvider (line 23) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 25) | public override async Task RegisterCodeFixesAsync(CodeFixContext context)
FILE: src/xunit.analyzers.fixes/X1000/FactMethodMustNotHaveParametersFixer.cs
class FactMethodMustNotHaveParametersFixer (line 13) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method FactMethodMustNotHaveParametersFixer (line 18) | public FactMethodMustNotHaveParametersFixer() :
method GetFixAllProvider (line 22) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 24) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method RemoveParameters (line 44) | static async Task<Document> RemoveParameters(
FILE: src/xunit.analyzers.fixes/X1000/FactMethodShouldNotHaveTestDataFixer.cs
class FactMethodShouldNotHaveTestDataFixer (line 11) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method FactMethodShouldNotHaveTestDataFixer (line 16) | public FactMethodShouldNotHaveTestDataFixer() :
method GetFixAllProvider (line 20) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 22) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X1000/InlineDataMustMatchTheoryParameters_ExtraValueFixer.cs
class InlineDataMustMatchTheoryParameters_ExtraValueFixer (line 17) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method GetFixAllProvider (line 20) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method InlineDataMustMatchTheoryParameters_ExtraValueFixer (line 24) | public InlineDataMustMatchTheoryParameters_ExtraValueFixer() :
method RegisterCodeFixesAsync (line 28) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method AddTheoryParameter (line 81) | static async Task<Document> AddTheoryParameter(
FILE: src/xunit.analyzers.fixes/X1000/InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForIncompatibleParameterFixer.cs
class InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForIncompatibleParameterFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForIncompatibleParameterFixer (line 20) | public InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForIncom...
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method MakeParameterNullable (line 56) | static async Task<Document> MakeParameterNullable(
FILE: src/xunit.analyzers.fixes/X1000/InlineDataMustMatchTheoryParameters_TooFewValuesFixer.cs
class InlineDataMustMatchTheoryParameters_TooFewValuesFixer (line 16) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method InlineDataMustMatchTheoryParameters_TooFewValuesFixer (line 21) | public InlineDataMustMatchTheoryParameters_TooFewValuesFixer() :
method GetFixAllProvider (line 25) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 27) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method AddDefaultValues (line 61) | static async Task<Document> AddDefaultValues(
method CreateDefaultValueSyntax (line 90) | static SyntaxNode CreateDefaultValueSyntax(
FILE: src/xunit.analyzers.fixes/X1000/InlineDataShouldBeUniqueWithinTheoryFixer.cs
class InlineDataShouldBeUniqueWithinTheoryFixer (line 13) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method InlineDataShouldBeUniqueWithinTheoryFixer (line 18) | public InlineDataShouldBeUniqueWithinTheoryFixer() :
method GetFixAllProvider (line 22) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 24) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method RemoveInlineDataDuplicate (line 42) | static async Task<Document> RemoveInlineDataDuplicate(
FILE: src/xunit.analyzers.fixes/X1000/LocalFunctionsCannotBeTestFunctionsFixer.cs
class LocalFunctionsCannotBeTestFunctionsFixer (line 10) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method LocalFunctionsCannotBeTestFunctionsFixer (line 15) | public LocalFunctionsCannotBeTestFunctionsFixer() :
method GetFixAllProvider (line 19) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 21) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_ExtraValueFixer.cs
class MemberDataShouldReferenceValidMember_ExtraValueFixer (line 17) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method GetFixAllProvider (line 20) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method MemberDataShouldReferenceValidMember_ExtraValueFixer (line 25) | public MemberDataShouldReferenceValidMember_ExtraValueFixer() :
method RegisterCodeFixesAsync (line 29) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method AddMethodParameter (line 120) | static async Task<Document> AddMethodParameter(
FILE: src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_NameOfFixer.cs
class MemberDataShouldReferenceValidMember_NameOfFixer (line 14) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method MemberDataShouldReferenceValidMember_NameOfFixer (line 19) | public MemberDataShouldReferenceValidMember_NameOfFixer() :
method GetFixAllProvider (line 23) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 25) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseNameOf (line 61) | static async Task<Document> UseNameOf(
FILE: src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_NullShouldNotBeUsedForIncompatibleParameterFixer.cs
class MemberDataShouldReferenceValidMember_NullShouldNotBeUsedForIncompatibleParameterFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method GetFixAllProvider (line 18) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method MemberDataShouldReferenceValidMember_NullShouldNotBeUsedForIncompatibleParameterFixer (line 22) | public MemberDataShouldReferenceValidMember_NullShouldNotBeUsedForInco...
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method MakeParameterNullable (line 85) | static async Task<Document> MakeParameterNullable(
FILE: src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_ParamsForNonMethodFixer.cs
class MemberDataShouldReferenceValidMember_ParamsForNonMethodFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method MemberDataShouldReferenceValidMember_ParamsForNonMethodFixer (line 20) | public MemberDataShouldReferenceValidMember_ParamsForNonMethodFixer() :
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method RemoveUnneededArguments (line 51) | static async Task<Document> RemoveUnneededArguments(
FILE: src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_ReturnTypeFixer.cs
class MemberDataShouldReferenceValidMember_ReturnTypeFixer (line 10) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method GetFixAllProvider (line 13) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method MemberDataShouldReferenceValidMember_ReturnTypeFixer (line 18) | public MemberDataShouldReferenceValidMember_ReturnTypeFixer() :
method RegisterCodeFixesAsync (line 22) | public override async Task RegisterCodeFixesAsync(
FILE: src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_StaticFixer.cs
class MemberDataShouldReferenceValidMember_StaticFixer (line 10) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method GetFixAllProvider (line 13) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method MemberDataShouldReferenceValidMember_StaticFixer (line 17) | public MemberDataShouldReferenceValidMember_StaticFixer() :
method RegisterCodeFixesAsync (line 21) | public override Task RegisterCodeFixesAsync(
FILE: src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_VisibilityFixer.cs
class MemberDataShouldReferenceValidMember_VisibilityFixer (line 10) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method GetFixAllProvider (line 13) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method MemberDataShouldReferenceValidMember_VisibilityFixer (line 17) | public MemberDataShouldReferenceValidMember_VisibilityFixer() :
method RegisterCodeFixesAsync (line 21) | public override Task RegisterCodeFixesAsync(
FILE: src/xunit.analyzers.fixes/X1000/PublicMethodShouldBeMarkedAsTestFixer.cs
class PublicMethodShouldBeMarkedAsTestFixer (line 13) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method PublicMethodShouldBeMarkedAsTestFixer (line 20) | public PublicMethodShouldBeMarkedAsTestFixer() :
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method AddAttribute (line 68) | static async Task<Document> AddAttribute(
FILE: src/xunit.analyzers.fixes/X1000/RemoveMethodParameterFix.cs
class RemoveMethodParameterFix (line 10) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method RemoveMethodParameterFix (line 15) | public RemoveMethodParameterFix() :
method RegisterCodeFixesAsync (line 22) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X1000/TestClassCannotBeNestedInGenericClassFixer.cs
class TestClassCannotBeNestedInGenericClassFixer (line 10) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method TestClassCannotBeNestedInGenericClassFixer (line 15) | public TestClassCannotBeNestedInGenericClassFixer() :
method RegisterCodeFixesAsync (line 19) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X1000/TestClassMustBePublicFixer.cs
class TestClassMustBePublicFixer (line 11) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method TestClassMustBePublicFixer (line 16) | public TestClassMustBePublicFixer() :
method GetFixAllProvider (line 20) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 22) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X1000/TestClassShouldHaveTFixtureArgumentFixer.cs
class TestClassShouldHaveTFixtureArgumentFixer (line 11) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method TestClassShouldHaveTFixtureArgumentFixer (line 16) | public TestClassShouldHaveTFixtureArgumentFixer() :
method RegisterCodeFixesAsync (line 20) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X1000/TestMethodMustNotHaveMultipleFactAttributesFixer.cs
class TestMethodMustNotHaveMultipleFactAttributesFixer (line 17) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method TestMethodMustNotHaveMultipleFactAttributesFixer (line 20) | public TestMethodMustNotHaveMultipleFactAttributesFixer() :
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method Key_KeepAttribute (line 26) | public static string Key_KeepAttribute(string simpleTypeName) =>
method RegisterCodeFixesAsync (line 29) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method GetAttributeSimpleName (line 60) | static string GetAttributeSimpleName(string attributeType)
method RemoveAttributes (line 73) | static async Task<Document> RemoveAttributes(
FILE: src/xunit.analyzers.fixes/X1000/TestMethodShouldNotBeSkippedFixer.cs
class TestMethodShouldNotBeSkippedFixer (line 13) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method TestMethodShouldNotBeSkippedFixer (line 18) | public TestMethodShouldNotBeSkippedFixer() :
method GetFixAllProvider (line 22) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 24) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method RemoveArgument (line 44) | static async Task<Document> RemoveArgument(
FILE: src/xunit.analyzers.fixes/X1000/TheoryDataShouldNotUseTheoryDataRowFixer.cs
class TheoryDataShouldNotUseTheoryDataRowFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method GetFixAllProvider (line 21) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 23) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method IsPartOfOnlyTypeDeclaration (line 54) | static bool IsPartOfOnlyTypeDeclaration(GenericNameSyntax genericName)
method ConvertToIEnumerable (line 67) | static async Task<Document> ConvertToIEnumerable(
FILE: src/xunit.analyzers.fixes/X1000/TheoryMethodCannotHaveDefaultParameterFixer.cs
class TheoryMethodCannotHaveDefaultParameterFixer (line 11) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method TheoryMethodCannotHaveDefaultParameterFixer (line 16) | public TheoryMethodCannotHaveDefaultParameterFixer() :
method GetFixAllProvider (line 20) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 22) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X1000/UseCancellationTokenFixer.cs
class UseCancellationTokenFixer (line 16) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method UseCancellationTokenFixer (line 21) | public UseCancellationTokenFixer() :
method GetFixAllProvider (line 25) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 27) | public override async Task RegisterCodeFixesAsync(CodeFixContext context)
method TransformParamsArgument (line 115) | static void TransformParamsArgument(
FILE: src/xunit.analyzers.fixes/X2000/AssertCollectionContainsShouldNotUseBoolCheckFixer.cs
class AssertCollectionContainsShouldNotUseBoolCheckFixer (line 16) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertCollectionContainsShouldNotUseBoolCheckFixer (line 21) | public AssertCollectionContainsShouldNotUseBoolCheckFixer() :
method GetFixAllProvider (line 25) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 27) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseContainsCheck (line 57) | static async Task<Document> UseContainsCheck(
FILE: src/xunit.analyzers.fixes/X2000/AssertEmptyCollectionCheckShouldNotBeUsedFixer.cs
class AssertEmptyCollectionCheckShouldNotBeUsedFixer (line 14) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertEmptyCollectionCheckShouldNotBeUsedFixer (line 20) | public AssertEmptyCollectionCheckShouldNotBeUsedFixer() :
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseEmptyCheck (line 55) | static async Task<Document> UseEmptyCheck(
method AddElementInspector (line 71) | static async Task<Document> AddElementInspector(
FILE: src/xunit.analyzers.fixes/X2000/AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksFixer.cs
class AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method GetFixAllProvider (line 21) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksFixer (line 29) | public AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksFixer() :
method RegisterCodeFixesAsync (line 33) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseCheck (line 74) | static async Task<Document> UseCheck(
FILE: src/xunit.analyzers.fixes/X2000/AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckFixer.cs
class AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckFixer (line 20) | public AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsChe...
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseContainsCheck (line 56) | static async Task<Document> UseContainsCheck(
FILE: src/xunit.analyzers.fixes/X2000/AssertEqualGenericShouldNotBeUsedForStringValueFixer.cs
class AssertEqualGenericShouldNotBeUsedForStringValueFixer (line 14) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertEqualGenericShouldNotBeUsedForStringValueFixer (line 19) | public AssertEqualGenericShouldNotBeUsedForStringValueFixer() :
method GetFixAllProvider (line 23) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 25) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseNonGenericStringEqualCheck (line 47) | static async Task<Document> UseNonGenericStringEqualCheck(
FILE: src/xunit.analyzers.fixes/X2000/AssertEqualLiteralValueShouldBeFirstFixer.cs
class AssertEqualLiteralValueShouldBeFirstFixer (line 14) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertEqualLiteralValueShouldBeFirstFixer (line 19) | public AssertEqualLiteralValueShouldBeFirstFixer() :
method GetFixAllProvider (line 23) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 25) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method SwapArguments (line 45) | static async Task<Document> SwapArguments(
FILE: src/xunit.analyzers.fixes/X2000/AssertEqualPrecisionShouldBeInRangeFixer.cs
class AssertEqualPrecisionShouldBeInRangeFixer (line 16) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertEqualPrecisionShouldBeInRangeFixer (line 21) | public AssertEqualPrecisionShouldBeInRangeFixer() :
method GetFixAllProvider (line 25) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 27) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseRecommendedPrecision (line 57) | static async Task<Document> UseRecommendedPrecision(
FILE: src/xunit.analyzers.fixes/X2000/AssertEqualShouldNotBeUsedForBoolLiteralCheckFixer.cs
class AssertEqualShouldNotBeUsedForBoolLiteralCheckFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertEqualShouldNotBeUsedForBoolLiteralCheckFixer (line 20) | public AssertEqualShouldNotBeUsedForBoolLiteralCheckFixer() :
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseBoolCheckAsync (line 59) | static async Task<Document> UseBoolCheckAsync(
FILE: src/xunit.analyzers.fixes/X2000/AssertEqualShouldNotBeUsedForCollectionSizeCheckFixer.cs
class AssertEqualShouldNotBeUsedForCollectionSizeCheckFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertEqualShouldNotBeUsedForCollectionSizeCheckFixer (line 20) | public AssertEqualShouldNotBeUsedForCollectionSizeCheckFixer() :
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseCollectionSizeAssertionAsync (line 58) | static async Task<Document> UseCollectionSizeAssertionAsync(
method GetExpressionSyntax (line 82) | static ExpressionSyntax? GetExpressionSyntax(InvocationExpressionSynta...
FILE: src/xunit.analyzers.fixes/X2000/AssertEqualShouldNotBeUsedForNullCheckFixer.cs
class AssertEqualShouldNotBeUsedForNullCheckFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertEqualShouldNotBeUsedForNullCheckFixer (line 20) | public AssertEqualShouldNotBeUsedForNullCheckFixer() :
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseNullCheckAsync (line 57) | static async Task<Document> UseNullCheckAsync(
FILE: src/xunit.analyzers.fixes/X2000/AssertEqualsShouldNotBeUsedFixer.cs
class AssertEqualsShouldNotBeUsedFixer (line 12) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertEqualsShouldNotBeUsedFixer (line 17) | public AssertEqualsShouldNotBeUsedFixer() :
method GetFixAllProvider (line 21) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 23) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X2000/AssertIsTypeShouldNotBeUsedForAbstractTypeFixer.cs
class AssertIsTypeShouldNotBeUsedForAbstractTypeFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertIsTypeShouldNotBeUsedForAbstractTypeFixer (line 20) | public AssertIsTypeShouldNotBeUsedForAbstractTypeFixer() :
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseExactMatchFalse (line 75) | static async Task<Document> UseExactMatchFalse(
method UseIsAssignableFrom (line 97) | static async Task<Document> UseIsAssignableFrom(
FILE: src/xunit.analyzers.fixes/X2000/AssertNullShouldNotBeCalledOnValueTypesFixer.cs
class AssertNullShouldNotBeCalledOnValueTypesFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertNullShouldNotBeCalledOnValueTypesFixer (line 20) | public AssertNullShouldNotBeCalledOnValueTypesFixer() :
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method RemoveCall (line 46) | static async Task<Document> RemoveCall(
FILE: src/xunit.analyzers.fixes/X2000/AssertRegexMatchShouldNotUseBoolLiteralCheckFixer.cs
class AssertRegexMatchShouldNotUseBoolLiteralCheckFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertRegexMatchShouldNotUseBoolLiteralCheckFixer (line 20) | public AssertRegexMatchShouldNotUseBoolLiteralCheckFixer() :
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseRegexCheckAsync (line 58) | static async Task<Document> UseRegexCheckAsync(
FILE: src/xunit.analyzers.fixes/X2000/AssertSameShouldNotBeCalledOnValueTypesFixer.cs
class AssertSameShouldNotBeCalledOnValueTypesFixer (line 12) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertSameShouldNotBeCalledOnValueTypesFixer (line 17) | public AssertSameShouldNotBeCalledOnValueTypesFixer() :
method GetFixAllProvider (line 21) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 23) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X2000/AssertSingleShouldBeUsedForSingleParameterFixer.cs
class AssertSingleShouldBeUsedForSingleParameterFixer (line 20) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertSingleShouldBeUsedForSingleParameterFixer (line 26) | public AssertSingleShouldBeUsedForSingleParameterFixer() :
method GetSafeVariableName (line 30) | static string GetSafeVariableName(
method GetLambdaStatements (line 43) | static IEnumerable<SyntaxNode> GetLambdaStatements(SimpleLambdaExpress...
method GetMethodInvocation (line 52) | static SyntaxNode GetMethodInvocation(
method OneItemVariableStatement (line 68) | static LocalDeclarationStatementSyntax OneItemVariableStatement(
method RegisterCodeFixesAsync (line 85) | public override async Task RegisterCodeFixesAsync(CodeFixContext context)
method UseSingleMethod (line 121) | static async Task<Document> UseSingleMethod(
FILE: src/xunit.analyzers.fixes/X2000/AssertSingleShouldUseTwoArgumentCallFixer.cs
class AssertSingleShouldUseTwoArgumentCallFixer (line 14) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertSingleShouldUseTwoArgumentCallFixer (line 19) | public AssertSingleShouldUseTwoArgumentCallFixer() :
method GetFixAllProvider (line 23) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 25) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseCheck (line 45) | static async Task<Document> UseCheck(
FILE: src/xunit.analyzers.fixes/X2000/AssertStringEqualityCheckShouldNotUseBoolCheckFixer.cs
class AssertStringEqualityCheckShouldNotUseBoolCheckFixer (line 16) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertStringEqualityCheckShouldNotUseBoolCheckFixer (line 21) | public AssertStringEqualityCheckShouldNotUseBoolCheckFixer() :
method GetFixAllProvider (line 25) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 27) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseEqualCheck (line 68) | static async Task<Document> UseEqualCheck(
FILE: src/xunit.analyzers.fixes/X2000/AssertSubstringCheckShouldNotUseBoolCheckFixer.cs
class AssertSubstringCheckShouldNotUseBoolCheckFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertSubstringCheckShouldNotUseBoolCheckFixer (line 20) | public AssertSubstringCheckShouldNotUseBoolCheckFixer() :
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseSubstringCheckAsync (line 58) | static async Task<Document> UseSubstringCheckAsync(
FILE: src/xunit.analyzers.fixes/X2000/AssertThrowsShouldNotBeUsedForAsyncThrowsCheckFixer.cs
class AssertThrowsShouldNotBeUsedForAsyncThrowsCheckFixer (line 18) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssertThrowsShouldNotBeUsedForAsyncThrowsCheckFixer (line 23) | public AssertThrowsShouldNotBeUsedForAsyncThrowsCheckFixer() :
method GetAsyncAssertionInvocation (line 27) | static ExpressionSyntax GetAsyncAssertionInvocation(
method GetAsyncAssertionMethodName (line 43) | static SimpleNameSyntax GetAsyncAssertionMethodName(
method GetFunctionFixer (line 53) | static IFunctionFixer? GetFunctionFixer(
method GetParentFunction (line 67) | static SyntaxNode? GetParentFunction(InvocationExpressionSyntax invoca...
method IsFunction (line 72) | static bool IsFunction(SyntaxNode node)
method RegisterCodeFixesAsync (line 83) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method ShouldFixParentFunction (line 117) | static bool ShouldFixParentFunction(
method UseAsyncAssertion (line 137) | static async Task<Document> UseAsyncAssertion(
type IFunctionFixer (line 166) | interface IFunctionFixer
method Fix (line 169) | Task Fix(CancellationToken cancellationToken);
method GetParentFunction (line 170) | SyntaxNode? GetParentFunction();
method ShouldFixParentFunction (line 171) | bool ShouldFixParentFunction(SyntaxNode parentFunction, Cancellation...
class AnonymousFunctionFixer (line 174) | sealed class AnonymousFunctionFixer(
method Fix (line 182) | public async Task Fix(CancellationToken cancellationToken)
method GetAncestors (line 213) | static IEnumerable<IOperation> GetAncestors(IOperation? operation)
method GetConditionalAccessOperation (line 219) | static IConditionalAccessOperation? GetConditionalAccessOperation(IC...
method GetInvocationLocalSymbol (line 227) | static ILocalSymbol? GetInvocationLocalSymbol(IInvocationOperation i...
method GetLocalDeclaration (line 242) | async Task<VariableDeclarationSyntax?> GetLocalDeclaration(Cancellat...
method GetLocalDeclaration (line 255) | static async Task<VariableDeclarationSyntax?> GetLocalDeclaration(
method GetLocalDeclarationSymbol (line 284) | ILocalSymbol? GetLocalDeclarationSymbol(CancellationToken cancellati...
method GetParentFunction (line 305) | public SyntaxNode? GetParentFunction() =>
method ShouldFixParentFunction (line 308) | public bool ShouldFixParentFunction(
class LocalFunctionFixer (line 329) | sealed class LocalFunctionFixer(
method Fix (line 337) | public async Task Fix(CancellationToken cancellationToken)
method GetParentFunction (line 356) | public SyntaxNode? GetParentFunction() =>
method ShouldFixParentFunction (line 359) | public bool ShouldFixParentFunction(
class MethodFixer (line 379) | sealed class MethodFixer(
method Fix (line 386) | public async Task Fix(CancellationToken cancellationToken)
method GetParentFunction (line 405) | public SyntaxNode? GetParentFunction() =>
method ShouldFixParentFunction (line 408) | public bool ShouldFixParentFunction(
FILE: src/xunit.analyzers.fixes/X2000/AssignableFromAssertionIsConfusinglyNamedFixer.cs
class AssignableFromAssertionIsConfusinglyNamedFixer (line 14) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AssignableFromAssertionIsConfusinglyNamedFixer (line 19) | public AssignableFromAssertionIsConfusinglyNamedFixer() :
method GetFixAllProvider (line 23) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 25) | public override async Task RegisterCodeFixesAsync(CodeFixContext context)
method UseIsType (line 53) | static async Task<Document> UseIsType(
FILE: src/xunit.analyzers.fixes/X2000/AsyncAssertsShouldBeAwaitedFixer.cs
class AsyncAssertsShouldBeAwaitedFixer (line 14) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method AsyncAssertsShouldBeAwaitedFixer (line 19) | public AsyncAssertsShouldBeAwaitedFixer() :
method RegisterCodeFixesAsync (line 23) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method UseAsyncAwait (line 51) | static async Task<Document> UseAsyncAwait(
FILE: src/xunit.analyzers.fixes/X2000/BooleanAssertsShouldNotBeNegatedFixer.cs
class BooleanAssertsShouldNotBeNegatedFixer (line 16) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method BooleanAssertsShouldNotBeNegatedFixer (line 21) | public BooleanAssertsShouldNotBeNegatedFixer() :
method GetFixAllProvider (line 25) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 27) | public override async Task RegisterCodeFixesAsync(CodeFixContext context)
method UseSuggestedAssert (line 55) | static async Task<Document> UseSuggestedAssert(
FILE: src/xunit.analyzers.fixes/X2000/BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckBooleanFixer.cs
class BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckBooleanFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckBooleanFixer (line 20) | public BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckBooleanFixer...
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public override async Task RegisterCodeFixesAsync(CodeFixContext context)
method UseSuggestedAssert (line 56) | static async Task<Document> UseSuggestedAssert(
FILE: src/xunit.analyzers.fixes/X2000/BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckNonBooleanFixer.cs
class BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckNonBooleanFixer (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckNonBooleanFixer (line 20) | public BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckNonBooleanFi...
method GetFixAllProvider (line 24) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 26) | public override async Task RegisterCodeFixesAsync(CodeFixContext context)
method UseSuggestedAssert (line 60) | static async Task<Document> UseSuggestedAssert(
FILE: src/xunit.analyzers.fixes/X2000/UseAssertFailInsteadOfBooleanAssertFixer.cs
class UseAssertFailInsteadOfBooleanAssertFixer (line 14) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method UseAssertFailInsteadOfBooleanAssertFixer (line 19) | public UseAssertFailInsteadOfBooleanAssertFixer() :
method GetFixAllProvider (line 23) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 25) | public override async Task RegisterCodeFixesAsync(CodeFixContext context)
method UseAssertFail (line 45) | static async Task<Document> UseAssertFail(
FILE: src/xunit.analyzers.fixes/X2000/UseGenericOverloadFix.cs
class UseGenericOverloadFix (line 15) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method UseGenericOverloadFix (line 20) | public UseGenericOverloadFix() :
method GetFixAllProvider (line 27) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 29) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method RemoveTypeofInvocationAndAddGenericTypeAsync (line 63) | static async Task<Document> RemoveTypeofInvocationAndAddGenericTypeAsync(
FILE: src/xunit.analyzers.fixes/X3000/CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectFixer.cs
class CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectFixer (line 12) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectFixer (line 17) | public CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectFixer() :
method GetFixAllProvider (line 21) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 23) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
FILE: src/xunit.analyzers.fixes/X3000/SerializableClassMustHaveParameterlessConstructorFixer.cs
class SerializableClassMustHaveParameterlessConstructorFixer (line 16) | [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
method SerializableClassMustHaveParameterlessConstructorFixer (line 24) | public SerializableClassMustHaveParameterlessConstructorFixer() :
method GetFixAllProvider (line 28) | public override FixAllProvider? GetFixAllProvider() => BatchFixer;
method RegisterCodeFixesAsync (line 30) | public sealed override async Task RegisterCodeFixesAsync(CodeFixContex...
method CreateOrUpdateConstructor (line 59) | static async Task<Document> CreateOrUpdateConstructor(
FILE: src/xunit.analyzers.tests/Analyzers/X1000/ClassDataAttributeMustPointAtValidClassTests.cs
class ClassDataAttributeMustPointAtValidClassTests (line 6) | public class ClassDataAttributeMustPointAtValidClassTests
class SuccessCases (line 11) | public class SuccessCases
method v2_only (line 13) | [Fact]
method v3_only (line 36) | [Fact]
class X1007_ClassDataAttributeMustPointAtValidClass (line 141) | public class X1007_ClassDataAttributeMustPointAtValidClass
method v2_only (line 143) | [Fact]
method v2_and_v3 (line 166) | [Fact]
method v3_only (line 233) | [Fact]
class X1037_TheoryDataTypeArgumentsMustMatchTestMethodParameters_TooFewTypeParameters (line 293) | public class X1037_TheoryDataTypeArgumentsMustMatchTestMethodParameter...
method v3_only (line 295) | [Fact]
class X1038_TheoryDataTypeArgumentsMustMatchTestMethodParameters_ExtraTypeParameters (line 319) | public class X1038_TheoryDataTypeArgumentsMustMatchTestMethodParameter...
method v3_only (line 321) | [Fact]
class X1039_TheoryDataTypeArgumentsMustMatchTestMethodParameters_IncompatibleTypes (line 357) | public class X1039_TheoryDataTypeArgumentsMustMatchTestMethodParameter...
method v3_only (line 359) | [Fact]
class X1040_TheoryDataTypeArgumentsMustMatchTestMethodParameters_IncompatibleNullability (line 394) | public class X1040_TheoryDataTypeArgumentsMustMatchTestMethodParameter...
method v3_only (line 396) | [Fact]
class X1050_ClassDataTheoryDataRowIsRecommendedForStronglyTypedAnalysis (line 422) | public class X1050_ClassDataTheoryDataRowIsRecommendedForStronglyTyped...
method v3_only (line 424) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/CollectionDefinitionClassesMustBePublicTests.cs
class CollectionDefinitionClassesMustBePublicTests (line 5) | public class CollectionDefinitionClassesMustBePublicTests
method ForPublicClass_DoesNotTrigger (line 7) | [Fact]
method ForFriendOrInternalClass_Triggers (line 18) | [Theory]
method ForPartialClassInSameFile_WhenClassIsPublic_DoesNotTrigger (line 31) | [Theory]
method ForPartialClassInSameFile_WhenClassIsNonPublic_Triggers (line 45) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/ConstructorsOnFactAttributeSubclassShouldBePublicTests.cs
class ConstructorsOnFactAttributeSubclassShouldBePublicTests (line 5) | public class ConstructorsOnFactAttributeSubclassShouldBePublicTests
method DefaultConstructor_DoesNotTrigger (line 7) | [Fact]
method ParameterlessPublicConstructor_DoesNotTrigger (line 29) | [Fact]
method PublicConstructorWithParameters_DoesNotTrigger (line 55) | [Fact]
method PublicConstructorWithOtherConstructors_DoesNotTrigger (line 81) | [Fact]
method InternalConstructor_Triggers (line 111) | [Fact]
method ProtectedInternalConstructor_Triggers (line 136) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/DataAttributeShouldBeUsedOnATheoryTests.cs
class DataAttributeShouldBeUsedOnATheoryTests (line 5) | public class DataAttributeShouldBeUsedOnATheoryTests
method FactMethodWithNoDataAttributes_DoesNotTrigger (line 7) | [Fact]
method FactMethodWithDataAttributes_DoesNotTrigger (line 20) | [Theory]
method TheoryMethodWithDataAttributes_DoesNotTrigger (line 37) | [Theory]
method MethodsWithDataAttributesButNotFactOrTheory_Triggers (line 54) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/DoNotUseAsyncVoidForTestMethodsTests.cs
class DoNotUseAsyncVoidForTestMethodsTests (line 5) | public class DoNotUseAsyncVoidForTestMethodsTests
method NonTestMethod_DoesNotTrigger (line 7) | [Fact]
method NonAsyncTestMethod_DoesNotTrigger (line 23) | [Fact]
method AsyncTaskMethod_DoesNotTrigger (line 38) | [Fact]
method AsyncValueTaskMethod_V3_DoesNotTrigger (line 56) | [Fact]
method AsyncVoidMethod_Triggers (line 74) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/DoNotUseBlockingTaskOperationsTests.cs
class DoNotUseBlockingTaskOperationsTests (line 6) | public class DoNotUseBlockingTaskOperationsTests
method SuccessCase (line 8) | [Fact]
class IValueTaskSource_NonGeneric (line 26) | public class IValueTaskSource_NonGeneric
method GetResult_Triggers (line 28) | [Fact]
class IValueTaskSource_Generic (line 52) | public class IValueTaskSource_Generic
method GetResult_Triggers (line 54) | [Fact]
class Task_NonGeneric (line 78) | public class Task_NonGeneric
class Wait (line 80) | public class Wait
method Wait_Triggers (line 82) | [Fact]
method Wait_BeforeWhenAll_Triggers (line 105) | [Fact]
method Wait_ForUnawaitedTask_Triggers (line 127) | [Fact]
method Wait_InLambda_DoesNotTrigger (line 151) | [Fact]
method Wait_AfterWhenAll_DoesNotTrigger (line 169) | [Fact]
method Wait_AfterWhenAny_DoesNotTrigger (line 193) | [Fact]
class WaitAny_WaitAll (line 217) | public class WaitAny_WaitAll
method WaitMethod_Triggers (line 219) | [Theory]
method WaitMethod_BeforeWhenAll_Triggers (line 244) | [Theory]
method WaitMethod_ForUnawaitedTask_Triggers (line 268) | [Theory]
method WaitMethod_InLambda_DoesNotTrigger (line 295) | [Theory]
method WaitMethod_AfterWhenAll_DoesNotTrigger (line 315) | [Theory]
method WaitMethod_AfterWhenAny_DoesNotTrigger (line 342) | [Theory]
class GetAwaiterGetResult (line 368) | public class GetAwaiterGetResult
method GetResult_Triggers (line 370) | [Fact]
method GetResult_BeforeWhenAll_Triggers (line 393) | [Fact]
method GetResult_OnUnawaitedTask_Triggers (line 415) | [Fact]
method GetResult_InLambda_DoesNotTrigger (line 439) | [Fact]
method GetResult_AfterWhenAll_DoesNotTrigger (line 457) | [Fact]
method GetResult_AfterWhenAny_DoesNotTrigger (line 481) | [Fact]
class Task_Generic (line 506) | public class Task_Generic
class Result (line 508) | public class Result
method Result_Triggers (line 510) | [Fact]
method Result_BeforeWhenAll_Triggers (line 533) | [Fact]
method Result_ForUnawaitedTask_Triggers (line 555) | [Fact]
method Result_InLambda_DoesNotTrigger (line 580) | [Fact]
method Result_AfterWhenAll_DoesNotTrigger (line 598) | [Fact]
method Result_AfterWhenAny_DoesNotTrigger (line 623) | [Fact]
class GetAwaiterGetResult (line 647) | public class GetAwaiterGetResult
method GetResult_Triggers (line 649) | [Fact]
method GetResult_BeforeWhenAll_Triggers (line 672) | [Fact]
method GetResult_OnUnawaitedTask_Triggers (line 695) | [Fact]
method GetResult_InLambda_DoesNotTrigger (line 720) | [Fact]
method GetResult_AfterWhenAll_DoesNotTrigger (line 738) | [Fact]
method GetResult_AfterWhenAny_DoesNotTrigger (line 763) | [Fact]
class ValueTask_NonGeneric (line 788) | public class ValueTask_NonGeneric
method GetResult_Triggers (line 790) | [Fact]
class ValueTask_Generic (line 814) | public class ValueTask_Generic
method Result_Triggers (line 816) | [Fact]
method GetResult_Triggers (line 839) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/DoNotUseConfigureAwaitTests.cs
class DoNotUseConfigureAwaitTests (line 6) | public class DoNotUseConfigureAwaitTests
method NoCall_DoesNotTrigger (line 8) | [Fact]
class ConfigureAwait_Boolean (line 26) | public class ConfigureAwait_Boolean
method NonTestMethod_DoesNotTrigger (line 28) | [Fact]
method True_DoesNotTrigger (line 45) | [Fact]
method InvalidValue_InsideLambda_DoesNotTrigger (line 71) | [Theory]
method InvalidValue_InsideLocalFunction_DoesNotTrigger (line 94) | [Theory]
method InvalidValue_TaskWithAwait_Triggers (line 116) | [Theory]
method InvalidValue_TaskWithoutAwait_Triggers (line 137) | [Theory]
method InvalidValue_TaskOfT_Triggers (line 158) | [Theory]
method InvalidValue_ValueTask_Triggers (line 180) | [Theory]
method InvalidValue_ValueTaskOfT_Triggers (line 202) | [Theory]
class ConfigureAwait_ConfigureAwaitOptions (line 227) | public class ConfigureAwait_ConfigureAwaitOptions
method NonTestMethod_DoesNotTrigger (line 229) | [Fact]
method ValidValue_DoesNotTrigger (line 246) | [Theory]
method InvalidValue_InsideLambda_DoesNotTrigger (line 277) | [Theory]
method InvalidValue_InsideLocalFunction_DoesNotTrigger (line 300) | [Theory]
method InvalidValue_TaskWithAwait_Triggers (line 322) | [Theory]
method InvalidValue_TaskWithoutAwait_Triggers (line 343) | [Theory]
method InvalidValue_TaskOfT_Triggers (line 364) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/EnsureFixturesHaveASourceTests.cs
class EnsureFixturesHaveASourceTests (line 6) | public class EnsureFixturesHaveASourceTests
class NonTestClass (line 8) | public class NonTestClass
method DoesNotTrigger (line 10) | [Fact]
class SupportedNonFixtureData (line 23) | public class SupportedNonFixtureData
method SupportedTypes_V2_DoesNotTrigger (line 25) | [Theory]
method SupportedTypes_V3_DoesNotTrigger (line 44) | [Theory]
method OptionalParameter_DoesNotTrigger (line 63) | [Fact]
method ParamsParameter_DoesNotTrigger (line 79) | [Fact]
class ClassFixtures (line 96) | public class ClassFixtures
method BaseClassParameter_DerivedClassFixture_DoesNotTrigger (line 98) | [Theory]
method ClassFixtureOnCollectionDefinition_DoesNotTrigger (line 138) | [Fact]
method MissingClassFixtureDefinition_Triggers (line 158) | [Fact]
class CollectionFixtures (line 175) | public class CollectionFixtures
method NoFixture_DoesNotTrigger (line 177) | [Theory]
method WithInheritedFixture_DoesNotTrigger (line 197) | [Theory]
method WithGenericFixture_TriggersWithV2_DoesNotTriggerWithV3 (line 235) | [Fact]
method WithInheritedGenericFixture_TriggersWithV2_DoesNotTriggerWithV3 (line 260) | [Fact]
method WithFixture_SupportsDerivation (line 289) | [Theory]
method WithFixture_WithDefinition_DoesNotTrigger (line 314) | [Fact]
method WithFixture_WithoutCollectionFixtureInterface_Triggers (line 334) | [Theory]
class AssemblyFixtures (line 357) | public class AssemblyFixtures
method WithAssemblyFixture_DoesNotTrigger (line 359) | [Fact]
class MixedFixtures (line 378) | public class MixedFixtures
method WithClassFixture_WithCollection_DoesNotTrigger (line 380) | [Theory]
method WithMixedClassAndCollectionFixture_AndSupportedNonFixture_DoesNotTrigger (line 402) | [Fact]
method MissingClassFixture_Triggers (line 426) | [Fact]
method MissingCollectionFixture_Triggers (line 449) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/FactMethodMustNotHaveParametersTests.cs
class FactMethodMustNotHaveParametersTests (line 5) | public class FactMethodMustNotHaveParametersTests
method FactWithNoParameters_DoesNotTrigger (line 7) | [Fact]
method TheoryWithParameters_DoesNotTrigger (line 20) | [Fact]
method FactWithParameters_Triggers (line 33) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/FactMethodShouldNotHaveTestDataTests.cs
class FactMethodShouldNotHaveTestDataTests (line 5) | public class FactMethodShouldNotHaveTestDataTests
method FactWithNoDataAttributes_DoesNotTrigger (line 7) | [Fact]
method TheoryWithDataAttributes_DoesNotTrigger (line 20) | [Theory]
method FactDerivedMethodWithDataAttributes_DoesNotTrigger (line 37) | [Theory]
method FactWithDataAttributes_Triggers (line 55) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/InlineDataMustMatchTheoryParametersTests.cs
class InlineDataMustMatchTheoryParametersTests (line 12) | public class InlineDataMustMatchTheoryParametersTests
class NonErrors (line 14) | public class NonErrors
method MethodUsingParamsArgument (line 16) | [Fact]
method MethodUsingNullParamsArgument_NonNullable (line 30) | [Fact]
method MethodUsingNullParamsArgument_Nullable (line 44) | [Fact]
method MethodUsingNormalAndParamsArgument (line 60) | [Fact]
method MethodUsingNormalAndNullParamsArgument_NonNullable (line 74) | [Fact]
method MethodUsingNormalAndNullParamsArgument_Nullable (line 88) | [Fact]
method MethodUsingNormalAndUnusedParamsArgument (line 104) | [Fact]
method MethodUsingEmptyArrayForParams (line 118) | [Fact]
method MethodUsingMixedArgumentsAndEmptyArrayForParams (line 132) | [Fact]
method MethodUsingNonEmptyArrayForParams (line 146) | [Fact]
method MethodUsingMixedArgumentsAndNonEmptyArrayForParams (line 160) | [Fact]
method UsingParameters (line 174) | [Fact]
method UsingParametersWithDefaultValues (line 188) | [Fact]
method UsingParametersWithDefaultValuesAndParamsArgument (line 202) | [Fact]
method UsingParameterWithOptionalAttribute (line 216) | [Fact]
method UsingMultipleParametersWithOptionalAttributes (line 230) | [Fact]
method UsingExplicitArray (line 248) | [Fact]
method UsingExplicitNamedArray (line 262) | [Fact]
method UsingImplicitArray (line 276) | [Fact]
method UsingImplicitNamedArray (line 290) | [Fact]
method EmptyArray (line 304) | [Fact]
method DecimalValue (line 319) | [Fact]
class X1009_TooFewValues (line 337) | public class X1009_TooFewValues
method IgnoresFact (line 339) | [Fact]
method NoArguments (line 353) | [Theory]
method TooFewArguments (line 369) | [Fact]
method TooFewArguments_WithParams (line 383) | [Fact]
class X1010_IncompatibleValueType (line 398) | public class X1010_IncompatibleValueType
method MethodUsingIncompatibleExplicitArrayForParams (line 400) | [Fact]
class NumericParameter (line 414) | public class NumericParameter : X1010_IncompatibleValueType
method CompatibleNumericValue_NonNullableType (line 437) | [Theory]
method CompatibleNumericValue_NullableType (line 454) | [Theory]
method BooleanValue_NumericType (line 471) | [Theory]
method CharValue_NumericType (line 489) | [Theory]
method EnumValue_NumericType (line 504) | [Theory]
class BooleanParameter (line 521) | public class BooleanParameter : X1010_IncompatibleValueType
method FromBooleanValue_ToNonNullable (line 523) | [Theory]
method FromBooleanValue_ToNullable (line 538) | [Theory]
method FromIncompatibleValue (line 553) | [Theory]
class CharParameter (line 574) | public class CharParameter : X1010_IncompatibleValueType
method FromCharOrIntegerValue_ToNonNullable (line 576) | [Theory]
method FromCharOrIntegerValue_ToNullable (line 592) | [Theory]
method FromIncompatibleValue (line 608) | [Theory]
class EnumParameter (line 629) | public class EnumParameter : X1010_IncompatibleValueType
method FromEnumValue_ToNonNullable (line 631) | [Fact]
method FromEnumValue_ToNullable (line 645) | [Fact]
method FromIncompatibleValue (line 659) | [Theory]
class TypeParameter (line 680) | public class TypeParameter : X1010_IncompatibleValueType
method FromTypeValue (line 682) | [Theory]
method FromTypeValue_ToParams (line 698) | [Theory]
method FromIncompatibleValue (line 714) | [Theory]
method FromIncompatibleValue_ToParams (line 734) | [Theory]
class StringParameter (line 755) | public class StringParameter : X1010_IncompatibleValueType
method FromStringValue (line 757) | [Theory]
method FromIncompatibleValue (line 773) | [Theory]
class InterfaceParameter (line 794) | public class InterfaceParameter : X1010_IncompatibleValueType
method FromTypeImplementingInterface (line 796) | [Theory]
method FromIncompatibleValue (line 813) | [Theory]
class ObjectParameter (line 835) | public class ObjectParameter : X1010_IncompatibleValueType
method FromAnyValue (line 837) | [Theory]
method FromAnyValue_ToParams (line 858) | [Theory]
class GenericParameter (line 880) | public class GenericParameter : X1010_IncompatibleValueType
method FromAnyValue_NoConstraint (line 882) | [Theory]
method FromValueTypeValue_WithStructConstraint (line 903) | [Theory]
method FromReferenceTypeValue_WithStructConstraint (line 921) | [Theory]
method FromReferenceTypeValue_WithClassConstraint (line 938) | [Theory]
method FromValueTypeValue_WithClassConstraint (line 955) | [Theory]
method FromCompatibleValue_WithTypeConstraint (line 974) | [Theory]
method TypeConstraint_WithCRTP (line 992) | [Fact]
method FromIncompatibleValue_WithTypeConstraint (line 1017) | [Theory]
method FromIncompatibleArray (line 1039) | [Fact]
method FromCompatibleArray (line 1054) | [Fact]
method FromNegativeInteger_ToUnsignedInteger (line 1068) | [Theory]
method FromLongMinValue_ToUnsignedInteger (line 1086) | [Theory]
class DateTimeLikeParameter (line 1103) | public class DateTimeLikeParameter : X1010_IncompatibleValueType
method NonStringValue (line 1117) | [Theory]
method StringValue_ToDateTime (line 1139) | [Theory]
method StringValue_ToDateTimeOffset (line 1148) | [Theory]
method StringValue_ToDateTimeOffset_Pre240 (line 1157) | [Theory]
method CreateSourceWithStringConst (line 1167) | static string CreateSourceWithStringConst(
class GuidParameter (line 1180) | public class GuidParameter : X1010_IncompatibleValueType
method NonStringValue (line 1191) | [Theory]
method StringValue (line 1210) | [Theory]
method StringValue_Pre240 (line 1219) | [Theory]
method CreateSource (line 1229) | static string CreateSource(string data) => string.Format(/* lang=c...
class UserDefinedConversionOperators (line 1238) | public class UserDefinedConversionOperators : X1010_IncompatibleValu...
method SupportsImplicitConversion (line 1240) | [Fact]
method SupportsExplicitConversion (line 1262) | [Fact]
class X1011_ExtraValue (line 1330) | public class X1011_ExtraValue
method IgnoresFact (line 1332) | [Fact]
method ExtraArguments (line 1346) | [Fact]
class X1012_NullShouldNotBeUsedForIncompatibleParameter (line 1366) | public class X1012_NullShouldNotBeUsedForIncompatibleParameter
method IgnoresFact (line 1368) | [Fact]
method SingleNullValue (line 1382) | [Theory]
method NonNullableValueTypes (line 1399) | [Theory]
method NullableValueTypes (line 1419) | [Theory]
method ReferenceTypes (line 1434) | [Theory]
method NonNullableReferenceTypes (line 1451) | [Theory]
method NullableReferenceTypes (line 1471) | [Theory]
method NullableParamsReferenceTypes (line 1490) | [Theory]
method NonNullableParamsReferenceTypes (line 1510) | [Theory]
class Analyzer_v2_Pre240 (line 1555) | internal class Analyzer_v2_Pre240 : InlineDataMustMatchTheoryParameters
method CreateXunitContext (line 1557) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Analyzers/X1000/InlineDataShouldBeUniqueWithinTheoryTests.cs
class InlineDataShouldBeUniqueWithinTheoryTests (line 6) | public abstract class InlineDataShouldBeUniqueWithinTheoryTests
class ForNonRelatedToInlineDataMethod (line 8) | public class ForNonRelatedToInlineDataMethod : InlineDataShouldBeUniqu...
method WithNoDataAttributes_DoesNotTrigger (line 10) | [Fact]
method WithDataAttributesOtherThanInline_DoesNotTrigger (line 23) | [Theory]
class ForUniqueInlineDataMethod (line 41) | public class ForUniqueInlineDataMethod : InlineDataShouldBeUniqueWithi...
method NonTheory_SingleInlineData_DoesNotTrigger (line 43) | [Fact]
method NonTheory_DoubledInlineData_DoesNotTrigger (line 57) | [Fact]
method SingleInlineData_DoesNotTrigger (line 72) | [Fact]
method MultipleInlineData_DifferentValues_DoesNotTrigger (line 86) | [Fact]
method UniqueValues_WithParamsInitializerValues_DoesNotTrigger (line 101) | [Theory]
method UniqueValues_WithOverridingDefaultValues_DoesNotTrigger (line 120) | [Fact]
method NullAndEmpty_DoesNotTrigger (line 135) | [Fact]
method NullAndArray_DoesNotTrigger (line 150) | [Fact]
method ArrayOrderVariance_DoesNotTrigger (line 165) | [Fact]
class ForDuplicatedInlineDataMethod (line 185) | public class ForDuplicatedInlineDataMethod : InlineDataShouldBeUniqueW...
method DoubleEmptyInlineData_Triggers (line 187) | [Fact]
method DoubleNullInlineData_Triggers (line 203) | [Fact]
method DoubleValues_Triggers (line 219) | [Fact]
method ValueFromConstant_Triggers (line 235) | [Fact]
method TwoParams_RawValuesVsArgumentArray_Triggers (line 253) | [Theory]
method ParamsArray_RawValuesVsArgumentArray_Triggers (line 271) | [Theory]
method DoubledArgumentArrays_Triggers (line 289) | [Fact]
method DoubledComplexValuesForObject_Triggers (line 305) | [Fact]
method DoubledComplexValues_RawValuesVsArgumentArray_Triggers (line 321) | [Fact]
method DefaultValueVsExplicitValue_Triggers (line 340) | [Theory]
method ExplicitValueVsDefaultValue_Triggers (line 357) | [Theory]
method DefaultValueVsDefaultValue_Triggers (line 374) | [Theory]
method DefaultValueVsNull_Triggers (line 391) | [Theory]
method Null_RawValuesVsExplicitArray_Triggers (line 413) | [Fact]
method DefaultOfStruct_Triggers (line 429) | [Theory]
method DefaultOfString_Triggers (line 451) | [Theory]
method Tripled_TriggersTwice (line 473) | [Fact]
method DoubledTwice_TriggersTwice (line 494) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/LocalFunctionsCannotBeTestFunctionsTests.cs
class LocalFunctionsCannotBeTestFunctionsTests (line 6) | public class LocalFunctionsCannotBeTestFunctionsTests
method NoTestAttribute_DoesNotTrigger (line 8) | [Fact]
method TestAttribute_Triggers (line 22) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/MemberDataShouldReferenceValidMemberTests.cs
class MemberDataShouldReferenceValidMemberTests (line 6) | public class MemberDataShouldReferenceValidMemberTests
class X1014_MemberDataShouldUseNameOfOperator (line 8) | public class X1014_MemberDataShouldUseNameOfOperator
method V2_and_V3 (line 10) | [Fact]
class X1015_MemberDataMustReferenceExistingMember (line 44) | public class X1015_MemberDataMustReferenceExistingMember
method V2_and_V3 (line 46) | [Fact]
method DoesNotTrigger_WhenMemberExistsOnDerivedType_AndBaseTypeIsAbstract (line 77) | [Fact]
class X1016_MemberDataMustReferencePublicMember (line 104) | public class X1016_MemberDataMustReferencePublicMember
method V2_and_V3 (line 106) | [Fact]
class X1017_MemberDataMustReferenceStaticMember (line 152) | public class X1017_MemberDataMustReferenceStaticMember
method V2_and_V3 (line 154) | [Fact]
class X1018_MemberDataMustReferenceValidMemberKind (line 174) | public class X1018_MemberDataMustReferenceValidMemberKind
method V2_and_V3 (line 176) | [Fact]
class X1019_MemberDataMustReferenceMemberOfValidType (line 219) | public class X1019_MemberDataMustReferenceMemberOfValidType
method V2_and_V3 (line 224) | [Fact]
method V3_only (line 381) | [Fact]
class X1020_MemberDataPropertyMustHaveGetter (line 433) | public class X1020_MemberDataPropertyMustHaveGetter
method V2_and_V3 (line 435) | [Fact]
class X1021_MemberDataNonMethodShouldNotHaveParameters (line 463) | public class X1021_MemberDataNonMethodShouldNotHaveParameters
method V2_and_V3 (line 465) | [Fact]
class X1034_MemberDataArgumentsMustMatchMethodParameters_NullShouldNotBeUsedForIncompatibleParameter (line 518) | public class X1034_MemberDataArgumentsMustMatchMethodParameters_NullSh...
method V2_and_V3 (line 520) | [Fact]
class X1035_MemberDataArgumentsMustMatchMethodParameters_IncompatibleValueType (line 566) | public class X1035_MemberDataArgumentsMustMatchMethodParameters_Incomp...
method V2_and_V3 (line 568) | [Fact]
class X1036_MemberDataArgumentsMustMatchMethodParameters_ExtraValue (line 616) | public class X1036_MemberDataArgumentsMustMatchMethodParameters_ExtraV...
method V2_and_V3 (line 618) | [Fact]
class X1037_TheoryDataTypeArgumentsMustMatchTestMethodParameters_TooFewTypeParameters (line 649) | public class X1037_TheoryDataTypeArgumentsMustMatchTestMethodParameter...
method V2_and_V3 (line 651) | [Fact]
method V3_only (line 698) | [Fact]
class X1038_TheoryDataTypeArgumentsMustMatchTestMethodParameters_ExtraTypeParameters (line 729) | public class X1038_TheoryDataTypeArgumentsMustMatchTestMethodParameter...
method V2_and_V3 (line 731) | [Fact]
method V3_only (line 1030) | [Fact]
class X1039_TheoryDataTypeArgumentsMustMatchTestMethodParameters_IncompatibleTypes (line 1127) | public class X1039_TheoryDataTypeArgumentsMustMatchTestMethodParameter...
method V2_and_V3 (line 1129) | [Fact]
method V3_only (line 1243) | [Fact]
class X1040_TheoryDataTypeArgumentsMustMatchTestMethodParameters_IncompatibleNullability (line 1358) | public class X1040_TheoryDataTypeArgumentsMustMatchTestMethodParameter...
method V2_and_V3 (line 1360) | [Fact]
method V3_only (line 1391) | [Fact]
class X1042_MemberDataTheoryDataIsRecommendedForStronglyTypedAnalysis (line 1424) | public class X1042_MemberDataTheoryDataIsRecommendedForStronglyTypedAn...
method V2_and_V3 (line 1429) | [Fact]
method V3_only (line 1480) | [Fact]
class X1053_MemberDataMemberMustBeStaticallyWrittenTo (line 1589) | public class X1053_MemberDataMemberMustBeStaticallyWrittenTo
method Initializers_AndGetExpressions_MarkAsWrittenTo (line 1591) | [Fact]
method SimpleCase_GeneratesResult (line 1625) | [Fact]
method OutOfScopeCase_GeneratesResult (line 1656) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/PublicMethodShouldBeMarkedAsTestTests.cs
class PublicMethodShouldBeMarkedAsTestTests (line 5) | public class PublicMethodShouldBeMarkedAsTestTests
method PublicMethodInNonTestClass_DoesNotTrigger (line 7) | [Fact]
method TestMethods_DoesNotTrigger (line 19) | [Theory]
method IDisposableDisposeMethod_DoesNotTrigger (line 34) | [Fact]
method PublicAbstractMethod_DoesNotTrigger (line 49) | [Fact]
method DerivedMethodWithFactOnBaseAbstractMethod_DoesNotTrigger (line 64) | [Fact]
method PublicAbstractMethodMarkedWithFact_DoesNotTrigger (line 84) | [Fact]
method IDisposableDisposeMethodOverrideFromParentClass_DoesNotTrigger (line 100) | [Fact]
method IDisposableDisposeMethodOverrideFromParentClassWithRepeatedInterfaceDeclaration_DoesNotTrigger (line 119) | [Fact]
method IDisposableDisposeMethodOverrideFromGrandParentClass_DoesNotTrigger (line 138) | [Fact]
method IAsyncLifetimeMethods_V2_DoesNotTrigger (line 159) | [Fact]
method IAsyncLifetimeMethods_V3_DoesNotTrigger (line 182) | [Fact]
method PublicMethodMarkedWithAttributeWhichIsMarkedWithIgnoreXunitAnalyzersRule1013_DoesNotTrigger (line 205) | [Fact]
method PublicMethodMarkedWithAttributeWhichInheritsFromAttributeMarkedWithIgnoreXunitAnalyzersRule1013_Triggers (line 226) | [Fact]
method PublicMethodWithoutParametersInTestClass_Triggers (line 250) | [Theory]
method PublicMethodWithParametersInTestClass_Triggers (line 268) | [Theory]
method OverridenMethod_FromParentNonTestClass_DoesNotTrigger (line 286) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TestClassCannotBeNestedInGenericClassTests.cs
class TestClassCannotBeNestedInGenericClassTests (line 5) | public class TestClassCannotBeNestedInGenericClassTests
method WhenTestClassIsNestedInOpenGenericType_Triggers (line 7) | [Fact]
method WhenDerivedTestClassIsNestedInOpenGenericType_Triggers (line 22) | [Fact]
method WhenTestClassIsNestedInClosedGenericType_DoesNotTrigger (line 39) | [Fact]
method WhenNestedClassIsNotTestClass_DoesNotTrigger (line 56) | [Fact]
method WhenTestClassIsNotNestedInOpenGenericType_DoesNotTrigger (line 68) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TestClassMustBePublicTests.cs
class TestClassMustBePublicTests (line 5) | public class TestClassMustBePublicTests
method ForPublicClass_DoesNotTrigger (line 13) | [Fact]
method ForFriendOrInternalClass_Triggers (line 26) | [Theory]
method ForPartialClassInSameFile_WhenClassIsPublic_DoesNotTrigger (line 42) | [Theory]
method ForPartialClassInOtherFiles_WhenClassIsPublic_DoesNotTrigger (line 62) | [Theory]
method ForPartialClassInSameFile_WhenClassIsNonPublic_Triggers (line 83) | [Theory]
method ForPartialClassInOtherFiles_WhenClassIsNonPublic_Triggers (line 107) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TestClassShouldHaveTFixtureArgumentTests.cs
class TestClassShouldHaveTFixtureArgumentTests (line 5) | public class TestClassShouldHaveTFixtureArgumentTests
method ForClassWithIClassFixtureWithoutConstructorArg_Triggers (line 13) | [Theory]
method ForClassWithIClassFixtureWithConstructorArg_DoesNotTrigger (line 32) | [Theory]
method ForClassWithIClassFixtureWithConstructorMultipleArg_DoesNotTrigger (line 52) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TestMethodCannotHaveOverloadsTests.cs
class TestMethodCannotHaveOverloadsTests (line 5) | public class TestMethodCannotHaveOverloadsTests
method ForInstanceMethodOverloads_InSameInstanceClass_Triggers (line 7) | [Fact]
method ForStaticMethodOverloads_InSameStaticClass_Triggers (line 28) | [Fact]
method ForInstanceMethodOverload_InDerivedClass_Triggers (line 49) | [Fact]
method ForStaticAndInstanceMethodOverload_Triggers (line 75) | [Fact]
method ForMethodOverrides_DoesNotTrigger (line 95) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TestMethodMustNotHaveMultipleFactAttributesTests.cs
class TestMethodMustNotHaveMultipleFactAttributesTests (line 5) | public class TestMethodMustNotHaveMultipleFactAttributesTests
method MethodWithSingleAttribute_DoesNotTrigger (line 7) | [Theory]
method MethodWithFactAndTheory_Triggers (line 22) | [Fact]
method MethodWithFactAndCustomFactAttribute_Triggers (line 36) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TestMethodShouldNotBeSkippedTests.cs
class TestMethodShouldNotBeSkippedTests (line 6) | public class TestMethodShouldNotBeSkippedTests
method NotSkippedTest_DoesNotTrigger (line 8) | [Theory]
method SkippedTest_Triggers (line 23) | [Theory]
method SkippedTestWhenConditionIsTrue_V3_DoesNotTrigger (line 38) | [Theory]
method SkippedTestUnlessConditionIsTrue_V3_DoesNotTrigger (line 54) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TestMethodSupportedReturnTypeTests.cs
class TestMethodSupportedReturnTypeTests (line 6) | public class TestMethodSupportedReturnTypeTests
method NonTestMethod_DoesNotTrigger (line 8) | [Fact]
method InvalidReturnType_Triggers (line 22) | [Theory]
method ValueTask_TriggersInV2_DoesNotTriggerInV3 (line 46) | [Fact]
method CustomTestAttribute_DoesNotTrigger (line 66) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TheoryDataRowArgumentsShouldBeSerializableTests.cs
class TheoryDataRowArgumentsShouldBeSerializableTests (line 10) | public sealed class TheoryDataRowArgumentsShouldBeSerializableTests
method ParamArrayArguments_NotUsingTheoryDataRow_DoesNotTrigger (line 12) | [Fact]
method IntrinsicallySerializableValue_DoesNotTrigger (line 32) | [Theory]
method IXunitSerializableValue_DoesNotTrigger (line 91) | [Theory]
method IXunitSerializerValue_DoesNotTrigger (line 131) | [Theory]
method KnownNonSerializableValue_Triggers1046 (line 182) | [Theory]
method KnownNonSerializableValue_Constructable_Triggers1046 (line 226) | [Theory]
method MaybeNonSerializableValue_Triggers1047 (line 262) | [Theory]
method MaybeNonSerializableValue_Constructable_Triggers1047 (line 308) | [Theory]
method IFormattableAndIParseable_DoesNotTrigger (line 343) | [Fact]
method Tuples_OnlySupportedByV3_3_0_1 (line 439) | [Fact]
class Analyzer_v3_Pre301 (line 487) | internal class Analyzer_v3_Pre301 : TheoryDataRowArgumentsShouldBeSeri...
method CreateXunitContext (line 489) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TheoryDataShouldNotUseTheoryDataRowTests.cs
class TheoryDataShouldNotUseTheoryDataRowTests (line 6) | public class TheoryDataShouldNotUseTheoryDataRowTests
method AcceptanceTest (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TheoryDataTypeArgumentsShouldBeSerializableTests.cs
class TheoryDataTypeArgumentsShouldBeSerializableTests (line 10) | public class TheoryDataTypeArgumentsShouldBeSerializableTests
method TheoryDataClass (line 12) | public static TheoryData<string, string, string, string> TheoryDataClass(
method TheoryDataClass (line 18) | public static TheoryData<string, string, string, string> TheoryDataClass(
method TheoryDataMembers (line 45) | public static TheoryData<string, string, string> TheoryDataMembers(str...
method TheoryDataMembersWithDiscoveryEnumerationDisabled (line 61) | public static TheoryData<string, string, string> TheoryDataMembersWith...
class NoDiagnostic (line 75) | public sealed class NoDiagnostic : TheoryDataTypeArgumentsShouldBeSeri...
method GivenMethodWithoutAttributes_DoesNotTrigger (line 77) | [Fact]
method GivenFact_DoesNotTrigger (line 89) | [Fact]
method GivenTheory_WithoutTheoryDataAsDataSource_DoesNotTrigger (line 102) | [Fact]
method GivenTheory_WithSerializableTheoryDataMember_DoesNotTrigger (line 130) | [Theory]
method GivenTheory_WithIXunitSerializableTheoryDataMember_DoesNotTrigger (line 214) | [Theory]
method GivenTheory_WithIXunitSerializerTheoryDataMember_DoesNotTrigger (line 263) | [Theory]
method GivenTheory_WithNonSerializableTheoryDataMember_WithDiscoveryEnumerationDisabledForTheory_DoesNotTrigger (line 312) | [Theory]
method GivenTheory_WithNonSerializableTheoryDataMember_WithDiscoveryEnumerationDisabledForMemberData_DoesNotTrigger (line 350) | [Theory]
method GivenTheory_WithSerializableTheoryDataClass_DoesNotTrigger (line 388) | [Theory]
method GivenTheory_WithNonSerializableTheoryDataClass_WithDiscoveryEnumerationDisabled_DoesNotTrigger (line 399) | [Theory]
class X1044_AvoidUsingTheoryDataTypeArgumentsThatAreNotSerializable (line 412) | public sealed class X1044_AvoidUsingTheoryDataTypeArgumentsThatAreNotS...
method GivenTheory_WithTypeOnlySupportedInV3_TriggersInV2_DoesNotTriggerInV3 (line 414) | [Theory]
method GivenTheory_WithNonSerializableTheoryDataMember_Triggers (line 446) | [Theory]
method GivenTheory_WithNonSerializableTheoryDataClass_Triggers (line 484) | [Theory]
method GivenTheory_WithValueTuple_OnlySupportedInV3_3_0_1 (line 501) | [Theory]
class X1045_AvoidUsingTheoryDataTypeArgumentsThatMightNotBeSerializable (line 529) | public sealed class X1045_AvoidUsingTheoryDataTypeArgumentsThatMightNo...
method GivenTheory_WithTypeOnlySupportedInV3_TriggersInV2_DoesNotTriggerInV3 (line 531) | [Theory]
method IFormattableAndIParseable_TriggersInV2_DoesNotTriggerInV3 (line 557) | [Fact]
method GivenTheory_WithTuple_OnlySupportedInV3_3_0_1 (line 626) | [Theory]
method GivenTheory_WithPossiblySerializableTheoryDataMember_Triggers (line 653) | [Theory]
method GivenTheory_WithPossiblySerializableTheoryDataClass_Triggers (line 698) | [Theory]
class Analyzer_v3_Pre301 (line 716) | internal class Analyzer_v3_Pre301 : TheoryDataTypeArgumentsShouldBeSer...
method CreateXunitContext (line 718) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TheoryMethodCannotHaveDefaultParameterTests.cs
class TheoryMethodCannotHaveDefaultParameterTests (line 9) | public class TheoryMethodCannotHaveDefaultParameterTests
method TheoryWithDefaultParameter_WhenDefaultValueNotSupported_Triggers (line 11) | [Fact]
method TheoryWithDefaultParameter_WhenDefaultValueSupported_DoesNotTrigger (line 25) | [Fact]
class Analyzer_v2_Pre220 (line 38) | internal class Analyzer_v2_Pre220 : TheoryMethodCannotHaveDefaultParam...
method CreateXunitContext (line 40) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TheoryMethodCannotHaveParamsArrayTests.cs
class TheoryMethodCannotHaveParamsArrayTests (line 9) | public class TheoryMethodCannotHaveParamsArrayTests
method TheoryWithParamsArrayAsync_WhenParamsArrayNotSupported_DoesNotTrigger (line 11) | [Fact]
method TheoryWithParamsArrayAsync_WhenParamsArraySupported_DoesNotTrigger (line 25) | [Fact]
method TheoryWithNonParamsArrayAsync_WhenParamsArrayNotSupported_DoesNotTrigger (line 38) | [Fact]
method TheoryWithNonParamsArrayAsync_WhenParamsArraySupported_DoesNotTrigger (line 51) | [Fact]
class Analyzer_v2_Pre220 (line 64) | internal class Analyzer_v2_Pre220 : TheoryMethodCannotHaveParamsArray
method CreateXunitContext (line 66) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TheoryMethodMustHaveTestDataTests.cs
class TheoryMethodMustHaveTestDataTests (line 6) | public class TheoryMethodMustHaveTestDataTests
method FactMethod_DoesNotTrigger (line 8) | [Fact]
method TheoryMethodWithDataAttributes_DoesNotTrigger (line 23) | [Fact]
method TheoryMethodWithCustomDataAttribute_v3_DoesNotTrigger (line 47) | [Fact]
method TheoryMethodMissingData_Triggers (line 89) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TheoryMethodShouldHaveParametersTests.cs
class TheoryMethodShouldHaveParametersTests (line 5) | public class TheoryMethodShouldHaveParametersTests
method FactMethod_DoesNotTrigger (line 7) | [Fact]
method TheoryMethodWithParameters_DoesNotTrigger (line 20) | [Fact]
method TheoryMethodWithoutParameters_Triggers (line 33) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/TheoryMethodShouldUseAllParametersTests.cs
class TheoryMethodShouldUseAllParametersTests (line 5) | public class TheoryMethodShouldUseAllParametersTests
method ParameterNotReferenced_Triggers (line 7) | [Fact]
method ParameterUnread_Triggers (line 23) | [Fact]
method MultipleUnreadParameters_Triggers (line 43) | [Fact]
method SomeUnreadParameters_Triggers (line 64) | [Fact]
method ExpressionBodiedMethod_Triggers (line 88) | [Fact]
method ParameterRead_DoesNotTrigger (line 104) | [Fact]
method ParameterCapturedAsOutParameterInMockSetup_DoesNotTrigger (line 122) | [Fact]
method ExpressionBodiedMethod_DoesNotTrigger (line 143) | [Fact]
method WhenParameterIsDiscardNamed_DoesNotTrigger (line 158) | [Fact]
method DoesNotCrash_MethodWithoutBody (line 179) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X1000/UseCancellationTokenTests.cs
class UseCancellationTokenTests (line 6) | public class UseCancellationTokenTests
method NoCancellationToken_DoesNotTrigger (line 8) | [Fact]
method NonTestMethod_DoesNotTrigger (line 26) | [Fact]
method WithAnyCancellationToken_DoesNotTrigger (line 44) | [Fact]
method WithoutCancellationToken_V2_DoesNotTrigger (line 73) | [Fact]
method WithoutCancellationToken_WithoutDirectUpgrade_DoesNotTrigger (line 92) | [Fact]
method WithoutCancellationToken_V3_Triggers (line 114) | [Fact]
method InsideLambda_DoesNotTrigger (line 147) | [Fact]
method InsideAssertionLambda_Triggers (line 170) | [Fact]
method WhenOverloadIsObsolete_DoesNotTrigger (line 192) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertCollectionContainsShouldNotUseBoolCheckTests.cs
class AssertCollectionContainsShouldNotUseBoolCheckTests (line 6) | public class AssertCollectionContainsShouldNotUseBoolCheckTests
method TrueCollectionContainsCheck_Triggers (line 20) | [Theory]
method FalseCollectionContainsCheck_Triggers (line 36) | [Theory]
method TrueLinqContainsCheck_Triggers (line 52) | [Theory]
method TrueLinqContainsCheckWithEqualityComparer_Triggers (line 70) | [Theory]
method FalseLinqContainsCheck_Triggers (line 88) | [Theory]
method FalseLinqContainsCheckWithEqualityComparer_Triggers (line 106) | [Theory]
method TrueCollectionContainsCheckWithAssertionMessage_DoesNotTrigger (line 124) | [Theory]
method FalseCollectionContainsCheckWithAssertionMessage_DoesNotTrigger (line 139) | [Theory]
method TrueLinqContainsCheckWithAssertionMessage_DoesNotTrigger (line 154) | [Theory]
method FalseLinqContainsCheckWithAssertionMessage_DoesNotTrigger (line 171) | [Theory]
method CollectionWithDifferentTypeParametersThanICollectionImplementation_ZeroParameters_Triggers (line 188) | [Fact]
method CollectionWithDifferentTypeParametersThanICollectionImplementation_TwoParameters_DoesNotTrigger (line 206) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertEmptyCollectionCheckShouldNotBeUsedTests.cs
class AssertEmptyCollectionCheckShouldNotBeUsedTests (line 5) | public class AssertEmptyCollectionCheckShouldNotBeUsedTests
method CollectionCheckWithoutAction_Triggers (line 19) | [Theory]
method CollectionCheckWithAction_DoesNotTrigger (line 35) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksTests.cs
class AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksTests (line 5) | public class AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksTests
method GetEnumerables (line 7) | public static TheoryData<string, string> GetEnumerables(
method Containers_WithoutWhereClause_DoesNotTrigger (line 19) | [Theory]
method Containers_WithWhereClauseWithIndex_DoesNotTrigger (line 38) | [Theory]
method EnumurableEmptyCheck_WithChainedLinq_DoesNotTrigger (line 59) | [Theory]
method Containers_WithWhereClause_Triggers (line 80) | [Theory]
method Strings_WithWhereClause_Triggers (line 101) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckTests.cs
class AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckTests (line 6) | public class AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContain...
method ForLinqAnyCheck_Triggers (line 14) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertEqualGenericShouldNotBeUsedForStringValueTests.cs
class AssertEqualGenericShouldNotBeUsedForStringValueTests (line 5) | public class AssertEqualGenericShouldNotBeUsedForStringValueTests
method StringEqualityCheckWithoutGenericType_DoesNotTrigger (line 18) | [Theory]
method StringEqualityCheckWithGenericType_Triggers (line 35) | [Theory]
method StrictStringEqualityCheck_Triggers (line 52) | [Theory]
method StrictStringEqualityCheckWithGenericType_Triggers (line 69) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertEqualLiteralValueShouldBeFirstTests.cs
class AssertEqualLiteralValueShouldBeFirstTests (line 5) | public class AssertEqualLiteralValueShouldBeFirstTests
method WhenConstantOrLiteralUsedForBothArguments_DoesNotTrigger (line 7) | [Fact]
method ExpectedConstantOrLiteralValueAsFirstArgument_DoesNotTrigger (line 34) | [Theory]
method ConstantsUsedInStringConstructorAsFirstArgument_DoesNotTrigger (line 52) | [Fact]
method ExpectedConstantOrLiteralValueAsSecondArgument_Triggers (line 66) | [Theory]
method ExpectedConstantOrLiteralValueAsNamedExpectedArgument_DoesNotTrigger (line 85) | [Theory]
method ExpectedConstantOrLiteralValueAsNamedExpectedArgument_Triggers (line 102) | [Theory]
method DoesNotFindWarningWhenArgumentsAreNotNamedCorrectly (line 121) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertEqualPrecisionShouldBeInRangeTest.cs
class AssertEqualPrecisionShouldBeInRangeTest (line 5) | public class AssertEqualPrecisionShouldBeInRangeTest
method DoesNotFindError_ForDoubleArgumentWithPrecisionProvidedInRange (line 15) | [Theory]
method FindsError_ForDoubleArgumentWithPrecisionProvidedOutOfRange (line 31) | [Theory]
method DoesNotFindError_ForDecimalArgumentWithPrecisionProvidedInRange (line 49) | [Theory]
method FindsError_ForDecimalArgumentWithPrecisionProvidedOutOfRange (line 65) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertEqualShouldNotBeUsedForBoolLiteralCheckTests.cs
class AssertEqualShouldNotBeUsedForBoolLiteralCheckTests (line 6) | public class AssertEqualShouldNotBeUsedForBoolLiteralCheckTests
method ForFirstBoolLiteral_Triggers (line 16) | [Theory]
method ForFirstBoolLiteral_WithCustomComparer_Triggers (line 38) | [Theory]
method ForFirstBoolLiteral_ObjectOverload_DoesNotTrigger (line 58) | [Theory]
method ForOtherLiteral_DoesNotTrigger (line 74) | [Theory]
method ForSecondBoolLiteral_DoesNotTrigger (line 90) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertEqualShouldNotBeUsedForCollectionSizeCheckTests.cs
class AssertEqualShouldNotBeUsedForCollectionSizeCheckTests (line 6) | public class AssertEqualShouldNotBeUsedForCollectionSizeCheckTests
method AllowedCollection_DoesNotTrigger (line 31) | [Theory]
method AllowedCheck_DoesNotTrigger (line 50) | [Theory]
method InvalidCheckWithConcreteType_Triggers (line 72) | [Theory]
method InvalidCheckWithInterfaceType_Triggers (line 97) | [Theory]
method InvalidCheckWithCustomNonGenericCollection_Triggers (line 124) | [Fact]
method OverridingCountMethod_DoesNotTrigger (line 162) | [Fact]
method ForNonIntArguments_DoesNotCrash (line 192) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertEqualShouldNotBeUsedForNullCheckTests.cs
class AssertEqualShouldNotBeUsedForNullCheckTests (line 6) | public class AssertEqualShouldNotBeUsedForNullCheckTests
method ForFirstNullLiteral_StringOverload_Triggers (line 23) | [Theory]
method ForFirstNullLiteral_StringOverload_WithCustomComparer_Triggers (line 42) | [Theory]
method ForFirstNullLiteral_ObjectOverload_Triggers (line 61) | [Theory]
method ForFirstNullLiteral_ObjectOverload_WithCustomComparer_Triggers (line 85) | [Theory]
method ForFirstNullLiteral_GenericOverload_Triggers (line 104) | [Theory]
method ForFirstNullLiteral_GenericOverload_WithCustomComparer_Triggers (line 126) | [Theory]
method ForOtherLiteral_DoesNotTrigger (line 145) | [Theory]
method ForSecondNullLiteral_DoesNotTrigger (line 161) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertEqualsShouldNotBeUsedTests.cs
class AssertEqualsShouldNotBeUsedTests (line 6) | public class AssertEqualsShouldNotBeUsedTests
method WhenProhibitedMethodIsUsed_Triggers (line 8) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertIsTypeShouldNotBeUsedForAbstractTypeTests.cs
class AssertIsTypeShouldNotBeUsedForAbstractTypeTests (line 10) | public class AssertIsTypeShouldNotBeUsedForAbstractTypeTests
method Interface_Triggers (line 21) | [Theory]
method Interface_WithExactMatchFlag_TriggersForTrue (line 49) | [Theory]
method AbstractClass_Triggers (line 77) | [Theory]
method AbstractClass_WithExactMatchFlag_TriggersForTrue (line 105) | [Theory]
method UsingStatic_Triggers (line 133) | [Theory]
method NonAbstractClass_DoesNotTrigger (line 161) | [Theory]
class Analyzer_v2_Pre2_9_3 (line 186) | internal class Analyzer_v2_Pre2_9_3 : AssertIsTypeShouldNotBeUsedForAb...
method CreateXunitContext (line 188) | protected override XunitContext CreateXunitContext(Compilation compi...
class Analyzer_v3_Pre0_6_0 (line 192) | internal class Analyzer_v3_Pre0_6_0 : AssertIsTypeShouldNotBeUsedForAb...
method CreateXunitContext (line 194) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertIsTypeShouldUseGenericOverloadTypeTests.cs
class AssertIsTypeShouldUseGenericOverloadTypeTests (line 9) | public class AssertIsTypeShouldUseGenericOverloadTypeTests
method ForNonGenericCall_Triggers (line 18) | [Theory]
method ForGenericCall_DoesNotTrigger (line 34) | [Theory]
method ForGenericCall_WithExactMatchFlag_DoesNotTrigger (line 49) | [Theory]
class StaticAbstractInterfaceMethods (line 68) | public class StaticAbstractInterfaceMethods
method ForStaticAbstractInterfaceMembers_DoesNotTrigger (line 98) | [Fact]
method ForNestedStaticAbstractInterfaceMembers_DoesNotTrigger (line 106) | [Fact]
method ForNotStaticAbstractInterfaceMembers_Triggers (line 116) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertNullShouldNotBeCalledOnValueTypesTests.cs
class AssertNullShouldNotBeCalledOnValueTypesTests (line 5) | public class AssertNullShouldNotBeCalledOnValueTypesTests
method ForValueType_Triggers (line 13) | [Theory]
method ForNullableValueType_DoesNotTrigger (line 30) | [Theory]
method ForNullableReferenceType_DoesNotTrigger (line 46) | [Theory]
method ForPointerType_v3_DoesNotTrigger (line 62) | [Fact]
method ForClassConstrainedGenericTypes_DoesNotTrigger (line 82) | [Theory]
method ForInterfaceConstrainedGenericTypes_DoesNotTrigger (line 97) | [Theory]
method ForUnconstrainedGenericTypes_DoesNotTrigger (line 116) | [Theory]
method ForUserDefinedImplicitConversion_DoesNotTrigger (line 133) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertRegexMatchShouldNotUseBoolLiteralCheckTests.cs
class AssertRegexMatchShouldNotUseBoolLiteralCheckTests (line 6) | public class AssertRegexMatchShouldNotUseBoolLiteralCheckTests
method ForStaticRegexIsMatch_Triggers (line 14) | [Theory]
method ForInstanceRegexIsMatchWithInlineConstructedRegex_Triggers (line 32) | [Theory]
method ForInstanceRegexIsMatchWithConstructedRegexVariable_Triggers (line 50) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertSameShouldNotBeCalledOnValueTypesTests.cs
class AssertSameShouldNotBeCalledOnValueTypesTests (line 6) | public class AssertSameShouldNotBeCalledOnValueTypesTests
method TwoValueParameters_Triggers (line 14) | [Theory]
method FirstValueParameters_Triggers (line 33) | [Theory]
method SecondValueParameters_Triggers (line 52) | [Theory]
method UserDefinedImplicitConversion_DoesNotTrigger (line 71) | [Theory]
method FirstValueParametersIfSecondIsNull_Triggers (line 107) | [Theory]
method SecondValueParametersIfFirstIsNull_Triggers (line 125) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertSingleShouldBeUsedForSingleParameterTests.cs
class AssertSingleShouldBeUsedForSingleParameterTests (line 6) | public class AssertSingleShouldBeUsedForSingleParameterTests
method EnumerableAcceptanceTest (line 8) | [Fact]
method AsyncEnumerableAcceptanceTest (line 51) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertSingleShouldUseTwoArgumentCallTests.cs
class AssertSingleShouldUseTwoArgumentCallTests (line 5) | public class AssertSingleShouldUseTwoArgumentCallTests
method GetEnumerables (line 7) | public static TheoryData<string, string> GetEnumerables(
method Containers_WithoutWhereClause_DoesNotTrigger (line 12) | [Theory]
method Containers_WithWhereClauseWithIndex_DoesNotTrigger (line 30) | [Theory]
method EnumurableEmptyCheck_WithChainedLinq_DoesNotTrigger (line 50) | [Theory]
method Containers_WithWhereClause_Triggers (line 70) | [Theory]
method Strings_WithWhereClause_Triggers (line 90) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertStringEqualityCheckShouldNotUseBoolCheckTest.cs
class AssertStringEqualityCheckShouldNotUseBoolCheckTest (line 7) | public class AssertStringEqualityCheckShouldNotUseBoolCheckTest
method ForInstanceEqualsCheck_Triggers (line 36) | [Theory]
method ForTrueInstanceEqualsCheck_WithSupportedStringComparison_Triggers (line 54) | [Theory]
method ForTrueInstanceEqualsCheck_WithUnsupportedStringComparison_DoesNotTrigger (line 70) | [Theory]
method ForFalseInstanceEqualsCheck_WithStringComparison_DoesNotTrigger (line 85) | [Theory]
method ForStaticEqualsCheck_Triggers (line 100) | [Theory]
method ForTrueStaticEqualsCheck_WithSupportedStringComparison_Triggers (line 118) | [Theory]
method ForTrueStaticEqualsCheck_WithUnsupportedStringComparison_DoesNotTrigger (line 134) | [Theory]
method ForFalseStaticEqualsCheck_WithStringComparison_DoesNotTrigger (line 149) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertSubstringCheckShouldNotUseBoolCheckTests.cs
class AssertSubstringCheckShouldNotUseBoolCheckTests (line 6) | public class AssertSubstringCheckShouldNotUseBoolCheckTests
method ForBooleanContainsCheck_Triggers (line 14) | [Theory]
method ForBooleanContainsCheck_WithUserMessage_DoesNotTrigger (line 33) | [Theory]
method ForBooleanTrueStartsWithCheck_Triggers (line 48) | [Fact]
method ForBooleanTrueStartsWithCheck_WithStringComparison_Triggers (line 63) | [Fact]
method ForBooleanFalseStartsWithCheck_DoesNotTrigger (line 78) | [Fact]
method ForBooleanFalseStartsWithCheck_WithStringComparison_DoesNotTrigger (line 92) | [Fact]
method ForBooleanStartsWithCheck_WithUserMessage_DoesNotTrigger (line 106) | [Theory]
method ForBooleanStartsWithCheck_WithStringComparison_AndUserMessage_DoesNotTrigger (line 121) | [Theory]
method ForBooleanStartsWithCheck_WithBoolAndCulture_DoesNotTrigger (line 136) | [Theory]
method ForBooleanStartsWithCheck_WithBoolAndCulture_AndUserMessage_DoesNotTrigger (line 151) | [Theory]
method ForBooleanTrueEndsWithCheck_Triggers (line 166) | [Fact]
method ForBooleanTrueEndsWithCheck_WithStringComparison_Triggers (line 181) | [Fact]
method ForBooleanFalseEndsWithCheck_DoesNotTrigger (line 196) | [Fact]
method ForBooleanFalseEndsWithCheck_WithStringComparison_DoesNotTrigger (line 210) | [Fact]
method ForBooleanEndsWithCheck_WithUserMessage_DoesNotTrigger (line 224) | [Theory]
method ForBooleanEndsWithCheck_WithStringComparison_AndUserMessage_DoesNotTrigger (line 239) | [Theory]
method ForBooleanEndsWithCheck_WithBoolAndCulture_DoesNotTrigger (line 254) | [Theory]
method ForBooleanEndsWithCheck_WithBoolAndCulture_AndUserMessage_DoesNotTrigger (line 269) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertThrowsShouldNotBeUsedForAsyncThrowsCheckTests.cs
class AssertThrowsShouldNotBeUsedForAsyncThrowsCheckTests (line 6) | public class AssertThrowsShouldNotBeUsedForAsyncThrowsCheckTests
method Throws_NonGeneric_WithNonAsyncLambda_DoesNotTrigger (line 22) | [Theory]
method Throws_Generic_WithNonAsyncLambda_DoesNotTrigger (line 41) | [Theory]
method Throws_Generic_WithNamedArgumentException_WithNonAsyncLambda_DoesNotTrigger (line 60) | [Theory]
method Throws_NonGeneric_WithAsyncLambda_Triggers (line 79) | [Theory]
method Throws_Generic_WithAsyncLambda_Triggers (line 99) | [Theory]
method Throws_Generic_WithNamedArgumentException_WithAsyncLambda_Triggers (line 119) | [Theory]
method ThrowsAsync_NonGeneric_WithAsyncLambda_DoesNotTrigger (line 139) | [Theory]
method ThrowsAsync_Generic_WithAsyncLambda_DoesNotTrigger (line 158) | [Theory]
method ThrowsAny_WithNonAsyncLambda_DoesNotTrigger (line 177) | [Theory]
method ThrowsAny_WithAsyncLambda_Triggers (line 196) | [Theory]
method ThrowsAnyAsync_WithAsyncLambda_DoesNotTrigger (line 216) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssertThrowsShouldUseGenericOverloadCheckTests.cs
class AssertThrowsShouldUseGenericOverloadCheckTests (line 8) | public class AssertThrowsShouldUseGenericOverloadCheckTests
method ForThrowsCheck_WithExceptionParameter_OnThrowingMethod_Triggers (line 16) | [Theory]
method ForThrowsCheck_WithExceptionParameter_OnThrowingLambda_Triggers (line 40) | [Theory]
method ForThrowsCheck_WithExceptionTypeArgument_OnThrowingMethod_TriggersCompilerError (line 60) | [Fact]
method ForThrowsAsyncCheck_WithExceptionTypeArgument_OnThrowingMethod_DoesNotTrigger (line 78) | [Fact]
method ForThrowsCheck_WithExceptionTypeArgument_OnThrowingLambda_TriggersCompilerError (line 96) | [Fact]
method ForThrowsAsyncCheck_WithExceptionTypeArgument_OnThrowingLambda_DoesNotTrigger (line 110) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AssignableFromAssertionIsConfusinglyNamedTests.cs
class AssignableFromAssertionIsConfusinglyNamedTests (line 10) | public class AssignableFromAssertionIsConfusinglyNamedTests
method WhenReplacementAvailable_Triggers (line 18) | [Theory]
method WhenReplacementNotAvailable_DoesNotTriggers (line 43) | [Theory]
class Analyzer_v2_Pre2_9_3 (line 65) | internal class Analyzer_v2_Pre2_9_3 : AssignableFromAssertionIsConfusi...
method CreateXunitContext (line 67) | protected override XunitContext CreateXunitContext(Compilation compi...
class Analyzer_v3_Pre0_6_0 (line 71) | internal class Analyzer_v3_Pre0_6_0 : AssignableFromAssertionIsConfusi...
method CreateXunitContext (line 73) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Analyzers/X2000/AsyncAssertsShouldBeAwaitedTests.cs
class AsyncAssertsShouldBeAwaitedTests (line 7) | public class AsyncAssertsShouldBeAwaitedTests
method UnawaitedNonAssertion_DoesNotTrigger (line 9) | [Fact]
method AwaitedAssert_DoesNotTrigger (line 72) | [Theory]
method AssertionWithConsumption_DoesNotTrigger (line 83) | [Theory]
method AssertionWithConsumptionViaExtension_DoesNotTrigger (line 94) | [Theory]
method AssertionWithStoredTask_DoesNotTrigger (line 105) | [Theory]
method AssertionWithoutAwait_Triggers (line 116) | [Theory]
method AssertionWithUnawaitedContinuation_Triggers (line 128) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/BooleanAssertsShouldNotBeNegatedTests.cs
class BooleanAssertsShouldNotBeNegatedTests (line 5) | public class BooleanAssertsShouldNotBeNegatedTests
method NegatedBooleanAssertion_Triggers (line 7) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckTests.cs
class BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckTests (line 9) | public class BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckTests
class X2024_BooleanAssertionsShouldNotBeUsedForSimpleEqualityCheck (line 11) | public class X2024_BooleanAssertionsShouldNotBeUsedForSimpleEqualityCheck
method ComparingAgainstNonLiteral_DoesNotTrigger (line 19) | [Theory]
method ComparingAgainstLiteral_WithMessage_DoesNotTrigger (line 50) | [Theory]
method ComparingAgainstLiteral_WithoutMessage_Triggers (line 75) | [Theory]
method ComparingAgainstNull_WithMessage_DoesNotTrigger (line 118) | [Theory]
method ComparingAgainstNull_WithoutMessage_Triggers (line 143) | [Theory]
method ComparingAgainstNullPointer_DoesNotTrigger (line 179) | [Fact]
method ComparingAgainstNullPointer_v3_301_Triggers (line 207) | [Fact]
class X2025_BooleanAssertionCanBeSimplified (line 247) | public class X2025_BooleanAssertionCanBeSimplified
method ComparingAgainstBooleanLiteral_Triggers (line 256) | [Theory]
class Analyzer_v3_Pre301 (line 289) | public class Analyzer_v3_Pre301 : BooleanAssertsShouldNotBeUsedForSimp...
method CreateXunitContext (line 291) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Analyzers/X2000/DoNotUseAssertEmptyWithProblematicTypesTests.cs
class DoNotUseAssertEmptyWithProblematicTypesTests (line 5) | public class DoNotUseAssertEmptyWithProblematicTypesTests
method NonProblematicCollection_DoesNotTrigger (line 13) | [Theory]
method ConvertingToCollection_DoesNotTrigger (line 35) | [Theory]
method UsingProblematicType_Triggers (line 59) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/SetEqualityAnalyzerTests.cs
class SetEqualityAnalyzerTests (line 6) | public class SetEqualityAnalyzerTests
class X2026_SetsMustBeComparedWithEqualityComparer (line 42) | public class X2026_SetsMustBeComparedWithEqualityComparer
method WithCollectionComparer_DoesNotTrigger (line 51) | [Theory]
method WithEqualityComparer_DoesNotTrigger (line 77) | [Theory]
method WithComparerLambda_Triggers (line 113) | [Theory]
method ComparerFunctionData (line 142) | public static MatrixTheoryData<string, string, string, string> Compa...
method WithComparerFunction_Triggers (line 150) | [Theory]
class X2027_SetsShouldNotBeComparedToLinearContainers (line 193) | public class X2027_SetsShouldNotBeComparedToLinearContainers
method LinearContainers_DoesNotTrigger (line 201) | [Theory]
method CastedSet_DoesNotTrigger (line 228) | [Fact]
method SetWithLinearContainer_Triggers (line 263) | [Theory]
FILE: src/xunit.analyzers.tests/Analyzers/X2000/UseAssertFailInsteadOfBooleanAssertTests.cs
class UseAssertFailInsteadOfBooleanAssertTests (line 9) | public class UseAssertFailInsteadOfBooleanAssertTests
method OppositeTestWithMessage_Prev25_DoesNotTrigger (line 20) | [Theory]
method OppositeTestWithMessage_v25_Triggers (line 32) | [Theory]
method SameTestWithMessage_DoesNotTrigger (line 45) | [Theory]
method NonConstantInvocation_DoesNotTrigger (line 57) | [Fact]
class Analyzer_Pre25 (line 73) | internal class Analyzer_Pre25 : UseAssertFailInsteadOfBooleanAssert
method CreateXunitContext (line 75) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Analyzers/X3000/CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectTests.cs
class CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectTests (line 9) | public class CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectTests
class WithAbstractions (line 11) | public class WithAbstractions
method NoInterfaces_DoesNotTrigger (line 48) | [Fact]
method InterfaceWithoutBaseClass_Triggers (line 56) | [Theory]
class Analyzer (line 66) | internal class Analyzer : CrossAppDomainClassesMustBeLongLivedMarsha...
method CreateXunitContext (line 68) | protected override XunitContext CreateXunitContext(Compilation com...
class WithExecution (line 73) | public class WithExecution
method NoInterfaces_DoesNotTrigger (line 101) | [Fact]
method WithXunitTestCase_DoesNotTrigger (line 109) | [Fact]
method CompatibleBaseClass_DoesNotTrigger (line 117) | [Theory]
method InterfaceWithoutBaseClass_Triggers (line 128) | [Theory]
method IncompatibleBaseClass_Triggers (line 138) | [Theory]
class Analyzer (line 148) | internal class Analyzer : CrossAppDomainClassesMustBeLongLivedMarsha...
method CreateXunitContext (line 150) | protected override XunitContext CreateXunitContext(Compilation com...
class WithRunnerUtility (line 155) | public class WithRunnerUtility
method NoInterfaces_DoesNotTrigger (line 184) | [Fact]
method CompatibleBaseClass_DoesNotTrigger (line 192) | [Theory]
method InterfaceWithoutBaseClass_Triggers (line 203) | [Theory]
method IncompatibleBaseClass_Triggers (line 213) | [Theory]
class Analyzer (line 223) | internal class Analyzer : CrossAppDomainClassesMustBeLongLivedMarsha...
method CreateXunitContext (line 225) | protected override XunitContext CreateXunitContext(Compilation com...
method MemberCount (line 230) | public static string MemberCount(
FILE: src/xunit.analyzers.tests/Analyzers/X3000/DoNotTestForConcreteTypeOfJsonSerializableTypesTests.cs
class DoNotTestForConcreteTypeOfJsonSerializableTypesTests (line 7) | public class DoNotTestForConcreteTypeOfJsonSerializableTypesTests
method AcceptanceTest (line 9) | [Fact]
FILE: src/xunit.analyzers.tests/Analyzers/X3000/FactAttributeDerivedClassesShouldProvideSourceInformationConstructorTests.cs
class FactAttributeDerivedClassesShouldProvideSourceInformationConstructorTests (line 10) | public class FactAttributeDerivedClassesShouldProvideSourceInformationCo...
method v2_OlderV3_DoesNotTrigger (line 12) | [Fact]
method v3_Triggers (line 28) | [Fact]
class Analyzer_v3_Pre300 (line 82) | internal class Analyzer_v3_Pre300 : FactAttributeDerivedClassesShouldP...
method CreateXunitContext (line 84) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Analyzers/X3000/SerializableClassMustHaveParameterlessConstructorTests.cs
class SerializableClassMustHaveParameterlessConstructorTests (line 9) | public class SerializableClassMustHaveParameterlessConstructorTests
class JsonTypeID (line 11) | public class JsonTypeID
method JsonTypeIDAcceptanceTest (line 13) | [Fact]
class RunnerReporter (line 48) | public class RunnerReporter
method ImplicitConstructor_DoesNotTrigger (line 73) | [Fact]
method WrongConstructor_Triggers (line 81) | [Fact]
method WrongConstructorOnAbstractClass_DoesNotTrigger (line 90) | [Fact]
method NonPublicConstructor_Triggers (line 98) | [Fact]
method NonPublicConstructorOnAbstractClass_DoesNotTrigger (line 107) | [Fact]
method PublicParameterlessConstructor_DoesNotTrigger (line 113) | [Fact]
class XunitSerializable (line 120) | public class XunitSerializable
method ImplicitConstructors_DoesNotTrigger (line 139) | [Theory]
method WrongConstructor_Triggers (line 147) | [Theory]
method WrongConstructorOnAbstractClass_DoesNotTrigger (line 162) | [Theory]
method NonPublicConstructor_Triggers (line 170) | [Theory]
method NonPublicConstructorOnAbstractClass_DoesNotTrigger (line 185) | [Theory]
method PublicParameterlessConstructor_DoesNotTrigger (line 193) | [Theory]
class XunitSerializer (line 202) | public class XunitSerializer
method ImplicitConstructor_DoesNotTrigger (line 222) | [Fact]
method WrongConstructor_Triggers (line 230) | [Fact]
method WrongConstructorOnAbstractClass_DoesNotTrigger (line 239) | [Fact]
method NonPublicConstructor_Triggers (line 245) | [Fact]
method NonPublicConstructorOnAbstractClass_DoesNotTrigger (line 254) | [Fact]
method PublicParameterlessConstructor_DoesNotTrigger (line 260) | [Fact]
class V2Analyzer (line 269) | public class V2Analyzer : SerializableClassMustHaveParameterlessConstr...
method CreateXunitContext (line 271) | protected override XunitContext CreateXunitContext(Compilation compi...
class V3Analyzer (line 275) | public class V3Analyzer : SerializableClassMustHaveParameterlessConstr...
method CreateXunitContext (line 277) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Fixes/X1000/ClassDataAttributeMustPointAtValidClassFixerTests.cs
class ClassDataAttributeMustPointAtValidClassFixerTests (line 6) | public class ClassDataAttributeMustPointAtValidClassFixerTests
method AddsIEnumerable (line 8) | [Fact]
method ConvertsParameterlessConstructorToPublic (line 44) | [Fact]
method AddsPublicParameterlessConstructor (line 89) | [Fact]
method RemovesAbstractModifierFromDataClass (line 162) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/CollectionDefinitionClassesMustBePublicFixerTests.cs
class CollectionDefinitionClassesMustBePublicFixerTests (line 6) | public class CollectionDefinitionClassesMustBePublicFixerTests
method FixAll_MakesAllClassesPublic (line 8) | [Fact]
method ForPartialClassDeclarations_MakesSingleDeclarationPublic (line 29) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/ConvertToFactFixTests.cs
class ConvertToFactFixTests (line 7) | public class ConvertToFactFixTests
method FixAll_From_X1003 (line 9) | [Fact]
method FixAll_From_X1006 (line 38) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/ConvertToTheoryFixTests.cs
class ConvertToTheoryFixTests (line 7) | public class ConvertToTheoryFixTests
method FixAll_From_X1001 (line 9) | [Fact]
method FixAll_From_X1005 (line 38) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/DataAttributeShouldBeUsedOnATheoryFixerTests.cs
class DataAttributeShouldBeUsedOnATheoryFixerTests (line 6) | public class DataAttributeShouldBeUsedOnATheoryFixerTests
method FixAll_MarkAsTheory (line 8) | [Fact]
method FixAll_RemoveDataAttributes (line 39) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/DoNotUseAsyncVoidForTestMethodsFixerTests.cs
class DoNotUseAsyncVoidForTestMethodsFixerTests (line 8) | public class DoNotUseAsyncVoidForTestMethodsFixerTests
method FixAll_ConvertsMultipleMethodsToTask (line 10) | [Fact]
method FixAll_ConvertsMultipleMethodsToValueTask (line 51) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/DoNotUseConfigureAwaitFixerTests.cs
class DoNotUseConfigureAwaitFixerTests (line 6) | public class DoNotUseConfigureAwaitFixerTests
method FixAll_RemovesAllConfigureAwaitCalls (line 8) | [Fact]
method FixAll_ReplacesAllConfigureAwaitArguments (line 49) | [Fact]
class ConfigureAwait_Boolean (line 90) | public class ConfigureAwait_Boolean
class RemoveConfigureAwait (line 100) | public class RemoveConfigureAwait
method Task_Async (line 102) | [Theory]
method Task_NonAsync (line 134) | [Theory]
method TaskOfT (line 166) | [Theory]
method ValueTask (line 200) | [Theory]
method ValueTaskOfT (line 234) | [Theory]
class ReplaceConfigureAwait (line 269) | public class ReplaceConfigureAwait
method Task_Async (line 271) | [Theory]
method Task_NonAsync (line 303) | [Theory]
method TaskOfT (line 335) | [Theory]
method ValueTask (line 369) | [Theory]
method ValueTaskOfT (line 403) | [Theory]
class ConfigureAwait_ConfigureAwaitOptions (line 441) | public class ConfigureAwait_ConfigureAwaitOptions
method Task_Async (line 454) | [Theory]
method Task_NonAsync (line 486) | [Theory]
method TaskOfT (line 518) | [Theory]
FILE: src/xunit.analyzers.tests/Fixes/X1000/FactMethodMustNotHaveParametersFixerTests.cs
class FactMethodMustNotHaveParametersFixerTests (line 6) | public class FactMethodMustNotHaveParametersFixerTests
method FixAll_RemovesParametersFromAllMethods (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/FactMethodShouldNotHaveTestDataFixerTests.cs
class FactMethodShouldNotHaveTestDataFixerTests (line 6) | public class FactMethodShouldNotHaveTestDataFixerTests
method FixAll_RemovesDataAttributesFromAllMethods (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/InlineDataMustMatchTheoryParameters_ExtraValueFixerTests.cs
class InlineDataMustMatchTheoryParameters_ExtraValueFixerTests (line 6) | public class InlineDataMustMatchTheoryParameters_ExtraValueFixerTests
method FixAll_RemovesMultipleUnusedDataValues (line 8) | [Fact]
method RemovesUnusedData (line 41) | [Fact]
method AddsParameterWithCorrectType (line 66) | [Theory]
method AddsParameterWithNonConflictingName (line 95) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForIncompatibleParameterFixerTests.cs
class InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForIncompatibleParameterFixerTests (line 7) | public class InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForI...
method FixAll_MakesMultipleParametersNullable (line 9) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/InlineDataMustMatchTheoryParameters_TooFewValuesFixerTests.cs
class InlineDataMustMatchTheoryParameters_TooFewValuesFixerTests (line 6) | public class InlineDataMustMatchTheoryParameters_TooFewValuesFixerTests
method MakesParameterNullable (line 8) | [Theory]
method FixAll_AddsDefaultValuesToMultipleAttributes (line 47) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/InlineDataShouldBeUniqueWithinTheoryFixerTests.cs
class InlineDataShouldBeUniqueWithinTheoryFixerTests (line 6) | public class InlineDataShouldBeUniqueWithinTheoryFixerTests
method FixAll_RemovesDuplicateData (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/LocalFunctionsCannotBeTestFunctionsFixerTests.cs
class LocalFunctionsCannotBeTestFunctionsFixerTests (line 7) | public class LocalFunctionsCannotBeTestFunctionsFixerTests
method FixAll_RemovesAttributesFromAllLocalFunctions (line 9) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/MemberDataShouldReferenceValidMember_ExtraValueFixerTests.cs
class MemberDataShouldReferenceValidMember_ExtraValueFixerTests (line 6) | public class MemberDataShouldReferenceValidMember_ExtraValueFixerTests
method FixAll_RemovesMultipleUnusedDataValues (line 8) | [Fact]
method RemovesUnusedData (line 47) | [Fact]
method AddsParameterWithCorrectType (line 76) | [Theory]
method AddsParameterWithNonConflictingName (line 109) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/MemberDataShouldReferenceValidMember_NameOfFixerTests.cs
class MemberDataShouldReferenceValidMember_NameOfFixerTests (line 6) | public class MemberDataShouldReferenceValidMember_NameOfFixerTests
method FixAll_ConvertsAllStringsToNameOf (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/MemberDataShouldReferenceValidMember_NullShouldNotBeUsedForIncompatibleParameterFixerTests.cs
class MemberDataShouldReferenceValidMember_NullShouldNotBeUsedForIncompatibleParameterFixerTests (line 7) | public class MemberDataShouldReferenceValidMember_NullShouldNotBeUsedFor...
method FixAll_MakesMultipleParametersNullable (line 9) | [Fact]
method MakesParameterNullable (line 48) | [Fact]
method MakesReferenceParameterNullable (line 77) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/MemberDataShouldReferenceValidMember_ParamsForNonMethodFixerTests.cs
class MemberDataShouldReferenceValidMember_ParamsForNonMethodFixerTests (line 6) | public class MemberDataShouldReferenceValidMember_ParamsForNonMethodFixe...
method FixAll_RemovesParametersFromNonMethodMemberData (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/MemberDataShouldReferenceValidMember_ReturnTypeFixerTests.cs
class MemberDataShouldReferenceValidMember_ReturnTypeFixerTests (line 6) | public class MemberDataShouldReferenceValidMember_ReturnTypeFixerTests
method FixAll_ChangesReturnTypeOnMultipleMembers (line 8) | [Fact]
method ChangesReturnType_ObjectArray (line 49) | [Fact]
method ChangesReturnType_TheoryDataRow (line 80) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/MemberDataShouldReferenceValidMember_StaticFixerTests.cs
class MemberDataShouldReferenceValidMember_StaticFixerTests (line 6) | public class MemberDataShouldReferenceValidMember_StaticFixerTests
method FixAll_MarksMultipleDataMembersAsStatic (line 8) | [Fact]
method MarksDataMemberAsStatic (line 49) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/MemberDataShouldReferenceValidMember_VisibilityFixerTests.cs
class MemberDataShouldReferenceValidMember_VisibilityFixerTests (line 6) | public class MemberDataShouldReferenceValidMember_VisibilityFixerTests
method FixAll_SetsPublicModifierOnMultipleMembers (line 8) | [Fact]
method SetsPublicModifier (line 71) | [Theory]
FILE: src/xunit.analyzers.tests/Fixes/X1000/PublicMethodShouldBeMarkedAsTestFixerTests.cs
class PublicMethodShouldBeMarkedAsTestFixerTests (line 6) | public class PublicMethodShouldBeMarkedAsTestFixerTests
method FixAll_AddsFactToAllPublicMethodsWithoutParameters (line 8) | [Fact]
method FixAll_AddsTheoryToAllPublicMethodsWithParameters (line 41) | [Fact]
method FixAll_MakesAllMethodsInternal (line 74) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/RemoveMethodParameterFixTests.cs
class RemoveMethodParameterFixTests (line 10) | public class RemoveMethodParameterFixTests
method X1022_RemoveParamsArray (line 12) | [Fact]
method X1026_RemovesUnusedParameter (line 37) | [Fact]
method X1026_DoesNotCrashWhenParameterDeclarationIsMissing (line 62) | [Fact]
class Analyzer_X1022 (line 93) | internal class Analyzer_X1022 : TheoryMethodCannotHaveParamsArray
method CreateXunitContext (line 95) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Fixes/X1000/TestClassCannotBeNestedInGenericClassFixerTests.cs
class TestClassCannotBeNestedInGenericClassFixerTests (line 6) | public class TestClassCannotBeNestedInGenericClassFixerTests
method MovesTestClassOutOfGenericParent (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/TestClassMustBePublicFixerTests.cs
class TestClassMustBePublicFixerTests (line 6) | public class TestClassMustBePublicFixerTests
method FixAll_MakesAllClassesPublic (line 8) | [Fact]
method ForPartialClassDeclarations_MakesSingleDeclarationPublic (line 37) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/TestClassShouldHaveTFixtureArgumentFixerTests.cs
class TestClassShouldHaveTFixtureArgumentFixerTests (line 6) | public class TestClassShouldHaveTFixtureArgumentFixerTests
method ForClassWithoutField_GenerateFieldAndConstructor (line 8) | [Fact]
method ForGenericTFixture_GenerateFieldAndConstructor (line 38) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/TestMethodMustNotHaveMultipleFactAttributesFixerTests.cs
class TestMethodMustNotHaveMultipleFactAttributesFixerTests (line 6) | public class TestMethodMustNotHaveMultipleFactAttributesFixerTests
method FixAll_RemovesDuplicateAttributes (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/TestMethodShouldNotBeSkippedFixerTests.cs
class TestMethodShouldNotBeSkippedFixerTests (line 6) | public class TestMethodShouldNotBeSkippedFixerTests
method FixAll_RemovesSkipFromAllMethods (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/TheoryDataShouldNotUseTheoryDataRowFixerTests.cs
class TheoryDataShouldNotUseTheoryDataRowFixerTests (line 7) | public class TheoryDataShouldNotUseTheoryDataRowFixerTests
method FixAll_ConvertsFixableTheoryDataToIEnumerable (line 24) | [Fact]
method AcceptanceTest_Unfixable (line 69) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X1000/TheoryMethodCannotHaveDefaultParameterFixerTests.cs
class TheoryMethodCannotHaveDefaultParameterFixerTests (line 9) | public class TheoryMethodCannotHaveDefaultParameterFixerTests
method FixAll_RemovesDefaultParameterValues (line 11) | [Fact]
class Analyzer (line 44) | internal class Analyzer : TheoryMethodCannotHaveDefaultParameter
method CreateXunitContext (line 46) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Fixes/X1000/UseCancellationTokenFixerTests.cs
class UseCancellationTokenFixerTests (line 6) | public class UseCancellationTokenFixerTests
method FixAll_AppliesAllFixesInDocument (line 8) | [Fact]
method UseCancellationTokenArgument (line 79) | [Fact]
method UseCancellationTokenArgument_AliasTestContext (line 134) | [Fact]
method UseCancellationTokenArgument_ParamsArgument (line 171) | [Fact]
method UseCancellationTokenArgument_ParamsArgumentAfterRegularArguments (line 212) | [Fact]
method UseCancellationTokenArgument_ParamsArgumentWithNoValues (line 253) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertCollectionContainsShouldNotUseBoolCheckFixerTests.cs
class AssertCollectionContainsShouldNotUseBoolCheckFixerTests (line 6) | public class AssertCollectionContainsShouldNotUseBoolCheckFixerTests
method ReplacesBooleanAssert (line 23) | [Theory]
method FixAll_ReplacesAllBooleanAsserts (line 52) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertEmptyCollectionCheckShouldNotBeUsedFixerTests.cs
class AssertEmptyCollectionCheckShouldNotBeUsedFixerTests (line 6) | public class AssertEmptyCollectionCheckShouldNotBeUsedFixerTests
method FixAll_UsesEmptyCheck (line 8) | [Fact]
method FixAll_AddsElementInspector (line 43) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksFixerTests.cs
class AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksFixerTests (line 6) | public class AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksFixerT...
method FixerReplacesAssertEmptyWithAssertDoesNotContain (line 24) | [Theory]
method FixerReplacesAssertNotEmptyWithAssertContains (line 44) | [Theory]
method FixAll_ReplacesAssertEmptyWithDoesNotContain (line 64) | [Fact]
method FixAll_ReplacesAssertNotEmptyWithContains (line 99) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckFixerTests.cs
class AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckFixerTests (line 6) | public class AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContain...
method FixAll_ReplacesAllAsserts (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertEqualGenericShouldNotBeUsedForStringValueFixerTests.cs
class AssertEqualGenericShouldNotBeUsedForStringValueFixerTests (line 6) | public class AssertEqualGenericShouldNotBeUsedForStringValueFixerTests
method FixAll_RemovesGenericFromAllAsserts (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertEqualLiteralValueShouldBeFirstFixerTests.cs
class AssertEqualLiteralValueShouldBeFirstFixerTests (line 7) | public class AssertEqualLiteralValueShouldBeFirstFixerTests
method SwapArguments (line 21) | [Theory]
method FixAll_SwapsAllArguments (line 55) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertEqualPrecisionShouldBeInRangeFixerTests.cs
class AssertEqualPrecisionShouldBeInRangeFixerTests (line 6) | public class AssertEqualPrecisionShouldBeInRangeFixerTests
method FixAll_ChangesPrecisionToValidRange (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertEqualShouldNotBeUsedForBoolLiteralCheckFixerTests.cs
class AssertEqualShouldNotBeUsedForBoolLiteralCheckFixerTests (line 6) | public class AssertEqualShouldNotBeUsedForBoolLiteralCheckFixerTests
method ConvertsToBooleanAssert (line 21) | [Theory]
method FixAll_ConvertsAllToBooleanAsserts (line 56) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertEqualShouldNotBeUsedForCollectionSizeCheckFixerTests.cs
class AssertEqualShouldNotBeUsedForCollectionSizeCheckFixerTests (line 6) | public class AssertEqualShouldNotBeUsedForCollectionSizeCheckFixerTests
method ReplacesCollectionCountWithAppropriateAssert (line 22) | [Theory]
method FixAll_ReplacesAllCollectionSizeChecks (line 42) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertEqualShouldNotBeUsedForNullCheckFixerTests.cs
class AssertEqualShouldNotBeUsedForNullCheckFixerTests (line 6) | public class AssertEqualShouldNotBeUsedForNullCheckFixerTests
method ConvertsToAppropriateNullAssert (line 21) | [Theory]
method FixAll_ReplacesAllNullChecks (line 44) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertEqualsShouldNotBeUsedFixerTests.cs
class AssertEqualsShouldNotBeUsedFixerTests (line 6) | public class AssertEqualsShouldNotBeUsedFixerTests
method FixAll_ReplacesAllEqualsAndReferenceEqualsCalls (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertIsTypeShouldNotBeUsedForAbstractTypeFixerTests.cs
class AssertIsTypeShouldNotBeUsedForAbstractTypeFixerTests (line 11) | public class AssertIsTypeShouldNotBeUsedForAbstractTypeFixerTests
method Conversions_WithoutExactMatch (line 13) | [Fact]
method Conversions_WithExactMatch (line 53) | [Fact]
method FixAll_ReplacesAllAbstractTypeChecks (line 108) | [Fact]
class Analyzer_v2_Pre2_9_3 (line 147) | internal class Analyzer_v2_Pre2_9_3 : AssertIsTypeShouldNotBeUsedForAb...
method CreateXunitContext (line 149) | protected override XunitContext CreateXunitContext(Compilation compi...
class Analyzer_v3_Pre0_6_0 (line 153) | internal class Analyzer_v3_Pre0_6_0 : AssertIsTypeShouldNotBeUsedForAb...
method CreateXunitContext (line 155) | protected override XunitContext CreateXunitContext(Compilation compi...
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertNullShouldNotBeCalledOnValueTypesFixerTests.cs
class AssertNullShouldNotBeCalledOnValueTypesFixerTests (line 6) | public class AssertNullShouldNotBeCalledOnValueTypesFixerTests
method ForValueTypeNullAssert_RemovesAssertion (line 8) | [Fact]
method ForAssertionWithTrivia_RemovesAssertionAndLeavesLeadingTriviaInPlace (line 38) | [Fact]
method FixAll_RemovesAllValueTypeNullAssertions (line 80) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertRegexMatchShouldNotUseBoolLiteralCheckFixerTests.cs
class AssertRegexMatchShouldNotUseBoolLiteralCheckFixerTests (line 6) | public class AssertRegexMatchShouldNotUseBoolLiteralCheckFixerTests
method FixAll_ReplacesAllBooleanRegexChecks (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertSameShouldNotBeCalledOnValueTypesFixerTests.cs
class AssertSameShouldNotBeCalledOnValueTypesFixerTests (line 6) | public class AssertSameShouldNotBeCalledOnValueTypesFixerTests
method FixAll_ReplacesAllSameCallsWithEqual (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertSingleShouldBeUsedForSingleParameterFixerTests.cs
class AssertSingleShouldBeUsedForSingleParameterFixerTests (line 7) | public class AssertSingleShouldBeUsedForSingleParameterFixerTests
method CannotFixInsideLambda (line 9) | [Fact]
method EnumerableAcceptanceTest (line 31) | [Fact]
method AsyncEnumerableAcceptanceTest (line 160) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertSingleShouldUseTwoArgumentCallFixerTests.cs
class AssertSingleShouldUseTwoArgumentCallFixerTests (line 6) | public class AssertSingleShouldUseTwoArgumentCallFixerTests
method FixerReplacesAssertSingleOneArgumentToTwoArgumentCall (line 24) | [Theory]
method FixAll_ReplacesAllSingleOneArgumentCalls (line 44) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertStringEqualityCheckShouldNotUseBoolCheckFixerTests.cs
class AssertStringEqualityCheckShouldNotUseBoolCheckFixerTests (line 6) | public class AssertStringEqualityCheckShouldNotUseBoolCheckFixerTests
method ConvertsBooleanAssertToEqualityAssert (line 22) | [Theory]
method FixAll_ReplacesAllBooleanStringEqualityChecks (line 61) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertSubstringCheckShouldNotUseBoolCheckFixerTests.cs
class AssertSubstringCheckShouldNotUseBoolCheckFixerTests (line 6) | public class AssertSubstringCheckShouldNotUseBoolCheckFixerTests
method ConvertsBooleanAssertToStringSpecificAssert (line 22) | [Theory]
method FixAll_ReplacesAllBooleanSubstringChecks (line 51) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssertThrowsShouldNotBeUsedForAsyncThrowsCheckFixerTests.cs
class AssertThrowsShouldNotBeUsedForAsyncThrowsCheckFixerTests (line 7) | public class AssertThrowsShouldNotBeUsedForAsyncThrowsCheckFixerTests
method GenerateAssertions (line 25) | static TheoryData<string, string> GenerateAssertions()
method GivenAssertionInMethod_ReplacesWithAsyncAssertion (line 68) | [Theory]
method GivenAssertionInInvokedAnonymousFunction_ReplacesWithAsyncAssertion (line 88) | [Theory]
method GivenAssertionInInvokedAnonymousFunctionWithAssignment_ReplacesWithAsyncAssertion (line 120) | [Theory]
method GivenAssertionInInvokedAnonymousFunctionWithVar_ReplacesWithAsyncAssertion (line 156) | [Theory]
method GivenAssertionInUninvokedAnonymousFunction_ReplacesWithAsyncAssertion (line 190) | [Theory]
method GivenAssertionInInvokedNestedAnonymousFunction_ReplacesWithAsyncAssertion (line 216) | [Theory]
method GivenAssertionInExplicitlyInvokedNestedAnonymousFunction_ReplacesWithAsyncAssertion (line 256) | [Theory]
method GivenAssertionInConditionallyInvokedNestedAnonymousFunction_ReplacesWithAsyncAssertion (line 294) | [Theory]
method GivenAssertionInUninvokedNestedAnonymousFunction_ReplacesWithAsyncAssertion (line 332) | [Theory]
method GivenAssertionInInvokedLocalFunction_ReplacesWithAsyncAssertion (line 362) | [Theory]
method GivenAssertionInUninvokedLocalFunction_ReplacesWithAsyncAssertion (line 394) | [Theory]
method GivenAssertionInInvokedNestedLocalFunction_ReplacesWithAsyncAssertion (line 420) | [Theory]
method GivenAssertionInUninvokedNestedLocalFunction_ReplacesWithAsyncAssertion (line 464) | [Theory]
method GivenAssertionInMixedNestedFunctions_ReplacesWithAsyncAssertion (line 498) | [Theory]
method VerifyCodeFix (line 562) | static async Task VerifyCodeFix(
method VerifyCodeFix (line 572) | static async Task VerifyCodeFix(
FILE: src/xunit.analyzers.tests/Fixes/X2000/AssignableFromAssertionIsConfusinglyNamedFixerTests.cs
class AssignableFromAssertionIsConfusinglyNamedFixerTests (line 6) | public class AssignableFromAssertionIsConfusinglyNamedFixerTests
method FixAll_ReplacesAllAssignableFromAssertions (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/AsyncAssertsShouldBeAwaitedFixerTests.cs
class AsyncAssertsShouldBeAwaitedFixerTests (line 7) | public class AsyncAssertsShouldBeAwaitedFixerTests
method AddsAsyncAndAwait (line 45) | [Theory]
FILE: src/xunit.analyzers.tests/Fixes/X2000/BooleanAssertsShouldNotBeNegatedFixerTests.cs
class BooleanAssertsShouldNotBeNegatedFixerTests (line 6) | public class BooleanAssertsShouldNotBeNegatedFixerTests
method AcceptanceTest (line 8) | [Fact]
method FixAll_ReplacesAllNegatedBooleanAsserts (line 107) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckBooleanFixerTests.cs
class BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckBooleanFixerTests (line 6) | public class BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckBooleanF...
method SimplifiesBooleanAssert (line 44) | [Theory]
method SimplifiesBooleanAssertWithMessage (line 57) | [Theory]
method FixAll_SimplifiesAllBooleanAsserts (line 70) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckNonBooleanFixerTests.cs
class BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckNonBooleanFixerTests (line 8) | public class BooleanAssertsShouldNotBeUsedForSimpleEqualityCheckNonBoole...
method BooleanAssertAgainstLiteralValue_ReplaceWithEquality (line 32) | [Theory]
method BooleanAssertAgainstNull_ReplaceWithNull (line 68) | [Theory]
method FixAll_ReplacesAllNonBooleanEqualityChecks (line 99) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/UseAssertFailInsteadOfBooleanAssertFixerTests.cs
class UseAssertFailInsteadOfBooleanAssertFixerTests (line 6) | public class UseAssertFailInsteadOfBooleanAssertFixerTests
method FixAll_ReplacesAllBooleanAssertsWithFail (line 8) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X2000/UseGenericOverloadFixTests.cs
class UseGenericOverloadFixTests (line 7) | public class UseGenericOverloadFixTests
method X2007_SwitchesToGenericIsAssignableFrom (line 9) | [Fact]
method X2007_SwitchesToGenericIsType (line 40) | [Theory]
method X2015_SwitchesToGenericThrows (line 74) | [Fact]
method FixAll_SwitchesAllToGenericOverloads (line 107) | [Fact]
FILE: src/xunit.analyzers.tests/Fixes/X3000/CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectFixerTests.cs
class CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectFixerTests (line 10) | public class CrossAppDomainClassesMustBeLongLivedMarshalByRefObjectFixer...
class WithAbstractions (line 12) | public class WithAbstractions : CrossAppDomainClassesMustBeLongLivedMa...
method DoesNotAttemptToFix (line 16) | [Theory]
class Analyzer (line 29) | internal class Analyzer : CrossAppDomainClassesMustBeLongLivedMarsha...
method CreateXunitContext (line 31) | protected override XunitContext CreateXunitContext(Compilation com...
class WithExecution (line 36) | public class WithExecution
method FixAll_AddsBaseClassToMultipleClasses (line 52) | [Fact]
method WithNoBaseClass_WithoutUsing_AddsBaseClass (line 81) | [Theory]
method WithNoBaseClass_WithUsing_AddsBaseClass (line 95) | [Theory]
method WithBadBaseClass_WithoutUsing_ReplacesBaseClass (line 109) | [Theory]
method WithBadBaseClass_WithUsing_ReplacesBaseClass (line 123) | [Theory]
class Analyzer (line 137) | internal class Analyzer : CrossAppDomainClassesMustBeLongLivedMarsha...
method CreateXunitContext (line 139) | protected override XunitContext CreateXunitContext(Compilation com...
class WithRunnerUtility (line 144) | public class WithRunnerUtility
method WithNoBaseClass_WithoutUsing_AddsBaseClass (line 160) | [Theory]
method WithNoBaseClass_WithUsing_AddsBaseClass (line 174) | [Theory]
method WithBadBaseClass_WithoutUsing_ReplacesBaseClass (line 188) | [Theory]
method WithBadBaseClass_WithUsing_ReplacesBaseClass (line 202) | [Theory]
class Analyzer (line 216) | internal class Analyzer : CrossAppDomainClassesMustBeLongLivedMarsha...
method CreateXunitContext (line 218) | protected override XunitContext CreateXunitContext(Compilation com...
FILE: src/xunit.analyzers.tests/Fixes/X3000/SerializableClassMustHaveParameterlessConstructorFixerTests.cs
class SerializableClassMustHaveParameterlessConstructorFixerTests (line 7) | public class SerializableClassMustHaveParameterlessConstructorFixerTests
class JsonTypeID (line 9) | public class JsonTypeID
method WithPublicParameteredConstructor_AddsNewConstructor (line 11) | [Fact]
method WithNonPublicParameterlessConstructor_ChangesVisibility (line 39) | [Fact]
class RunnerReporter (line 64) | public class RunnerReporter
method WithPublicParameteredConstructor_AddsNewConstructor (line 66) | [Fact]
method WithNonPublicParameterlessConstructor_ChangesVisibility (line 121) | [Fact]
class XunitSerializable (line 173) | public class XunitSerializable
method FixAll_AddsConstructorsToMultipleClasses (line 175) | [Fact]
method WithPublicParameteredConstructor_AddsNewConstructor (line 226) | [Fact]
method WithNonPublicParameterlessConstructor_ChangesVisibility_WithoutUsing (line 262) | [Fact]
method WithNonPublicParameterlessConstructor_ChangesVisibility_WithUsing (line 298) | [Fact]
method PreservesExistingObsoleteAttribute (line 336) | [Fact]
class XunitSerializer (line 376) | public class XunitSerializer
method WithPublicParameteredConstructor_AddsNewConstructor (line 378) | [Fact]
method WithNonPublicParameterlessConstructor_ChangesVisibility (line 423) | [Fact]
FILE: src/xunit.analyzers.tests/Suppressors/ConsiderCallingConfigureAwaitSuppressorTests.cs
class ConsiderCallingConfigureAwaitSuppressorTests (line 8) | public sealed class ConsiderCallingConfigureAwaitSuppressorTests
method NonTestMethod_DoesNotSuppress (line 10) | [Fact]
method StandardTestMethod_Suppresses (line 26) | [Theory]
method CustomFactTestMethod_DoesNotSuppress (line 49) | [Fact]
method CodeInsideFunctions_DoesNotSuppress (line 69) | [Fact]
FILE: src/xunit.analyzers.tests/Suppressors/MakeTypesInternalSuppressorTests.cs
class MakeTypesInternalSuppressorTests (line 8) | public sealed class MakeTypesInternalSuppressorTests
method NonTestClass_DoesNotSuppress (line 10) | [Fact]
method TestClass_Suppresses (line 22) | [Theory]
FILE: src/xunit.analyzers.tests/Suppressors/NonNullableFieldInitializationSuppressorTests.cs
class NonNullableFieldInitializationSuppressorTests (line 7) | public sealed class NonNullableFieldInitializationSuppressorTests
method NonAsyncLifetimeClass_V2_DoesNotSuppress (line 11) | [Fact]
method FieldInitializedInInitializeAsync_V2_Suppresses (line 26) | [Fact]
method PropertyInitializedInInitializeAsync_V2_Suppresses (line 54) | [Fact]
method FieldNotInitializedInInitializeAsync_V2_DoesNotSuppress (line 82) | [Fact]
method FieldInitializedWithThis_V2_Suppresses (line 108) | [Fact]
method MultipleFields_OnlyInitializedOnesSuppressed_V2 (line 136) | [Fact]
method FieldAssignedWithExplicitConstructor_V2_Suppresses (line 165) | [Fact]
method FieldNotAssignedWithExplicitConstructor_V2_DoesNotSuppress (line 194) | [Fact]
method PropertyAssignedWithExplicitConstructor_V2_Suppresses (line 221) | [Fact]
method NonAsyncLifetimeClass_V3_DoesNotSuppress (line 252) | [Fact]
method FieldInitializedInInitializeAsync_V3_Suppresses (line 267) | [Fact]
method PropertyInitializedInInitializeAsync_V3_Suppresses (line 295) | [Fact]
method FieldNotInitializedInInitializeAsync_V3_DoesNotSuppress (line 323) | [Fact]
method FieldAssignedWithExplicitConstructor_V3_Suppresses (line 347) | [Fact]
method FieldNotAssignedWithExplicitConstructor_V3_DoesNotSuppress (line 376) | [Fact]
method PropertyAssignedWithExplicitConstructor_V3_Suppresses (line 401) | [Fact]
FILE: src/xunit.analyzers.tests/Suppressors/UseAsyncSuffixForAsyncMethodsSuppressorTests.cs
class UseAsyncSuffixForAsyncMethodsSuppressorTests (line 10) | public class UseAsyncSuffixForAsyncMethodsSuppressorTests
method AcceptanceTest (line 12) | [Fact]
FILE: src/xunit.analyzers.tests/Utility/3rdPartyAnalyzers/AnalyzerLoaderBase.cs
class AnalyzerLoaderBase (line 12) | public class AnalyzerLoaderBase
method FindType (line 18) | protected static Type FindType(
method GetNuGetPackagesFolder (line 23) | static string GetNuGetPackagesFolder()
method LoadAssembly (line 42) | protected static Assembly LoadAssembly(string assemblyPath) =>
FILE: src/xunit.analyzers.tests/Utility/3rdPartyAnalyzers/CodeAnalysisNetAnalyzers.cs
class CodeAnalysisNetAnalyzers (line 8) | public class CodeAnalysisNetAnalyzers : AnalyzerLoaderBase
method CA1515 (line 15) | public static DiagnosticAnalyzer CA1515() =>
method CA2007 (line 18) | public static DiagnosticAnalyzer CA2007() =>
method LoadCSharpNetAnalyzers (line 21) | static Assembly LoadCSharpNetAnalyzers()
method LoadNetAnalyzers (line 29) | static Assembly LoadNetAnalyzers()
FILE: src/xunit.analyzers.tests/Utility/3rdPartyAnalyzers/VsThreadingAnalyzers.cs
class VsThreadingAnalyzers (line 10) | public class VsThreadingAnalyzers : AnalyzerLoaderBase
method VSTHRD200 (line 15) | public static DiagnosticAnalyzer VSTHRD200() =>
method LoadVsThreadingAnalyzers (line 18) | static Assembly LoadVsThreadingAnalyzers()
FILE: src/xunit.analyzers.tests/Utility/AssertsExtensions/EmptyException.cs
class EmptyException (line 5) | internal partial class EmptyException
method ForNamedNonEmptyCollection (line 7) | public static EmptyException ForNamedNonEmptyCollection(
FILE: src/xunit.analyzers.tests/Utility/AssertsExtensions/EqualException.cs
class EqualException (line 5) | internal partial class EqualException
method ForMismatchedValuesWithMessage (line 7) | public static EqualException ForMismatchedValuesWithMessage(
FILE: src/xunit.analyzers.tests/Utility/AssertsExtensions/NotEmptyException.cs
class NotEmptyException (line 3) | internal partial class NotEmptyException
method ForNamedNonEmptyCollection (line 5) | public static NotEmptyException ForNamedNonEmptyCollection(string coll...
FILE: src/xunit.analyzers.tests/Utility/CSharpVerifier.Analyzers.RunnerUtility.cs
class CSharpVerifier (line 5) | public partial class CSharpVerifier<TAnalyzer>
method VerifyAnalyzerRunnerUtility (line 15) | public static async Task VerifyAnalyzerRunnerUtility(
method VerifyAnalyzerRunnerUtility (line 30) | public static async Task VerifyAnalyzerRunnerUtility(
method VerifyAnalyzerRunnerUtility (line 45) | public static async Task VerifyAnalyzerRunnerUtility(
method VerifyAnalyzerRunnerUtility (line 60) | public static async Task VerifyAnalyzerRunnerUtility(
method VerifyAnalyzerV2RunnerUtility (line 77) | public static Task VerifyAnalyzerV2RunnerUtility(
method VerifyAnalyzerV2RunnerUtility (line 89) | public static Task VerifyAnalyzerV2RunnerUtility(
method VerifyAnalyzerV2RunnerUtility (line 101) | public static Task VerifyAnalyzerV2RunnerUtility(
method VerifyAnalyzerV2RunnerUtility (line 113) | public static Task VerifyAnalyzerV2RunnerUtility(
method VerifyAnalyzerV3RunnerUtility (line 135) | public static Task VerifyAnalyzerV3RunnerUtility(
method VerifyAnalyzerV3RunnerUtility (line 147) | public static Task VerifyAnalyzerV3RunnerUtility(
method VerifyAnalyzerV3RunnerUtility (line 159) | public static Task VerifyAnalyzerV3RunnerUtility(
method VerifyAnalyzerV3RunnerUtility (line 171) | public static Task VerifyAnalyzerV3RunnerUtility(
FILE: src/xunit.analyzers.tests/Utility/CSharpVerifier.Analyzers.cs
class CSharpVerifier (line 5) | public partial class CSharpVerifier<TAnalyzer>
method VerifyAnalyzer (line 15) | public static async Task VerifyAnalyzer(
method VerifyAnalyzer (line 30) | public static async Task VerifyAnalyzer(
method VerifyAnalyzer (line 45) | public static async Task VerifyAnalyzer(
method VerifyAnalyzer (line 60) | public static async Task VerifyAnalyzer(
method VerifyAnalyzerV2 (line 77) | public static Task VerifyAnalyzerV2(
method VerifyAnalyzerV2 (line 89) | public static Task VerifyAnalyzerV2(
method VerifyAnalyzerV2 (line 101) | public static Task VerifyAnalyzerV2(
method VerifyAnalyzerV2 (line 113) | public static Task VerifyAnalyzerV2(
method VerifyAnalyzerV3 (line 135) | public static Task VerifyAnalyzerV3(
method VerifyAnalyzerV3 (line 147) | public static Task VerifyAnalyzerV3(
method VerifyAnalyzerV3 (line 159) | public static Task VerifyAnalyzerV3(
method VerifyAnalyzerV3 (line 171) | public static Task VerifyAnalyzerV3(
FILE: src/xunit.analyzers.tests/Utility/CSharpVerifier.CodeFixes.RunnerUtility.cs
class CSharpVerifier (line 6) | public partial class CSharpVerifier<TAnalyzer>
method VerifyCodeFixRunnerUtility (line 17) | public static async Task VerifyCodeFixRunnerUtility(
method VerifyCodeFixRunnerUtility (line 36) | public static async Task VerifyCodeFixRunnerUtility(
method VerifyCodeFixV2RunnerUtility (line 56) | public static Task VerifyCodeFixV2RunnerUtility(
method VerifyCodeFixV2RunnerUtility (line 72) | public static Task VerifyCodeFixV2RunnerUtility(
method VerifyCodeFixV3RunnerUtility (line 99) | public static Task VerifyCodeFixV3RunnerUtility(
method VerifyCodeFixV3RunnerUtility (line 115) | public static Task VerifyCodeFixV3RunnerUtility(
FILE: src/xunit.analyzers.tests/Utility/CSharpVerifier.CodeFixes.cs
class CSharpVerifier (line 6) | public partial class CSharpVerifier<TAnalyzer>
method VerifyCodeFixFixAll (line 17) | public static async Task VerifyCodeFixFixAll(
method VerifyCodeFixFixAll (line 34) | public static async Task VerifyCodeFixFixAll(
method VerifyCodeFixV2FixAll (line 51) | public static Task VerifyCodeFixV2FixAll(
method VerifyCodeFixV2FixAll (line 65) | public static Task VerifyCodeFixV2FixAll(
method VerifyCodeFixV3FixAll (line 89) | public static Task VerifyCodeFixV3FixAll(
method VerifyCodeFixV3FixAll (line 103) | public static Task VerifyCodeFixV3FixAll(
method VerifyCodeFix (line 129) | public static async Task VerifyCodeFix(
method VerifyCodeFix (line 148) | public static async Task VerifyCodeFix(
method VerifyCodeFixV2 (line 168) | public static Task VerifyCodeFixV2(
method VerifyCodeFixV2 (line 184) | public static Task VerifyCodeFixV2(
method VerifyCodeFixV3 (line 211) | public static Task VerifyCodeFixV3(
method VerifyCodeFixV3 (line 227) | public static Task VerifyCodeFixV3(
FILE: src/xunit.analyzers.tests/Utility/CSharpVerifier.Suppressors.cs
class CSharpVerifier (line 7) | public partial class CSharpVerifier<TAnalyzer>
method VerifySuppressor (line 18) | public static async Task VerifySuppressor(
method VerifySuppressor (line 35) | public static async Task VerifySuppressor(
method VerifySuppressor (line 53) | public static async Task VerifySuppressor(
method VerifyCompilerWarningSuppressor (line 71) | public static async Task VerifyCompilerWarningSuppressor(
method VerifySuppressorV2 (line 89) | public static Task VerifySuppressorV2(
method VerifySuppressorV2 (line 103) | public static Task VerifySuppressorV2(
method VerifySuppressorV2 (line 118) | public static Task VerifySuppressorV2(
method VerifyCompilerWarningSuppressorV2 (line 145) | public static Task VerifyCompilerWarningSuppressorV2(
method VerifySuppressorV3 (line 180) | public static Task VerifySuppressorV3(
method VerifySuppressorV3 (line 194) | public static Task VerifySuppressorV3(
method VerifySuppressorV3 (line 209) | public static Task VerifySuppressorV3(
method VerifyCompilerWarningSuppressorV3 (line 236) | public static Task VerifyCompilerWarningSuppressorV3(
FILE: src/xunit.analyzers.tests/Utility/CSharpVerifier.cs
class CSharpVerifier (line 13) | public partial class CSharpVerifier<TAnalyzer>
method Diagnostic (line 19) | public static DiagnosticResult Diagnostic() =>
method Diagnostic (line 26) | public static DiagnosticResult Diagnostic(string diagnosticId) =>
method CompilerError (line 33) | public static DiagnosticResult CompilerError(string errorIdentifier) =>
class TestBase (line 36) | class TestBase<TVerifier> : CSharpCodeFixTest<TAnalyzer, EmptyCodeFixP...
method TestBase (line 41) | protected TestBase(
method AddDiagnosticAnalyzer (line 68) | public void AddDiagnosticAnalyzer(DiagnosticAnalyzer analyzer) =>
method GetCodeFixProviders (line 71) | protected override IEnumerable<CodeFixProvider> GetCodeFixProviders()
method GetDiagnosticAnalyzers (line 80) | protected override IEnumerable<DiagnosticAnalyzer> GetDiagnosticAnal...
method CreateParseOptions (line 88) | protected override ParseOptions CreateParseOptions() =>
class TestV2 (line 92) | class TestV2 : TestBase<XunitVerifierV2>
method TestV2 (line 94) | public TestV2(LanguageVersion languageVersion) :
class TestV2RunnerUtility (line 99) | class TestV2RunnerUtility : TestBase<XunitVerifierV2>
method TestV2RunnerUtility (line 101) | public TestV2RunnerUtility(LanguageVersion languageVersion) :
class TestV3 (line 106) | class TestV3 : TestBase<XunitVerifierV3>
method TestV3 (line 108) | public TestV3(LanguageVersion languageVersion) :
class TestV3RunnerUtility (line 113) | class TestV3RunnerUtility : TestBase<XunitVerifierV3>
method TestV3RunnerUtility (line 115) | public TestV3RunnerUtility(LanguageVersion languageVersion) :
FILE: src/xunit.analyzers.tests/Utility/CodeAnalyzerHelper.cs
class CodeAnalyzerHelper (line 8) | static class CodeAnalyzerHelper
method CodeAnalyzerHelper (line 21) | static CodeAnalyzerHelper()
FILE: src/xunit.analyzers.tests/Utility/CodeFixProviderDiscovery.cs
class CodeFixProviderDiscovery (line 11) | static class CodeFixProviderDiscovery
method CodeFixProviderDiscovery (line 15) | static CodeFixProviderDiscovery()
method GetCodeFixProviders (line 32) | public static IEnumerable<CodeFixProvider> GetCodeFixProviders(string ...
class LanguageMetadata (line 40) | class LanguageMetadata
method LanguageMetadata (line 42) | public LanguageMetadata(IDictionary<string, object> data)
FILE: src/xunit.analyzers.tests/Utility/XunitVerifier.cs
class XunitVerifier (line 15) | public class XunitVerifier : IVerifier
method XunitVerifier (line 17) | public XunitVerifier() :
method XunitVerifier (line 21) | protected XunitVerifier(ImmutableStack<string> context) =>
method CreateMessage (line 26) | protected virtual string CreateMessage(string? message)
method Empty (line 34) | void IVerifier.Empty<T>(
method Equal (line 45) | void IVerifier.Equal<T>(
method Fail (line 59) | [DoesNotReturn]
method False (line 63) | void IVerifier.False(
method LanguageIsSupported (line 73) | void IVerifier.LanguageIsSupported(string language) =>
method NotEmpty (line 76) | void IVerifier.NotEmpty<T>(
method PushContext (line 86) | IVerifier IVerifier.PushContext(string context)
method SequenceEqual (line 93) | void IVerifier.SequenceEqual<T>(
method True (line 106) | void IVerifier.True(
class SequenceEqualEnumerableEqualityComparer (line 116) | sealed class SequenceEqualEnumerableEqualityComparer<T> : IEqualityCom...
method SequenceEqualEnumerableEqualityComparer (line 120) | public SequenceEqualEnumerableEqualityComparer(IEqualityComparer<T>?...
method Equals (line 123) | public bool Equals(IEnumerable<T>? x, IEnumerable<T>? y)
method GetHashCode (line 134) | public int GetHashCode(IEnumerable<T>? obj)
FILE: src/xunit.analyzers.tests/Utility/XunitVerifierV2.cs
class XunitVerifierV2 (line 5) | public class XunitVerifierV2 : XunitVerifier
method XunitVerifierV2 (line 7) | public XunitVerifierV2() :
FILE: src/xunit.analyzers.tests/Utility/XunitVerifierV3.cs
class XunitVerifierV3 (line 5) | public class XunitVerifierV3 : XunitVerifier
method XunitVerifierV3 (line 7) | public XunitVerifierV3() :
FILE: src/xunit.analyzers/Suppressors/ConsiderCallingConfigureAwaitSuppressor.cs
class ConsiderCallingConfigureAwaitSuppressor (line 10) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method ConsiderCallingConfigureAwaitSuppressor (line 13) | public ConsiderCallingConfigureAwaitSuppressor() :
method ShouldSuppress (line 17) | protected override bool ShouldSuppress(
FILE: src/xunit.analyzers/Suppressors/MakeTypesInternalSuppressor.cs
class MakeTypesInternalSuppressor (line 8) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method MakeTypesInternalSuppressor (line 11) | public MakeTypesInternalSuppressor() :
method ShouldSuppress (line 15) | protected override bool ShouldSuppress(
FILE: src/xunit.analyzers/Suppressors/NonNullableFieldInitializationSuppressor.cs
class NonNullableFieldInitializationSuppressor (line 10) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method NonNullableFieldInitializationSuppressor (line 13) | public NonNullableFieldInitializationSuppressor() :
method ShouldSuppress (line 17) | protected override bool ShouldSuppress(
method ResolveMemberSymbol (line 59) | static ISymbol? ResolveMemberSymbol(
method IsMemberAssignedInMethod (line 112) | static bool IsMemberAssignedInMethod(
FILE: src/xunit.analyzers/Suppressors/UseAsyncSuffixForAsyncMethodsSuppressor.cs
class UseAsyncSuffixForAsyncMethodsSuppressor (line 8) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method UseAsyncSuffixForAsyncMethodsSuppressor (line 11) | public UseAsyncSuffixForAsyncMethodsSuppressor() :
method ShouldSuppress (line 15) | protected override bool ShouldSuppress(
FILE: src/xunit.analyzers/Utility/AssertUsageAnalyzerBase.cs
class AssertUsageAnalyzerBase (line 9) | public abstract class AssertUsageAnalyzerBase(
method AssertUsageAnalyzerBase (line 16) | protected AssertUsageAnalyzerBase(
method AnalyzeCompilation (line 22) | public sealed override void AnalyzeCompilation(
method AnalyzeInvocation (line 46) | protected abstract void AnalyzeInvocation(
FILE: src/xunit.analyzers/Utility/Category.cs
type Category (line 3) | public enum Category
FILE: src/xunit.analyzers/Utility/CodeAnalysisExtensions.cs
class CodeAnalysisExtensions (line 11) | static class CodeAnalysisExtensions
method FindNamedType (line 13) | public static INamedTypeSymbol? FindNamedType(
method GetAttributesWithInheritance (line 25) | public static ImmutableArray<AttributeData> GetAttributesWithInheritance(
method IsInTestMethod (line 71) | public static (bool isInTestMethod, IOperation? lambdaOwner) IsInTestM...
method IsPointer (line 136) | public static bool IsPointer(
method IsTestClass (line 141) | public static bool IsTestClass(
method IsTestClassNonStrict (line 157) | static bool IsTestClassNonStrict(
method IsTestClassStrict (line 177) | static bool IsTestClassStrict(
method IsTestMethod (line 202) | public static bool IsTestMethod(
method WalkDownImplicitConversions (line 227) | public static IOperation WalkDownImplicitConversions(this IOperation o...
class NamedTypeVisitor (line 238) | sealed class NamedTypeVisitor(Func<INamedTypeSymbol, bool> selector) :
method VisitAssembly (line 245) | public override void VisitAssembly(IAssemblySymbol symbol) =>
method VisitNamespace (line 248) | public override void VisitNamespace(INamespaceSymbol symbol)
method VisitNamedType (line 259) | public override void VisitNamedType(INamedTypeSymbol symbol)
FILE: src/xunit.analyzers/Utility/Constants.cs
class Constants (line 3) | public static class Constants
class AssertArguments (line 8) | public static class AssertArguments
class Asserts (line 18) | public static class Asserts
class Attributes (line 72) | public static class Attributes
class AttributeProperties (line 81) | public static class AttributeProperties
class Properties (line 91) | public static class Properties
class Types (line 122) | public static class Types
class System (line 124) | public static class System
class Xunit (line 129) | public static class Xunit
FILE: src/xunit.analyzers/Utility/ConversionChecker.cs
class ConversionChecker (line 10) | static class ConversionChecker
method IsConvertible (line 26) | public static bool IsConvertible(
method IsConvertibleTypeParameter (line 68) | static bool IsConvertibleTypeParameter(
method IsConvertibleNumeric (line 80) | static bool IsConvertibleNumeric(
method IsDateTimeOffsetOrGuid (line 99) | static bool IsDateTimeOffsetOrGuid(ITypeSymbol destination)
method IsSigned (line 107) | static bool IsSigned(ITypeSymbol typeSymbol) =>
method IsUnsigned (line 110) | static bool IsUnsigned(ITypeSymbol typeSymbol) =>
FILE: src/xunit.analyzers/Utility/Descriptors.Suppressors.cs
class Descriptors (line 5) | public static partial class Descriptors
FILE: src/xunit.analyzers/Utility/Descriptors.cs
class Descriptors (line 6) | public static partial class Descriptors
method Diagnostic (line 10) | static DiagnosticDescriptor Diagnostic(
method Suppression (line 23) | static SuppressionDescriptor Suppression(
FILE: src/xunit.analyzers/Utility/Descriptors.xUnit1xxx.cs
class Descriptors (line 7) | public static partial class Descriptors
FILE: src/xunit.analyzers/Utility/Descriptors.xUnit2xxx.cs
class Descriptors (line 7) | public static partial class Descriptors
FILE: src/xunit.analyzers/Utility/Descriptors.xUnit3xxx.cs
class Descriptors (line 7) | public static partial class Descriptors
FILE: src/xunit.analyzers/Utility/EmptyAssertContext.cs
class EmptyAssertContext (line 6) | public class EmptyAssertContext : IAssertContext
method EmptyAssertContext (line 8) | EmptyAssertContext()
FILE: src/xunit.analyzers/Utility/EmptyCommonContext.cs
class EmptyCommonContext (line 6) | public class EmptyCommonContext : ICommonContext
method EmptyCommonContext (line 8) | EmptyCommonContext()
FILE: src/xunit.analyzers/Utility/EmptyCoreContext.cs
class EmptyCoreContext (line 6) | public class EmptyCoreContext : ICoreContext
method EmptyCoreContext (line 8) | EmptyCoreContext()
FILE: src/xunit.analyzers/Utility/EmptyRunnerUtilityContext.cs
class EmptyRunnerUtilityContext (line 6) | public class EmptyRunnerUtilityContext : IRunnerUtilityContext
method EmptyRunnerUtilityContext (line 8) | EmptyRunnerUtilityContext()
FILE: src/xunit.analyzers/Utility/EnumerableExtensions.cs
class EnumerableExtensions (line 9) | static partial class EnumerableExtensions
method Add (line 13) | public static void Add<TKey, TValue>(
method AddRange (line 28) | public static void AddRange<T>(
method WhereNotNull (line 43) | public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T?> source)
FILE: src/xunit.analyzers/Utility/IAssertContext.cs
type IAssertContext (line 6) | public interface IAssertContext
FILE: src/xunit.analyzers/Utility/ICommonContext.cs
type ICommonContext (line 10) | public interface ICommonContext
FILE: src/xunit.analyzers/Utility/ICoreContext.cs
type ICoreContext (line 6) | public interface ICoreContext
FILE: src/xunit.analyzers/Utility/IRunnerUtilityContext.cs
type IRunnerUtilityContext (line 6) | public interface IRunnerUtilityContext
FILE: src/xunit.analyzers/Utility/Serializability.cs
type Serializability (line 3) | public enum Serializability
FILE: src/xunit.analyzers/Utility/SerializabilityAnalyzer.cs
class SerializabilityAnalyzer (line 8) | public sealed class SerializabilityAnalyzer(SerializableTypeSymbols type...
method AnalayzeSerializability (line 19) | public Serializability AnalayzeSerializability(
method GetSpecialTypeSerializability (line 87) | static Serializability GetSpecialTypeSerializability(SpecialType type) =>
method GetTypeKindSerializability (line 118) | static Serializability GetTypeKindSerializability(TypeKind kind) =>
method TypeKindShouldBeIgnored (line 130) | static bool TypeKindShouldBeIgnored(TypeKind kind) =>
method TypeShouldBeIgnored (line 155) | public bool TypeShouldBeIgnored([NotNullWhen(false)] ITypeSymbol? type)
FILE: src/xunit.analyzers/Utility/SerializableTypeSymbols.cs
class SerializableTypeSymbols (line 9) | public sealed class SerializableTypeSymbols
method SerializableTypeSymbols (line 31) | SerializableTypeSymbols(
method Create (line 109) | public static SerializableTypeSymbols? Create(
method GetTraitDictionary (line 136) | static INamedTypeSymbol? GetTraitDictionary(Compilation compilation)
method TheoryData (line 149) | public INamedTypeSymbol? TheoryData(int arity)
FILE: src/xunit.analyzers/Utility/SymbolExtensions.cs
class SymbolExtensions (line 8) | public static class SymbolExtensions
method ContainsAttributeType (line 10) | public static bool ContainsAttributeType(
method GetAsyncEnumerableType (line 20) | public static ITypeSymbol? GetAsyncEnumerableType(this ITypeSymbol? ty...
method GetEnumerableType (line 38) | public static ITypeSymbol? GetEnumerableType(this ITypeSymbol? typeSym...
method GetGenericInterfaceImplementation (line 49) | public static INamedTypeSymbol? GetGenericInterfaceImplementation(
method GetMember (line 62) | public static ISymbol? GetMember(
method GetInheritedAndOwnMembers (line 67) | public static ImmutableArray<ISymbol> GetInheritedAndOwnMembers(
method IsAssignableFrom (line 81) | public static bool IsAssignableFrom(
method IsInstanceOf (line 167) | public static bool IsInstanceOf(
method UnwrapEnumerable (line 176) | public static ITypeSymbol? UnwrapEnumerable(
method UnwrapEnumerable (line 197) | public static ITypeSymbol? UnwrapEnumerable(
method UnwrapNullable (line 219) | public static ITypeSymbol UnwrapNullable(this ITypeSymbol type)
FILE: src/xunit.analyzers/Utility/SyntaxExtensions.cs
class SyntaxExtensions (line 8) | public static class SyntaxExtensions
method ContainsAttributeType (line 10) | public static bool ContainsAttributeType(
method GetSimpleName (line 32) | public static SimpleNameSyntax? GetSimpleName(this InvocationExpressio...
method IsEnumValueExpression (line 40) | public static bool IsEnumValueExpression(
method IsNameofExpression (line 55) | public static bool IsNameofExpression(
FILE: src/xunit.analyzers/Utility/TypeHierarchyComparer.cs
class TypeHierarchyComparer (line 7) | public class TypeHierarchyComparer : IComparer<ITypeSymbol>
method TypeHierarchyComparer (line 9) | TypeHierarchyComparer()
method Compare (line 14) | public int Compare(
FILE: src/xunit.analyzers/Utility/TypeSymbolFactory.cs
class TypeSymbolFactory (line 8) | public static class TypeSymbolFactory
method Action (line 10) | public static INamedTypeSymbol? Action(Compilation compilation) =>
method Action (line 13) | public static INamedTypeSymbol? Action(
method ArraySegmentOfT (line 18) | public static INamedTypeSymbol? ArraySegmentOfT(Compilation compilatio...
method AssemblyFixtureAttribute_V3 (line 21) | public static INamedTypeSymbol? AssemblyFixtureAttribute_V3(Compilatio...
method Assert (line 24) | public static INamedTypeSymbol? Assert(Compilation compilation) =>
method AttributeUsageAttribute (line 27) | public static INamedTypeSymbol? AttributeUsageAttribute(Compilation co...
method BigInteger (line 30) | public static INamedTypeSymbol? BigInteger(Compilation compilation) =>
method CallerFilePathAttribute (line 33) | public static INamedTypeSymbol? CallerFilePathAttribute(Compilation co...
method CallerLineNumberAttribute (line 36) | public static INamedTypeSymbol? CallerLineNumberAttribute(Compilation ...
method CancellationToken (line 39) | public static INamedTypeSymbol? CancellationToken(Compilation compilat...
method ClassDataAttribute (line 42) | public static INamedTypeSymbol? ClassDataAttribute(Compilation compila...
method ClassDataAttributeOfT_V3 (line 45) | public static INamedTypeSymbol? ClassDataAttributeOfT_V3(Compilation c...
method CollectionAttribute (line 48) | public static INamedTypeSymbol? CollectionAttribute(Compilation compil...
method CollectionAttributeOfT_V3 (line 51) | public static INamedTypeSymbol? CollectionAttributeOfT_V3(Compilation ...
method CollectionDefinitionAttribute (line 54) | public static INamedTypeSymbol? CollectionDefinitionAttribute(Compilat...
method ConfigureAwaitOptions (line 57) | public static INamedTypeSymbol? ConfigureAwaitOptions(Compilation comp...
method ConfiguredTaskAwaitable (line 60) | public static INamedTypeSymbol? ConfiguredTaskAwaitable(Compilation co...
method DataAttribute_V2 (line 63) | public static INamedTypeSymbol? DataAttribute_V2(Compilation compilati...
method DataAttribute_V3 (line 66) | public static INamedTypeSymbol? DataAttribute_V3(Compilation compilati...
method DateOnly (line 69) | public static INamedTypeSymbol? DateOnly(Compilation compilation) =>
method DateTimeOffset (line 72) | public static INamedTypeSymbol? DateTimeOffset(Compilation compilation...
method DictionaryofTKeyTValue (line 75) | public static INamedTypeSymbol? DictionaryofTKeyTValue(Compilation com...
method FactAttribute (line 78) | public static INamedTypeSymbol? FactAttribute(Compilation compilation) =>
method Func (line 81) | public static INamedTypeSymbol? Func(
method Guid (line 86) | public static INamedTypeSymbol? Guid(Compilation compilation) =>
method IAssemblyInfo_V2 (line 89) | public static INamedTypeSymbol? IAssemblyInfo_V2(Compilation compilati...
method IAsyncEnumerableOfITheoryDataRow (line 92) | public static INamedTypeSymbol? IAsyncEnumerableOfITheoryDataRow(Compi...
method IAsyncEnumerableOfObjectArray (line 105) | public static INamedTypeSymbol? IAsyncEnumerableOfObjectArray(Compilat...
method IAsyncEnumerableOfT (line 115) | public static INamedTypeSymbol? IAsyncEnumerableOfT(Compilation compil...
method IAsyncEnumerableOfTuple (line 118) | public static INamedTypeSymbol? IAsyncEnumerableOfTuple(Compilation co...
method IAsyncLifetime (line 127) | public static INamedTypeSymbol? IAsyncLifetime(Compilation compilation...
method IAttributeInfo_V2 (line 130) | public static INamedTypeSymbol? IAttributeInfo_V2(Compilation compilat...
method IClassFixureOfT (line 133) | public static INamedTypeSymbol? IClassFixureOfT(Compilation compilatio...
method ICollection (line 136) | public static INamedTypeSymbol? ICollection(Compilation compilation) =>
method ICollectionFixtureOfT (line 139) | public static INamedTypeSymbol? ICollectionFixtureOfT(Compilation comp...
method ICollectionOfT (line 142) | public static INamedTypeSymbol ICollectionOfT(Compilation compilation) =>
method ICriticalNotifyCompletion (line 145) | public static INamedTypeSymbol? ICriticalNotifyCompletion(Compilation ...
method IDataAttribute_V3 (line 148) | public static INamedTypeSymbol? IDataAttribute_V3(Compilation compilat...
method IDisposable (line 151) | public static INamedTypeSymbol IDisposable(Compilation compilation) =>
method IEnumerableOfITheoryDataRow (line 154) | public static INamedTypeSymbol? IEnumerableOfITheoryDataRow(Compilatio...
method IEnumerableOfObjectArray (line 163) | public static INamedTypeSymbol IEnumerableOfObjectArray(Compilation co...
method IEnumerableOfT (line 166) | public static INamedTypeSymbol IEnumerableOfT(Compilation compilation) =>
method IEnumerableOfTuple (line 169) | public static INamedTypeSymbol? IEnumerableOfTuple(Compilation compila...
method IFormattable (line 178) | public static INamedTypeSymbol? IFormattable(Compilation compilation) =>
method IMessageSink_V2 (line 181) | public static INamedTypeSymbol? IMessageSink_V2(Compilation compilatio...
method IMessageSink_V3 (line 184) | public static INamedTypeSymbol? IMessageSink_V3(Compilation compilatio...
method IMessageSinkMessage_V2 (line 187) | public static INamedTypeSymbol? IMessageSinkMessage_V2(Compilation com...
method IMethodInfo_V2 (line 190) | public static INamedTypeSymbol? IMethodInfo_V2(Compilation compilation...
method Index (line 193) | public static INamedTypeSymbol? Index(Compilation compilation) =>
method InlineDataAttribute (line 196) | public static INamedTypeSymbol? InlineDataAttribute(Compilation compil...
method IParameterInfo_V2 (line 199) | public static INamedTypeSymbol? IParameterInfo_V2(Compilation compilat...
method IParsableOfT (line 202) | public static INamedTypeSymbol? IParsableOfT(Compilation compilation) =>
method IReadOnlyCollectionOfT (line 205) | public static INamedTypeSymbol IReadOnlyCollectionOfT(Compilation comp...
method IReadOnlySetOfT (line 208) | public static INamedTypeSymbol? IReadOnlySetOfT(Compilation compilatio...
method IRunnerReporter_V3 (line 211) | public static INamedTypeSymbol? IRunnerReporter_V3(Compilation compila...
method ISetOfT (line 214) | public static INamedTypeSymbol? ISetOfT(Compilation compilation) =>
method ISourceInformation_V2 (line 217) | public static INamedTypeSymbol? ISourceInformation_V2(Compilation comp...
method ISourceInformationProvider_V2 (line 220) | public static INamedTypeSymbol? ISourceInformationProvider_V2(Compilat...
method ISourceInformationProvider_V3 (line 223) | public static INamedTypeSymbol? ISourceInformationProvider_V3(Compilat...
method ITest_V2 (line 226) | public static INamedTypeSymbol? ITest_V2(Compilation compilation) =>
method ITest_V3 (line 229) | public static INamedTypeSymbol? ITest_V3(Compilation compilation) =>
method ITestAssembly_V2 (line 232) | public static INamedTypeSymbol? ITestAssembly_V2(Compilation compilati...
method ITestAssembly_V3 (line 235) | public static INamedTypeSymbol? ITestAssembly_V3(Compilation compilati...
method ITestCase_V2 (line 238) | public static INamedTypeSymbol? ITestCase_V2(Compilation compilation) =>
method ITestCase_V3 (line 241) | public static INamedTypeSymbol? ITestCase_V3(Compilation compilation) =>
method ITestClass_V2 (line 244) | public static INamedTypeSymbol? ITestClass_V2(Compilation compilation) =>
method ITestClass_V3 (line 247) | public static INamedTypeSymbol? ITestClass_V3(Compilation compilation) =>
method ITestCollection_V2 (line 250) | public static INamedTypeSymbol? ITestCollection_V2(Compilation compila...
method ITestCollection_V3 (line 253) | public static INamedTypeSymbol? ITestCollection_V3(Compilation compila...
method ITestContextAccessor_V3 (line 256) | public static INamedTypeSymbol? ITestContextAccessor_V3(Compilation co...
method ITestFramework_V2 (line 259) | public static INamedTypeSymbol? ITestFramework_V2(Compilation compilat...
method ITestFramework_V3 (line 262) | public static INamedTypeSymbol? ITestFramework_V3(Compilation compilat...
method ITestFrameworkDiscoverer_V2 (line 265) | public static INamedTypeSymbol? ITestFrameworkDiscoverer_V2(Compilatio...
method ITestFrameworkDiscoverer_V3 (line 268) | public static INamedTypeSymbol? ITestFrameworkDiscoverer_V3(Compilatio...
method ITestFrameworkExecutor_V2 (line 271) | public static INamedTypeSymbol? ITestFrameworkExecutor_V2(Compilation ...
method ITestFrameworkExecutor_V3 (line 274) | public static INamedTypeSymbol? ITestFrameworkExecutor_V3(Compilation ...
method ITestMethod_V2 (line 277) | public static INamedTypeSymbol? ITestMethod_V2(Compilation compilation...
method ITestMethod_V3 (line 280) | public static INamedTypeSymbol? ITestMethod_V3(Compilation compilation...
method ITestOutputHelper_V2 (line 283) | public static INamedTypeSymbol? ITestOutputHelper_V2(Compilation compi...
method ITestOutputHelper_V3 (line 286) | public static INamedTypeSymbol? ITestOutputHelper_V3(Compilation compi...
method ITheoryDataRow_V3 (line 289) | public static INamedTypeSymbol? ITheoryDataRow_V3(Compilation compilat...
method ITuple (line 292) | public static INamedTypeSymbol? ITuple(Compilation compilation) =>
method ITypeInfo_V2 (line 295) | public static INamedTypeSymbol? ITypeInfo_V2(Compilation compilation) =>
method IValueTaskSource (line 298) | public static INamedTypeSymbol? IValueTaskSource(Compilation compilati...
method IValueTaskSourceOfT (line 301) | public static INamedTypeSymbol? IValueTaskSourceOfT(Compilation compil...
method IXunitSerializable_V2 (line 304) | public static INamedTypeSymbol? IXunitSerializable_V2(Compilation comp...
method IXunitSerializable_V3 (line 307) | public static INamedTypeSymbol? IXunitSerializable_V3(Compilation comp...
method IXunitSerializer_V3 (line 310) | public static INamedTypeSymbol? IXunitSerializer_V3(Compilation compil...
method JsonTypeIDAttribute_V3 (line 313) | public static INamedTypeSymbol? JsonTypeIDAttribute_V3(Compilation com...
method ListOfT (line 316) | public static INamedTypeSymbol? ListOfT(Compilation compilation) =>
method LongLivedMarshalByRefObject_ExecutionV2 (line 319) | public static INamedTypeSymbol? LongLivedMarshalByRefObject_ExecutionV...
method LongLivedMarshalByRefObject_RunnerUtility (line 322) | public static INamedTypeSymbol? LongLivedMarshalByRefObject_RunnerUtil...
method MemberDataAttribute (line 325) | public static INamedTypeSymbol? MemberDataAttribute(Compilation compil...
method NullableOfT (line 328) | public static INamedTypeSymbol NullableOfT(Compilation compilation) =>
method ObjectArray (line 331) | public static IArrayTypeSymbol ObjectArray(Compilation compilation) =>
method ObsoleteAttribute (line 334) | public static INamedTypeSymbol? ObsoleteAttribute(Compilation compilat...
method OptionalAttribute (line 337) | public static INamedTypeSymbol? OptionalAttribute(Compilation compilat...
method Range (line 340) | public static INamedTypeSymbol? Range(Compilation compilation) =>
method Record (line 343) | public static INamedTypeSymbol? Record(Compilation compilation) =>
method RegisterXunitSerializerAttribute_V3 (line 346) | public static INamedTypeSymbol? RegisterXunitSerializerAttribute_V3(Co...
method SortedSetOfT (line 349) | public static INamedTypeSymbol? SortedSetOfT(Compilation compilation) =>
method String (line 352) | public static INamedTypeSymbol String(Compilation compilation) =>
method StringValues (line 355) | public static INamedTypeSymbol? StringValues(Compilation compilation) =>
method Task (line 358) | public static INamedTypeSymbol? Task(Compilation compilation) =>
method TaskOfT (line 361) | public static INamedTypeSymbol? TaskOfT(Compilation compilation) =>
method TestContext_V3 (line 364) | public static INamedTypeSymbol? TestContext_V3(Compilation compilation...
method TheoryAttribute (line 367) | public static INamedTypeSymbol? TheoryAttribute(Compilation compilatio...
method TheoryData (line 370) | public static INamedTypeSymbol? TheoryData(Compilation compilation) =>
method TheoryData_ByGenericArgumentCount (line 375) | public static Dictionary<int, INamedTypeSymbol> TheoryData_ByGenericAr...
method TheoryDataRow_V3 (line 395) | public static INamedTypeSymbol? TheoryDataRow_V3(Compilation compilati...
method TheoryDataRow_ByGenericArgumentCount_V3 (line 400) | public static Dictionary<int, INamedTypeSymbol> TheoryDataRow_ByGeneri...
method TimeOnly (line 420) | public static INamedTypeSymbol? TimeOnly(Compilation compilation) =>
method TimeSpan (line 423) | public static INamedTypeSymbol? TimeSpan(Compilation compilation) =>
method Type (line 426) | public static INamedTypeSymbol? Type(Compilation compilation) =>
method ValidateArity (line 429) | static int ValidateArity(
method Uri (line 440) | public static INamedTypeSymbol? Uri(Compilation compilation) =>
method ValueTask (line 443) | public static INamedTypeSymbol? ValueTask(Compilation compilation) =>
method ValueTaskOfT (line 446) | public static INamedTypeSymbol? ValueTaskOfT(Compilation compilation) =>
method Version (line 449) | public static INamedTypeSymbol? Version(Compilation compilation) =>
method Void (line 452) | public static INamedTypeSymbol Void(Compilation compilation) =>
FILE: src/xunit.analyzers/Utility/V2AbstractionsContext.cs
class V2AbstractionsContext (line 7) | public class V2AbstractionsContext : ICommonContext
method V2AbstractionsContext (line 29) | V2AbstractionsContext(
method Get (line 151) | public static V2AbstractionsContext? Get(
FILE: src/xunit.analyzers/Utility/V2AssertContext.cs
class V2AssertContext (line 7) | public class V2AssertContext : IAssertContext
method V2AssertContext (line 14) | V2AssertContext(
method Get (line 42) | public static V2AssertContext? Get(
FILE: src/xunit.analyzers/Utility/V2CoreContext.cs
class V2CoreContext (line 7) | public class V2CoreContext : ICoreContext
method V2CoreContext (line 24) | V2CoreContext(
method Get (line 105) | public static V2CoreContext? Get(
FILE: src/xunit.analyzers/Utility/V2ExecutionContext.cs
class V2ExecutionContext (line 7) | public class V2ExecutionContext
method V2ExecutionContext (line 12) | V2ExecutionContext(
method Get (line 40) | public static V2ExecutionContext? Get(
FILE: src/xunit.analyzers/Utility/V2RunnerUtilityContext.cs
class V2RunnerUtilityContext (line 7) | public class V2RunnerUtilityContext : IRunnerUtilityContext
method V2RunnerUtilityContext (line 12) | V2RunnerUtilityContext(
method Get (line 33) | public static V2RunnerUtilityContext? Get(
FILE: src/xunit.analyzers/Utility/V3AssertContext.cs
class V3AssertContext (line 7) | public class V3AssertContext : IAssertContext
method V3AssertContext (line 14) | V3AssertContext(
method Get (line 41) | public static V3AssertContext? Get(
FILE: src/xunit.analyzers/Utility/V3CommonContext.cs
class V3CommonContext (line 7) | public class V3CommonContext : ICommonContext
method V3CommonContext (line 23) | V3CommonContext(
method Get (line 116) | public static V3CommonContext? Get(
FILE: src/xunit.analyzers/Utility/V3CoreContext.cs
class V3CoreContext (line 7) | public class V3CoreContext : ICoreContext
method V3CoreContext (line 27) | V3CoreContext(
method Get (line 144) | public static V3CoreContext? Get(
FILE: src/xunit.analyzers/Utility/V3RunnerCommonContext.cs
class V3RunnerCommonContext (line 7) | public class V3RunnerCommonContext
method V3RunnerCommonContext (line 11) | V3RunnerCommonContext(
method Get (line 26) | public static V3RunnerCommonContext? Get(
FILE: src/xunit.analyzers/Utility/V3RunnerUtilityContext.cs
class V3RunnerUtilityContext (line 7) | public class V3RunnerUtilityContext : IRunnerUtilityContext
method V3RunnerUtilityContext (line 12) | V3RunnerUtilityContext(
method Get (line 33) | public static V3RunnerUtilityContext? Get(
FILE: src/xunit.analyzers/Utility/XunitContext.cs
class XunitContext (line 9) | public class XunitContext
method XunitContext (line 17) | XunitContext()
method XunitContext (line 25) | public XunitContext(Compilation compilation)
method ForV2 (line 177) | public static XunitContext ForV2(
method ForV2Abstractions (line 191) | public static XunitContext ForV2Abstractions(Compilation compilation) =>
method ForV2Assert (line 203) | public static XunitContext ForV2Assert(
method ForV2Execution (line 217) | public static XunitContext ForV2Execution(
method ForV2RunnerUtility (line 232) | public static XunitContext ForV2RunnerUtility(
method ForV3 (line 248) | public static XunitContext ForV3(
method ForV3Assert (line 265) | public static XunitContext ForV3Assert(
FILE: src/xunit.analyzers/Utility/XunitDiagnosticAnalyzer.cs
class XunitDiagnosticAnalyzer (line 10) | public abstract class XunitDiagnosticAnalyzer(params DiagnosticDescripto...
method AnalyzeCompilation (line 23) | public abstract void AnalyzeCompilation(
method CreateXunitContext (line 33) | protected virtual XunitContext CreateXunitContext(Compilation compilat...
method Initialize (line 37) | public sealed override void Initialize(AnalysisContext context)
method ShouldAnalyze (line 58) | protected virtual bool ShouldAnalyze(XunitContext xunitContext) =>
FILE: src/xunit.analyzers/Utility/XunitDiagnosticSuppressor.cs
class XunitDiagnosticSuppressor (line 11) | public abstract class XunitDiagnosticSuppressor(SuppressionDescriptor de...
method CreateXunitContext (line 27) | protected virtual XunitContext CreateXunitContext(Compilation compilat...
method ReportSuppressions (line 31) | public sealed override void ReportSuppressions(SuppressionAnalysisCont...
method ShouldAnalyze (line 47) | protected virtual bool ShouldAnalyze(XunitContext xunitContext) =>
method ShouldSuppress (line 56) | protected abstract bool ShouldSuppress(
FILE: src/xunit.analyzers/Utility/XunitV2DiagnosticAnalyzer.cs
class XunitV2DiagnosticAnalyzer (line 8) | public abstract class XunitV2DiagnosticAnalyzer(params DiagnosticDescrip...
method ShouldAnalyze (line 11) | protected override bool ShouldAnalyze(XunitContext xunitContext) =>
FILE: src/xunit.analyzers/Utility/XunitV2DiagnosticSuppressor.cs
class XunitV2DiagnosticSuppressor (line 9) | public abstract class XunitV2DiagnosticSuppressor(SuppressionDescriptor ...
method ShouldAnalyze (line 12) | protected override bool ShouldAnalyze(XunitContext xunitContext) =>
FILE: src/xunit.analyzers/Utility/XunitV3DiagnosticAnalyzer.cs
class XunitV3DiagnosticAnalyzer (line 8) | public abstract class XunitV3DiagnosticAnalyzer(params DiagnosticDescrip...
method ShouldAnalyze (line 11) | protected override bool ShouldAnalyze(XunitContext xunitContext) =>
FILE: src/xunit.analyzers/Utility/XunitV3DiagnosticSuppressor.cs
class XunitV3DiagnosticSuppressor (line 9) | public abstract class XunitV3DiagnosticSuppressor(SuppressionDescriptor ...
method ShouldAnalyze (line 12) | protected override bool ShouldAnalyze(XunitContext xunitContext) =>
FILE: src/xunit.analyzers/X1000/ClassDataAttributeMustPointAtValidClass.cs
class ClassDataAttributeMustPointAtValidClass (line 12) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method ClassDataAttributeMustPointAtValidClass (line 18) | public ClassDataAttributeMustPointAtValidClass() :
method AnalyzeCompilation (line 29) | public override void AnalyzeCompilation(
method IsGenericTheoryDataRowType (line 102) | static bool IsGenericTheoryDataRowType(
method ReportClassReturnsUnsafeTypeValue (line 126) | static void ReportClassReturnsUnsafeTypeValue(
method ReportExtraTypeArguments (line 136) | static void ReportExtraTypeArguments(
method ReportIncompatibleType (line 148) | static void ReportIncompatibleType(
method ReportIncorrectImplementationType (line 164) | static void ReportIncorrectImplementationType(
method ReportNullabilityMismatch (line 178) | static void ReportNullabilityMismatch(
method ReportTooFewTypeArguments (line 194) | static void ReportTooFewTypeArguments(
method VerifyDataSourceDeclaration (line 206) | static bool VerifyDataSourceDeclaration(
method VerifyGenericArgumentTypes (line 248) | static void VerifyGenericArgumentTypes(
FILE: src/xunit.analyzers/X1000/CollectionDefinitionsMustBePublic.cs
class CollectionDefinitionClassesMustBePublic (line 7) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method CollectionDefinitionClassesMustBePublic (line 10) | public CollectionDefinitionClassesMustBePublic() :
method AnalyzeCompilation (line 14) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/ConstructorsOnFactAttributeSubclassShouldBePublic.cs
class ConstructorsOnFactAttributeSubclassShouldBePublic (line 7) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method ConstructorsOnFactAttributeSubclassShouldBePublic (line 10) | public ConstructorsOnFactAttributeSubclassShouldBePublic() :
method AnalyzeCompilation (line 14) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/DataAttributeShouldBeUsedOnATheory.cs
class DataAttributeShouldBeUsedOnATheory (line 9) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method DataAttributeShouldBeUsedOnATheory (line 12) | public DataAttributeShouldBeUsedOnATheory() :
method AnalyzeCompilation (line 16) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/DoNotUseAsyncVoidForTestMethods.cs
class DoNotUseAsyncVoidForTestMethods (line 8) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method DoNotUseAsyncVoidForTestMethods (line 11) | public DoNotUseAsyncVoidForTestMethods() :
method AnalyzeCompilation (line 18) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/DoNotUseBlockingTaskOperations.cs
method DoNotUseBlockingTaskOperations (line 45) | public DoNotUseBlockingTaskOperations() :
method AnalyzeCompilation (line 49) | public override void AnalyzeCompilation(
method FindSymbol (line 172) | static bool FindSymbol(
method TaskIsKnownToBeCompleted (line 208) | static bool TaskIsKnownToBeCompleted(
FILE: src/xunit.analyzers/X1000/DoNotUseConfigureAwait.cs
class DoNotUseConfigureAwait (line 14) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method DoNotUseConfigureAwait (line 17) | public DoNotUseConfigureAwait() :
method AnalyzeCompilation (line 21) | public override void AnalyzeCompilation(
method ContainsContinueOnCapturedContext (line 135) | static bool ContainsContinueOnCapturedContext(
FILE: src/xunit.analyzers/X1000/EnsureFixturesHaveASource.cs
class EnsureFixturesHaveASource (line 9) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method EnsureFixturesHaveASource (line 12) | public EnsureFixturesHaveASource() :
method AnalyzeCompilation (line 16) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/FactMethodMustNotHaveParameters.cs
class FactMethodMustNotHaveParameters (line 7) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method FactMethodMustNotHaveParameters (line 10) | public FactMethodMustNotHaveParameters() :
method AnalyzeCompilation (line 14) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/FactMethodShouldNotHaveTestData.cs
class FactMethodShouldNotHaveTestData (line 9) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method FactMethodShouldNotHaveTestData (line 12) | public FactMethodShouldNotHaveTestData() :
method AnalyzeCompilation (line 16) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/InlineDataMustMatchTheoryParameters.cs
class InlineDataMustMatchTheoryParameters (line 12) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method InlineDataMustMatchTheoryParameters (line 15) | public InlineDataMustMatchTheoryParameters() :
method AnalyzeCompilation (line 24) | public override void AnalyzeCompilation(
method RequiresMatchingValue (line 224) | static bool RequiresMatchingValue(
method GetParameterExpressionsFromArrayArgument (line 233) | static IList<ExpressionSyntax>? GetParameterExpressionsFromArrayArgume...
type ParameterArrayStyleType (line 253) | public enum ParameterArrayStyleType
FILE: src/xunit.analyzers/X1000/InlineDataShouldBeUniqueWithinTheory.cs
class InlineDataShouldBeUniqueWithinTheory (line 10) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method InlineDataShouldBeUniqueWithinTheory (line 13) | public InlineDataShouldBeUniqueWithinTheory() :
method AnalyzeCompilation (line 17) | public override void AnalyzeCompilation(
method AnalyzeMethod (line 27) | static void AnalyzeMethod(
method AnalyzeInlineDataAttributesWithinTheory (line 49) | static void AnalyzeInlineDataAttributesWithinTheory(
method GetAttributeSyntax (line 73) | static AttributeSyntax? GetAttributeSyntax(
method ReportDuplicate (line 78) | static void ReportDuplicate(
method HasAttributeDeclarationNoCompilationErrors (line 99) | static bool HasAttributeDeclarationNoCompilationErrors(
class InlineDataUniquenessComparer (line 105) | sealed class InlineDataUniquenessComparer(IMethodSymbol attributeRelat...
method Equals (line 114) | public bool Equals(
method AreArgumentsEqual (line 134) | static bool AreArgumentsEqual(
method IsSingleNullByInlineDataOrByDefaultParamValue (line 207) | static bool IsSingleNullByInlineDataOrByDefaultParamValue(ImmutableA...
method GetHashCode (line 224) | public int GetHashCode(AttributeData attributeData)
method GetFlattenedArgumentPrimitives (line 237) | static ImmutableArray<object?> GetFlattenedArgumentPrimitives(IEnume...
method GetEffectiveTestArguments (line 270) | ImmutableArray<object> GetEffectiveTestArguments(AttributeData attri...
FILE: src/xunit.analyzers/X1000/LocalFunctionsCannotBeTestFunctions.cs
class LocalFunctionsCannotBeTestFunctions (line 9) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method LocalFunctionsCannotBeTestFunctions (line 12) | public LocalFunctionsCannotBeTestFunctions() :
method AnalyzeCompilation (line 16) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/MemberDataShouldReferenceValidMember.cs
class MemberDataShouldReferenceValidMember (line 17) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method MemberDataShouldReferenceValidMember (line 20) | public MemberDataShouldReferenceValidMember() :
method AnalyzeCompilation (line 42) | public override void AnalyzeCompilation(
method IsInitialized (line 203) | static bool IsInitialized(
method FindMemberSymbol (line 253) | static ISymbol? FindMemberSymbol(
method FindMethodSymbol (line 273) | public static ISymbol? FindMethodSymbol(
method FindTypeArgumentFromIEnumerable (line 297) | static ITypeSymbol? FindTypeArgumentFromIEnumerable(
method GetClassTypesForAttribute (line 333) | public static (INamedTypeSymbol? TestClass, ITypeSymbol? MemberClass) ...
method GetParameterExpressionsFromArrayArgument (line 357) | static IList<ExpressionSyntax>? GetParameterExpressionsFromArrayArgument(
method IsGenericTheoryDataRowType (line 386) | static bool IsGenericTheoryDataRowType(
method IsTheoryDataType (line 420) | static bool IsTheoryDataType(
method ShouldSuppressX1015BecauseAllDerivedConcreteTypesHaveMember (line 446) | static bool ShouldSuppressX1015BecauseAllDerivedConcreteTypesHaveMember(
method ReportIllegalNonMethodArguments (line 508) | static void ReportIllegalNonMethodArguments(
method ReportIncorrectMemberType (line 523) | static void ReportIncorrectMemberType(
method ReportIncorrectReturnType (line 533) | static void ReportIncorrectReturnType(
method ReportMemberMethodParametersDoNotMatchArgumentTypes (line 576) | static void ReportMemberMethodParametersDoNotMatchArgumentTypes(
method ReportMemberMethodParameterNullability (line 592) | static void ReportMemberMethodParameterNullability(
method ReportMemberMethodTheoryDataExtraTypeArguments (line 608) | static void ReportMemberMethodTheoryDataExtraTypeArguments(
method ReportMemberMethodTheoryDataIncompatibleType (line 622) | static void ReportMemberMethodTheoryDataIncompatibleType(
method ReportMemberMethodTheoryDataNullability (line 639) | static void ReportMemberMethodTheoryDataNullability(
method ReportMemberMethodTheoryDataTooFewTypeArguments (line 656) | static void ReportMemberMethodTheoryDataTooFewTypeArguments(
method ReportMemberMustBeWrittenTo (line 670) | static void ReportMemberMustBeWrittenTo(
method ReportMissingMember (line 681) | static void ReportMissingMember(
method ReportNonPublicAccessibility (line 702) | static void ReportNonPublicAccessibility(
method ReportNonPublicPropertyGetter (line 714) | static void ReportNonPublicPropertyGetter(
method ReportMemberReturnsTypeUnsafeValue (line 724) | static void ReportMemberReturnsTypeUnsafeValue(
method ReportNonStatic (line 736) | static void ReportNonStatic(
method ReportTooManyArgumentsProvided (line 748) | static void ReportTooManyArgumentsProvided(
method ReportUseNameof (line 762) | static void ReportUseNameof(
method ResolveDeclaredBaseTypeFromSyntax (line 788) | static ITypeSymbol? ResolveDeclaredBaseTypeFromSyntax(
method VerifyDataMethodParameterUsage (line 830) | static void VerifyDataMethodParameterUsage(
method VerifyDataSourceReturnType (line 941) | static bool VerifyDataSourceReturnType(
method VerifyGenericArgumentTypes (line 1005) | static void VerifyGenericArgumentTypes(
FILE: src/xunit.analyzers/X1000/PublicMethodShouldBeMarkedAsTest.cs
class PublicMethodShouldBeMarkedAsTest (line 9) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method PublicMethodShouldBeMarkedAsTest (line 12) | public PublicMethodShouldBeMarkedAsTest() :
method AnalyzeCompilation (line 16) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/TestClassCannotBeNestedInGenericClass.cs
class TestClassCannotBeNestedInGenericClass (line 7) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method TestClassCannotBeNestedInGenericClass (line 10) | public TestClassCannotBeNestedInGenericClass() :
method AnalyzeCompilation (line 14) | public override void AnalyzeCompilation(
method DoesInheritenceTreeContainTests (line 46) | static bool DoesInheritenceTreeContainTests(
FILE: src/xunit.analyzers/X1000/TestClassMustBePublic.cs
class TestClassMustBePublic (line 7) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method TestClassMustBePublic (line 10) | public TestClassMustBePublic() :
method AnalyzeCompilation (line 14) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/TestClassShouldHaveTFixtureArgument.cs
class TestClassShouldHaveTFixtureArgument (line 8) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method TestClassShouldHaveTFixtureArgument (line 11) | public TestClassShouldHaveTFixtureArgument() :
method AnalyzeCompilation (line 15) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/TestMethodCannotHaveOverloads.cs
class TestMethodCannotHaveOverloads (line 8) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method TestMethodCannotHaveOverloads (line 11) | public TestMethodCannotHaveOverloads() :
method AnalyzeCompilation (line 15) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/TestMethodMustNotHaveMultipleFactAttributes.cs
class TestMethodMustNotHaveMultipleFactAttributes (line 9) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method TestMethodMustNotHaveMultipleFactAttributes (line 12) | public TestMethodMustNotHaveMultipleFactAttributes() :
method AnalyzeCompilation (line 16) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/TestMethodShouldNotBeSkipped.cs
class TestMethodShouldNotBeSkipped (line 8) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method TestMethodShouldNotBeSkipped (line 11) | public TestMethodShouldNotBeSkipped() :
method AnalyzeCompilation (line 15) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/TestMethodSupportedReturnType.cs
class TestMethodSupportedReturnType (line 9) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method TestMethodSupportedReturnType (line 12) | public TestMethodSupportedReturnType() :
method AnalyzeCompilation (line 16) | public override void AnalyzeCompilation(
method GetValidReturnTypes (line 58) | public static List<INamedTypeSymbol> GetValidReturnTypes(
FILE: src/xunit.analyzers/X1000/TheoryDataRowArgumentsShouldBeSerializable.cs
method TheoryDataRowArgumentsShouldBeSerializable (line 12) | public TheoryDataRowArgumentsShouldBeSerializable() :
method AnalyzeCompilation (line 19) | public override void AnalyzeCompilation(
FILE: src/xunit.analyzers/X1000/TheoryDataShouldNotUseTheoryDataRow.cs
class TheoryDataShouldNotUseTheoryDataRow (line 9) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method AnalyzeCompilation (line 13) | public override void AnalyzeCompilation(
method IsOrImplementsITheoryDataRow (line 50) | static bool IsOrImplementsITheoryDataRow(
FILE: src/xunit.analyzers/X1000/TheoryDataTypeArgumentsShouldBeSerializable.cs
class TheoryDataTypeArgumentsShouldBeSerializable (line 11) | [DiagnosticAnalyzer(LanguageNames.CSharp)]
method TheoryDataTypeArgumentsShouldBeSerializable (line 14) | public TheoryDataTypeArgumentsShouldBeSerializable() :
method AnalyzeCompilation (line 21) | public override void AnalyzeCompilation(
method AttributeIsTheoryOrDataAttribute (line 85) | static bool AttributeIsTheoryOrDataAttribute(AttributeData attribute, ...
method DiscoveryEnumerationIsDisabled (line 88) | static bool DiscoveryEnumerationIsDisabled(IMethodSymbol method, Seria...
class TheoryDataTypeArgumentFinder (line 95) | sealed class TheoryDataTypeArgumentFinder(SerializableTypeSymbols type...
method FindTypeArguments (line 105) | public IEnumerable<ITypeSymbol> FindTypeArguments(
method GetCompatibleMethod (line 112) | static IMethodSymbol? GetCompatibleMethod(
method GetDataSourceType (line 140) | INamedTypeSymbol? GetDataSourceType(
method GetField (line 156) | static IFieldSymbol? GetField(
method GetMemberContainingType (line 168) | static ITypeSymbol? GetMemberContainingType(AttributeData memberData...
method GetMemberType (line 179) | static ITypeSymbol? GetMemberType(
method GetMemberType (line 200) | static ITypeSymbol? GetMemberType(ISymbol? member) =>
method GetMethod (line 212) | static IMethodSymbol? GetMethod(
method GetProperty (line 232) | static IPropertySymbol? GetProperty(
method GetPublicMember (line 244) | static TSymbol? GetPublicMember<TSymbol>(
method GetTheoryDataTypeArguments (line 267) | IEnumer
Condensed preview — 373 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (1,582K chars).
[
{
"path": ".config/dotnet-tools.json",
"chars": 184,
"preview": "{\n \"version\": 1,\n \"isRoot\": true,\n \"tools\": {\n \"sign\": {\n \"version\": \"0.9.1-beta.25330.2\",\n \"commands\": "
},
{
"path": ".editorconfig",
"chars": 10657,
"preview": "# top-most EditorConfig file\nroot = true\n\n[*]\ncharset = utf-8\nend_of_line = lf\ninsert_final_newline = true\nindent_style "
},
{
"path": ".gitattributes",
"chars": 204,
"preview": "* text=auto eol=lf\n\n*.cs text diff=csharp\n*.csproj text merge=union\n*.ico binary\n*.resx text merge=union\n*.ps1 eol=crlf\n"
},
{
"path": ".github/FUNDING.yml",
"chars": 14,
"preview": "github: xunit\n"
},
{
"path": ".github/workflows/ci-signed.yaml",
"chars": 2378,
"preview": "name: xUnit.net Analyzers CI Build (signed)\non:\n push:\n branches:\n - main\n - 'rel/**'\n workflow_dispatch:"
},
{
"path": ".github/workflows/ci-unsigned.yaml",
"chars": 1363,
"preview": "name: xUnit.net Analyzers CI Build (unsigned)\non:\n push:\n branches-ignore:\n - main\n - 'rel/**'\n workflow_"
},
{
"path": ".github/workflows/pull-request.yaml",
"chars": 2192,
"preview": "name: xUnit.net Analyzers PR Build\non:\n - pull_request\n - workflow_dispatch\n\njobs:\n build:\n name: \"Build\"\n runs"
},
{
"path": ".gitignore",
"chars": 7128,
"preview": "# Visual Studio\nlaunchSettings.json\n\n# NCrunch\n*.ncrunchsolution\n*.ncrunchsolution.user\n*.ncrunchproject\n\n# Mono's local"
},
{
"path": ".gitmodules",
"chars": 195,
"preview": "[submodule \"tools/media\"]\n\tpath = tools/media\n\turl = https://github.com/xunit/media\n[submodule \"tools/builder/common\"]\n\t"
},
{
"path": ".vscode/launch.json",
"chars": 47,
"preview": "{\n\t\"version\": \"0.2.0\",\n\t\"configurations\": []\n}\n"
},
{
"path": ".vscode/settings.json",
"chars": 253,
"preview": "{\n\t\"cSpell.words\": [\n\t\t\"LLMBRO\",\n\t\t\"MBRO\",\n\t\t\"app\",\n\t\t\"nuget\",\n\t\t\"nupkg\",\n\t\t\"parallelization\",\n\t\t\"veyor\"\n\t],\n\t\"files.exc"
},
{
"path": ".vscode/tasks.json",
"chars": 1437,
"preview": "{\n\t\"version\": \"2.0.0\",\n\t\"tasks\": [\n\t\t{\n\t\t\t\"label\": \"Build\",\n\t\t\t\"type\": \"process\",\n\t\t\t\"command\": \"dotnet\",\n\t\t\t\"args\": [\n\t"
},
{
"path": "BUILDING.md",
"chars": 3962,
"preview": "# Building xUnit.net Analyzers\n\nThe primary build system for xUnit.net Analyzers is done via command line, and officiall"
},
{
"path": "LICENSE",
"chars": 2056,
"preview": "Unless otherwise noted, the source code here is covered by the following license:\n\n\tCopyright (c) .NET Foundation and Co"
},
{
"path": "NuGet.Config",
"chars": 332,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<configuration>\n <packageSources>\n <clear />\n <add key=\"nuget.org\" value=\""
},
{
"path": "README.md",
"chars": 8446,
"preview": "# About This Project\n\nThis project contains source code analysis and cleanup rules for xUnit.net. Analysis and fixes are"
},
{
"path": "build",
"chars": 1028,
"preview": "#!/usr/bin/env bash\nset -euo pipefail\n\nPUSHED=0\n\ncleanup () {\n\tif [[ $PUSHED == 1 ]]; then\n\t\tpopd >/dev/null\n\t\tPUSHED=0\n"
},
{
"path": "build.ps1",
"chars": 945,
"preview": "#!/usr/bin/env pwsh\r\n#Requires -Version 5.1\r\n\r\nSet-StrictMode -Version Latest\r\n$ErrorActionPreference = \"Stop\"\r\n\r\nif ($n"
},
{
"path": "global.json",
"chars": 79,
"preview": "{\n \"sdk\": {\n \"version\": \"10.0.100\",\n \"rollForward\": \"latestMinor\"\n }\n}\n"
},
{
"path": "src/Directory.Build.props",
"chars": 4332,
"preview": "<Project>\n\n <!-- ============================== -->\n <!-- Universal properties and items -->\n\n <PropertyGroup>\n <A"
},
{
"path": "src/Directory.Build.targets",
"chars": 2876,
"preview": "<Project>\n\n <!-- Enable building .NET Framework on non-Windows machines -->\n <ItemGroup Condition=\" '$(TargetFramework"
},
{
"path": "src/common/CallerArgumentExpressionAttribute.cs",
"chars": 283,
"preview": "#if !NETCOREAPP\n\nnamespace System.Runtime.CompilerServices;\n\n[AttributeUsage(AttributeTargets.Parameter, Inherited = fal"
},
{
"path": "src/common/Guard.cs",
"chars": 2995,
"preview": "using System;\nusing System.Collections;\nusing System.Diagnostics.CodeAnalysis;\nusing System.Runtime.CompilerServices;\n\nn"
},
{
"path": "src/compat/Directory.Build.props",
"chars": 252,
"preview": "<Project>\n\n <PropertyGroup>\n <DefineConstants>$(DefineConstants);ROSLYN_LATEST</DefineConstants>\n <MicrosoftCodeA"
},
{
"path": "src/compat/xunit.analyzers.latest/xunit.analyzers.latest.csproj",
"chars": 295,
"preview": "<Project Sdk=\"Microsoft.NET.Sdk\">\n\n <PropertyGroup>\n <RootNamespace>Xunit.Analyzers</RootNamespace>\n <TargetFrame"
},
{
"path": "src/compat/xunit.analyzers.latest.fixes/xunit.analyzers.latest.fixes.csproj",
"chars": 578,
"preview": "<Project Sdk=\"Microsoft.NET.Sdk\">\n\n <PropertyGroup>\n <RootNamespace>Xunit.Analyzers.Fixes</RootNamespace>\n <Targe"
},
{
"path": "src/compat/xunit.analyzers.latest.tests/xunit.analyzers.latest.tests.csproj",
"chars": 810,
"preview": "<Project Sdk=\"Microsoft.NET.Sdk\">\n\n <PropertyGroup>\n <AssemblyName>xunit.analyzers.latest.tests.$(TargetFramework)</"
},
{
"path": "src/xunit.analyzers/Properties/AssemblyInfo.cs",
"chars": 260,
"preview": "using System.Reflection;\n\n[assembly: AssemblyCompany(\".NET Foundation\")]\n[assembly: AssemblyProduct(\"xUnit.net Testing F"
},
{
"path": "src/xunit.analyzers/Suppressors/ConsiderCallingConfigureAwaitSuppressor.cs",
"chars": 1730,
"preview": "using System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp"
},
{
"path": "src/xunit.analyzers/Suppressors/MakeTypesInternalSuppressor.cs",
"chars": 1009,
"preview": "using Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp.Syntax;\nusing Microsoft.CodeAnalysis.Diagnostics;\nusin"
},
{
"path": "src/xunit.analyzers/Suppressors/NonNullableFieldInitializationSuppressor.cs",
"chars": 4561,
"preview": "using System.Globalization;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp.Syntax;"
},
{
"path": "src/xunit.analyzers/Suppressors/UseAsyncSuffixForAsyncMethodsSuppressor.cs",
"chars": 1156,
"preview": "using Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp.Syntax;\nusing Microsoft.CodeAnalysis.Diagnostics;\nusin"
},
{
"path": "src/xunit.analyzers/Utility/AssertUsageAnalyzerBase.cs",
"chars": 1553,
"preview": "using System;\nusing System.Collections.Generic;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\n"
},
{
"path": "src/xunit.analyzers/Utility/Category.cs",
"chars": 119,
"preview": "namespace Xunit.Analyzers;\n\npublic enum Category\n{\n\t// 1xxx\n\tUsage,\n\n\t// 2xxx\n\tAssertions,\n\n\t// 3xxx\n\tExtensibility,\n}\n"
},
{
"path": "src/xunit.analyzers/Utility/CodeAnalysisExtensions.cs",
"chars": 7842,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.C"
},
{
"path": "src/xunit.analyzers/Utility/Constants.cs",
"chars": 10079,
"preview": "namespace Xunit.Analyzers;\n\npublic static class Constants\n{\n\t/// <summary>\n\t/// Argument names for Assert methods\n\t/// <"
},
{
"path": "src/xunit.analyzers/Utility/ConversionChecker.cs",
"chars": 3604,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing Microsoft.CodeAnaly"
},
{
"path": "src/xunit.analyzers/Utility/Descriptors.Suppressors.cs",
"chars": 746,
"preview": "using Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic static partial class Descriptors\n{\n\tpublic static Supp"
},
{
"path": "src/xunit.analyzers/Utility/Descriptors.cs",
"chars": 863,
"preview": "using System.Collections.Concurrent;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic static partial cl"
},
{
"path": "src/xunit.analyzers/Utility/Descriptors.xUnit1xxx.cs",
"chars": 19522,
"preview": "using Microsoft.CodeAnalysis;\nusing static Microsoft.CodeAnalysis.DiagnosticSeverity;\nusing static Xunit.Analyzers.Categ"
},
{
"path": "src/xunit.analyzers/Utility/Descriptors.xUnit2xxx.cs",
"chars": 10771,
"preview": "using Microsoft.CodeAnalysis;\nusing static Microsoft.CodeAnalysis.DiagnosticSeverity;\nusing static Xunit.Analyzers.Categ"
},
{
"path": "src/xunit.analyzers/Utility/Descriptors.xUnit3xxx.cs",
"chars": 1906,
"preview": "using Microsoft.CodeAnalysis;\nusing static Microsoft.CodeAnalysis.DiagnosticSeverity;\nusing static Xunit.Analyzers.Categ"
},
{
"path": "src/xunit.analyzers/Utility/EmptyAssertContext.cs",
"chars": 457,
"preview": "using System;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class EmptyAssertContext : IAssertContex"
},
{
"path": "src/xunit.analyzers/Utility/EmptyCommonContext.cs",
"chars": 921,
"preview": "using System;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class EmptyCommonContext : ICommonContex"
},
{
"path": "src/xunit.analyzers/Utility/EmptyCoreContext.cs",
"chars": 1091,
"preview": "using System;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class EmptyCoreContext : ICoreContext\n{\n"
},
{
"path": "src/xunit.analyzers/Utility/EmptyRunnerUtilityContext.cs",
"chars": 389,
"preview": "using System;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class EmptyRunnerUtilityContext : IRunne"
},
{
"path": "src/xunit.analyzers/Utility/EnumerableExtensions.cs",
"chars": 1089,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing Xunit;\n\n/// <summary>\n/// Extension methods for"
},
{
"path": "src/xunit.analyzers/Utility/IAssertContext.cs",
"chars": 962,
"preview": "using System;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic interface IAssertContext\n{\n\t/// <summary"
},
{
"path": "src/xunit.analyzers/Utility/ICommonContext.cs",
"chars": 2263,
"preview": "using System;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\n/// <summary>\n/// Context for types that that o"
},
{
"path": "src/xunit.analyzers/Utility/ICoreContext.cs",
"chars": 2521,
"preview": "using System;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic interface ICoreContext\n{\n\t/// <summary>\n"
},
{
"path": "src/xunit.analyzers/Utility/IRunnerUtilityContext.cs",
"chars": 657,
"preview": "using System;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic interface IRunnerUtilityContext\n{\n\t/// <"
},
{
"path": "src/xunit.analyzers/Utility/Serializability.cs",
"chars": 123,
"preview": "namespace Xunit.Analyzers;\n\npublic enum Serializability\n{\n\tNeverSerializable,\n\tPossiblySerializable,\n\tAlwaysSerializable"
},
{
"path": "src/xunit.analyzers/Utility/SerializabilityAnalyzer.cs",
"chars": 5995,
"preview": "using System;\nusing System.Diagnostics.CodeAnalysis;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.A"
},
{
"path": "src/xunit.analyzers/Utility/SerializableTypeSymbols.cs",
"chars": 6472,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.C"
},
{
"path": "src/xunit.analyzers/Utility/SymbolExtensions.cs",
"chars": 7701,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\n\n"
},
{
"path": "src/xunit.analyzers/Utility/SyntaxExtensions.cs",
"chars": 2409,
"preview": "using System.Threading;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.CodeAnalysis."
},
{
"path": "src/xunit.analyzers/Utility/TypeHierarchyComparer.cs",
"chars": 776,
"preview": "using System;\nusing System.Collections.Generic;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class "
},
{
"path": "src/xunit.analyzers/Utility/TypeSymbolFactory.cs",
"chars": 23053,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xun"
},
{
"path": "src/xunit.analyzers/Utility/V2AbstractionsContext.cs",
"chars": 6074,
"preview": "using System;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class V2AbstractionsC"
},
{
"path": "src/xunit.analyzers/Utility/V2AssertContext.cs",
"chars": 1345,
"preview": "using System;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class V2AssertContext"
},
{
"path": "src/xunit.analyzers/Utility/V2CoreContext.cs",
"chars": 4150,
"preview": "using System;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class V2CoreContext :"
},
{
"path": "src/xunit.analyzers/Utility/V2ExecutionContext.cs",
"chars": 1642,
"preview": "using System;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class V2ExecutionCont"
},
{
"path": "src/xunit.analyzers/Utility/V2RunnerUtilityContext.cs",
"chars": 1324,
"preview": "using System;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class V2RunnerUtility"
},
{
"path": "src/xunit.analyzers/Utility/V3AssertContext.cs",
"chars": 1348,
"preview": "using System;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class V3AssertContext"
},
{
"path": "src/xunit.analyzers/Utility/V3CommonContext.cs",
"chars": 4984,
"preview": "using System;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class V3CommonContext"
},
{
"path": "src/xunit.analyzers/Utility/V3CoreContext.cs",
"chars": 5985,
"preview": "using System;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class V3CoreContext :"
},
{
"path": "src/xunit.analyzers/Utility/V3RunnerCommonContext.cs",
"chars": 987,
"preview": "using System;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class V3RunnerCommonC"
},
{
"path": "src/xunit.analyzers/Utility/V3RunnerUtilityContext.cs",
"chars": 1327,
"preview": "using System;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\npublic class V3RunnerUtility"
},
{
"path": "src/xunit.analyzers/Utility/XunitContext.cs",
"chars": 10703,
"preview": "using System;\nusing Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\n/// <summary>\n/// Class which provides informat"
},
{
"path": "src/xunit.analyzers/Utility/XunitDiagnosticAnalyzer.cs",
"chars": 2346,
"preview": "using System.Collections.Immutable;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\n\nnamespace X"
},
{
"path": "src/xunit.analyzers/Utility/XunitDiagnosticSuppressor.cs",
"chars": 2466,
"preview": "using System.Collections.Immutable;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\nusing Xunit."
},
{
"path": "src/xunit.analyzers/Utility/XunitV2DiagnosticAnalyzer.cs",
"chars": 420,
"preview": "using Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\n/// <summary>\n/// Base class for diagnostic analyzers which s"
},
{
"path": "src/xunit.analyzers/Utility/XunitV2DiagnosticSuppressor.cs",
"chars": 441,
"preview": "using Microsoft.CodeAnalysis;\nusing Xunit.Analyzers;\n\nnamespace Xunit.Suppressors;\n\n/// <summary>\n/// Base class for dia"
},
{
"path": "src/xunit.analyzers/Utility/XunitV3DiagnosticAnalyzer.cs",
"chars": 420,
"preview": "using Microsoft.CodeAnalysis;\n\nnamespace Xunit.Analyzers;\n\n/// <summary>\n/// Base class for diagnostic analyzers which s"
},
{
"path": "src/xunit.analyzers/Utility/XunitV3DiagnosticSuppressor.cs",
"chars": 441,
"preview": "using Microsoft.CodeAnalysis;\nusing Xunit.Analyzers;\n\nnamespace Xunit.Suppressors;\n\n/// <summary>\n/// Base class for dia"
},
{
"path": "src/xunit.analyzers/X1000/ClassDataAttributeMustPointAtValidClass.cs",
"chars": 12020,
"preview": "using System.Collections.Generic;\nusing System.Diagnostics.CodeAnalysis;\nusing System.Linq;\nusing System.Reflection;\nusi"
},
{
"path": "src/xunit.analyzers/X1000/CollectionDefinitionsMustBePublic.cs",
"chars": 1332,
"preview": "using System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\n\nnamespace Xunit.Analyzers;\n\n"
},
{
"path": "src/xunit.analyzers/X1000/ConstructorsOnFactAttributeSubclassShouldBePublic.cs",
"chars": 1683,
"preview": "using Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp.Syntax;\nusing Microsoft.CodeAnalysis.Diagnostics;\n\nnam"
},
{
"path": "src/xunit.analyzers/X1000/DataAttributeShouldBeUsedOnATheory.cs",
"chars": 1772,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nu"
},
{
"path": "src/xunit.analyzers/X1000/DoNotUseAsyncVoidForTestMethods.cs",
"chars": 1782,
"preview": "using System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagno"
},
{
"path": "src/xunit.analyzers/X1000/DoNotUseBlockingTaskOperations.cs",
"chars": 11090,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Diagnostics.CodeAnalysis;\nusing System.Linq;\nusing System.T"
},
{
"path": "src/xunit.analyzers/X1000/DoNotUseConfigureAwait.cs",
"chars": 6077,
"preview": "using System.Collections.Immutable;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Micro"
},
{
"path": "src/xunit.analyzers/X1000/EnsureFixturesHaveASource.cs",
"chars": 5634,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nu"
},
{
"path": "src/xunit.analyzers/X1000/FactMethodMustNotHaveParameters.cs",
"chars": 1123,
"preview": "using System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\n\nnamespace Xunit.Analyzers;\n\n"
},
{
"path": "src/xunit.analyzers/X1000/FactMethodShouldNotHaveTestData.cs",
"chars": 1690,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nu"
},
{
"path": "src/xunit.analyzers/X1000/InlineDataMustMatchTheoryParameters.cs",
"chars": 10539,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Globalization;\nusing System.Linq;\nusi"
},
{
"path": "src/xunit.analyzers/X1000/InlineDataShouldBeUniqueWithinTheory.cs",
"chars": 9566,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nu"
},
{
"path": "src/xunit.analyzers/X1000/LocalFunctionsCannotBeTestFunctions.cs",
"chars": 1839,
"preview": "using System.Collections.Generic;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.Cod"
},
{
"path": "src/xunit.analyzers/X1000/MemberDataShouldReferenceValidMember.cs",
"chars": 41459,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Diagnostics.CodeAnalysi"
},
{
"path": "src/xunit.analyzers/X1000/PublicMethodShouldBeMarkedAsTest.cs",
"chars": 4095,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAna"
},
{
"path": "src/xunit.analyzers/X1000/TestClassCannotBeNestedInGenericClass.cs",
"chars": 1729,
"preview": "using System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\n\nnamespace Xunit.Analyzers;\n\n"
},
{
"path": "src/xunit.analyzers/X1000/TestClassMustBePublic.cs",
"chars": 1262,
"preview": "using System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\n\nnamespace Xunit.Analyzers;\n\n"
},
{
"path": "src/xunit.analyzers/X1000/TestClassShouldHaveTFixtureArgument.cs",
"chars": 2603,
"preview": "using System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagno"
},
{
"path": "src/xunit.analyzers/X1000/TestMethodCannotHaveOverloads.cs",
"chars": 2360,
"preview": "using System.Collections.Generic;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnost"
},
{
"path": "src/xunit.analyzers/X1000/TestMethodMustNotHaveMultipleFactAttributes.cs",
"chars": 1534,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nu"
},
{
"path": "src/xunit.analyzers/X1000/TestMethodShouldNotBeSkipped.cs",
"chars": 1542,
"preview": "using Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.CodeAnalysis.CSharp.Syntax;\nusing Mic"
},
{
"path": "src/xunit.analyzers/X1000/TestMethodSupportedReturnType.cs",
"chars": 2371,
"preview": "using System.Collections.Generic;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\n"
},
{
"path": "src/xunit.analyzers/X1000/TheoryDataRowArgumentsShouldBeSerializable.cs",
"chars": 4861,
"preview": "using System.Collections.Generic;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnost"
},
{
"path": "src/xunit.analyzers/X1000/TheoryDataShouldNotUseTheoryDataRow.cs",
"chars": 2194,
"preview": "using System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.CodeAnalysis.CShar"
},
{
"path": "src/xunit.analyzers/X1000/TheoryDataTypeArgumentsShouldBeSerializable.cs",
"chars": 10972,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nu"
},
{
"path": "src/xunit.analyzers/X1000/TheoryMethodCannotHaveDefaultParameter.cs",
"chars": 1832,
"preview": "using System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp.Syntax;\nusing Microsoft.CodeAnalysi"
},
{
"path": "src/xunit.analyzers/X1000/TheoryMethodCannotHaveParamsArray.cs",
"chars": 1508,
"preview": "using System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\n\nnamespace Xunit.Analyzers;\n\n"
},
{
"path": "src/xunit.analyzers/X1000/TheoryMethodMustHaveTestData.cs",
"chars": 1337,
"preview": "using System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\n\nnamespace Xunit.Analyzers;\n\n"
},
{
"path": "src/xunit.analyzers/X1000/TheoryMethodShouldHaveParameters.cs",
"chars": 1074,
"preview": "using System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\n\nnamespace Xunit.Analyzers;\n\n"
},
{
"path": "src/xunit.analyzers/X1000/TheoryMethodShouldUseAllParameters.cs",
"chars": 2523,
"preview": "using System.Collections.Generic;\nusing System.Linq;\nusing System.Text.RegularExpressions;\nusing Microsoft.CodeAnalysis;"
},
{
"path": "src/xunit.analyzers/X1000/UseCancellationToken.cs",
"chars": 4861,
"preview": "using System.Collections.Immutable;\nusing System.Globalization;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing M"
},
{
"path": "src/xunit.analyzers/X2000/AssertCollectionContainsShouldNotUseBoolCheck.cs",
"chars": 3892,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nu"
},
{
"path": "src/xunit.analyzers/X2000/AssertEmptyCollectionCheckShouldNotBeUsed.cs",
"chars": 1957,
"preview": "using Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.CodeAnalysis.CSharp.Syntax;\nusing Mic"
},
{
"path": "src/xunit.analyzers/X2000/AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecks.cs",
"chars": 2149,
"preview": "using Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.CodeAnalysis.Diagnostics;\nusing Micro"
},
{
"path": "src/xunit.analyzers/X2000/AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheck.cs",
"chars": 2319,
"preview": "using System.Collections.Immutable;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.C"
},
{
"path": "src/xunit.analyzers/X2000/AssertEqualGenericShouldNotBeUsedForStringValue.cs",
"chars": 1741,
"preview": "using Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\nusing Microsoft.CodeAnalysis.Operations;\n\nnamesp"
},
{
"path": "src/xunit.analyzers/X2000/AssertEqualLiteralValueShouldBeFirst.cs",
"chars": 2390,
"preview": "using System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.CodeAnalysis.Diagn"
},
{
"path": "src/xunit.analyzers/X2000/AssertEqualPrecisionShoulBeInRange.cs",
"chars": 3551,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Globalization;\nusing System.Linq;\nusi"
},
{
"path": "src/xunit.analyzers/X2000/AssertEqualShouldNotBeUsedForBoolLiteralCheck.cs",
"chars": 3086,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nu"
},
{
"path": "src/xunit.analyzers/X2000/AssertEqualShouldNotBeUsedForCollectionSizeCheck.cs",
"chars": 5815,
"preview": "using System.Collections;\nusing System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Globalizati"
},
{
"path": "src/xunit.analyzers/X2000/AssertEqualShouldNotBeUsedForNullCheck.cs",
"chars": 2558,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nu"
},
{
"path": "src/xunit.analyzers/X2000/AssertEqualsShouldNotBeUsed.cs",
"chars": 1611,
"preview": "using System.Collections.Immutable;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.C"
},
{
"path": "src/xunit.analyzers/X2000/AssertIsTypeShouldNotBeUsedForAbstractType.cs",
"chars": 2517,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nu"
},
{
"path": "src/xunit.analyzers/X2000/AssertIsTypeShouldUseGenericOverloadType.cs",
"chars": 2249,
"preview": "using System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp"
},
{
"path": "src/xunit.analyzers/X2000/AssertNullShouldNotBeCalledOnValueTypes.cs",
"chars": 2038,
"preview": "using Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.CodeAnalysis.Diagnostics;\nusing Micro"
},
{
"path": "src/xunit.analyzers/X2000/AssertRegexMatchShouldNotUseBoolLiteralCheck.cs",
"chars": 2371,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.Code"
},
{
"path": "src/xunit.analyzers/X2000/AssertSameShouldNotBeCalledOnValueTypes.cs",
"chars": 2439,
"preview": "using System.Collections.Immutable;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.C"
},
{
"path": "src/xunit.analyzers/X2000/AssertSingleShouldBeUsedForSingleParameter.cs",
"chars": 1695,
"preview": "using System.Collections.Immutable;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\nusing Micros"
},
{
"path": "src/xunit.analyzers/X2000/AssertSingleShouldUseTwoArgumentCall.cs",
"chars": 1830,
"preview": "using Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.CodeAnalysis.Diagnostics;\nusing Micro"
},
{
"path": "src/xunit.analyzers/X2000/AssertStringEqualityCheckShouldNotUseBoolCheck.cs",
"chars": 3557,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.C"
},
{
"path": "src/xunit.analyzers/X2000/AssertSubstringCheckShouldNotUseBoolCheck.cs",
"chars": 2776,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.Code"
},
{
"path": "src/xunit.analyzers/X2000/AssertThrowsShouldNotBeUsedForAsyncThrowsCheck.cs",
"chars": 3803,
"preview": "using System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp"
},
{
"path": "src/xunit.analyzers/X2000/AssertThrowsShouldUseGenericOverloadCheck.cs",
"chars": 1743,
"preview": "using System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp"
},
{
"path": "src/xunit.analyzers/X2000/AssignableFromAssertionIsConfusinglyNamed.cs",
"chars": 1398,
"preview": "using System.Collections.Generic;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\nusing Microsof"
},
{
"path": "src/xunit.analyzers/X2000/AsyncAssertsShouldBeAwaited.cs",
"chars": 2093,
"preview": "using Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\nusing Microsoft.CodeAnalysis.Operations;\n\nnamesp"
},
{
"path": "src/xunit.analyzers/X2000/BooleanAssertsShouldNotBeNegated.cs",
"chars": 1604,
"preview": "using System.Collections.Immutable;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.C"
},
{
"path": "src/xunit.analyzers/X2000/BooleanAssertsShouldNotBeUsedForSimpleEqualityCheck.cs",
"chars": 5571,
"preview": "using System.Collections.Immutable;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.C"
},
{
"path": "src/xunit.analyzers/X2000/DoNotUseAssertEmptyWithProblematicTypes.cs",
"chars": 2265,
"preview": "using Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnostics;\nusing Microsoft.CodeAnalysis.Operations;\n\nnamesp"
},
{
"path": "src/xunit.analyzers/X2000/SetEqualityAnalyzer.cs",
"chars": 4092,
"preview": "using System.Collections.Generic;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnost"
},
{
"path": "src/xunit.analyzers/X2000/UseAssertFailInsteadOfBooleanAssert.cs",
"chars": 1858,
"preview": "using System.Collections.Generic;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagnost"
},
{
"path": "src/xunit.analyzers/X3000/CrossAppDomainClassesMustBeLongLivedMarshalByRefObject.cs",
"chars": 2954,
"preview": "using System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagno"
},
{
"path": "src/xunit.analyzers/X3000/DoNotTestForConcreteTypeOfJsonSerializableTypes.cs",
"chars": 4179,
"preview": "using System;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.Code"
},
{
"path": "src/xunit.analyzers/X3000/FactAttributeDerivedClassesShouldProvideSourceInformationConstructor.cs",
"chars": 2438,
"preview": "using System;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;\nusing Microsoft.Code"
},
{
"path": "src/xunit.analyzers/X3000/SerializableClassMustHaveParameterlessConstructor.cs",
"chars": 2860,
"preview": "using System.Collections.Immutable;\nusing System.Linq;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.Diagno"
},
{
"path": "src/xunit.analyzers/xunit.analyzers.csproj",
"chars": 189,
"preview": "<Project Sdk=\"Microsoft.NET.Sdk\">\n\n <PropertyGroup>\n <RootNamespace>Xunit.Analyzers</RootNamespace>\n <TargetFrame"
},
{
"path": "src/xunit.analyzers/xunit.analyzers.nuspec",
"chars": 1801,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<package xmlns=\"http://schemas.microsoft.com/packaging/2011/10/nuspec.xsd\">\n\t<met"
},
{
"path": "src/xunit.analyzers.fixes/Properties/AssemblyInfo.cs",
"chars": 257,
"preview": "using System.Reflection;\n\n[assembly: AssemblyCompany(\".NET Foundation\")]\n[assembly: AssemblyProduct(\"xUnit.net Testing F"
},
{
"path": "src/xunit.analyzers.fixes/Utility/AsyncHelper.cs",
"chars": 8268,
"preview": "using System;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusi"
},
{
"path": "src/xunit.analyzers.fixes/Utility/CodeAnalysisExtensions.cs",
"chars": 7048,
"preview": "using System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CSharp;"
},
{
"path": "src/xunit.analyzers.fixes/Utility/ConvertAttributeCodeAction.cs",
"chars": 1714,
"preview": "using System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeAct"
},
{
"path": "src/xunit.analyzers.fixes/Utility/RemoveAttributesOfTypeCodeAction.cs",
"chars": 1547,
"preview": "using System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeAct"
},
{
"path": "src/xunit.analyzers.fixes/Utility/XunitCodeAction.cs",
"chars": 2618,
"preview": "using System;\nusing System.Globalization;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnal"
},
{
"path": "src/xunit.analyzers.fixes/Utility/XunitCodeFixProvider.cs",
"chars": 489,
"preview": "using System.Collections.Immutable;\nusing Microsoft.CodeAnalysis.CodeFixes;\n\nnamespace Xunit.Analyzers.Fixes;\n\npublic ab"
},
{
"path": "src/xunit.analyzers.fixes/Utility/XunitMemberFixProvider.cs",
"chars": 1387,
"preview": "using System.Linq;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeFixes;\n\n"
},
{
"path": "src/xunit.analyzers.fixes/X1000/ClassDataAttributeMustPointAtValidClassFixer.cs",
"chars": 3855,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/CollectionDefinitionClassesMustBePublicFixer.cs",
"chars": 1405,
"preview": "using System.Composition;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/ConvertToFactFix.cs",
"chars": 1379,
"preview": "using System.Composition;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeF"
},
{
"path": "src/xunit.analyzers.fixes/X1000/ConvertToTheoryFix.cs",
"chars": 1393,
"preview": "using System.Composition;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeF"
},
{
"path": "src/xunit.analyzers.fixes/X1000/DataAttributeShouldBeUsedOnATheoryFixer.cs",
"chars": 2419,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/DoNotUseAsyncVoidForTestMethodsFixer.cs",
"chars": 1935,
"preview": "using System.Composition;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/DoNotUseConfigureAwaitFixer.cs",
"chars": 3303,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft"
},
{
"path": "src/xunit.analyzers.fixes/X1000/FactMethodMustNotHaveParametersFixer.cs",
"chars": 1750,
"preview": "using System.Composition;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Micr"
},
{
"path": "src/xunit.analyzers.fixes/X1000/FactMethodShouldNotHaveTestDataFixer.cs",
"chars": 1572,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft"
},
{
"path": "src/xunit.analyzers.fixes/X1000/InlineDataMustMatchTheoryParameters_ExtraValueFixer.cs",
"chars": 3475,
"preview": "using System;\nusing System.Collections.Immutable;\nusing System.Composition;\nusing System.Globalization;\nusing System.Lin"
},
{
"path": "src/xunit.analyzers.fixes/X1000/InlineDataMustMatchTheoryParameters_NullShouldNotBeUsedForIncompatibleParameterFixer.cs",
"chars": 2897,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/InlineDataMustMatchTheoryParameters_TooFewValuesFixer.cs",
"chars": 4638,
"preview": "using System;\nusing System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing M"
},
{
"path": "src/xunit.analyzers.fixes/X1000/InlineDataShouldBeUniqueWithinTheoryFixer.cs",
"chars": 1719,
"preview": "using System.Composition;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Micr"
},
{
"path": "src/xunit.analyzers.fixes/X1000/LocalFunctionsCannotBeTestFunctionsFixer.cs",
"chars": 1327,
"preview": "using System.Composition;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeF"
},
{
"path": "src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_ExtraValueFixer.cs",
"chars": 4807,
"preview": "using System;\nusing System.Collections.Immutable;\nusing System.Composition;\nusing System.Globalization;\nusing System.Lin"
},
{
"path": "src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_NameOfFixer.cs",
"chars": 2791,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_NullShouldNotBeUsedForIncompatibleParameterFixer.cs",
"chars": 4033,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_ParamsForNonMethodFixer.cs",
"chars": 2120,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_ReturnTypeFixer.cs",
"chars": 1918,
"preview": "using System.Composition;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_StaticFixer.cs",
"chars": 1053,
"preview": "using System.Composition;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/MemberDataShouldReferenceValidMember_VisibilityFixer.cs",
"chars": 1076,
"preview": "using System.Composition;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/PublicMethodShouldBeMarkedAsTestFixer.cs",
"chars": 2614,
"preview": "using System.Composition;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Micr"
},
{
"path": "src/xunit.analyzers.fixes/X1000/RemoveMethodParameterFix.cs",
"chars": 1234,
"preview": "using System.Composition;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/TestClassCannotBeNestedInGenericClassFixer.cs",
"chars": 1201,
"preview": "using System.Composition;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/TestClassMustBePublicFixer.cs",
"chars": 1288,
"preview": "using System.Composition;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/TestClassShouldHaveTFixtureArgumentFixer.cs",
"chars": 1839,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft"
},
{
"path": "src/xunit.analyzers.fixes/X1000/TestMethodMustNotHaveMultipleFactAttributesFixer.cs",
"chars": 3470,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Composition;\nusing System.Globalizati"
},
{
"path": "src/xunit.analyzers.fixes/X1000/TestMethodShouldNotBeSkippedFixer.cs",
"chars": 1606,
"preview": "using System.Composition;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Micr"
},
{
"path": "src/xunit.analyzers.fixes/X1000/TheoryDataShouldNotUseTheoryDataRowFixer.cs",
"chars": 2447,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/TheoryMethodCannotHaveDefaultParameterFixer.cs",
"chars": 1404,
"preview": "using System.Composition;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft.CodeAnalysis.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X1000/UseCancellationTokenFixer.cs",
"chars": 4662,
"preview": "using System.Collections.Generic;\nusing System.Composition;\nusing System.Linq;\nusing System.Threading.Tasks;\nusing Micro"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertCollectionContainsShouldNotUseBoolCheckFixer.cs",
"chars": 3227,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertEmptyCollectionCheckShouldNotBeUsedFixer.cs",
"chars": 2661,
"preview": "using System.Composition;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Micr"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertEmptyOrNotEmptyShouldNotBeUsedForContainsChecksFixer.cs",
"chars": 3162,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertEnumerableAnyCheckShouldNotBeUsedForCollectionContainsCheckFixer.cs",
"chars": 2895,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertEqualGenericShouldNotBeUsedForStringValueFixer.cs",
"chars": 2061,
"preview": "using System.Composition;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Micr"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertEqualLiteralValueShouldBeFirstFixer.cs",
"chars": 2373,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertEqualPrecisionShouldBeInRangeFixer.cs",
"chars": 2260,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertEqualShouldNotBeUsedForBoolLiteralCheckFixer.cs",
"chars": 2701,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertEqualShouldNotBeUsedForCollectionSizeCheckFixer.cs",
"chars": 3190,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertEqualShouldNotBeUsedForNullCheckFixer.cs",
"chars": 2571,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertEqualsShouldNotBeUsedFixer.cs",
"chars": 1581,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertIsTypeShouldNotBeUsedForAbstractTypeFixer.cs",
"chars": 3382,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertNullShouldNotBeCalledOnValueTypesFixer.cs",
"chars": 2048,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertRegexMatchShouldNotUseBoolLiteralCheckFixer.cs",
"chars": 3312,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertSameShouldNotBeCalledOnValueTypesFixer.cs",
"chars": 1617,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Microsoft"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertSingleShouldBeUsedForSingleParameterFixer.cs",
"chars": 6926,
"preview": "using System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Composition;\nusing System.Globalizati"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertSingleShouldUseTwoArgumentCallFixer.cs",
"chars": 2225,
"preview": "using System.Composition;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeAnalysis;\nusing Micr"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertStringEqualityCheckShouldNotUseBoolCheckFixer.cs",
"chars": 3839,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertSubstringCheckShouldNotUseBoolCheckFixer.cs",
"chars": 2962,
"preview": "using System.Composition;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks;\nusing Microsoft.CodeA"
},
{
"path": "src/xunit.analyzers.fixes/X2000/AssertThrowsShouldNotBeUsedForAsyncThrowsCheckFixer.cs",
"chars": 13869,
"preview": "using System.Collections.Generic;\nusing System.Composition;\nusing System.Diagnostics.CodeAnalysis;\nusing System.Linq;\nus"
}
]
// ... and 173 more files (download for full content)
About this extraction
This page contains the full source code of the xunit/xunit.analyzers GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 373 files (1.3 MB), approximately 370.5k tokens, and a symbol index with 2090 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.