C# et Array non dimensionné ?

C# et Array non dimensionné ? - C#/.NET managed - Programmation

Marsh Posté le 26-08-2005 à 22:33:41    

Salut, je suis en train d'écrire une classe "Node" me permettant de modéliser un graph.
 
Alors...
 
Une node comporte deux propriétés A et B
Une node peut être liée à d'autres nodes
 
J'ai donc commencé à écrire le code suivant :

Code :
  1. public class Node
  2. {
  3.  public int A, B;
  5.  private Node[] linkedNodes = new Node[];
  7.  Node(int a, int b)
  8.  {
  9.   this.A = a;
  10.   this.B = b;
  11.  }
  13.  public void LinkToNode(ref Node node)
  14.  {
  15.   LinkToNode(ref node, true);
  16.  }
  18.  protected void LinkToNode(ref Node node, bool canCallback)
  19.  {
  20.   if (node == this)
  21.   {
  22.    System.Exception exp = new System.Exception("Can't link a node to itself!" );
  23.   }
  25.   for (int i = 0; i < linkedNodes.Length; i++)
  26.   {
  27.    if (linkedNodes[i] == node)
  28.    {
  29.     return;
  30.    }
  31.   }
  33.   linkedNodes[linkedNodes.Length] = node;
  34.   if (canCallback)
  35.   {
  36.    Node nodeRef = this;
  37.    node.LinkToNode(ref nodeRef, false);
  38.   }
  39.  }
  40. }


 
Sauf qu'évidement, il n'aime pas "Node[] linkedNodes = new Node[];".
Si je ne fais pas de "new", alors il n'aime pas plus, il m'indique que pour pouvoir utiliser mon array, je dois l'avoir instancié avec un new.
Comment faire ?
 
Deplus, plutôt que me trimballer des "ref" un peu partout, j'aurais préféré utiliser des pointeurs. C'est quoi la différence d'ailleurs entre un "ref" et un pointeur ? Un "ref", ça correspond bien à un "*variable" ou si ça n'a rien à voir ? (si c'est le cas, alors ça devrait aller)
 
M'enfin mon vrai problème pour le moment, c'est ce array.
 
Ca m'ennuie de le dimensionner à l'avance, car non seulement je vais me retrouver avec une limitation en nombre de nodes liées à une node, mais en plus, et surtout, je sais pas trop ce que je vais mettre dedans ! Des valeurs "null" ?


Message édité par Arjuna le 26-08-2005 à 22:38:57
Reply

Marsh Posté le 26-08-2005 à 22:33:41   

Reply

Marsh Posté le 26-08-2005 à 22:52:54    

En tout cas, le "ref" fait pas ce que je veux...
 

Code :
  1. public class Node
  2. {
  3.  public int A, B;
  5.  private Node[] linkedNodes = new Node[10];
  7.  public Node(int a, int b)
  8.  {
  9.   this.A = a;
  10.   this.B = b;
  11.  }
  13.  public void LinkToNode(ref Node node)
  14.  {
  15.   LinkToNode(ref node, true);
  16.  }
  18.  protected void LinkToNode(ref Node node, bool canCallback)
  19.  {
  20.   if (node == this)
  21.   {
  22.    System.Exception exp = new System.Exception("Can't link a node to itself!" );
  23.   }
  25.   for (int i = 0; i < linkedNodes.Length; i++)
  26.   {
  27.    if (linkedNodes[i] == node)
  28.    {
  29.     return;
  30.    }
  31.   }
  33.   linkedNodes[0] = node;
  34.   if (canCallback)
  35.   {
  36.    Node refNode = this;
  37.    node.LinkToNode(ref refNode, false);
  38.   }
  39.  }
  41.  public override string ToString()
  42.  {
  43.   string ret = "";
  44.   for (int i = 0; i < linkedNodes.Length; i++)
  45.    if (linkedNodes[i] != null)
  46.     ret += linkedNodes[i].A + ", ";
  47.   return ret;
  48.  }
  50. }


 
Si le lance :

Code :
  1. Node a = new Node(0,0);
  2. a.LinkToNode(ref a);
  3. MessageBox.Show(a.ToString());


 
Ben ça affiche "0, " donc il n'a pas levé l'exception là où il aurait dû :/

Reply

Marsh Posté le 26-08-2005 à 23:04:24    

quel con, si, ça marche, c'est juste que je suis un gros blaireau :D
 
faut faire un throw de l'exception :D

Reply

Marsh Posté le 26-08-2005 à 23:05:56    

Pourquoi ne pas utiliser un ArrayList? :??:
La classe est prevue justement pour ce genre de chose.

Reply

Marsh Posté le 26-08-2005 à 23:10:14    

Bon, il ne me reste plus qu'à trouver comment faire un Array redimensionnable pour éviter de raiser l'exception exp3...
 

Code :
  1. public class Node
  2. {
  3.  public int A, B;
  5.  private Node[] linkedNodes = new Node[10];
  7.  public Node(int a, int b)
  8.  {
  9.   this.A = a;
  10.   this.B = b;
  11.  }
  13.  public void LinkToNode(ref Node node)
  14.  {
  15.   LinkToNode(ref node, true);
  16.  }
  18.  protected void LinkToNode(ref Node node, bool canCallback)
  19.  {
  20.   System.Exception exp = new System.Exception("Can't link a node to itself!" );
  21.   System.Exception exp2 = new System.Exception("Already linked!" );
  22.   System.Exception exp3 = new System.Exception("Linking array is full!" );
  23.   if (node == this)
  24.   {
  25.    throw exp;
  26.   }
  28.   for (int i = 0; i < linkedNodes.Length; i++)
  29.   {
  30.    if (linkedNodes[i] == node)
  31.    {
  32.     throw exp2;
  33.    }
  34.   }
  36.   for (int i = 0; i < linkedNodes.Length; i++)
  37.   {
  38.    if (linkedNodes[i] == null)
  39.    {
  40.     linkedNodes[0] = node;
  41.     if (canCallback)
  42.     {
  43.      Node refNode = this;
  44.      node.LinkToNode(ref refNode, false);
  45.     }
  46.     return;
  47.    }
  48.   }
  49.   throw exp3;
  50.  }
  52.  public override string ToString()
  53.  {
  54.   string ret = "(" + this.A.ToString() + ", " + this.B.ToString() + " ) is lined to :\n";
  55.   for (int i = 0; i < linkedNodes.Length; i++)
  56.    if (linkedNodes[i] != null)
  57.     ret += "   (" + linkedNodes[i].A.ToString() + ", " + linkedNodes[i].B.ToString() + " )\n";
  58.   return ret;
  59.  }
  61. }

Reply

Marsh Posté le 26-08-2005 à 23:17:09    

Arjuna a écrit :

Bon, il ne me reste plus qu'à trouver comment faire un Array redimensionnable pour éviter de raiser l'exception exp3...


T'aime pas les ArrayList ou l'équivalent en generics?
Dans system collection il a pas mal de structure de données toutes prêtes, pourquoi s'en passé [:core 666]
La tu va refaire la gestion d'un tableau de taille dynamique alors que le framework a deja ce qu'il te faut [:figti]


Message édité par chagarou le 26-08-2005 à 23:59:35
Reply

Marsh Posté le 26-08-2005 à 23:49:43    

ben c'est parceque je sais pas ce que c'est :D
 
je regarde ça :)
merci !

