SquareTest实体类模板

最新推荐文章于 2023-10-10 15:05:20 发布

王者丶丿风范

最新推荐文章于 2023-10-10 15:05:20 发布

阅读量1.1k

点赞数

分类专栏： java 文章标签： junit java 单元测试

本文链接：https://blog.csdn.net/w4187402/article/details/125856365

版权

Quick Settings - configure common code style and other settings here. -----------------------------------------------

Set these to use special prefixes for test class members containing dependencies of certain types.

Note that the template code below will ignore any prefix set to “” and use your IDE code style settings instead.

#set( $KaTeX parse error: Expected 'EOF', got '#' at position 34: \dotsmePrefix = "") #̲set($ mockDependencyMemberNamePrefix = “mock”)

Set this to use a special prefix for local fields containing arguments for test methods.

#set( $KaTeX parse error: Expected 'EOF', got '#' at position 37: \dotsmePrefix = "") #̲set($ mockParameterLocalFieldNamePrefix = “mock”)

Customize the name of the member and local field (if needed) used to store the instance of the source class.

#set( $so u rce Cl a ss . t es tCl a ss M e mb er N am e = "$ {sourceClass.testClassMemberName}UnderTest")
#set( $so u rce Cl a ss . t es tCl a ss L oc a lF i e l d N am e = "$ {sourceClass.testClassLocalFieldName}UnderTest")
#set($shouldUseMockitoExtension = $ClassUtils.isInTestClasspath(‘org.mockito.runners.MockitoJUnitRunner’) || $Cl a ss U t i l s . i s I n T es tCl a ss p a t h (^{'} or g . m oc ki t o . j u ni t . M oc ki t o J U ni tR u nn e r^{'}) ∣∣!$ ClassUtils.isInTestClasspath(‘org.mockito.Mockito’))
#set($shouldUseMockitoBdd = false)

Configure how Bean DTOs are initialized.

#set( $KaTeX parse error: Expected 'EOF', got '#' at position 33: \dotsnitDepth = 10) #̲set($ maxNumberOfSettersToCallPerClass = 10)
#set( $KaTeX parse error: Expected 'EOF', got '#' at position 32: \dotsrsToCall = 70) #̲set($ useStaticImportForInitMocks = true)

Set this to use mocks for mockable method parameters that end in “listener” or “callback” ignoring case.

#set( $KaTeX parse error: Expected 'EOF', got '#' at position 50: \dotsmeters = true) #̲set($ generateStubsAndVerifyStatements = true)

Use this to specify custom initialization values for dependencies and method parameters of certain types;

See https://squaretest.com#template_api_quick_settings for details.

#set($initExpressionOverrides = {} )
##----------------------------------------------------------------------------------------------------------------------

Initialize the data model. This sets global variables based on the architype of the source class and Quick Settings.

See the comments above the macro or https://squaretest.com#template_api_initializeTemplateDataModel for details.

#initializeTemplateDataModel()

Package declaration

#if( $St r in gU t i l s . i s N o tE m pt y ($ sourceClass.packageName))
package $sourceClass.packageName;
#end

Imports; Note that Squaretest invokes IntelliJ’s import organize and code reformatter after creating the test class.

#foreach($importLine in $importLinesRequired)
$KaTeX parse error: Expected 'EOF', got '#' at position 12: importLine #̲end #if($ useStaticImportForInitMocks)
import static org.mockito.MockitoAnnotations. $KaTeX parse error: Expected 'EOF', got '#' at position 101: \dotso.Mockito.spy; #̲end import java\dots$ hasAssertThrows)
import static org.junit.Assert.assertThrows;
#end
#renderImportsForMatchers()
#if($shouldUseMockitoBdd)
import static org.mockito.BDDMockito.willAnswer;
import static org.mockito.BDDMockito.willReturn;
import static org.mockito.BDDMockito.willThrow;
import static org.mockito.BDDMockito.then;
import static org.mockito.BDDMockito.given;
#else
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
#end
import $KaTeX parse error: Expected 'EOF', got '#' at position 296: \dotsubbing.Answer; #̲if($ springController)
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.HttpStatus;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.mock.web.MockMultipartFile;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.user;
import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
#end

Test class

