private void startBeans(boolean autoStartupOnly) {
	Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
	Map<Integer, LifecycleGroup> phases = new HashMap<>();
	lifecycleBeans.forEach((beanName, bean) -> {
		if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
			int phase = getPhase(bean);
			LifecycleGroup group = phases.get(phase);
			if (group == null) {
				group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
				phases.put(phase, group);
			}
			group.add(beanName, bean);
		}
	});
	if (!phases.isEmpty()) {
		List<Integer> keys = new ArrayList<>(phases.keySet());
		Collections.sort(keys);
		for (Integer key : keys) {
			phases.get(key).start();
		}
	}
}
 

private void stopBeans() {
	Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
	Map<Integer, LifecycleGroup> phases = new HashMap<>();
	lifecycleBeans.forEach((beanName, bean) -> {
		int shutdownPhase = getPhase(bean);
		LifecycleGroup group = phases.get(shutdownPhase);
		if (group == null) {
			group = new LifecycleGroup(shutdownPhase, this.timeoutPerShutdownPhase, lifecycleBeans, false);
			phases.put(shutdownPhase, group);
		}
		group.add(beanName, bean);
	});
	if (!phases.isEmpty()) {
		List<Integer> keys = new ArrayList<>(phases.keySet());
		keys.sort(Collections.reverseOrder());
		for (Integer key : keys) {
			phases.get(key).stop();
		}
	}
}
 

/**
 * Retrieve all applicable Lifecycle beans: all singletons that have already been created,
 * as well as all SmartLifecycle beans (even if they are marked as lazy-init).
 * @return the Map of applicable beans, with bean names as keys and bean instances as values
 */
protected Map<String, Lifecycle> getLifecycleBeans() {
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	Map<String, Lifecycle> beans = new LinkedHashMap<>();
	String[] beanNames = beanFactory.getBeanNamesForType(Lifecycle.class, false, false);
	for (String beanName : beanNames) {
		String beanNameToRegister = BeanFactoryUtils.transformedBeanName(beanName);
		boolean isFactoryBean = beanFactory.isFactoryBean(beanNameToRegister);
		String beanNameToCheck = (isFactoryBean ? BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName);
		if ((beanFactory.containsSingleton(beanNameToRegister) &&
				(!isFactoryBean || matchesBeanType(Lifecycle.class, beanNameToCheck, beanFactory))) ||
				matchesBeanType(SmartLifecycle.class, beanNameToCheck, beanFactory)) {
			Object bean = beanFactory.getBean(beanNameToCheck);
			if (bean != this && bean instanceof Lifecycle) {
				beans.put(beanNameToRegister, (Lifecycle) bean);
			}
		}
	}
	return beans;
}
 

@Test
public void singleSmartLifecycleWithoutAutoStartup() throws Exception {
	CopyOnWriteArrayList<Lifecycle> startedBeans = new CopyOnWriteArrayList<Lifecycle>();
	TestSmartLifecycleBean bean = TestSmartLifecycleBean.forStartupTests(1, startedBeans);
	bean.setAutoStartup(false);
	StaticApplicationContext context = new StaticApplicationContext();
	context.getBeanFactory().registerSingleton("bean", bean);
	assertFalse(bean.isRunning());
	context.refresh();
	assertFalse(bean.isRunning());
	assertEquals(0, startedBeans.size());
	context.start();
	assertTrue(bean.isRunning());
	assertEquals(1, startedBeans.size());
	context.stop();
}
 

@Before
public void setup() throws Exception {
	this.client = new ReactorNettyWebSocketClient();

	this.server = new ReactorHttpServer();
	this.server.setHandler(createHttpHandler());
	this.server.afterPropertiesSet();
	this.server.start();

	// Set dynamically chosen port
	this.serverPort = this.server.getPort();

	if (this.client instanceof Lifecycle) {
		((Lifecycle) this.client).start();
	}

	this.gatewayContext = new SpringApplicationBuilder(GatewayConfig.class)
			.properties("ws.server.port:" + this.serverPort, "server.port=0",
					"spring.jmx.enabled=false")
			.run();

	ConfigurableEnvironment env = this.gatewayContext
			.getBean(ConfigurableEnvironment.class);
	this.gatewayPort = Integer.valueOf(env.getProperty("local.server.port"));
}
 

