mise à jour des tests

tests/testsAdvanced/carre.test_out

@@ -0,0 +1,2 @@
+
+5^2 + 4^2 + 3^2 + 2^2 + 1^2 = 55

tests/testsAdvanced/carre.vsl

@@ -0,0 +1,28 @@
+FUNC VOID main()
+{ INT n,i,s
+ 
+  n := 5
+  s := 0
+  i := n
+
+  WHILE i
+  DO
+    { s := s + i*i 
+      i := i - 1 
+    }
+  DONE
+
+  PRINT "\n"
+
+  i := n
+  WHILE i-1
+  DO
+    { PRINT i, "^2 + "
+      i := i - 1
+    } 
+  DONE
+
+  PRINT "1^2 = ", s, "\n"
+
+}
+

tests/testsAdvanced/diverge.test_ret

@@ -0,0 +1 @@
+0

tests/testsAdvanced/diverge.vsl

@@ -0,0 +1,6 @@
+FUNC VOID main() {
+	INT x
+	PRINT "Toto"
+	WHILE 1 DO {	
+			x := 1 } DONE
+	}

tests/testsAdvanced/divergeDifficile.test_ret

@@ -0,0 +1 @@
+0

tests/testsAdvanced/divergeDifficile.vsl

@@ -0,0 +1,5 @@
+FUNC VOID main() {
+	PRINT "Toto"
+	WHILE 1 DO {	INT x
+			x := 1 } DONE
+	}

tests/testsAdvanced/fact.test_out

@@ -0,0 +1,11 @@
+f(0) = 1
+f(1) = 1
+f(2) = 2
+f(3) = 6
+f(4) = 24
+f(5) = 120
+f(6) = 720
+f(7) = 5040
+f(8) = 40320
+f(9) = 362880
+f(10) = 3628800

tests/testsAdvanced/fact.vsl

@@ -0,0 +1,32 @@
+PROTO INT fact(k)
+FUNC VOID main()
+{
+  INT i, t[11]
+  i := 0
+
+  WHILE 11 -i
+  DO
+   {
+     t[i] := fact(i)
+     i := i+1
+   }
+  DONE
+  i := 0
+  WHILE 11 -i
+  DO
+   {
+     PRINT "f(", i, ") = ", t[i], "\n"
+     i := i+1
+   }
+  DONE
+}
+
+FUNC INT fact(n)
+{
+  IF n
+  THEN
+    RETURN n* fact(n-1)
+  ELSE
+    RETURN 1
+  FI
+}

tests/testsAdvanced/fact2.test_out

@@ -0,0 +1,11 @@
+f(0) = 1
+f(1) = 1
+f(2) = 2
+f(3) = 6
+f(4) = 24
+f(5) = 120
+f(6) = 720
+f(7) = 5040
+f(8) = 40320
+f(9) = 362880
+f(10) = 3628800

tests/testsAdvanced/fact2.vsl

@@ -0,0 +1,35 @@
+PROTO INT fact(k)
+FUNC VOID main()
+{
+  INT i, t[11]
+  i := 0
+
+  WHILE 11 -i
+  DO
+   {
+     t[i] := fact(i)
+     i := i+1
+   }
+  DONE
+  i := 0
+  WHILE 11 -i
+  DO
+   {
+     PRINT "f(", i, ") = ", t[i], "\n"
+     i := i+1
+   }
+  DONE
+}
+
+FUNC INT fact(n)
+{
+  INT res
+  IF n
+  THEN
+    res := n* fact(n-1)
+  ELSE
+    res := 1
+  FI
+  RETURN res
+}
+

tests/testsAdvanced/fact3.test_in

@@ -0,0 +1 @@
+10

tests/testsAdvanced/fact3.test_out

@@ -0,0 +1,10 @@
+Que vaut n ?f(0) = 1
+f(1) = 1
+f(2) = 2
+f(3) = 6
+f(4) = 24
+f(5) = 120
+f(6) = 720
+f(7) = 5040
+f(8) = 40320
+f(9) = 362880