#renderTestClassAnnotationsIfNeeded()
public class ${sourceClass.name}Test extends BaseVoEntityTest<$ {sourceClass.name}>{

@Override
protected ${sourceClass.name} getT() {
    return new ${sourceClass.name}();
}


#renderMockMvcDeclarationIfNeeded()

## Declare member fields for the dependencies.

#renderMemberDeclarations( $KaTeX parse error: Expected 'EOF', got '#' at position 23: \dotsberFields) #̲renderMemberDec\dots$ nonMockMemberFields)

## Declare a member field for the instance of the source class.

#if( $KaTeX parse error: Expected 'EOF', got '#' at position 34: \dotseeded) #̲if($ shouldUseInjectMocks) @InjectMocks #end
private ${sourceClass.type.canonicalText} ${sourceClass.testClassMemberName};
#end

#if( $KaTeX parse error: Expected 'EOF', got '&' at position 13: mocksNeeded &̲& !$ shouldUseMockitoExtension && !$springController && $hasOpenMocksMethod)
private AutoCloseable mockitoCloseable;
#end

Render setUp() only if we need to instantiate source class.

#if( $KaTeX parse error: Expected 'EOF', got '&' at position 25: \dotsssMemberNeeded &̲& !($ shouldUseInjectMocks && $KaTeX parse error: Expected '}', got '#' at position 104: \dots { #̲if($ mocksNeeded && ! $KaTeX parse error: Expected 'EOF', got '#' at position 44: \dots #̲set($ initMocksQualifier = "#if(! $KaTeX parse error: Expected 'EOF', got '#' at position 48: \dotsitoAnnotations.#̲else#end") \dots$ hasOpenMocksMethod)
mockitoCloseable = ${initMocksQualifier}$ {initMocksMethodName}(this);
#else
${initMocksQualifier}$ {initMocksMethodName}(this);
#end
#end

Initialize the non-mock member fields.

#foreach($field in $nonMockMemberFields)
$field.testClassMemberName = $field.initExpression;
#end

Initialize the member containing the source class.

#if( $KaTeX parse error: Expected 'EOF', got '#' at position 23: \dotsseInjectMocks) #̲# Do nothing. \dots$ sourceClass.preferredConstructor)
## Invoke the constructor.
$KaTeX parse error: Expected 'EOF', got '#' at position 41: \dotsberName} = new #̲methodCall($ sourceClass.preferredConstructor, true) #if( $KaTeX parse error: Expected 'EOF', got '&' at position 22: \dotsClass.abstract &̲& !$ sourceClass.sealed) $KaTeX parse error: Expected 'EOF', got '#' at position 30: \dotsstractClassBody#̲end; \dots$ shouldSetPackageLocalFields)
#foreach($field in $dependencies)
${sourceClass.testClassMemberName}.$ {field.declaredName} = #if($field.shouldStoreInReference) $field.testClassMemberName #else $KaTeX parse error: Expected 'EOF', got '#' at position 22: \dotsinitExpression #̲end; \dots$ sourceClass.singleton)
${sourceClass.testClassMemberName} = $sourceClass.singletonAccessExpression;
#else

As a fallback, set the member to null and leave a comment.

$KaTeX parse error: Expected 'EOF', got '#' at position 90: \dots/; #̲end } \dots$ mocksNeeded && ! $KaTeX parse error: Expected 'EOF', got '&' at position 27: \dotsckitoExtension &̲& !$ springController && $hasOpenMocksMethod)
@After
public void tearDown() throws Exception {
mockitoCloseable.close();
}
#end
#end

Render the test methods.

#if( $KaTeX parse error: Expected 'EOF', got '#' at position 46: \dotsthods) #̲renderTestMetho\dots$ sourceClass.publicInstanceMethods)
#renderTestMethods( $KaTeX parse error: Expected 'EOF', got '#' at position 50: \dotsthods) #̲renderTestMetho\dots$ sourceClass.protectedInstanceMethods)
#end
#renderTestMethods( $KaTeX parse error: Expected 'EOF', got '#' at position 38: \dotsicMethods) #̲renderTestMetho\dots$ sourceClass.packageLocalStaticMethods)
#renderTestMethods($sourceClass.protectedStaticMethods)
}

Macros

Add your own macros here. Newlines between macros will not appear in the generated test class;

Squaretest automatically removes all but 1 newline at the end of the generated test class.

##----------------------------------------------------------------------------------------------------------------------

renderTestClassAnnotationsIfNeeded()

Renders the spring controller test class annotations if needed.

##----------------------------------------------------------------------------------------------------------------------
#macro(renderTestClassAnnotationsIfNeeded)
#if( $s p r in g C o n t ro ll er) @ R u nWi t h (Sp r in g R u nn er . c l a ss) @ W e b M v c T es t ($ {sourceClass.canonicalNameOrName}.class)
#elseif($mocksNeeded && $s h o u l d U se M oc ki t o E x t e n s i o n) @ R u nWi t h ($ {mockitoRunnerName}.class)
#end
#end

##----------------------------------------------------------------------------------------------------------------------

renderMockMvcDeclarationIfNeeded()

Renders a MockMvc member field if one is needed.

##----------------------------------------------------------------------------------------------------------------------
#macro(renderMockMvcDeclarationIfNeeded)
#if($springController)
@Autowired
private MockMvc $mockMvcMemberName;
#end
#end

##----------------------------------------------------------------------------------------------------------------------

renderMemberDeclarations($fields)

Renders test-class member declarations for the given List.

Param: $fields - the list of variables for which to render declarations.

##----------------------------------------------------------------------------------------------------------------------
#macro(renderMemberDeclarations $KaTeX parse error: Expected 'EOF', got '#' at position 13: fields) #̲set($ macro.mockAnnotation = "#if( $KaTeX parse error: Expected 'EOF', got '#' at position 27: \dotsoller)@MockBean#̲else@Mock#end")\dots$ macro.nonMockAnnotation = "#if( $KaTeX parse error: Expected 'EOF', got '#' at position 28: \dotsller)@Autowired#̲else#end") \dots$ field in $KaTeX parse error: Expected 'EOF', got '#' at position 17: \dotsields) #̲if($ field.shouldBeMocked)
$macro.mockAnnotation
#else
$macro.nonMockAnnotation
#end
private $field.type.canonicalText $field.testClassMemberName;
#end
#end

##----------------------------------------------------------------------------------------------------------------------

renderTestMethods($methods)

Renders tests for the given List. This filters out getters/setters and other methods for which tests should

not be rendered.

Param: $methods - the list of methods for which to render tests.

##----------------------------------------------------------------------------------------------------------------------
#macro(renderTestMethods $KaTeX parse error: Expected 'EOF', got '#' at position 14: methods) #̲if($ sourceClass.enum)
#set($macro.methodsToUse = $KaTeX parse error: Expected 'EOF', got '#' at position 14: methods) #̲else #set($ macro.methodsToUse = $KaTeX parse error: Expected 'EOF', got '#' at position 70: \dotsbstract')) #̲end #foreach($ method in $KaTeX parse error: Expected 'EOF', got '#' at position 29: \dotsToUse) #̲if($ hasAssertThrows && $KaTeX parse error: Expected 'EOF', got '#' at position 41: \dotst) #̲renderSimpleTes\dots$ method)
#else
#renderTestMethodForPrimaryFlow( $KaTeX parse error: Expected 'EOF', got '#' at position 21: \dotsd) #̲renderTestMetho\dots$ method)
#end
#end
#end