/**
 * Retrieve all applicable Lifecycle beans: all singletons that have already been created,
 * as well as all SmartLifecycle beans (even if they are marked as lazy-init).
 * @return the Map of applicable beans, with bean names as keys and bean instances as values
 */
protected Map<String, Lifecycle> getLifecycleBeans() {
	Map<String, Lifecycle> beans = new LinkedHashMap<String, Lifecycle>();
	String[] beanNames = this.beanFactory.getBeanNamesForType(Lifecycle.class, false, false);
	for (String beanName : beanNames) {
		String beanNameToRegister = BeanFactoryUtils.transformedBeanName(beanName);
		boolean isFactoryBean = this.beanFactory.isFactoryBean(beanNameToRegister);
		String beanNameToCheck = (isFactoryBean ? BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName);
		if ((this.beanFactory.containsSingleton(beanNameToRegister) &&
				(!isFactoryBean || Lifecycle.class.isAssignableFrom(this.beanFactory.getType(beanNameToCheck)))) ||
				SmartLifecycle.class.isAssignableFrom(this.beanFactory.getType(beanNameToCheck))) {
			Lifecycle bean = this.beanFactory.getBean(beanNameToCheck, Lifecycle.class);
			if (bean != this) {
				beans.put(beanNameToRegister, bean);
			}
		}
	}
	return beans;
}
 

@Before
public void setup() throws Exception {
	logger.debug("Setting up '" + this.testName.getMethodName() + "', client=" +
			this.webSocketClient.getClass().getSimpleName() + ", server=" +
			this.server.getClass().getSimpleName());

	this.wac = new AnnotationConfigWebApplicationContext();
	this.wac.register(getAnnotatedConfigClasses());
	this.wac.register(upgradeStrategyConfigTypes.get(this.server.getClass()));

	if (this.webSocketClient instanceof Lifecycle) {
		((Lifecycle) this.webSocketClient).start();
	}

	this.server.setup();
	this.server.deployConfig(this.wac);
	this.server.start();

	this.wac.setServletContext(this.server.getServletContext());
	this.wac.refresh();
}
 

private void startBeans(boolean autoStartupOnly) {
	Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
	Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();
	for (Map.Entry<String, ? extends Lifecycle> entry : lifecycleBeans.entrySet()) {
		Lifecycle bean = entry.getValue();
		if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
			int phase = getPhase(bean);
			LifecycleGroup group = phases.get(phase);
			if (group == null) {
				group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
				phases.put(phase, group);
			}
			group.add(entry.getKey(), bean);
		}
	}
	if (phases.size() > 0) {
		List<Integer> keys = new ArrayList<Integer>(phases.keySet());
		Collections.sort(keys);
		for (Integer key : keys) {
			phases.get(key).start();
		}
	}
}
 

@Test
public void singleSmartLifecycleAutoStartupWithNonAutoStartupDependency() throws Exception {
	CopyOnWriteArrayList<Lifecycle> startedBeans = new CopyOnWriteArrayList<Lifecycle>();
	TestSmartLifecycleBean bean = TestSmartLifecycleBean.forStartupTests(1, startedBeans);
	bean.setAutoStartup(true);
	TestSmartLifecycleBean dependency = TestSmartLifecycleBean.forStartupTests(1, startedBeans);
	dependency.setAutoStartup(false);
	StaticApplicationContext context = new StaticApplicationContext();
	context.getBeanFactory().registerSingleton("bean", bean);
	context.getBeanFactory().registerSingleton("dependency", dependency);
	context.getBeanFactory().registerDependentBean("dependency", "bean");
	assertFalse(bean.isRunning());
	assertFalse(dependency.isRunning());
	context.refresh();
	assertTrue(bean.isRunning());
	assertFalse(dependency.isRunning());
	context.stop();
	assertFalse(bean.isRunning());
	assertFalse(dependency.isRunning());
	assertEquals(1, startedBeans.size());
}
 