tests/testsAdvanced/fact3.vsl

@@ -0,0 +1,30 @@
+  PROTO INT fact(k)
+  FUNC VOID affichetab(taille, t[]) {
+    INT i
+    i := 0
+    WHILE taille - i
+    DO {
+      PRINT "f(", i, ") = ", t[i], "\n"
+      i := i+1
+    }
+    DONE
+  }
+  FUNC VOID main() {
+    INT n
+    PRINT "Que vaut n ?"
+    READ n
+    {
+      INT i, t[n]
+      i := 0
+      WHILE n - i
+      DO {
+        t[i] := fact(i)
+        i := i+1
+      }
+      DONE
+      affichetab(n, t)
+    }
+  }
+  FUNC INT fact(n)
+    IF n THEN RETURN n* fact(n-1)
+    ELSE RETURN 1 FI

tests/testsAdvanced/hanoi.test_out

@@ -0,0 +1,29 @@
+
+ Hanoi avec 3 disques
+
+Deplacer un disque de 1 a 3
+Deplacer un disque de 1 a 2
+Deplacer un disque de 3 a 2
+Deplacer un disque de 1 a 3
+Deplacer un disque de 2 a 1
+Deplacer un disque de 2 a 3
+Deplacer un disque de 1 a 3
+
+
+Hanoi avec 4 disques
+
+Deplacer un disque de 1 a 2
+Deplacer un disque de 1 a 3
+Deplacer un disque de 2 a 3
+Deplacer un disque de 1 a 2
+Deplacer un disque de 3 a 1
+Deplacer un disque de 3 a 2
+Deplacer un disque de 1 a 2
+Deplacer un disque de 1 a 3
+Deplacer un disque de 2 a 3
+Deplacer un disque de 2 a 1
+Deplacer un disque de 3 a 1
+Deplacer un disque de 2 a 3
+Deplacer un disque de 1 a 2
+Deplacer un disque de 1 a 3
+Deplacer un disque de 2 a 3

tests/testsAdvanced/hanoi.vsl

@@ -0,0 +1,30 @@
+PROTO INT hanoi(n,delatour,alatour,parlatour)
+
+FUNC VOID main()
+{
+  INT ndisque,a
+
+  ndisque := 3
+  PRINT "\n Hanoi avec ", ndisque, " disques\n\n"
+  a := hanoi(ndisque,1,3,2)
+
+  ndisque := 4
+  PRINT "\n\nHanoi avec ", ndisque, " disques\n\n"
+  a := hanoi(ndisque,1,3,2)
+}
+
+
+FUNC INT hanoi(n,delatour,alatour,parlatour)
+{
+  INT b
+  IF n
+  THEN
+  {
+    b := hanoi( n-1, delatour, parlatour, alatour )
+    PRINT "Deplacer un disque de ",delatour," a ",alatour,"\n"
+    b := hanoi( n-1, parlatour, alatour, delatour )
+  }
+  FI
+  RETURN 1
+}
+

tests/testsAdvanced/heapsort.test_in

@@ -0,0 +1,11 @@
+5
+20
+15
+10
+4
+8
+13
+19
+30
+18
+

tests/testsAdvanced/heapsort.test_out

@@ -0,0 +1,21 @@
+
+ Entrer le0eme:     i=1  j=5
+ Entrer le1eme:     i=2  j=20
+ Entrer le2eme:     i=3  j=15
+ Entrer le3eme:     i=4  j=10
+ Entrer le4eme:     i=5  j=4
+ Entrer le5eme:     i=6  j=8
+ Entrer le6eme:     i=7  j=13
+ Entrer le7eme:     i=8  j=19
+ Entrer le8eme:     i=9  j=30
+ Entrer le9eme:     i=10  j=18
+ t[0] = 4
+ t[1] = 5
+ t[2] = 8
+ t[3] = 10
+ t[4] = 13
+ t[5] = 15
+ t[6] = 18
+ t[7] = 19
+ t[8] = 20
+ t[9] = 30

