github.com/dolthub/dolt/go@v0.40.5-0.20240520175717-68db7794bea6/store/hash/hash_test.go (about)

     1  // Copyright 2019 Dolthub, Inc.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  //
    15  // This file incorporates work covered by the following copyright and
    16  // permission notice:
    17  //
    18  // Copyright 2016 Attic Labs, Inc. All rights reserved.
    19  // Licensed under the Apache License, version 2.0:
    20  // http://www.apache.org/licenses/LICENSE-2.0
    21  
    22  package hash
    23  
    24  import (
    25  	"math/rand"
    26  	"testing"
    27  
    28  	"golang.org/x/crypto/blake2b"
    29  
    30  	"github.com/stretchr/testify/assert"
    31  	"github.com/zeebo/blake3"
    32  	"github.com/zeebo/xxh3"
    33  )
    34  
    35  func TestParseError(t *testing.T) {
    36  	assert := assert.New(t)
    37  
    38  	assertParseError := func(s string) {
    39  		assert.Panics(func() {
    40  			Parse(s)
    41  		})
    42  	}
    43  
    44  	assertParseError("foo")
    45  
    46  	// too few digits
    47  	assertParseError("0000000000000000000000000000000")
    48  
    49  	// too many digits
    50  	assertParseError("000000000000000000000000000000000")
    51  
    52  	// 'w' not valid base32
    53  	assertParseError("00000000000000000000000000000000w")
    54  
    55  	// no prefix
    56  	assertParseError("sha1-00000000000000000000000000000000")
    57  	assertParseError("sha2-00000000000000000000000000000000")
    58  
    59  	r := Parse("00000000000000000000000000000000")
    60  	assert.NotNil(r)
    61  }
    62  
    63  func TestMaybeParse(t *testing.T) {
    64  	assert := assert.New(t)
    65  
    66  	parse := func(s string, success bool) {
    67  		r, ok := MaybeParse(s)
    68  		assert.Equal(success, ok, "Expected success=%t for %s", success, s)
    69  		if ok {
    70  			assert.Equal(s, r.String())
    71  		} else {
    72  			assert.Equal(emptyHash, r)
    73  		}
    74  	}
    75  
    76  	parse("00000000000000000000000000000000", true)
    77  	parse("00000000000000000000000000000001", true)
    78  	parse("", false)
    79  	parse("adsfasdf", false)
    80  	parse("sha2-00000000000000000000000000000000", false)
    81  	parse("0000000000000000000000000000000w", false)
    82  }
    83  
    84  func TestEquals(t *testing.T) {
    85  	assert := assert.New(t)
    86  
    87  	r0 := Parse("00000000000000000000000000000000")
    88  	r01 := Parse("00000000000000000000000000000000")
    89  	r1 := Parse("00000000000000000000000000000001")
    90  
    91  	assert.Equal(r0, r01)
    92  	assert.Equal(r01, r0)
    93  	assert.NotEqual(r0, r1)
    94  	assert.NotEqual(r1, r0)
    95  }
    96  
    97  func TestString(t *testing.T) {
    98  	s := "0123456789abcdefghijklmnopqrstuv"
    99  	r := Parse(s)
   100  	assert.Equal(t, s, r.String())
   101  }
   102  
   103  func TestOf(t *testing.T) {
   104  	r := Of([]byte("abc"))
   105  	assert.Equal(t, "rmnjb8cjc5tblj21ed4qs821649eduie", r.String())
   106  }
   107  
   108  func TestIsEmpty(t *testing.T) {
   109  	r1 := Hash{}
   110  	assert.True(t, r1.IsEmpty())
   111  
   112  	r2 := Parse("00000000000000000000000000000000")
   113  	assert.True(t, r2.IsEmpty())
   114  
   115  	r3 := Parse("rmnjb8cjc5tblj21ed4qs821649eduie")
   116  	assert.False(t, r3.IsEmpty())
   117  }
   118  
   119  func TestLess(t *testing.T) {
   120  	assert := assert.New(t)
   121  
   122  	r1 := Parse("00000000000000000000000000000001")
   123  	r2 := Parse("00000000000000000000000000000002")
   124  
   125  	assert.False(r1.Less(r1))
   126  	assert.True(r1.Less(r2))
   127  	assert.False(r2.Less(r1))
   128  	assert.False(r2.Less(r2))
   129  
   130  	r0 := Hash{}
   131  	assert.False(r0.Less(r0))
   132  	assert.True(r0.Less(r2))
   133  	assert.False(r2.Less(r0))
   134  }
   135  
   136  func TestCompareGreater(t *testing.T) {
   137  	assert := assert.New(t)
   138  
   139  	r1 := Parse("00000000000000000000000000000001")
   140  	r2 := Parse("00000000000000000000000000000002")
   141  
   142  	assert.False(r1.Compare(r1) > 0)
   143  	assert.False(r1.Compare(r2) > 0)
   144  	assert.True(r2.Compare(r1) > 0)
   145  	assert.False(r2.Compare(r2) > 0)
   146  
   147  	r0 := Hash{}
   148  	assert.False(r0.Compare(r0) > 0)
   149  	assert.False(r0.Compare(r2) > 0)
   150  	assert.True(r2.Compare(r0) > 0)
   151  }
   152  
   153  func init() {
   154  	for i := range benchData {
   155  		benchData[i] = make([]byte, 100)
   156  		rand.Read(benchData[i])
   157  	}
   158  }
   159  
   160  var benchData [512][]byte
   161  
   162  func BenchmarkSha512(b *testing.B) {
   163  	for i := 0; i < b.N; i++ {
   164  		j := i % len(benchData)
   165  		_ = Of(benchData[j])
   166  	}
   167  }
   168  
   169  func BenchmarkBlake2(b *testing.B) {
   170  	for i := 0; i < b.N; i++ {
   171  		j := i % len(benchData)
   172  		_ = blake2b.Sum256(benchData[j])
   173  	}
   174  }
   175  
   176  func BenchmarkBlake3(b *testing.B) {
   177  	for i := 0; i < b.N; i++ {
   178  		j := i % len(benchData)
   179  		_ = blake3.Sum256(benchData[j])
   180  	}
   181  }
   182  
   183  func BenchmarkXXHash(b *testing.B) {
   184  	for i := 0; i < b.N; i++ {
   185  		j := i % len(benchData)
   186  		_ = xxh3.Hash128(benchData[j])
   187  	}
   188  }