private void stopBeans() {
	Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
	Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();
	for (Map.Entry<String, Lifecycle> entry : lifecycleBeans.entrySet()) {
		Lifecycle bean = entry.getValue();
		int shutdownOrder = getPhase(bean);
		LifecycleGroup group = phases.get(shutdownOrder);
		if (group == null) {
			group = new LifecycleGroup(shutdownOrder, this.timeoutPerShutdownPhase, lifecycleBeans, false);
			phases.put(shutdownOrder, group);
		}
		group.add(entry.getKey(), bean);
	}
	if (!phases.isEmpty()) {
		List<Integer> keys = new ArrayList<Integer>(phases.keySet());
		Collections.sort(keys, Collections.reverseOrder());
		for (Integer key : keys) {
			phases.get(key).stop();
		}
	}
}
 

private void stopBeans() {
	Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
	Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();
	for (Map.Entry<String, Lifecycle> entry : lifecycleBeans.entrySet()) {
		Lifecycle bean = entry.getValue();
		int shutdownOrder = getPhase(bean);
		LifecycleGroup group = phases.get(shutdownOrder);
		if (group == null) {
			group = new LifecycleGroup(shutdownOrder, this.timeoutPerShutdownPhase, lifecycleBeans, false);
			phases.put(shutdownOrder, group);
		}
		group.add(entry.getKey(), bean);
	}
	if (phases.size() > 0) {
		List<Integer> keys = new ArrayList<Integer>(phases.keySet());
		Collections.sort(keys, Collections.reverseOrder());
		for (Integer key : keys) {
			phases.get(key).stop();
		}
	}
}
 

private void startBeans(boolean autoStartupOnly) {
	Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
	Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();
	for (Map.Entry<String, ? extends Lifecycle> entry : lifecycleBeans.entrySet()) {
		Lifecycle bean = entry.getValue();
		if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
			int phase = getPhase(bean);
			LifecycleGroup group = phases.get(phase);
			if (group == null) {
				group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
				phases.put(phase, group);
			}
			group.add(entry.getKey(), bean);
		}
	}
	if (!phases.isEmpty()) {
		List<Integer> keys = new ArrayList<Integer>(phases.keySet());
		Collections.sort(keys);
		for (Integer key : keys) {
			phases.get(key).start();
		}
	}
}
 

private void startBeans(boolean autoStartupOnly) {
	Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
	Map<Integer, LifecycleGroup> phases = new HashMap<>();
	lifecycleBeans.forEach((beanName, bean) -> {
		if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
			int phase = getPhase(bean);
			LifecycleGroup group = phases.get(phase);
			if (group == null) {
				group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
				phases.put(phase, group);
			}
			group.add(beanName, bean);
		}
	});
	if (!phases.isEmpty()) {
		List<Integer> keys = new ArrayList<>(phases.keySet());
		Collections.sort(keys);
		for (Integer key : keys) {
			phases.get(key).start();
		}
	}
}
 

/**
 * Start the specified bean as part of the given set of Lifecycle beans,
 * making sure that any beans that it depends on are started first.
 * @param lifecycleBeans a Map with bean name as key and Lifecycle instance as value
 * @param beanName the name of the bean to start
 */
private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName, boolean autoStartupOnly) {
	Lifecycle bean = lifecycleBeans.remove(beanName);
	if (bean != null && bean != this) {
		String[] dependenciesForBean = getBeanFactory().getDependenciesForBean(beanName);
		for (String dependency : dependenciesForBean) {
			doStart(lifecycleBeans, dependency, autoStartupOnly);
		}
		if (!bean.isRunning() &&
				(!autoStartupOnly || !(bean instanceof SmartLifecycle) || ((SmartLifecycle) bean).isAutoStartup())) {
			if (logger.isTraceEnabled()) {
				logger.trace("Starting bean '" + beanName + "' of type [" + bean.getClass().getName() + "]");
			}
			try {
				bean.start();
			}
			catch (Throwable ex) {
				throw new ApplicationContextException("Failed to start bean '" + beanName + "'", ex);
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Successfully started bean '" + beanName + "'");
			}
		}
	}
}
 

