Codebase Browser
llvm
Go to App

llvm/clang/unittests/Format/FormatTest.cpp 

//===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "FormatTestBase.h"

#define DEBUG_TYPE …

namespace clang {
namespace format {
namespace test {
namespace {

class FormatTest : public test::FormatTestBase { … };

TEST_F(FormatTest, MessUp) { … }

TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { … }

TEST_F(FormatTest, LLVMStyleOverride) { … }

//===----------------------------------------------------------------------===//
// Basic function tests.
//===----------------------------------------------------------------------===//

TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { … }

TEST_F(FormatTest, FormatsGlobalStatementsAt0) { … }

TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { … }

TEST_F(FormatTest, FormatsNestedBlockStatements) { … }

TEST_F(FormatTest, FormatsNestedCall) { … }

TEST_F(FormatTest, NestedNameSpecifiers) { … }

TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { … }

TEST_F(FormatTest, RemovesEmptyLines) { … }

TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { … }

TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) { … }

//===----------------------------------------------------------------------===//
// Tests for control statements.
//===----------------------------------------------------------------------===//

TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { … }

TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { … }

TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { … }

TEST_F(FormatTest, FormatShortBracedStatements) { … }

TEST_F(FormatTest, UnderstandsMacros) { … }

TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { … }

TEST_F(FormatTest, ParseIfElse) { … }

TEST_F(FormatTest, ElseIf) { … }

TEST_F(FormatTest, SeparatePointerReferenceAlignment) { … }

TEST_F(FormatTest, FormatsForLoop) { … }

TEST_F(FormatTest, RangeBasedForLoops) { … }

TEST_F(FormatTest, ForEachLoops) { … }

TEST_F(FormatTest, FormatsWhileLoop) { … }

TEST_F(FormatTest, FormatsDoWhile) { … }

TEST_F(FormatTest, FormatsSwitchStatement) { … }

TEST_F(FormatTest, CaseRanges) { … }

TEST_F(FormatTest, ShortEnums) { … }

TEST_F(FormatTest, ShortCompoundRequirement) { … }

TEST_F(FormatTest, ShortCaseLabels) { … }

TEST_F(FormatTest, FormatsLabels) { … }

TEST_F(FormatTest, MultiLineControlStatements) { … }

TEST_F(FormatTest, BeforeWhile) { … }

//===----------------------------------------------------------------------===//
// Tests for classes, namespaces, etc.
//===----------------------------------------------------------------------===//

TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { … }

TEST_F(FormatTest, UnderstandsAccessSpecifiers) { … }

TEST_F(FormatTest, SeparatesLogicalBlocks) { … }

TEST_F(FormatTest, FormatsClasses) { … }

TEST_F(FormatTest, BreakInheritanceStyle) { … }

TEST_F(FormatTest, FormatsVariableDeclarationsAfterRecord) { … }

TEST_F(FormatTest, FormatsEnum) { … }

TEST_F(FormatTest, FormatsEnumsWithErrors) { … }

TEST_F(FormatTest, FormatsEnumStruct) { … }

TEST_F(FormatTest, FormatsEnumClass) { … }

TEST_F(FormatTest, FormatsEnumTypes) { … }

TEST_F(FormatTest, FormatsTypedefEnum) { … }

TEST_F(FormatTest, FormatsNSEnums) { … }

TEST_F(FormatTest, FormatsBitfields) { … }

TEST_F(FormatTest, FormatsNamespaces) { … }

TEST_F(FormatTest, NamespaceMacros) { … }

TEST_F(FormatTest, FormatsCompactNamespaces) { … }

TEST_F(FormatTest, FormatsExternC) { … }

TEST_F(FormatTest, IndentExternBlockStyle) { … }

TEST_F(FormatTest, FormatsInlineASM) { … }

TEST_F(FormatTest, FormatTryCatch) { … }

TEST_F(FormatTest, FormatTryAsAVariable) { … }

TEST_F(FormatTest, FormatSEHTryCatch) { … }

TEST_F(FormatTest, IncompleteTryCatchBlocks) { … }

TEST_F(FormatTest, FormatTryCatchBraceStyles) { … }

TEST_F(FormatTest, StaticInitializers) { … }

TEST_F(FormatTest, DesignatedInitializers) { … }

TEST_F(FormatTest, BracedInitializerIndentWidth) { … }

TEST_F(FormatTest, NestedStaticInitializers) { … }

TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { … }

TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { … }

TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { … }

TEST_F(FormatTest, UnderstandsLinePPDirective) { … }

TEST_F(FormatTest, LayoutUnknownPPDirective) { … }

TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { … }

TEST_F(FormatTest, EndOfFileEndsPPDirective) { … }

TEST_F(FormatTest, DoesntRemoveUnknownTokens) { … }

TEST_F(FormatTest, IndentsPPDirectiveWithPPIndentWidth) { … }

TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { … }

TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { … }

TEST_F(FormatTest, LayoutSingleHash) { … }

TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { … }

TEST_F(FormatTest, LayoutRemainingTokens) { … }

TEST_F(FormatTest, MacroDefinitionInsideStatement) { … }

TEST_F(FormatTest, HashInMacroDefinition) { … }

TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { … }

TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { … }

TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { … }

TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { … }

TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { … }

TEST_F(FormatTest, FormatsMacrosWithZeroColumnWidth) { … }

TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { … }

TEST_F(FormatTest, IndentPreprocessorDirectives) { … }

TEST_F(FormatTest, FormatAlignInsidePreprocessorElseBlock) { … }

TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { … }

TEST_F(FormatTest, FormatUnbalancedStructuralElements) { … }

TEST_F(FormatTest, EscapedNewlines) { … }

TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { … }

TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { … }

TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { … }

TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { … }

TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { … }

TEST_F(FormatTest, LayoutBlockInsideParens) { … }

TEST_F(FormatTest, LayoutBlockInsideStatement) { … }

TEST_F(FormatTest, LayoutNestedBlocks) { … }

TEST_F(FormatTest, FormatNestedBlocksInMacros) { … }

TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { … }

TEST_F(FormatTest, FormatBeginBlockEndMacros) { … }

//===----------------------------------------------------------------------===//
// Line break tests.
//===----------------------------------------------------------------------===//

TEST_F(FormatTest, PreventConfusingIndents) { … }

TEST_F(FormatTest, LineBreakingInBinaryExpressions) { … }

TEST_F(FormatTest, ExpressionIndentation) { … }

TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { … }

TEST_F(FormatTest, ExpressionIndentationStrictAlign) { … }

TEST_F(FormatTest, EnforcedOperatorWraps) { … }

TEST_F(FormatTest, NoOperandAlignment) { … }

TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { … }

TEST_F(FormatTest, AllowBinPackingInsideArguments) { … }

TEST_F(FormatTest, BreakBinaryOperatorsInPresenceOfTemplates) { … }

TEST_F(FormatTest, ConstructorInitializers) { … }

TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { … }

TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { … }

TEST_F(FormatTest, AllowAllArgumentsOnNextLineDontAlign) { … }

TEST_F(FormatTest, BreakFunctionDefinitionParameters) { … }

TEST_F(FormatTest, BreakBeforeInlineASMColon) { … }

TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { … }

#ifndef EXPENSIVE_CHECKS
// Expensive checks enables libstdc++ checking which includes validating the
// state of ranges used in std::priority_queue - this blows out the
// runtime/scalability of the function and makes this test unacceptably slow.
TEST_F(FormatTest, MemoizationTests) { … }
#endif

TEST_F(FormatTest, BreaksAsHighAsPossible) { … }

TEST_F(FormatTest, BreaksFunctionDeclarations) { … }

TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { … }

TEST_F(FormatTest, TrailingReturnType) { … }

TEST_F(FormatTest, DeductionGuides) { … }

TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { … }

TEST_F(FormatTest, FunctionAnnotations) { … }

TEST_F(FormatTest, BreaksDesireably) { … }

TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { … }

TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { … }

TEST_F(FormatTest, FormatsDeclarationBreakAlways) { … }

TEST_F(FormatTest, FormatsDefinitionBreakAlways) { … }

TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { … }

TEST_F(FormatTest, FormatsBuilderPattern) { … }

TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { … }

TEST_F(FormatTest, BreaksAfterAssignments) { … }

TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { … }

TEST_F(FormatTest, AlignsAfterAssignments) { … }

TEST_F(FormatTest, AlignsAfterReturn) { … }

TEST_F(FormatTest, AlignsAfterOpenBracket) { … }

TEST_F(FormatTest, ParenthesesAndOperandAlignment) { … }

TEST_F(FormatTest, BreaksConditionalExpressions) { … }

TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { … }

TEST_F(FormatTest, DeclarationsOfMultipleVariables) { … }

TEST_F(FormatTest, ConditionalExpressionsInBrackets) { … }

TEST_F(FormatTest, AlignsStringLiterals) { … }

TEST_F(FormatTest, ReturnTypeBreakingStyle) { … }

TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { … }

TEST_F(FormatTest, AlignsPipes) { … }

TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { … }

TEST_F(FormatTest, WrapBeforeInsertionOperatorbetweenStringLiterals) { … }

TEST_F(FormatTest, UnderstandsEquals) { … }

TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { … }

TEST_F(FormatTest, WrapsTemplateDeclarations) { … }

TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { … }

TEST_F(FormatTest, WrapsTemplateParameters) { … }

TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { … }

TEST_F(FormatTest, UnderstandsTemplateParameters) { … }

TEST_F(FormatTest, UnderstandsShiftOperators) { … }

TEST_F(FormatTest, BitshiftOperatorWidth) { … }

TEST_F(FormatTest, UnderstandsBinaryOperators) { … }

TEST_F(FormatTest, UnderstandsPointersToMembers) { … }

TEST_F(FormatTest, UnderstandsUnaryOperators) { … }

TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { … }

TEST_F(FormatTest, UnderstandsOverloadedOperators) { … }

TEST_F(FormatTest, SpaceBeforeTemplateCloser) { … }

TEST_F(FormatTest, UnderstandsFunctionRefQualification) { … }

TEST_F(FormatTest, PointerAlignmentFallback) { … }

TEST_F(FormatTest, UnderstandsNewAndDelete) { … }

TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { … }

TEST_F(FormatTest, UnderstandsAttributes) { … }

TEST_F(FormatTest, UnderstandsPointerQualifiersInCast) { … }

TEST_F(FormatTest, UnderstandsSquareAttributes) { … }

TEST_F(FormatTest, AttributeClass) { … }

TEST_F(FormatTest, AttributesAfterMacro) { … }

TEST_F(FormatTest, AttributePenaltyBreaking) { … }

TEST_F(FormatTest, UnderstandsEllipsis) { … }

TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { … }

TEST_F(FormatTest, UnderstandsRvalueReferences) { … }

TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { … }

TEST_F(FormatTest, FormatsCasts) { … }

TEST_F(FormatTest, FormatsFunctionTypes) { … }

TEST_F(FormatTest, FormatsPointersToArrayTypes) { … }

TEST_F(FormatTest, BreaksLongVariableDeclarations) { … }

TEST_F(FormatTest, BreaksLongDeclarations) { … }

TEST_F(FormatTest, FormatsAccessModifiers) { … }

TEST_F(FormatTest, FormatsAfterAccessModifiers) { … }

TEST_F(FormatTest, FormatsAfterAndBeforeAccessModifiersInteraction) { … }

TEST_F(FormatTest, FormatsArrays) { … }

TEST_F(FormatTest, LineStartsWithSpecialCharacter) { … }

TEST_F(FormatTest, HandlesIncludeDirectives) { … }

//===----------------------------------------------------------------------===//
// Error recovery tests.
//===----------------------------------------------------------------------===//

TEST_F(FormatTest, IncompleteParameterLists) { … }

TEST_F(FormatTest, IncorrectCodeTrailingStuff) { … }

TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { … }

TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { … }

TEST_F(FormatTest, IncorrectAccessSpecifier) { … }

TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { … }

TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { … }

TEST_F(FormatTest, IncorrectCodeDoNoWhile) { … }

TEST_F(FormatTest, IncorrectCodeMissingParens) { … }

TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { … }

TEST_F(FormatTest, IncorrectCodeErrorDetection) { … }

TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { … }

TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { … }

TEST_F(FormatTest, LayoutCxx11BraceInitializers) { … }

TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { … }

TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { … }

TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { … }

TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { … }

TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { … }

TEST_F(FormatTest, SplitEmptyFunction) { … }

TEST_F(FormatTest, SplitEmptyFunctionButNotRecord) { … }

TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { … }

TEST_F(FormatTest, SplitEmptyClass) { … }

TEST_F(FormatTest, SplitEmptyStruct) { … }

TEST_F(FormatTest, SplitEmptyUnion) { … }

TEST_F(FormatTest, SplitEmptyNamespace) { … }

TEST_F(FormatTest, NeverMergeShortRecords) { … }

TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { … }

TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { … }

TEST_F(FormatTest, FormatHashIfExpressions) { … }

TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { … }

TEST_F(FormatTest, FormatStarDependingOnContext) { … }

TEST_F(FormatTest, SpecialTokensAtEndOfLine) { … }

TEST_F(FormatTest, SkipsDeeplyNestedLines) { … }

//===----------------------------------------------------------------------===//
// Objective-C tests.
//===----------------------------------------------------------------------===//

TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { … }

TEST_F(FormatTest, BreaksStringLiterals) { … }

TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { … }

TEST_F(FormatTest, FullyRemoveEmptyLines) { … }

TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { … }

TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { … }

TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { … }

TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { … }

TEST_F(FormatTest, BreaksStringLiteralOperands) { … }

TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { … }

TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { … }

TEST_F(FormatTest, SkipsUnknownStringLiterals) { … }

TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { … }

TEST_F(FormatTest, CppLexVersion) { … }

TEST_F(FormatTest, UnderstandsCpp1y) { … }

TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { … }

TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { … }

TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { … }

TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { … }

TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { … }

TEST_F(FormatTest, ConfigurableIndentWidth) { … }

TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { … }

TEST_F(FormatTest, ConfigurableUseOfTab) { … }

TEST_F(FormatTest, ZeroTabWidth) { … }

TEST_F(FormatTest, CalculatesOriginalColumn) { … }

TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { … }

TEST_F(FormatTest, SpaceAfterLogicalNot) { … }

TEST_F(FormatTest, ConfigurableSpacesInParens) { … }

TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { … }

TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) { … }

TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { … }

TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { … }

TEST_F(FormatTest, ConfigurableSpaceAroundPointerQualifiers) { … }

TEST_F(FormatTest, AlignConsecutiveMacros) { … }

TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossEmptyLines) { … }

TEST_F(FormatTest, AlignConsecutiveDeclarationsAcrossEmptyLinesAndComments) { … }

TEST_F(FormatTest, AlignConsecutiveBitFieldsAcrossEmptyLinesAndComments) { … }

TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossComments) { … }

TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossEmptyLinesAndComments) { … }

TEST_F(FormatTest, AlignCompoundAssignments) { … }

TEST_F(FormatTest, AlignConsecutiveAssignments) { … }

TEST_F(FormatTest, AlignConsecutiveBitFields) { … }

TEST_F(FormatTest, AlignConsecutiveDeclarations) { … }

TEST_F(FormatTest, AlignConsecutiveShortCaseStatements) { … }

TEST_F(FormatTest, AlignWithLineBreaks) { … }

TEST_F(FormatTest, AlignWithInitializerPeriods) { … }

TEST_F(FormatTest, LinuxBraceBreaking) { … }

TEST_F(FormatTest, MozillaBraceBreaking) { … }

TEST_F(FormatTest, StroustrupBraceBreaking) { … }

TEST_F(FormatTest, AllmanBraceBreaking) { … }

TEST_F(FormatTest, WhitesmithsBraceBreaking) { … }

TEST_F(FormatTest, GNUBraceBreaking) { … }

TEST_F(FormatTest, WebKitBraceBreaking) { … }

TEST_F(FormatTest, CatchExceptionReferenceBinding) { … }

TEST_F(FormatTest, CatchAlignArrayOfStructuresRightAlignment) { … }

TEST_F(FormatTest, CatchAlignArrayOfStructuresLeftAlignment) { … }

