func (s *XLSuite) TestInsert(c *C) {
var (
hc, bitmap uint32
lev uint32
idx uint32
flag, mask, pos uint32
where uint32
)
rng := xr.MakeSimpleRNG()
perm := rng.Perm(32) // a random permutation of [0..32)
var slice []byte
for i := byte(0); i < 32; i++ {
hc = uint32(perm[i])
// insert the value into the hash slice in such a way as
// to maintain order
idx = (hc >> lev) & 0x1f
c.Assert(idx, Equals, hc) // hc is restricted to that range
where = s.insertHash(c, &slice, byte(idx))
flag = uint32(1) << (idx + 1)
mask = flag - 1
//pos = intgr.BitCount(int(bitmap) & mask)
pos = uint32(xu.BitCount32(bitmap & mask))
occupied := uint32(1 << idx)
bitmap |= occupied
//fmt.Printf("%02d: hc %02x, idx %02x, mask 0x%08x, bitmap 0x%08x, pos %02d where %02d\n\n",
// i, hc, idx, mask, bitmap, pos, where)
c.Assert(pos, Equals, where)
}
}
// Verify that 0.0.0.0 is acceptable as an address (meaning "listen
// on all interfaces")
//
func (s *XLSuite) TestAllInterfaces(c *C) {
rng := xr.MakeSimpleRNG()
var str string
// test with port = 0 (meaning the system decides)
str = "0.0.0.0:0"
a, err := NewV4Address(str)
c.Assert(err, IsNil)
c.Assert(a.String(), Equals, str)
// test with random port
port := rng.Intn(256 * 256)
str = fmt.Sprintf("0.0.0.0:%d", port)
a, err = NewV4Address(str)
c.Assert(err, IsNil)
c.Assert(a.String(), Equals, str)
// ABBREVIATED as [::]; test with port = 0
str = "[::]:0"
a, err = NewV4Address(str)
c.Assert(err, IsNil)
c.Assert(a.String(), Equals, "0.0.0.0:0")
// test with random port
port = rng.Intn(256 * 256)
str = fmt.Sprintf("0.0.0.0:%d", port)
a, err = NewV4Address(str)
c.Assert(err, IsNil)
c.Assert(a.String(), Equals, str)
}
func (s *XLSuite) TestMakingPermutedKeys(c *C) {
rng := xr.MakeSimpleRNG()
var w uint
for w = uint(4); w < uint(7); w++ {
fields, keys := s.makePermutedKeys(rng, w)
flag := uint64(1 << w)
mask := flag - 1
maxDepth := 64 / w // rounding down
fieldCount := uint(len(fields))
// we are relying on Hashcode(), which has only 64 bits
if maxDepth > fieldCount {
maxDepth = fieldCount
}
for i := uint(0); i < maxDepth; i++ {
bKey, err := NewBytesKey(keys[i])
c.Assert(err, IsNil)
hc := bKey.Hashcode()
for j := uint(0); j <= i; j++ {
ndx := hc & mask
if uint(ndx) != uint(fields[j]) {
fmt.Printf(
"GLITCH: w %d keyset %d field[%2d] %02x ndx %02x\n",
w, i, j, fields[j], ndx)
}
c.Assert(uint(ndx), Equals, uint(fields[j]))
hc >>= w
}
}
}
}
func (s *XLSuite) TestKeySelector64(c *C) {
rng := xr.MakeSimpleRNG()
// m := uint(10 + rng.Intn(15)) // so 10..24
s.doTestKeySelector64(c, rng, true, 24)
s.doTestKeySelector64(c, rng, false, 24)
}
func makeSomeUniqueKeys(N, K uint) (rawKeys [][]byte, bKeys []gh.BytesKey) {
rng := xr.MakeSimpleRNG()
rawKeys = make([][]byte, N)
bKeys = make([]gh.BytesKey, N)
keyMap := make(map[uint64]bool)
for i := uint(0); i < N; i++ {
var bKey gh.BytesKey
key := make([]byte, K)
for {
rng.NextBytes(key)
bKey, _ = gh.NewBytesKey(key)
hc := bKey.Hashcode()
_, ok := keyMap[hc]
if !ok { // value is not in the map
keyMap[hc] = true
break
}
}
rawKeys[i] = key
bKeys[i] = bKey
}
return
}
func (s *XLSuite) TestPow2_64(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_POW2_64")
}
rng := xr.MakeSimpleRNG()
_ = rng
c.Assert(NextPow2_64(0), Equals, uint64(1))
c.Assert(NextPow2_64(1), Equals, uint64(1))
c.Assert(NextPow2_64(2), Equals, uint64(2))
c.Assert(NextPow2_64(7), Equals, uint64(8))
c.Assert(NextPow2_64(8), Equals, uint64(8))
c.Assert(NextPow2_64(9), Equals, uint64(16))
c.Assert(NextPow2_64(1023), Equals, uint64(1024))
c.Assert(NextPow2_64(1024), Equals, uint64(1024))
c.Assert(NextPow2_64(1025), Equals, uint64(2048))
// Test all powers of 2
n := uint64(4)
for i := 2; i < 64; i++ {
c.Assert(NextPow2_64(n), Equals, n)
n <<= 1
}
// Test random values
n = uint64(4)
for i := 2; i < 63; i++ {
lowBits := uint64(rng.Int63n(int64(n)))
if lowBits != uint64(0) {
c.Assert(NextPow2_64(n+lowBits), Equals, 2*n)
}
n <<= 1
}
}
func (s *XLSuite) TestHamtTopBottomIDMap(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_HAMT_TOP_BOTTOM_MAP")
}
var err error
m, err := NewNewIDMapHAMT()
c.Assert(err, IsNil)
rng := xr.MakeSimpleRNG()
topBNI, bottomBNI := s.makeTopAndBottomBNI(c, rng)
bottomKey := bottomBNI.GetNodeID().Value()
topKey := topBNI.GetNodeID().Value()
err = m.Insert(topKey, topBNI)
c.Assert(err, IsNil)
err = m.Insert(bottomKey, bottomBNI)
c.Assert(err, IsNil)
entryCount, _, _ := m.Size()
c.Assert(entryCount, Equals, uint(2))
// insert a duplicate
err = m.Insert(bottomKey, bottomBNI)
c.Assert(err, IsNil)
entryCount, _, _ = m.Size()
c.Assert(entryCount, Equals, uint(2))
}
func (s *XLSuite) TestSNode(c *C) {
var err error
rng := xr.MakeSimpleRNG()
const COUNT = uint(8)
keys := make([]BytesKey, COUNT)
values := make([]interface{}, COUNT)
hashCodes := make([]uint, COUNT)
for i := uint(0); i < COUNT; i++ {
length := 8 + rng.Intn(32) // so [8,40) bytes
data := make([]byte, length)
rng.NextBytes(data)
key := NewBytesKey(data)
var shc uint32
var hc uint
shc, err = key.Hashcode()
hc = uint(shc)
c.Assert(err, IsNil)
keys[i] = *key
hashCodes[i] = hc
dummyVal := &DummyValue{i}
values[i] = dummyVal
}
// a trivial test, presumably will be elaborated over time
for i := uint(0); i < COUNT; i++ {
var hc uint32
hc, err = keys[i].Hashcode()
c.Assert(uint(hc), Equals, hashCodes[i])
expectedV := &DummyValue{n: i}
c.Assert(values[i], DeepEquals, expectedV)
}
}
// Create a new 16x16 file system, ORing perm into the default permissions.
// If perm is 0, the default is to allow user and group access.
// If the root is U, then this creates U/, U/tmp, U/in, and the top-level
// hex directories U/x
func NewU16x16(path string, perm os.FileMode) (udir *U16x16, err error) {
// TODO: validate path
var (
inDir, tmpDir string
)
err = os.MkdirAll(path, 0750|perm)
if err == nil {
inDir = filepath.Join(path, "in")
err = os.MkdirAll(inDir, 0770|perm)
if err == nil {
tmpDir = filepath.Join(path, "tmp")
err = os.MkdirAll(tmpDir, 0700)
if err == nil {
for i := 0; i < 16; i++ {
hexDir := fmt.Sprintf("%x", i)
hexPath := filepath.Join(path, hexDir)
err = os.MkdirAll(hexPath, 0750|perm)
if err != nil {
break
}
}
}
}
}
udir = &U16x16{
path: path,
rng: xr.MakeSimpleRNG(),
inDir: inDir,
tmpDir: tmpDir,
}
return
}
//// DEBUG
//func dumpBuffer( title string, p*[]byte) {
// length := len(*p)
// fmt.Printf("%s ", title)
// for i := 0; i < length; i++ {
// fmt.Printf("%02x ", (*p)[i])
// }
// fmt.Print("\n")
//}
//// END
func (s *XLSuite) TestReadWrite(c *C) {
const COUNT = 16
const MAX_TYPE = 128
rng := xr.MakeSimpleRNG()
for i := 0; i < COUNT; i++ {
tType := uint16(rng.NextInt32(MAX_TYPE))
bufLen := 4 * (1 + int(rng.NextInt32(16)))
value := make([]byte, bufLen)
rng.NextBytes(value) // just adds noise
tlv := new(TLV16)
tlv.Init(tType, &value)
// create a buffer, write TLV16 into it, read it back
buffer := make([]byte, 4+bufLen)
// XXX offset should be randomized
offset := uint16(0)
tlv.Encode(&buffer, offset)
decoded := Decode(&buffer, offset)
c.Assert(tType, Equals, decoded.Type())
c.Assert(bufLen, Equals, int(decoded.Length()))
// // DEBUG
// dumpBuffer("value ", &buffer)
// dumpBuffer("encoded ", decoded.Value())
// // END
for j := 0; j < bufLen; j++ {
c.Assert((*tlv.Value())[j], Equals, (*decoded.Value())[j])
}
}
}
func (s *XLSuite) TestParser(c *C) {
// fmt.Println("TEST_PARSER")
rng := xr.MakeSimpleRNG()
for i := 0; i < 16; i++ {
s.doTestParser(c, rng)
}
}
func (s *XLSuite) TestLeaf(c *C) {
const MIN_KEY_LEN = 8
rng := xr.MakeSimpleRNG()
_ = rng
// a nil argument must cause an error
p := 0
gk := make([]byte, MIN_KEY_LEN)
goodKey, err := NewBytesKey(gk)
c.Assert(err, IsNil)
sk := make([]byte, MIN_KEY_LEN-1)
_, err = NewBytesKey(sk)
// must fail - key is too short
c.Assert(err, NotNil)
_, err = NewLeaf(nil, &p)
c.Assert(err, NotNil)
_, err = NewLeaf(goodKey, nil)
c.Assert(err, NotNil)
leaf, err := NewLeaf(goodKey, &p)
c.Assert(err, IsNil)
c.Assert(leaf, NotNil)
c.Assert(leaf.IsLeaf(), Equals, true)
// XXX test a Table, IsLeaf() should return false
// XXX STUB
}
func (s *XLSuite) TestByteBuffer(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_BYTE_BUFFER")
}
var soFar, totalSize int
rng := xr.MakeSimpleRNG()
count := 8 + rng.Intn(8)
p := make([][]byte, count) // we make this many little slices
sizes := make([]int, count) // the length of each
for i := 0; i < count; i++ {
size := 16 + rng.Intn(16)
sizes[i] = size
p[i] = make([]byte, size)
rng.NextBytes(p[i]) // fill the slice with random values
totalSize = totalSize + size
}
capacity := 2 * totalSize
b, err := NewByteBuffer(capacity)
c.Assert(err, IsNil)
c.Assert(b.Len(), Equals, 0)
c.Assert(b.Cap(), Equals, capacity)
for i := 0; i < count; i++ {
n, err := b.Write(p[i])
c.Assert(err, IsNil)
c.Assert(n, Equals, sizes[i])
soFar += n
c.Assert(b.Len(), Equals, soFar)
}
}
func (s *XLSuite) TestBadLengths(c *C) {
datum, err := xi.New(nil) // generates random NodeID
rng := xr.MakeSimpleRNG()
ndx := uint32(rng.Intn(256 * 256 * 256))
okData := make([]byte, 256+rng.Intn(3))
// verify nil datum causes error
nilChunk, err := NewChunk(nil, ndx, okData)
c.Assert(err, Equals, NilDatum)
c.Assert(nilChunk, Equals, (*Chunk)(nil))
// verify nil data causes error
nilChunk, err = NewChunk(datum, ndx, nil)
c.Assert(err, Equals, NilData)
c.Assert(nilChunk, Equals, (*Chunk)(nil))
// verify length of zero causes error
zeroLenData := make([]byte, 0)
lenZeroChunk, err := NewChunk(datum, ndx, zeroLenData)
c.Assert(err, Equals, ZeroLengthChunk)
c.Assert(lenZeroChunk, Equals, (*Chunk)(nil))
// verify length > MAX_CHUNK_BYTES causes error
bigData := make([]byte, MAX_CHUNK_BYTES+1+rng.Intn(3))
tooBig, err := NewChunk(datum, ndx, bigData)
c.Assert(err, Equals, ChunkTooLong)
c.Assert(tooBig, Equals, (*Chunk)(nil))
}
func (s *XLSuite) TestHamtFindID(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_HAMT_FIND_ID")
}
var err error
m, err := NewNewIDMapHAMT()
c.Assert(err, IsNil)
rng := xr.MakeSimpleRNG()
baseNode0123 := s.makeABNI(c, rng, "baseNode0123", 0, 1, 2, 3)
baseNode1 := s.makeABNI(c, rng, "baseNode1", 1)
baseNode12 := s.makeABNI(c, rng, "baseNode12", 1, 2)
baseNode123 := s.makeABNI(c, rng, "baseNode123", 1, 2, 3)
baseNode4 := s.makeABNI(c, rng, "baseNode4", 4)
baseNode42 := s.makeABNI(c, rng, "baseNode42", 4, 2)
baseNode423 := s.makeABNI(c, rng, "baseNode423", 4, 2, 3)
baseNode5 := s.makeABNI(c, rng, "baseNode5", 5)
baseNode6 := s.makeABNI(c, rng, "baseNode6", 6)
baseNode62 := s.makeABNI(c, rng, "baseNode62", 6, 2)
baseNode623 := s.makeABNI(c, rng, "baseNode623", 6, 2, 3)
// TODO: randomize order in which baseNodes are added
s.addIDToHAMT(c, m, baseNode123)
s.addIDToHAMT(c, m, baseNode12)
s.addIDToHAMT(c, m, baseNode1)
s.addIDToHAMT(c, m, baseNode5)
s.addIDToHAMT(c, m, baseNode4)
s.addIDToHAMT(c, m, baseNode42)
s.addIDToHAMT(c, m, baseNode423)
s.addIDToHAMT(c, m, baseNode6)
s.addIDToHAMT(c, m, baseNode623)
s.addIDToHAMT(c, m, baseNode62)
s.addIDToHAMT(c, m, baseNode0123)
// adding duplicates should have no effect
s.addIDToHAMT(c, m, baseNode4)
s.addIDToHAMT(c, m, baseNode42)
s.addIDToHAMT(c, m, baseNode423)
// TODO: randomize order in which finding baseNodes is tested
s.findIDInHAMT(c, m, baseNode0123)
s.findIDInHAMT(c, m, baseNode1)
s.findIDInHAMT(c, m, baseNode12)
s.findIDInHAMT(c, m, baseNode123)
s.findIDInHAMT(c, m, baseNode4)
s.findIDInHAMT(c, m, baseNode42)
s.findIDInHAMT(c, m, baseNode423)
s.findIDInHAMT(c, m, baseNode6)
s.findIDInHAMT(c, m, baseNode62)
s.findIDInHAMT(c, m, baseNode623)
}
func (s *XLSuite) TestRegexes(c *C) {
rng := xr.MakeSimpleRNG()
for i := 0; i < 8; i++ {
s.doTestRegexes(c, rng, xu.USING_SHA1)
s.doTestRegexes(c, rng, xu.USING_SHA2)
s.doTestRegexes(c, rng, xu.USING_SHA3)
}
}
func (s *XLSuite) TestHamtEntrySplittingInserts(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_HAMT_ENTRY_SPLITTING_INSERTS")
}
rng := xr.MakeSimpleRNG()
s.doTestHamtEntrySplittingInserts(c, rng, 5, 5)
}
func (s *XLSuite) TestSameNodeID(c *C) {
rng := xr.MakeSimpleRNG()
id1 := s.makeANodeID(c, rng)
c.Assert(SameNodeID(id1, id1), Equals, true)
id2 := s.makeANodeID(c, rng)
c.Assert(SameNodeID(id1, id2), Equals, false)
}
func (s *XLSuite) TestGoodNames(c *C) {
rng := xr.MakeSimpleRNG()
var count int = 3 + rng.Intn(16)
for i := 0; i < count; i++ {
s := s.noDotsOrDashes(rng)
c.Assert(ValidEntityName(s), IsNil)
}
}
func (d *XLSuite) TestXLatticePkt(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_XLATTICE_PKT")
}
rng := xr.MakeSimpleRNG()
myMsgN := uint64(rng.Int63())
for myMsgN == 0 { // must not be zero
myMsgN = uint64(rng.Int63())
}
id := make([]byte, 32) // sha3 length
rng.NextBytes(id) // random bytes
seqBuf := new(bytes.Buffer)
binary.Write(seqBuf, binary.LittleEndian, myMsgN)
msgLen := 64 + rng.Intn(64)
msg := make([]byte, msgLen)
rng.NextBytes(msg) // fill with rubbish
salt := make([]byte, 8)
rng.NextBytes(salt) // still more rubbish
digest := sha3.New256()
digest.Write(id)
digest.Write(seqBuf.Bytes())
digest.Write(msg)
digest.Write([]byte(salt))
hash := digest.Sum(nil)
// XXX This does not adhere to the rules: it has no Cmd field;
// since it has a payload it must be a Put, and so the id is
// also required and the Hash field should be a Sig instead, right?
var pkt = XLatticeMsg{
MsgN: &myMsgN,
Payload: msg,
Salt: salt,
Hash: hash,
}
// In each of these cases, the test proves that the field
// was present; otherwise the 'empty' value (zero, nil, etc)
// would have been returned.
msgNOut := pkt.GetMsgN()
c.Assert(msgNOut, Equals, myMsgN)
msgOut := pkt.GetPayload()
d.compareByteSlices(c, msgOut, msg)
saltOut := pkt.GetSalt()
d.compareByteSlices(c, saltOut, salt)
hashOut := pkt.GetHash()
d.compareByteSlices(c, hashOut, hash)
}
func (s *XLSuite) TestShallowIDMap(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_SHALLOW_MAP")
}
m, err := NewIDMap(MY_MAX_DEPTH)
c.Assert(err, IsNil)
c.Assert(m.MaxDepth, Equals, MY_MAX_DEPTH)
rng := xr.MakeSimpleRNG()
// 1 or 2 or 3 is first digit of key, guaranteeing shallownes
baseNode1 := s.makeABNI(c, rng, "baseNode1", 1)
baseNode2 := s.makeABNI(c, rng, "baseNode2", 2)
baseNode3 := s.makeABNI(c, rng, "baseNode3", 3)
key1 := baseNode1.GetNodeID().Value()
key2 := baseNode2.GetNodeID().Value()
key3 := baseNode3.GetNodeID().Value()
// INSERT BNI 3 -------------------------------------------------
err = m.Insert(key3, baseNode3)
c.Assert(err, IsNil)
cell3 := &m.Cells[3]
c.Assert(cell3.Value, NotNil)
c.Assert(cell3.Value.(*MockBaseNode).GetName(), Equals, baseNode3.GetName())
// INSERT BNI 2 ------------------------------------------------
err = m.Insert(key2, baseNode2)
c.Assert(err, IsNil)
cell2 := &m.Cells[2]
c.Assert(cell2.Value, NotNil)
c.Assert(cell2.Value.(*MockBaseNode).GetName(), Equals, baseNode2.GetName())
// INSERT BNI 1 ------------------------------------------------
err = m.Insert(key1, baseNode1)
c.Assert(err, IsNil)
cell1 := &m.Cells[1]
c.Assert(cell1.Value, NotNil)
c.Assert(cell1.Value.(*MockBaseNode).GetName(), Equals, baseNode1.GetName())
c.Assert(err, IsNil)
entryCount, _, _ := m.Size()
c.Assert(entryCount, Equals, uint(3))
// insert a duplicate -------------------------------------------
err = m.Insert(key1, baseNode1)
c.Assert(err, IsNil)
entryCount, _, _ = m.Size()
c.Assert(entryCount, Equals, uint(3))
for i := 0; i < 256; i++ {
cell := &m.Cells[i]
c.Assert(cell.Next, IsNil)
if i < 1 || i > 3 {
c.Assert(cell.Key, IsNil)
c.Assert(cell.Value, IsNil)
}
}
}
func (s *XLSuite) TestDecimalVersion(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_DECIMAL_VERSION")
}
rng := xr.MakeSimpleRNG()
_ = rng
// always print at least two decimals
dv := New(1, 0, 0, 0)
v := dv.String()
c.Assert(v, Equals, "1.0")
dv2, err := ParseDecimalVersion(v)
c.Assert(err, IsNil)
c.Assert(dv2, Equals, dv)
// don't print more if the values are zero
dv = New(1, 2, 0, 0)
v = dv.String()
c.Assert(v, Equals, "1.2")
dv2, err = ParseDecimalVersion(v)
c.Assert(err, IsNil)
c.Assert(dv2, Equals, dv)
// if the third byte is zero but the fourth isn't, print
// both
dv = New(1, 2, 0, 4)
v = dv.String()
c.Assert(v, Equals, "1.2.0.4")
dv2, err = ParseDecimalVersion(v)
c.Assert(err, IsNil)
c.Assert(dv2, Equals, dv)
// other cases
dv = New(1, 2, 3, 0)
v = dv.String()
c.Assert(v, Equals, "1.2.3")
dv2, err = ParseDecimalVersion(v)
c.Assert(err, IsNil)
c.Assert(dv2, Equals, dv)
dv = New(1, 2, 3, 4)
v = dv.String()
c.Assert(v, Equals, "1.2.3.4")
dv2, err = ParseDecimalVersion(v)
c.Assert(err, IsNil)
c.Assert(dv2, Equals, dv)
for i := 0; i < 8; i++ {
n := rng.Uint32()
dv := DecimalVersion(n)
v = dv.String()
dv2, err := ParseDecimalVersion(v)
c.Assert(err, IsNil)
c.Assert(dv2, Equals, dv)
}
}
func (s *XLSuite) TestCluster(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_CLUSTER")
}
rng := xr.MakeSimpleRNG()
_ = rng
// XXX STUB
}
func (s *XLSuite) TestMerkleDoc(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_MERKLE_DOC_CONSTRUCTOR")
}
rng := xr.MakeSimpleRNG()
s.doTestMerkleDoc(c, rng, xu.USING_SHA1)
s.doTestMerkleDoc(c, rng, xu.USING_SHA2)
// XXX WILL FAIL BECAUSE xu.SHA2_BIN_LEN == xu.SHA3_BIN_LEN
//s.doTestMerkleDoc(c, rng, xu.USING_SHA3)
}
func (s *XLSuite) TestMDParser(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_MERKLE_DOC_PARSER")
}
rng := xr.MakeSimpleRNG()
s.doTestMDParser(c, rng, xu.USING_SHA1)
s.doTestMDParser(c, rng, xu.USING_SHA2)
s.doTestMDParser(c, rng, xu.USING_SHA3)
}
func (s *XLSuite) TestCnxHandler(c *C) {
if VERBOSITY > 0 {
fmt.Println("\nTEST_CNX_HANDLER")
}
rng := xr.MakeSimpleRNG()
_ = rng
// XXX STUB XXX
}
// Parse an XmlDecl followed by an (empty) element followed by Misc
func (s *XLSuite) TestParseXmlDeclPlusElmPlusMisc(c *C) {
if VERBOSITY > 0 {
fmt.Println("\nTEST_PARSE_XML_DECL_PLUS_ELM_PLUS_MISC")
}
rng := xr.MakeSimpleRNG()
misc1 := s.createMiscItems(rng) // a small, possibly empty, slice
miscN := s.createMiscItems(rng) // a small, possibly empty, slice
s.doParseXmlDeclWithMisc(c, XML_DECL+s.textFromMISlice(misc1)+
EMPTY_ELM+s.textFromMISlice(miscN), misc1)
}
func (s *XLSuite) TestPathlessUnboundConstructor(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_PATHLESS_UNBOUND_CONSTRUCTOR")
}
rng := xr.MakeSimpleRNG()
s.doTestPathlessUnboundConstructor(c, rng, xu.USING_SHA1)
s.doTestPathlessUnboundConstructor(c, rng, xu.USING_SHA2)
// XXX WILL FAIL BECAUSE xu.SHA2_BIN_LEN == xu.SHA3_BIN_LEN
//s.doTestPathlessUnboundConstructor(c, rng, xu.USING_SHA3)
}
// ------------------------------------------------------------------
func (s *XLSuite) TestBoundNeedleDirs(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_BOUND_NEEDLE_DIRS")
}
rng := xr.MakeSimpleRNG()
s.doTestBoundNeedleDirs(c, rng, xu.USING_SHA1)
s.doTestBoundNeedleDirs(c, rng, xu.USING_SHA2)
// XXX WILL FAIL BECAUSE xu.SHA2_BIN_LEN == xu.SHA3_BIN_LEN
// s.doTestBoundNeedleDirs(c, rng, xu.USING_SHA3)
}
func (s *XLSuite) TestMerkleLeaf(c *C) {
if VERBOSITY > 0 {
fmt.Println("TEST_MERKLE_LEAF")
}
rng := xr.MakeSimpleRNG()
s.doTestSimpleConstructor(c, rng, xu.USING_SHA1)
s.doTestSimpleConstructor(c, rng, xu.USING_SHA2)
s.doTestSimpleConstructor(c, rng, xu.USING_SHA3)
}