@Override
public View resolveViewName(final String viewName, Locale locale) throws Exception {
	return new AbstractView () {
		@Override
		public String getContentType() {
			return null;
		}
		@Override
		protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request,
				HttpServletResponse response) throws Exception {
			for (String key : attrsToValidate.keySet()) {
				assertTrue("Model should contain attribute named " + key, model.containsKey(key));
				assertEquals(attrsToValidate.get(key), model.get(key));
				validatedAttrCount++;
			}
		}
	};
}
 

@Override
public View resolveViewName(final String viewName, Locale locale) throws Exception {
	return new AbstractView () {
		@Override
		public String getContentType() {
			return null;
		}
		@Override
		protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request,
				HttpServletResponse response) throws Exception {
			for (String key : attrsToValidate.keySet()) {
				assertTrue("Model should contain attribute named " + key, model.containsKey(key));
				assertEquals(attrsToValidate.get(key), model.get(key));
				validatedAttrCount++;
			}
		}
	};
}
 

@Advice.OnMethodEnter(suppress = Throwable.class)
public static void beforeExecute(@Advice.Local("span") @Nullable Span span,
                                 @Advice.This @Nullable Object thiz) {
    if (tracer == null || tracer.getActive() == null) {
        return;
    }
    final AbstractSpan<?> parent = tracer.getActive();

    String className = thiz.getClass().getName();
    span = parent.createSpan()
        .withType(SPAN_TYPE)
        .withSubtype(getSubtype(className))
        .withAction(SPAN_ACTION)
        .withName(DISPATCHER_SERVLET_RENDER_METHOD);

    if (thiz instanceof AbstractView) {
        AbstractView view = (AbstractView) thiz;
        span.appendToName(" ").appendToName(view.getBeanName());
    }
    span.activate();
}
 

@Override
public View resolveViewName(final String viewName, Locale locale) throws Exception {
	return new AbstractView () {
		@Override
		public String getContentType() {
			return null;
		}
		@Override
		protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request,
				HttpServletResponse response) throws Exception {
			for (String key : attrsToValidate.keySet()) {
				assertTrue("Model should contain attribute named " + key, model.containsKey(key));
				assertEquals(attrsToValidate.get(key), model.get(key));
				validatedAttrCount++;
			}
		}
	};
}
 

@Test
public void validTemplateName() throws Exception {
	FreeMarkerView fv = new FreeMarkerView();

	WebApplicationContext wac = mock(WebApplicationContext.class);
	MockServletContext sc = new MockServletContext();

	Map<String, FreeMarkerConfig> configs = new HashMap<>();
	FreeMarkerConfigurer configurer = new FreeMarkerConfigurer();
	configurer.setConfiguration(new TestConfiguration());
	configurer.setServletContext(sc);
	configs.put("configurer", configurer);
	given(wac.getBeansOfType(FreeMarkerConfig.class, true, false)).willReturn(configs);
	given(wac.getServletContext()).willReturn(sc);

	fv.setUrl("templateName");
	fv.setApplicationContext(wac);

	MockHttpServletRequest request = new MockHttpServletRequest();
	request.addPreferredLocale(Locale.US);
	request.setAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);
	request.setAttribute(DispatcherServlet.LOCALE_RESOLVER_ATTRIBUTE, new AcceptHeaderLocaleResolver());
	HttpServletResponse response = new MockHttpServletResponse();

	Map<String, Object> model = new HashMap<>();
	model.put("myattr", "myvalue");
	fv.render(model, request, response);

	assertEquals(AbstractView.DEFAULT_CONTENT_TYPE, response.getContentType());
}
 

@Test
public void validTemplateName() throws Exception {
	FreeMarkerView fv = new FreeMarkerView();

	WebApplicationContext wac = mock(WebApplicationContext.class);
	MockServletContext sc = new MockServletContext();

	Map<String, FreeMarkerConfig> configs = new HashMap<>();
	FreeMarkerConfigurer configurer = new FreeMarkerConfigurer();
	configurer.setConfiguration(new TestConfiguration());
	configurer.setServletContext(sc);
	configs.put("configurer", configurer);
	given(wac.getBeansOfType(FreeMarkerConfig.class, true, false)).willReturn(configs);
	given(wac.getServletContext()).willReturn(sc);

	fv.setUrl("templateName");
	fv.setApplicationContext(wac);

	MockHttpServletRequest request = new MockHttpServletRequest();
	request.addPreferredLocale(Locale.US);
	request.setAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);
	request.setAttribute(DispatcherServlet.LOCALE_RESOLVER_ATTRIBUTE, new AcceptHeaderLocaleResolver());
	HttpServletResponse response = new MockHttpServletResponse();

	Map<String, Object> model = new HashMap<>();
	model.put("myattr", "myvalue");
	fv.render(model, request, response);

	assertEquals(AbstractView.DEFAULT_CONTENT_TYPE, response.getContentType());
}
 