private void stopBeans() {
	Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
	Map<Integer, LifecycleGroup> phases = new HashMap<>();
	lifecycleBeans.forEach((beanName, bean) -> {
		int shutdownPhase = getPhase(bean);
		LifecycleGroup group = phases.get(shutdownPhase);
		if (group == null) {
			group = new LifecycleGroup(shutdownPhase, this.timeoutPerShutdownPhase, lifecycleBeans, false);
			phases.put(shutdownPhase, group);
		}
		group.add(beanName, bean);
	});
	if (!phases.isEmpty()) {
		List<Integer> keys = new ArrayList<>(phases.keySet());
		keys.sort(Collections.reverseOrder());
		for (Integer key : keys) {
			phases.get(key).stop();
		}
	}
}
 

/**
 * Retrieve all applicable Lifecycle beans: all singletons that have already been created,
 * as well as all SmartLifecycle beans (even if they are marked as lazy-init).
 * @return the Map of applicable beans, with bean names as keys and bean instances as values
 */
protected Map<String, Lifecycle> getLifecycleBeans() {
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	Map<String, Lifecycle> beans = new LinkedHashMap<>();
	String[] beanNames = beanFactory.getBeanNamesForType(Lifecycle.class, false, false);
	for (String beanName : beanNames) {
		String beanNameToRegister = BeanFactoryUtils.transformedBeanName(beanName);
		boolean isFactoryBean = beanFactory.isFactoryBean(beanNameToRegister);
		String beanNameToCheck = (isFactoryBean ? BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName);
		if ((beanFactory.containsSingleton(beanNameToRegister) &&
				(!isFactoryBean || matchesBeanType(Lifecycle.class, beanNameToCheck, beanFactory))) ||
				matchesBeanType(SmartLifecycle.class, beanNameToCheck, beanFactory)) {
			Object bean = beanFactory.getBean(beanNameToCheck);
			if (bean != this && bean instanceof Lifecycle) {
				beans.put(beanNameToRegister, (Lifecycle) bean);
			}
		}
	}
	return beans;
}
 

/**
 * Start the specified bean as part of the given set of Lifecycle beans,
 * making sure that any beans that it depends on are started first.
 * @param lifecycleBeans Map with bean name as key and Lifecycle instance as value
 * @param beanName the name of the bean to start
 */
private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName, boolean autoStartupOnly) {
	Lifecycle bean = lifecycleBeans.remove(beanName);
	if (bean != null && !this.equals(bean)) {
		String[] dependenciesForBean = this.beanFactory.getDependenciesForBean(beanName);
		for (String dependency : dependenciesForBean) {
			doStart(lifecycleBeans, dependency, autoStartupOnly);
		}
		if (!bean.isRunning() &&
				(!autoStartupOnly || !(bean instanceof SmartLifecycle) || ((SmartLifecycle) bean).isAutoStartup())) {
			if (logger.isDebugEnabled()) {
				logger.debug("Starting bean '" + beanName + "' of type [" + bean.getClass() + "]");
			}
			try {
				bean.start();
			}
			catch (Throwable ex) {
				throw new ApplicationContextException("Failed to start bean '" + beanName + "'", ex);
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Successfully started bean '" + beanName + "'");
			}
		}
	}
}
 

@After
public void stop() throws Exception {
	if (this.client instanceof Lifecycle) {
		((Lifecycle) this.client).stop();
	}
	this.server.stop();
	if (this.gatewayContext != null) {
		this.gatewayContext.stop();
	}
}
 

public LifecycleGroup(
		int phase, long timeout, Map<String, ? extends Lifecycle> lifecycleBeans, boolean autoStartupOnly) {

	this.phase = phase;
	this.timeout = timeout;
	this.lifecycleBeans = lifecycleBeans;
	this.autoStartupOnly = autoStartupOnly;
}
 

@Override
public void start() {
	if (!isRunning()) {
		if (this.webSocketClient instanceof Lifecycle) {
			((Lifecycle) this.webSocketClient).start();
		}
		else {
			this.running = true;
		}
	}
}
 