Reply

Marsh Posté le 27-08-2005 à 00:11:39    

Yes !
 
Merci, ça marche super bien :) :bounce:
 
Sinon, ma gestion d'erreurs, elle est pas trop pourrie ?
 

Code :
  1. using System;
  2. using System.Collections;
  3. using System.Windows.Forms;
  4. namespace MagicTrain.gameClass
  5. {
  6. public class Exceptions
  7. {
  8.  #region CustomException
  9.  public class ExceptionRecursiveLink : System.ArgumentException
  10.  {
  11.   public ExceptionRecursiveLink(string message) : base (message) {}
  12.  }
  13.  public class ExceptionAlreadyLinked : System.ArgumentException
  14.  {
  15.   public ExceptionAlreadyLinked(string message) : base (message) {}
  16.  }
  17.  public class ExceptionLinkArrayFull : System.ArgumentException
  18.  {
  19.   public ExceptionLinkArrayFull(string message) : base (message) {}
  20.  }
  21.  #endregion
  22. }
  23. public class Node
  24. {
  25.  public int A, B;
  27.  private ArrayList linkedNodes = new ArrayList();
  28. //  private Node[] linkedNodes = new Node[10];
  30.  public Node(int a, int b)
  31.  {
  32.   this.A = a;
  33.   this.B = b;
  34.  }
  36.  public void LinkToNode(ref Node node)
  37.  {
  38.   LinkToNode(ref node, true);
  39.  }
  41.  protected void LinkToNode(ref Node node, bool canCallback)
  42.  {
  43.   if (node == this)
  44.   {
  45.    throw new Exceptions.ExceptionRecursiveLink("A node can't be linked to itself!" );
  46.   }
  48.   for (int i = 0; i < linkedNodes.Count; i++)
  49.   {
  50.    if (((Node) linkedNodes[i]) == node)
  51.    {
  52.     throw new Exceptions.ExceptionAlreadyLinked("This link already exists!" );
  53.    }
  54.   }
  56.   try
  57.   {
  58.    linkedNodes.Add(node);
  59.    if (canCallback)
  60.    {
  61.     Node refNode = this;
  62.     node.LinkToNode(ref refNode, false);
  63.    }
  64.   }
  65.   catch (Exception e)
  66.   {
  67.    throw new Exceptions.ExceptionLinkArrayFull("Linking array is full!" );
  68.   }
  69.  }
  71.  public override string ToString()
  72.  {
  73.   string ret = "(" + this.A.ToString() + ", " + this.B.ToString() + " ) is lined to :\n";
  74.   for (int i = 0; i < linkedNodes.Count; i++)
  75.    if (((Node) linkedNodes[i]) != null)
  76.     ret += "   (" + ((Node) linkedNodes[i]).A.ToString() + ", " + ((Node) linkedNodes[i]).B.ToString() + " )\n";
  77.   return ret;
  78.  }
  80. }
  81. }


 

Code :
  1. static void Main()
  2.  {
  3.   MagicTrain.gameClass.Node a = new MagicTrain.gameClass.Node(0,0);
  4.   MagicTrain.gameClass.Node b = new MagicTrain.gameClass.Node(0,1);
  5.   MagicTrain.gameClass.Node c = new MagicTrain.gameClass.Node(1,0);
  6.   MagicTrain.gameClass.Node d = new MagicTrain.gameClass.Node(1,1);
  7.   MagicTrain.gameClass.Node e = new MagicTrain.gameClass.Node(2,0);
  8.   MagicTrain.gameClass.Node f = new MagicTrain.gameClass.Node(2,1);
  9.   MagicTrain.gameClass.Node g = new MagicTrain.gameClass.Node(3,0);
  10.   MagicTrain.gameClass.Node h = new MagicTrain.gameClass.Node(3,1);
  11.   MagicTrain.gameClass.Node i = new MagicTrain.gameClass.Node(4,0);
  12.   MagicTrain.gameClass.Node j = new MagicTrain.gameClass.Node(4,1);
  13.   MagicTrain.gameClass.Node k = new MagicTrain.gameClass.Node(5,0);
  14.   MagicTrain.gameClass.Node l = new MagicTrain.gameClass.Node(5,1);
  15.   try
  16.   {
  17.    a.LinkToNode(ref a);
  18.   }
  19.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  20.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  21.   try
  22.   {
  23.    a.LinkToNode(ref b);
  24.   }
  25.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  26.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  27.   try
  28.   {
  29.    a.LinkToNode(ref c);
  30.   }
  31.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  32.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  33.   try
  34.   {
  35.    a.LinkToNode(ref d);
  36.   }
  37.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  38.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  39.   try
  40.   {
  41.    a.LinkToNode(ref e);
  42.   }
  43.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  44.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  45.   try
  46.   {
  47.    b.LinkToNode(ref f);
  48.   }
  49.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  50.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  51.   try
  52.   {
  53.    b.LinkToNode(ref g);
  54.   }
  55.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  56.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  57.   try
  58.   {
  59.    b.LinkToNode(ref h);
  60.   }
  61.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  62.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  63.   try
  64.   {
  65.    b.LinkToNode(ref i);
  66.   }
  67.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  68.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  69.   try
  70.   {
  71.    b.LinkToNode(ref j);
  72.   }
  73.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  74.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  75.   try
  76.   {
  77.    b.LinkToNode(ref k);
  78.   }
  79.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  80.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  81.   try
  82.   {
  83.    b.LinkToNode(ref l);
  84.   }
  85.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  86.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  87.   try
  88.   {
  89.    b.LinkToNode(ref a);
  90.   }
  91.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull exp) {MessageBox.Show("Erreur fatale!\n\n" + exp.Message); return;}
  92.   catch (Exception exp) { MessageBox.Show("Erreur non bloquante :\n\n" + exp.Message); }
  93.   MessageBox.Show(a.ToString());
  94.   MessageBox.Show(b.ToString());
  95.   MessageBox.Show(c.ToString());
  96.   MessageBox.Show(d.ToString());
  97.   MessageBox.Show(e.ToString());
  98.   MessageBox.Show(f.ToString());
  99.   MessageBox.Show(g.ToString());
  100.   MessageBox.Show(h.ToString());
  101.   MessageBox.Show(i.ToString());
  102.   MessageBox.Show(j.ToString());
  103.   MessageBox.Show(k.ToString());
  104.   MessageBox.Show(l.ToString());
  105.  }

Reply

Marsh Posté le 27-08-2005 à 02:01:22    

# Node a = new Node(0,0);
#     a.LinkToNode(ref a);
 