@Test
public void validTemplateName() throws Exception {
	FreeMarkerView fv = new FreeMarkerView();

	WebApplicationContext wac = mock(WebApplicationContext.class);
	MockServletContext sc = new MockServletContext();

	Map<String, FreeMarkerConfig> configs = new HashMap<String, FreeMarkerConfig>();
	FreeMarkerConfigurer configurer = new FreeMarkerConfigurer();
	configurer.setConfiguration(new TestConfiguration());
	configs.put("configurer", configurer);
	given(wac.getBeansOfType(FreeMarkerConfig.class, true, false)).willReturn(configs);
	given(wac.getServletContext()).willReturn(sc);

	fv.setUrl("templateName");
	fv.setApplicationContext(wac);

	MockHttpServletRequest request = new MockHttpServletRequest();
	request.addPreferredLocale(Locale.US);
	request.setAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);
	request.setAttribute(DispatcherServlet.LOCALE_RESOLVER_ATTRIBUTE, new AcceptHeaderLocaleResolver());
	HttpServletResponse response = new MockHttpServletResponse();

	Map<String, Object> model = new HashMap<String, Object>();
	model.put("myattr", "myvalue");
	fv.render(model, request, response);

	assertEquals(AbstractView.DEFAULT_CONTENT_TYPE, response.getContentType());
}
 

protected void renderActualView(String pageViewName, Map<String, Object> model, HttpServletRequest request,
                                HttpServletResponse response) throws Exception {
    View actualView = delegatedViewResolver.resolveViewName(pageViewName, locale);
    if (actualView == null) {
        throw new RenderingException("No view was resolved for page view name '" + pageViewName + "'");
    }
    if (actualView instanceof AbstractView) {
        ((AbstractView) actualView).setContentType(getContentType());
    }

    actualView.render(model, request, response);
}
 

@Test
public void testExposeHelpers() throws Exception {
	final String templateName = "test.vm";

	WebApplicationContext wac = mock(WebApplicationContext.class);
	given(wac.getServletContext()).willReturn(new MockServletContext());

	final Template expectedTemplate = new Template();
	VelocityConfig vc = new VelocityConfig() {
		@Override
		public VelocityEngine getVelocityEngine() {
			return new TestVelocityEngine(templateName, expectedTemplate);
		}
	};
	Map<String, VelocityConfig> configurers = new HashMap<String, VelocityConfig>();
	configurers.put("velocityConfigurer", vc);
	given(wac.getBeansOfType(VelocityConfig.class, true, false)).willReturn(configurers);


	// let it ask for locale
	HttpServletRequest req = mock(HttpServletRequest.class);
	given(req.getAttribute(View.PATH_VARIABLES)).willReturn(null);
	given(req.getAttribute(DispatcherServlet.LOCALE_RESOLVER_ATTRIBUTE)).willReturn(new AcceptHeaderLocaleResolver());
	given(req.getLocale()).willReturn(Locale.CANADA);

	final HttpServletResponse expectedResponse = new MockHttpServletResponse();

	VelocityView vv = new VelocityView() {
		@Override
		protected void mergeTemplate(Template template, Context context, HttpServletResponse response) throws Exception {
			assertTrue(template == expectedTemplate);
			assertTrue(response == expectedResponse);

			assertEquals("myValue", context.get("myHelper"));
			assertTrue(context.get("math") instanceof MathTool);

			assertTrue(context.get("dateTool") instanceof DateTool);
			DateTool dateTool = (DateTool) context.get("dateTool");
			assertTrue(dateTool.getLocale().equals(Locale.CANADA));

			assertTrue(context.get("numberTool") instanceof NumberTool);
			NumberTool numberTool = (NumberTool) context.get("numberTool");
			assertTrue(numberTool.getLocale().equals(Locale.CANADA));
		}

		@Override
		protected void exposeHelpers(Map<String, Object> model, HttpServletRequest request) throws Exception {
			model.put("myHelper", "myValue");
		}
	};

	vv.setUrl(templateName);
	vv.setApplicationContext(wac);
	Map<String, Class<?>> toolAttributes = new HashMap<String, Class<?>>();
	toolAttributes.put("math", MathTool.class);
	vv.setToolAttributes(toolAttributes);
	vv.setDateToolAttribute("dateTool");
	vv.setNumberToolAttribute("numberTool");
	vv.setExposeSpringMacroHelpers(false);

	vv.render(new HashMap<String, Object>(), req, expectedResponse);

	assertEquals(AbstractView.DEFAULT_CONTENT_TYPE, expectedResponse.getContentType());
}
 

private View applyLifecycleMethods(String viewName, AbstractView view) {
	return (View) getApplicationContext().getAutowireCapableBeanFactory().initializeBean(view, viewName);
}