@Test
public void dependencyStartedFirstAndIsSmartLifecycle() throws Exception {
	CopyOnWriteArrayList<Lifecycle> startedBeans = new CopyOnWriteArrayList<Lifecycle>();
	TestSmartLifecycleBean beanNegative = TestSmartLifecycleBean.forStartupTests(-99, startedBeans);
	TestSmartLifecycleBean bean99 = TestSmartLifecycleBean.forStartupTests(99, startedBeans);
	TestSmartLifecycleBean bean7 = TestSmartLifecycleBean.forStartupTests(7, startedBeans);
	TestLifecycleBean simpleBean = TestLifecycleBean.forStartupTests(startedBeans);
	StaticApplicationContext context = new StaticApplicationContext();
	context.getBeanFactory().registerSingleton("beanNegative", beanNegative);
	context.getBeanFactory().registerSingleton("bean7", bean7);
	context.getBeanFactory().registerSingleton("bean99", bean99);
	context.getBeanFactory().registerSingleton("simpleBean", simpleBean);
	context.getBeanFactory().registerDependentBean("bean7", "simpleBean");
	context.refresh();
	context.stop();
	startedBeans.clear();
	// clean start so that simpleBean is included
	context.start();
	assertTrue(beanNegative.isRunning());
	assertTrue(bean99.isRunning());
	assertTrue(bean7.isRunning());
	assertTrue(simpleBean.isRunning());
	assertEquals(4, startedBeans.size());
	assertEquals(-99, getPhase(startedBeans.get(0)));
	assertEquals(7, getPhase(startedBeans.get(1)));
	assertEquals(0, getPhase(startedBeans.get(2)));
	assertEquals(99, getPhase(startedBeans.get(3)));
	context.stop();
}
 

@Override
public boolean isRunning() {
	if (this.webSocketClient instanceof Lifecycle) {
		return ((Lifecycle) this.webSocketClient).isRunning();
	}
	else {
		return this.running;
	}
}
 

@Test
public void smartLifecycleGroupStartup() throws Exception {
	CopyOnWriteArrayList<Lifecycle> startedBeans = new CopyOnWriteArrayList<>();
	TestSmartLifecycleBean beanMin = TestSmartLifecycleBean.forStartupTests(Integer.MIN_VALUE, startedBeans);
	TestSmartLifecycleBean bean1 = TestSmartLifecycleBean.forStartupTests(1, startedBeans);
	TestSmartLifecycleBean bean2 = TestSmartLifecycleBean.forStartupTests(2, startedBeans);
	TestSmartLifecycleBean bean3 = TestSmartLifecycleBean.forStartupTests(3, startedBeans);
	TestSmartLifecycleBean beanMax = TestSmartLifecycleBean.forStartupTests(Integer.MAX_VALUE, startedBeans);
	StaticApplicationContext context = new StaticApplicationContext();
	context.getBeanFactory().registerSingleton("bean3", bean3);
	context.getBeanFactory().registerSingleton("beanMin", beanMin);
	context.getBeanFactory().registerSingleton("bean2", bean2);
	context.getBeanFactory().registerSingleton("beanMax", beanMax);
	context.getBeanFactory().registerSingleton("bean1", bean1);
	assertFalse(beanMin.isRunning());
	assertFalse(bean1.isRunning());
	assertFalse(bean2.isRunning());
	assertFalse(bean3.isRunning());
	assertFalse(beanMax.isRunning());
	context.refresh();
	assertTrue(beanMin.isRunning());
	assertTrue(bean1.isRunning());
	assertTrue(bean2.isRunning());
	assertTrue(bean3.isRunning());
	assertTrue(beanMax.isRunning());
	context.stop();
	assertEquals(5, startedBeans.size());
	assertEquals(Integer.MIN_VALUE, getPhase(startedBeans.get(0)));
	assertEquals(1, getPhase(startedBeans.get(1)));
	assertEquals(2, getPhase(startedBeans.get(2)));
	assertEquals(3, getPhase(startedBeans.get(3)));
	assertEquals(Integer.MAX_VALUE, getPhase(startedBeans.get(4)));
}
 