c'est le truc le plus stupide que j'ai jamais vu ...

Reply

Marsh Posté le 27-08-2005 à 19:04:25    

Arjuna a écrit :


Deplus, plutôt que me trimballer des "ref" un peu partout, j'aurais préféré utiliser des pointeurs. C'est quoi la différence d'ailleurs entre un "ref" et un pointeur ? Un "ref", ça correspond bien à un "*variable" ou si ça n'a rien à voir ? (si c'est le cas, alors ça devrait aller)


Bon j'ai un peu de temps pour repondre a cette question, il existe deux types de type( [:ddr555] ) en csharp les types passés par référence, et ceux passés par valeur.
Les classes sont des types passés par référence, tu n'as donc pas besoin de te trainer des ref partout dans ton code.
 
Des petit bout de l'aide de csharp a ce sujet(comme toujours je te conseille fortement d'aller y mettre le nez dedans  :whistle: ):
 

Citation :

class
 
A reference type that encapsulates data (constants and fields) and behavior (methods, properties, indexers, events, operators, instance constructors, static constructors, and destructors), and can contain nested types. Class types support inheritance, a mechanism whereby a derived class can extend and specialize a base class. See also: encapsulation, indexer, property, reference type.
 
 
reference type  
 
A data type that is represented by a reference (similar to a pointer) to the type's actual value. If a reference type is assigned to a variable, that variable references (or "points to" ) the original value. No copy is made. Reference types comprise classes, interfaces, delegates, and boxed value types. See also: value type.
 
 
value type  
 
A data type that is represented by the type's actual value. If a value type is assigned to a variable, that variable is given a fresh copy of the value. (This is in contrast to a reference type, where assignment does not create a copy.) Value types are usually created on a method's stack frame, rather than in the garbage-collected heap. A value type can be boxed, which is a process that creates a corresponding reference type. See also: boxing, reference type, unboxing.


Message édité par chagarou le 27-08-2005 à 19:06:00
Reply

Marsh Posté le 27-08-2005 à 19:04:25   

Reply

Marsh Posté le 28-08-2005 à 14:10:33    

Taz a écrit :

# Node a = new Node(0,0);
#     a.LinkToNode(ref a);
 
c'est le truc le plus stupide que j'ai jamais vu ...


 
 
Ouais, Arjuna, c'est pas glop ta 2eme ligne (pkoi lier un node à lui meme ? tu risque de faire des boucle infinies en parcourant ton arbre. Pi, inutile de passer une ref).

Reply

Marsh Posté le 28-08-2005 à 18:29:49    

oliv5 a écrit :

Ouais, Arjuna, c'est pas glop ta 2eme ligne (pkoi lier un node à lui meme ? tu risque de faire des boucle infinies en parcourant ton arbre. Pi, inutile de passer une ref).


Peut être pour tester ce si ce code marche bien?
 

Code :
  1. if (node == this)
  2. {
  3.     throw new Exceptions.ExceptionRecursiveLink("A node can't be linked to itself!" );
  4. }

Reply

Marsh Posté le 28-08-2005 à 18:39:13    

chagarou a écrit :

Peut être pour tester ce si ce code marche bien?
 

Code :
  1. if (node == this)
  2. {
  3.     throw new Exceptions.ExceptionRecursiveLink("A node can't be linked to itself!" );
  4. }



C'est à ça que servent les tests unitaires normalement [:pingouino]


---------------
Stick a parrot in a Call of Duty lobby, and you're gonna get a racist parrot. — Cody
Reply

Marsh Posté le 29-08-2005 à 00:11:00    

Taz a écrit :

# Node a = new Node(0,0);
#     a.LinkToNode(ref a);
 
c'est le truc le plus stupide que j'ai jamais vu ...


C'est pas stupide, c'est un test.
Quand j'aurai mon prog terminé, je ne suis pas à l'abrit d'une tentative d'une telle référence.
 
Je veux coder un jeu où une personne va construire une voie ferrée. Je ne suis pas à l'abri qu'un blaireau tente de créer un point dans sa ligne, puis tenter de faire un rail qui tourne sur lui-même pour revenir à ce point, sans passer par un autre point. :spamafote:

Reply

Marsh Posté le 29-08-2005 à 00:19:06    

Sinon, pour le coup du ref et pas ref, y'a un truc qui me choque quand même.
 
Bon, déjà, je viens du VB, et en VB, une class aussi est passée par référence. Mais si on stipule explicitement ByVal ou ByRef, alors le comportement est différent, même si le ByVal reste de la référence.
 
Explication :
 
ByRef sur une class, ca veut dire que si je modifie les attributs de mon objets via le lien (ou pointeur) passé ByRef, alors ça modifie l'objet.
Si je tue l'objet (= Nothing) alors je détruis l'objet.
 
ByVal, ça marche pareil, sauf que si j'affecte à Nothing, je ne fait que détruire le pointeur, l'objet original reste actif. Y'a une autre différence, mais je ne sais plus laquelle (en tout cas, y'a pas de recopie, dans aucun des deux cas).
 
Vu qu'en C#, à partir du moment où on tente de passer un objet sans mettre ref alors qu'il est déclaré ref dans la méthode, il plante à la compilation. J'en déduis que lui aussi doit avoir un mécanisme qui diffère si on passe ByRef ou non.
 
Ceci dit, en écrivant ces lignes, je m'apperçois que c'est plutôt le comportement VB "ByVal" que je veux : je dois pouvoir déduire un lien entre deux nodes sans détruire la node liée... Donc mes ref semble erronés. En tout cas, je suis presque certain que le comportement diffère, ou alors y'a un souci dans le compilo.


Message édité par Arjuna le 29-08-2005 à 00:21:19
Reply

Marsh Posté le 29-08-2005 à 00:20:03    

masklinn a écrit :

C'est à ça que servent les tests unitaires normalement [:pingouino]


Bah oui, je voulais juste vérifier que l'exception se levait bien en cas d'erreur.

Reply

Marsh Posté le 29-08-2005 à 00:27:56    

Ah, oui, la différence entre ByVal et ByRef sur un objet en VB, c'est qu'on peut réaffecter un pointeur passé ByVal, mais pas un pointeur passé ByRef
Si je réaffecte un nouvel objet à une variable ByRef, alors je tue l'objet initial, et je le recrée avec sa nouvelle déclaration (scope global).
Si je réaffecte un nouvell objet à une variable ByVal, le lien se brise, l'objet original reste, et je crée un nouvel objet de scope local.
 
En y repensant, je suis sûr que ça fait pareil en C#, j'essaierai demain :
 
public class toto
{
   public string val;
   public toto(string val)
   {
      this.val = val
   }
 
   public string testequitue(ref toto link, string newVal)
   {
      link = new toto(newVal);
      return link.val;
   }
}
 
toto v1 = new toto("v1" );
Console.Write(toto.testquitue(ref toto, "v2" ));
Console.Write(toto.val);
 
