Error running tests with Gradle


(José Luiz Abreu Cardoso Junior) #1

Hello, I have a problem with a project in my work, we decide to migrate a java project to gradle project and start to create tests using JUnit 5, the project is a sockect used to comunicate with a vehicles’ tracker.
the tests runnig without problems when running using Eclipse’s Junit runnig, all tests pass, but when I use a test’s gradle task I get a problem with a test who using Socket to communicate with a thread with a serverSocket.
This test is a parameterized test and have a 120 parameters, after each test I stop a thread and kill serverSocket connection and before each test restart it.
In a gradle a parameterized test “fail” in 57º test and it don’t stop, like a connection is locked and JUnit don’t get close it. If I remove some tests the same “error” appear in other random test.
But using Eclipse’s Junit runnig the test runnig without problem and the process don’t lock in a port connected.
Follow the test class:

public class ComunicacaoSocketTest {

	private static ComunicacaoSocket cs;
	
	private static Parametros parametros;
	
	private static ComandoPool comandoPool = null;
	
	private static Thread threadComunicacaoSocket = null;

	private final List<String> identificacoes = new ArrayList<String>() 
	{
		private static final long serialVersionUID = 1L;
		{
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
			add("000000");
		}
	};
	
	@BeforeAll
	public static void setUp() throws Exception {
		DBUtils.limparTabela("RespostaComando");
		ParametrosDAO parametrosDAO = new ParametrosDAO(PersistenceUtil.openSession(), Parametros.class);
		parametros = parametrosDAO.findById(1l);
		PersistenceUtil.closeCurrentSession();
		comandoPool = ComandoPool.getInstance();
		cs = new ComunicacaoSocket(Main.portComunicacaoTCP, Main.versao);
		Runnable task = () -> cs.executa();
		threadComunicacaoSocket = new Thread(task);
		threadComunicacaoSocket.start();
	}
	
	@AfterAll
	public static void tearDown() {
		comunicarThreadComandos(ComunicacaoSocket.PARAR_COMUNICACAO, "-|-");// this String is spected by serverSocket to stop the connection
		threadComunicacaoSocket.interrupt();
		threadComunicacaoSocket = null;
		DBUtils.limparTabela("RespostaComando");
	}
	
	@DisplayName("simulando envio de comandos da plataforma web para o socket")
	@ParameterizedTest(name = "recebendo comandos")
	@CsvFileSource(numLinesToSkip = 1, delimiter = '_', resources = "/csv/thread/comandosPlataformaWeb.csv")
	public void testeRecebimentoComandoPlatafoma(String comandoEnviado, String retornoEsperado, String idVeiculo, String comandoEsperado) {
		comandoEnviado = comandoEnviado.replace("#*#UUID#*#", UUID.randomUUID().toString());
		comandoEnviado = comandoEnviado.replace("#*#IDSCOMPONENTES#*#", formatarIdentificacoesMotorista(identificacoes));
		comandoEsperado = comandoEsperado.replace("#*#IDSCOMPONENTES#*#", formatarIdentificacoesMotorista(identificacoes));
		String mensagemRetorno = "-|-";
		mensagemRetorno = comunicarThreadComandos(comandoEnviado, mensagemRetorno);
		assertEquals(retornoEsperado, mensagemRetorno, "erro na definição do retorno para plataforma web");
		String[] comandos = comandoPool.getComando(idVeiculo);
		assertEquals(true, Arrays.asList(comandos).contains(comandoEsperado), "não foi encontrado o comando inserido no pool");
		assertEquals(1, comandos.length, "erro na quantidade de comandos retornados");
	}
	
	private String formatarIdentificacoesMotorista(List<String> identificacoesMotorista) {
		StringBuilder concatenador = new StringBuilder();
		for(int i = 0; identificacoesMotorista.size() > i; i ++) {
			String numero = ((String.valueOf(i + 1).length() > 1) ? String.valueOf(i + 1) : "0" + String.valueOf(i + 1));
			concatenador.append(numero + identificacoesMotorista.get(i));
		}
		return getHexByString(concatenador.toString());
	}
	
	private static String getHexByString(String dado) {
		char[] charDados = dado.toCharArray();
		String dadoConverter = "";
		StringBuilder dadoHex = new StringBuilder();
		for (char c : charDados) {
			dadoConverter = String.format("%02X", (int) c);
			dadoHex.append(dadoConverter);
		}
		return dadoHex.toString();
	}
	
	private static String comunicarThreadComandos(String comandoEnviado, String mensagemRetorno) {
		Socket socketCliente = null;
		ObjectOutputStream paraServidor = null;
		ObjectInputStream doServidor = null;
		try {
			socketCliente = new Socket(parametros.getIpServerSocket(), 7778);
		   
			paraServidor = new ObjectOutputStream(socketCliente.getOutputStream());
			doServidor = new ObjectInputStream(socketCliente.getInputStream());
						 
			paraServidor.writeObject(comandoEnviado);
		   
			mensagemRetorno = (String) doServidor.readObject();
		} catch(ClassNotFoundException | IOException e) {
			e.printStackTrace();
		} finally {
			if(paraServidor != null){
				try {
					paraServidor.close();
				}
				catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			if(doServidor != null) {
				try {
					doServidor.close();
				}
				catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			if((socketCliente != null) && (!socketCliente.isClosed())) {
				try {
					socketCliente.close();
				}
				catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return mensagemRetorno;
	}
	
}

The project use gradle 4.8.1


(José Luiz Abreu Cardoso Junior) #2

I found my problem, I have one test who use singleton class and after test I did not clear instance and this altered my tests results.
Thank you.