Nuovi posts

Cerca

Iscriviti

CONTROLLO PROGRAMMA ECLIPSE CON CASI DI TEST

di

il 24 mag 2012, 20:05

6 risposte

Pochi posts

Iscritto da: mag, 2012

Messaggi:: 4

CONTROLLO PROGRAMMA ECLIPSE CON CASI DI TEST

24 mag 2012, 20:38

Salve a tutti, gentilmente qualcuno sarebbe disposto a controllare alcuni errori che non riesco ad eliminare nella compilazione dei casi di test? vi posto il progetto qualora qualcuno volesse darmi una mano. Grazie Anticipatamente

6 Risposte

skynet
Utente Famoso
Iscritto da
lug, 2010
Messaggi:
3060
Re: CONTROLLO PROGRAMMA ECLIPSE CON CASI DI TEST
24 mag 2012, 20:45
Ciao, Cerca di non scrivere in Maiuscolo sembra un urlo in un forum.
Posta pure il tuo codice e anche gli errori che ti vengono fuori.
I
ileninia
Pochi posts
Iscritto da
mag, 2012
Messaggi:
4
Re: CONTROLLO PROGRAMMA ECLIPSE CON CASI DI TEST
24 mag 2012, 20:46
Scusatemi non era mia intenzione. Volevo allegarvi il codice in archivio ma non mi permette di caricarlo ora lo posto qui..

Pochi posts

Iscritto da: mag, 2012

Messaggi:: 4

Re: CONTROLLO PROGRAMMA ECLIPSE CON CASI DI TEST

24 mag 2012, 20:49

// questi sono i casi di test //
#include <stdio.h>
#include <stdlib.h>
#include "string.h"
#include "persone.h"
#include "CUnit/Basic.h"

persone* _persone = NULL;
persona* p1= NULL;
persona* p2= NULL;
persona* p3= NULL;

int suite_void_init(void) {
	_persone = crea_nuove_persone();
	inizializza_persone (_persone);

	p1 = crea_nuova_persona ("1", "1","1", "1");
	p2 = crea_nuova_persona ("2", "2", "2", "2");
	p3 = crea_nuova_persona ("3", "3", "3", "3");

	return 0;
}

int suite_void_cleanup (void) {
	cancella_persone(_persone);

	cancella_persona(p1);
	cancella_persona(p2);
	cancella_persona(p3);

	return 0;

}

void test_crea_nuova_persona(void) {
	persona* person = NULL;
	CU_ASSERT_TRUE(vuoto(_persone));
	person = crea_nuova_persona ("Nome", "Cognome", "Cod_fis", "18/08/1984");
	CU_ASSERT_STRING_EQUAL (person->nome, "Nome");
	CU_ASSERT_STRING_EQUAL (person->cognome,"Cognome");
	CU_ASSERT_STRING_EQUAL (person->Cod_fis, "Cod_fis");
	CU_ASSERT_STRING_EQUAL (person->data_nascita, "10/08/1984");

	cancella_persona(person);
	person = crea_nuova_persona ("Nome", "Cognome", "Cod_fis", NULL);
	CU_ASSERT_PTR_NULL(person);
}

void test_cancella_persona(void) {
	persona* p = NULL;
	CU_ASSERT_EQUAL_TRUE(vuoto(_persone));

	cancella_persona(NULL);
	p = crea_nuova_persona ("","","","");
	cancella_persona(p);
	CU_ASSERT_TRUE(vuoto(_persone));
}

void test_persona_uguale(void) {
	persona* vuota, *_p2, *_p3;
	CU_ASSERT_TRUE(vuoto(_persone));
	vuota = crea_nuova_persona("","","","");
	CU_ASSERT_FALSE(persona_uguale(NULL, vuota));
	CU_ASSERT_FALSE(persona_uguale(p1, NULL));
	CU_ASSERT_FALSE(PERSONA_UGUALE(p1, vuota));

	p2 = crea_nuova_persona("2","2","2","2");
	CU_ASSERT_FALSE(persona_uguale(p2,_p2));

	p3 = crea_nuova_persona("3","3","3","3");
	CU_ASSERT_TRUE(persona_uguale(p3,_p3));

	cancella_persona(vuota);
	cancella_persona(_p2);
	cancella_persona(_p3);
}

 //* void test_leggi_persona(void) {
	/*int pos =-1; /*significa forse che la persona nn è presente nel pool di persone */
	//*persona* letta=NULL;

	/*CU_ASSERT_TRUE(vuoto(_persone));
	posiz=aggiungi_persona(_persone,p1);
	CU_ASSERT_EQUAL(posiz, 0);
	CU_ASSERT_EQUAL(dimensione (_persone),1);
	posiz=aggiungi_persona(_persone,p3);
	CU_ASSERT_EQUAL
} */
void test_cancella_persone(void) {
	CU_ASSERT_EQUAL(vuoto(_persone), TRUE);
	aggiungi_persona_pos(_persone, crea_nuova_persona("2","2","2","2"),4);
	aggiungi_persona_pos(_persone, crea_nuova_persona("2","2","2","2") 9);
	aggiungi_persona_pos(_persone, crea_nuova_persona("2","2","2","2") MAX_PERSONE-1);

	CU_ASSERT_EQUAL(dimensione(_persone),4);
	cancella_persone(NULL);
	cancella_persone(_persone);
	CU_ASSERT_TRUE(vuoto(_persone));

}

void test_cerca_persona(void) {
	int pos=-1;
	CU_ASSERT_EQUAL (vuoto(_persone), TRUE);
	aggiungi_persona_pos(_persone, p1, 2 );
	aggiungi_persona_pos(_persone,p2, 6);
	aggiungi_persona_pos(_persone,p3, MAX_PERSONE-1);

	CU ASSERT_EQUAL(dimensione(_persone), 4);
	pos=cerca_persona(NULL, p1);

	pos=cerca_persona(NULL, p1);
	CU_ASSERT_EQUAL(pos, -1);
	pos=cerca_persona(_persone, p1);
	CU_ASSERT_EQUAL(pos, 2);
	pos=cerca_persona(_persone,p2);
	CU_ASSERT_EQUAL(pos, 6);
	pos=cerca_persona(_persone, p3);
	CU_ASSERT_EQUAL(pos, MAX_PERSONE -1);
	pos=cerca_persona(_persone, NULL);
	CU_ASSERT_EQUAL(pos, -1);

	rimuovi_persona(_persone,MAX_PERSONE -1);
	rimuovi_persona(_persone, 2);
	rimuovi_persona(_persone, 6);
	CU_ASSERT_TRUE(vuoto(_persone));
}

void test_aggiungi_persona(void) {
	CU_ASSERT_TRUE(vuoto(_persone));
	aggiungi_persona(NULL,NULL);
	CU_ASSERT_TRUE(vuoto(_persone));
	aggiungi_persona(_persone, NULL);
	CU_ASSERT_TRUE(vuoto(_persone));
	aggiungi_persona(NULL, p1);
	CU_ASSERT_TRUE(vuoto(_persone));
}

void test_aggiungi_persona_pos(void) {
	CU_ASSERT_TRUE(vuoto(_persone));
	aggiungi_persona_pos(NULL, NULL,-20);//VERIFICA//
	CU_ASSERT_TRUE(vuoto_(persone));
	aggiungi_persona_pos(_persone, NULL, 0);
	CU_ASSERT_TRUE(vuoto(_persone));
	aggiungi_persona_pos(NULL, p1, 0);
	CU_ASSERT_TRUE(vuoto(_persone));
	aggiungi_persona_pos(_persone, p1, -1);
	CU_ASSERT_TRUE(vuoto(_persone));
	aggiungi_persona_pos(_persone,p1, MAX_PERSONE);
	CU_ASSERT_TRUE(vuoto(_persone));
}

void test_rimuovi_persona(void) {
	persona* rimossa = NULL;
	aggiungi_persona_pos(_persone, p1, 4);
	aggiungi_persona_pos(_persone, p2, 9);
	aggiungi_persona_pos(_persone, p3, MAX_PERSONE -1);
	CU_ASSERT_EQUALE_(dimensione(_persone), 3);

	rimossa=rimuovi_persona(_persone, MAX_PERSONE);
	CU_ASSERT_PTR_NULL(rimossa);
	rimossa=rimuovi_persona(_persone, -15);//verifica//
	CU_ASSERT_PTR_NULL(rimossa);
	rimossa=rimuovi_persona(NULL,0);
	CU_ASSERT_PTR_NULL(rimossa);
	rimossa=rimuovi_persona(_persone,0);
	CU_ASSERT_PTR_NULL(cancellata);

	rimossa=rimuovi_persona(_persone, MAX_PERSONE -1);
	CU_ASSERT_TRUE(persona_uguale(cancellata, p1));
	CU_ASSERT_EQUAL(dimensione(_persone), 2) //VERIFICA//
	rimossa=rimuovi_persona(_persone,4); //VERIFICAPERSONA/
	CU_ASSERT_TRUE(persona_uguale(cancellata, p3));
	CU_ASSERT_EQUAL(dimensione(_persone), 1);
	rimossa=rimuovi_persona(_persone, 9);
	CU_ASSERT_TRUE(persona_uguale(cancellata,p2));
	CU_ASSERT_TRUE(vuoto(_persone));
}


void test_dimensione(void) {
	CU_ASSERT_EQUAL(vuoto(NULL), FALSE);
	CU_ASSERT_EQUAL(vuoto(_persone), TRUE);
	aggiungi_persona(_persone, p1);
	CU_ASSERT_EQUAL(dimensione(_persone),1);
	aggiungi_persona(_persone, p2);
	CU_ASSERT_EQUAL(dimensione(_persone, 2);
	aggiungi_persona_pos(_persone, p3, MAX_PERSONE-1);
	CU_ASSERT_EQUAL(dimensione(_persone), 3); //verifica//
	rimuovi_persona(_persone, 1);
	CU_ASSERT_EQUAL(dimensione(_persone), 2); //veridica//
	rimuovi_persona(_persone, 2);
	CU_ASSERT_EQUAL(dimensione(_persone), 2); //verifica//
	rimuovi_persona(_persone, 0);
	CU_ASSERT_EQUAL(dimensione(_persone), 1);
	rimuovi_persona(_persone, MAX_PERSONE-1);
	CU_ASSERT_TRUE(vuoto(_persone));

}

void test_pieno(void) {
	register int i;
	CU_ASSERT_TRUE(vuoto(_persone));
	for(i=0, i<MAX_PERSONE-1, i++)
	{
		aggiungi_persona(_persone,p1);
		CU_ASSERT_FALSE(pieno(_persone));
	}
	aggiungi_persona (_persone,p1);
	CU_ASSERT_TRUE(pieno(_persone));
	for(i=0; i< MAX_PERSONE, i++) {
		rimuovi_persona(_persone, i);
		CU_ASSERT_FALSE(pieno(_persone));
	}
	CU_ASSERT_TRUE(vuoto(_persone));
}

void test_vuoto(void) {
	CU_ASSERT_TRUE(vuoto(_persone));

	aggiungi_persona_pos(_persone,p1, 4);
	CU_ASSERT_FALSE(vuoto(_persone));
	aggiungi_persona_pos(_persone, p2, 6);
	CU_ASSERT_FALSE(vuoto(_persone));
	aggiungi_persona_pos(_persone, p3, MAX_PERSONE-1);
	CU_ASSERT_FALSE(vuoto_(_persone));

	rimuovi_persona(_persona, 4);
	CU_ASSERT_FALSE(vuoto(_persone));
	rimuovi_persona(_persona, 6);
	CU_ASSERT_FALSE (vuoto(_persone));
	rimuovi_persona(_persone, MAX_PERSONE-1);
	CU_ASSERT_TRUE (vuoto(_persone));

}

inr main(int argc, const char * argv[]) {
	CU_ErrorCode error;

	CU_TestInfo test_array_funzioni_persona[] = {
			{"test crea_nuova_persona()", test_crea_nuova_persona },
			{"test cancella_persona()", test_cancella_persona},
			{"test persona_uguale()", test_persona_uguale },
			CU_TEST_INFO_NULL,
	};

	CU_testInfo test_array_funzioni_persone[]= {
			{"test cancella_persone()", test_cancella_persone},
			{"test cerca_persona()", test_cerca_persona },
			{"test aggiungi_persona()", tes_aggiungi_persona},
			{"test aggiungi_persona_pos()", test_aggiungi_persona_pos },
			{"test rimuovi_persona()" test_rimuovi_persona},
			{"test dimensione()" test_dimensione },
			{"test pieno ()" test_piano },
			{"test vuoto()" test_vuoto },

	CU_TEST_INFO_NULL

};

CU_SuiteInfo suiter [] = {
		{ "test suite funzioni_persona", suite_init_func, suite cleanup_func, test_array_funzioni_persona },
		{"test suite funzioni_persone", suite init_func, suit cleanup func, test_array_persone },
		CU_SUITE_INFO_NULL,
};

if (CUE_SUCCESS != CU_ initializ_registry()) {
	CU_get_error();
	system("PAUSE");
	return -1;
}

error = CU_register_suites(suites);

	if(CUE_SUCCESS!=error)
	{
		CU_cleanup_registry();
		CU_get_error();
		system("PAUSE");
		return -1;
	}

CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

CU_cleanup_registry();
error = CU_get_error();
system("PAUSE");
return error;

}

// funzioni//
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "persone.h"

persona* crea_nuova_persona(const string nome, const string cognome, const string Cod_Fis, const string data_nascita)
{
	persona *nuovapers=NULL;
   nuovapers=(persona*) malloc (sizeof(persona));
	    			nuovapers->nome=nome;
	    			nuovapers->cognome=cognome;
	    			nuovapers->Cod_Fis=Cod_Fis;
	    			nuovapers->data_nascita=data_nascita;
	return nuovapers;
}



void cancella_persona(persona* p)
{
	if (p!=NULL) free(p);
}

//VERIF
enum bool persona_uguale(const persona* p1, const persona* p2)
{
	persona_uguale=FALSE;
	     if ((p1!=NULL) && (p2!=NULL))
		   {
	    	 if ((strcmp(p1->nome, p2->nome)==0) && (strcmp(p1->cognome, p2->cognome)==0))
	    	   {
	    		 if ((strcmp(p1->data_nascita, p2->data_nascita)==0) && (strcmp(p1->Cod_Fis, p2->Cod_Fis)==0))
	    		 persona_uguale=TRUE;
	    	   }
		   }
    if (persona_uguale==-1)
      {
    	return FALSE;
      }
    else   return TRUE;
}



persone* crea_nuove_persone()
        {
	     persone* nuova_persona;
	     nuova_persona=(persone*) malloc (sizeof(persone));
	     return nuova_persona;
        }


void inizializza_persone(persone* _persone)
    {
	  int i;
	  _persone->contatore=0;
	  if (_persone!=NULL)
	     {
		  for (i=0; i<MAX_PERSONE; i++)
		     {
			   _persone->gente[i]=NULL;
			   _persone->posizioni[i]=POSIZ_LIBERA;
		     }
	     }
    }


void cancella_persone(persone* _persone)
     {
		     free(_persone);
     }



int cerca_persona(const persone* _persone, const persona* p)
{
	int _posizione
	if (_persone!=NULL && p!=NULL)
	   {
		 int i=0;
		 int _posizione=-1;
		 while((i<MAX_PERSONE) &&(_posizione<0))
		    {
			   if (persona_uguale(_persone->gente[i],p)==TRUE)
				   _posizione=i;
			   else
				   i++;
		    }
	   }
	return _posizione;
}




int aggiungi_persona(persone* _persone, persona* p)
  {
    int i;
    int posizione=-1;
    if (_persone!=NULL && p!=NULL)
       {
          for (i=0; i<MAX_PERSONE && posizione==-1; i++)
          if (_persone->gente[i]==NULL &&_persone->posizioni[i]==POSIZ_LIBERA)
             {
    	       _persone->gente[i]=p;
               _persone->posizioni[i] = POSIZ_OCCUPATA;
               _persone->contatore++;
               posizione=i;
             }
       }
    return posizione;
  }



void aggiungi_persona_pos(persone* _persone, persona* p, int pos)
     {
	    if((_persone!=NULL) && (p!=NULL))
	       {
	          if ((pos>=0) && (pos<MAX_PERSONE))
	             {
	    	       _persone->gente[pos]=p;
	    	       _persone->posizioni[pos]=POSIZ_OCCUPATA;
	    	       _persone->contatore++;
	    	     }
            }
     }



persona* rimuovi_persona(persone* _persone, int pos)
     {
	  persona* _p=NULL;
	  if((_persone!=NULL) && (pos>=0) && (pos<MAX_PERSONE))
	     {
		   _p=(persona*) malloc (sizeof(persona));
		   _p=_persone->gente[pos];
		   _persone->gente[pos]=NULL;
		   _persone->contatore--;
		   _persone->posizioni[pos]=POSIZ_LIBERA;
	     }
	  return _p;
     }



int dimensione(const persone* _persone)
   {
	int numero=0;
	numero=_persone->contatore;
	return numero;
   }



enum bool pieno(const persone* _persone)
     {
       int _pieno=FALSE;
       if(_persone!=NULL)
          {
            if ((_persone->contatore) == (MAX_PERSONE))
            _pieno=TRUE;
          }
         return _pieno;
     }



enum bool vuoto(const persone* _persone)
     {
	       int _vuoto=FALSE;
	       if(_persone!=NULL)
	          {
	            if ((_persone->contatore) == (MAX_PERSONE))
	            _vuoto=TRUE;
	          }
	       return _vuoto;
     }

// file header//
#ifndef PERSONE_H
#define PERSONE_H
#define MAX_PERSONE 20



typedef definizione tipo struct persona
typedef char* string;
typedef struct {
	            string nome;
	            string cognome;
	            string Cod_Fis;
	            string data_nascita;
	            }persona;

typedef enum bool{FALSE, TRUE}bool;

#define POSIZ_LIBERA 0
#define POSIZ_OCCUPATA 1

typedef struct {
	            persona* gente[MAX_PERSONE];
	            unsigned contatore;
	            int posizioni[MAX_PERSONE];
                }persone;


persona* crea_nuova_persona(const string nome, const  cognome, const string Cod_Fis, const string data_nascita);
void cancella_persona(persona* p);
enum bool persona_uguale(const persona* p1, const persona* p2 );
persone* crea_nuove_persone();
void inizializza_persone(persone* _persone);
void cancella_persone(persone* _persone);
int cerca_persona(persone* _persone, persona* p);
int aggiungi_persona(persone* _persone, persona* p);
void aggiungi_persona_pos(persone* _persone, persona* p, int pos);
persona* rimuovi_persona(persone* _persone, int pos);
int dimensione(const persone* _persone);
enum bool vuoto(const persone* _persone);
enum bool pieno(const persone* _persone);
bool carica_da_file(string* path, persone* _persone);
bool salva_su_file(const string* path, const persone* _persone);



#endif

I
ileninia
Pochi posts
Iscritto da
mag, 2012
Messaggi:
4
Re: CONTROLLO PROGRAMMA ECLIPSE CON CASI DI TEST
24 mag 2012, 20:53
Gli errori li trovo nel campo funzioni rispettivamente a int cerca_persona e nei casi di test da CU_suites_info ovvero il main subito dopo la funzione test_vuoto. Grazie
skynet
Utente Famoso
Iscritto da
lug, 2010
Messaggi:
3060
Re: CONTROLLO PROGRAMMA ECLIPSE CON CASI DI TEST
24 mag 2012, 21:16
Leggere il regolamento no e?
Devi imparare ad inserire i code tags se no il tuo codice lo capisci solo tu. Sta volta lo metto a posto io.

Utente Famoso

Iscritto da: lug, 2010

Messaggi:: 3060

Re: CONTROLLO PROGRAMMA ECLIPSE CON CASI DI TEST

24 mag 2012, 21:20

CU ASSERT_EQUAL(dimensione(_persone), 4);

impara a conosce gli errori indicati dal compilatore. Come vedi qui manca un underscore.

CU_TEST_INFO_NULL,

qui la virgola non serve.

{"test rimuovi_persona()" test_rimuovi_persona},
         {"test dimensione()" test_dimensione },
         {"test pieno ()" test_piano },
         {"test vuoto()" test_vuoto },

qui invece serve dopo ogni " e cioè

{"test rimuovi_persona()", test_rimuovi_persona},
         {"test dimensione()", test_dimensione },
         {"test pieno ()", test_piano },
         {"test vuoto()", test_vuoto },

Tutto questo mi fa pensare che il codice non l'hai scritto tu perche questi errori non dovevi farli.

Devi accedere o registrarti per scrivere nel forum

6 risposte