=> Normalement, il affiche "v2v2"
 
Si je vire les "ref", alors normalement, à la sortie, "v2v1" devrait s'afficher.
 
par contre, dans les deux cas, qui le "testquitue" fait avant le new
 
link.val = newVal;
 
=> à la sortie, l'objet toto sera dans les deux cas modifié


Message édité par Arjuna le 29-08-2005 à 00:31:50
Reply

Marsh Posté le 29-08-2005 à 00:35:18    

Arjuna a écrit :

Bah oui, je voulais juste vérifier que l'exception se levait bien en cas d'erreur.


Et c'est le rôle des tests unitaires bordel [:pingouino]


---------------
Stick a parrot in a Call of Duty lobby, and you're gonna get a racist parrot. — Cody
Reply

Marsh Posté le 29-08-2005 à 02:23:43    

( jme fais tapper si je dis que c'est quand même vachement plus simple la notation pointeurs/* ? )


---------------
Me: Django Localization, Yogo Puzzle, Chrome Grapher, C++ Signals, Brainf*ck.
Reply

Marsh Posté le 29-08-2005 à 10:59:41    

masklinn a écrit :

Et c'est le rôle des tests unitaires bordel [:pingouino]


Et c'est quoi ça justement ?.

Reply

Marsh Posté le 29-08-2005 à 11:00:55    

0x90 a écrit :

( jme fais tapper si je dis que c'est quand même vachement plus simple la notation pointeurs/* ? )


Justement, ça marche pas, et si je ne m'abuse, c'est ma question initiale...
 
(mais comme d'hab, les gens préfèrent critiquer la façon de coder plutôt que répondre à la question... c'est pas toujours inintéressant, mais ça sert pas toujours à grand chose si on n'a pas de réponse à sa question initiale...)

Reply

Marsh Posté le 29-08-2005 à 11:21:55    

Arjuna a écrit :

Et c'est quoi ça justement ?.


Grosso merdo, ce sont les tests de validité d'une fonction, d'une classe, d'un objet, ...
 
Le principe, c'est qu'avant de créer un élément tu connais ses entrées/sorties et les réactions que sont censées avoir ses méthodes aux différents évènements (que ce soient des réussites, des algos ou des erreurs/exceptions).
 
Donc tu crées des ensembles de tests pour vérifier si l'objet réagit bien comme il le doit (lance des erreurs quand il devrait planter et sort ce qu'il devrait sortir).
 
T'es censé faire ça pour tous tes objets, et pour tous les cas d'utilisation (tu peux en oublier, naturellement, et quand tu t'en rends compte tu crées de nouveaux tests pour vérifier ce que tu avais oublié).
 
Ca permet d'être sûr que tes objets se comportement correctement quelles que soient les modifications que tu y apportes.
 
Dans les méthodologies agiles, et XP en particulier, les tests unitaires doivent même être écrits avant les objets testés (ou en parallèle): ils sont à la vois le carcan, le guide et la documentation de l'objet.
 
http://www.sdmagazine.com/columnists/martin/
pour une introduction romancée à la chose
http://butunclebob.com/ArticleS.UncleBob
pour un peu plus d'infos


---------------
Stick a parrot in a Call of Duty lobby, and you're gonna get a racist parrot. — Cody
Reply

Marsh Posté le 29-08-2005 à 12:26:30    

Je te demande pas ce qu'est un test unitaire, j'en fais suffisament comme ça pour savoir exactement ce que c'est :o
 
Quand j'ai une fonction qui ne contiens rien que des trucs censés faires planter ma class, ou exploiter ce qu'elle fait, le tout codé à la fois en dur et avec des noms de variables bidons, je te demande justement à quoi ça te fait penser :o

Reply

Marsh Posté le 29-08-2005 à 12:27:31    

Arjuna a écrit :


Si le lance :

Code :
  1. Node a = new Node(0,0);
  2. a.LinkToNode(ref a);
  3. MessageBox.Show(a.ToString());


 
Ben ça affiche "0, " donc il n'a pas levé l'exception là où il aurait dû :/


 
=> C'est pourtant suffisament explicite ! Je cherchais bien a faire planter ma classe et vérifiant que l'exception à propos des liens en boucles...

Reply

Marsh Posté le 29-08-2005 à 12:29:29    

Au fait, dans un catch, je me rends compte que l'exception levée n'est pas bloquante, je peux faire un résume du code dans le try ou pas ?
 
Comme le "continue" après un break si mes souvenirs sont bons.
 
En VB, c'est "Resume Next"
 
Parceque faire des try {} catch {} à chaque instruction, c'est un peu lourd...


Message édité par Arjuna le 29-08-2005 à 12:31:09
Reply

Marsh Posté le 29-08-2005 à 12:38:46    

Arjuna a écrit :

Je te demande pas ce qu'est un test unitaire, j'en fais suffisament comme ça pour savoir exactement ce que c'est :o


T'as qu'à être clair dans tes réponses, et aprendre à faire des quotes et des multiquotes :o

Citation :

Quand j'ai une fonction qui ne contiens rien que des trucs censés faires planter ma class, ou exploiter ce qu'elle fait, le tout codé à la fois en dur et avec des noms de variables bidons, je te demande justement à quoi ça te fait penser :o


À une émulation d'un vrai framework de tests unitaire qui fonctionne [:gratgrat]


---------------
Stick a parrot in a Call of Duty lobby, and you're gonna get a racist parrot. — Cody
Reply

Marsh Posté le 29-08-2005 à 14:25:09    

1) C'est pas à moi de répéter 25 fois ce que je viens de dire. Depuis mes deux premiers posts, je pense avoir été suffisament explicite quant à mes tests. Ca se voit à 20 kilomètres que je fais des tests sur ma class.
 
2) Généralement, moi c'est comme ça que je bosse : je cherche pas à faire la class d'un coup, j'avance points par point et je rempli une fonction de tests au fur et à mesure que j'ajoute des cas. Donc il est impossible que mon truc ait une tête de framework avant même qu'il soit écrit. Je rappelle aussi que je débute en C#, mais aussi niveau algo : le cheminement dans un graph, j'ai vu ça en maths à l'IUT, et j'ai non seulement jamais mis en pratique, mais en plus j'ai tout oublié. Par conséquent, j'aurai du mal à faire un code nickel chrome comme ça...
 
Là, ma class node est très loin d'être terminée, d'autant plus qu'afin d'optimiser le finding path computing, je veux que chaque node indique en interne quelles nodes suivre pour aller vers une node précise, ainsi que la distance. Rien que pour ça, j'ai réfléchis des heures dessus, et je n'ai aucune idée de comment faire... L'initialisation, c'est chaud, mais surtout, quand je supprime une node, ou que j'en ajoute une au milieu d'un lien existant, il faut impacter ces valeurs sans recalculer tout l'arbre.
 
En effet, ce que je veux modéliser dans ce graph, c'est un réseau ferroviaire. Vu qu'il y aura virtuellement des centaines de train, et certainement plusieur dizaines de milliers de nodes, je dois impérativement optimiser au maximum la recherche du plus court chemin disponible pour me rendre d'une gare à une autre : c'est à dire que je ne dois pas me contenter de suivre le plus court chemin, si un train plus lent est déjà engagé sur la voie, ou vient en sens inverse, je dois tenter de trouver une alternative... Rechercher le chemin dans un tel graph à chaque passage à une node (parceque les trains ça bouge, donc le meilleur chemin peut évoluer dans le temps), c'est la mort, ça n'avancera pas.
Mais si au contraire je fais une usine à gaz lors de la création de chaque node, c'est le contraire, le joueur ne pourra pas modéliser ses voies dans de bonnes conditions.
 
Bref, la tannée :D
 
Sans compter que si une node A est liée à une node B, et que cette dernière est liée à une node C, le chemin pour aller de A à C n'existe pas forcément, à cause du sens d'embranchement des voies. Encore un truc que je dois résoudre, et là c'est pas gagné :D


Message édité par Arjuna le 29-08-2005 à 14:27:29
Reply

Marsh Posté le 29-08-2005 à 14:33:51    

Arjuna a écrit :

1) C'est pas à moi de répéter 25 fois ce que je viens de dire. Depuis mes deux premiers posts, je pense avoir été suffisament explicite quant à mes tests. Ca se voit à 20 kilomètres que je fais des tests sur ma class.


