Exemple #1
0
        public void ConsultarSemaforosImpactadosPorCronogramaQuandoExistiremVariosConflitantesTest()
        {
            #region contexto

            //semáforo já existente
            SemaforoPorIntervalo semaforoIntervalo1 = new SemaforoPorIntervalo(10, 20);

            //semáforo já existente no cronograma
            SemaforoSingleton.SemaforosControle semaforoPorCronogramaC1 = new SemaforoSingleton.SemaforosControle()
            {
                lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>()
            };

            semaforoPorCronogramaC1.semaforos.Add(semaforoIntervalo1);

            //mockando o método que realiza a liberação de um semáforo.
            Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>()
            {
                CallBase = true
            };

            SemaforoSingletonMock.SetInstancia(mockSemaforo.Object);

            SemaforoSingletonMock.cronogramaSemaforosMock.Clear();
            SemaforoSingleton.semaforosPorCronograma.Add(cronogramas[0].Oid, semaforoPorCronogramaC1);

            cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[0].Oid,
                inicio        = 5,
                final         = 8,
                tempoDeEspera = 0
            };

            cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[0].Oid,
                inicio        = 1,
                final         = 5,
                tempoDeEspera = 6000
            };

            cronogramaIntervalo cronoIntervalo3 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[0].Oid,
                inicio        = 6,
                final         = 10,
                tempoDeEspera = 8000
            };

            cronogramaIntervalo cronoIntervalo4 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[0].Oid,
                inicio        = 2,
                final         = 5,
                tempoDeEspera = 1000
            };

            cronogramaIntervalo cronoIntervalo5 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[0].Oid,
                inicio        = 2,
                final         = 4,
                tempoDeEspera = 2000
            };

            cronogramaIntervalo cronoIntervalo6 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[0].Oid,
                inicio        = 1,
                final         = 6,
                tempoDeEspera = 3000
            };

            Thread thread1 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
            {
                Priority = ThreadPriority.Highest,
                Name     = "Thread 1",
            };

            Thread thread2 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
            {
                Priority = ThreadPriority.Normal,
                Name     = "Thread 2"
            };

            Thread thread3 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
            {
                Priority = ThreadPriority.Normal,
                Name     = "Thread 3"
            };

            Thread thread4 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
            {
                Priority = ThreadPriority.Normal,
                Name     = "Thread 4"
            };

            Thread thread5 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
            {
                Priority = ThreadPriority.Normal,
                Name     = "Thread 5"
            };

            Thread thread6 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
            {
                Priority = ThreadPriority.Normal,
                Name     = "Thread 6"
            };

            #endregion

            thread1.Start(cronoIntervalo1);
            thread2.Start(cronoIntervalo2);
            thread3.Start(cronoIntervalo3);
            thread4.Start(cronoIntervalo4);
            thread5.Start(cronoIntervalo5);
            thread6.Start(cronoIntervalo6);

            ControleDeEsperaUtil.AguardarAte(() =>
            {
                return(thread1.ThreadState == System.Threading.ThreadState.Stopped &&
                       thread2.ThreadState == System.Threading.ThreadState.Stopped &&
                       thread3.ThreadState == System.Threading.ThreadState.Stopped &&
                       thread4.ThreadState == System.Threading.ThreadState.Stopped &&
                       thread5.ThreadState == System.Threading.ThreadState.Stopped &&
                       thread6.ThreadState == System.Threading.ThreadState.Stopped);
            }, 180);

            Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra.");
            Assert.AreEqual(System.Threading.ThreadState.Stopped, thread2.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra.");
            Assert.AreEqual(1, SemaforoSingleton.semaforosPorCronograma.Count, "Deveria existir um índice no dicionário de cronograma, pois 2 threads de cronogramas iguais efetuaram o processo.");
            Assert.AreEqual(5, SemaforoSingleton.semaforosPorCronograma[cronogramas[0].Oid].semaforos.Count, "Deveria existir uma lista contendo 3 semáforos criados.");
        }
