diff --git a/client_test.go b/client_test.go
index 7fa87200..2cc11eac 100644
--- a/client_test.go
+++ b/client_test.go
@@ -11,7 +11,7 @@ func TestClientSync(t *testing.T) {
 
 	s, addrstr, err := RunLocalUDPServer("127.0.0.1:0")
 	if err != nil {
-		t.Fatalf("Unable to run test server: %s", err)
+		t.Fatalf("Unable to run test server: %v", err)
 	}
 	defer s.Shutdown()
 
@@ -19,22 +19,20 @@ func TestClientSync(t *testing.T) {
 	m.SetQuestion("miek.nl.", TypeSOA)
 
 	c := new(Client)
-	r, _, e := c.Exchange(m, addrstr)
-	if e != nil {
-		t.Errorf("failed to exchange: %s", e.Error())
+	r, _, err := c.Exchange(m, addrstr)
+	if err != nil {
+		t.Errorf("failed to exchange: %v", err)
 	}
 	if r != nil && r.Rcode != RcodeSuccess {
-		t.Error("failed to get an valid answer")
-		t.Errorf("%v\n", r)
+		t.Errorf("failed to get an valid answer\n%v", r)
 	}
 	// And now with plain Exchange().
-	r, e = Exchange(m, addrstr)
-	if e != nil {
-		t.Errorf("failed to exchange: %s", e.Error())
+	r, err = Exchange(m, addrstr)
+	if err != nil {
+		t.Errorf("failed to exchange: %v", err)
 	}
 	if r != nil && r.Rcode != RcodeSuccess {
-		t.Error("failed to get an valid answer")
-		t.Errorf("%v\n", r)
+		t.Errorf("failed to get an valid answer\n%v", r)
 	}
 }
 
@@ -44,7 +42,7 @@ func TestClientEDNS0(t *testing.T) {
 
 	s, addrstr, err := RunLocalUDPServer("127.0.0.1:0")
 	if err != nil {
-		t.Fatalf("Unable to run test server: %s", err)
+		t.Fatalf("Unable to run test server: %v", err)
 	}
 	defer s.Shutdown()
 
@@ -54,14 +52,13 @@ func TestClientEDNS0(t *testing.T) {
 	m.SetEdns0(2048, true)
 
 	c := new(Client)
-	r, _, e := c.Exchange(m, addrstr)
-	if e != nil {
-		t.Errorf("failed to exchange: %s", e.Error())
+	r, _, err := c.Exchange(m, addrstr)
+	if err != nil {
+		t.Errorf("failed to exchange: %v", err)
 	}
 
 	if r != nil && r.Rcode != RcodeSuccess {
-		t.Error("failed to get an valid answer")
-		t.Errorf("%v\n", r)
+		t.Errorf("failed to get an valid answer\n%v", r)
 	}
 }
 
@@ -71,7 +68,7 @@ func TestSingleSingleInflight(t *testing.T) {
 
 	s, addrstr, err := RunLocalUDPServer("127.0.0.1:0")
 	if err != nil {
-		t.Fatalf("Unable to run test server: %s", err)
+		t.Fatalf("Unable to run test server: %v", err)
 	}
 	defer s.Shutdown()
 
@@ -100,7 +97,7 @@ Loop:
 				first = rtt
 			} else {
 				if first != rtt {
-					t.Error("all rtts should be equal")
+					t.Errorf("all rtts should be equal.  got %d want %d", rtt, first)
 				}
 			}
 			i++
@@ -135,6 +132,6 @@ func ExampleUpdateLeaseTSIG(t *testing.T) {
 
 	_, _, err := c.Exchange(m, "127.0.0.1:53")
 	if err != nil {
-		t.Error(err.Error())
+		t.Error(err)
 	}
 }
diff --git a/dns_test.go b/dns_test.go
index 283be912..d16fe09f 100644
--- a/dns_test.go
+++ b/dns_test.go
@@ -58,7 +58,7 @@ func TestPackUnpack2(t *testing.T) {
 	m.Answer[0] = rr
 	_, err := m.Pack()
 	if err != nil {
-		t.Error("Packing failed: ", err.Error())
+		t.Error("Packing failed: ", err)
 		return
 	}
 }
@@ -85,7 +85,7 @@ func TestPackUnpack3(t *testing.T) {
 	m.Answer[0] = rr
 	b, err := m.Pack()
 	if err != nil {
-		t.Error("packing failed: " + err.Error())
+		t.Error("packing failed: ", err)
 		return
 	}
 
@@ -104,7 +104,7 @@ func TestBailiwick(t *testing.T) {
 	}
 	for parent, child := range yes {
 		if !IsSubDomain(parent, child) {
-			t.Errorf("%s should be child of %s\n", child, parent)
+			t.Errorf("%s should be child of %s", child, parent)
 			t.Errorf("comparelabels %d", CompareDomainName(parent, child))
 			t.Errorf("lenlabels %d %d", CountLabel(parent), CountLabel(child))
 		}
@@ -118,7 +118,7 @@ func TestBailiwick(t *testing.T) {
 	}
 	for parent, child := range no {
 		if IsSubDomain(parent, child) {
-			t.Errorf("%s should not be child of %s\n", child, parent)
+			t.Errorf("%s should not be child of %s", child, parent)
 			t.Errorf("comparelabels %d", CompareDomainName(parent, child))
 			t.Errorf("lenlabels %d %d", CountLabel(parent), CountLabel(child))
 		}
@@ -133,11 +133,11 @@ func TestPack(t *testing.T) {
 	for _, r := range rr {
 		m.Answer[0], err = NewRR(r)
 		if err != nil {
-			t.Errorf("failed to create RR: %s\n", err.Error())
+			t.Errorf("failed to create RR: %v", err)
 			continue
 		}
 		if _, err := m.Pack(); err != nil {
-			t.Errorf("packing failed: %s\n", err.Error())
+			t.Errorf("packing failed: %v", err)
 		}
 	}
 	x := new(Msg)
@@ -172,10 +172,10 @@ func TestPackNAPTR(t *testing.T) {
 		rr, _ := NewRR(n)
 		msg := make([]byte, rr.len())
 		if off, err := PackRR(rr, msg, 0, nil, false); err != nil {
-			t.Errorf("packing failed: %s", err.Error())
-			t.Errorf("length %d, need more than %d\n", rr.len(), off)
+			t.Errorf("packing failed: %v", err)
+			t.Errorf("length %d, need more than %d", rr.len(), off)
 		} else {
-			t.Logf("buf size needed: %d\n", off)
+			t.Logf("buf size needed: %d", off)
 		}
 	}
 }
@@ -216,7 +216,7 @@ func TestMsgCompressLength(t *testing.T) {
 			t.Error(err)
 		}
 		if predicted < len(buf) {
-			t.Errorf("predicted compressed length is wrong: predicted %s (len=%d) %d, actual %d\n",
+			t.Errorf("predicted compressed length is wrong: predicted %s (len=%d) %d, actual %d",
 				msg.Question[0].Name, len(msg.Answer), predicted, len(buf))
 		}
 	}
@@ -246,7 +246,7 @@ func TestMsgLength(t *testing.T) {
 			t.Error(err)
 		}
 		if predicted < len(buf) {
-			t.Errorf("predicted length is wrong: predicted %s (len=%d), actual %d\n",
+			t.Errorf("predicted length is wrong: predicted %s (len=%d), actual %d",
 				msg.Question[0].Name, predicted, len(buf))
 		}
 	}
@@ -434,9 +434,9 @@ func TestNoRdataPack(t *testing.T) {
 		}
 		r := fn()
 		*r.Header() = RR_Header{Name: "miek.nl.", Rrtype: typ, Class: ClassINET, Ttl: 3600}
-		_, e := PackRR(r, data, 0, nil, false)
-		if e != nil {
-			t.Errorf("failed to pack RR with zero rdata: %s: %s\n", TypeToString[typ], e.Error())
+		_, err := PackRR(r, data, 0, nil, false)
+		if err != nil {
+			t.Errorf("failed to pack RR with zero rdata: %s: %v", TypeToString[typ], err)
 		}
 	}
 }
@@ -452,16 +452,17 @@ func TestNoRdataUnpack(t *testing.T) {
 		}
 		r := fn()
 		*r.Header() = RR_Header{Name: "miek.nl.", Rrtype: typ, Class: ClassINET, Ttl: 3600}
-		off, e := PackRR(r, data, 0, nil, false)
-		if e != nil {
-			// Should always works, TestNoDataPack should have catched this
+		off, err := PackRR(r, data, 0, nil, false)
+		if err != nil {
+			// Should always works, TestNoDataPack should have caught this
+			t.Errorf("failed to pack RR: %v", err)
 			continue
 		}
-		rr, _, e := UnpackRR(data[:off], 0)
-		if e != nil {
-			t.Errorf("failed to unpack RR with zero rdata: %s: %s\n", TypeToString[typ], e.Error())
+		rr, _, err := UnpackRR(data[:off], 0)
+		if err != nil {
+			t.Errorf("failed to unpack RR with zero rdata: %s: %v", TypeToString[typ], err)
 		}
-		t.Logf("%s\n", rr)
+		t.Log(rr)
 	}
 }
 
@@ -542,17 +543,17 @@ func TestPackIPSECKEY(t *testing.T) {
 	buf := make([]byte, 1024)
 	for _, t1 := range tests {
 		rr, _ := NewRR(t1)
-		off, e := PackRR(rr, buf, 0, nil, false)
-		if e != nil {
-			t.Errorf("failed to pack IPSECKEY %s: %s\n", e, t1)
+		off, err := PackRR(rr, buf, 0, nil, false)
+		if err != nil {
+			t.Errorf("failed to pack IPSECKEY %v: %s", err, t1)
 			continue
 		}
 
-		rr, _, e = UnpackRR(buf[:off], 0)
-		if e != nil {
-			t.Errorf("failed to unpack IPSECKEY %s: %s\n", e, t1)
+		rr, _, err = UnpackRR(buf[:off], 0)
+		if err != nil {
+			t.Errorf("failed to unpack IPSECKEY %v: %s", err, t1)
 		}
-		t.Logf("%s\n", rr)
+		t.Log(rr)
 	}
 }
 
@@ -571,10 +572,10 @@ func TestMsgPackBuffer(t *testing.T) {
 		// we won't fail the decoding of the hex
 		input, _ := hex.DecodeString(hexData)
 		m := new(Msg)
-		if e := m.Unpack(input); e != nil {
+		if err := m.Unpack(input); err != nil {
 			t.Errorf("packet %d failed to unpack", i)
 			continue
 		}
-		t.Logf("packet %d %s\n", i, m.String())
+		t.Logf("packet %d %s", i, m.String())
 	}
 }
diff --git a/dnssec_test.go b/dnssec_test.go
index b686be6c..48c22362 100644
--- a/dnssec_test.go
+++ b/dnssec_test.go
@@ -45,8 +45,8 @@ func TestGenerateEC(t *testing.T) {
 	key.Protocol = 3
 	key.Algorithm = ECDSAP256SHA256
 	privkey, _ := key.Generate(256)
-	t.Logf("%s\n", key.String())
-	t.Logf("%s\n", key.PrivateKeyString(privkey))
+	t.Log(key.String())
+	t.Log(key.PrivateKeyString(privkey))
 }
 
 func TestGenerateDSA(t *testing.T) {
@@ -62,8 +62,8 @@ func TestGenerateDSA(t *testing.T) {
 	key.Protocol = 3
 	key.Algorithm = DSA
 	privkey, _ := key.Generate(1024)
-	t.Logf("%s\n", key.String())
-	t.Logf("%s\n", key.PrivateKeyString(privkey))
+	t.Log(key.String())
+	t.Log(key.PrivateKeyString(privkey))
 }
 
 func TestGenerateRSA(t *testing.T) {
@@ -79,8 +79,8 @@ func TestGenerateRSA(t *testing.T) {
 	key.Protocol = 3
 	key.Algorithm = RSASHA256
 	privkey, _ := key.Generate(1024)
-	t.Logf("%s\n", key.String())
-	t.Logf("%s\n", key.PrivateKeyString(privkey))
+	t.Log(key.String())
+	t.Log(key.PrivateKeyString(privkey))
 }
 
 func TestSecure(t *testing.T) {
@@ -200,7 +200,7 @@ func TestSignVerify(t *testing.T) {
 			t.Error("failure to validate")
 			continue
 		}
-		t.Logf("validated: %s\n", r.Header().Name)
+		t.Logf("validated: %s", r.Header().Name)
 	}
 }
 
@@ -236,7 +236,7 @@ func Test65534(t *testing.T) {
 		t.Error(err)
 		t.Error("failure to validate")
 	} else {
-		t.Logf("validated: %s\n", t6.Header().Name)
+		t.Logf("validated: %s", t6.Header().Name)
 	}
 }
 
@@ -285,7 +285,7 @@ func TestTag(t *testing.T) {
 
 	tag := key.KeyTag()
 	if tag != 12051 {
-		t.Errorf("wrong key tag: %d for key %v\n", tag, key)
+		t.Errorf("wrong key tag: %d for key %v", tag, key)
 	}
 }
 
@@ -346,7 +346,7 @@ func TestKeyToDS(t *testing.T) {
 
 	ds := key.ToDS(SHA1)
 	if strings.ToUpper(ds.Digest) != "B5121BDB5B8D86D0CC5FFAFBAAABE26C3E20BAC1" {
-		t.Errorf("wrong DS digest for SHA1\n%v\n", ds)
+		t.Errorf("wrong DS digest for SHA1\n%v", ds)
 	}
 }
 
@@ -371,7 +371,7 @@ Activate: 20110302104537`
 	k := xk.(*DNSKEY)
 	p, err := k.NewPrivateKey(priv)
 	if err != nil {
-		t.Errorf("%v\n", err)
+		t.Error(err)
 	}
 	switch priv := p.(type) {
 	case *RSAPrivateKey:
@@ -382,8 +382,7 @@ Activate: 20110302104537`
 		t.Errorf("we should have read an RSA key: %v", priv)
 	}
 	if k.KeyTag() != 37350 {
-		t.Errorf("%d %v\n", k.KeyTag(), k)
-		t.Error("keytag should be 37350")
+		t.Errorf("keytag should be 37350, got %d %v", k.KeyTag(), k)
 	}
 
 	soa := new(SOA)
@@ -406,8 +405,7 @@ Activate: 20110302104537`
 
 	sig.Sign(p, []RR{soa})
 	if sig.Signature != "D5zsobpQcmMmYsUMLxCVEtgAdCvTu8V/IEeP4EyLBjqPJmjt96bwM9kqihsccofA5LIJ7DN91qkCORjWSTwNhzCv7bMyr2o5vBZElrlpnRzlvsFIoAZCD9xg6ZY7ZyzUJmU6IcTwG4v3xEYajcpbJJiyaw/RqR90MuRdKPiBzSo=" {
-		t.Error("signature is not correct")
-		t.Errorf("%v\n", sig)
+		t.Errorf("signature is not correct: %v", sig)
 	}
 }
 
@@ -422,11 +420,11 @@ PrivateKey: WURgWHCcYIYUPWgeLmiPY2DJJk02vgrmTfitxgqcL4vwW7BOrbawVmVe0d9V94SR`
 
 	eckey, err := NewRR(pub)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 	privkey, err := eckey.(*DNSKEY).NewPrivateKey(priv)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 	// TODO: Create separate test for this
 	ds := eckey.(*DNSKEY).ToDS(SHA384)
@@ -449,22 +447,21 @@ PrivateKey: WURgWHCcYIYUPWgeLmiPY2DJJk02vgrmTfitxgqcL4vwW7BOrbawVmVe0d9V94SR`
 		t.Fatal("failure to sign the record")
 	}
 
-	if e := sig.Verify(eckey.(*DNSKEY), []RR{a}); e != nil {
-		t.Logf("\n%s\n%s\n%s\n\n%s\n\n",
+	if err := sig.Verify(eckey.(*DNSKEY), []RR{a}); err != nil {
+		t.Fatalf("Failure to validate:\n%s\n%s\n%s\n\n%s\n\n%v",
 			eckey.(*DNSKEY).String(),
 			a.String(),
 			sig.String(),
 			eckey.(*DNSKEY).PrivateKeyString(privkey),
+			err,
 		)
-
-		t.Fatalf("failure to validate: %s", e.Error())
 	}
 }
 
 func TestSignVerifyECDSA2(t *testing.T) {
 	srv1, err := NewRR("srv.miek.nl. IN SRV 1000 800 0 web1.miek.nl.")
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatal(err)
 	}
 	srv := srv1.(*SRV)
 
@@ -500,14 +497,13 @@ func TestSignVerifyECDSA2(t *testing.T) {
 
 	err = sig.Verify(key, []RR{srv})
 	if err != nil {
-		t.Logf("\n%s\n%s\n%s\n\n%s\n\n",
+		t.Logf("Failure to validate:\n%s\n%s\n%s\n\n%s\n\n%v",
 			key.String(),
 			srv.String(),
 			sig.String(),
 			key.PrivateKeyString(privkey),
+			err,
 		)
-
-		t.Fatal("Failure to validate:", err)
 	}
 }
 
@@ -522,11 +518,11 @@ Algorithm: 13 (ECDSAP256SHA256)
 PrivateKey: GU6SnQ/Ou+xC5RumuIUIuJZteXT2z0O/ok1s38Et6mQ=`
 	rrDNSKEY, err := NewRR(exDNSKEY)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 	priv, err := rrDNSKEY.(*DNSKEY).NewPrivateKey(exPriv)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 
 	exDS := `example.net. 3600 IN DS 55648 13 2 (
@@ -534,11 +530,11 @@ PrivateKey: GU6SnQ/Ou+xC5RumuIUIuJZteXT2z0O/ok1s38Et6mQ=`
              e2770ce6d6e37df61d17 )`
 	rrDS, err := NewRR(exDS)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 	ourDS := rrDNSKEY.(*DNSKEY).ToDS(SHA256)
 	if !reflect.DeepEqual(ourDS, rrDS.(*DS)) {
-		t.Errorf("DS record differs:\n%v\n%v\n", ourDS, rrDS.(*DS))
+		t.Errorf("DS record differs:\n%v\n%v", ourDS, rrDS.(*DS))
 	}
 
 	exA := `www.example.net. 3600 IN A 192.0.2.1`
@@ -548,11 +544,11 @@ PrivateKey: GU6SnQ/Ou+xC5RumuIUIuJZteXT2z0O/ok1s38Et6mQ=`
                 yGmt+3SNruPFKG7tZoLBLlUzGGus7ZwmwWep666VCw== )`
 	rrA, err := NewRR(exA)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 	rrRRSIG, err := NewRR(exRRSIG)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 	if err = rrRRSIG.(*RRSIG).Verify(rrDNSKEY.(*DNSKEY), []RR{rrA}); err != nil {
 		t.Errorf("Failure to validate the spec RRSIG: %v", err)
@@ -570,7 +566,7 @@ PrivateKey: GU6SnQ/Ou+xC5RumuIUIuJZteXT2z0O/ok1s38Et6mQ=`
 	ourRRSIG.Inception, _ = StringToTime("20100812100439")
 	err = ourRRSIG.Sign(priv, []RR{rrA})
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 
 	if err = ourRRSIG.Verify(rrDNSKEY.(*DNSKEY), []RR{rrA}); err != nil {
@@ -581,7 +577,7 @@ PrivateKey: GU6SnQ/Ou+xC5RumuIUIuJZteXT2z0O/ok1s38Et6mQ=`
 	rrRRSIG.(*RRSIG).Signature = ""
 	ourRRSIG.Signature = ""
 	if !reflect.DeepEqual(ourRRSIG, rrRRSIG.(*RRSIG)) {
-		t.Fatalf("RRSIG record differs:\n%v\n%v\n", ourRRSIG, rrRRSIG.(*RRSIG))
+		t.Fatalf("RRSIG record differs:\n%v\n%v", ourRRSIG, rrRRSIG.(*RRSIG))
 	}
 }
 
@@ -596,11 +592,11 @@ Algorithm: 14 (ECDSAP384SHA384)
 PrivateKey: WURgWHCcYIYUPWgeLmiPY2DJJk02vgrmTfitxgqcL4vwW7BOrbawVmVe0d9V94SR`
 	rrDNSKEY, err := NewRR(exDNSKEY)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 	priv, err := rrDNSKEY.(*DNSKEY).NewPrivateKey(exPriv)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 
 	exDS := `example.net. 3600 IN DS 10771 14 4 (
@@ -609,11 +605,11 @@ PrivateKey: WURgWHCcYIYUPWgeLmiPY2DJJk02vgrmTfitxgqcL4vwW7BOrbawVmVe0d9V94SR`
            6df983d6 )`
 	rrDS, err := NewRR(exDS)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 	ourDS := rrDNSKEY.(*DNSKEY).ToDS(SHA384)
 	if !reflect.DeepEqual(ourDS, rrDS.(*DS)) {
-		t.Fatalf("DS record differs:\n%v\n%v\n", ourDS, rrDS.(*DS))
+		t.Fatalf("DS record differs:\n%v\n%v", ourDS, rrDS.(*DS))
 	}
 
 	exA := `www.example.net. 3600 IN A 192.0.2.1`
@@ -624,11 +620,11 @@ PrivateKey: WURgWHCcYIYUPWgeLmiPY2DJJk02vgrmTfitxgqcL4vwW7BOrbawVmVe0d9V94SR`
            WTSSPdz7wnqXL5bdcJzusdnI0RSMROxxwGipWcJm )`
 	rrA, err := NewRR(exA)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 	rrRRSIG, err := NewRR(exRRSIG)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 	if err = rrRRSIG.(*RRSIG).Verify(rrDNSKEY.(*DNSKEY), []RR{rrA}); err != nil {
 		t.Errorf("Failure to validate the spec RRSIG: %v", err)
@@ -646,7 +642,7 @@ PrivateKey: WURgWHCcYIYUPWgeLmiPY2DJJk02vgrmTfitxgqcL4vwW7BOrbawVmVe0d9V94SR`
 	ourRRSIG.Inception, _ = StringToTime("20100812102025")
 	err = ourRRSIG.Sign(priv, []RR{rrA})
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 
 	if err = ourRRSIG.Verify(rrDNSKEY.(*DNSKEY), []RR{rrA}); err != nil {
@@ -657,6 +653,6 @@ PrivateKey: WURgWHCcYIYUPWgeLmiPY2DJJk02vgrmTfitxgqcL4vwW7BOrbawVmVe0d9V94SR`
 	rrRRSIG.(*RRSIG).Signature = ""
 	ourRRSIG.Signature = ""
 	if !reflect.DeepEqual(ourRRSIG, rrRRSIG.(*RRSIG)) {
-		t.Fatalf("RRSIG record differs:\n%v\n%v\n", ourRRSIG, rrRRSIG.(*RRSIG))
+		t.Fatalf("RRSIG record differs:\n%v\n%v", ourRRSIG, rrRRSIG.(*RRSIG))
 	}
 }
diff --git a/labels_test.go b/labels_test.go
index 40402444..2a3f3d05 100644
--- a/labels_test.go
+++ b/labels_test.go
@@ -52,9 +52,9 @@ func TestSplit(t *testing.T) {
 	}
 	for s, i := range splitter {
 		if x := len(Split(s)); x != i {
-			t.Errorf("labels should be %d, got %d: %s %v\n", i, x, s, Split(s))
+			t.Errorf("labels should be %d, got %d: %s %v", i, x, s, Split(s))
 		} else {
-			t.Logf("%s %v\n", s, Split(s))
+			t.Logf("%s %v", s, Split(s))
 		}
 	}
 }
@@ -70,11 +70,11 @@ func TestSplit2(t *testing.T) {
 		switch len(i) {
 		case 1:
 			if x[0] != i[0] {
-				t.Errorf("labels should be %v, got %v: %s\n", i, x, s)
+				t.Errorf("labels should be %v, got %v: %s", i, x, s)
 			}
 		default:
 			if x[0] != i[0] || x[1] != i[1] || x[2] != i[2] {
-				t.Errorf("labels should be %v, got %v: %s\n", i, x, s)
+				t.Errorf("labels should be %v, got %v: %s", i, x, s)
 			}
 		}
 	}
@@ -103,7 +103,7 @@ func TestPrevLabel(t *testing.T) {
 	for s, i := range prever {
 		x, ok := PrevLabel(s.string, s.int)
 		if i != x {
-			t.Errorf("label should be %d, got %d, %t: preving %d, %s\n", i, x, ok, s.int, s.string)
+			t.Errorf("label should be %d, got %d, %t: preving %d, %s", i, x, ok, s.int, s.string)
 		}
 	}
 }
@@ -118,7 +118,7 @@ func TestCountLabel(t *testing.T) {
 	for s, i := range splitter {
 		x := CountLabel(s)
 		if x != i {
-			t.Errorf("CountLabel should have %d, got %d\n", i, x)
+			t.Errorf("CountLabel should have %d, got %d", i, x)
 		}
 	}
 }
diff --git a/nsecx_test.go b/nsecx_test.go
index b983369d..93e0c63f 100644
--- a/nsecx_test.go
+++ b/nsecx_test.go
@@ -7,12 +7,12 @@ import (
 func TestPackNsec3(t *testing.T) {
 	nsec3 := HashName("dnsex.nl.", SHA1, 0, "DEAD")
 	if nsec3 != "ROCCJAE8BJJU7HN6T7NG3TNM8ACRS87J" {
-		t.Errorf("%v\n", nsec3)
+		t.Error(nsec3)
 	}
 
 	nsec3 = HashName("a.b.c.example.org.", SHA1, 2, "DEAD")
 	if nsec3 != "6LQ07OAHBTOOEU2R9ANI2AT70K5O0RCG" {
-		t.Errorf("%v\n", nsec3)
+		t.Error(nsec3)
 	}
 }
 
diff --git a/parse_test.go b/parse_test.go
index bc7f13ca..5795d3c9 100644
--- a/parse_test.go
+++ b/parse_test.go
@@ -49,17 +49,17 @@ func TestDotLastInLabel(t *testing.T) {
 func TestTooLongDomainName(t *testing.T) {
 	l := "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrsssttt."
 	dom := l + l + l + l + l + l + l
-	_, e := NewRR(dom + " IN A 127.0.0.1")
-	if e == nil {
+	_, err := NewRR(dom + " IN A 127.0.0.1")
+	if err == nil {
 		t.Error("should be too long")
 	} else {
-		t.Logf("error is %s", e.Error())
+		t.Logf("error is %v", err)
 	}
-	_, e = NewRR("..com. IN A 127.0.0.1")
-	if e == nil {
+	_, err = NewRR("..com. IN A 127.0.0.1")
+	if err == nil {
 		t.Error("should fail")
 	} else {
-		t.Logf("error is %s", e.Error())
+		t.Logf("error is %v", err)
 	}
 }
 
@@ -80,7 +80,7 @@ func TestDomainName(t *testing.T) {
 			continue
 		}
 		if ts != n {
-			t.Errorf("must be equal: in: %s, out: %s\n", ts, n)
+			t.Errorf("must be equal: in: %s, out: %s", ts, n)
 		}
 	}
 }
@@ -103,22 +103,22 @@ func TestDomainNameAndTXTEscapes(t *testing.T) {
 		rr2, err := NewRR(s)
 		if err != nil {
 			t.Errorf("Error parsing unpacked RR's string: %v", err)
-			t.Errorf(" Bytes: %v\n", rrbytes)
-			t.Errorf("String: %v\n", s)
+			t.Errorf(" Bytes: %v", rrbytes)
+			t.Errorf("String: %v", s)
 		}
 		repacked := make([]byte, len(rrbytes))
 		if _, err := PackRR(rr2, repacked, 0, nil, false); err != nil {
 			t.Errorf("error packing parsed RR: %v", err)
-			t.Errorf(" original Bytes: %v\n", rrbytes)
-			t.Errorf("unpacked Struct: %V\n", rr1)
-			t.Errorf("  parsed Struct: %V\n", rr2)
+			t.Errorf(" original Bytes: %v", rrbytes)
+			t.Errorf("unpacked Struct: %v", rr1)
+			t.Errorf("  parsed Struct: %v", rr2)
 		}
 		if !bytes.Equal(repacked, rrbytes) {
 			t.Error("packed bytes don't match original bytes")
 			t.Errorf(" original bytes: %v", rrbytes)
 			t.Errorf("   packed bytes: %v", repacked)
-			t.Errorf("unpacked struct: %V", rr1)
-			t.Errorf("  parsed struct: %V", rr2)
+			t.Errorf("unpacked struct: %v", rr1)
+			t.Errorf("  parsed struct: %v", rr2)
 		}
 	}
 }
@@ -195,9 +195,9 @@ func TestDomainQuick(t *testing.T) {
 		buf := make([]byte, 255)
 		off, err := PackDomainName(ds, buf, 0, nil, false)
 		if err != nil {
-			t.Errorf("error packing domain: %s", err.Error())
-			t.Errorf(" bytes: %v\n", db)
-			t.Errorf("string: %v\n", ds)
+			t.Errorf("error packing domain: %v", err)
+			t.Errorf(" bytes: %v", db)
+			t.Errorf("string: %v", ds)
 			return false
 		}
 		if !bytes.Equal(db, buf[:off]) {
@@ -261,14 +261,14 @@ func TestTXTRRQuick(t *testing.T) {
 		buf := make([]byte, len(rrbytes)*3)
 		off, err := PackRR(rr, buf, 0, nil, false)
 		if err != nil {
-			t.Errorf("pack Error: %s\nRR: %V", err.Error(), rr)
+			t.Errorf("pack Error: %v\nRR: %v", err, rr)
 			return false
 		}
 		buf = buf[:off]
 		if !bytes.Equal(buf, rrbytes) {
 			t.Errorf("packed bytes don't match original bytes")
 			t.Errorf("src bytes: %v", rrbytes)
-			t.Errorf("   struct: %V", rr)
+			t.Errorf("   struct: %v", rr)
 			t.Errorf("out bytes: %v", buf)
 			return false
 		}
@@ -279,8 +279,8 @@ func TestTXTRRQuick(t *testing.T) {
 		rrString := rr.String()
 		rr2, err := NewRR(rrString)
 		if err != nil {
-			t.Errorf("error parsing own output: %s", err.Error())
-			t.Errorf("struct: %V", rr)
+			t.Errorf("error parsing own output: %v", err)
+			t.Errorf("struct: %v", rr)
 			t.Errorf("string: %v", rrString)
 			return false
 		}
@@ -294,19 +294,19 @@ func TestTXTRRQuick(t *testing.T) {
 		buf = make([]byte, len(rrbytes)*3)
 		off, err = PackRR(rr2, buf, 0, nil, false)
 		if err != nil {
-			t.Errorf("error packing parsed rr: %s", err.Error())
-			t.Errorf("unpacked Struct: %V", rr)
+			t.Errorf("error packing parsed rr: %v", err)
+			t.Errorf("unpacked Struct: %v", rr)
 			t.Errorf("         string: %v", rrString)
-			t.Errorf("  parsed Struct: %V", rr2)
+			t.Errorf("  parsed Struct: %v", rr2)
 			return false
 		}
 		buf = buf[:off]
 		if !bytes.Equal(buf, rrbytes) {
 			t.Errorf("parsed packed bytes don't match original bytes")
 			t.Errorf("   source bytes: %v", rrbytes)
-			t.Errorf("unpacked struct: %V", rr)
+			t.Errorf("unpacked struct: %v", rr)
 			t.Errorf("         string: %v", rrString)
-			t.Errorf("  parsed struct: %V", rr2)
+			t.Errorf("  parsed struct: %v", rr2)
 			t.Errorf(" repacked bytes: %v", buf)
 			return false
 		}
@@ -334,13 +334,13 @@ func TestParseDirectiveMisc(t *testing.T) {
 		"ONE.MY-ROOTS.NET. 3600000 IN A 192.168.1.1": "ONE.MY-ROOTS.NET.\t3600000\tIN\tA\t192.168.1.1",
 	}
 	for i, o := range tests {
-		rr, e := NewRR(i)
-		if e != nil {
-			t.Error("failed to parse RR: ", e)
+		rr, err := NewRR(i)
+		if err != nil {
+			t.Error("failed to parse RR: ", err)
 			continue
 		}
 		if rr.String() != o {
-			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'\n", i, o, rr.String())
+			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'", i, o, rr.String())
 		} else {
 			t.Logf("RR is OK: `%s'", rr.String())
 		}
@@ -356,13 +356,13 @@ func TestNSEC(t *testing.T) {
 		"localhost.dnssex.nl. IN NSEC www.dnssex.nl. A RRSIG NSec Type65534":                                                                       "localhost.dnssex.nl.\t3600\tIN\tNSEC\twww.dnssex.nl. A RRSIG NSEC TYPE65534",
 	}
 	for i, o := range nsectests {
-		rr, e := NewRR(i)
-		if e != nil {
-			t.Error("failed to parse RR: ", e)
+		rr, err := NewRR(i)
+		if err != nil {
+			t.Error("failed to parse RR: ", err)
 			continue
 		}
 		if rr.String() != o {
-			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'\n", i, o, rr.String())
+			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'", i, o, rr.String())
 		} else {
 			t.Logf("RR is OK: `%s'", rr.String())
 		}
@@ -375,13 +375,13 @@ func TestParseLOC(t *testing.T) {
 		"SW1A2AA.find.me.uk.	LOC	51 0 0.0 N 00 07 39.611 W 0.00m 0.00m 0.00m 0.00m": "SW1A2AA.find.me.uk.\t3600\tIN\tLOC\t51 00 0.000 N 00 07 39.611 W 0m 0.00m 0.00m 0.00m",
 	}
 	for i, o := range lt {
-		rr, e := NewRR(i)
-		if e != nil {
-			t.Error("failed to parse RR: ", e)
+		rr, err := NewRR(i)
+		if err != nil {
+			t.Error("failed to parse RR: ", err)
 			continue
 		}
 		if rr.String() != o {
-			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'\n", i, o, rr.String())
+			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'", i, o, rr.String())
 		} else {
 			t.Logf("RR is OK: `%s'", rr.String())
 		}
@@ -393,13 +393,13 @@ func TestParseDS(t *testing.T) {
 		"example.net. 3600 IN DS 40692 12 3 22261A8B0E0D799183E35E24E2AD6BB58533CBA7E3B14D659E9CA09B 2071398F": "example.net.\t3600\tIN\tDS\t40692 12 3 22261A8B0E0D799183E35E24E2AD6BB58533CBA7E3B14D659E9CA09B2071398F",
 	}
 	for i, o := range dt {
-		rr, e := NewRR(i)
-		if e != nil {
-			t.Error("failed to parse RR: ", e)
+		rr, err := NewRR(i)
+		if err != nil {
+			t.Error("failed to parse RR: ", err)
 			continue
 		}
 		if rr.String() != o {
-			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'\n", i, o, rr.String())
+			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'", i, o, rr.String())
 		} else {
 			t.Logf("RR is OK: `%s'", rr.String())
 		}
@@ -427,13 +427,13 @@ func TestQuotes(t *testing.T) {
 		"cid.urn.arpa. NAPTR 100 10 \"\" \"\" \"/urn:cid:.+@([^\\.]+\\.)(.*)$/\\2/i\" .":     "cid.urn.arpa.\t3600\tIN\tNAPTR\t100 10 \"\" \"\" \"/urn:cid:.+@([^\\.]+\\.)(.*)$/\\2/i\" .",
 	}
 	for i, o := range tests {
-		rr, e := NewRR(i)
-		if e != nil {
-			t.Error("failed to parse RR: ", e)
+		rr, err := NewRR(i)
+		if err != nil {
+			t.Error("failed to parse RR: ", err)
 			continue
 		}
 		if rr.String() != o {
-			t.Errorf("`%s' should be equal to\n`%s', but is\n`%s'\n", i, o, rr.String())
+			t.Errorf("`%s' should be equal to\n`%s', but is\n`%s'", i, o, rr.String())
 		} else {
 			t.Logf("RR is OK: `%s'", rr.String())
 		}
@@ -450,13 +450,13 @@ func TestParseClass(t *testing.T) {
 		"t.example.com. NONE A 127.0.0.1": "t.example.com.	3600	NONE	A	127.0.0.1",
 	}
 	for i, o := range tests {
-		rr, e := NewRR(i)
-		if e != nil {
-			t.Error("failed to parse RR: ", e)
+		rr, err := NewRR(i)
+		if err != nil {
+			t.Error("failed to parse RR: ", err)
 			continue
 		}
 		if rr.String() != o {
-			t.Errorf("`%s' should be equal to\n`%s', but is\n`%s'\n", i, o, rr.String())
+			t.Errorf("`%s' should be equal to\n`%s', but is\n`%s'", i, o, rr.String())
 		} else {
 			t.Logf("RR is OK: `%s'", rr.String())
 		}
@@ -501,13 +501,13 @@ func TestBrace(t *testing.T) {
                         )`: "miek.nl.\t86400\tIN\tSOA\telektron.atoom.net. miekg.atoom.net. 2009032802 21600 7200 604800 3600",
 	}
 	for i, o := range tests {
-		rr, e := NewRR(i)
-		if e != nil {
-			t.Errorf("failed to parse RR: %v\n\t%d", e, i)
+		rr, err := NewRR(i)
+		if err != nil {
+			t.Errorf("failed to parse RR: %v\n\t%s", err, i)
 			continue
 		}
 		if rr.String() != o {
-			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'\n", i, o, rr.String())
+			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'", i, o, rr.String())
 		} else {
 			t.Logf("RR is OK: `%s'", rr.String())
 		}
@@ -551,10 +551,10 @@ test                          IN CNAME test.a.example.com.
 	for x := range to {
 		i++
 		if x.Error != nil {
-			t.Errorf("%s\n", x.Error)
+			t.Error(x.Error)
 			continue
 		}
-		t.Logf("%s\n", x.RR)
+		t.Log(x.RR)
 	}
 	delta := time.Now().UnixNano() - start
 	t.Logf("%d RRs parsed in %.2f s (%.2f RR/s)", i, float32(delta)/1e9, float32(i)/(float32(delta)/1e9))
@@ -598,7 +598,7 @@ moutamassey             NS      ns01.yahoodomains.jp.
 `
 	to := ParseZone(strings.NewReader(zone), "", "testzone")
 	for x := range to {
-		fmt.Printf("%s\n", x.RR)
+		fmt.Println(x.RR)
 	}
 	// Output:
 	// name.	3600	IN	SOA	a6.nstld.com. hostmaster.nic.name. 203362132 300 300 1209600 300
@@ -631,7 +631,7 @@ func ExampleHIP() {
 b1slImA8YVJyuIDsj7kwzG7jnERNqnWxZ48AWkskmdHaVDP4BcelrTI3rMXdXF5D
         rvs.example.com. )`
 	if hip, err := NewRR(h); err == nil {
-		fmt.Printf("%s\n", hip.String())
+		fmt.Println(hip.String())
 	}
 	// Output:
 	// www.example.com.	3600	IN	HIP	2 200100107B1A74DF365639CC39F1D578 AwEAAbdxyhNuSutc5EMzxTs9LBPCIkOFH8cIvM4p9+LrV4e19WzK00+CI6zBCQTdtWsuxKbWIy87UOoJTwkUs7lBu+Upr1gsNrut79ryra+bSRGQb1slImA8YVJyuIDsj7kwzG7jnERNqnWxZ48AWkskmdHaVDP4BcelrTI3rMXdXF5D rvs.example.com.
@@ -659,17 +659,17 @@ b1slImA8YVJyuIDsj7kwzG7jnERNqnWxZ48AWkskmdHaVDP4BcelrTI3rMXdXF5D
 		t.Fatalf("failed to unpack msg: %s", err)
 	}
 	if len(msg.Answer) != 2 {
-		t.Fatalf("2 answers expected: %V", msg)
+		t.Fatalf("2 answers expected: %v", msg)
 	}
 	for i, rr := range msg.Answer {
 		rr := rr.(*HIP)
 		t.Logf("RR: %s", rr)
 		if l := len(rr.RendezvousServers); l != 2 {
-			t.Fatalf("2 servers expected, only %d in record %d:\n%V", l, i, msg)
+			t.Fatalf("2 servers expected, only %d in record %d:\n%v", l, i, msg)
 		}
 		for j, s := range []string{"rvs1.example.com.", "rvs2.example.com."} {
 			if rr.RendezvousServers[j] != s {
-				t.Fatalf("expected server %d of record %d to be %s:\n%V", j, i, s, msg)
+				t.Fatalf("expected server %d of record %d to be %s:\n%v", j, i, s, msg)
 			}
 		}
 	}
@@ -678,7 +678,7 @@ b1slImA8YVJyuIDsj7kwzG7jnERNqnWxZ48AWkskmdHaVDP4BcelrTI3rMXdXF5D
 func ExampleSOA() {
 	s := "example.com. 1000 SOA master.example.com. admin.example.com. 1 4294967294 4294967293 4294967295 100"
 	if soa, err := NewRR(s); err == nil {
-		fmt.Printf("%s\n", soa.String())
+		fmt.Println(soa.String())
 	}
 	// Output:
 	// example.com.	1000	IN	SOA	master.example.com. admin.example.com. 1 4294967294 4294967293 4294967295 100
@@ -705,14 +705,13 @@ func TestLineNumberError2(t *testing.T) {
 		`example.com 1000 IN TALINK ( a.example.com.  b...example.com.
 	)`: "dns: bad TALINK NextName: \"b...example.com.\" at line: 2:1"}
 
-	for in, err := range tests {
-		_, e := NewRR(in)
-		if e == nil {
-			t.Error("e is nil")
+	for in, errStr := range tests {
+		_, err := NewRR(in)
+		if err == nil {
+			t.Error("err is nil")
 		} else {
-			if e.Error() != err {
-				t.Errorf("%s\n", in)
-				t.Errorf("error should be %s is %s\n", err, e.Error())
+			if err.Error() != errStr {
+				t.Errorf("%s: error should be %s is %v", in, errStr, err)
 			}
 		}
 	}
@@ -786,7 +785,7 @@ func TestLowercaseTokens(t *testing.T) {
 	for _, testrr := range testrecords {
 		_, err := NewRR(testrr)
 		if err != nil {
-			t.Errorf("failed to parse %#v, got %s", testrr, err.Error())
+			t.Errorf("failed to parse %#v, got %v", testrr, err)
 		}
 	}
 }
@@ -797,7 +796,7 @@ func ExampleGenerate() {
 	to := ParseZone(strings.NewReader(zone), "0.0.192.IN-ADDR.ARPA.", "")
 	for x := range to {
 		if x.Error == nil {
-			fmt.Printf("%s\n", x.RR.String())
+			fmt.Println(x.RR.String())
 		}
 	}
 	// Output:
@@ -848,25 +847,25 @@ func TestSRVPacking(t *testing.T) {
 
 	_, err := msg.Pack()
 	if err != nil {
-		t.Fatalf("couldn't pack %v\n", msg)
+		t.Fatalf("couldn't pack %v: %v", msg, err)
 	}
 }
 
 func TestParseBackslash(t *testing.T) {
-	if r, e := NewRR("nul\\000gap.test.globnix.net. 600 IN	A 192.0.2.10"); e != nil {
+	if r, err := NewRR("nul\\000gap.test.globnix.net. 600 IN	A 192.0.2.10"); err != nil {
 		t.Errorf("could not create RR with \\000 in it")
 	} else {
-		t.Logf("parsed %s\n", r.String())
+		t.Logf("parsed %s", r.String())
 	}
-	if r, e := NewRR(`nul\000gap.test.globnix.net. 600 IN TXT "Hello\123"`); e != nil {
+	if r, err := NewRR(`nul\000gap.test.globnix.net. 600 IN TXT "Hello\123"`); err != nil {
 		t.Errorf("could not create RR with \\000 in it")
 	} else {
-		t.Logf("parsed %s\n", r.String())
+		t.Logf("parsed %s", r.String())
 	}
-	if r, e := NewRR(`m\ @\ iek.nl. IN 3600 A 127.0.0.1`); e != nil {
+	if r, err := NewRR(`m\ @\ iek.nl. IN 3600 A 127.0.0.1`); err != nil {
 		t.Errorf("could not create RR with \\ and \\@ in it")
 	} else {
-		t.Logf("parsed %s\n", r.String())
+		t.Logf("parsed %s", r.String())
 	}
 }
 
@@ -886,9 +885,9 @@ func TestILNP(t *testing.T) {
 		"host1.example.com.\t3600\tIN\tLP\t20 l32-subnet1.example.com.",
 	}
 	for _, t1 := range tests {
-		r, e := NewRR(t1)
-		if e != nil {
-			t.Fatalf("an error occured: %s\n", e.Error())
+		r, err := NewRR(t1)
+		if err != nil {
+			t.Fatalf("an error occurred: %v", err)
 		} else {
 			if t1 != r.String() {
 				t.Fatalf("strings should be equal %s %s", t1, r.String())
@@ -908,13 +907,13 @@ func TestNsapGposEidNimloc(t *testing.T) {
 		"VAXA.     IN EID     3141592653589793":                                    "VAXA.\t3600\tIN\tEID\t3141592653589793",
 	}
 	for i, o := range dt {
-		rr, e := NewRR(i)
-		if e != nil {
-			t.Error("failed to parse RR: ", e.Error())
+		rr, err := NewRR(i)
+		if err != nil {
+			t.Error("failed to parse RR: ", err)
 			continue
 		}
 		if rr.String() != o {
-			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'\n", i, o, rr.String())
+			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'", i, o, rr.String())
 		} else {
 			t.Logf("RR is OK: `%s'", rr.String())
 		}
@@ -927,13 +926,13 @@ func TestPX(t *testing.T) {
 		"ab.net2.it. IN PX 10 ab.net2.it. O-ab.PRMD-net2.ADMDb.C-it.": "ab.net2.it.\t3600\tIN\tPX\t10 ab.net2.it. O-ab.PRMD-net2.ADMDb.C-it.",
 	}
 	for i, o := range dt {
-		rr, e := NewRR(i)
-		if e != nil {
-			t.Error("failed to parse RR: ", e.Error())
+		rr, err := NewRR(i)
+		if err != nil {
+			t.Error("failed to parse RR: ", err)
 			continue
 		}
 		if rr.String() != o {
-			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'\n", i, o, rr.String())
+			t.Errorf("`%s' should be equal to\n`%s', but is     `%s'", i, o, rr.String())
 		} else {
 			t.Logf("RR is OK: `%s'", rr.String())
 		}
@@ -980,12 +979,12 @@ func TestEUIxx(t *testing.T) {
 		"host.example. IN EUI64 00-00-5e-ef-00-00-00-2a": "host.example.\t3600\tIN\tEUI64\t00-00-5e-ef-00-00-00-2a",
 	}
 	for i, o := range tests {
-		r, e := NewRR(i)
-		if e != nil {
-			t.Errorf("failed to parse %s: %s\n", i, e.Error())
+		r, err := NewRR(i)
+		if err != nil {
+			t.Errorf("failed to parse %s: %s", i, err)
 		}
 		if r.String() != o {
-			t.Errorf("want %s, got %s\n", o, r.String())
+			t.Errorf("want %s, got %s", o, r.String())
 		}
 	}
 }
@@ -997,12 +996,12 @@ func TestUserRR(t *testing.T) {
 		"host.example. IN UINFO \"Miek Gieben\"": "host.example.\t3600\tIN\tUINFO\t\"Miek Gieben\"",
 	}
 	for i, o := range tests {
-		r, e := NewRR(i)
-		if e != nil {
-			t.Errorf("failed to parse %s: %s\n", i, e.Error())
+		r, err := NewRR(i)
+		if err != nil {
+			t.Errorf("failed to parse %s: %s", i, err)
 		}
 		if r.String() != o {
-			t.Errorf("want %s, got %s\n", o, r.String())
+			t.Errorf("want %s, got %s", o, r.String())
 		}
 	}
 }
@@ -1072,7 +1071,7 @@ func TestTXT(t *testing.T) {
 func TestTypeXXXX(t *testing.T) {
 	_, err := NewRR("example.com IN TYPE1234 \\# 4 aabbccdd")
 	if err != nil {
-		t.Errorf("failed to parse TYPE1234 RR: %s", err.Error())
+		t.Errorf("failed to parse TYPE1234 RR: %v", err)
 	}
 	_, err = NewRR("example.com IN TYPE655341 \\# 8 aabbccddaabbccdd")
 	if err == nil {
@@ -1087,7 +1086,7 @@ func TestTypeXXXX(t *testing.T) {
 func TestPTR(t *testing.T) {
 	_, err := NewRR("144.2.0.192.in-addr.arpa. 900 IN PTR ilouse03146p0\\(.example.com.")
 	if err != nil {
-		t.Error("failed to parse ", err.Error())
+		t.Error("failed to parse ", err)
 	}
 }
 
@@ -1102,13 +1101,13 @@ func TestDigit(t *testing.T) {
 		"miek\\004.nl. 100 IN TXT \"A\"": 4,
 	}
 	for s, i := range tests {
-		r, e := NewRR(s)
+		r, err := NewRR(s)
 		buf := make([]byte, 40)
-		if e != nil {
-			t.Fatalf("failed to parse %s\n", e.Error())
+		if err != nil {
+			t.Fatalf("failed to parse %v", err)
 		}
 		PackRR(r, buf, 0, nil, false)
-		t.Logf("%v\n", buf)
+		t.Log(buf)
 		if buf[5] != i {
 			t.Fatalf("5 pos must be %d, is %d", i, buf[5])
 		}
@@ -1125,9 +1124,9 @@ func TestParseRRSIGTimestamp(t *testing.T) {
 		`miek.nl.  IN RRSIG SOA 8 2 43200 315565800 4102477800 12051 miek.nl. MVZUyrYwq0iZhMFDDnVXD2BvuNiUJjSYlJAgzyAE6CF875BMvvZa+Sb0 RlSCL7WODQSQHhCx/fegHhVVF+Iz8N8kOLrmXD1+jO3Bm6Prl5UhcsPx WTBsg/kmxbp8sR1kvH4oZJtVfakG3iDerrxNaf0sQwhZzyfJQAqpC7pcBoc=`:          true,
 	}
 	for r := range tests {
-		_, e := NewRR(r)
-		if e != nil {
-			t.Errorf("%s\n", e.Error())
+		_, err := NewRR(r)
+		if err != nil {
+			t.Error(err)
 		}
 	}
 }
@@ -1139,10 +1138,9 @@ func TestTxtEqual(t *testing.T) {
 	rr2, _ := NewRR(rr1.String())
 	if rr1.String() != rr2.String() {
 		// This is not an error, but keep this test.
-		t.Errorf("these two TXT records should match")
-		t.Errorf("\n%s\n%s\n", rr1.String(), rr2.String())
+		t.Errorf("these two TXT records should match:\n%s\n%s", rr1.String(), rr2.String())
 	}
-	t.Logf("\n%s\n%s\n", rr1.String(), rr2.String())
+	t.Logf("%s\n%s", rr1.String(), rr2.String())
 }
 
 func TestTxtLong(t *testing.T) {
@@ -1206,15 +1204,14 @@ func TestNewPrivateKey(t *testing.T) {
 		key.Algorithm = algo.name
 		privkey, err := key.Generate(algo.bits)
 		if err != nil {
-			t.Fatal(err.Error())
+			t.Fatal(err)
 		}
 
 		newPrivKey, err := key.NewPrivateKey(key.PrivateKeyString(privkey))
 		if err != nil {
 			t.Error(key.String())
 			t.Error(key.PrivateKeyString(privkey))
-
-			t.Fatal(err.Error())
+			t.Fatal(err)
 		}
 
 		switch newPrivKey := newPrivKey.(type) {
@@ -1223,7 +1220,7 @@ func TestNewPrivateKey(t *testing.T) {
 		}
 
 		if !reflect.DeepEqual(privkey, newPrivKey) {
-			t.Errorf("[%v] Private keys differ:\n%#v\n%#v\n", AlgorithmToString[algo.name], privkey, newPrivKey)
+			t.Errorf("[%v] Private keys differ:\n%#v\n%#v", AlgorithmToString[algo.name], privkey, newPrivKey)
 		}
 	}
 }
@@ -1347,14 +1344,13 @@ func TestParseIPSECKEY(t *testing.T) {
 	for i := 0; i < len(tests)-1; i++ {
 		t1 := tests[i]
 		e1 := tests[i+1]
-		r, e := NewRR(t1)
-		if e != nil {
-			t.Errorf("failed to parse IPSECKEY %s", e)
+		r, err := NewRR(t1)
+		if err != nil {
+			t.Errorf("failed to parse IPSECKEY %v", err)
 			continue
 		}
 		if r.String() != e1 {
-			t.Errorf("these two IPSECKEY records should match")
-			t.Errorf("\n%s\n%s\n", r.String(), e1)
+			t.Errorf("these two IPSECKEY records should match:\n%s\n%s", r.String(), e1)
 		}
 		i++
 	}
diff --git a/server_test.go b/server_test.go
index c83c9e6c..3b908bac 100644
--- a/server_test.go
+++ b/server_test.go
@@ -310,7 +310,7 @@ func TestServingLargeResponses(t *testing.T) {
 	M.Unlock()
 	_, _, err = c.Exchange(m, addrstr)
 	if err != nil {
-		t.Errorf("failed to exchange: %s", err.Error())
+		t.Errorf("failed to exchange: %v", err)
 	}
 	// This must fail
 	M.Lock()
@@ -324,7 +324,7 @@ func TestServingLargeResponses(t *testing.T) {
 	c.UDPSize = 7000
 	_, _, err = c.Exchange(m, addrstr)
 	if err != nil {
-		t.Errorf("failed to exchange: %s", err.Error())
+		t.Errorf("failed to exchange: %v", err)
 	}
 }
 
diff --git a/update_test.go b/update_test.go
index d94f6f4a..921cc178 100644
--- a/update_test.go
+++ b/update_test.go
@@ -12,9 +12,9 @@ func TestDynamicUpdateParsing(t *testing.T) {
 			typ == "TSIG" || typ == "ISDN" || typ == "UNSPEC" || typ == "NULL" || typ == "ATMA" {
 			continue
 		}
-		r, e := NewRR(prefix + typ)
-		if e != nil {
-			t.Error("failure to parse: " + prefix + typ)
+		r, err := NewRR(prefix + typ)
+		if err != nil {
+			t.Errorf("failure to parse: %s %s: %v", prefix, typ, err)
 		} else {
 			t.Logf("parsed: %s", r.String())
 		}
@@ -30,7 +30,7 @@ func TestDynamicUpdateUnpack(t *testing.T) {
 	msg := new(Msg)
 	err := msg.Unpack(buf)
 	if err != nil {
-		t.Error("failed to unpack: " + err.Error() + "\n" + msg.String())
+		t.Error("failed to unpack: %v\n%s", err, msg.String())
 	}
 }
 
diff --git a/xfr_test.go b/xfr_test.go
index f0f09c38..f9707234 100644
--- a/xfr_test.go
+++ b/xfr_test.go
@@ -7,8 +7,8 @@ import (
 )
 
 func getIP(s string) string {
-	a, e := net.LookupAddr(s)
-	if e != nil {
+	a, err := net.LookupAddr(s)
+	if err != nil {
 		return ""
 	}
 	return a[0]
@@ -32,7 +32,7 @@ func testClientAXFR(t *testing.T) {
 	} else {
 		for ex := range a {
 			if ex.Error != nil {
-				t.Errorf("error %s\n", ex.Error.Error())
+				t.Errorf("error %v", ex.Error)
 				break
 			}
 			for _, rr := range ex.RR {
@@ -54,12 +54,11 @@ func testClientAXFRMultipleEnvelopes(t *testing.T) {
 
 	tr := new(Transfer)
 	if a, err := tr.In(m, net.JoinHostPort(server, "53")); err != nil {
-		t.Fatal("Failed to setup axfr" + err.Error() + "for server: " + server)
-		return
+		t.Fatalf("Failed to setup axfr %v for server: %v", err, server)
 	} else {
 		for ex := range a {
 			if ex.Error != nil {
-				t.Errorf("Error %s\n", ex.Error.Error())
+				t.Errorf("Error %v", ex.Error)
 				break
 			}
 		}
@@ -82,7 +81,7 @@ func testClientTsigAXFR(t *testing.T) {
 	} else {
 		for ex := range a {
 			if ex.Error != nil {
-				t.Errorf("error %s\n", ex.Error.Error())
+				t.Errorf("error %v", ex.Error)
 				break
 			}
 			for _, rr := range ex.RR {