junit2

package br.com.sed.seris.scenarios;

import static org.junit.Assert.assertEquals;

import org.junit.Before;
import org.junit.Test;

import br.com.sed.seris.domain.ContaminationScenario;
import br.com.sed.seris.domain.ContaminationSource;
import br.com.sed.seris.domain.ExpositionRoute;
import br.com.sed.seris.domain.Media;
import br.com.sed.seris.domain.simulation.Simulation;
import br.com.sed.seris.domain.simulation.SimulationExpositionRoutes;
import br.com.sed.seris.domain.simulation.SimulationMedias;

public class SimulationTabsTest {
	
	private Simulation simulation;

	@Before
	public void setUp(){
		simulation = new Simulation();
	}
	
	@Test
	public void testOverSourceSoilDegradationFalseAllRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL);
		simulation.getSource().setSourceDegradation(false);
		
		Media mediaSoil = new Media();
		mediaSoil.setId((long)1);
		mediaSoil.setDescription("Soil");

		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		mediaAir.setDescription("Air");
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);

		SimulationMedias simulationMediasSoil = new SimulationMedias();
		simulationMediasSoil.setMedia(mediaSoil);
		simulationMediasSoil.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		simulation.getSimulationMedias().add(simulationMediasSoil);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		ExpositionRoute expositionRouteSoil = new ExpositionRoute();
		expositionRouteSoil.setMedia(mediaSoil);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		SimulationExpositionRoutes simulationExpositionRoutesSoil = new SimulationExpositionRoutes();
		simulationExpositionRoutesSoil.setExpositionRoute(expositionRouteSoil);
		simulationExpositionRoutesSoil.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesSoil);

		assertEquals("TabSoil deve ser Verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser Verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser Falsa", false , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceSoilDegradationFalseRouteSoil() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");
		
		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL);
		simulation.getSource().setSourceDegradation(false);
		
		Media mediaSoil = new Media();
		mediaSoil.setId((long)1);
		mediaSoil.setDescription("Soil");
		
		SimulationMedias simulationMediasSoil = new SimulationMedias();
		simulationMediasSoil.setMedia(mediaSoil);
		simulationMediasSoil.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasSoil);
		
		ExpositionRoute expositionRouteSoil = new ExpositionRoute();
		expositionRouteSoil.setMedia(mediaSoil);
		
		SimulationExpositionRoutes simulationExpositionRoutesSoil = new SimulationExpositionRoutes();
		simulationExpositionRoutesSoil.setExpositionRoute(expositionRouteSoil);
		simulationExpositionRoutesSoil.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesSoil);
		
		assertEquals("TabSoil deve ser Verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser false", false, simulation.hasTabAir());
		assertEquals("TabWater deve ser Falsa", false , simulation.hasTabWater());
		
		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser fixed", false , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceSoilDegradationTrueAllRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL);
		simulation.getSource().setSourceDegradation(true);
		
		Media mediaSoil = new Media();
		mediaSoil.setId((long)1);
		mediaSoil.setDescription("Soil");
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);
		mediaWater.setDescription("Water");

		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		mediaAir.setDescription("Air");
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);

		SimulationMedias simulationMediasSoil = new SimulationMedias();
		simulationMediasSoil.setMedia(mediaSoil);
		simulationMediasSoil.setSimulation(simulation);
		
		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		simulation.getSimulationMedias().add(simulationMediasWater);
		simulation.getSimulationMedias().add(simulationMediasSoil);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		ExpositionRoute expositionRouteSoil = new ExpositionRoute();
		expositionRouteSoil.setMedia(mediaSoil);

		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		SimulationExpositionRoutes simulationExpositionRoutesSoil = new SimulationExpositionRoutes();
		simulationExpositionRoutesSoil.setExpositionRoute(expositionRouteSoil);
		simulationExpositionRoutesSoil.setSimulation(simulation);

		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesSoil);

		assertEquals("TabSoil deve ser Verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser Verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser Falsa", false , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceSoilDegradationTrueSoilRoute() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL);
		simulation.getSource().setSourceDegradation(true);
		
		Media mediaSoil = new Media();
		mediaSoil.setId((long)1);
		mediaSoil.setDescription("Soil");

		SimulationMedias simulationMediasSoil = new SimulationMedias();
		simulationMediasSoil.setMedia(mediaSoil);
		simulationMediasSoil.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasSoil);
		
		ExpositionRoute expositionRouteSoil = new ExpositionRoute();
		expositionRouteSoil.setMedia(mediaSoil);
		
		SimulationExpositionRoutes simulationExpositionRoutesSoil = new SimulationExpositionRoutes();
		simulationExpositionRoutesSoil.setExpositionRoute(expositionRouteSoil);
		simulationExpositionRoutesSoil.setSimulation(simulation);

		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesSoil);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser falsa", false, simulation.hasTabAir());
		assertEquals("TabWater deve ser falsa", false , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimadada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser fixed", false , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceSoilDegradationTrueWaterRoute() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL);
		simulation.getSource().setSourceDegradation(true);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);
		mediaWater.setDescription("Water");

		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);

		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser falsa", false, simulation.hasTabAir());
		assertEquals("TabWater deve ser falsa", false , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimadada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser fixed", false , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceSoilDegradationTrueAirRoute() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL);
		simulation.getSource().setSourceDegradation(true);
		
		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		mediaAir.setDescription("Air");

		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setDescription("Inhalation in bath");
		expositionRouteAir.setMedia(mediaAir);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);

		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser true", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser falsa", false , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimadada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceWaterDegradationFalseAllRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.WATER);
		simulation.getSource().setSourceDegradation(false);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);
		mediaWater.setDescription("Water");

		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		mediaAir.setDescription("Air");
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);

		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser falsa", false, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceWaterDegradationFalseWaterRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.WATER);
		simulation.getSource().setSourceDegradation(false);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);
		mediaWater.setDescription("Water");
		
		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser falsa", false, simulation.hasTabSoil());
		assertEquals("TabAir deve ser falsa", false, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser fixed", false , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceWaterDegradationFalseAirRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.WATER);
		simulation.getSource().setSourceDegradation(false);
		
		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);

		assertEquals("TabSoil deve ser falsa", false, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}

	@Test
	public void testOverSourceWaterDegradationTrueAllRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.WATER);
		simulation.getSource().setSourceDegradation(true);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);
		mediaWater.setDescription("Water");

		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		mediaAir.setDescription("Air");
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);

		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser falsa", false, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceWaterDegradationTrueWaterRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.WATER);
		simulation.getSource().setSourceDegradation(true);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);
		mediaWater.setDescription("Water");

		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser falsa", false, simulation.hasTabSoil());
		assertEquals("TabAir deve ser falsa", false, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser fixed", false , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceWaterDegradationTrueAirRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.WATER);
		simulation.getSource().setSourceDegradation(true);
		
		Media mediaAir = new Media();
		mediaAir.setId((long)3);

		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaAir);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaAir);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser falsa", false, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceSoilAndWaterDegradationFalseAllRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL_AND_WATER);
		simulation.getSource().setSourceDegradation(false);
		
		Media mediaSoil = new Media();
		mediaSoil.setId((long)1);

		Media mediaWater = new Media();
		mediaWater.setId((long)2);

		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);

		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		SimulationMedias simulationMediasSoil = new SimulationMedias();
		simulationMediasSoil.setMedia(mediaSoil);
		simulationMediasSoil.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		simulation.getSimulationMedias().add(simulationMediasWater);
		simulation.getSimulationMedias().add(simulationMediasSoil);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		ExpositionRoute expositionRouteSoil = new ExpositionRoute();
		expositionRouteSoil.setMedia(mediaSoil);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		SimulationExpositionRoutes simulationExpositionRoutesSoil = new SimulationExpositionRoutes();
		simulationExpositionRoutesSoil.setExpositionRoute(expositionRouteSoil);
		simulationExpositionRoutesSoil.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesSoil);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceSoilAndWaterDegradationFalseSoilRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL_AND_WATER);
		simulation.getSource().setSourceDegradation(false);
		
		Media mediaSoil = new Media();
		mediaSoil.setId((long)1);
		
		SimulationMedias simulationMediasSoil = new SimulationMedias();
		simulationMediasSoil.setMedia(mediaSoil);
		simulationMediasSoil.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasSoil);
		
		ExpositionRoute expositionRouteSoil = new ExpositionRoute();
		expositionRouteSoil.setMedia(mediaSoil);
		
		SimulationExpositionRoutes simulationExpositionRoutesSoil = new SimulationExpositionRoutes();
		simulationExpositionRoutesSoil.setExpositionRoute(expositionRouteSoil);
		simulationExpositionRoutesSoil.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesSoil);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser falsa", false, simulation.hasTabAir());
		assertEquals("TabWater deve ser falsa", false , simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser fixed", false , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceSoilAndWaterDegradationFalseWaterRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL_AND_WATER);
		simulation.getSource().setSourceDegradation(false);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);
		
		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser falsa", false, simulation.hasTabSoil());
		assertEquals("TabAir deve ser falsa", false, simulation.hasTabAir());
		assertEquals("TabWater deve ser falsa", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser fixed", false , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceSoilAndWaterDegradationFalseAirRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL_AND_WATER);
		simulation.getSource().setSourceDegradation(false);
		
		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	
	@Test
	public void testOverSourceSoilAndWaterDegradationTrueAllRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL_AND_WATER);
		simulation.getSource().setSourceDegradation(true);
		
		Media mediaSoil = new Media();
		mediaSoil.setId((long)1);

		Media mediaWater = new Media();
		mediaWater.setId((long)2);

		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);

		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		SimulationMedias simulationMediasSoil = new SimulationMedias();
		simulationMediasSoil.setMedia(mediaSoil);
		simulationMediasSoil.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		simulation.getSimulationMedias().add(simulationMediasWater);
		simulation.getSimulationMedias().add(simulationMediasSoil);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		ExpositionRoute expositionRouteSoil = new ExpositionRoute();
		expositionRouteSoil.setMedia(mediaSoil);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		SimulationExpositionRoutes simulationExpositionRoutesSoil = new SimulationExpositionRoutes();
		simulationExpositionRoutesSoil.setExpositionRoute(expositionRouteSoil);
		simulationExpositionRoutesSoil.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesSoil);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceSoilAndWaterDegradationTrueSoilRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL_AND_WATER);
		simulation.getSource().setSourceDegradation(true);
		
		Media mediaSoil = new Media();
		mediaSoil.setId((long)1);
		
		SimulationMedias simulationMediasSoil = new SimulationMedias();
		simulationMediasSoil.setMedia(mediaSoil);
		simulationMediasSoil.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasSoil);
		
		ExpositionRoute expositionRouteSoil = new ExpositionRoute();
		expositionRouteSoil.setMedia(mediaSoil);
		
		SimulationExpositionRoutes simulationExpositionRoutesSoil = new SimulationExpositionRoutes();
		simulationExpositionRoutesSoil.setExpositionRoute(expositionRouteSoil);
		simulationExpositionRoutesSoil.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesSoil);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser falsa", false, simulation.hasTabAir());
		assertEquals("TabWater deve ser falsa", false , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser fixed", false , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser fixed", false , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceSoilAndWaterDegradationTrueWaterRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL_AND_WATER);
		simulation.getSource().setSourceDegradation(true);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);
		
		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser falsa", false, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser fixed", false , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testOverSourceSoilAndWaterDegradationTrueAirRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("overSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL_AND_WATER);
		simulation.getSource().setSourceDegradation(true);
		
		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	
	@Test
	public void testFarSourceSoilAllRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("farSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);

		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);

		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testFarSourceSoilWaterRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("farSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);

		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser falsa", false, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser fixed", false , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testFarSourceSoilAirRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("farSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL);
		
		Media mediaAir = new Media();
		mediaAir.setId((long)3);

		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testFarSourceWaterAllRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("farSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.WATER);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);

		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);

		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser falsa", false, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testFarSourceWaterWaterRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("farSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.WATER);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);

		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser falsa", false, simulation.hasTabSoil());
		assertEquals("TabAir deve ser falsa", false, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true, simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser fixed", false , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testFarSourceWaterAirRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("farSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.WATER);
		
		Media mediaAir = new Media();
		mediaAir.setId((long)3);

		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);

		assertEquals("TabSoil deve ser falsa", false, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true, simulation.hasTabWater());

		assertEquals("TabSoil deve ser fixed", false , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testFarSourceSoilAndWaterAllRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("farSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL_AND_WATER);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);

		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);

		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true, simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testFarSourceSoilAndWaterWaterRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("farSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL_AND_WATER);
		
		Media mediaWater = new Media();
		mediaWater.setId((long)2);
		
		SimulationMedias simulationMediasWater = new SimulationMedias();
		simulationMediasWater.setMedia(mediaWater);
		simulationMediasWater.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasWater);
		
		ExpositionRoute expositionRouteWater = new ExpositionRoute();
		expositionRouteWater.setMedia(mediaWater);
		
		SimulationExpositionRoutes simulationExpositionRoutesWater = new SimulationExpositionRoutes();
		simulationExpositionRoutesWater.setExpositionRoute(expositionRouteWater);
		simulationExpositionRoutesWater.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesWater);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser falsa", false , simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser fixed", false , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
	@Test
	public void testFarSourceSoilAndWaterAirRoutes() {
		simulation.setTypeSimulation("transportModel");
		simulation.setReceptorSimulation("farSource");

		simulation.setSource(new ContaminationSource());
		simulation.getSource().setContamination(ContaminationScenario.SOIL_AND_WATER);
		
		Media mediaAir = new Media();
		mediaAir.setId((long)3);
		
		SimulationMedias simulationMediasAir = new SimulationMedias();
		simulationMediasAir.setMedia(mediaAir);
		simulationMediasAir.setSimulation(simulation);
		
		simulation.getSimulationMedias().add(simulationMediasAir);
		
		ExpositionRoute expositionRouteAir = new ExpositionRoute();
		expositionRouteAir.setMedia(mediaAir);
		
		SimulationExpositionRoutes simulationExpositionRoutesAir = new SimulationExpositionRoutes();
		simulationExpositionRoutesAir.setExpositionRoute(expositionRouteAir);
		simulationExpositionRoutesAir.setSimulation(simulation);
		
		simulation.getSimulationExpositionRoutes().add(simulationExpositionRoutesAir);

		assertEquals("TabSoil deve ser verdadeira", true, simulation.hasTabSoil());
		assertEquals("TabAir deve ser verdadeira", true , simulation.hasTabAir());
		assertEquals("TabWater deve ser verdadeira", true , simulation.hasTabWater());

		assertEquals("TabSoil deve ser estimada", true , simulation.hasEstimatedSoil());
		assertEquals("TabAir deve ser estimada", true , simulation.hasEstimatedAir());
		assertEquals("TabWater deve ser estimada", true , simulation.hasEstimatedWater());
	}
	
}