github.com/wuhuizuo/gomplate@v3.5.0+incompatible/random/random_test.go (about)

     1  package random
     2  
     3  import (
     4  	"math"
     5  	"testing"
     6  	"unicode/utf8"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  func TestMatchChars(t *testing.T) {
    12  	in := "[a-g]"
    13  	expected := []rune("abcdefg")
    14  	out, err := matchChars(in)
    15  	assert.NoError(t, err)
    16  	assert.EqualValues(t, expected, out)
    17  
    18  	in = "[a-zA-Z0-9_.-]"
    19  	expected = []rune(defaultSet)
    20  	out, err = matchChars(in)
    21  	assert.NoError(t, err)
    22  	assert.Equal(t, expected, out)
    23  
    24  	in = "[[:alpha:]]"
    25  	expected = []rune("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
    26  	out, err = matchChars(in)
    27  	assert.NoError(t, err)
    28  	assert.Equal(t, expected, out)
    29  }
    30  
    31  func TestStringRE(t *testing.T) {
    32  	r, err := StringRE(15, "[\\p{Yi}[:alnum:]]")
    33  	assert.NoError(t, err)
    34  	assert.Equal(t, 15, utf8.RuneCountInString(r))
    35  
    36  	_, err = StringRE(1, "[bogus")
    37  	assert.Error(t, err)
    38  }
    39  
    40  func TestStringBounds(t *testing.T) {
    41  	_, err := StringBounds(15, 0, 19)
    42  	assert.Error(t, err)
    43  
    44  	// surrogate range isn't valid, should error
    45  	_, err = StringBounds(15, 0xd800, 0xdfff)
    46  	assert.Error(t, err)
    47  
    48  	r, err := StringBounds(1, 'a', 'a')
    49  	assert.NoError(t, err)
    50  	assert.Equal(t, "a", r)
    51  
    52  	r, err = StringBounds(99, 'a', 'b')
    53  	assert.NoError(t, err)
    54  	assert.Regexp(t, "^[a-b]+$", r)
    55  
    56  	r, err = StringBounds(100, 0x0020, 0x007f)
    57  	assert.NoError(t, err)
    58  	assert.Regexp(t, "^[\u0020-\u007f]*$", r)
    59  
    60  	// only 🂱 (\U0001F0B1) in this range is "graphic"
    61  	r, err = StringBounds(8, 0x0001f0af, 0x0001f0b1)
    62  	assert.NoError(t, err)
    63  	assert.Regexp(t, "^🂱🂱🂱🂱🂱🂱🂱🂱$", r)
    64  }
    65  
    66  func TestItem(t *testing.T) {
    67  	_, err := Item(nil)
    68  	assert.Error(t, err)
    69  
    70  	i, err := Item([]interface{}{"foo"})
    71  	assert.NoError(t, err)
    72  	assert.Equal(t, "foo", i)
    73  
    74  	in := []interface{}{"foo", "bar"}
    75  	got := ""
    76  	for j := 0; j < 10; j++ {
    77  		i, err = Item(in)
    78  		assert.NoError(t, err)
    79  		got += i.(string)
    80  	}
    81  	assert.NotEqual(t, "foofoofoofoofoofoofoofoofoofoo", got)
    82  	assert.NotEqual(t, "barbarbarbarbarbarbarbarbarbar", got)
    83  }
    84  
    85  func TestNumber(t *testing.T) {
    86  	_, err := Number(0, -1)
    87  	assert.Error(t, err)
    88  	_, err = Number(0, math.MaxInt64)
    89  	assert.Error(t, err)
    90  	_, err = Number(math.MinInt64, 0)
    91  	assert.Error(t, err)
    92  
    93  	testdata := []struct {
    94  		min, max, expected int64
    95  		delta              float64
    96  	}{
    97  		{0, 100, 50, 50},
    98  		{0, 0, 0, 0},
    99  		{9, 9, 9, 0},
   100  		{-10, -10, -10, 0},
   101  		{-10, -0, -5, 5},
   102  	}
   103  	for _, d := range testdata {
   104  		n, err := Number(d.min, d.max)
   105  		assert.NoError(t, err)
   106  		assert.InDelta(t, d.expected, n, d.delta)
   107  	}
   108  }
   109  
   110  func TestFloat(t *testing.T) {
   111  	testdata := []struct {
   112  		min, max, expected float64
   113  		delta              float64
   114  	}{
   115  		{0, 1.0, 0.5, 0.5},
   116  		{0, 0.5, 0.25, 0.25},
   117  		{490, 500, 495, 5},
   118  		{-500, 500, 0, 500},
   119  		{0, math.MaxFloat64, math.MaxFloat64 / 2, math.MaxFloat64 / 2},
   120  	}
   121  
   122  	for _, d := range testdata {
   123  		n, err := Float(d.min, d.max)
   124  		assert.NoError(t, err)
   125  		assert.InDelta(t, d.expected, n, d.delta)
   126  	}
   127  }