Test unitaire junit

Je vois, j'ai écris tous les tests en essayant de respecter les critères que l'on m'a donné
J'obtiens cela:

package testunitair;

import org.junit.*;
import static org.junit.Assert.*;


public class test {
	
	
	@Test
	public void Consultation() {
	    compte cpt = new compte(0);
	   assertEquals(0, cpt.consultation());
	   assertTrue(cpt.consultation()>=0); 
	}
	@Test
	public void testVirement() {
	    int a = 17, b = 12;
	    compte cpt = new compte(a);
	    cpt.virement(b);
	    assertEquals(a + b, cpt.consultation());
	}
	@Test
	public void virement() {
		int b = 0;
		compte cpt = new compte(0);
		cpt.virement(b);
		assertTrue(b>= 0);
		assertTrue(b < cpt.consultation());
		}
	@Test
	public void debiter() {
		int b = 0;
		compte cpt = new compte(0);
		cpt.debiter(b);
		assertTrue(b>= 0);
		assertTrue(b < cpt.consultation());
		
	}
	
	@Test
	public void testcrediter() {
	    int a = 10, b = 45;
	    compte cpt = new compte(a);
	    cpt.virement(b);
	    assertEquals(a + b, cpt.consultation());
	    
	}
	@Test
	public void crediter() {
		int b = 0;
		compte cpt = new compte(0);
		cpt.crediter(b);
		assertTrue(b>= 0);
		
		}
}

Est ce que c'est bien comme cela que j’étais sensé le faire?

"en essayant de respecter les critères que l'on m'a donné"
De quel genre ?

De ce que je vois :

@Test
public void virement() {
    int b = 0;
    compte cpt = new compte(0);
    cpt.virement(b);
    assertTrue(b>= 0);
    assertTrue(b < cpt.consultation());
}

Ici

assertTrue(b>= 0);

ne sert à rien, b vaut 0 donc b>=0 sera forcément true, et en plus ça ne testes rien de ton code (ça teste le test unitaire... inutile !)

De ton code ce que tu testes c'est

cpt.virement(b);

mais sachant que b vaut 0, ça n'affecte pas vraiment l'état de ton compte, c'est même bizarre que l'on puisse autoriser un virement de valeur 0...

assertTrue(b < cpt.consultation());

je n'ai pas testé, mais a priori c'est incorrect, puisque ton compte vaut 0 et que tu fais un virement de 0, tu n'auras pas 0 < 0...

De plus, dans les règles de l'art, un test unitaire ne devrait tester qu'une seule chose pour être vraiment unitaire, donc un seul assert par méthode.

Remarque : il serait également bon de respecter les conventions de nommage Java (nom de classe avec une majuscule, camel case, etc.)

Ce sont ces critères la:
— un compte n’est jamais à découvert,
— seules des sommes positives peuvent être passées en paramètre des opérations,
— l’invocation du débit ou du virement ne peut se faire qu’avec une somme inférieure au solde du compte concerné

Pour virement j'ai corrigé et cela me donne:

@Test
	public void virement() {
		int b = 10;
		compte cpt = new compte(20);
		cpt.virement(b);
		assertTrue(b>= 0);
		assertTrue(b < cpt.consultation());
		}

je l'ai testé et il fonctionne.

Le problème c'est que tu testes un cas particulier qui n'est pas pertinent.
Sachant que de toute façon ton code est faux, donc avoir des tests qui fonctionnent sans changer ton code, ça veut dire que le test est faux aussi.
Un bon test devrait t'indiquer que ton code est faux.

Voici quelques cas dont il faudrait écrire les tests (et corriger le code) pour respecter tes critères d'exigences :

compte cpt = new compte(20);
cpt.debiter(50);

compte cpt = new compte(20);
cpt.virement(50);

compte cpt = new compte(20);
cpt.debiter(-50);

compte cpt = new compte(20);
cpt.virement(-50);