Et pourtant, marrant, personne a l'air d'avoir compris ça [:pingouino]

Citation :

2) Généralement, moi c'est comme ça que je bosse : je cherche pas à faire la class d'un coup, j'avance points par point et je rempli une fonction de tests au fur et à mesure que j'ajoute des cas. Donc il est impossible que mon truc ait une tête de framework avant même qu'il soit écrit.


Et alors?
Je vois pas en quoi ça empêche d'utiliser les frameworks de tests unitaires existants (NUnit ou CSUnit en C#) [:pingouino]
 
Ni même d'écrire les tests avant d'avoir implémenté les actions dans la classe [:pingouino]
 
edit: tu devrais aller voir les liens que je t'ai filés, quand même [:pingouino]


Message édité par masklinn le 29-08-2005 à 14:35:31

---------------
Stick a parrot in a Call of Duty lobby, and you're gonna get a racist parrot. — Cody
Reply

Marsh Posté le 29-08-2005 à 15:15:26    

Ben voilà, au lieu de me parler de tests unitaire, donne l'info complète. Il s'agit donc d'une fonction de VS. C'est peut-être ça le plus intéressant dans ton post non ?
 
Ceci dit, franchement, je ne vois pas l'intérêt d'utiliser ces trucs, m'enfin si ça peut te faire plaisir, je peux toujours aller voir à quoi ça ressemble.
 
Sinon, là je suis au boulot. Je suis allé vite fait suivre tes liens et euh... Nan, pas moyen, je me coltine pas les 25 articles qu'il y a sur chaque page pour trouver lequel est intéressant... Si t'avais un lien direct vers l'utilisation de ces trucs, ça m'arrangerait un peu.
 
J'en chie déjà assez avec l'algo pour pas m'emmerder à passer la soirée à chaque fois que je veux me documenter sur un truc.

Reply

Marsh Posté le 29-08-2005 à 15:22:30    

Arjuna a écrit :

Ben voilà, au lieu de me parler de tests unitaire, donne l'info complète. Il s'agit donc d'une fonction de VS. C'est peut-être ça le plus intéressant dans ton post non ?


C'est pas une fonction de Visual Studio [:pingouino]
 
Ptin, tu me dis que tu connais les tests unitaires mais tu ne sais même pas qu'existent des frameworks de test [:petrus dei]

Citation :

Ceci dit, franchement, je ne vois pas l'intérêt d'utiliser ces trucs, m'enfin si ça peut te faire plaisir, je peux toujours aller voir à quoi ça ressemble.


À automatiser et systémiser les tests unitaires et à disposer d'un ensemble de fonctions d'assertions standard [:petrus75]

Citation :

Sinon, là je suis au boulot. Je suis allé vite fait suivre tes liens et euh... Nan, pas moyen, je me coltine pas les 25 articles qu'il y a sur chaque page pour trouver lequel est intéressant... Si t'avais un lien direct vers l'utilisation de ces trucs, ça m'arrangerait un peu.


Ce ne sont pas des tutoriels, ce sont des présentations "en cas réel" sur la méthodologie XP, vu que tu ne sembles pas savoir comment ça fonctionne [:jagstang]

Citation :

J'en chie déjà assez avec l'algo pour pas m'emmerder à passer la soirée à chaque fois que je veux me documenter sur un truc.


[:petrus75]


---------------
Stick a parrot in a Call of Duty lobby, and you're gonna get a racist parrot. — Cody
Reply

Marsh Posté le 29-08-2005 à 15:54:43    

Bon, ben écoute. Désolé de te décevoir, mais je ne vois pas à quoi ça pourrait me servir ton truc si c'est juste encapsuler mes tests dans une classe spécifique.
 
Je suis pas en train de faire un FrameWork, je fais juste une classe qui va me servir pour mon programme. J'ai rien à redistribuer, et une fois mes tests validés, je n'ai aucune utilité de les garder dans un coin.
 
On a chacun notre méthode pour faire les tests unitaires, et visiblement c'est pas la même. Moi, je bosse tout seul, alors faire un truc super découpé dans tous les sens et super architecturé, ça me servira à rien mise à part me faire perdre mon temps. L'important dans un jeu de test, c'est qu'il soit réfléchit et éxécuté avec succès. Point :spamafote:

Reply

Marsh Posté le 29-08-2005 à 17:25:54    

Arjuna a écrit :

Bon, ben écoute. Désolé de te décevoir, mais je ne vois pas à quoi ça pourrait me servir ton truc si c'est juste encapsuler mes tests dans une classe spécifique.


C'est justement le but, une architecture de test stable, avec des helpers pour facilement mettre en place les tests [:klem3i1]
 
Ce qui permet entre autre de lancer une suite de 500 ou 600 tests en une seule commande [:klem3i1]

Citation :

une fois mes tests validés, je n'ai aucune utilité de les garder dans un coin.


Bien sûr que si, tu vas construire des structures sur tes structures existantes, tu vas résoudre des bugs, tu vas modifier des classes... conserver et activer fréquement ses tests unitaires permet d'être sûr qu'on ne "casse" pas un module, et permet de savoir aisément ce qui a cassé.
 
De plus tout bug ou problème détecté résulte en la génération de tests unitaires (afin de vérifier, après patch, que le problème a bien été résolu) qui jouent simultanément le rôle de tests de non régression [:spamafote]

Citation :

c'est qu'il soit réfléchit et éxécuté avec succès


Et qu'il reste exécuté avec succès [:spamafote]  


---------------
Stick a parrot in a Call of Duty lobby, and you're gonna get a racist parrot. — Cody
Reply

