Instituto Tecnológico de Aeronáutica
CE-230 - Qualidade, Confiabilidade e Segurança ( Safety ) de Software Professor Doutor: Adilson Marques da Cunha
Sumário
1. OBJETIVO
Realizar os Warm-ups 1 (um) ao 8 (oito). Abaixo uma visão geral dos exercícios:
Warm-Up 1: Hello, World!
Criar uma cápsula com o comportamento, mas nenhuma estrutura.
Warm-Up 2: Passive class
Warm-Up 3: Traffic Light
Criar uma cápsula com uma porta, cujo estado da máquina contém três estados.
Warm-Up 4: Electronic Lock
Criar um modelo com uma classe de passivo cujo comportamento é definido por um diagrama de estado.
Warm-Up 5: Battleship
Criar um modelo com estrutura simples e de comportamento, que usa os temporizadores e os serviços de log.
Warm-Up 6: Traffic System
Criar um modelo com comportamento moderado e estrutura.
Warm-Up 7: Client / Server
Criar dois client / server modelos com estrutura dinâmica e comportamento.
Warm-Up 8: RQA-RT
Criar um diagrama de seqüência de especificação para o modelo cliente / servidor e executar o Verificar o comportamento contra ela.
2. WARM-UP 1 Objetivos
Depois de completar este exercício, você será capaz de: Criar um novo modelo.
Criar uma cápsula no modelo.
Adicionar comportamento simples para a cápsula. Compilar, executar e depurar o modelo.
Instruções
Iniciar oconjunto de ferramentasRoseRealTime. Criar um novomodelo deC++.
Selecione Arquivo> Novo.
Clique duas vezes emRTC++. Salvar o modelo.
Selecione Arquivo> Salvar como Modelo. Nomeie o arquivo Hello Word.
Criar uma cápsula:
Clicar com o botão direito do mouse em Logic View. Selecione New -> Capsule.
O nome da cápsula: Tipo HelloWorld.
Abrir a cápsula State Diagram Selecionar Open State Diagram.
Adicionar um diagrama de estado para a cápsula. Adicionar uma transição inicial para o estado. Clicar na ferramenta de transição de estado. Clicar no ponto estado inicial e arraste para Active. Colocar o código na transição:
Selecione a aba Actions. Digite o seguinte código:
cout <<"Hello, World" <<endl;
Incluir uma biblioteca:
Clicar duas vezes na cápsula na Logic View para abrir a Caixa de diálogo da cápsula Clique na guia C + +.
Na área HeaderPreface digite a instrução:
#include <iostream.h>
Criar um novo componente:
Selecione Component> Novo.
Nomear o componente como HelloWorld.
Clicar no componente e selecione Definir como Active.
Arraste a cápsula HelloWorld (da Logic View) para o componente.
Definir TopCapsule para HelloWorld. Ir para a guia C + + Executável . Escolher HelloWorld da lista. Ir para a guia de compilação C + +.
Selecionar NT40T.x86-VisualC + 6.0 da lista.
Clicar OK para salvar as configurações.
Criar um novo processador:
Botão direito do mouse em Deployment View. Selecione New > Processor.
Nomear o processador Workstation. Compilar, executar e depurar HelloWorld.
Arraste o componente HelloWorld (da Visão de componentes) para
Estação de trabalho (na Visão de Implantação). Isso cria uma instância do componente. Renomeá-lo HelloWorld e ativá-lo.
Salvar o seu modelo.
Clique para construir e executar o modelo.
Quando a construção for concluída com êxito, um prompt de comando janela aparecerá. Para que aparece nessa janela o HelloWorld na tela do prompt, é só dar play no modelo:
Após, finalize a sessão clicando em Shutdown
1. WARM-UP 2 Objetivos
Criar um modelo usando uma Passive class.
Adicionar comportamento simples para a classe adicionando uma operação. Compilar, executar e depurar o modelo.
Alterar o código produzido por Rose RealTime com um utilitário de texto.
Instruções
Criar o modelo e salvar como Passive Class.
Na aba Logic View, criar uma Passive Class e nomeie como Greetings.
Como o botão direito em cima de Greetings, crie uma operação com o nome de main. Dar um duplo clique em main e especificar a operação para main.
Escolha o tipo de return int e adicione os parâmetros. Dê um duplo clique em argv e configure como abaixo: Em code, digitar: printf(“ Greetings, ”); printf(“ Earthling \n”); getchar(); return 0;
Clicar em ok.
Dar um duplo clique em Greetings, ir na aba C++ para adicionar biblioteca #include <stdio.h> no espaço ImplementationPreface.
Em seguida, clicar em ok.
Adicionada a biblioteca, criar um novo componente, dando um duplo clique em ComponentView, New->Component nomeando-o como Greetings.
Arrastar Greetings de LogicView para dentro de Greetings em Component View e ative-o. Dê um duplo clique no componente ativado.
Ao abrir a caixa de especificação, ir na aba General e setar as variáveis como abaixo:
Após, ir na aba C++ compilation, em Target configuration selecionar Select NT40T.x86-VisualC+ +-6.0.
Clique em Ok.
Clicar duas vezes em Greetings do Component View, ir na aba general e em Environment escolher C++.
Em C++ Compilation, em Target Configuration selecionar: NT40T.x86-VisualC++-6.0 e clique em Ok.
Após, deve-se criar um processador.
Ir em Deployment View, New->Processor, nomeando como Workstation e salve o modelo.
Arrastar o Greetings de ComponentView para dentro do Workstation e uma instância será criada. Nomei-a como Greetings.
Dê um duplo clique na instância, nas especificações da instância, ir na aba Detail e desativar
Attach to target on startup e clicar em Ok.
Após ative a instância.
Rodar o modelo, utilizando o botão Run.
Ocorrerá um processamento e o prompt irá aparecer. Feche-a.
Após, clique com o botão direito na instância Greetings, dar um Shutdown, ok.
Editar a fonte Greetings.cpp e abri-lo em um editor de texto. No código, onde tiver printf, substituir
Earthling trocar por outra palavra. Por exemplo, contato. Salve as alterações.
Após, deve-ser abrir a caixa de comand. Após aberta, ir a uma pasta acima do código fonte e copie o endereço onde se encontra o Greetings e cole na linha de comando, escrever nmake e dar enter.
No Rational Rose Real Time, rode o modelo. Na linha de comando ao invés de Earthling aparecerá Contato.
Após, dar um shutdown na instância Greetings.
Clicar em Greetings em ComponentView, escolher Build ->Code Sync, conforme abaixo: A janela que abrir, aparecerá o código novo e o alterado.
Dar Ok e rodar novamente o modelo. E irá mudar novamente.
2. WARM-UP 3
Objetivos
Construir um modelo de requisitos apresentados na forma de um diagrama de seqüência. Criar uma classe simples protocolo.
Definir comportamento (máquina de estado finito), composto por vários estados e transições. Compilar, executar, depurar e verificar o modelo multi-estado, utilizando diagramas de seqüência gerados durante o tempo de execução.
Instruções
Criar um modelo e nomeá-lo como Traffic Light e salve-o.
Após, criar um protocolo clicando com o botão direito em LogicView-> New-> Protocol. Nomei-o como Light Control.
Clique duas vezes no protocolo. Abrirá a cixa para especificações do protocolo. Na aba Signals, cria-se os três sinais: Red, Yellow e Green.
Após, deve-se criar uma cápsula, clicando com o botão direito em LogicView->New->Capsule e nomei-a como Traffic Light.
Abrir o diagrama de estrutura para Traffic Light, expandindo sua árvore e dando um duplo clique no diagrama.
Dar um duplo em Structure Diagram e adionar uma porta e nomei-a como control. Dê um duplo clique na porta criada e aparecerá a espeficação para a porta. Na aba General, clicar em
Conjugated e End Port e dar Ok.
Para definir o comportamento para Traffic Light, deve-se adicionar em State Diagram, selecionar a ferramenta State e criar as caixas Red, Yellow e Green.
Após, definir o Red como estado inicial. Para isso, utlizar a ferramenta de transição.
Após, adicionar as demais transições de Red para Green, Green para Yellow e Yellow para Red.
Após, deve-se adicionar um trigger para cada transição. Para isso, dar um duplo clique na linha de transição e abrirá a caixa de especificação. Em General, Inserir a direção que a transição está sendo apontada, fazendo para os estados.
Após, clicar com o botão direito em ComponentView e criar um novo componente nomeado como
Traffic Light e ative-o. Em seguida, arraste a cápsula para dentro do componente.
Clicar duas vezes em Traffic Light, na aba C++ Executable e em C++ Compilation, configurando como a seguir:
Após, deve-se criar um processador em Deployment View, nomeando como Workstation. Após criar uma instância para Traffic Light, arrastando-o para Workstation e renome-a a instância para
Traffic Light e ative-a e salve.
Rode o modelo. A caixa de comando abrirá. Para testar, clicar em:
Criar três sinais: Red, Amareloe Verde.
Expandir a pasta Probes e clicar duas vezes para abrir sua caixa de especificação. Clicar na guia Details, clique com o campo de entrada, e selecione Inserir.
Salvar.
Repitiro procedimento para Probes restantes.
Após, dar Play no modelo.
Clique com o Botão direito do mouse e selecione Open State Monitor.
Dar um duplo clique em control/Red, control/yellow e control/green. Isso permitirá a transição entre os estados.
3. WARM-UP 4 Objetivos:
Adicionar uma máquina de estado para uma Passive Class.
Criar uma operação de gatilho para uma máquina Passive Class do Estado. Adicione código para uma transição.
Instruções
Criar um modelo com o nome de lock e salvá-lo.
Criar uma Passive Class com o nome de Eletronic Lock e adiciona a biblioteca #include < stdio.h>, #include < stdlib.h> e #include < conio.h>.
Criar uma operação com o nome main.
Dar duplo clique e adicionar as especificações para a operação.
Criar mais um operador para agir como trigger, nomeando-a como Number e escolher o esteriótipo trigger para esta operação e configure as especificações.
Criar uma máquina de estado, dando um duplo clique em Eletronic Lock.
Clicar na ferramenta State, clicar dentro da máquina criada, nomeie como Lock e criar uma transição.
Digitar o código nessa transição:
printf("*****************************\n");
printf(" ACME Electronic Lock System \n"); printf("*****************************\n\n");
Criar uma transição para o próprio estado, nomear como Question e defina a transição na aba trigger.
Clicar duas vezes na transição para abrir a Especificação de diálogo de transição. Ir até a aba Triggers.
Botão direito do mouse e selecione Inserir. Selecionar Number da caixa drop-down. Na janela da Guarda, type: num == '?'.
Ir até a aba Ações na caixa de diálogo Especificação de transição e digitar o código:
printf ("Help Locked Goes Here \ n");
Adicionar um novo estado com o nome Unlocking, outro estado com o nome Unlocked. Criar uma transição de Locked para Unlocking chamada Number1.
Criar outra transição de Unlocked para Locked, chamada locklsClosed. Criar uma transição de Unclocked para ele mesmo com o nome de question.
Definir a transição locklsClosed, dando um duplo clique em cima linha. Na caixa de especificação ir na aba Triggers, inserir o código num == 'L'.
Em actions colocar o código: printf("The lock is LOCKED\n");
Após, definir a transição Number1, digitando na aba Guard Code, inserir o código: num == '1'. Na transição de Unlocked para Unlocked, também deve-se fazer as especificações: na aba
triggers, digitar num == '?', em Actions, digitar o código: printf ("Unlocked Help Goes Here\n");
Criar um ponto de escolha.
Selecionar a ferramenta ponto de escolha e criar um ponto de escolha chamado
IsQuestion.
Dar duplo para abrir a caixa de especificação.
Ir para a guia Condição e digitar a condição: Num == '?'
Criar um ponto de escolha para determinar se a entrada for de dois ou não.
Abrir a caixa de Especificação Point.
Ir para a guia Condição e digitar a condição: Num == '2 ' Criar as transições conforme a figura abaixo:
Definir a transição InputRcvd.
Duplo clique na transição InputRcvd para abrir a especificação. Ir para a aba Triggers.
Adicionar o código para o IsQuestion .
Ir para a aba Actions e digite o seguinte no Código
printf ("Desbloquear Help Goes Here \ n");
Clicar duas vezes na transição IsTwo em Ir para a aba Actions
printf ("The lock is UNLOCKED\n");
Adicionar código para a transição False.
Dar duplo clique na linha e digitar na aba Actions o código:
printf ("Sorry, that is not the right combination\n"); Salve o modelo.
Ciar um componente coom o nome LockSystem Arrastar o EletronicLock para dentro do componente. Ativar o componente.
Dar um duplo clique no LockSystem, na aba General, escolher C++ na opção Environment. Na aba C++ Compilation, na aba TargetConfiguration, escolher a opção como abaixo:
Clicar na ferramenta Build Component.
Se rodar com sucesso, criar o processador com o nome de Workstation.
Arrastar o componente para dentro do processador e renomear como LockSystem.
Duplo clique em LockSystem, na aba Detail, desativar a opção: Attach to target on startup.
Após, ativar a instância. Clicar no botão Run.
Se rodar com sucesso, aparecerá um prompt de comando.
Se apertar qualquer outra tecla, nenhuma mensagem no prompt aparecerá, mas se apertar o ponto de interrogação a frase acima aparecerá, monstrando que ainda está em Locked. Para passar para Unlocking é só apertar o número 1.
Apertar o número dois e passará de Unlocking para Unlocked.
O ponto de interrogação aparecerá a mensagem Unlocked Help Goes Here. Para voltar para Locked, deve-se apertar o L maiúsculo.
O resultado está abaixo:
4. WARM-UP 5 Objetivos
Criar um novo modelo a partir de elementos do modelo existente.
Desencadear o comportamento da cápsula com um timer, usando o Timing Service na biblioteca de serviços.
Exibir mensagens de texto a partir de uma cápsula, usando o Log Service nos serviços biblioteca.
Compilar, executar, depurar e verificar o modelo usando diagramas de seqüência gerada durante o tempo de execução.
Instruções
Abrir o modelo Battleship. Salvar o modelo.
Criar duas cápsulas: Battleship e Ocean. Conectar as portas com o mesmo protocolo.
Criar um State Diagram dentro de Battleship e adicionar as transições. Criar um Structure Diagram.
Colocar na transição Send o timeout..
A porta SonarSignals tem que ser End Port para comunicar com a máquina de estado.
Receive vai ser trigado com a função echo.
Após definie-se a ação.
Adicionar a biblioteca <stdio.h>;
Após criar o componente, processador, execute o modelo.
Dessa forma, de 1 (um) em 1 (um) segundo, é enviado um sinal de ping do Battleship para o
5. WARM-UP 6 Objetivo
Criar um novo modelo usando um modelo existente e seus elementos (cápsula e classes de protocolo).
Criar uma classe nova cápsula e definir sua estrutura e comportamento. Criar uma cápsula.
Adicionar estrutura para a cápsula.
Compilar, executar e depurar o novo modelo.
Instruções
Abrir o modelo TrafficLight do exercício 3. Salvar o modelo como TrafficSystem.
Criar uma cápsula com o nome de Controller. Definir uma estrutura.
Criar uma cápsula com o nome de Intersection. Adicionar uma cápsula, baseada na Controller.
Adicionar quatro cápsulas baseadas em TrafficLight, nomeadas como norte, sul, leste e oeste. Conectar cada uma das quatro cápsulas TrafficLight no seu controle apropriado.
Compilar, rodar e debugar Intersection.
6. WARM-UP 7 Objetivos
Criar um modelo com cápsulas que estão intercaladas (criada dinamicamente ao executar). Criar um modelo com cápsulas que são importados (de forma dinâmica ao executar). Compilar, executar e depurar os modelos que usam intercalação e contenções múltiplas.
Instruções
Abrir o modelo ClientServer.
Salvar o modelo como ClientServerIncarnated. Abrir o diagrama de estrutura para o TheSystem.
Abir a caixa de diálogo CapsuleRole especificação para o cliente e altere a configuração de fixo para opcional.
Adicionar um protegido, frame de porta unwired, com base no serviço Frame. Selecionar a ferramenta Port e clique dentro do limite da TheSystem.
Selecionar o quadro na lista de protocolos. Digitar o nome da nova porta.
Adicionar uma transição inicial ao comportamento TheSystem contendo o seguinte código:
frame.incarnate (cliente);
Construir o modelo e remover quaisquer erros. Executar o modelo.
Salvar o modelo como ClientServerImported.
Setar cliente para Plug-in em sua caixa de diálogo Especificação. Adicionar um novo cliente para TheSystem, chamado realClient.
Alterar o código na transição inicial do comportamento TheSystem para:
frame.import (realClient, client);
Construir o modelo e remover quaisquer erros.
Executar o modelo, assista cliente receber o realClient importados, e depois utilizar o Rastreamento para assistir o cliente eo servidor de mensagens começar.
7. WARM-UP 8 Objetivos:
Criar um modelo Cliente/Servidor a partir do diagrama de seqüência e verificar seu comportamento.
Parte 1
Baixar o pacote TestClientServer. Criar um pacote TestResults.
Criar um diagrama de colaboração e nomeá-lo SingleClient.
Arrastar as cápsulas cliente e servidor para o diagrama de colaboração e criar a ligação entre elas com a ferramenta de Associação.
Criar um diagrama de seqüência de especificação para o modelo da colaboração diagrama. O nome do HappyPath diagrama. Criando um diagrama de colaboração mantém os artefatos de teste isolado do resto do modelo.
Criar uma mensagem assíncrona chamado RequestService do cliente ao servidor. Criar um componente chamado TestComponent com a configuração-alvo correto. Criar um processador chamado TestProc usando as configurações padrão. Nesse momento que o armazenamento dos resultados é definido.
Fazer as verificações de comportamentos e verificar resultado.
Parte 2
Criar um diagrama de classe TestClientServer2. Criar Diagrama de Colaboração MultipleClients.
Criar um novo diagrama de seqüência chamado RequestWithData . Alterar a classe de dados para int.
Adicionar os dados RequestService. Digite o número 6 na caixa de dados. Definir uma variável na interação clientR1.
Abrir a caixa de diálogo Interação Instância Especificação, clique com o botão ClientRole1 interação no diagrama de seqüência e selecione Abrir
Especificação.
Na janela Atributos digitar: serviceNumber: int
Criar uma ação local acima da primeira mensagem sobre a interação clientR1.
Abrir a caixa de diálogo Enviar Mensagem Especificação para a mensagem de resposta de o servidor para clientR1.
Adicionar dados para as mensagens e modificar clientR2 da mesma maneira como para clientR1.
CONCLUSÕES
A Execução dos Warm-ups exigiu pesquisa, uma vez que nem todos os passos estão claramente definidos no tutorial.
O Warm-up 8 foi finalizado quando se descobriu que deveria ligar as portas dos componentes Server e client e não somente as estruturas.