Exemple #2
0
        public void ConsultarSemaforosImpactadosPorCronogramaQuandoIntervaloAbrangerOutrosIntervalosTest()
        {
            //semáforo já existente
            SemaforoPorIntervalo semaforoIntervalo1 = new SemaforoPorIntervalo(10, 20);

            //semáforo já existente no cronograma
            SemaforoSingleton.SemaforosControle semaforoPorCronogramaC1 = new SemaforoSingleton.SemaforosControle()
            {
                lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>()
            };

            semaforoPorCronogramaC1.semaforos.Add(semaforoIntervalo1);

            //mockando o método que realiza a liberação de um semáforo.
            Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>()
            {
                CallBase = true
            };

            SemaforoSingletonMock.SetInstancia(mockSemaforo.Object);

            SemaforoSingletonMock.cronogramaSemaforosMock.Clear();
            SemaforoSingleton.semaforosPorCronograma.Add(cronogramas[0].Oid, semaforoPorCronogramaC1);

            cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[0].Oid,
                inicio        = 5,
                final         = 15,
                tempoDeEspera = 0
            };

            cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[0].Oid,
                inicio        = 8,
                final         = 22,
                tempoDeEspera = 5000
            };

            Thread thread1 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
            {
                Priority = ThreadPriority.Highest,
                Name     = "Thread 1",
            };

            Thread thread2 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
            {
                Priority = ThreadPriority.Normal,
                Name     = "Thread 2"
            };

            thread1.Start(cronoIntervalo1);
            thread2.Start(cronoIntervalo2);

            ControleDeEsperaUtil.AguardarAte(() =>
            {
                return(thread1.ThreadState == System.Threading.ThreadState.Stopped &&
                       thread2.ThreadState == System.Threading.ThreadState.Stopped);
            }, 60);

            Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra.");
            Assert.AreEqual(System.Threading.ThreadState.Stopped, thread2.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra.");
            Assert.AreEqual(1, SemaforoSingleton.semaforosPorCronograma.Count, "Deveria existir um índice no dicionário de cronograma, pois 2 threads de cronogramas iguais efetuaram o processo.");
            Assert.AreEqual(3, SemaforoSingleton.semaforosPorCronograma[cronogramas[0].Oid].semaforos.Count, "Deveria existir uma lista contendo 3 semáforos criados.");

            List <SemaforoPorIntervalo> semaforosCriados = SemaforoSingleton.semaforosPorCronograma[cronogramas[0].Oid].semaforos;

            Assert.IsNotNull(semaforosCriados.Where(o => o.inicio == semaforoIntervalo1.inicio && o.final == semaforoIntervalo1.final), "Deveria existir o semáforo, pois já estava criado.");
            Assert.IsNotNull(semaforosCriados.Where(o => o.inicio == 5 && o.final == 9), "Deveria existir o semáforo, pois a thread 1 criou.");
            Assert.IsNotNull(semaforosCriados.Where(o => o.inicio == 21 && o.final == 22), "Deveria existir o semáforo, pois a thread 2 criou.");
        }