@Test
public void contextRefreshThenStartWithMixedBeans() throws Exception {
	CopyOnWriteArrayList<Lifecycle> startedBeans = new CopyOnWriteArrayList<>();
	TestLifecycleBean simpleBean1 = TestLifecycleBean.forStartupTests(startedBeans);
	TestLifecycleBean simpleBean2 = TestLifecycleBean.forStartupTests(startedBeans);
	TestSmartLifecycleBean smartBean1 = TestSmartLifecycleBean.forStartupTests(5, startedBeans);
	TestSmartLifecycleBean smartBean2 = TestSmartLifecycleBean.forStartupTests(-3, startedBeans);
	StaticApplicationContext context = new StaticApplicationContext();
	context.getBeanFactory().registerSingleton("simpleBean1", simpleBean1);
	context.getBeanFactory().registerSingleton("smartBean1", smartBean1);
	context.getBeanFactory().registerSingleton("simpleBean2", simpleBean2);
	context.getBeanFactory().registerSingleton("smartBean2", smartBean2);
	assertFalse(simpleBean1.isRunning());
	assertFalse(simpleBean2.isRunning());
	assertFalse(smartBean1.isRunning());
	assertFalse(smartBean2.isRunning());
	context.refresh();
	assertTrue(smartBean1.isRunning());
	assertTrue(smartBean2.isRunning());
	assertFalse(simpleBean1.isRunning());
	assertFalse(simpleBean2.isRunning());
	assertEquals(2, startedBeans.size());
	assertEquals(-3, getPhase(startedBeans.get(0)));
	assertEquals(5, getPhase(startedBeans.get(1)));
	context.start();
	assertTrue(smartBean1.isRunning());
	assertTrue(smartBean2.isRunning());
	assertTrue(simpleBean1.isRunning());
	assertTrue(simpleBean2.isRunning());
	assertEquals(4, startedBeans.size());
	assertEquals(0, getPhase(startedBeans.get(2)));
	assertEquals(0, getPhase(startedBeans.get(3)));
}
 

@Override
public boolean isRunning() {
	if (storeWriter instanceof Lifecycle) {
		return ((Lifecycle) storeWriter).isRunning();
	}
	else {
		return false;
	}
}
 

@Override
public void start() {
	if (!isRunning()) {
		this.running = true;
		for (TransportHandler handler : this.handlers.values()) {
			if (handler instanceof Lifecycle) {
				((Lifecycle) handler).start();
			}
		}
	}
}
 

@Override
public void start() {
	if (!isRunning()) {
		this.running = true;
		if (this.handshakeHandler instanceof Lifecycle) {
			((Lifecycle) this.handshakeHandler).start();
		}
	}
}
 

@Test
void clientIdWithoutSecretNotAllowed() {
	assertThatThrownBy(() -> this.contextRunner
		.withPropertyValues("spring.cloud.appbroker.deployer.cloudfoundry.api-host=https://api.example.local",
			"spring.cloud.appbroker.deployer.cloudfoundry.client_id=user")
		.run(Lifecycle::start));
}
 

@Override
public void stop() {
	if (isRunning()) {
		if (this.webSocketClient instanceof Lifecycle) {
			((Lifecycle) this.webSocketClient).stop();
		}
		else {
			this.running = false;
		}
	}
}
 

@Test
public void singleLifecycleShutdown() throws Exception {
	CopyOnWriteArrayList<Lifecycle> stoppedBeans = new CopyOnWriteArrayList<Lifecycle>();
	Lifecycle bean = new TestLifecycleBean(null, stoppedBeans);
	StaticApplicationContext context = new StaticApplicationContext();
	context.getBeanFactory().registerSingleton("bean", bean);
	context.refresh();
	assertFalse(bean.isRunning());
	bean.start();
	assertTrue(bean.isRunning());
	context.stop();
	assertEquals(1, stoppedBeans.size());
	assertFalse(bean.isRunning());
	assertEquals(bean, stoppedBeans.get(0));
}