Référence de la classe TestCases

Liste de tous les membres

Fonctions membres publiques statiques
static bool	doInteger (int parameter)
	Calculs sur les entiers.
static bool	doLong (int parameter)
	Calculs sur les entiers longs.
static bool	doDouble (int parameter)
	Calculs sur les doubles.
static bool	doIO (int parameter)
	Ecriture d'un fichier d'un pattern composé d'une ligne de lettres contenant des caractères accentués.
static bool	doConcatenation (int parameter)
	Concaténation de n chaines en une seule.
static bool	doMatrix (int parameter)
	Simple multiplication de deux matrices carrées.
static bool	doSort (int n)
	Tri d'un tableau d'ordre inversé par rapport à l'objectif.
static bool	doHash (int parameter)
	Ici on cré une table de hash<int,int> initialisé à FACTOR*parameter valeurs entières.
static bool	doException (int parameter)
	Génére un nombre important d'exceptions dans une boucle.
static bool	doTrigo (int parameter)
	Fonctions mathématiques et trigonométriques.
static bool	doLoop (int parameter)
	6 boucles imbriquées.
static bool	doVector (int parameter)
	Création de deux vecteurs et divers opérations pour passer des éléments de l'un à l'autre.
static bool	doThreads (int parameter)
	Composition d'un anneau de N threads servant de relai de signal.

---

Documentation des fonctions membres

static bool doInteger

(

int

parameter

)

[static]

Calculs sur les entiers.

Paramètres:

parameter

Nombre d'itérations

Renvoie:

True si le test est validé.

    {
      int result = 1;

      for (int i = 1; i < parameter; i++) {
        result -= i;
        result += i;
        result *= i;
        result /= i;
      }
      return result == 1;
    }

static bool doLong

(

int

parameter

)

[static]

Calculs sur les entiers longs.

Paramètres:

parameter

Nombre d'itérations

Renvoie:

True si le test est validé.

    {
      long result = 1;

      for (int i = 1; i < parameter; i++) {
        result -= i;
        result += i;
        result *= i;
        result /= i;
      }
      return result == 1;
    }

static bool doDouble

(

int

parameter

)

[static]

Calculs sur les doubles.

Paramètres:

parameter

Nombre d'itérations

Renvoie:

True si le test est validé.

    {
      double result = 1;

      for (int i = 1; i < parameter; i++) {
        result -= i;
        result += i;
        result *= i;
        result /= i;
      }
      return result == 1;
    }

static bool doIO

(

int

parameter

)

[static]

Ecriture d'un fichier d'un pattern composé d'une ligne de lettres contenant des caractères accentués.

Ensuite relecture du même fichier ligne par ligne.

Paramètres:

parameter

Nombre d'itérations

Renvoie:

True si le test est validé.

    {
      const String PATTERN = "éàôabcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890abcdefgh";
      const String FILE_NAME = "../tmp/test_csharp.txt";

      StreamWriter streamWriter = new StreamWriter (FILE_NAME);

      for (int i = 0; i < parameter; i++) {
        streamWriter.WriteLine (PATTERN);
      }
      streamWriter.Close ();

      StreamReader streamReader = new StreamReader (FILE_NAME);
      String line = "";
      for (int i = 0; i < parameter; i++) {
        line = streamReader.ReadLine ();
        if (!line.Equals (PATTERN)) {
          return false;
        }
      }
      return true;
    }

static bool doConcatenation

(

int

parameter

)

[static]

Concaténation de n chaines en une seule.

Pour être plus juste par rapport à l'immutabilité des chaînes dans les langages Java et C#, ce sont les versions bufferisées qui sont utilisées.

Paramètres:

parameter

nombre de concaténations.

Renvoie:

true si c'est ok

    {
      StringBuilder buffer = new StringBuilder();
      const String PATTERN = "éàôabcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890abcdefgh";

      for (int j = 0; j < parameter; j++) {
        buffer.Append(PATTERN);
      }

      return buffer.Length == PATTERN.Length * parameter &&
      buffer.ToString().Substring (buffer.Length - PATTERN.Length).Equals (PATTERN);
    }

