From c0b57def7f716d5502bf514728f1bfdb97951f1b Mon Sep 17 00:00:00 2001 From: Daniel Krawisz Date: Sun, 29 Mar 2015 12:43:55 -0500 Subject: [PATCH] Added tests for addrmgr.KnownAddress Adjusted tests in response to redefinition of KnownAddress.chance --- addrmgr/internal_test.go | 25 ++++++++ addrmgr/knownaddress.go | 6 +- addrmgr/knownaddress_test.go | 112 +++++++++++++++++++++++++++++++++++ 3 files changed, 140 insertions(+), 3 deletions(-) create mode 100644 addrmgr/internal_test.go create mode 100644 addrmgr/knownaddress_test.go diff --git a/addrmgr/internal_test.go b/addrmgr/internal_test.go new file mode 100644 index 00000000..6e107879 --- /dev/null +++ b/addrmgr/internal_test.go @@ -0,0 +1,25 @@ +// Copyright (c) 2013-2015 Conformal Systems LLC. +// Use of this source code is governed by an ISC +// license that can be found in the LICENSE file. + +package addrmgr + +import ( + "time" + + "github.com/btcsuite/btcd/wire" +) + +func TstKnownAddressIsBad(ka *KnownAddress) bool { + return ka.isBad() +} + +func TstKnownAddressChance(ka *KnownAddress) float64 { + return ka.chance() +} + +func TstNewKnownAddress(na *wire.NetAddress, attempts int, + lastattempt, lastsuccess time.Time, tried bool, refs int) *KnownAddress { + return &KnownAddress{na: na, attempts: attempts, lastattempt: lastattempt, + lastsuccess: lastsuccess, tried: tried, refs: refs} +} diff --git a/addrmgr/knownaddress.go b/addrmgr/knownaddress.go index ea843122..05f5fc2d 100644 --- a/addrmgr/knownaddress.go +++ b/addrmgr/knownaddress.go @@ -51,12 +51,12 @@ func (ka *KnownAddress) chance() float64 { c := 1.0 // Very recent attempts are less likely to be retried. - if lastAttempt > 10*time.Minute { + if lastAttempt < 10*time.Minute { c *= 0.01 } // Failed attempts deprioritise. - for i := ka.attempts; i < 0; i++ { + for i := ka.attempts; i > 0; i-- { c /= 1.5 } @@ -82,7 +82,7 @@ func (ka *KnownAddress) isBad() bool { } // Over a month old? - if ka.na.Timestamp.After(time.Now().Add(-1 * numMissingDays * time.Hour * 24)) { + if ka.na.Timestamp.Before(time.Now().Add(-1 * numMissingDays * time.Hour * 24)) { return true } diff --git a/addrmgr/knownaddress_test.go b/addrmgr/knownaddress_test.go new file mode 100644 index 00000000..bb6fd188 --- /dev/null +++ b/addrmgr/knownaddress_test.go @@ -0,0 +1,112 @@ +// Copyright (c) 2013-2015 Conformal Systems LLC. +// Use of this source code is governed by an ISC +// license that can be found in the LICENSE file. + +package addrmgr_test + +import ( + "math" + "testing" + "time" + + "github.com/btcsuite/btcd/addrmgr" + "github.com/btcsuite/btcd/wire" +) + +func TestChance(t *testing.T) { + var tests = []struct { + addr *addrmgr.KnownAddress + expected float64 + }{ + { + //Test normal case + addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: time.Now().Add(-35 * time.Second)}, + 0, time.Now().Add(-30*time.Minute), time.Now(), false, 0), + 1.0, + }, { + //Test case in which lastseen < 0 + addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: time.Now().Add(20 * time.Second)}, + 0, time.Now().Add(-30*time.Minute), time.Now(), false, 0), + 1.0, + }, { + //Test case in which lastattempt < 0 + addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: time.Now().Add(-35 * time.Second)}, + 0, time.Now().Add(30*time.Minute), time.Now(), false, 0), + 1.0 * .01, + }, { + //Test case in which lastattempt < ten minutes + addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: time.Now().Add(-35 * time.Second)}, + 0, time.Now().Add(-5*time.Minute), time.Now(), false, 0), + 1.0 * .01, + }, { + //Test case with several failed attempts. + addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: time.Now().Add(-35 * time.Second)}, + 2, time.Now().Add(-30*time.Minute), time.Now(), false, 0), + 1 / 1.5 / 1.5, + }, + } + + err := .0001 + for i, test := range tests { + chance := addrmgr.TstKnownAddressChance(test.addr) + if math.Abs(test.expected-chance) >= err { + t.Errorf("case %d: got %f, expected %f", i, chance, test.expected) + } + } +} + +func TestIsBad(t *testing.T) { + future := time.Now().Add(35 * time.Minute) + monthOld := time.Now().Add(-43 * time.Hour * 24) + secondsOld := time.Now().Add(-2 * time.Second) + minutesOld := time.Now().Add(-27 * time.Minute) + hoursOld := time.Now().Add(-5 * time.Hour) + zeroTime, _ := time.Parse("Jan 1, 1970 at 0:00am (GMT)", "Jan 1, 1970 at 0:00am (GMT)") + + futureNa := &wire.NetAddress{Timestamp: future} + minutesOldNa := &wire.NetAddress{Timestamp: minutesOld} + monthOldNa := &wire.NetAddress{Timestamp: monthOld} + currentNa := &wire.NetAddress{Timestamp: secondsOld} + + //Test addresses that have been tried in the last minute. + if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(futureNa, 3, secondsOld, zeroTime, false, 0)) { + t.Errorf("test case 1: addresses that have been tried in the last minute are not bad.") + } + if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(monthOldNa, 3, secondsOld, zeroTime, false, 0)) { + t.Errorf("test case 2: addresses that have been tried in the last minute are not bad.") + } + if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(currentNa, 3, secondsOld, zeroTime, false, 0)) { + t.Errorf("test case 3: addresses that have been tried in the last minute are not bad.") + } + if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(currentNa, 3, secondsOld, monthOld, true, 0)) { + t.Errorf("test case 4: addresses that have been tried in the last minute are not bad.") + } + if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(currentNa, 2, secondsOld, secondsOld, true, 0)) { + t.Errorf("test case 5: addresses that have been tried in the last minute are not bad.") + } + + //Test address that claims to be from the future. + if !addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(futureNa, 0, minutesOld, hoursOld, true, 0)) { + t.Errorf("test case 6: addresses that claim to be from the future are bad.") + } + + //Test address that has not been seen in over a month. + if !addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(monthOldNa, 0, minutesOld, hoursOld, true, 0)) { + t.Errorf("test case 7: addresses more than a month old are bad.") + } + + //It has failed at least three times and never succeeded. + if !addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(minutesOldNa, 3, minutesOld, zeroTime, true, 0)) { + t.Errorf("test case 8: addresses that have never succeeded are bad.") + } + + //It has failed ten times in the last week + if !addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(minutesOldNa, 10, minutesOld, monthOld, true, 0)) { + t.Errorf("test case 9: addresses that have not succeeded in too long are bad.") + } + + //Test an address that should work. + if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(minutesOldNa, 2, minutesOld, hoursOld, true, 0)) { + t.Errorf("test case 10: This should be a valid address.") + } +}