github.com/attic-labs/noms@v0.0.0-20210827224422-e5fa29d95e8b/go/hash/hash_test.go (about)

     1  // Copyright 2016 Attic Labs, Inc. All rights reserved.
     2  // Licensed under the Apache License, version 2.0:
     3  // http://www.apache.org/licenses/LICENSE-2.0
     4  
     5  package hash
     6  
     7  import (
     8  	"testing"
     9  
    10  	"github.com/attic-labs/noms/go/d"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestParseError(t *testing.T) {
    15  	assert := assert.New(t)
    16  
    17  	assertParseError := func(s string) {
    18  		e := d.Try(func() { Parse(s) })
    19  		_, ok := e.(d.WrappedError)
    20  		assert.True(ok)
    21  	}
    22  
    23  	assertParseError("foo")
    24  
    25  	// too few digits
    26  	assertParseError("0000000000000000000000000000000")
    27  
    28  	// too many digits
    29  	assertParseError("000000000000000000000000000000000")
    30  
    31  	// 'w' not valid base32
    32  	assertParseError("00000000000000000000000000000000w")
    33  
    34  	// no prefix
    35  	assertParseError("sha1-00000000000000000000000000000000")
    36  	assertParseError("sha2-00000000000000000000000000000000")
    37  
    38  	r := Parse("00000000000000000000000000000000")
    39  	assert.NotNil(r)
    40  }
    41  
    42  func TestMaybeParse(t *testing.T) {
    43  	assert := assert.New(t)
    44  
    45  	parse := func(s string, success bool) {
    46  		r, ok := MaybeParse(s)
    47  		assert.Equal(success, ok, "Expected success=%t for %s", success, s)
    48  		if ok {
    49  			assert.Equal(s, r.String())
    50  		} else {
    51  			assert.Equal(emptyHash, r)
    52  		}
    53  	}
    54  
    55  	parse("00000000000000000000000000000000", true)
    56  	parse("00000000000000000000000000000001", true)
    57  	parse("", false)
    58  	parse("adsfasdf", false)
    59  	parse("sha2-00000000000000000000000000000000", false)
    60  	parse("0000000000000000000000000000000w", false)
    61  }
    62  
    63  func TestEquals(t *testing.T) {
    64  	assert := assert.New(t)
    65  
    66  	r0 := Parse("00000000000000000000000000000000")
    67  	r01 := Parse("00000000000000000000000000000000")
    68  	r1 := Parse("00000000000000000000000000000001")
    69  
    70  	assert.Equal(r0, r01)
    71  	assert.Equal(r01, r0)
    72  	assert.NotEqual(r0, r1)
    73  	assert.NotEqual(r1, r0)
    74  }
    75  
    76  func TestString(t *testing.T) {
    77  	s := "0123456789abcdefghijklmnopqrstuv"
    78  	r := Parse(s)
    79  	assert.Equal(t, s, r.String())
    80  }
    81  
    82  func TestOf(t *testing.T) {
    83  	r := Of([]byte("abc"))
    84  	assert.Equal(t, "rmnjb8cjc5tblj21ed4qs821649eduie", r.String())
    85  }
    86  
    87  func TestIsEmpty(t *testing.T) {
    88  	r1 := Hash{}
    89  	assert.True(t, r1.IsEmpty())
    90  
    91  	r2 := Parse("00000000000000000000000000000000")
    92  	assert.True(t, r2.IsEmpty())
    93  
    94  	r3 := Parse("rmnjb8cjc5tblj21ed4qs821649eduie")
    95  	assert.False(t, r3.IsEmpty())
    96  }
    97  
    98  func TestLess(t *testing.T) {
    99  	assert := assert.New(t)
   100  
   101  	r1 := Parse("00000000000000000000000000000001")
   102  	r2 := Parse("00000000000000000000000000000002")
   103  
   104  	assert.False(r1.Less(r1))
   105  	assert.True(r1.Less(r2))
   106  	assert.False(r2.Less(r1))
   107  	assert.False(r2.Less(r2))
   108  
   109  	r0 := Hash{}
   110  	assert.False(r0.Less(r0))
   111  	assert.True(r0.Less(r2))
   112  	assert.False(r2.Less(r0))
   113  }
   114  
   115  func TestGreater(t *testing.T) {
   116  	assert := assert.New(t)
   117  
   118  	r1 := Parse("00000000000000000000000000000001")
   119  	r2 := Parse("00000000000000000000000000000002")
   120  
   121  	assert.False(r1.Greater(r1))
   122  	assert.False(r1.Greater(r2))
   123  	assert.True(r2.Greater(r1))
   124  	assert.False(r2.Greater(r2))
   125  
   126  	r0 := Hash{}
   127  	assert.False(r0.Greater(r0))
   128  	assert.False(r0.Greater(r2))
   129  	assert.True(r2.Greater(r0))
   130  }