##----------------------------------------------------------------------------------------------------------------------

renderTestMethodForPrimaryFlow($method)

Renders primary flow test case for the given Method.

Param: $method - the method for which to render the test.

##----------------------------------------------------------------------------------------------------------------------
#macro(renderTestMethodForPrimaryFlow $KaTeX parse error: Expected 'EOF', got '#' at position 13: method) #̲renderTestMetho\dots$ method, $AltInfo.newValue())
#end

##----------------------------------------------------------------------------------------------------------------------

renderTestMethodsForAltFlows($method)

Renders test for alternate flows for the given method.

Param: $method - the method for which to render alt-flow tests.

##----------------------------------------------------------------------------------------------------------------------
#macro(renderTestMethodsForAltFlows $method)
## Render tests for exceptions declared by the source method.

Determine if at at least one dependency interaction that we’ve mocked throws an exception.

#set($macro.mockedDIs = $m o d e l A tt r ib u t e P ro v i d er M e t h o d D I s . co n c a t ($ method.dependencyInteractions).satisfiedBy( $KaTeX parse error: Expected 'EOF', got '#' at position 45: \dotsMocked'))) #̲set($ macro.isControllerMethod = $springController && $co n t ro ll er M e t h o d s . co n t ain s ($ method))
#set($macro.shouldRenderTestsForIoParams = $m e t h o d . s t a t i c ∣∣ (!$ macro.isControllerMethod && !( $KaTeX parse error: Expected 'EOF', got '#' at position 42: \dotse() > 1))) #̲set($ macro.runtimeOrNonJdkExRegex = ‘(java.lang.RuntimeException|^(?!java.).+)’)
#set($macro.atLeastOneMockedDiThrows = $macro.mockedDIs.containsAnyWith(‘method.throwsException’, true) || $macro.mockedDIs.containsAnyWithNonNull(‘method.returnType.brokenIoInitExpression’) || $macro.mockedDIs.flatMap(‘method.javadocExceptions’).containsAnyWithRegex(‘type.canonicalName’, $KaTeX parse error: Expected 'EOF', got '#' at position 36: \dotskExRegex)) #̲set($ macro.atLeastOneMockedDiReturnsFailure = $KaTeX parse error: Expected 'EOF', got '#' at position 88: \dotsression')) #̲set($ macro.atLeastOneParamHasIo = $method.parameters.containsAnyWithNonNull(‘type.brokenIoInitExpression’))
## Only render tests for the source method’s declared exceptions if none of the source method’s mocked DIs throw.

If one of the mocked DIs throw, that test case will likely be the case where the source class throws the declared exception(s).

#set( $ma cro . s h o u l d R e n d er T es t s F orDec l a re d E x ce pt i o n s =!$ macro.atLeastOneMockedDiThrows && ! $KaTeX parse error: Expected 'EOF', got '&' at position 28: \dotstOneParamHasIo &̲& !$ macro.atLeastOneMockedDiReturnsFailure)
#set($macro.allSourceMethodExceptions = $m e t h o d . d ec l a re d E x ce pt i o n s . u ni o n ($ method.javadocExceptions, ‘type.canonicalName’))
#if(! $KaTeX parse error: Expected 'EOF', got '#' at position 43: \dotsments) #̲renderAltFlowTe\dots$ method, $macro.allSourceMethodExceptions)
#break
#end

Determine the exception to throw in the broken IO case (if any).

#set($macro.declaredIoException = $KaTeX parse error: Expected 'EOF', got '#' at position 90: \dotsn').first) #̲if(!$ macro.declaredIoException && $KaTeX parse error: Expected 'EOF', got '#' at position 48: \dots == 1) #̲set($ macro.declaredIoException = $method.declaredExceptions.first)
#end

Render alternate flow tests based on parameters.

#if( $KaTeX parse error: Expected 'EOF', got '#' at position 45: \dotsarams) #̲foreach($ param in $KaTeX parse error: Expected 'EOF', got '#' at position 32: \dotss) #̲if($ param.type.emptyIoInitExpression)
#renderTestMethod($method, $A lt I n f o . f ro m P a r amWi t h E m pt y I o ($ param))
#end
#if( $KaTeX parse error: Expected 'EOF', got '#' at position 52: \dots #̲renderTestMetho\dots$ method, $A lt I n f o . f ro m P a r amWi t h B ro k e n I o ($ param, $macro.declaredIoException))
#end
#end
#end

Render alternate flow tests based on the dependency interactions.