Marsh Posté le 29-08-2005 à 18:28:53    

Arjuna a écrit :

Au fait, dans un catch, je me rends compte que l'exception levée n'est pas bloquante, je peux faire un résume du code dans le try ou pas ?
 
Comme le "continue" après un break si mes souvenirs sont bons.
 
En VB, c'est "Resume Next"
 
Parceque faire des try {} catch {} à chaque instruction, c'est un peu lourd...


 
Le probleme fondamentale, c'est que C# n'est pas VB (..,4,5,6) et qu'il permet de faire des choses bien plus puissantes et propres, il ne faut pas raisonner de la meme maniere entre les 2 langage et prendre au moins les bases du C# (concernant les passage par reference ou par valeur... -> MSDN)
 
D'ailleur, si VB.Net tranche radicalement des précédentes version de VB, c'est qu'il est calqué sur le fonctionnement du C# (même s'il reste toujours possible de faire des choses tordues à la sauce VB)
 
 
Le Resume next etait une horreur du VB, à bannir autant que les GOTO... s'il y a exception, il faut la gerer et basta, ou alors c'est que le code est mal pensé...
 
 
dans toutes fonction on devrait retrouver une structure  
 

Code :
  1. try
  2. {
  3. [...]
  4. }
  5. catch(SpecificException exp_spec)
  6. {
  7. [...]
  8. }
  9. catch(Exception exp_generale)
  10. {
  11. [...]
  12. }
  13. finally
  14. {
  15. [...]
  16. }


 
C'est pas plus compliqué, et ça evite bien des erreurs :)

Reply

Marsh Posté le 29-08-2005 à 19:01:24    

Le seul souci avec ton système, c'est que je veux gérer les "warning" comme des exceptions.
 
Par exemple, si l'utilisateur tente de faire une action interdite, je veux que dans mon code ça gère une exception, afin de traîter l'action proprement, et sans mettre des tests à toutes les sauces.
 
Hors, dans le cas d'un warning, moi je veux pas planter l'éxécution du code, et encore moins foutre des erreur handlers toutes les lignes, si le Resume Next utilisé à mauvais escient ("On Error Resume Next" ) il s'avère à la fois très propre et sûre quand on l'utilise correctement dans l'EventHandler.
Et je suis parfaîtement sûr qu'il existe un équivalent en C#, tout comme le "continue" dans un Break (qui pourtant est autrement plus pourri !)

Reply

Marsh Posté le 29-08-2005 à 20:42:05    

Bon, histoire de faire plaisir à Masklinn, j'ai fait une classe de tests, sinon il va bouder dans son coin et va plus m'aider :o
 
Sauf que là, y'a un léger souci ! Ca fait total n'importe quoi !
 
Il lance des bouts de code dans tous les sens n'importe comment !!!
C'est quoi ce délire ?
 
Voici le code de ma class "Node" et des exceptions qui vont avec :

Code :
  1. /// <summary>
  2. /// This class contains Exceptions that can be raised from this namespace
  3. /// </summary>
  4. public class Exceptions
  5. {
  6.  #region CustomException
  7.  public class ExceptionRecursiveLink : System.ArgumentException
  8.  {
  9.   public ExceptionRecursiveLink(string message) : base (message) {}
  10.  }
  11.  public class ExceptionAlreadyLinked : System.ArgumentException
  12.  {
  13.   public ExceptionAlreadyLinked(string message) : base (message) {}
  14.  }
  15.  public class ExceptionLinkArrayFull : System.ArgumentException
  16.  {
  17.   public ExceptionLinkArrayFull(string message) : base (message) {}
  18.  }
  19.  #endregion
  20. }
  22. /// <summary>
  23. /// This class represents a node that can be linked to other nodes
  24. /// </summary>
  25. public class Node
  26. {
  27.  public string name;
  29.  private ArrayList linkedNodes = new ArrayList();
  31.  /// <summary>
  32.  /// Creates a node
  33.  /// </summary>
  34.  /// <param name="Name">Node's name</param>
  35.  public Node(string Name)
  36.  {
  37.   this.name = Name;
  38.  }
  40.  /// <summary>
  41.  /// Link to another node
  42.  /// </summary>
  43.  /// <exception cref="Exceptions.ExceptionRecursiveLink">
  44.  /// Raised if the link tries to link itself
  45.  /// </exception>
  46.  /// <exception cref="Exceptions.ExceptionAlreadyLinked">
  47.  /// Raised if the two nodes are already linked together
  48.  /// </exception>
  49.  /// <exception cref="Exceptions.ExceptionLinkArrayFull">
  50.  /// Raised if the linking table is full
  51.  /// </exception>
  52.  /// <remarks>
  53.  /// A node can't be linked to itself.
  54.  /// If a link already exists, a exception will be raised.
  55.  /// </remarks>
  56.  /// <param name="node">
  57.  /// Node to link with
  58.  /// </param>
  59.  public void LinkToNode(Node node)
  60.  {
  61.   LinkToNode(node, true);
  62.  }
  64.  /// <summary>
  65.  /// Same as previous declaration, but for internal use only
  66.  /// </summary>
  67.  /// <param name="node">Node to link with</param>
  68.  /// <param name="canCallback">If true, then the linked node is allowed to link itself to this node</param>
  69.  protected void LinkToNode(Node node, bool canCallback)
  70.  {
  71.   if (node == this)
  72.   {
  73.    throw new Exceptions.ExceptionRecursiveLink("A node can't be linked to itself!" );
  74.   }
  76.   for (int i = 0; i < linkedNodes.Count; i++)
  77.   {
  78.    if (((Node) linkedNodes[i]) == node)
  79.    {
  80.     throw new Exceptions.ExceptionAlreadyLinked("This link already exists!" );
  81.    }
  82.   }
  84.   try
  85.   {
  86.    if (canCallback)
  87.    {
  88.     node.LinkToNode(this, false);
  89.    }
  90.    linkedNodes.Add(node);
  91.   }
  92.   catch (StackOverflowException e)
  93.   {
  94.    throw new Exceptions.ExceptionLinkArrayFull("Linking array is full!" );
  95.   }
  96.  }
  98.  /// <summary>
  99.  /// Unlink two nodes
  100.  /// </summary>
  101.  /// <param name="node">Linked node to remove</param>
  102.  public void UnLinkNode(Node node)
  103.  {
  104.   this.UnLinkNode(node, true);
  105.  }
  107.  /// <summary>
  108.  /// Same as previous declaration, but for internal use only
  109.  /// </summary>
  110.  /// <param name="node">Linked node to remove</param>
  111.  /// <param name="canCallback">If true, the the unlinked node is allowed to unlink itself from this node</param>
  112.  protected void UnLinkNode(Node node, bool canCallback)
  113.  {
  114.   // This method can't raise error
  115.   if (canCallback)
  116.   {
  117.    node.UnLinkNode(node, false);
  118.   }
  119.   linkedNodes.Remove((object) node);
  120.  }
  122.  /// <summary>
  123.  /// Displays this node in string format
  124.  /// </summary>
  125.  /// <returns>User-friendly representation of the node</returns>
  126.  public override string ToString()
  127.  {
  128.   string ret = this.name + " is lined to :\n";
  129.   for (int i = 0; i < linkedNodes.Count; i++)
  130.    if (((Node) linkedNodes[i]) != null)
  131.     ret += "   " + ((Node) linkedNodes[i]).name + "\n";
  132.   return ret;
  133.  }
  134. }


 