TEST_F(FormatTest, UnderstandsPragmas) { … }

TEST_F(FormatTest, UnderstandsPragmaOmpTarget) { … }

TEST_F(FormatTest, UnderstandPragmaOption) { … }

TEST_F(FormatTest, UnderstandPragmaRegion) { … }

TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { … }

TEST_F(FormatTest, BreakPenaltyAfterLParen) { … }

TEST_F(FormatTest, BreakPenaltyAfterCastLParen) { … }

TEST_F(FormatTest, BreakPenaltyAfterForLoopLParen) { … }

TEST_F(FormatTest, BreakPenaltyScopeResolution) { … }

TEST_F(FormatTest, WorksFor8bitEncodings) { … }

TEST_F(FormatTest, HandlesUTF8BOM) { … }

// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
#if !defined(_MSC_VER)

TEST_F(FormatTest, CountsUTF8CharactersProperly) { … }

TEST_F(FormatTest, SplitsUTF8Strings) { … }

TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { … }

TEST_F(FormatTest, SplitsUTF8LineComments) { … }

TEST_F(FormatTest, SplitsUTF8BlockComments) { … }

#endif // _MSC_VER

TEST_F(FormatTest, ConstructorInitializerIndentWidth) { … }

TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { … }

TEST_F(FormatTest, ConstructorInitializersWithPreprocessorDirective) { … }