#foreach($di in $KaTeX parse error: Expected 'EOF', got '#' at position 26: \dotsedDIs) #̲# Determine inf\dots$ macro.isListenableFuture = $L i s t e nab l e F u t u re N am es . co n t ain s ($ di.method.returnType.canonicalName))
#set($macro.isStandardFuture = $St r in gU t i l s . e q u a l s A n y ($ di.method.returnType.canonicalName, ‘java.util.concurrent.Future’, ‘java.util.concurrent.CompletableFuture’, ‘java.util.concurrent.CompletionStage’))
#set($macro.isAnyFuture = $KaTeX parse error: Expected 'EOF', got '#' at position 68: \dotsure')) #̲set($ macro.firstTypeParamCanBeEmpty = $St r in gU t i l s . i s N o tE m pt y ($ di.method.returnType.parameters.first.emptyInitExpression))
#set($macro.firstTypeParamCanBeAbsent = $KaTeX parse error: Expected 'EOF', got '&' at position 60: \dotsInitExpression &̲& !$ StringUtils.equals( $KaTeX parse error: Expected 'EOF', got '#' at position 78: \dotsull')) #̲set($ macro.shouldRenderAbsentTest = ! $KaTeX parse error: Expected 'EOF', got '&' at position 54: \dotsent.Executor') &̲& ($ di.method.returnTypeCanBeAbsent || ($macro.isListenableFuture && $KaTeX parse error: Expected 'EOF', got '#' at position 44: \dotsent))) #̲set($ macro.shouldRenderEmptyTest = ! $KaTeX parse error: Expected 'EOF', got '&' at position 54: \dotsent.Executor') &̲& ($ di.method.returnType.emptyInitExpression || ($macro.isListenableFuture && $KaTeX parse error: Expected 'EOF', got '#' at position 43: \dotspty))) #̲set($ macro.shouldRenderEmptyIoTest = ! $KaTeX parse error: Expected 'EOF', got '&' at position 54: \dotsent.Executor') &̲& ($ di.method.returnType.emptyIoInitExpression || $d i . m e t h o d . re t u r n T y p e . d t o B e anWi t h I n p u t I o P ro p er t y ∣∣ ($ macro.isListenableFuture && $KaTeX parse error: Expected 'EOF', got '#' at position 72: \dotsion))) #̲set($ macro.shouldRenderBrokenIoTest = ! $KaTeX parse error: Expected 'EOF', got '&' at position 54: \dotsent.Executor') &̲& ($ di.method.returnType.brokenIoInitExpression || $d i . m e t h o d . re t u r n T y p e . d t o B e anWi t h I n p u t I o P ro p er t y ∣∣ ($ macro.isListenableFuture && $KaTeX parse error: Expected 'EOF', got '#' at position 73: \dotsion))) #̲set($ macro.shouldRenderFailureTest = !($di.field.type.isAny(‘java.util.concurrent.Executor’) && $KaTeX parse error: Expected 'EOF', got '&' at position 20: \dotso.isAnyFuture) &̲& ($ di.method.returnType.failureInitExpression || $macro.isStandardFuture || $KaTeX parse error: Expected 'EOF', got '#' at position 36: \dotsture)) #̲if(!$ di.method.declaredExceptions.empty)
#set($macro.diExceptionsToUse = $KaTeX parse error: Expected 'EOF', got '#' at position 39: \dotstions) #̲else #set($ macro.diExceptionsToUse = $di.method.javadocExceptions.filterItemsWithRegex(‘type.canonicalName’, $KaTeX parse error: Expected 'EOF', got '#' at position 40: \dotsegex)) #̲end #set($ macro.diExceptionsToUse = $ma cro . d i E x ce pt i o n s T o U se . u ni o n ($ di.method.undeclaredExceptions, ‘type.canonicalName’))
## Render the alt flow tests.
#if( $KaTeX parse error: Expected 'EOF', got '#' at position 43: \dotst) #̲# Render the te\dots$ method, $A lt I n f o . f ro m D i T o R e t u r n A b se n t ($ di))
#end
#if( $KaTeX parse error: Expected 'EOF', got '#' at position 42: \dotst) #̲# Render the te\dots$ method, $A lt I n f o . f ro m D i T o R e t u r n E m pt y ($ di))
#end
#if( $KaTeX parse error: Expected 'EOF', got '#' at position 44: \dotst) #̲renderTestMetho\dots$ method, $A lt I n f o . f ro m D i T o R e t u r n E m pt y I o ($ di))
#end
#if( $KaTeX parse error: Expected 'EOF', got '#' at position 45: \dotst) #̲renderTestMetho\dots$ method, $A lt I n f o . f ro m D i T o R e t u r n B ro k e n I o ($ di, $KaTeX parse error: Expected 'EOF', got '#' at position 37: \dotstion)) #̲end #if($ macro.shouldRenderFailureTest)
#renderTestMethod($method, $A lt I n f o . f ro m D i T o R e t u r n F ai l u re ($ di))
#end
#foreach($exception in $KaTeX parse error: Expected 'EOF', got '#' at position 38: \dotse) #̲if($ macro.allSourceMethodExceptions.containsAnyWith(‘type.canonicalName’, $exception.type.canonicalName))
## If the source method throws a checked exception of the same type as the exception thrown by this

dependency interaction, assume it simply lets the exception bubble up; in this case, the test case

should expect the source-method to throw the $exception.

#set($macro.expectedException = $KaTeX parse error: Expected 'EOF', got '#' at position 24: \dotsn) #̲else #set($ macro.expectedException = $KaTeX parse error: Expected 'EOF', got '#' at position 19: \dotsl) #̲end #renderTes\dots$ method, $A lt I n f o . f ro m D i T ha tT h ro w s ($ di, $exception, $KaTeX parse error: Expected 'EOF', got '#' at position 35: \dotstion)) #̲end #end #if($ macro.shouldRenderTestsForDeclaredExceptions)
#renderAltFlowTestsForDeclaredExceptions($method, $macro.allSourceMethodExceptions)
#end
#end

##----------------------------------------------------------------------------------------------------------------------

renderAltFlowTestsForDeclaredExceptions $method, $exceptions)

Renders alt-flow tests where the provided $method is expected to throw the provided $exceptions.

Param: $method - the method for which to render alt-flow tests.

