{Teste 1 - OK}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   

---------------------------------

{Teste de ponto e virgula excedente}
programa test1;;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x; inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
      leia(z)
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   

             
-------------------------------------

{Teste  de virgula a mais}
programa test1;

var a,b,c,: inteiro;

{proc 1}
procedimento analisa1;
var a, x; inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
      leia(z)
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   

             
-------------------------------------

{Teste sem variaveis - deve compilar}
programa test1;


{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
  leia(z) ;
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   


---------------------------------------             

{Teste sem procedimentos - deve compilar}
programa test1;

var a,b,c: inteiro;


inicio
   se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   

---------------------------------------             

{Teste erro operador relacional}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1 ;
var a, x: inteiro ;
       z:booleano;
inicio
  se x>>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   

             
----------------------------------

{Teste erro atribuicao}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;
inicio
  se x>1  entao
      x: 0;
  leia(z);

  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   

             
----------------------------------------

{Teste operador logico a mais}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 1000) ou {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   

             
-----------------------------------------

{Teste ponto e virgula antes do fim}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca a:= x+z;
  escreva(a);
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   

             
------------------------------

{Teste numero com ponto}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 100.0)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   

             
------------------------------

{Teste expressao em lugar errado}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a; a+(c div b) 
fim;

inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   


------------------------------------------             

{Teste fim a mais}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim
fim;
inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   


------------------------------------------             

{Teste falta inicio}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;


    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   

-------------------------------------------
             

{Teste ponto e virgula antes do senao}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b);
    senao escreva(c)
fim.

{fim}   

             

-------------------------------------------
             

{Teste falta ; depois do procedimento}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim

inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   


------------------------------------------
             

{Teste falta ponto final
}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;

procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;



inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim

{fim}   


------------------------------------------

{Teste procedimento aninhado - OK}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;

procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;



inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   

             
----------------------------------

{Teste do operador logico}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;

procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;



inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim.

{fim}   

             
-----------------------------------

{Teste duplo inicio fim - OK}
programa test1;

var a,b,c: inteiro;

{proc 1}
procedimento analisa1;
var a, x: inteiro;
       z: booleano;
inicio
  se x>1  entao
      x:= 0;
  leia(z);
  enquanto (a <> 89) e (a<= 1000)  {condicao de parada}
  faca inicio
           a:= x+z
       fim;
  escreva(a)
fim;


procedimento analisa2;
inicio
  leia(a);
  b:= a*a+(c div b) 
fim;

inicio
inicio
    analisa1;
    analisa2;
    se b > (c+ a*a)
    entao escreva(b)
    senao escreva(c)
fim
fim.

{fim}