github.com/zignig/go-ipfs@v0.0.0-20141111235910-c9e5fdf55a52/routing/keyspace/xor_test.go (about)

     1  package keyspace
     2  
     3  import (
     4  	"bytes"
     5  	"math/big"
     6  	"testing"
     7  
     8  	u "github.com/jbenet/go-ipfs/util"
     9  )
    10  
    11  func TestPrefixLen(t *testing.T) {
    12  	cases := [][]byte{
    13  		[]byte{0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00},
    14  		[]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    15  		[]byte{0x00, 0x58, 0xFF, 0x80, 0x00, 0x00, 0xF0},
    16  	}
    17  	lens := []int{24, 56, 9}
    18  
    19  	for i, c := range cases {
    20  		r := ZeroPrefixLen(c)
    21  		if r != lens[i] {
    22  			t.Errorf("ZeroPrefixLen failed: %v != %v", r, lens[i])
    23  		}
    24  	}
    25  
    26  }
    27  
    28  func TestXorKeySpace(t *testing.T) {
    29  
    30  	ids := [][]byte{
    31  		[]byte{0xFF, 0xFF, 0xFF, 0xFF},
    32  		[]byte{0x00, 0x00, 0x00, 0x00},
    33  		[]byte{0xFF, 0xFF, 0xFF, 0xF0},
    34  	}
    35  
    36  	ks := [][2]Key{
    37  		[2]Key{XORKeySpace.Key(ids[0]), XORKeySpace.Key(ids[0])},
    38  		[2]Key{XORKeySpace.Key(ids[1]), XORKeySpace.Key(ids[1])},
    39  		[2]Key{XORKeySpace.Key(ids[2]), XORKeySpace.Key(ids[2])},
    40  	}
    41  
    42  	for i, set := range ks {
    43  		if !set[0].Equal(set[1]) {
    44  			t.Errorf("Key not eq. %v != %v", set[0], set[1])
    45  		}
    46  
    47  		if !bytes.Equal(set[0].Bytes, set[1].Bytes) {
    48  			t.Errorf("Key gen failed. %v != %v", set[0].Bytes, set[1].Bytes)
    49  		}
    50  
    51  		if !bytes.Equal(set[0].Original, ids[i]) {
    52  			t.Errorf("ptrs to original. %v != %v", set[0].Original, ids[i])
    53  		}
    54  
    55  		if len(set[0].Bytes) != 32 {
    56  			t.Errorf("key length incorrect. 32 != %d", len(set[0].Bytes))
    57  		}
    58  	}
    59  
    60  	for i := 1; i < len(ks); i++ {
    61  		if ks[i][0].Less(ks[i-1][0]) == ks[i-1][0].Less(ks[i][0]) {
    62  			t.Errorf("less should be different.")
    63  		}
    64  
    65  		if ks[i][0].Distance(ks[i-1][0]).Cmp(ks[i-1][0].Distance(ks[i][0])) != 0 {
    66  			t.Errorf("distance should be the same.")
    67  		}
    68  
    69  		if ks[i][0].Equal(ks[i-1][0]) {
    70  			t.Errorf("Keys should not be eq. %v != %v", ks[i][0], ks[i-1][0])
    71  		}
    72  	}
    73  }
    74  
    75  func TestDistancesAndCenterSorting(t *testing.T) {
    76  
    77  	adjs := [][]byte{
    78  		[]byte{173, 149, 19, 27, 192, 183, 153, 192, 177, 175, 71, 127, 177, 79, 207, 38, 166, 169, 247, 96, 121, 228, 139, 240, 144, 172, 183, 232, 54, 123, 253, 14},
    79  		[]byte{223, 63, 97, 152, 4, 169, 47, 219, 64, 87, 25, 45, 196, 61, 215, 72, 234, 119, 138, 220, 82, 188, 73, 140, 232, 5, 36, 192, 20, 184, 17, 25},
    80  		[]byte{73, 176, 221, 176, 149, 143, 22, 42, 129, 124, 213, 114, 232, 95, 189, 154, 18, 3, 122, 132, 32, 199, 53, 185, 58, 157, 117, 78, 52, 146, 157, 127},
    81  		[]byte{73, 176, 221, 176, 149, 143, 22, 42, 129, 124, 213, 114, 232, 95, 189, 154, 18, 3, 122, 132, 32, 199, 53, 185, 58, 157, 117, 78, 52, 146, 157, 127},
    82  		[]byte{73, 176, 221, 176, 149, 143, 22, 42, 129, 124, 213, 114, 232, 95, 189, 154, 18, 3, 122, 132, 32, 199, 53, 185, 58, 157, 117, 78, 52, 146, 157, 126},
    83  		[]byte{73, 0, 221, 176, 149, 143, 22, 42, 129, 124, 213, 114, 232, 95, 189, 154, 18, 3, 122, 132, 32, 199, 53, 185, 58, 157, 117, 78, 52, 146, 157, 127},
    84  	}
    85  
    86  	keys := make([]Key, len(adjs))
    87  	for i, a := range adjs {
    88  		keys[i] = Key{Space: XORKeySpace, Bytes: a}
    89  	}
    90  
    91  	cmp := func(a int64, b *big.Int) int {
    92  		return big.NewInt(a).Cmp(b)
    93  	}
    94  
    95  	if 0 != cmp(0, keys[2].Distance(keys[3])) {
    96  		t.Errorf("distance calculation wrong: %v", keys[2].Distance(keys[3]))
    97  	}
    98  
    99  	if 0 != cmp(1, keys[2].Distance(keys[4])) {
   100  		t.Errorf("distance calculation wrong: %v", keys[2].Distance(keys[4]))
   101  	}
   102  
   103  	d1 := keys[2].Distance(keys[5])
   104  	d2 := u.XOR(keys[2].Bytes, keys[5].Bytes)
   105  	d2 = d2[len(keys[2].Bytes)-len(d1.Bytes()):] // skip empty space for big
   106  	if !bytes.Equal(d1.Bytes(), d2) {
   107  		t.Errorf("bytes should be the same. %v == %v", d1.Bytes(), d2)
   108  	}
   109  
   110  	if -1 != cmp(2<<32, keys[2].Distance(keys[5])) {
   111  		t.Errorf("2<<32 should be smaller")
   112  	}
   113  
   114  	keys2 := SortByDistance(XORKeySpace, keys[2], keys)
   115  	order := []int{2, 3, 4, 5, 1, 0}
   116  	for i, o := range order {
   117  		if !bytes.Equal(keys[o].Bytes, keys2[i].Bytes) {
   118  			t.Errorf("order is wrong. %d?? %v == %v", o, keys[o], keys2[i])
   119  		}
   120  	}
   121  
   122  }