Example #1
0
func TestKeyBytes(t *testing.T) {
	buf := bytes.Repeat([]byte("borketyBorkBORK!"), 4)
	k := cas.NewKey(buf)
	if g, e := k.Bytes(), buf; !bytes.Equal(g, e) {
		t.Errorf("unexpected key data: %q %x", g, e)
	}
}
Example #2
0
func TestKeyNewPrivateNum(t *testing.T) {
	k := cas.NewKeyPrivateNum(31337)
	buf := k.Bytes()
	k2 := cas.NewKey(buf)
	if g, e := k2, cas.Invalid; g != e {
		t.Errorf("expected NewKey to give Invalid: %v", g)
	}
	k3 := cas.NewKeyPrivate(buf)
	if g, e := k3, k; g != e {
		t.Errorf("expected NewKeyPrivate to give original key: %v", g)
	}
	priv, ok := k3.Private()
	if !ok {
		t.Fatalf("expected Private to work: %v %v", priv, ok)
	}
	if g, e := priv, uint64(31337); g != e {
		t.Errorf("expected Private to match original: %v", g)
	}
	if g, e := k.IsSpecial(), true; g != e {
		t.Errorf("not Special: %v != %v", g, e)
	}
	if g, e := k.IsPrivate(), true; g != e {
		t.Errorf("not Private: %v != %v", g, e)
	}
	if g, e := k.IsReserved(), false; g != e {
		t.Errorf("bad Reserved: %v != %v", g, e)
	}
}
Example #3
0
func makeKey(keybuf []byte) cas.Key {
	key := cas.NewKey(keybuf)
	if key.IsSpecial() {
		// Tough luck, we happened to hash one of the reserved byte
		// sequences. You should play lotto today.
		copy(keybuf, replaceSpecial)
		key = cas.NewKey(keybuf)

		if key.IsSpecial() {
			// This has to mean replaceSpecial was poorly chosen, and
			// does not avoid the special prefixes.
			panic(fmt.Errorf("replaceSpecial is still Special: %x", keybuf))
		}
	}
	return key
}
Example #4
0
func TestKeyMarshalBinary(t *testing.T) {
	buf := bytes.Repeat([]byte("borketyBorkBORK!"), 4)
	k := cas.NewKey(buf)
	out, err := k.MarshalBinary()
	if err != nil {
		t.Fatal(err)
	}
	if g, e := string(out), string(buf); g != e {
		t.Errorf("unexpected marshaled data: %q != %q", g, e)
	}
}
Example #5
0
func TestNotFoundErrorDispay(t *testing.T) {
	k := make([]byte, cas.KeySize)
	copy(k, "\x01evil\xFF")
	e := cas.NotFoundError{
		Type:  "blob",
		Level: 4,
		Key:   cas.NewKey(k),
	}
	got := e.Error()
	if got != `Not found: "blob"@4 016576696cff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000` {
		t.Errorf("bad error message: %q", got)
	}
}
Example #6
0
func TestKeyMarshalTo(t *testing.T) {
	buf := bytes.Repeat([]byte("borketyBorkBORK!"), 4)
	k := cas.NewKey(buf)
	out := make([]byte, 100)
	n, err := k.MarshalTo(out)
	if err != nil {
		t.Fatal(err)
	}
	if g, e := n, cas.KeySize; g != e {
		t.Errorf("unexpected MarshalTo size: %q %x", g, e)
	}
	if g, e := string(out[:n]), string(buf); g != e {
		t.Errorf("unexpected MarshalTo data: %q != %q", g, e)
	}
}
Example #7
0
func TestKeySimple(t *testing.T) {
	buf := bytes.Repeat([]byte("borketyBorkBORK!"), 4)
	k := cas.NewKey(buf)
	if g, e := k.String(), hex.EncodeToString(buf); g != e {
		t.Errorf("bad key: %q != %q", g, e)
	}
	if g, e := k.IsSpecial(), false; g != e {
		t.Errorf("bad Special: %v != %v", g, e)
	}
	if g, e := k.IsPrivate(), false; g != e {
		t.Errorf("bad Private: %v != %v", g, e)
	}
	if g, e := k.IsReserved(), false; g != e {
		t.Errorf("bad Reserved: %v != %v", g, e)
	}
}
Example #8
0
func TestKeyInvalid(t *testing.T) {
	buf := make([]byte, cas.KeySize)
	buf[len(buf)-1] = 0x42
	k := cas.NewKey(buf)
	if g, e := k, cas.Invalid; g != e {
		t.Errorf("not Invalid: %q != %q", g, e)
	}
	if g, e := k.IsSpecial(), true; g != e {
		t.Errorf("not Special: %v != %v", g, e)
	}
	if g, e := k.IsPrivate(), false; g != e {
		t.Errorf("bad Private: %v != %v", g, e)
	}
	if g, e := k.IsReserved(), true; g != e {
		t.Errorf("not Reserved: %v != %v", g, e)
	}
}
Example #9
0
func TestKeyBadSize(t *testing.T) {
	buf := []byte("tooshort")
	defer func() {
		x := recover()
		switch i := x.(type) {
		case nil:
			t.Error("expected panic")
		case cas.BadKeySizeError:
			if g, e := i.Error(), "Key is bad length 8: 746f6f73686f7274"; g != e {
				t.Errorf("bad error message: %q != %q", g, e)
			}
		default:
			t.Errorf("expected BadKeySize: %v", x)
		}
	}()
	_ = cas.NewKey(buf)
}
Example #10
0
func TestKeyEmpty(t *testing.T) {
	buf := make([]byte, cas.KeySize)
	k := cas.NewKey(buf)
	if g, e := k, cas.Empty; g != e {
		t.Errorf("not Empty: %q != %q", g, e)
	}
	if g, e := k.String(), strings.Repeat("00", cas.KeySize); g != e {
		t.Errorf("bad key: %q != %q", g, e)
	}
	if g, e := k.IsSpecial(), true; g != e {
		t.Errorf("not Special: %v != %v", g, e)
	}
	if g, e := k.IsPrivate(), false; g != e {
		t.Errorf("bad Private: %v != %v", g, e)
	}
	if g, e := k.IsReserved(), false; g != e {
		t.Errorf("bad Reserved: %v != %v", g, e)
	}
}