static bool doMatrix

(

int

parameter

)

[static]

Simple multiplication de deux matrices carrées.

Paramètres:

parameter

taille de la matrice

Renvoie:

true si tout est ok

    {
      // Create the the matrix
      int [,] m1 = new int [parameter, parameter];
      int [,] m2 = new int [parameter, parameter];
      int count = 1;
      for (int i = 0; i < parameter; i++) {
        for (int j = 0; j < parameter; j++) {
          m1 [i, j] = count;
          m2 [i, j] = 0;
          count++;
        }
      }

      // Create inversion matrix
      for (int i = 0; i < parameter; i++) {
        m2 [i, parameter - i - 1] = 1;
      }

      // Multiply them
      int [,] mm = new int [parameter, parameter];
      for (int i = 0; i < parameter; i++) {
        for (int j = 0; j < parameter; j++) {
          int val = 0;
          for (int k = 0; k < parameter; k++) {
            val += m1 [i, k] * m2 [k, j];
          }
          mm [i, j] = val;
        }
      }

      // Check inversion
      for (int i = 0; i < parameter; i++) {
        for (int j = 0; j < parameter; j++) {
          if (mm [i, j] != m1 [i, parameter - j - 1]) {
            return false;
          }
        }
      }
      return true;
    }

static bool doSort

(

int

n

)

[static]

Tri d'un tableau d'ordre inversé par rapport à l'objectif.

Paramètres:

n

Taille du tableau

Renvoie:

true si le test est validé.

    {
      int i, j;

      int[] ra = new int [n + 1];
      for (i = 0; i <= n; i++) {
        ra [i] = n - i;
      }
      int ir = n;
      int l = (n >> 1) + 1;
      int rra;

      for (;;) {
        if (l> 1) {
          rra = ra [--l];
        }
        else {
          rra = ra [ir];
          ra [ir] = ra [1];
          if (--ir == 1) {
            ra [1] = rra;
            break;
          }
        }
        i = l;
        j = l << 1;
        while (j <= ir) {
          if (j < ir && ra [j] < ra [j + 1]) {
            ++j;
          }
          if (rra < ra [j]) {
            ra [i] = ra [j];
            j += i = j;
          }
          else {
            j = ir + 1;
          }
        }
        ra [i] = rra;
      }
      for (i = 1; i < n; i++) {
        if (ra [i]> ra [i + 1]) {
          return false;
        }
      }
      return true;
    }

static bool doHash

(

int

parameter

)

[static]

Ici on cré une table de hash<int,int> initialisé à FACTOR*parameter valeurs entières.

Ensuite on énumère ces valeurs pour les ajouter dans une seconde hash avec une clef % FACTOR.

Paramètres:

parameter

La taille de la hash / FACTOR

Renvoie:

true si ok

    {
      const int FACTOR = 100;
      int ITEMS = parameter * FACTOR;
      Hashtable hash1 = new Hashtable ();
      Hashtable hash2 = new Hashtable ();

      for (int i = 0; i < ITEMS; i++) {
        hash1.Add (i, i);
      }

      IDictionaryEnumerator it = hash1.GetEnumerator ();
      while (it.MoveNext ()) {
        int key = (int)it.Key;
        int key2 = key % FACTOR;
        int v1 = (int)it.Value;
        object v2 = hash2 [key2];
        if (v2 != null) {
          v1 += (int)v2;
          hash2 [key2] = v1;
        }
        else {
          hash2.Add (key2, v1);
        }
        //hash1.Remove(key);
      }
      return hash2.Count == FACTOR;
    }

static bool doException

(

int

parameter

)

[static]

Génére un nombre important d'exceptions dans une boucle.

Paramètres:

parameter

nombre d'itérations.

Renvoie:

true si le test est validé.

    {
      int counter = 0;

      for (int i = 0; i < parameter; i++) {
        if (i % 2 == 0) {
          try {
            throw new System.Exception ();
          } catch (Exception e) {
            counter++;
          }
        }
      }

      return counter == parameter / 2;
    }