##----------------------------------------------------------------------------------------------------------------------
#macro(renderAltFlowTestsForDeclaredExceptions $method, $KaTeX parse error: Expected 'EOF', got '#' at position 17: \dotsxceptions) #̲foreach($ declaredException in $KaTeX parse error: Expected 'EOF', got '#' at position 21: \dotstions) #̲renderTestMetho\dots$ method, $A lt I n f o . f ro m E x p ec t e d E x ce pt i o n ($ declaredException))
#end
#end

##----------------------------------------------------------------------------------------------------------------------

renderTestMethod($method, $altInfo)

Renders the test for the given Method.

Param: $method - the method for which to render the test.

Param: $altInfo - information about which alternate flow this test should cover.

##----------------------------------------------------------------------------------------------------------------------
#macro(renderTestMethod $method, $KaTeX parse error: Expected 'EOF', got '#' at position 14: altInfo) #̲set($ _ = $KaTeX parse error: Expected 'EOF', got '#' at position 40: \dotsodScope()) #̲if($ method.shouldUseSimpleTest)
#renderSimpleTestMethod($method, $KaTeX parse error: Expected 'EOF', got '#' at position 32: \dotsException) #̲elseif($ sourceClass.enum)
#renderTestMethodForEnum($method, $KaTeX parse error: Expected 'EOF', got '#' at position 14: altInfo) #̲elseif($ sourceClass.packageVisibleStaticCreatorMethods.contains( $KaTeX parse error: Expected 'EOF', got '&' at position 9: method) &̲& !$ sourceClass.singleton && ! $KaTeX parse error: Expected 'EOF', got '&' at position 27: \dotsectedException &̲& !$ altInfo.paramWithEmptyIo && ! $KaTeX parse error: Expected 'EOF', got '#' at position 36: \dotskenIo) #̲renderStaticCre\dots$ method)
#elseif($springController && $co n t ro ll er M e t h o d s . co n t ain s ($ method))
#renderTestMethodForController($method, $KaTeX parse error: Expected 'EOF', got '#' at position 14: altInfo) #̲elseif($ springController && !$method.static) ## Do nothing. This could be a method with @ExceptionHandler, @InitBinder, etc. Those should be covered in the other test cases.
#else

Determine if we should create an assertEquals(…) call.

#set($macro.returnTypeIsArrayWithComparableType = $KaTeX parse error: Expected 'EOF', got '&' at position 25: \dotsturnType.array &̲& ($ method.returnType.deepArrayComponentType.primitive || $KaTeX parse error: Expected 'EOF', got '#' at position 68: \dotsuals)) #̲set($ macro.shouldCreateAssertEqualsCall =
$KaTeX parse error: Expected 'EOF', got '&' at position 19: \dotshod.returnType &̲& ($ method.returnType.primitive || $method.returnType.overridesEquals || $KaTeX parse error: Expected 'EOF', got '&' at position 27: \dotsrnType.array) &̲& ($ method.returnType.classT || $method.returnType.allNestedTypeParamsOverrideEquals || $KaTeX parse error: Expected 'EOF', got '&' at position 45: \dotsmparableType) &̲& !$ altInfo.expectedException)
#set($macro.shouldStoreExpectedValue = $KaTeX parse error: Expected 'EOF', got '&' at position 36: \dotssertEqualsCall &̲& !$ method.returnType.simple)
#set($macro.shouldRenderExceptionHeader = $KaTeX parse error: Expected 'EOF', got '&' at position 27: \dotsectedException &̲& !$ hasAssertThrows)
## Determine the test case suffix to use for this test method and store the result in: $KaTeX parse error: Expected 'EOF', got '#' at position 18: \dotsstCaseSuffix. #̲determineTestCa\dots$ method, $altInfo)

@Test #if($macro.shouldRenderExceptionHeader)(expected = ${altInfo.expectedException.type.canonicalNameOrName}.class) #end

public void test $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dotsils.capitalize($ {method.name})} ${method.overloadSuffix}$ {testCaseSuffix}() throws Exception {
// Setup

Declare parameters to use to invoke the method.

#foreach($param in $KaTeX parse error: Expected 'EOF', got '#' at position 71: \dots)) #̲if($ param == $KaTeX parse error: Expected 'EOF', got '#' at position 43: \dots #̲declareAndInitL\dots$ param, $KaTeX parse error: Expected 'EOF', got '#' at position 53: \dotse) #̲elseif($ param == $KaTeX parse error: Expected 'EOF', got '#' at position 44: \dots #̲declareAndInitL\dots$ param, $KaTeX parse error: Expected 'EOF', got '#' at position 54: \dotse) #̲else #declareA\dots$ param, true)
#end
#end
#if( $KaTeX parse error: Expected 'EOF', got '#' at position 45: \dotse) #̲declareAndInitL\dots$ method.returnType, true)
#end
#renderStubs($method, $altInfo)

        // Run the test

#set( $KaTeX parse error: Expected 'EOF', got '#' at position 20: \dotso.qualifier = "#̲if($ method.static) $KaTeX parse error: Expected 'EOF', got '#' at position 34: \dotsicalNameOrName}#̲else$ {sourceClass.testClassMemberName}#end")
#if( $KaTeX parse error: Expected 'EOF', got '#' at position 40: \dotsn) #̲if($ hasAssertThrows)
assertThrows(${altInfo.expectedException.type.canonicalNameOrName}.class, () -> $KaTeX parse error: Expected 'EOF', got '#' at position 19: \dotscro.qualifier}.#̲methodCall($ method, false));
#renderVerifyStatements($method, $altInfo)
#else
$KaTeX parse error: Expected 'EOF', got '#' at position 19: \dotscro.qualifier}.#̲methodCall($ method, false);
#end
#else
#if($method.returnType) final $method.returnType.canonicalText result = #end $KaTeX parse error: Expected 'EOF', got '#' at position 19: \dotscro.qualifier}.#̲methodCall($ method, false);

            // Verify the results