tests/testsAdvanced/heapsort.vsl

@@ -0,0 +1,122 @@
+PROTO INT plusgrandstrict(n,m)
+PROTO INT plusgrand(n,m)
+PROTO VOID heapsort(t[], n)
+
+// Ce programme lit un tableau de 10 entiers et imprime
+// le tableau trie par heapsort.
+//=====================================================
+FUNC VOID main()
+{
+  INT a[10], i, j
+
+  i := 0
+  WHILE 10-i DO
+    {
+	PRINT "\n Entrer le",i,"eme:  "
+        READ j
+        a[i] := j
+	i := i+1
+	PRINT "   i=", i, "  j=",j
+    }
+  DONE
+  heapsort(a,10)
+  i := 0
+  WHILE 10-i DO
+    {
+	PRINT "\n t[",i,"] = ",a[i]
+        i:= i+1
+    }
+  DONE
+}
+
+
+// Implementation du heapsort
+//===========================
+FUNC VOID heapsort(t[], n ) // n: nombre d'elements a trier
+{
+  INT l,r,j,s, test
+
+  l := n/2+1
+  r := n
+
+  WHILE plusgrand(r,2) DO
+    {
+      IF plusgrandstrict(l,1)
+         THEN  // agrandissement t[l..r] -> t[l-1..r] heap
+          {
+           l := l-1
+           j := l
+          }
+         ELSE  // selection : t[0] est le + grand et echange avec t[r-1]
+               // rearrangement de t[0..r-2]
+          {
+           INT ex
+           ex := t[0]
+           t[0] := t[r-1]
+           t[r-1] := ex
+           r := r-1
+           j := 1
+          }
+      FI
+      s := t[j-1]
+      test := plusgrand(r, 2*j)
+      WHILE test DO
+          {
+           INT k
+           k := 2*j // indice du premier fils de t[~j]
+       // on choisit le plus grand des deux
+           IF plusgrandstrict(r,k)*plusgrandstrict(t[k], t[k-1]) THEN k:=k+1 FI
+       // si le plus grand des deux est plus grand que s on echange avec s    
+           IF plusgrandstrict(t[k-1],s) 
+              THEN
+               {
+                t[j-1] := t[k-1]
+                j := k
+                test := plusgrand(r, 2*j)
+               }
+              ELSE  test := 0  // une facon de faire un break
+           FI 
+          }
+      DONE
+      t[j-1] := s
+    }
+ DONE
+}
+
+// fonctions de comparaison entre entiers
+//=======================================
+FUNC INT plusgrandstrict(n,m )
+{
+  INT continue, nn, mm
+
+  continue := n*m
+  nn := n
+  mm := m
+  WHILE continue
+    DO
+	{ 
+	  mm := mm-1
+          nn := nn-1
+          continue := nn*mm
+	}
+    DONE
+  IF nn THEN RETURN 1 ELSE RETURN 0 FI
+}
+
+FUNC INT plusgrand(n,m )
+{
+  INT continue, nn, mm
+
+  continue := n*m
+  nn := n
+  mm := m
+  WHILE continue
+    DO
+	{ 
+	  mm := mm-1
+          nn := nn-1
+          continue := nn*mm
+	}
+    DONE
+  IF nn THEN RETURN 1 ELSE IF mm THEN RETURN 0 ELSE RETURN 1 FI FI
+}

tests/testsAdvanced/portee.test_in

@@ -0,0 +1,3 @@
+2
+5
+

tests/testsAdvanced/portee.test_out

@@ -0,0 +1 @@
+y a l'interieur vaut 5, mais a l'exterieur du bloc il vaut 2

tests/testsAdvanced/portee.vsl