static bool doTrigo

(

int

parameter

)

[static]

Fonctions mathématiques et trigonométriques.

Paramètres:

parameter

itéartions sur le test

Renvoie:

true si ok

    {
      double sine = 0.0D;
      double cosine = 0.0D;
      double tangent = 0.0D;
      double logarithm = 0.0D;
      double squareRoot = 0.0D;
      double cumul = 0;
      double full = 2 * Math.PI;

      for (int i = 0; i < parameter; i++) {
        double angle = 0;
        while (angle < full) {
          sine = Math.Sin (angle);
          cosine = Math.Cos (angle);
          tangent = Math.Tan (angle);
          cumul += sine + cosine + tangent;
          angle++;
        }
        logarithm = Math.Log (i + 1);
        squareRoot = Math.Sqrt (i + 1);
        cumul += logarithm + squareRoot;
      }
      return cumul != 0;
    }

static bool doLoop

(

int

parameter

)

[static]

6 boucles imbriquées.

Paramètres:

parameter

nombre d'itérations à chaque étage

Renvoie:

True si le test est validé

    {
      int a, b, c, d, e, f;
      double x = 0;

      for (a = 0; a <= parameter; a++) {
        for (b = 0; b <= parameter; b++) {
          for (c = 0; c <= parameter; c++) {
            for (d = 0; d <= parameter; d++) {
              for (e = 0; e <= parameter; e++) {
                for (f = 0; f <= parameter; f++) {
                  x = a + b + c + d + e + f;
                }
              }
            }
          }
        }
      }
      return x == 6 * parameter;
    }

static bool doVector

(

int

parameter

)

[static]

Création de deux vecteurs et divers opérations pour passer des éléments de l'un à l'autre.

Paramètres:

parameter

taille des vecteurs.

Renvoie:

true si le test est validé.

    {
      ArrayList Li1 = new ArrayList ();

      for (int i = 0; i < parameter; i++) {
        Li1.Insert (Li1.Count, i);
      }

      ArrayList Li2 = new ArrayList (Li1);
      ArrayList Li3 = new ArrayList ();

      while (Li2.Count> 0) {
        Li3.Insert (Li3.Count, Li2 [0]);
        Li2.RemoveAt (0);
      }

      while (Li3.Count> 0) {
        Li2.Insert (Li2.Count, Li3 [Li3.Count - 1]);
        Li3.RemoveAt (Li3.Count - 1);
      }

      ArrayList tmp = new ArrayList ();
      while (Li1.Count> 0) {
        tmp.Insert (0, Li1 [0]);
        Li1.RemoveAt (0);
      }
      Li1 = tmp;

      return((int)(Li1 [0]) == parameter - 1);
    }

static bool doThreads

(

int

parameter

)

[static]

Composition d'un anneau de N threads servant de relai de signal.

Le signal en question est un entier dont la valeur est 1000xNombreThreads. Le message est passé d'un thread à l'autre en étant à chaque fois décrémenté. Lorsqu'un thread reçoit une valeur de signal négative, il le passe à son voisin et meurt.

Paramètres:

n

Nombre de threads

Renvoie:

true si le test est validé.

    {
      int threadCount = parameter - 1;
      int factor = 1000;
      int signal = factor * parameter;
      Node firstNode = new Node ();

      // Make the ring
      Node previousNode = firstNode;

      for (int iNode = 0; iNode < threadCount; iNode++) {
        Node currentNode = new Node ();
        if (previousNode != null) {
          currentNode.setNextNode (previousNode);
        }
        else {
          firstNode = currentNode;
        }
        currentNode.start ();
        previousNode = currentNode;
      }

      // Close the ring
      firstNode.setNextNode (previousNode);

      while (true) {
        if (Node.ALIVES.Count == threadCount) {
          break;
        }
        Thread.Sleep (1);
      }

      firstNode.initialize (signal);
      return firstNode.received == factor+1;
    }

Voici le graphe d'appel pour cette fonction :

---

La documentation de cette classe a été générée à partir du fichier suivant :

• Benchmark.cs