Exemple #3
0
        public void RnControlarVerificacaoSemaforosImpactadosQuandoDuasThreadsDeCronogramasIguaisAcessaremSimultaneamenteEUmaEstiverEscrevendoNaListaEUmaEsperandoNaEscritaParaAdicionarOMesmoCronogramaTest()
        {
            //mockando o método que realiza a liberação de um semáforo.
            Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>()
            {
                CallBase = true
            };

            mockSemaforo.Setup(o => o.EsperarLeituraCronogramas());
            mockSemaforo.Setup(o => o.LiberarLeituraCronogramas());

            SemaforoSingletonMock.SetInstancia(mockSemaforo.Object);

            SemaforoSingletonMock.cronogramaSemaforosMock.Clear();

            cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[0].Oid,
                inicio        = 1,
                final         = 10,
                tempoDeEspera = 0
            };

            cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[0].Oid,
                inicio        = 11,
                final         = 15,
                tempoDeEspera = 500
            };

            Thread thread1 = new Thread(AcionarControleVerificacaoSemaforosImpactados)
            {
                Priority = ThreadPriority.Highest,
                Name     = "Thread 1",
            };

            Thread thread2 = new Thread(AcionarControleVerificacaoSemaforosImpactados)
            {
                Priority = ThreadPriority.Normal,
                Name     = "Thread 2"
            };

            thread1.Start(cronoIntervalo1);

            ControleDeEsperaUtil.AguardarAte(() =>
            {
                return(thread1.ThreadState == System.Threading.ThreadState.Running);
            });

            thread2.Start(cronoIntervalo2);

            ControleDeEsperaUtil.AguardarAte(() =>
            {
                return(thread1.ThreadState == System.Threading.ThreadState.Stopped &&
                       thread2.ThreadState == System.Threading.ThreadState.Stopped);
            }, 15);

            Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread 1, deveria estar em estado de finalizada, pois a thread 1 terminou de realizar o processamento necessário dentro do método Aguarde e está em processamento em outro método.");
            Assert.AreEqual(System.Threading.ThreadState.Stopped, thread2.ThreadState, "A thread 2 deveria estar em estado de finalizada, pois a thread 2 esperou a thread 1 e depois finalizou seu processamento.");
            Assert.AreEqual(1, SemaforoSingletonMock.cronogramaSemaforosMock.Count, "Deveria ter 1 cronograma na lista, pois a thread 1 já adicionou-o.");
        }
Exemple #4
0
        public void ConsultarSemaforosImpactadosPorCronogramaQuandoThreadsAcessaremSimultanementeDeCronogramasDiferentesTest()
        {
            SemaforoPorIntervalo semaforoIntervalo1 = new SemaforoPorIntervalo(80, 100);
            SemaforoPorIntervalo semaforoIntervalo2 = new SemaforoPorIntervalo(80, 100);

            SemaforoSingleton.SemaforosControle semaforoPorCronogramaC1 = new SemaforoSingleton.SemaforosControle()
            {
                lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>()
            };
            SemaforoSingleton.SemaforosControle semaforoPorCronogramaC2 = new SemaforoSingleton.SemaforosControle()
            {
                lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>()
            };

            semaforoPorCronogramaC1.semaforos.Add(semaforoIntervalo1);
            semaforoPorCronogramaC2.semaforos.Add(semaforoIntervalo2);

            //mockando o método que realiza a liberação de um semáforo.
            Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>()
            {
                CallBase = true
            };

            mockSemaforo.Setup(o => o.LiberarEscritaSemaforos(It.IsAny <Guid>()));

            SemaforoSingletonMock.SetInstancia(mockSemaforo.Object);

            SemaforoSingletonMock.cronogramaSemaforosMock.Clear();
            SemaforoSingleton.semaforosPorCronograma.Add(cronogramas[1].Oid, semaforoPorCronogramaC2);
            SemaforoSingleton.semaforosPorCronograma.Add(cronogramas[0].Oid, semaforoPorCronogramaC1);

            cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[0].Oid,
                inicio        = 5,
                final         = 10,
                tempoDeEspera = 0
            };

            cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[1].Oid,
                inicio        = 8,
                final         = 15,
                tempoDeEspera = 0
            };

            Thread thread1 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
            {
                Priority = ThreadPriority.Highest,
                Name     = "Thread 1",
            };

            Thread thread2 = new Thread(AcionarConsultaSemaforosImpactadosPorCronograma)
            {
                Priority = ThreadPriority.Normal,
                Name     = "Thread 2"
            };

            thread1.Start(cronoIntervalo1);
            thread2.Start(cronoIntervalo2);

            ControleDeEsperaUtil.AguardarAte(() =>
            {
                return(thread1.ThreadState == System.Threading.ThreadState.Stopped &&
                       thread2.ThreadState == System.Threading.ThreadState.Stopped);
            }, 60);

            Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra.");
            Assert.AreEqual(System.Threading.ThreadState.Stopped, thread2.ThreadState, "A thread deveria estar com o processo finalizado, pois não depende de nenhuma outra, ou seja, não impacta nenhuma outra.");
            Assert.AreEqual(2, SemaforoSingleton.semaforosPorCronograma.Count, "Deveria existir dois índices no dicionário de cronograma, pois 2 threads de cronogramas diferentes efetuaram o processo.");
            Assert.AreEqual(2, SemaforoSingleton.semaforosPorCronograma[cronogramas[0].Oid].semaforos.Count, "Deveria existir uma lista contendo 2 semáforos criados.");
            Assert.AreEqual(2, SemaforoSingleton.semaforosPorCronograma[cronogramas[1].Oid].semaforos.Count, "Deveria existir uma lista contendo 2 semáforos criados.");
        }
