Merge pull request #186 from michaelharo/tests
Convert tests from being t.Log(..) then t.Fail() to just t.Error(...)
This commit is contained in:
Miek Gieben
commit
3ec344b2c8
|
|
@ -21,24 +21,20 @@ func TestClientSync(t *testing.T) {
|
|||
c := new(Client)
|
||||
r, _, e := c.Exchange(m, addrstr)
|
||||
if e != nil {
|
||||
t.Logf("failed to exchange: %s", e.Error())
|
||||
t.Fail()
|
||||
t.Errorf("failed to exchange: %s", e.Error())
|
||||
}
|
||||
if r != nil && r.Rcode != RcodeSuccess {
|
||||
t.Log("failed to get an valid answer")
|
||||
t.Fail()
|
||||
t.Logf("%v\n", r)
|
||||
t.Error("failed to get an valid answer")
|
||||
t.Errorf("%v\n", r)
|
||||
}
|
||||
// And now with plain Exchange().
|
||||
r, e = Exchange(m, addrstr)
|
||||
if e != nil {
|
||||
t.Logf("failed to exchange: %s", e.Error())
|
||||
t.Fail()
|
||||
t.Errorf("failed to exchange: %s", e.Error())
|
||||
}
|
||||
if r != nil && r.Rcode != RcodeSuccess {
|
||||
t.Log("failed to get an valid answer")
|
||||
t.Fail()
|
||||
t.Logf("%v\n", r)
|
||||
t.Error("failed to get an valid answer")
|
||||
t.Errorf("%v\n", r)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -60,14 +56,12 @@ func TestClientEDNS0(t *testing.T) {
|
|||
c := new(Client)
|
||||
r, _, e := c.Exchange(m, addrstr)
|
||||
if e != nil {
|
||||
t.Logf("failed to exchange: %s", e.Error())
|
||||
t.Fail()
|
||||
t.Errorf("failed to exchange: %s", e.Error())
|
||||
}
|
||||
|
||||
if r != nil && r.Rcode != RcodeSuccess {
|
||||
t.Log("failed to get an valid answer")
|
||||
t.Fail()
|
||||
t.Logf("%v\n", r)
|
||||
t.Error("failed to get an valid answer")
|
||||
t.Errorf("%v\n", r)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -106,8 +100,7 @@ Loop:
|
|||
first = rtt
|
||||
} else {
|
||||
if first != rtt {
|
||||
t.Log("all rtts should be equal")
|
||||
t.Fail()
|
||||
t.Error("all rtts should be equal")
|
||||
}
|
||||
}
|
||||
i++
|
||||
|
|
@ -142,7 +135,6 @@ func ExampleUpdateLeaseTSIG(t *testing.T) {
|
|||
|
||||
_, _, err := c.Exchange(m, "127.0.0.1:53")
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
t.Fail()
|
||||
t.Error(err.Error())
|
||||
}
|
||||
}
|
||||
|
|
|
|||
76
dns_test.go
76
dns_test.go
|
|
@ -17,13 +17,11 @@ func TestPackUnpack(t *testing.T) {
|
|||
out.Answer[0] = key
|
||||
msg, err := out.Pack()
|
||||
if err != nil {
|
||||
t.Log("failed to pack msg with DNSKEY")
|
||||
t.Fail()
|
||||
t.Error("failed to pack msg with DNSKEY")
|
||||
}
|
||||
in := new(Msg)
|
||||
if in.Unpack(msg) != nil {
|
||||
t.Log("failed to unpack msg with DNSKEY")
|
||||
t.Fail()
|
||||
t.Error("failed to unpack msg with DNSKEY")
|
||||
}
|
||||
|
||||
sig := new(RRSIG)
|
||||
|
|
@ -35,13 +33,11 @@ func TestPackUnpack(t *testing.T) {
|
|||
out.Answer[0] = sig
|
||||
msg, err = out.Pack()
|
||||
if err != nil {
|
||||
t.Log("failed to pack msg with RRSIG")
|
||||
t.Fail()
|
||||
t.Error("failed to pack msg with RRSIG")
|
||||
}
|
||||
|
||||
if in.Unpack(msg) != nil {
|
||||
t.Log("failed to unpack msg with RRSIG")
|
||||
t.Fail()
|
||||
t.Error("failed to unpack msg with RRSIG")
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -62,8 +58,7 @@ func TestPackUnpack2(t *testing.T) {
|
|||
m.Answer[0] = rr
|
||||
_, err := m.Pack()
|
||||
if err != nil {
|
||||
t.Log("Packing failed: " + err.Error())
|
||||
t.Fail()
|
||||
t.Error("Packing failed: ", err.Error())
|
||||
return
|
||||
}
|
||||
}
|
||||
|
|
@ -90,16 +85,14 @@ func TestPackUnpack3(t *testing.T) {
|
|||
m.Answer[0] = rr
|
||||
b, err := m.Pack()
|
||||
if err != nil {
|
||||
t.Log("packing failed: " + err.Error())
|
||||
t.Fail()
|
||||
t.Error("packing failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
var unpackMsg Msg
|
||||
err = unpackMsg.Unpack(b)
|
||||
if err != nil {
|
||||
t.Log("unpacking failed")
|
||||
t.Fail()
|
||||
t.Error("unpacking failed")
|
||||
return
|
||||
}
|
||||
}
|
||||
|
|
@ -111,10 +104,9 @@ func TestBailiwick(t *testing.T) {
|
|||
}
|
||||
for parent, child := range yes {
|
||||
if !IsSubDomain(parent, child) {
|
||||
t.Logf("%s should be child of %s\n", child, parent)
|
||||
t.Logf("comparelabels %d", CompareDomainName(parent, child))
|
||||
t.Logf("lenlabels %d %d", CountLabel(parent), CountLabel(child))
|
||||
t.Fail()
|
||||
t.Errorf("%s should be child of %s\n", child, parent)
|
||||
t.Errorf("comparelabels %d", CompareDomainName(parent, child))
|
||||
t.Errorf("lenlabels %d %d", CountLabel(parent), CountLabel(child))
|
||||
}
|
||||
}
|
||||
no := map[string]string{
|
||||
|
|
@ -126,10 +118,9 @@ func TestBailiwick(t *testing.T) {
|
|||
}
|
||||
for parent, child := range no {
|
||||
if IsSubDomain(parent, child) {
|
||||
t.Logf("%s should not be child of %s\n", child, parent)
|
||||
t.Logf("comparelabels %d", CompareDomainName(parent, child))
|
||||
t.Logf("lenlabels %d %d", CountLabel(parent), CountLabel(child))
|
||||
t.Fail()
|
||||
t.Errorf("%s should not be child of %s\n", child, parent)
|
||||
t.Errorf("comparelabels %d", CompareDomainName(parent, child))
|
||||
t.Errorf("lenlabels %d %d", CountLabel(parent), CountLabel(child))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -142,13 +133,11 @@ func TestPack(t *testing.T) {
|
|||
for _, r := range rr {
|
||||
m.Answer[0], err = NewRR(r)
|
||||
if err != nil {
|
||||
t.Logf("failed to create RR: %s\n", err.Error())
|
||||
t.Fail()
|
||||
t.Errorf("failed to create RR: %s\n", err.Error())
|
||||
continue
|
||||
}
|
||||
if _, err := m.Pack(); err != nil {
|
||||
t.Logf("packing failed: %s\n", err.Error())
|
||||
t.Fail()
|
||||
t.Errorf("packing failed: %s\n", err.Error())
|
||||
}
|
||||
}
|
||||
x := new(Msg)
|
||||
|
|
@ -160,20 +149,17 @@ func TestPack(t *testing.T) {
|
|||
// This crashes due to the fact the a.ntpns.org isn't a FQDN
|
||||
// How to recover() from a remove panic()?
|
||||
if _, err := x.Pack(); err == nil {
|
||||
t.Log("packing should fail")
|
||||
t.Fail()
|
||||
t.Error("packing should fail")
|
||||
}
|
||||
x.Answer = make([]RR, 1)
|
||||
x.Answer[0], err = NewRR(rr[0])
|
||||
if _, err := x.Pack(); err == nil {
|
||||
t.Log("packing should fail")
|
||||
t.Fail()
|
||||
t.Error("packing should fail")
|
||||
}
|
||||
x.Question = make([]Question, 1)
|
||||
x.Question[0] = Question{";sd#eddddséâèµââ
â¥âxzztsestxssweewwsssstx@s@Zåµe@cn.pool.ntp.org.", TypeA, ClassINET}
|
||||
if _, err := x.Pack(); err == nil {
|
||||
t.Log("packing should fail")
|
||||
t.Fail()
|
||||
t.Error("packing should fail")
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -186,9 +172,8 @@ 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.Logf("packing failed: %s", err.Error())
|
||||
t.Logf("length %d, need more than %d\n", rr.len(), off)
|
||||
t.Fail()
|
||||
t.Errorf("packing failed: %s", err.Error())
|
||||
t.Errorf("length %d, need more than %d\n", rr.len(), off)
|
||||
} else {
|
||||
t.Logf("buf size needed: %d\n", off)
|
||||
}
|
||||
|
|
@ -229,12 +214,10 @@ func TestMsgCompressLength(t *testing.T) {
|
|||
buf, err := msg.Pack()
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
t.Fail()
|
||||
}
|
||||
if predicted < len(buf) {
|
||||
t.Errorf("predicted compressed length is wrong: predicted %s (len=%d) %d, actual %d\n",
|
||||
msg.Question[0].Name, len(msg.Answer), predicted, len(buf))
|
||||
t.Fail()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -261,12 +244,10 @@ func TestMsgLength(t *testing.T) {
|
|||
buf, err := msg.Pack()
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
t.Fail()
|
||||
}
|
||||
if predicted < len(buf) {
|
||||
t.Errorf("predicted length is wrong: predicted %s (len=%d), actual %d\n",
|
||||
msg.Question[0].Name, predicted, len(buf))
|
||||
t.Fail()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -441,7 +422,7 @@ func TestToRFC3597(t *testing.T) {
|
|||
x := new(RFC3597)
|
||||
x.ToRFC3597(a)
|
||||
if x.String() != `miek.nl. 3600 CLASS1 TYPE1 \# 4 0a000101` {
|
||||
t.Fail()
|
||||
t.Error("string mismatch")
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -455,8 +436,7 @@ func TestNoRdataPack(t *testing.T) {
|
|||
*r.Header() = RR_Header{Name: "miek.nl.", Rrtype: typ, Class: ClassINET, Ttl: 3600}
|
||||
_, e := PackRR(r, data, 0, nil, false)
|
||||
if e != nil {
|
||||
t.Logf("failed to pack RR with zero rdata: %s: %s\n", TypeToString[typ], e.Error())
|
||||
t.Fail()
|
||||
t.Errorf("failed to pack RR with zero rdata: %s: %s\n", TypeToString[typ], e.Error())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -479,8 +459,7 @@ func TestNoRdataUnpack(t *testing.T) {
|
|||
}
|
||||
rr, _, e := UnpackRR(data[:off], 0)
|
||||
if e != nil {
|
||||
t.Logf("failed to unpack RR with zero rdata: %s: %s\n", TypeToString[typ], e.Error())
|
||||
t.Fail()
|
||||
t.Errorf("failed to unpack RR with zero rdata: %s: %s\n", TypeToString[typ], e.Error())
|
||||
}
|
||||
t.Logf("%s\n", rr)
|
||||
}
|
||||
|
|
@ -565,15 +544,13 @@ func TestPackIPSECKEY(t *testing.T) {
|
|||
rr, _ := NewRR(t1)
|
||||
off, e := PackRR(rr, buf, 0, nil, false)
|
||||
if e != nil {
|
||||
t.Logf("failed to pack IPSECKEY %s: %s\n", e, t1)
|
||||
t.Fail()
|
||||
t.Errorf("failed to pack IPSECKEY %s: %s\n", e, t1)
|
||||
continue
|
||||
}
|
||||
|
||||
rr, _, e = UnpackRR(buf[:off], 0)
|
||||
if e != nil {
|
||||
t.Logf("failed to unpack IPSECKEY %s: %s\n", e, t1)
|
||||
t.Fail()
|
||||
t.Errorf("failed to unpack IPSECKEY %s: %s\n", e, t1)
|
||||
}
|
||||
t.Logf("%s\n", rr)
|
||||
}
|
||||
|
|
@ -595,8 +572,7 @@ func TestMsgPackBuffer(t *testing.T) {
|
|||
input, _ := hex.DecodeString(hexData)
|
||||
m := new(Msg)
|
||||
if e := m.Unpack(input); e != nil {
|
||||
t.Logf("packet %d failed to unpack", i)
|
||||
t.Fail()
|
||||
t.Errorf("packet %d failed to unpack", i)
|
||||
continue
|
||||
}
|
||||
t.Logf("packet %d %s\n", i, m.String())
|
||||
|
|
|
|||
|
|
@ -109,8 +109,7 @@ func TestSecure(t *testing.T) {
|
|||
|
||||
// It should validate. Period is checked separately, so this will keep on working
|
||||
if sig.Verify(key, []RR{soa}) != nil {
|
||||
t.Log("failure to validate")
|
||||
t.Fail()
|
||||
t.Error("failure to validate")
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -131,15 +130,13 @@ func TestSignature(t *testing.T) {
|
|||
|
||||
// Should not be valid
|
||||
if sig.ValidityPeriod(time.Now()) {
|
||||
t.Log("should not be valid")
|
||||
t.Fail()
|
||||
t.Error("should not be valid")
|
||||
}
|
||||
|
||||
sig.Inception = 315565800 //Tue Jan 1 10:10:00 CET 1980
|
||||
sig.Expiration = 4102477800 //Fri Jan 1 10:10:00 CET 2100
|
||||
if !sig.ValidityPeriod(time.Now()) {
|
||||
t.Log("should be valid")
|
||||
t.Fail()
|
||||
t.Error("should be valid")
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -196,13 +193,11 @@ func TestSignVerify(t *testing.T) {
|
|||
|
||||
for _, r := range []RR{soa, soa1, srv} {
|
||||
if sig.Sign(privkey, []RR{r}) != nil {
|
||||
t.Log("failure to sign the record")
|
||||
t.Fail()
|
||||
t.Error("failure to sign the record")
|
||||
continue
|
||||
}
|
||||
if sig.Verify(key, []RR{r}) != nil {
|
||||
t.Log("failure to validate")
|
||||
t.Fail()
|
||||
t.Error("failure to validate")
|
||||
continue
|
||||
}
|
||||
t.Logf("validated: %s\n", r.Header().Name)
|
||||
|
|
@ -234,14 +229,12 @@ func Test65534(t *testing.T) {
|
|||
sig.SignerName = key.Hdr.Name
|
||||
sig.Algorithm = RSASHA256
|
||||
if err := sig.Sign(privkey, []RR{t6}); err != nil {
|
||||
t.Log(err)
|
||||
t.Log("failure to sign the TYPE65534 record")
|
||||
t.Fail()
|
||||
t.Error(err)
|
||||
t.Error("failure to sign the TYPE65534 record")
|
||||
}
|
||||
if err := sig.Verify(key, []RR{t6}); err != nil {
|
||||
t.Log(err)
|
||||
t.Log("failure to validate")
|
||||
t.Fail()
|
||||
t.Error(err)
|
||||
t.Error("failure to validate")
|
||||
} else {
|
||||
t.Logf("validated: %s\n", t6.Header().Name)
|
||||
}
|
||||
|
|
@ -271,13 +264,11 @@ Coefficient: UuRoNqe7YHnKmQzE6iDWKTMIWTuoqqrFAmXPmKQnC+Y+BQzOVEHUo9bXdDnoI9hzXP1
|
|||
t.Fatal(err)
|
||||
}
|
||||
if pubkey.(*DNSKEY).PublicKey != "AwEAAZuMCu2FdugHkTrXYgl5qixvcDw1aDDlvL46/xJKbHBAHY16fNUb2b65cwko2Js/aJxUYJbZk5dwCDZxYfrfbZVtDPQuc3o8QaChVxC7/JYz2AHc9qHvqQ1j4VrH71RWINlQo6VYjzN/BGpMhOZoZOEwzp1HfsOE3lNYcoWU1smL" {
|
||||
t.Log("pubkey is not what we've read")
|
||||
t.Fail()
|
||||
t.Error("pubkey is not what we've read")
|
||||
}
|
||||
if pubkey.(*DNSKEY).PrivateKeyString(privkey) != privStr {
|
||||
t.Log("privkey is not what we've read")
|
||||
t.Logf("%v", pubkey.(*DNSKEY).PrivateKeyString(privkey))
|
||||
t.Fail()
|
||||
t.Error("privkey is not what we've read")
|
||||
t.Errorf("%v", pubkey.(*DNSKEY).PrivateKeyString(privkey))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -294,8 +285,7 @@ func TestTag(t *testing.T) {
|
|||
|
||||
tag := key.KeyTag()
|
||||
if tag != 12051 {
|
||||
t.Logf("wrong key tag: %d for key %v\n", tag, key)
|
||||
t.Fail()
|
||||
t.Errorf("wrong key tag: %d for key %v\n", tag, key)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -335,13 +325,11 @@ func TestKeyRSA(t *testing.T) {
|
|||
sig.SignerName = key.Hdr.Name
|
||||
|
||||
if err := sig.Sign(priv, []RR{soa}); err != nil {
|
||||
t.Logf("failed to sign")
|
||||
t.Fail()
|
||||
t.Error("failed to sign")
|
||||
return
|
||||
}
|
||||
if err := sig.Verify(key, []RR{soa}); err != nil {
|
||||
t.Logf("failed to verify")
|
||||
t.Fail()
|
||||
t.Error("failed to verify")
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -358,8 +346,7 @@ func TestKeyToDS(t *testing.T) {
|
|||
|
||||
ds := key.ToDS(SHA1)
|
||||
if strings.ToUpper(ds.Digest) != "B5121BDB5B8D86D0CC5FFAFBAAABE26C3E20BAC1" {
|
||||
t.Logf("wrong DS digest for SHA1\n%v\n", ds)
|
||||
t.Fail()
|
||||
t.Errorf("wrong DS digest for SHA1\n%v\n", ds)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -384,23 +371,19 @@ Activate: 20110302104537`
|
|||
k := xk.(*DNSKEY)
|
||||
p, err := k.NewPrivateKey(priv)
|
||||
if err != nil {
|
||||
t.Logf("%v\n", err)
|
||||
t.Fail()
|
||||
t.Errorf("%v\n", err)
|
||||
}
|
||||
switch priv := p.(type) {
|
||||
case *RSAPrivateKey:
|
||||
if 65537 != priv.PublicKey.E {
|
||||
t.Log("exponenent should be 65537")
|
||||
t.Fail()
|
||||
t.Error("exponenent should be 65537")
|
||||
}
|
||||
default:
|
||||
t.Logf("we should have read an RSA key: %v", priv)
|
||||
t.Fail()
|
||||
t.Errorf("we should have read an RSA key: %v", priv)
|
||||
}
|
||||
if k.KeyTag() != 37350 {
|
||||
t.Logf("%d %v\n", k.KeyTag(), k)
|
||||
t.Log("keytag should be 37350")
|
||||
t.Fail()
|
||||
t.Errorf("%d %v\n", k.KeyTag(), k)
|
||||
t.Error("keytag should be 37350")
|
||||
}
|
||||
|
||||
soa := new(SOA)
|
||||
|
|
@ -423,9 +406,8 @@ Activate: 20110302104537`
|
|||
|
||||
sig.Sign(p, []RR{soa})
|
||||
if sig.Signature != "D5zsobpQcmMmYsUMLxCVEtgAdCvTu8V/IEeP4EyLBjqPJmjt96bwM9kqihsccofA5LIJ7DN91qkCORjWSTwNhzCv7bMyr2o5vBZElrlpnRzlvsFIoAZCD9xg6ZY7ZyzUJmU6IcTwG4v3xEYajcpbJJiyaw/RqR90MuRdKPiBzSo=" {
|
||||
t.Log("signature is not correct")
|
||||
t.Logf("%v\n", sig)
|
||||
t.Fail()
|
||||
t.Error("signature is not correct")
|
||||
t.Errorf("%v\n", sig)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -13,34 +13,27 @@ func TestCompareDomainName(t *testing.T) {
|
|||
s6 := "miek.nl"
|
||||
|
||||
if CompareDomainName(s1, s2) != 2 {
|
||||
t.Logf("%s with %s should be %d", s1, s2, 2)
|
||||
t.Fail()
|
||||
t.Errorf("%s with %s should be %d", s1, s2, 2)
|
||||
}
|
||||
if CompareDomainName(s1, s3) != 1 {
|
||||
t.Logf("%s with %s should be %d", s1, s3, 1)
|
||||
t.Fail()
|
||||
t.Errorf("%s with %s should be %d", s1, s3, 1)
|
||||
}
|
||||
if CompareDomainName(s3, s4) != 0 {
|
||||
t.Logf("%s with %s should be %d", s3, s4, 0)
|
||||
t.Fail()
|
||||
t.Errorf("%s with %s should be %d", s3, s4, 0)
|
||||
}
|
||||
// Non qualified tests
|
||||
if CompareDomainName(s1, s5) != 1 {
|
||||
t.Logf("%s with %s should be %d", s1, s5, 1)
|
||||
t.Fail()
|
||||
t.Errorf("%s with %s should be %d", s1, s5, 1)
|
||||
}
|
||||
if CompareDomainName(s1, s6) != 2 {
|
||||
t.Logf("%s with %s should be %d", s1, s5, 2)
|
||||
t.Fail()
|
||||
t.Errorf("%s with %s should be %d", s1, s5, 2)
|
||||
}
|
||||
|
||||
if CompareDomainName(s1, ".") != 0 {
|
||||
t.Logf("%s with %s should be %d", s1, s5, 0)
|
||||
t.Fail()
|
||||
t.Errorf("%s with %s should be %d", s1, s5, 0)
|
||||
}
|
||||
if CompareDomainName(".", ".") != 0 {
|
||||
t.Logf("%s with %s should be %d", ".", ".", 0)
|
||||
t.Fail()
|
||||
t.Errorf("%s with %s should be %d", ".", ".", 0)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -59,8 +52,7 @@ func TestSplit(t *testing.T) {
|
|||
}
|
||||
for s, i := range splitter {
|
||||
if x := len(Split(s)); x != i {
|
||||
t.Logf("labels should be %d, got %d: %s %v\n", i, x, s, Split(s))
|
||||
t.Fail()
|
||||
t.Errorf("labels should be %d, got %d: %s %v\n", i, x, s, Split(s))
|
||||
} else {
|
||||
t.Logf("%s %v\n", s, Split(s))
|
||||
}
|
||||
|
|
@ -78,13 +70,11 @@ func TestSplit2(t *testing.T) {
|
|||
switch len(i) {
|
||||
case 1:
|
||||
if x[0] != i[0] {
|
||||
t.Logf("labels should be %v, got %v: %s\n", i, x, s)
|
||||
t.Fail()
|
||||
t.Errorf("labels should be %v, got %v: %s\n", i, x, s)
|
||||
}
|
||||
default:
|
||||
if x[0] != i[0] || x[1] != i[1] || x[2] != i[2] {
|
||||
t.Logf("labels should be %v, got %v: %s\n", i, x, s)
|
||||
t.Fail()
|
||||
t.Errorf("labels should be %v, got %v: %s\n", i, x, s)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -113,8 +103,7 @@ func TestPrevLabel(t *testing.T) {
|
|||
for s, i := range prever {
|
||||
x, ok := PrevLabel(s.string, s.int)
|
||||
if i != x {
|
||||
t.Logf("label should be %d, got %d, %t: preving %d, %s\n", i, x, ok, s.int, s.string)
|
||||
t.Fail()
|
||||
t.Errorf("label should be %d, got %d, %t: preving %d, %s\n", i, x, ok, s.int, s.string)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -129,8 +118,7 @@ func TestCountLabel(t *testing.T) {
|
|||
for s, i := range splitter {
|
||||
x := CountLabel(s)
|
||||
if x != i {
|
||||
t.Logf("CountLabel should have %d, got %d\n", i, x)
|
||||
t.Fail()
|
||||
t.Errorf("CountLabel should have %d, got %d\n", i, x)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -149,14 +137,12 @@ domainLoop:
|
|||
for domain, splits := range labels {
|
||||
parts := SplitDomainName(domain)
|
||||
if len(parts) != len(splits) {
|
||||
t.Logf("SplitDomainName returned %v for %s, expected %v", parts, domain, splits)
|
||||
t.Fail()
|
||||
t.Errorf("SplitDomainName returned %v for %s, expected %v", parts, domain, splits)
|
||||
continue domainLoop
|
||||
}
|
||||
for i := range parts {
|
||||
if parts[i] != splits[i] {
|
||||
t.Logf("SplitDomainName returned %v for %s, expected %v", parts, domain, splits)
|
||||
t.Fail()
|
||||
t.Errorf("SplitDomainName returned %v for %s, expected %v", parts, domain, splits)
|
||||
continue domainLoop
|
||||
}
|
||||
}
|
||||
|
|
@ -180,9 +166,8 @@ func TestIsDomainName(t *testing.T) {
|
|||
for d, ok := range names {
|
||||
l, k := IsDomainName(d)
|
||||
if ok.ok != k || ok.lab != l {
|
||||
t.Logf(" got %v %d for %s ", k, l, d)
|
||||
t.Logf("have %v %d for %s ", ok.ok, ok.lab, d)
|
||||
t.Fail()
|
||||
t.Errorf(" got %v %d for %s ", k, l, d)
|
||||
t.Errorf("have %v %d for %s ", ok.ok, ok.lab, d)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,14 +7,12 @@ import (
|
|||
func TestPackNsec3(t *testing.T) {
|
||||
nsec3 := HashName("dnsex.nl.", SHA1, 0, "DEAD")
|
||||
if nsec3 != "ROCCJAE8BJJU7HN6T7NG3TNM8ACRS87J" {
|
||||
t.Logf("%v\n", nsec3)
|
||||
t.Fail()
|
||||
t.Errorf("%v\n", nsec3)
|
||||
}
|
||||
|
||||
nsec3 = HashName("a.b.c.example.org.", SHA1, 2, "DEAD")
|
||||
if nsec3 != "6LQ07OAHBTOOEU2R9ANI2AT70K5O0RCG" {
|
||||
t.Logf("%v\n", nsec3)
|
||||
t.Fail()
|
||||
t.Errorf("%v\n", nsec3)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -22,12 +20,10 @@ func TestNsec3(t *testing.T) {
|
|||
// examples taken from .nl
|
||||
nsec3, _ := NewRR("39p91242oslggest5e6a7cci4iaeqvnk.nl. IN NSEC3 1 1 5 F10E9F7EA83FC8F3 39P99DCGG0MDLARTCRMCF6OFLLUL7PR6 NS DS RRSIG")
|
||||
if !nsec3.(*NSEC3).Cover("snasajsksasasa.nl.") { // 39p94jrinub66hnpem8qdpstrec86pg3
|
||||
t.Logf("39p94jrinub66hnpem8qdpstrec86pg3. should be covered by 39p91242oslggest5e6a7cci4iaeqvnk.nl. - 39P99DCGG0MDLARTCRMCF6OFLLUL7PR6")
|
||||
t.Fail()
|
||||
t.Error("39p94jrinub66hnpem8qdpstrec86pg3. should be covered by 39p91242oslggest5e6a7cci4iaeqvnk.nl. - 39P99DCGG0MDLARTCRMCF6OFLLUL7PR6")
|
||||
}
|
||||
nsec3, _ = NewRR("sk4e8fj94u78smusb40o1n0oltbblu2r.nl. IN NSEC3 1 1 5 F10E9F7EA83FC8F3 SK4F38CQ0ATIEI8MH3RGD0P5I4II6QAN NS SOA TXT RRSIG DNSKEY NSEC3PARAM")
|
||||
if !nsec3.(*NSEC3).Match("nl.") { // sk4e8fj94u78smusb40o1n0oltbblu2r.nl.
|
||||
t.Logf("sk4e8fj94u78smusb40o1n0oltbblu2r.nl. should match sk4e8fj94u78smusb40o1n0oltbblu2r.nl.")
|
||||
t.Fail()
|
||||
t.Error("sk4e8fj94u78smusb40o1n0oltbblu2r.nl. should match sk4e8fj94u78smusb40o1n0oltbblu2r.nl.")
|
||||
}
|
||||
}
|
||||
|
|
|
|||
242
parse_test.go
242
parse_test.go
|
|
@ -20,19 +20,16 @@ func TestDotInName(t *testing.T) {
|
|||
PackDomainName("aa\\.bb.nl.", buf, 0, nil, false)
|
||||
// index 3 must be a real dot
|
||||
if buf[3] != '.' {
|
||||
t.Log("dot should be a real dot")
|
||||
t.Fail()
|
||||
t.Error("dot should be a real dot")
|
||||
}
|
||||
|
||||
if buf[6] != 2 {
|
||||
t.Log("this must have the value 2")
|
||||
t.Fail()
|
||||
t.Error("this must have the value 2")
|
||||
}
|
||||
dom, _, _ := UnpackDomainName(buf, 0)
|
||||
// printing it should yield the backspace again
|
||||
if dom != "aa\\.bb.nl." {
|
||||
t.Log("dot should have been escaped: " + dom)
|
||||
t.Fail()
|
||||
t.Error("dot should have been escaped: ", dom)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -54,15 +51,13 @@ func TestTooLongDomainName(t *testing.T) {
|
|||
dom := l + l + l + l + l + l + l
|
||||
_, e := NewRR(dom + " IN A 127.0.0.1")
|
||||
if e == nil {
|
||||
t.Log("should be too long")
|
||||
t.Fail()
|
||||
t.Error("should be too long")
|
||||
} else {
|
||||
t.Logf("error is %s", e.Error())
|
||||
}
|
||||
_, e = NewRR("..com. IN A 127.0.0.1")
|
||||
if e == nil {
|
||||
t.Log("should fail")
|
||||
t.Fail()
|
||||
t.Error("should fail")
|
||||
} else {
|
||||
t.Logf("error is %s", e.Error())
|
||||
}
|
||||
|
|
@ -76,19 +71,16 @@ func TestDomainName(t *testing.T) {
|
|||
|
||||
for _, ts := range tests {
|
||||
if _, err := PackDomainName(ts, dbuff, 0, nil, false); err != nil {
|
||||
t.Log("not a valid domain name")
|
||||
t.Fail()
|
||||
t.Error("not a valid domain name")
|
||||
continue
|
||||
}
|
||||
n, _, err := UnpackDomainName(dbuff, 0)
|
||||
if err != nil {
|
||||
t.Log("failed to unpack packed domain name")
|
||||
t.Fail()
|
||||
t.Error("failed to unpack packed domain name")
|
||||
continue
|
||||
}
|
||||
if ts != n {
|
||||
t.Logf("must be equal: in: %s, out: %s\n", ts, n)
|
||||
t.Fail()
|
||||
t.Errorf("must be equal: in: %s, out: %s\n", ts, n)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -110,26 +102,23 @@ func TestDomainNameAndTXTEscapes(t *testing.T) {
|
|||
s := rr1.String()
|
||||
rr2, err := NewRR(s)
|
||||
if err != nil {
|
||||
t.Logf("Error parsing unpacked RR's string: %v", err)
|
||||
t.Logf(" Bytes: %v\n", rrbytes)
|
||||
t.Logf("String: %v\n", s)
|
||||
t.Fail()
|
||||
t.Errorf("Error parsing unpacked RR's string: %v", err)
|
||||
t.Errorf(" Bytes: %v\n", rrbytes)
|
||||
t.Errorf("String: %v\n", s)
|
||||
}
|
||||
repacked := make([]byte, len(rrbytes))
|
||||
if _, err := PackRR(rr2, repacked, 0, nil, false); err != nil {
|
||||
t.Logf("error packing parsed RR: %v", err)
|
||||
t.Logf(" original Bytes: %v\n", rrbytes)
|
||||
t.Logf("unpacked Struct: %V\n", rr1)
|
||||
t.Logf(" parsed Struct: %V\n", rr2)
|
||||
t.Fail()
|
||||
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)
|
||||
}
|
||||
if !bytes.Equal(repacked, rrbytes) {
|
||||
t.Log("packed bytes don't match original bytes")
|
||||
t.Logf(" original bytes: %v", rrbytes)
|
||||
t.Logf(" packed bytes: %v", repacked)
|
||||
t.Logf("unpacked struct: %V", rr1)
|
||||
t.Logf(" parsed struct: %V", rr2)
|
||||
t.Fail()
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -206,16 +195,16 @@ func TestDomainQuick(t *testing.T) {
|
|||
buf := make([]byte, 255)
|
||||
off, err := PackDomainName(ds, buf, 0, nil, false)
|
||||
if err != nil {
|
||||
t.Logf("error packing domain: %s", err.Error())
|
||||
t.Logf(" bytes: %v\n", db)
|
||||
t.Logf("string: %v\n", ds)
|
||||
t.Errorf("error packing domain: %s", err.Error())
|
||||
t.Errorf(" bytes: %v\n", db)
|
||||
t.Errorf("string: %v\n", ds)
|
||||
return false
|
||||
}
|
||||
if !bytes.Equal(db, buf[:off]) {
|
||||
t.Logf("repacked domain doesn't match original:")
|
||||
t.Logf("src bytes: %v", db)
|
||||
t.Logf(" string: %v", ds)
|
||||
t.Logf("out bytes: %v", buf[:off])
|
||||
t.Errorf("repacked domain doesn't match original:")
|
||||
t.Errorf("src bytes: %v", db)
|
||||
t.Errorf(" string: %v", ds)
|
||||
t.Errorf("out bytes: %v", buf[:off])
|
||||
return false
|
||||
}
|
||||
return true
|
||||
|
|
@ -272,15 +261,15 @@ func TestTXTRRQuick(t *testing.T) {
|
|||
buf := make([]byte, len(rrbytes)*3)
|
||||
off, err := PackRR(rr, buf, 0, nil, false)
|
||||
if err != nil {
|
||||
t.Logf("pack Error: %s\nRR: %V", err.Error(), rr)
|
||||
t.Errorf("pack Error: %s\nRR: %V", err.Error(), rr)
|
||||
return false
|
||||
}
|
||||
buf = buf[:off]
|
||||
if !bytes.Equal(buf, rrbytes) {
|
||||
t.Logf("packed bytes don't match original bytes")
|
||||
t.Logf("src bytes: %v", rrbytes)
|
||||
t.Logf(" struct: %V", rr)
|
||||
t.Logf("oUt bytes: %v", buf)
|
||||
t.Errorf("packed bytes don't match original bytes")
|
||||
t.Errorf("src bytes: %v", rrbytes)
|
||||
t.Errorf(" struct: %V", rr)
|
||||
t.Errorf("out bytes: %v", buf)
|
||||
return false
|
||||
}
|
||||
if len(rdata) == 0 {
|
||||
|
|
@ -290,35 +279,35 @@ func TestTXTRRQuick(t *testing.T) {
|
|||
rrString := rr.String()
|
||||
rr2, err := NewRR(rrString)
|
||||
if err != nil {
|
||||
t.Logf("error parsing own output: %s", err.Error())
|
||||
t.Logf("struct: %V", rr)
|
||||
t.Logf("string: %v", rrString)
|
||||
t.Errorf("error parsing own output: %s", err.Error())
|
||||
t.Errorf("struct: %V", rr)
|
||||
t.Errorf("string: %v", rrString)
|
||||
return false
|
||||
}
|
||||
if rr2.String() != rrString {
|
||||
t.Logf("parsed rr.String() doesn't match original string")
|
||||
t.Logf("original: %v", rrString)
|
||||
t.Logf(" parsed: %v", rr2.String())
|
||||
t.Errorf("parsed rr.String() doesn't match original string")
|
||||
t.Errorf("original: %v", rrString)
|
||||
t.Errorf(" parsed: %v", rr2.String())
|
||||
return false
|
||||
}
|
||||
|
||||
buf = make([]byte, len(rrbytes)*3)
|
||||
off, err = PackRR(rr2, buf, 0, nil, false)
|
||||
if err != nil {
|
||||
t.Logf("error packing parsed rr: %s", err.Error())
|
||||
t.Logf("unpacked Struct: %V", rr)
|
||||
t.Logf(" string: %v", rrString)
|
||||
t.Logf(" parsed Struct: %V", rr2)
|
||||
t.Errorf("error packing parsed rr: %s", err.Error())
|
||||
t.Errorf("unpacked Struct: %V", rr)
|
||||
t.Errorf(" string: %v", rrString)
|
||||
t.Errorf(" parsed Struct: %V", rr2)
|
||||
return false
|
||||
}
|
||||
buf = buf[:off]
|
||||
if !bytes.Equal(buf, rrbytes) {
|
||||
t.Logf("parsed packed bytes don't match original bytes")
|
||||
t.Logf(" source bytes: %v", rrbytes)
|
||||
t.Logf("unpacked struct: %V", rr)
|
||||
t.Logf(" string: %v", rrString)
|
||||
t.Logf(" parsed struct: %V", rr2)
|
||||
t.Logf(" repacked bytes: %v", buf)
|
||||
t.Errorf("parsed packed bytes don't match original bytes")
|
||||
t.Errorf(" source bytes: %v", rrbytes)
|
||||
t.Errorf("unpacked struct: %V", rr)
|
||||
t.Errorf(" string: %v", rrString)
|
||||
t.Errorf(" parsed struct: %V", rr2)
|
||||
t.Errorf(" repacked bytes: %v", buf)
|
||||
return false
|
||||
}
|
||||
return true
|
||||
|
|
@ -347,13 +336,11 @@ func TestParseDirectiveMisc(t *testing.T) {
|
|||
for i, o := range tests {
|
||||
rr, e := NewRR(i)
|
||||
if e != nil {
|
||||
t.Log("failed to parse RR: " + e.Error())
|
||||
t.Fail()
|
||||
t.Error("failed to parse RR: ", e)
|
||||
continue
|
||||
}
|
||||
if rr.String() != o {
|
||||
t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
t.Fail()
|
||||
t.Errorf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
} else {
|
||||
t.Logf("RR is OK: `%s'", rr.String())
|
||||
}
|
||||
|
|
@ -371,13 +358,11 @@ func TestNSEC(t *testing.T) {
|
|||
for i, o := range nsectests {
|
||||
rr, e := NewRR(i)
|
||||
if e != nil {
|
||||
t.Log("failed to parse RR: " + e.Error())
|
||||
t.Fail()
|
||||
t.Error("failed to parse RR: ", e)
|
||||
continue
|
||||
}
|
||||
if rr.String() != o {
|
||||
t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
t.Fail()
|
||||
t.Errorf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
} else {
|
||||
t.Logf("RR is OK: `%s'", rr.String())
|
||||
}
|
||||
|
|
@ -392,13 +377,11 @@ func TestParseLOC(t *testing.T) {
|
|||
for i, o := range lt {
|
||||
rr, e := NewRR(i)
|
||||
if e != nil {
|
||||
t.Log("failed to parse RR: " + e.Error())
|
||||
t.Fail()
|
||||
t.Error("failed to parse RR: ", e)
|
||||
continue
|
||||
}
|
||||
if rr.String() != o {
|
||||
t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
t.Fail()
|
||||
t.Errorf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
} else {
|
||||
t.Logf("RR is OK: `%s'", rr.String())
|
||||
}
|
||||
|
|
@ -412,13 +395,11 @@ func TestParseDS(t *testing.T) {
|
|||
for i, o := range dt {
|
||||
rr, e := NewRR(i)
|
||||
if e != nil {
|
||||
t.Log("failed to parse RR: " + e.Error())
|
||||
t.Fail()
|
||||
t.Error("failed to parse RR: ", e)
|
||||
continue
|
||||
}
|
||||
if rr.String() != o {
|
||||
t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
t.Fail()
|
||||
t.Errorf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
} else {
|
||||
t.Logf("RR is OK: `%s'", rr.String())
|
||||
}
|
||||
|
|
@ -448,13 +429,11 @@ func TestQuotes(t *testing.T) {
|
|||
for i, o := range tests {
|
||||
rr, e := NewRR(i)
|
||||
if e != nil {
|
||||
t.Log("failed to parse RR: " + e.Error())
|
||||
t.Fail()
|
||||
t.Error("failed to parse RR: ", e)
|
||||
continue
|
||||
}
|
||||
if rr.String() != o {
|
||||
t.Logf("`%s' should be equal to\n`%s', but is\n`%s'\n", i, o, rr.String())
|
||||
t.Fail()
|
||||
t.Errorf("`%s' should be equal to\n`%s', but is\n`%s'\n", i, o, rr.String())
|
||||
} else {
|
||||
t.Logf("RR is OK: `%s'", rr.String())
|
||||
}
|
||||
|
|
@ -473,13 +452,11 @@ func TestParseClass(t *testing.T) {
|
|||
for i, o := range tests {
|
||||
rr, e := NewRR(i)
|
||||
if e != nil {
|
||||
t.Log("failed to parse RR: " + e.Error())
|
||||
t.Fail()
|
||||
t.Error("failed to parse RR: ", e)
|
||||
continue
|
||||
}
|
||||
if rr.String() != o {
|
||||
t.Logf("`%s' should be equal to\n`%s', but is\n`%s'\n", i, o, rr.String())
|
||||
t.Fail()
|
||||
t.Errorf("`%s' should be equal to\n`%s', but is\n`%s'\n", i, o, rr.String())
|
||||
} else {
|
||||
t.Logf("RR is OK: `%s'", rr.String())
|
||||
}
|
||||
|
|
@ -526,13 +503,11 @@ func TestBrace(t *testing.T) {
|
|||
for i, o := range tests {
|
||||
rr, e := NewRR(i)
|
||||
if e != nil {
|
||||
t.Log("failed to parse RR: " + e.Error() + "\n\t" + i)
|
||||
t.Fail()
|
||||
t.Errorf("failed to parse RR: %v\n\t%d", e, i)
|
||||
continue
|
||||
}
|
||||
if rr.String() != o {
|
||||
t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
t.Fail()
|
||||
t.Errorf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
} else {
|
||||
t.Logf("RR is OK: `%s'", rr.String())
|
||||
}
|
||||
|
|
@ -555,8 +530,7 @@ func TestParseFailure(t *testing.T) {
|
|||
for _, s := range tests {
|
||||
_, err := NewRR(s)
|
||||
if err == nil {
|
||||
t.Logf("should have triggered an error: \"%s\"", s)
|
||||
t.Fail()
|
||||
t.Errorf("should have triggered an error: \"%s\"", s)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -577,8 +551,7 @@ test IN CNAME test.a.example.com.
|
|||
for x := range to {
|
||||
i++
|
||||
if x.Error != nil {
|
||||
t.Logf("%s\n", x.Error)
|
||||
t.Fail()
|
||||
t.Errorf("%s\n", x.Error)
|
||||
continue
|
||||
}
|
||||
t.Logf("%s\n", x.RR)
|
||||
|
|
@ -715,8 +688,7 @@ func TestLineNumberError(t *testing.T) {
|
|||
s := "example.com. 1000 SOA master.example.com. admin.example.com. monkey 4294967294 4294967293 4294967295 100"
|
||||
if _, err := NewRR(s); err != nil {
|
||||
if err.Error() != "dns: bad SOA zone parameter: \"monkey\" at line: 1:68" {
|
||||
t.Logf("not expecting this error: " + err.Error())
|
||||
t.Fail()
|
||||
t.Error("not expecting this error: ", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -736,12 +708,11 @@ func TestLineNumberError2(t *testing.T) {
|
|||
for in, err := range tests {
|
||||
_, e := NewRR(in)
|
||||
if e == nil {
|
||||
t.Fail()
|
||||
t.Error("e is nil")
|
||||
} else {
|
||||
if e.Error() != err {
|
||||
t.Logf("%s\n", in)
|
||||
t.Logf("error should be %s is %s\n", err, e.Error())
|
||||
t.Fail()
|
||||
t.Errorf("%s\n", in)
|
||||
t.Errorf("error should be %s is %s\n", err, e.Error())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -756,8 +727,7 @@ func TestRfc1982(t *testing.T) {
|
|||
strtests := []string{"20120525134203", "19700101000000", "20380119031408"}
|
||||
for _, v := range strtests {
|
||||
if x, _ := StringToTime(v); v != TimeToString(x) {
|
||||
t.Logf("1982 arithmetic string failure %s (%s:%d)", v, TimeToString(x), x)
|
||||
t.Fail()
|
||||
t.Errorf("1982 arithmetic string failure %s (%s:%d)", v, TimeToString(x), x)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -767,8 +737,7 @@ func TestRfc1982(t *testing.T) {
|
|||
}
|
||||
for i, v := range inttests {
|
||||
if TimeToString(i) != v {
|
||||
t.Logf("1982 arithmetic int failure %d:%s (%s)", i, v, TimeToString(i))
|
||||
t.Fail()
|
||||
t.Errorf("1982 arithmetic int failure %d:%s (%s)", i, v, TimeToString(i))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -785,16 +754,14 @@ func TestRfc1982(t *testing.T) {
|
|||
x, _ := StringToTime(from)
|
||||
y := TimeToString(x)
|
||||
if y != to {
|
||||
t.Logf("1982 arithmetic future failure %s:%s (%s)", from, to, y)
|
||||
t.Fail()
|
||||
t.Errorf("1982 arithmetic future failure %s:%s (%s)", from, to, y)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmpty(t *testing.T) {
|
||||
for _ = range ParseZone(strings.NewReader(""), "", "") {
|
||||
t.Logf("should be empty")
|
||||
t.Fail()
|
||||
t.Errorf("should be empty")
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -887,17 +854,17 @@ func TestSRVPacking(t *testing.T) {
|
|||
|
||||
func TestParseBackslash(t *testing.T) {
|
||||
if r, e := NewRR("nul\\000gap.test.globnix.net. 600 IN A 192.0.2.10"); e != nil {
|
||||
t.Fatalf("could not create RR with \\000 in it")
|
||||
t.Errorf("could not create RR with \\000 in it")
|
||||
} else {
|
||||
t.Logf("parsed %s\n", r.String())
|
||||
}
|
||||
if r, e := NewRR(`nul\000gap.test.globnix.net. 600 IN TXT "Hello\123"`); e != nil {
|
||||
t.Fatalf("could not create RR with \\000 in it")
|
||||
t.Errorf("could not create RR with \\000 in it")
|
||||
} else {
|
||||
t.Logf("parsed %s\n", r.String())
|
||||
}
|
||||
if r, e := NewRR(`m\ @\ iek.nl. IN 3600 A 127.0.0.1`); e != nil {
|
||||
t.Fatalf("could not create RR with \\ and \\@ in it")
|
||||
t.Errorf("could not create RR with \\ and \\@ in it")
|
||||
} else {
|
||||
t.Logf("parsed %s\n", r.String())
|
||||
}
|
||||
|
|
@ -943,13 +910,11 @@ func TestNsapGposEidNimloc(t *testing.T) {
|
|||
for i, o := range dt {
|
||||
rr, e := NewRR(i)
|
||||
if e != nil {
|
||||
t.Log("failed to parse RR: " + e.Error())
|
||||
t.Fail()
|
||||
t.Error("failed to parse RR: ", e.Error())
|
||||
continue
|
||||
}
|
||||
if rr.String() != o {
|
||||
t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
t.Fail()
|
||||
t.Errorf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
} else {
|
||||
t.Logf("RR is OK: `%s'", rr.String())
|
||||
}
|
||||
|
|
@ -964,13 +929,11 @@ func TestPX(t *testing.T) {
|
|||
for i, o := range dt {
|
||||
rr, e := NewRR(i)
|
||||
if e != nil {
|
||||
t.Log("failed to parse RR: " + e.Error())
|
||||
t.Fail()
|
||||
t.Error("failed to parse RR: ", e.Error())
|
||||
continue
|
||||
}
|
||||
if rr.String() != o {
|
||||
t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
t.Fail()
|
||||
t.Errorf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
|
||||
} else {
|
||||
t.Logf("RR is OK: `%s'", rr.String())
|
||||
}
|
||||
|
|
@ -1004,8 +967,7 @@ foo. IN TXT "THIS IS TEXT MAN"; this is comment 8
|
|||
if x.Error == nil {
|
||||
if x.Comment != "" {
|
||||
if _, ok := comments[x.Comment]; !ok {
|
||||
t.Logf("wrong comment %s", x.Comment)
|
||||
t.Fail()
|
||||
t.Errorf("wrong comment %s", x.Comment)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1020,12 +982,10 @@ func TestEUIxx(t *testing.T) {
|
|||
for i, o := range tests {
|
||||
r, e := NewRR(i)
|
||||
if e != nil {
|
||||
t.Logf("failed to parse %s: %s\n", i, e.Error())
|
||||
t.Fail()
|
||||
t.Errorf("failed to parse %s: %s\n", i, e.Error())
|
||||
}
|
||||
if r.String() != o {
|
||||
t.Logf("want %s, got %s\n", o, r.String())
|
||||
t.Fail()
|
||||
t.Errorf("want %s, got %s\n", o, r.String())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1039,12 +999,10 @@ func TestUserRR(t *testing.T) {
|
|||
for i, o := range tests {
|
||||
r, e := NewRR(i)
|
||||
if e != nil {
|
||||
t.Logf("failed to parse %s: %s\n", i, e.Error())
|
||||
t.Fail()
|
||||
t.Errorf("failed to parse %s: %s\n", i, e.Error())
|
||||
}
|
||||
if r.String() != o {
|
||||
t.Logf("want %s, got %s\n", o, r.String())
|
||||
t.Fail()
|
||||
t.Errorf("want %s, got %s\n", o, r.String())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1114,18 +1072,15 @@ func TestTXT(t *testing.T) {
|
|||
func TestTypeXXXX(t *testing.T) {
|
||||
_, err := NewRR("example.com IN TYPE1234 \\# 4 aabbccdd")
|
||||
if err != nil {
|
||||
t.Logf("failed to parse TYPE1234 RR: %s", err.Error())
|
||||
t.Fail()
|
||||
t.Errorf("failed to parse TYPE1234 RR: %s", err.Error())
|
||||
}
|
||||
_, err = NewRR("example.com IN TYPE655341 \\# 8 aabbccddaabbccdd")
|
||||
if err == nil {
|
||||
t.Logf("this should not work, for TYPE655341")
|
||||
t.Fail()
|
||||
t.Errorf("this should not work, for TYPE655341")
|
||||
}
|
||||
_, err = NewRR("example.com IN TYPE1 \\# 4 0a000001")
|
||||
if err == nil {
|
||||
t.Logf("this should not work")
|
||||
t.Fail()
|
||||
t.Errorf("this should not work")
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1172,8 +1127,7 @@ func TestParseRRSIGTimestamp(t *testing.T) {
|
|||
for r := range tests {
|
||||
_, e := NewRR(r)
|
||||
if e != nil {
|
||||
t.Fail()
|
||||
t.Logf("%s\n", e.Error())
|
||||
t.Errorf("%s\n", e.Error())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1184,9 +1138,9 @@ func TestTxtEqual(t *testing.T) {
|
|||
rr1.Txt = []string{"a\"a", "\"", "b"}
|
||||
rr2, _ := NewRR(rr1.String())
|
||||
if rr1.String() != rr2.String() {
|
||||
t.Logf("these two TXT records should match")
|
||||
t.Logf("\n%s\n%s\n", rr1.String(), rr2.String())
|
||||
t.Fail() // This is not an error, but keep this test.
|
||||
// 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.Logf("\n%s\n%s\n", rr1.String(), rr2.String())
|
||||
}
|
||||
|
|
@ -1202,8 +1156,7 @@ func TestTxtLong(t *testing.T) {
|
|||
}
|
||||
str := rr1.String()
|
||||
if len(str) < len(rr1.Txt[0]) {
|
||||
t.Logf("string conversion should work")
|
||||
t.Fail()
|
||||
t.Error("string conversion should work")
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1258,8 +1211,8 @@ func TestNewPrivateKey(t *testing.T) {
|
|||
|
||||
newPrivKey, err := key.NewPrivateKey(key.PrivateKeyString(privkey))
|
||||
if err != nil {
|
||||
t.Log(key.String())
|
||||
t.Log(key.PrivateKeyString(privkey))
|
||||
t.Error(key.String())
|
||||
t.Error(key.PrivateKeyString(privkey))
|
||||
|
||||
t.Fatal(err.Error())
|
||||
}
|
||||
|
|
@ -1396,13 +1349,12 @@ func TestParseIPSECKEY(t *testing.T) {
|
|||
e1 := tests[i+1]
|
||||
r, e := NewRR(t1)
|
||||
if e != nil {
|
||||
t.Logf("failed to parse IPSECKEY %s", e)
|
||||
t.Errorf("failed to parse IPSECKEY %s", e)
|
||||
continue
|
||||
}
|
||||
if r.String() != e1 {
|
||||
t.Logf("these two IPSECKEY records should match")
|
||||
t.Logf("\n%s\n%s\n", r.String(), e1)
|
||||
t.Fail()
|
||||
t.Errorf("these two IPSECKEY records should match")
|
||||
t.Errorf("\n%s\n%s\n", r.String(), e1)
|
||||
}
|
||||
i++
|
||||
}
|
||||
|
|
|
|||
|
|
@ -104,38 +104,32 @@ func TestServing(t *testing.T) {
|
|||
m.SetQuestion("miek.nl.", TypeTXT)
|
||||
r, _, err := c.Exchange(m, addrstr)
|
||||
if err != nil || len(r.Extra) == 0 {
|
||||
t.Log("failed to exchange miek.nl", err)
|
||||
t.FailNow()
|
||||
t.Fatal("failed to exchange miek.nl", err)
|
||||
}
|
||||
txt := r.Extra[0].(*TXT).Txt[0]
|
||||
if txt != "Hello world" {
|
||||
t.Log("Unexpected result for miek.nl", txt, "!= Hello world")
|
||||
t.Fail()
|
||||
t.Error("Unexpected result for miek.nl", txt, "!= Hello world")
|
||||
}
|
||||
|
||||
m.SetQuestion("example.com.", TypeTXT)
|
||||
r, _, err = c.Exchange(m, addrstr)
|
||||
if err != nil {
|
||||
t.Log("failed to exchange example.com", err)
|
||||
t.FailNow()
|
||||
t.Fatal("failed to exchange example.com", err)
|
||||
}
|
||||
txt = r.Extra[0].(*TXT).Txt[0]
|
||||
if txt != "Hello example" {
|
||||
t.Log("Unexpected result for example.com", txt, "!= Hello example")
|
||||
t.Fail()
|
||||
t.Error("Unexpected result for example.com", txt, "!= Hello example")
|
||||
}
|
||||
|
||||
// Test Mixes cased as noticed by Ask.
|
||||
m.SetQuestion("eXaMplE.cOm.", TypeTXT)
|
||||
r, _, err = c.Exchange(m, addrstr)
|
||||
if err != nil {
|
||||
t.Log("failed to exchange eXaMplE.cOm", err)
|
||||
t.Fail()
|
||||
t.Error("failed to exchange eXaMplE.cOm", err)
|
||||
}
|
||||
txt = r.Extra[0].(*TXT).Txt[0]
|
||||
if txt != "Hello example" {
|
||||
t.Log("Unexpected result for example.com", txt, "!= Hello example")
|
||||
t.Fail()
|
||||
t.Error("Unexpected result for example.com", txt, "!= Hello example")
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -316,8 +310,7 @@ func TestServingLargeResponses(t *testing.T) {
|
|||
M.Unlock()
|
||||
_, _, err = c.Exchange(m, addrstr)
|
||||
if err != nil {
|
||||
t.Logf("failed to exchange: %s", err.Error())
|
||||
t.Fail()
|
||||
t.Errorf("failed to exchange: %s", err.Error())
|
||||
}
|
||||
// This must fail
|
||||
M.Lock()
|
||||
|
|
@ -325,15 +318,13 @@ func TestServingLargeResponses(t *testing.T) {
|
|||
M.Unlock()
|
||||
_, _, err = c.Exchange(m, addrstr)
|
||||
if err == nil {
|
||||
t.Logf("failed to fail exchange, this should generate packet error")
|
||||
t.Fail()
|
||||
t.Error("failed to fail exchange, this should generate packet error")
|
||||
}
|
||||
// But this must work again
|
||||
c.UDPSize = 7000
|
||||
_, _, err = c.Exchange(m, addrstr)
|
||||
if err != nil {
|
||||
t.Logf("failed to exchange: %s", err.Error())
|
||||
t.Fail()
|
||||
t.Errorf("failed to exchange: %s", err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -353,14 +344,12 @@ func TestServingResponse(t *testing.T) {
|
|||
m.Response = false
|
||||
_, _, err = c.Exchange(m, addrstr)
|
||||
if err != nil {
|
||||
t.Log("failed to exchange", err)
|
||||
t.FailNow()
|
||||
t.Fatal("failed to exchange", err)
|
||||
}
|
||||
m.Response = true
|
||||
_, _, err = c.Exchange(m, addrstr)
|
||||
if err == nil {
|
||||
t.Log("exchanged response message")
|
||||
t.FailNow()
|
||||
t.Fatal("exchanged response message")
|
||||
}
|
||||
|
||||
s.Shutdown()
|
||||
|
|
@ -373,8 +362,7 @@ func TestServingResponse(t *testing.T) {
|
|||
m.Response = true
|
||||
_, _, err = c.Exchange(m, addrstr)
|
||||
if err != nil {
|
||||
t.Log("could exchanged response message in Unsafe mode")
|
||||
t.FailNow()
|
||||
t.Fatal("could exchanged response message in Unsafe mode")
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
24
sig0_test.go
24
sig0_test.go
|
|
@ -27,8 +27,7 @@ func TestSIG0(t *testing.T) {
|
|||
}
|
||||
pk, err := keyrr.Generate(keysize)
|
||||
if err != nil {
|
||||
t.Logf("Failed to generate key for “%s”: %v", algstr, err)
|
||||
t.Fail()
|
||||
t.Errorf("Failed to generate key for “%s”: %v", algstr, err)
|
||||
continue
|
||||
}
|
||||
now := uint32(time.Now().Unix())
|
||||
|
|
@ -43,19 +42,16 @@ func TestSIG0(t *testing.T) {
|
|||
sigrr.SignerName = keyrr.Hdr.Name
|
||||
mb, err := sigrr.Sign(pk, m)
|
||||
if err != nil {
|
||||
t.Logf("Failed to sign message using “%s”: %v", algstr, err)
|
||||
t.Fail()
|
||||
t.Errorf("Failed to sign message using “%s”: %v", algstr, err)
|
||||
continue
|
||||
}
|
||||
m := new(Msg)
|
||||
if err := m.Unpack(mb); err != nil {
|
||||
t.Logf("Failed to unpack message signed using “%s”: %v", algstr, err)
|
||||
t.Fail()
|
||||
t.Errorf("Failed to unpack message signed using “%s”: %v", algstr, err)
|
||||
continue
|
||||
}
|
||||
if len(m.Extra) != 1 {
|
||||
t.Logf("Missing SIG for message signed using “%s”", algstr)
|
||||
t.Fail()
|
||||
t.Errorf("Missing SIG for message signed using “%s”", algstr)
|
||||
continue
|
||||
}
|
||||
var sigrrwire *SIG
|
||||
|
|
@ -63,8 +59,7 @@ func TestSIG0(t *testing.T) {
|
|||
case *SIG:
|
||||
sigrrwire = rr
|
||||
default:
|
||||
t.Logf("Expected SIG RR, instead: %v", rr)
|
||||
t.Fail()
|
||||
t.Errorf("Expected SIG RR, instead: %v", rr)
|
||||
continue
|
||||
}
|
||||
for _, rr := range []*SIG{sigrr, sigrrwire} {
|
||||
|
|
@ -73,23 +68,20 @@ func TestSIG0(t *testing.T) {
|
|||
id = "sigrrwire"
|
||||
}
|
||||
if err := rr.Verify(keyrr, mb); err != nil {
|
||||
t.Logf("Failed to verify “%s” signed SIG(%s): %v", algstr, id, err)
|
||||
t.Fail()
|
||||
t.Errorf("Failed to verify “%s” signed SIG(%s): %v", algstr, id, err)
|
||||
continue
|
||||
}
|
||||
}
|
||||
mb[13]++
|
||||
if err := sigrr.Verify(keyrr, mb); err == nil {
|
||||
t.Logf("Verify succeeded on an altered message using “%s”", algstr)
|
||||
t.Fail()
|
||||
t.Errorf("Verify succeeded on an altered message using “%s”", algstr)
|
||||
continue
|
||||
}
|
||||
sigrr.Expiration = 2
|
||||
sigrr.Inception = 1
|
||||
mb, _ = sigrr.Sign(pk, m)
|
||||
if err := sigrr.Verify(keyrr, mb); err == nil {
|
||||
t.Logf("Verify succeeded on an expired message using “%s”", algstr)
|
||||
t.Fail()
|
||||
t.Errorf("Verify succeeded on an expired message using “%s”", algstr)
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,8 +14,7 @@ func TestDynamicUpdateParsing(t *testing.T) {
|
|||
}
|
||||
r, e := NewRR(prefix + typ)
|
||||
if e != nil {
|
||||
t.Log("failure to parse: " + prefix + typ)
|
||||
t.Fail()
|
||||
t.Error("failure to parse: " + prefix + typ)
|
||||
} else {
|
||||
t.Logf("parsed: %s", r.String())
|
||||
}
|
||||
|
|
@ -31,8 +30,7 @@ func TestDynamicUpdateUnpack(t *testing.T) {
|
|||
msg := new(Msg)
|
||||
err := msg.Unpack(buf)
|
||||
if err != nil {
|
||||
t.Log("failed to unpack: " + err.Error() + "\n" + msg.String())
|
||||
t.Fail()
|
||||
t.Error("failed to unpack: " + err.Error() + "\n" + msg.String())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -45,13 +43,11 @@ func TestDynamicUpdateZeroRdataUnpack(t *testing.T) {
|
|||
rr.Rrtype = n
|
||||
bytes, err := m.Pack()
|
||||
if err != nil {
|
||||
t.Logf("failed to pack %s: %v", s, err)
|
||||
t.Fail()
|
||||
t.Errorf("failed to pack %s: %v", s, err)
|
||||
continue
|
||||
}
|
||||
if err := new(Msg).Unpack(bytes); err != nil {
|
||||
t.Logf("failed to unpack %s: %v", s, err)
|
||||
t.Fail()
|
||||
t.Errorf("failed to unpack %s: %v", s, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -82,8 +78,7 @@ func TestRemoveRRset(t *testing.T) {
|
|||
if err := tmp.Unpack(actual); err != nil {
|
||||
t.Fatalf("Error unpacking actual msg: %v", err)
|
||||
}
|
||||
t.Logf("Expected msg:\n%s", expectstr)
|
||||
t.Logf("Actual msg:\n%v", tmp)
|
||||
t.Fail()
|
||||
t.Errorf("Expected msg:\n%s", expectstr)
|
||||
t.Errorf("Actual msg:\n%v", tmp)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
19
xfr_test.go
19
xfr_test.go
|
|
@ -28,13 +28,11 @@ func testClientAXFR(t *testing.T) {
|
|||
tr := new(Transfer)
|
||||
|
||||
if a, err := tr.In(m, net.JoinHostPort(server, "53")); err != nil {
|
||||
t.Log("failed to setup axfr: " + err.Error())
|
||||
t.FailNow()
|
||||
t.Fatal("failed to setup axfr: ", err)
|
||||
} else {
|
||||
for ex := range a {
|
||||
if ex.Error != nil {
|
||||
t.Logf("error %s\n", ex.Error.Error())
|
||||
t.Fail()
|
||||
t.Errorf("error %s\n", ex.Error.Error())
|
||||
break
|
||||
}
|
||||
for _, rr := range ex.RR {
|
||||
|
|
@ -56,13 +54,12 @@ func testClientAXFRMultipleEnvelopes(t *testing.T) {
|
|||
|
||||
tr := new(Transfer)
|
||||
if a, err := tr.In(m, net.JoinHostPort(server, "53")); err != nil {
|
||||
t.Log("Failed to setup axfr" + err.Error() + "for server: " + server)
|
||||
t.FailNow()
|
||||
t.Fatal("Failed to setup axfr" + err.Error() + "for server: " + server)
|
||||
return
|
||||
} else {
|
||||
for ex := range a {
|
||||
if ex.Error != nil {
|
||||
t.Logf("Error %s\n", ex.Error.Error())
|
||||
t.Fail()
|
||||
t.Errorf("Error %s\n", ex.Error.Error())
|
||||
break
|
||||
}
|
||||
}
|
||||
|
|
@ -81,13 +78,11 @@ func testClientTsigAXFR(t *testing.T) {
|
|||
tr.TsigSecret = map[string]string{"axfr.": "so6ZGir4GPAqINNh9U5c3A=="}
|
||||
|
||||
if a, err := tr.In(m, "176.58.119.54:53"); err != nil {
|
||||
t.Log("failed to setup axfr: " + err.Error())
|
||||
t.FailNow()
|
||||
t.Fatal("failed to setup axfr: ", err)
|
||||
} else {
|
||||
for ex := range a {
|
||||
if ex.Error != nil {
|
||||
t.Logf("error %s\n", ex.Error.Error())
|
||||
t.Fail()
|
||||
t.Errorf("error %s\n", ex.Error.Error())
|
||||
break
|
||||
}
|
||||
for _, rr := range ex.RR {
|
||||
|
|
|
|||
Loading…
Reference in New Issue