From 785ae6599b3a8403ae84b5cd69729d4c7a665641 Mon Sep 17 00:00:00 2001 From: Emanuel Borsoi Date: Mon, 27 Dec 2021 09:09:08 +0100 Subject: [PATCH] Remove useless return values --- codicedicontrollo.go | 4 ++-- codicefiscale.go | 16 ++++++++-------- codicefiscale_test.go | 28 ++++++++++++++-------------- confrontacodicifiscali.go | 34 +++++++++++++++++----------------- 4 files changed, 41 insertions(+), 41 deletions(-) diff --git a/codicedicontrollo.go b/codicedicontrollo.go index 8b2d2f9..9fd1374 100644 --- a/codicedicontrollo.go +++ b/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") } diff --git a/codicefiscale.go b/codicefiscale.go index 5380e6d..29b2974 100644 --- a/codicefiscale.go +++ b/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 } diff --git a/codicefiscale_test.go b/codicefiscale_test.go index 7188ab6..1d83763 100644 --- a/codicefiscale_test.go +++ b/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,19 +89,19 @@ 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") @@ -109,7 +109,7 @@ func TestConfrontaCodicifiscali(t *testing.T) { // 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") diff --git a/confrontacodicifiscali.go b/confrontacodicifiscali.go index 06d8980..9e7b440 100644 --- a/confrontacodicifiscali.go +++ b/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") }