TEST_F(FormatTest, Destructors) { … }

TEST_F(FormatTest, FormatsWithWebKitStyle) { … }

TEST_F(FormatTest, FormatsLambdas) { … }

TEST_F(FormatTest, LambdaWithLineComments) { … }

TEST_F(FormatTest, EmptyLinesInLambdas) { … }

TEST_F(FormatTest, FormatsBlocks) { … }

TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { … }

TEST_F(FormatTest, SupportsCRLF) { … }

TEST_F(FormatTest, MunchSemicolonAfterBlocks) { … }

TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { … }

TEST_F(FormatTest, WrappedClosingParenthesisIndent) { … }

TEST_F(FormatTest, SpacesInAngles) { … }

TEST_F(FormatTest, SpaceAfterTemplateKeyword) { … }

TEST_F(FormatTest, TripleAngleBrackets) { … }

TEST_F(FormatTest, MergeLessLessAtEnd) { … }

TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { … }

TEST_F(FormatTest, HandleConflictMarkers) { … }

TEST_F(FormatTest, DisableRegions) { … }

TEST_F(FormatTest, DoNotCrashOnInvalidInput) { … }

TEST_F(FormatTest, FormatsTableGenCode) { … }

TEST_F(FormatTest, ArrayOfTemplates) { … }

