Tests unitaires, est-ce un bogue ?

Version imprimable

1 pièce(s) jointe(s)

D'un test à l'autre, les champs sont remis à zéro, mais si je remplace fx:double par class var fx:double, fi conserve sa valeur. Tel que le code est écrit, dans le deuxième test, FAIL est activé par ce que fi=0 sans qu'aucune affectation n'ai jamais été effectuée dans ce sens.

Est-ce que c'est volontaire dans le but de forcer l'utilisation de SetUp et de décourager les tests avec des effets de bords? Est-ce un bogue à signaler?

Le vrai bogue à signaler, est-ce le fait que les champs soient remis à zéro ou le fait que l'ajout de de class var empêche la remise à zéro?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 unit TestCase1; {$mode objfpc}{$H+} interface uses Classes, SysUtils, fpcunit, testutils, testregistry, Dialogs; type TTestCase1= class(TTestCase) protected fx:double; fi:integer; procedure SetUp; override; procedure TearDown; override; published procedure One; procedure Two; end; implementation procedure TTestCase1.One; begin fx:=0.5; fi:=3; IF fi <> 3 THEN Fail('Must be 3.'); end; procedure TTestCase1.Two; begin ShowMessage('fx='+fx.ToString); ShowMessage('fi='+fi.ToString); IF fi <> 3 THEN //Will fail, fi =0, it has been automatically cleared Fail('Must be 3.'); end; procedure TTestCase1.SetUp; begin end; procedure TTestCase1.TearDown; begin end; initialization RegisterTest(TTestCase1); end.
Pièce jointe 381150

Bonjour je ne comprend pas bien ta question.

Pour ma part je met mes valeurs à tester dans public et non dans protected.
Dans le cadre d'un de mes projets (https://lazarus.developpez.com/actu/...rome-Delauney/) j'effectue plusieurs tests différents qui sont basés sur la même classe parente.

Je procède donc ainsi :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
  TBaseTestCase = class(TTestCase)
  public
     Ir1, Ir2: integer;
     Fs1,Fs2 : Single;
     nb, vb, ab: boolean;
  end;
 
 
  TVectorBaseTestCase = class(TBaseTestCase)
  protected
    procedure Setup; override;
    public
     {$CODEALIGN RECORDMIN=16}
     vtt1,vtt2, vtt3, vtt4: TGLZVector2f;
     vttd1,vttd2, vttd3, vttd4: TGLZVector2d;
     vt1,vt2, vt3, vt4 : TGLZVector4f;
     at1, at2, at3, at4, vorg: TGLZVector4f;
     ntt1,ntt2, ntt3 : TNativeGLZVector2f;
     nttd1,nttd2, nttd3 : TNativeGLZVector2d;
     vt2i  : TGLZVector2i;
     vt4i  : TGLZVector4i;
     nt2i  : TNativeGLZVector2i;
     nt4i  : TNativeGLZVector4i;
     nt1,nt2, nt3 : TNativeGLZVector4f;
     ant1,ant2, ant3, ant4, norg : TNativeGLZVector4f;
     {$CODEALIGN RECORDMIN=4}
     r1, rs : Single;
     rd1, rds : Double;
     Res: boolean;
    published
  end; 
 
procedure TVectorBaseTestCase.Setup;
begin
  vtt1.Create(5.850,4.525);
  vtt2.Create(1.558,6.512);
  ntt1.V := vtt1.V;
  ntt2.V := vtt2.V;
 
  vttd1.Create(5.850,4.525);
  vttd2.Create(1.558,6.512);
  nttd1.V := vttd1.V;
  nttd2.V := vttd2.V;
 
  vt1.Create(5.850,-15.480,8.512,1.5);
  vt2.Create(1.558,6.512,4.525,1.0);
  nt1.V := vt1.V;
  nt2.V := vt2.V;
 
  Fs1 := 1.5;
  Fs2 := 5.5;
 
  r1 := 1.5;
  rs := 5.5;
  rd1 := 1.5;
  rds := 5.5;
  res := false;
end;
 
TVector2OperatorsTestCase = class(TVectorBaseTestCase)
  published
    procedure TestCompare;       // these two test ensure we have data to play
    procedure TestCompareFalse;  // with and tests the compare function.
    procedure TestAddVector;
  end; 
 
{Test IsEqual and we have same values for each class ttpe}
procedure TVector2OperatorsTestCase.TestCompare;
begin
  AssertTrue('Test Values do not match'+ntt3.ToString+' --> '+vtt3.ToString, Compare(ntt1,vtt1));
end;
 
procedure TVector2OperatorsTestCase.TestCompareFalse;
begin
  AssertFalse('Test Values should not match'+ntt3.ToString+' --> '+vtt3.ToString, Compare(ntt1,vtt2));
end;
 
procedure TVector2OperatorsTestCase.TestAddVector;
begin
  ntt3 := ntt2 + ntt1;
  vtt3 := vtt1 + vtt2;
  AssertTrue('Vector + Vector no match'+ntt3.ToString+' --> '+vtt3.ToString, Compare(ntt3,vtt3));
end;

ici mes variables sont initialisé via la procedure Setup pour mes tests de comparaisons

Pour mes tests fonctionnels je procède comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 TVector2fFunctionalTest = class(TVectorBaseTestCase)
 published
      procedure TestCreate;
      procedure TestOpAdd;
      procedure TestOpSub;
      procedure TestOpDiv;
  end;  
 
procedure TVector2fFunctionalTest.TestCreate;
begin
  vtt1.Create(1.234,2.345);
  AssertEquals('Create:Sub1 X failed ', 1.234, vtt1.X);
  AssertEquals('Create:Sub2 Y failed ', 2.345, vtt1.Y);
end;
 
procedure TVector2fFunctionalTest.TestOpAdd;
begin
  vtt1.Create(1.0,2.0);
  vtt2.Create(3.0,2.0);
  vtt3 := vtt1 + vtt2;
  AssertEquals('OpAdd:Sub1 X failed ', 4.0, vtt3.X);
  AssertEquals('OpAdd:Sub2 Y failed ', 4.0, vtt3.Y);
  vtt3 := vtt2 + vtt1;
  AssertEquals('OpAdd:Sub3 X failed ', 4.0, vtt3.X);
  AssertEquals('OpAdd:Sub4 Y failed ', 4.0, vtt3.Y);
end;

Ici comme tu peux le voir je réaffecte de nouvelles valeurs via ma procedure Create. Tout fonctionne correctement.
En espérant que cela t'aide un peu.

18/05/2018, 05h44
Pierre le Grand

Je confirme que remplacer protected par public n'a aucun effet. Cela aurait été un gros bogue, car augmenter la visibilité ne doit pas modifier la sémantique d'un programme bien fait.

En fait, je testait quelque chose de plus conséquent, la classe de smart pointers de Marco Cantù. Si on utilisait un array of SmartPointer<T> au lieu d'un entier, au début du deuxième test, le tableau dynamique aurait été redimensionné avec HIGH(fA) =-1 sans qu'aucun des smart pointers n'ait été libéré :oops:. J'ai mis un compteur dans le destructeur afin de confirmer la destruction lors des tests, c'est facile avec {$IFDEF}.

Je me demandais si la classe TVector de la fcl-stl pouvait libérer ses éléments si ce sont des références à des classes mais un examen du code source confirme que TVector n'a pas de destructeur, il ne libère donc absolument rien. Je l'ai bidouillé en TVectorOfClassesInstances<T: class> qui libère tous ses éléments. J'ai aussi essayé des SmartPointers (en réalité, SmartReferenceAUneInstance).

Il faudrait que j'ajoute un test pour détruire ce qui a été créé car rechercher les fuites de mémoires, avec l'outil intégré de Lazarus, fait partie intégrante de mes tests. Un test réussi, c'est à la fois une barre verte et aucune fuite de mémoire.