#if( $KaTeX parse error: Expected 'EOF', got '#' at position 53: \dots #̲set($ macro.expectedValueExpression = "#if( $ma cro . s h o u l d St ore E x p ec t e d Va l u e)$ method.returnType.testClassLocalFieldName #else $KaTeX parse error: Expected 'EOF', got '#' at position 34: \dotsinitExpression #̲end") \dots$ macro.expectedValueExpression, ‘result’, $KaTeX parse error: Expected 'EOF', got '#' at position 33: \dots); #̲end #renderVer\dots$ method, $KaTeX parse error: Expected 'EOF', got '#' at position 18: \dotstInfo) #̲end } #end\dots$ _ = $CodeStyleUtils.endMethodScope())
#end

##----------------------------------------------------------------------------------------------------------------------

renderTestMethodForController $method, $altInfo)

Renders the test for the given controller Method.

Param: $method - the method for which to render the test.

Param: $altInfo - information about which alternate flow this test should cover.

##----------------------------------------------------------------------------------------------------------------------
#macro(renderTestMethodForController $method, $altInfo)
## Determine the test case suffix to use for this test method and store the result in: $KaTeX parse error: Expected 'EOF', got '#' at position 18: \dotsstCaseSuffix. #̲determineTestCa\dots$ method, $KaTeX parse error: Expected 'EOF', got '#' at position 14: altInfo) #̲# Determine the\dots$ macro.pathHolder = $KaTeX parse error: Expected 'EOF', got '#' at position 29: \dots.create()) #̲determinePath($ method, $KaTeX parse error: Expected 'EOF', got '#' at position 23: \dotsathHolder) #̲# Determine the\dots$ macro.pathArgsHolder = $KaTeX parse error: Expected 'EOF', got '#' at position 29: \dots.create()) #̲determinePathAr\dots$ method, $KaTeX parse error: Expected 'EOF', got '#' at position 27: \dotsrgsHolder) #̲# Determine if \dots$ macro.multipartUploadHolder = $KaTeX parse error: Expected 'EOF', got '#' at position 35: \dotste(false)) #̲determineIfMult\dots$ method, $KaTeX parse error: Expected 'EOF', got '#' at position 34: \dotsoadHolder) #̲# Determine the\dots$ macro.requestMethodHolder = $KaTeX parse error: Expected 'EOF', got '#' at position 29: \dots.create()) #̲determineReques\dots$ method, $macro.multipartUploadHolder.value, $KaTeX parse error: Expected 'EOF', got '#' at position 32: \dotshodHolder) #̲# Determine the\dots$ macro.responseContentTypeHolder = $KaTeX parse error: Expected 'EOF', got '#' at position 29: \dots.create()) #̲determineRespon\dots$ method, $KaTeX parse error: Expected 'EOF', got '#' at position 38: \dotsypeHolder) #̲# Determine the\dots$ macro.expectedResponseCodeHolder = $KaTeX parse error: Expected 'EOF', got '#' at position 29: \dots.create()) #̲determineExpect\dots$ altInfo.expectedException, $KaTeX parse error: Expected 'EOF', got '#' at position 39: \dotsodeHolder) #̲# Determine the\dots$ macro.httpParamsCallStringHolder = $KaTeX parse error: Expected 'EOF', got '#' at position 29: \dots.create()) #̲determineHttpPa\dots$ method, $macro.requestMethodHolder.value, $macro.multipartUploadHolder.value, $KaTeX parse error: Expected 'EOF', got '#' at position 39: \dotsingHolder) #̲if($ macro.requestMethodHolder.value == ‘trace’)
#set($macro.requestMethodCall = 'request(HttpMethod.TRACE, ’ + ‘"’ + $macro.pathHolder.value + ‘"’ + $KaTeX parse error: Expected 'EOF', got '#' at position 39: \dotslue + ')') #̲else #set($ macro.requestMethodCall = $macro.requestMethodHolder.value + ‘(’ + ‘"’ + $macro.pathHolder.value + ‘"’ + $KaTeX parse error: Expected 'EOF', got '#' at position 39: \dotslue + ')') #̲end @Test publi\dots$ {StringUtils.capitalize( $KaTeX parse error: Expected 'EOF', got '}' at position 15: {method.name})}̲$ {method.overloadSuffix} $KaTeX parse error: Expected '}', got '#' at position 49: \dotson { // Setup #̲renderStubs($ method, $altInfo)

// Run the test
final MockHttpServletResponse response = ${mockMvcMemberName}.perform($ {macro.requestMethodCall} ${Newline}$ {macro.httpParamsCallStringHolder}.accept( $ma cro . res p o n se C o n t e n tT y p eHo l d er))$ {Newline}.andReturn().getResponse();

    // Verify the results

#assertEqualsCall( $KaTeX parse error: Expected 'EOF', got '#' at position 77: \dots', false); #̲assertEqualsCal\dots$ method, $altInfo)
}
#end

##----------------------------------------------------------------------------------------------------------------------

determineExpectedResponseCode($expectedException, $expectedResponseCodeHolder)

Determines the expected response code based on the provided exception and writes the string to

$expectedResponseCodeHolder.value.

Param: $expectedException - the expected exception for the test case.

Param: $expectedResponseCodeHolder - the MutableString that will contain the expected response code.