La class de test (et va pas dire que c'est pas ce qu'il faut faire sinon je t'étripe et je te noie dans ton sang :o)

Code :
  1. /// <summary>
  2. /// Test class contains unit tests to help validating the program components work.
  3. /// </summary>
  4. public class test
  5. {
  6.  /// <summary>
  7.  /// Global test method : use it to test all the components.
  8.  /// </summary>
  9.  public test()
  10.  {
  11.  }
  13.  /// <summary>
  14.  /// Launchs all tests and returns true is all tests are OK
  15.  /// </summary>
  16.  /// <returns>
  17.  /// True : Everyting is OK
  18.  /// False : A test was not validated
  19.  /// </returns>
  20.  public bool runTests()
  21.  {
  22.   bool everythingIsOk = true;
  23.   Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));
  24.   Debug.AutoFlush = true;
  25.   Debug.WriteLine("Launch global test battery" );
  27.   worldTest wTest = new worldTest();
  28.   everythingIsOk &= wTest.testRecursiveLink();
  29.   everythingIsOk &= wTest.testAlredayLinked();
  30.   everythingIsOk &= wTest.testLinkArrayFull();
  31.   wTest.terminate();
  32.   Debug.WriteLine("Finish global test battery" );
  33.   wTest = null;
  34.   Debug.Close();
  35.   return everythingIsOk;
  36.  }
  37. }
  39. public class worldTest
  40. {
  41.  Node[] arrNodes = new Node[5];
  43.  /// <summary>
  44.  /// Create the worldTest environment
  45.  /// </summary>
  46.  public worldTest()
  47.  {
  48.   Debug.Indent();
  49.   Debug.WriteLine("Create worldTest environment" );
  50.   Debug.WriteLine("Create " + arrNodes.Length.ToString() + " nodes" );
  51.   for (int i = 0; i < arrNodes.Length; i++)
  52.   {
  53.    arrNodes[i] = new Node("Automatic node generated numuber " + i.ToString());
  54.   }
  55.   Debug.WriteLine("worldText environment created successfully" );
  56.  }
  58.  /// <summary>
  59.  /// Write in debug console test is over
  60.  /// </summary>
  61.  public void terminate()
  62.  {
  63.   for (int i = 0; i < arrNodes.Length; i++)
  64.   {
  65.    arrNodes[i] = null;
  66.   }
  67.   Debug.WriteLine("Destroying worldTest environment" );
  68.   Debug.Unindent();
  69.  }
  71.  /// <summary>
  72.  /// Check if RecursiveLink exception can be raised
  73.  /// </summary>
  74.  /// <returns>
  75.  /// True : exception correclty raised
  76.  /// False : exception was not raised
  77.  /// </returns>
  78.  public bool testRecursiveLink()
  79.  {
  80.   bool exceptionRaised = false;
  82.   Debug.Indent();
  83.   Debug.WriteLine("Launch testRecursiveLink test" );
  84.   Debug.Indent();
  85.   try
  86.   {
  87.    arrNodes[0].LinkToNode(arrNodes[0]);
  88.    Debug.WriteLine("(E) ExceptionRecursiveLink exception was not raised !" );
  89.    arrNodes[0].UnLinkNode(arrNodes[0]);
  90.   }
  91.   catch (MagicTrain.gameClass.Exceptions.ExceptionRecursiveLink e)
  92.   {
  93.    exceptionRaised = true;
  94.    Debug.WriteLine("(I) ExceptionRecursiveLink exception correctly raised" );
  95.   }
  96.   catch (Exception e)
  97.   {
  98.    Debug.WriteLine("(E) Unexpected exception was raised !" );
  99.    Debug.WriteLine("==> " + e.ToString() + " : " + e.Message);
  100.   }
  101.   Debug.Unindent();
  102.   Debug.WriteLine("Finish testRecursiveLink test" );
  103.   Debug.Unindent();
  104.   return exceptionRaised;
  105.  }
  107.  /// <summary>
  108.  /// Check if AlredayLinked exception can be raised
  109.  /// </summary>
  110.  /// <returns>
  111.  /// True : exception correclty raised
  112.  /// False : exception was not raised
  113.  /// </returns>
  114.  public bool testAlredayLinked()
  115.  {
  116.   bool exceptionRaised = false;
  118.   Debug.Indent();
  119.   Debug.WriteLine("Launch testAlredayLinked test" );
  120.   Debug.Indent();
  121.   try
  122.   {
  123.    arrNodes[0].LinkToNode(arrNodes[1]);
  124.    arrNodes[0].LinkToNode(arrNodes[1]);
  125.    Debug.WriteLine("(E) ExceptionAlreadyLinked exception was not raised !" );
  126.    arrNodes[0].UnLinkNode(arrNodes[1]);
  127.   }
  128.   catch (MagicTrain.gameClass.Exceptions.ExceptionAlreadyLinked e)
  129.   {
  130.    exceptionRaised = true;
  131.    arrNodes[0].UnLinkNode(arrNodes[1]);
  132.    Debug.WriteLine("(I) ExceptionAlreadyLinked exception correctly raised" );
  133.   }
  134.   catch (Exception e)
  135.   {
  136.    Debug.WriteLine("(E) Unexpected exception was raised !" );
  137.    Debug.WriteLine("==> " + e.ToString() + " : " + e.Message);
  138.   }
  139.   Debug.Unindent();
  140.   Debug.WriteLine("Finish testAlredayLinked test" );
  141.   Debug.Unindent();
  142.   return exceptionRaised;
  143.  }
  145.  /// <summary>
  146.  /// Check if LinkArrayFull exception can be raised (not mandatory test)
  147.  /// </summary>
  148.  /// <returns>Always true</returns>
  149.  public bool testLinkArrayFull()
  150.  {
  151.   bool exceptionRaised = false;
  153.   Debug.Indent();
  154.   Debug.WriteLine("Launch testLinkArrayFull test" );
  155.   Debug.Indent();
  156.   try
  157.   {
  158.    for (int i = 0; i < arrNodes.Length; i++)
  159.    {
  160.     for (int j = i + 1; j < arrNodes.Length; j++)
  161.     {
  162.      arrNodes[i].LinkToNode(arrNodes[j]);
  163.      Debug.WriteLine(i.ToString() + " <->" + j.ToString());
  164.     }
  165.    }
  166.    Debug.WriteLine("(E) ExceptionLinkArrayFull exception was not raised !" );
  167.    // This exception should never occurs, so we don't bother it is raised or not
  168.    exceptionRaised = true;
  169.    for (int i = 0; i < arrNodes.Length; i++)
  170.    {
  171.     for (int j = i + 1; j < arrNodes.Length; j++)
  172.     {
  173.      arrNodes[i].UnLinkNode(arrNodes[j]);
  174.     }
  175.    }
  176.   }
  177.   catch (MagicTrain.gameClass.Exceptions.ExceptionLinkArrayFull e)
  178.   {
  179.    exceptionRaised = true;
  180.    for (int i = 0; i < arrNodes.Length; i++)
  181.    {
  182.     for (int j = i + 1; j < arrNodes.Length; j++)
  183.     {
  184.      arrNodes[i].UnLinkNode(arrNodes[j]);
  185.     }
  186.    }
  187.    Debug.WriteLine("(I) ExceptionLinkArrayFull exception correctly raised" );
  188.   }
  189.   catch (Exception e)
  190.   {
  191.    for (int i = 0; i < arrNodes.Length; i++)
  192.    {
  193.     for (int j = i + 1; j < arrNodes.Length; j++)
  194.     {
  195.      arrNodes[i].UnLinkNode(arrNodes[j]);
  196.     }
  197.    }
  198.    Debug.WriteLine("(E) Unexpected exception was raised !" );
  199.    Debug.WriteLine("==> " + e.ToString() + " : " + e.Message);
  200.   }
  201.   Debug.Unindent();
  202.   Debug.WriteLine("Finish testLinkArrayFull test" );
  203.   Debug.Unindent();
  204.   return exceptionRaised;
  205.  }
  206. }


 