@@ -0,0 +1,9 @@
+FUNC VOID main() {
+	INT y
+	READ y
+	{ INT y
+	  READ y
+	  PRINT "y a l'interieur vaut ",y
+	}
+	PRINT ", mais a l'exterieur du bloc il vaut ",y
+}

tests/testsAdvanced/portee2.test_out

@@ -0,0 +1 @@
+100

tests/testsAdvanced/portee2.vsl

@@ -0,0 +1,5 @@
+FUNC VOID main(f) {
+	INT f
+	f:=100
+	PRINT f 
+}

tests/testsAdvanced/portee3.test_out

@@ -0,0 +1 @@
+Et voila: 0001

tests/testsAdvanced/portee3.vsl

@@ -0,0 +1,18 @@
+FUNC VOID main()
+{
+  INT i,j,k,l
+  i := 0
+  j := 0
+  k := 0
+  l := 0
+ { INT i,j,k
+     l := 1
+    { INT i,j
+       k:= 2
+       { INT i
+          j:= 3
+       }
+    }
+ }
+  PRINT "Et voila: ", i,j,k,l
+}

tests/testsAdvanced/tri.test_in

@@ -0,0 +1,11 @@
+10
+15
+12
+18
+17
+19
+13
+12
+11
+11
+

tests/testsAdvanced/tri.test_out

@@ -0,0 +1,21 @@
+
+ Entrer le 0eme:  
+ Entrer le 1eme:  
+ Entrer le 2eme:  
+ Entrer le 3eme:  
+ Entrer le 4eme:  
+ Entrer le 5eme:  
+ Entrer le 6eme:  
+ Entrer le 7eme:  
+ Entrer le 8eme:  
+ Entrer le 9eme:  
+ t[0] = 10
+ t[1] = 11
+ t[2] = 11
+ t[3] = 12
+ t[4] = 12
+ t[5] = 13
+ t[6] = 15
+ t[7] = 17
+ t[8] = 18
+ t[9] = 19

tests/testsAdvanced/tri.vsl

@@ -0,0 +1,80 @@
+PROTO INT plusgrandstrict(n,m)
+PROTO VOID naivesort(t[], index)
+
+// Ce programme lit un tableau de 10 entiers et imprime
+// le tableau trie. Illustre le passage de tableaux en parametres
+//===============================================================
+FUNC VOID main()
+{
+  INT a[10], i, j
+
+  i := 0
+  WHILE 10-i DO
+    {
+	PRINT "\n Entrer le ",i,"eme:  "
+        READ j
+        a[i] := j
+	i := i+1
+    }
+  DONE
+  naivesort(a,9)
+  i := 0
+  WHILE 10-i DO
+    {
+	PRINT "\n t[",i,"] = ",a[i]
+        i:= i+1
+    }
+  DONE
+}
+
+
+// Tri naif: cherche le +grand elem du tableau et le met
+// a la fin. Recommence avec le sous tableau terminant a index-1
+//==============================================================
+FUNC VOID naivesort(t[], index )
+{
+  INT max , maxpos, i
+
+  IF index THEN  // il y a au moins deux elements
+    {
+     max := t[index]
+     i:= index
+     maxpos := index
+
+     WHILE i+1 DO
+       {
+        IF plusgrandstrict(t[i], max) THEN
+           {
+             max := t[i]
+             maxpos := i
+           }
+        FI
+        i := i-1
+       }
+     DONE
+     t[maxpos] := t[index]
+     t[index] := max
+     naivesort(t,index-1)
+    }
+   FI
+}
+
+// fonction de comparaison entre entiers
+//======================================
+FUNC INT plusgrandstrict(n,m )
+{
+  INT continue, nn, mm
+
+  continue := n*m
+  nn := n
+  mm := m
+  WHILE continue
+    DO
+	{ 
+	  mm := mm-1
+          nn := nn-1
+          continue := nn*mm
+	}
+    DONE
+  IF nn THEN RETURN 1 ELSE RETURN 0 FI
+}