Exemple #5
0
        public void RnControlarVerificacaoSemaforosImpactadosQuandoDuasThreadsDeCronogramasDiferentesAcessaremSimultaneamenteUmaEstiverEscrevendoNaListaEUmaEsperandoParaEscreverNaListaTest()
        {
            //mockando o método que realiza a liberação de um semáforo.
            Mock <SemaforoSingletonMock> mockSemaforo = new Mock <SemaforoSingletonMock>()
            {
                CallBase = true
            };

            mockSemaforo.Setup(o => o.EsperarLeituraCronogramas());
            mockSemaforo.Setup(o => o.LiberarLeituraCronogramas());
            mockSemaforo.Setup(o => o.LiberarEscritaCronogramas());

            SemaforoSingletonMock.SetInstancia(mockSemaforo.Object);

            SemaforoSingletonMock.cronogramaSemaforosMock.Clear();

            cronogramaIntervalo cronoIntervalo1 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[0].Oid,
                inicio        = 1,
                final         = 10,
                tempoDeEspera = 0
            };

            cronogramaIntervalo cronoIntervalo2 = new cronogramaIntervalo()
            {
                oidCronograma = cronogramas[1].Oid,
                inicio        = 11,
                final         = 15,
                tempoDeEspera = 1000
            };

            Thread thread1 = new Thread(AcionarControleVerificacaoSemaforosImpactados)
            {
                Priority = ThreadPriority.Highest,
                Name     = "Thread 1",
            };

            Thread thread2 = new Thread(AcionarControleVerificacaoSemaforosImpactados)
            {
                Priority = ThreadPriority.Normal,
                Name     = "Thread 2"
            };

            thread1.Start(cronoIntervalo1);

            ControleDeEsperaUtil.AguardarAte(() =>
            {
                return(thread1.ThreadState == System.Threading.ThreadState.Running);
            });

            thread2.Start(cronoIntervalo2);

            ControleDeEsperaUtil.AguardarAte(() =>
            {
                return(thread1.ThreadState == System.Threading.ThreadState.Stopped &&
                       thread2.ThreadState == System.Threading.ThreadState.WaitSleepJoin &&
                       SemaforoSingletonMock.lockerCronogramas.WaitingWriteCount == 1);
            }, 100);

            Assert.AreEqual(System.Threading.ThreadState.Stopped, thread1.ThreadState, "A thread 1, deveria estar em estado de finalizada, pois a thread 1 terminou de realizar o processamento necessário dentro do método Aguarde e está em processamento em outro método.");
            Assert.AreEqual(System.Threading.ThreadState.WaitSleepJoin, thread2.ThreadState, "A thread 2 deveria estar em estado de espera, pois a thread 1 ainda está realizando o processamento e a thread 2 não pode impactar a thread 2.");
            Assert.AreEqual(1, SemaforoSingletonMock.lockerCronogramas.WaitingWriteCount, "Deveria ter 1 thread em espera de escrita, pois a thread 1 está realizando a escrita.");
            Assert.AreEqual(1, SemaforoSingletonMock.cronogramaSemaforosMock.Count, "Deveria ter 1 cronograma na lista.");
            Assert.AreEqual(1, SemaforoSingletonMock.cronogramaSemaforosMock[cronogramas[0].Oid].semaforos.Count, "Deveria ter criado um semáforo.");
        }