github.com/hairyhenderson/gomplate/v4@v4.0.0-pre-2.0.20240520121557-362f058f0c93/random/random_test.go (about)

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