##----------------------------------------------------------------------------------------------------------------------
#macro(determineExpectedResponseCode $expectedException, $KaTeX parse error: Expected 'EOF', got '#' at position 33: \dotsodeHolder) #̲if($ expectedException)
#set( $KaTeX parse error: Expected 'EOF', got '#' at position 84: \dots.value()') #̲else #set($ expectedResponseCodeHolder.value = ‘HttpStatus.OK.value()’)
#end
#end

##----------------------------------------------------------------------------------------------------------------------

determineResponseContentType($method, $responseContentTypeHolder)

Determines the content type to use for the response and stores the result in $responseContentTypeHolder.value.

Param: $method - the expected exception for the test case.

Param: $responseContentTypeHolder - the MutableString that will contain the expected response code.

##----------------------------------------------------------------------------------------------------------------------
#macro(determineResponseContentType $method, $KaTeX parse error: Expected 'EOF', got '#' at position 32: \dotsypeHolder) #̲set($ macro.superMethods = $Fl u e n t L i s t . o f ($ method).concat( $KaTeX parse error: Expected 'EOF', got '#' at position 27: \dotsrMethods)) #̲if($ restController || $macro.superMethods.containsAnyWithAnnotation(‘ResponseBody’, ‘JsonView’)
|| $method.returnType.isAny(‘org.springframework.http.HttpEntity’) || $KaTeX parse error: Expected 'EOF', got '#' at position 90: \dotsity')) #̲set($ responseContentTypeHolder.value = ‘MediaType.APPLICATION_JSON’)
#else
#set($responseContentTypeHolder.value = ‘MediaType.TEXT_HTML’)
#end
#end

##----------------------------------------------------------------------------------------------------------------------

determineIfMultipartUpload($method, $multipartUploadHolder)

Determines if the controller method is handling a multipart upload request and saves the output (boolean) to

$multipartUploadHolder.value.

Param: $method - the method.

Param: $multipartUploadHolder - the MutableBoolean that will contain the output value.

##----------------------------------------------------------------------------------------------------------------------
#macro(determineIfMultipartUpload $method, $KaTeX parse error: Expected 'EOF', got '#' at position 28: \dotsoadHolder) #̲set($ multipartUploadHolder.value = false)
#set($macro.superMethods = $Fl u e n t L i s t . o f ($ method).concat( $KaTeX parse error: Expected 'EOF', got '#' at position 27: \dotsrMethods)) #̲set($ macro.superParams = $m e t h o d . p a r am e t ers . co n c a t ($ method.superMethods.flatMap(‘parameters’)))
## Check the controller method(s) mapping annotations to see if one of them has consumes=multipart.
#if($macro.superMethods.flatMap(‘annotations’).filterItemsWithAny(‘name’, $ControllerMethodAnnotations).flatMap('parameters').filter('key', 'consumes').containsAnyWithRegex('value.text', '^.*(MULTIPART_|multipart/).*$ '))
#set( $KaTeX parse error: Expected 'EOF', got '#' at position 45: \dots true) #̲break($ macro)
#end
#if( $KaTeX parse error: Expected 'EOF', got '#' at position 69: \dotsart')) #̲set($ multipartUploadHolder.value = true)
#break( $KaTeX parse error: Expected 'EOF', got '#' at position 12: macro) #̲end #foreach($ param in $KaTeX parse error: Expected 'EOF', got '#' at position 28: \dotseters) #̲if($ param.type.isOrHasAnyNestedTypeParamWith( $KaTeX parse error: Expected 'EOF', got '#' at position 39: \dots)) #̲set($ multipartUploadHolder.value = true)
#break( $KaTeX parse error: Expected 'EOF', got '#' at position 16: macro) #̲end #determine\dots$ param, $KaTeX parse error: Expected 'EOF', got '#' at position 32: \dotsolder) #̲if($ multipartUploadHolder.value)
#break($macro)
#end
#end
#end

##----------------------------------------------------------------------------------------------------------------------

determineIfClassHasMultipartFile($method, $paramClassHasMultipartHolder)

Determines if the parameter or the parameter’s inner most type parameter have a member field containing a multipart

file type. This macro writes the output boolean to $paramClassHasMultipartHolder.value.

Param: $param - the parameter

Param: $paramClassHasMultipartHolder - the MutableBoolean that will contain the output.

##----------------------------------------------------------------------------------------------------------------------
#macro(determineIfClassHasMultipartFile $param, $KaTeX parse error: Expected 'EOF', got '#' at position 35: \dotsartHolder) #̲set($ paramClassHasMultipartHolder.value = false)
#set($macro.typeToUse = $KaTeX parse error: Expected 'EOF', got '#' at position 17: \dotsaram.type) #̲set($ macro.hasMultipleTypeParams = false)
#foreach( $KaTeX parse error: Expected 'EOF', got '#' at position 23: \dots..25]) #̲if($ macro.typeToUse.parameters.empty)
#break( $KaTeX parse error: Expected 'EOF', got '#' at position 18: \dotsreach) #̲elseif($ macro.typeToUse.parameters.size() > 1)
#set( $KaTeX parse error: Expected 'EOF', got '#' at position 49: \dotse) #̲break($ foreach)
#else
#set($macro.typeToUse = $KaTeX parse error: Expected 'EOF', got '#' at position 43: \dotsfirst) #̲end #end #if($ macro.hasMultipleTypeParams)
#break( $KaTeX parse error: Expected 'EOF', got '#' at position 12: macro) #̲end #set($ macro.paramClass = $Cl a ss U t i l s . reso l v e Cl a ss ($ macro.typeToUse))
#if( $KaTeX parse error: Expected 'EOF', got '#' at position 27: \dotsClass) #̲foreach($ field in $KaTeX parse error: Expected 'EOF', got '#' at position 38: \dotss) #̲if($ field.type.isOrHasAnyNestedTypeParamWith( $KaTeX parse error: Expected 'EOF', got '#' at position 43: \dots #̲set($ paramClassHasMultipartHolder.value = true)
#break($macro)
#end
#end
#end
#end