Et enfin, le lancement des tests dans le Main de mon projet :

Code :
  1. /// <summary>
  2.  /// The main entry point for the application.
  3.  /// </summary>
  4.  static void Main()
  5.  {
  6.   MagicTrain.testClass.test unitTests = new MagicTrain.testClass.test();
  7.   if (unitTests.runTests())
  8.   {
  9.    MessageBox.Show("All classes tested successfully !" );
  10.   }
  11.   else
  12.   {
  13.    MessageBox.Show("One or more tests were not working correctly !" );
  14.   }
  15.  }


 
Sortie DEBUG :

Code :
  1. 'DefaultDomain': Loaded 'g:\windows\microsoft.net\framework\v1.1.4322\mscorlib.dll', No symbols loaded.
  2. 'MagicTrain': Loaded 'G:\Documents and Settings\MagicBuzz\Mes documents\Visual Studio Projects\MagicTrain\MagicTrain\bin\Debug\MagicTrain.exe', Symbols loaded.
  3. 'MagicTrain.exe': Loaded 'g:\windows\assembly\gac\system.windows.forms\1.0.5000.0__b77a5c561934e089\system.windows.forms.dll', No symbols loaded.
  4. 'MagicTrain.exe': Loaded 'g:\windows\assembly\gac\system\1.0.5000.0__b77a5c561934e089\system.dll', No symbols loaded.
  5. 'MagicTrain.exe': Loaded 'g:\windows\assembly\gac\system.xml\1.0.5000.0__b77a5c561934e089\system.xml.dll', No symbols loaded.
  6. Launch global test battery
  7.     Create worldTest environment
  8.     Create 5 nodes
  9.     worldText environment created successfully
  10.         Launch testRecursiveLink test
  11. Launch global test battery
  12.     Create worldTest environment
  13.     Create 5 nodes
  14.     worldText environment created successfully
  15.         Launch testRecursiveLink test
  16.             (I) ExceptionRecursiveLink exception correctly raised
  17.         Finish testRecursiveLink test
  18.         Launch testAlredayLinked test
  19.                 (I) ExceptionRecursiveLink exception correctly raised
  20.         Finish testRecursiveLink test
  21.         Launch testAlredayLinked test
  22.             (I) ExceptionAlreadyLinked exception correctly raised
  23.         Finish testAlredayLinked test
  24.         Launch testLinkArrayFull test
  25.             (E) Unexpected exception was raised !
  26.         (I) ExceptionAlreadyLinked exception correctly raised
  27.         Finish testAlredayLinked test
  28.         Launch testLinkArrayFull test
  29.             (E) Unexpected exception was raised !
  30.             ==> ExceptionAlreadyLinked: This link already exists!
  31.    at MagicTrain.gameClass.Node.LinkToNode(Node node, Boolean canCallback) in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\world.cs:line 96
  32.    at MagicTrain.gameClass.Node.LinkToNode(Node node, Boolean canCallback) in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\world.cs:line 104
  33.    at MagicTrain.gameClass.Node.LinkToNode(Node node) in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\world.cs:line 77
  34.    at MagicTrain.testClass.worldTest.testLinkArrayFull() in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\test.cs:line 168 : This link already exists!
  35.         Finish testLinkArrayFull test
  36.     Destroying worldTest environment
  37. Finish global test battery
  38.             ==> ExceptionAlreadyLinked: This link already exists!
  39.    at MagicTrain.gameClass.Node.LinkToNode(Node node, Boolean canCallback) in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\world.cs:line 96
  40.    at MagicTrain.gameClass.Node.LinkToNode(Node node, Boolean canCallback) in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\world.cs:line 104
  41.    at MagicTrain.gameClass.Node.LinkToNode(Node node) in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\world.cs:line 77
  42.    at MagicTrain.testClass.worldTest.testLinkArrayFull() in g:\documents and settings\magicbuzz\mes documents\visual studio projects\magictrain\magictrain\gameclass\test.cs:line 168 : This link already exists!
  43.         Finish testLinkArrayFull test
  44.     Destroying worldTest environment
  45. Finish global test battery
  46. The program '[2388] MagicTrain.exe' has exited with code 0 (0x0).


 
C'est quoi ce délire ? Dès le début, pourquoi il passe deux fois dans mon contructeur ?
Puis fait tous les tests en double !
Et ensuite, pourquoi est-ce que pendant le "testAlreadyLinked" il écrit un débug normalement écrit dans la "testRecursiveLink" ?
 
Du coup, ça déconne à plein tube et à la fin il raise une erreur qui ne devrait pas se déclencher, parceque je m'escrime à faire du nettoyage dans à la fin de mes tests et normalement les nodes devraient toujours être dans un état vide à la fin de chaque test...


Message édité par Arjuna le 29-08-2005 à 20:53:54
Reply

Marsh Posté le 30-08-2005 à 19:49:04    

Ca y est, je les ai tous fait fuir :sweat:

Reply

Marsh Posté le 30-08-2005 à 22:11:14    

Problème ci-dessus résolu.
 
Nouvelle question à propos des Array : Est-ce qu'on peut passer outre la limitation de 2^15 - 1 lignes pour un tableau "simple" ? Ou si je dois passer par un objet ArrayList ?
 
Pourtant, y'a une propriété .LongLength, j'en déduit que l'index peut être un long :??:

Reply

Marsh Posté le    

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed