Remove useless return values

codicedicontrollo.go

@@ -20,8 +20,8 @@ con go: go get github.com/squeeze69/codicefiscale
 
 //Codicedicontrollo : rende il codice di controllo del codice fiscale (15 caratteri)
 //ingresso: cfin (senza codice di controllo)
-//uscita: codice di controllo (vuoto in caso di problemi), err: nil se ok, *CFError se ci sono problemi
-func Codicedicontrollo(cfin string) (string, *CFError) {
+//uscita: codice di controllo (vuoto in caso di problemi), err: nil se ok, error se ci sono problemi
+func Codicedicontrollo(cfin string) (string, error) {
 	if len(cfin) != 15 {
 		return "", errCFError("Lunghezza Sbagliata")
 	}

codicefiscale.go

@@ -44,7 +44,7 @@ var ordv = map[byte]int{
 }
 
 //genera un errore CFError
-func errCFError(s string) *CFError {
+func errCFError(s string) error {
 	er := new(CFError)
 	er.msg = s
 	return er
@@ -53,19 +53,19 @@ func errCFError(s string) *CFError {
 //CodiceFiscale  controlla il codice fiscale, restituisce doppio valore, true/false e messaggio, ove opportuno
 //se cfin è vuota, viene considerata valida, per questo caso, il controllo dovrebbe essere altrove
 //Ingresso: cfin: stringa,non importa maiuscolo o minuscolo
-//Uscita: bool:true (a posto)/false (problemi) e *CFError (nil (a posto)/puntatore all'errore (problemi)
-func CodiceFiscale(cfin string) (bool, *CFError) {
+//Uscita: error (nil (a posto)/puntatore all'errore (problemi)
+func CodiceFiscale(cfin string) error {
 
 	if len(cfin) == 0 {
-		return true, nil //convenzione generale usata sulle routine su Icosaedro
+		return nil //convenzione generale usata sulle routine su Icosaedro
 	}
 	if len(cfin) != 16 {
-		return false, errCFError("Lunghezza Sbagliata")
+		return errCFError("Lunghezza Sbagliata")
 	}
 
 	//verifica per simboli inattesi
 	if regexp.MustCompile("[^a-zA-Z0-9]").MatchString(cfin) {
-		return false, errCFError("Caratteri Non validi")
+		return errCFError("Caratteri Non validi")
 	}
 
 	cfin = strings.ToUpper(cfin)
@@ -75,7 +75,7 @@ func CodiceFiscale(cfin string) (bool, *CFError) {
 		s += tcf[cfin[i]] + ordv[cfin[i+1]]
 	}
 	if s%26 != ordv[cfin[15]] {
-		return false, errCFError("Carattere Di Controllo Non Valido")
+		return errCFError("Carattere Di Controllo Non Valido")
 	}
-	return true, nil
+	return nil
 }

codicefiscale_test.go

@@ -16,15 +16,15 @@ func TestCodiceFiscale(t *testing.T) {
 	fmt.Println("test CondiceFiscale")
 	//verifica codici validi
 	for _, v := range testOK {
-		s, err := CodiceFiscale(v)
-		if !s {
+		err := CodiceFiscale(v)
+		if err != nil {
 			t.Fatal("Ko. Errore, Il Codice Fiscale", v, " dovrebbe essere valido", err)
 		}
 		fmt.Printf("Ok (valido) \"%s\"\n", v)
 	}
 	//verifica codici non validi
 	for _, v := range testKO {
-		_, err := CodiceFiscale(v)
+		err := CodiceFiscale(v)
 		if err == nil {
 			t.Fatal("Ko. Errore, Il Codice Fiscale", v, " NON dovrebbe essere valido")
 		}
@@ -61,22 +61,22 @@ func TestConfrontaCodicifiscaliOmocodici(t *testing.T) {
 	o, _ := Codicedicontrollo(cof2)
 	sb := cof1 + s
 	oa := cof2 + o
-	if _, err := ConfrontaCodicifiscaliOmocodici(oa, sb); err != nil {
+	if err := ConfrontaCodicifiscaliOmocodici(oa, sb); err != nil {
 		t.Fatal("KO. Errore, dovrebbe essere uguale", oa, sb, err)
 	}
 	fmt.Println("Ok. Uguale - test anche con omocodie ", oa, sb)
 	s, _ = Codicedicontrollo("ABCDEF12B23P433")
 	sb = "ABCDEF12B23P433" + s
-	if _, err := ConfrontaCodicifiscaliOmocodici(oa, sb); err == nil {
+	if err := ConfrontaCodicifiscaliOmocodici(oa, sb); err == nil {
 		t.Fatal("KO. Errore, dovrebbero essere diversi", oa, sb)
 	}
-	if _, err := ConfrontaCodicifiscaliOmocodici(cof1, sb); err == nil {
+	if err := ConfrontaCodicifiscaliOmocodici(cof1, sb); err == nil {
 		t.Fatal("KO. Errore, dovrebbe essere uguale", oa, sb)
 	}
-	if _, err := ConfrontaCodicifiscaliOmocodici(oa, cof2); err == nil {
+	if err := ConfrontaCodicifiscaliOmocodici(oa, cof2); err == nil {
 		t.Fatal("KO. Errore, dovrebbe essere uguale", oa, sb)
 	}
-	if _, err := ConfrontaCodicifiscaliOmocodici(cof3, cof3); err != nil {
+	if err := ConfrontaCodicifiscaliOmocodici(cof3, cof3); err != nil {
 		t.Fatal("KO. Errore, dovrebbe essere uguale", cof3, err)
 	}
 	fmt.Println("Ok, errori per codici fiscali sbagliati e giusti")
@@ -89,27 +89,27 @@ func TestConfrontaCodicifiscali(t *testing.T) {
 		cofb          = "ABCDEF12B23P433R"
 	)
 	fmt.Println("test ConfrontaCodicifiscali")
-	if _, err := ConfrontaCodicifiscali(cofa, cofa); err != nil {
+	if err := ConfrontaCodicifiscali(cofa, cofa); err != nil {
 		t.Fatal("KO. Errore, dovrebbe essere uguale", err)
 	}
 	fmt.Println("Ok. Uguali")
 
-	if _, err := ConfrontaCodicifiscali(cofa, cofb); err == nil {
+	if err := ConfrontaCodicifiscali(cofa, cofb); err == nil {
 		t.Fatal("KO. Errore, dovrebbero essere diversi", cofa, cofb, err)
 	}
 	fmt.Println("Ok. Diversi")
-	if _, err := ConfrontaCodicifiscali(cof1sbagliato, cofb); err == nil {
+	if err := ConfrontaCodicifiscali(cof1sbagliato, cofb); err == nil {
 		t.Fatal("KO. Errore, dovrebbe rilevare codice sbagliato", cof1sbagliato, err)
 	}
-	if _, err := ConfrontaCodicifiscali(cofa, cof1sbagliato); err == nil {
+	if err := ConfrontaCodicifiscali(cofa, cof1sbagliato); err == nil {
 		t.Fatal("KO. Errore, dovrebbe rilevare codice sbagliato", cof1sbagliato, err)
 	}
 	fmt.Println("Ok. Rileva codici sbagliati")
 }
 
 // test aggiuntivi utili per godoc
 func ExampleConfrontaCodicifiscali() {
-	if _, err := ConfrontaCodicifiscali("ABCDEF12B23P432P", "ABCDEF12B23P433R"); err != nil {
+	if err := ConfrontaCodicifiscali("ABCDEF12B23P432P", "ABCDEF12B23P433R"); err != nil {
 		fmt.Println("ConfrontaCodicifiscali:", err)
 	}
 	// Output: ConfrontaCodicifiscali: Non corrispondono
@@ -125,7 +125,7 @@ func ExampleCodicedicontrollo() {
 }
 
 func ExampleCodiceFiscale() {
-	if _, err := CodiceFiscale("ABCDEF12B23P433R"); err != nil {
+	if err := CodiceFiscale("ABCDEF12B23P433R"); err != nil {
 		fmt.Println(err)
 	} else {
 		fmt.Println("Codice Fiscale Verificato")

confrontacodicifiscali.go

@@ -47,39 +47,39 @@ func Deomocodia(s string) string {
 //ConfrontaCodicifiscaliOmocodici : ingresso a,b, tiene conto di omocodie per confronto
 //ingresso: a,b stringhe con i codici fiscali da confrontare
 //se non corrispondono, riconduce entrambi alla forma non per omocodie e riconfronta
-//uscita: bool (true:ok,false:ko), *CFError (nil se va bene)
+//uscita: error (nil se va bene)
 //da sostituire: 7,8,10,11,13,14,15
-func ConfrontaCodicifiscaliOmocodici(a, b string) (bool, *CFError) {
-	if _, err := CodiceFiscale(a); err != nil {
-		return false, err
+func ConfrontaCodicifiscaliOmocodici(a, b string) error {
+	if err := CodiceFiscale(a); err != nil {
+		return err
 	}
-	if _, err := CodiceFiscale(b); err != nil {
-		return false, err
+	if err := CodiceFiscale(b); err != nil {
+		return err
 	}
 	a = strings.ToUpper(a)
 	b = strings.ToUpper(b)
 	if a == b {
-		return true, nil
+		return nil
 	}
 	if Deomocodia(a)[0:15] != Deomocodia(b)[0:15] {
-		return false, errCFError("Non corrispondono")
+		return errCFError("Non corrispondono")
 	}
-	return true, nil
+	return nil
 }
 
 //ConfrontaCodicifiscali : controlla e confronta due codici fiscali
 //DEVONO corrispondere al 100% - prima verifica il codice di controllo
 //Ingresso: a,b : string : codifici fiscali
-//Uscita: bool (true:ok,false:ko), *CFError (nil se va bene)
-func ConfrontaCodicifiscali(a, b string) (bool, *CFError) {
-	if _, err := CodiceFiscale(a); err != nil {
-		return false, err
+//Uscita: error (nil se va bene)
+func ConfrontaCodicifiscali(a, b string) error {
+	if err := CodiceFiscale(a); err != nil {
+		return err
 	}
-	if _, err := CodiceFiscale(b); err != nil {
-		return false, err
+	if err := CodiceFiscale(b); err != nil {
+		return err
 	}
 	if strings.EqualFold(a, b) {
-		return true, nil
+		return nil
 	}
-	return false, errCFError("Non corrispondono")
+	return errCFError("Non corrispondono")
 }