Fix test cases that were failing for stupid reasons (typically, bad node name)

nb : #FAILS=128->90

test/lus2lic.time

-testcase ./lus2lic.tests/non-reg.exp completed in 223 seconds
+testcase ./lus2lic.tests/non-reg.exp completed in 333 seconds
 testcase ./lus2lic.tests/progression.exp completed in 0 seconds

test/should_work/TIME_STABLE1.lus

-node TIME1_STABLE1(set,second:bool; delay:int) returns (level:bool);
+
+
+node TIME_STABLE1(set,second:bool; delay:int) returns (level:bool);
 var count: int;
 let
   level = (count > 0);

test/should_work/aa.lus

@@ -8,7 +8,7 @@ let
    _acc1 = Lustre::plus(i1, i2_0);
 tel
 -- end of node n_node_alias
-node matrice2(a:int) returns (res:int);
+node aa(a:int) returns (res:int);
 var
    _acc1:int;
    _v1_0:int;

test/should_work/bred_lv4.lus

@@ -15,7 +15,7 @@ type T1_ARRAY = bool^2;
 -------------------------------------------- 
 -- operator definition 
 -------------------------------------------- 
-node bred(
+node bred_lv4(
  i_a : T1_ARRAY;
  ) returns ( 
  o_x : bool;

test/should_work/bug.lus

@@ -9,7 +9,7 @@ let
   o = x^3;
 tel
 
-node simple2(x:s) returns (o: s^3^2; i: int);
+node bug(x:s) returns (o: s^3^2; i: int);
 let 
   o[0] = simple(x);
   o[1] = simple(x);

test/should_work/bug2.lus

@@ -5,7 +5,7 @@
 
 type s =  { f1: int ; f2: int^2 };
 
-node simple(x:s) returns (i: s^2);
+node bug2(x:s) returns (i: s^2);
 let 
 
   i = s { f1 = 42; f2 = [5, 6] } ^ 2;

test/should_work/clock_ite.lus

 
 
-node clock(a: bool; b: bool) returns (c: bool when a);
+node clock_ite(a: bool; b: bool) returns (c: bool when a);
 -- var
 --  z: bool;
 

test/should_work/cond01.lus

 
 
-node main(c: bool; x,y:int) returns (o: int);
+node cond01(c: bool; x,y:int) returns (o: int);
 let
 	o = condact<<+,0>>(c,x,y);
 tel

test/should_work/consensus.lus

@@ -17,13 +17,14 @@ let
 	a = T[0] and consensus<<n-1>>(T[1..n-1]);
 tel
 *)
-node consensus<<const n : int>>(T: bool^n) returns (a: bool); 
+node consensus_gen<<const n : int>>(T: bool^n) returns (a: bool); 
 let
 	a = with (n = 1)
 		then T[0]
-		else T[0] and consensus << n-1 >> (T[1 .. n-1]);
+		else T[0] and consensus_gen << n-1 >> (T[1 .. n-1]);
 tel
 
+node consensus = consensus_gen<<8>>
 (*
 node consensus(T: bool list) returns (a: bool); 
 let
@@ -32,7 +33,7 @@ let
 tel
 *)
 
-node c8 = consensus<<8>>;
+node c8 = consensus_gen<<8>>;
 
 
 
@@ -40,7 +41,7 @@ node c8 = consensus<<8>>;
 
 node main (T : bool^4) returns (c : bool);
 let
-	c = consensus<<4>>(T);
+	c = consensus_gen<<4>>(T);
 tel
 
-node main2 = consensus<<10>>;
+node main2 = consensus_gen<<10>>;

test/should_work/contractForElementSelectionInArray.lus

@@ -33,3 +33,5 @@ let
                                      else acc_in.elementSelected
                    };
 tel
+
+node contractForElementSelectionInArray = selectOneStage
\ No newline at end of file

test/should_work/cst.lus

-const i, j, k: int;
+const i=3;
+const j=3;
+const k=3;
 
 node cst(x:int) returns (y:int);
 var z,t: int;

test/should_work/ec.lus

 
-node left__toto(
+node ec(
 	x:bool) 
 returns (
 	t_0_a_0:bool;

test/should_work/fresh_name.lus

@@ -9,8 +9,7 @@ let
 	n1s = (n1b1 or n1b2);				
 tel
 
-
-node fn (b:bool) returns (res:bool);
+node fresh_name (b:bool) returns (res:bool);
 var _n1e1_1:bool;
 let
   _n1e1_1 = not b;

test/should_work/func_with_body.lus

 -- an intern function
-function trivial(x : int) returns (y : int);
+function func_with_body(x : int) returns (y : int);
 let
 	y = 1;
 tel
@@ -8,5 +8,3 @@ tel
 -- and an extern node
 extern node ext(x : int) returns (y : int);
 
-
-

test/should_work/impl_priority.lus

-node test_impl_prio(x: int) returns (ok: bool)
+
+node impl_priority(x: int) returns (ok: bool)
 let
   ok = x=1 => true;
 tel

test/should_work/is_stable.lus

@@ -88,4 +88,6 @@ let
 tel
 
 node maxr=max<<real>>;
-node minr=min<<real>>;
+node minr=min<<real>>;
\ No newline at end of file
+
+node is_stable = is_d_stable<<5, 0.1>>
\ No newline at end of file

test/should_work/left.lus

@@ -5,7 +5,7 @@ type truc = struct {
 };
 
 
-node toto(x : bool) returns (t : truc^3);
+node left(x : bool) returns (t : truc^3);
 let
         t[0].a[0..98 step 2][48..0 step -2] = true^25;	
 --      t[0].a[0..98 step 2][0..48 step 2] = true^25;	

test/should_work/map.lus

@@ -12,7 +12,7 @@ let
 	(* o = titi<<int>>(x,y); *)
 tel
 
-node tutu(x,y: real^4) returns (o: real^4);
+node map(x,y: real^4) returns (o: real^4);
 let
 	o = titi<<real>>(x,y);
 tel

test/should_work/multipar.lus

@@ -4,7 +4,7 @@
 
 node gup(x: int) returns (y:int);
 let
-   y = 2 * sil<< lis_bok >>(x);
+   y = 2 * sil<< multipar >>(x);
 tel
 
 node bok(x:int)returns(y:int);
@@ -22,6 +22,4 @@ let
    y = x * g(x);
 tel
 
-node lis_bok = lis <<bok>>;
-
-
+node multipar = lis <<bok>>;