TEST_F(FormatTest, ArrayAsTemplateType) { … }

TEST_F(FormatTest, NoSpaceAfterSuper) { … }

TEST_F(FormatTest, FormatSortsUsingDeclarations) { … }

TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { … }

TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { … }

TEST_F(FormatTest, DoNotFormatLikelyXml) { … }

TEST_F(FormatTest, StructuredBindings) { … }

TEST_F(FormatTest, FileAndCode) { … }

TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { … }

TEST_F(FormatTest, GuessLanguageWithCaret) { … }

TEST_F(FormatTest, GuessLanguageWithPragmas) { … }

TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) { … }

TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { … }

TEST_F(FormatTest, GuessLanguageWithChildLines) { … }

TEST_F(FormatTest, TypenameMacros) { … }

TEST_F(FormatTest, AtomicQualifier) { … }

TEST_F(FormatTest, C11Generic) { … }

TEST_F(FormatTest, AmbersandInLamda) { … }

TEST_F(FormatTest, TrailingReturnTypeAuto) { … }

TEST_F(FormatTest, SpacesInConditionalStatement) { … }

TEST_F(FormatTest, AlternativeOperators) { … }

TEST_F(FormatTest, STLWhileNotDefineChed) { … }

TEST_F(FormatTest, OperatorSpacing) { … }

TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) { … }

TEST_F(FormatTest, WhitespaceSensitiveMacros) { … }

TEST_F(FormatTest, SkipMacroDefinitionBody) { … }

TEST_F(FormatTest, VeryLongNamespaceCommentSplit) { … }

TEST_F(FormatTest, LikelyUnlikely) { … }

TEST_F(FormatTest, PenaltyIndentedWhitespace) { … }

TEST_F(FormatTest, LLVMDefaultStyle) { … }
TEST_F(FormatTest, GNUDefaultStyle) { … }
TEST_F(FormatTest, MozillaDefaultStyle) { … }
TEST_F(FormatTest, GoogleDefaultStyle) { … }
TEST_F(FormatTest, ChromiumDefaultStyle) { … }
TEST_F(FormatTest, MicrosoftDefaultStyle) { … }
TEST_F(FormatTest, WebKitDefaultStyle) { … }

TEST_F(FormatTest, Concepts) { … }

TEST_F(FormatTest, RequiresClausesPositions) { … }

TEST_F(FormatTest, RequiresClauses) { … }

TEST_F(FormatTest, RequiresExpressionIndentation) { … }

TEST_F(FormatTest, StatementAttributeLikeMacros) { … }

TEST_F(FormatTest, IndentAccessModifiers) { … }

TEST_F(FormatTest, LimitlessStringsAndComments) { … }

TEST_F(FormatTest, FormatDecayCopy) { … }

TEST_F(FormatTest, Cpp20ModulesSupport) { … }

TEST_F(FormatTest, CoroutineForCoawait) { … }

TEST_F(FormatTest, CoroutineCoAwait) { … }

TEST_F(FormatTest, CoroutineCoYield) { … }

TEST_F(FormatTest, CoroutineCoReturn) { … }

TEST_F(FormatTest, EmptyShortBlock) { … }

TEST_F(FormatTest, ShortTemplatedArgumentLists) { … }

TEST_F(FormatTest, MultilineLambdaInConditional) { … }

TEST_F(FormatTest, AlignAfterOpenBracketBlockIndent) { … }

TEST_F(FormatTest, AlignAfterOpenBracketBlockIndentIfStatement) { … }

TEST_F(FormatTest, AlignAfterOpenBracketBlockIndentForStatement) { … }

TEST_F(FormatTest, AlignAfterOpenBracketBlockIndentInitializers) { … }

TEST_F(FormatTest, UnderstandsDigraphs) { … }

TEST_F(FormatTest, AlignArrayOfStructuresLeftAlignmentNonSquare) { … }

TEST_F(FormatTest, AlignArrayOfStructuresRightAlignmentNonSquare) { … }

TEST_F(FormatTest, FormatsVariableTemplates) { … }

TEST_F(FormatTest, RemoveSemicolon) { … }

TEST_F(FormatTest, BreakAfterAttributes) { … }

TEST_F(FormatTest, InsertNewlineAtEOF) { … }

TEST_F(FormatTest, KeepEmptyLinesAtEOF) { … }

TEST_F(FormatTest, SpaceAfterUDL) { … }

TEST_F(FormatTest, InterfaceAsClassMemberName) { … }

TEST_F(FormatTest, PreprocessorOverlappingRegions) { … }

TEST_F(FormatTest, RemoveParentheses) { … }

TEST_F(FormatTest, AllowBreakBeforeNoexceptSpecifier) { … }

TEST_F(FormatTest, PPBranchesInBracedInit) { … }

TEST_F(FormatTest, PPDirectivesAndCommentsInBracedInit) { … }

TEST_F(FormatTest, BreakAdjacentStringLiterals) { … }

TEST_F(FormatTest, AlignUTFCommentsAndStringLiterals) { … }

TEST_F(FormatTest, SpaceBetweenKeywordAndLiteral) { … }

TEST_F(FormatTest, BreakBinaryOperations) { … }

} // namespace
} // namespace test
} // namespace format
} // namespace clang