##----------------------------------------------------------------------------------------------------------------------

determinePath($method, $pathHolder)

Determines the path to use for the controller method and writes it to $pathHolder.value.

Param: $method - the method to determine the controller path for.

Param: $pathHolder - the MutableString the controller path will be written to.

##----------------------------------------------------------------------------------------------------------------------
#macro(determinePath $method, $KaTeX parse error: Expected 'EOF', got '#' at position 17: \dotsathHolder) #̲set($ pathHolder.value = ‘path’)
#set($macro.superMethods = $Fl u e n t L i s t . o f ($ method).concat( $KaTeX parse error: Expected 'EOF', got '#' at position 27: \dotsrMethods)) #̲set($ macro.annotationPath = $macro.superMethods.flatMap(‘annotations’).filterItemsWithAny(‘name’, $RequestMappingAnnotations).flatMap(‘parameters’).filter(‘key’, ‘path’, ‘value’).filterOut(‘value.text’, ‘{}’).first.value.text)
## Replace environment variable placeholders like $KaTeX parse error: Expected 'EOF', got '#' at position 48: \dotscompanyName/. #̲set($ macro.tempPath = $St r in gU t i l s . re pl a ce A ll ($ macro.annotationPath, ‘${(.*?)}’, '/ $KaTeX parse error: Expected 'EOF', got '#' at position 11: 1/')) #̲# The path can \dots$ macro.tempPath = $St r in gU t i l s . l o n g es t ($ StringUtils.substringsBetween( $KaTeX parse error: Expected 'EOF', got '#' at position 28: \dotsth, '"'))) #̲if($ macro.tempPath)
#set($pathHolder.value = $basePath + ‘/’ + $KaTeX parse error: Expected 'EOF', got '#' at position 21: \dots.tempPath) #̲elseif($ macro.annotationPath)
## The path could be a reference to a constant; e.g. MyPaths.FooPath.
#set($pathHolder.value = $basePath + ‘/’ + ‘path’)
#else

There is no mapping annotation with a path parameter. Use the base path.

#set($pathHolder.value = $basePath)
#end

Remove duplicate forward slashes.

#set($pathHolder.value = $pathHolder.value.replaceAll(‘/+’, ‘/’).trim())
#end

##----------------------------------------------------------------------------------------------------------------------

determinePathArgs($method, $pathArgsHolder)

Determines the path variables to use for the controller method and writes it to determinePathArgs.value.

Param: $method - the method to determine the controller path args for.

Param: $pathArgsHolder - the MutableString the controller path args String will be written to.

##----------------------------------------------------------------------------------------------------------------------
#macro(determinePathArgs $method, $KaTeX parse error: Expected 'EOF', got '#' at position 21: \dotsrgsHolder) #̲set($ pathArgsHolder.value = ‘’)
#foreach($param in $KaTeX parse error: Expected 'EOF', got '#' at position 28: \dotseters) #̲set($ macro.superParamsAtIndex = $Fl u e n t L i s t . o f ($ param).concat( $m e t h o d . g e tS u p er M e t h o d P a r am e t ers A t I n d e x ($ foreach.index)))
#if( $KaTeX parse error: Expected 'EOF', got '#' at position 99: \dots)) #̲# Determine the\dots$ macro.paramValue = ‘"’ + $KaTeX parse error: Expected 'EOF', got '#' at position 39: \dots') #̲if($ param.type.isOrHasAnyNestedTypeParamWith( $KaTeX parse error: Expected 'EOF', got '#' at position 32: \dots #̲set($ macro.paramValue = ‘false’)
#elseif( $p a r am . t y p e . i s O rH a s A n y N es t e d T y p e P a r amWi t h ($ NumericTypes))
#set( $KaTeX parse error: Expected 'EOF', got '#' at position 37: \dots') #̲end #set($ pathArgsHolder.value = $pathArgsHolder.value + ', ’ + $macro.paramValue)
#end
#end
#end

##----------------------------------------------------------------------------------------------------------------------

determineHttpParamsCallString($method, $requestMethod, $multipartUpload, $httpParamsCallStringHolder)

Determines the string of method calls needed to add parts to the HTTP request that the controller method is expecting.

The result is stored as a String in $httpParamsCallStringHolder.value.

Param: $method - the controller method to create the http method calls for.

Param: $requestMethod - the request method determined for this method; e.g. ‘get’, ‘post’, ‘multipart’, etc.

Param: $multipartUpload - boolean indicating whether or not this is a multipart request.

Param: $httpParamsCallStringHolder - MutableString object whose value will contain the output of this macro.

##----------------------------------------------------------------------------------------------------------------------
#macro(determineHttpParamsCallString $method, $requestMethod, $multipartUpload, $KaTeX parse error: Expected 'EOF', got '#' at position 33: \dotsingHolder) #̲set($ httpParamsCallStringHolder.value = ‘’)
#set($macro.fileParamsCallStringHolder = $KaTeX parse error: Expected 'EOF', got '#' at position 31: \dotsreate('')) #̲set($ macro.superParams = $m e t h o d . p a r am e t ers . co n c a t ($ method.superMethods.flatMap(‘parameters’)))
#set($macro.superMethods = $Fl u e n t L i s$