github.com/khulnasoft-lab/defsec@v1.0.5-0.20230827010352-5e9f46893d95/pkg/scanners/azure/arm/parser/armjson/parse_number_test.go (about)

     1  package armjson
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/khulnasoft-lab/defsec/pkg/types"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  func Test_Number_IntToInt(t *testing.T) {
    13  	example := []byte(`123`)
    14  	var output int
    15  	metadata := types.NewTestMetadata()
    16  	err := Unmarshal(example, &output, &metadata)
    17  	require.NoError(t, err)
    18  	assert.Equal(t, 123, output)
    19  }
    20  
    21  func Test_Number_IntToFloat(t *testing.T) {
    22  	example := []byte(`123`)
    23  	var output float64
    24  	metadata := types.NewTestMetadata()
    25  	err := Unmarshal(example, &output, &metadata)
    26  	require.NoError(t, err)
    27  	assert.Equal(t, 123.0, output)
    28  }
    29  
    30  func Test_Number_FloatToFloat(t *testing.T) {
    31  	example := []byte(`123.456`)
    32  	var output float64
    33  	metadata := types.NewTestMetadata()
    34  	err := Unmarshal(example, &output, &metadata)
    35  	require.NoError(t, err)
    36  	assert.Equal(t, 123.456, output)
    37  }
    38  
    39  func Test_Number_FloatToInt(t *testing.T) {
    40  	example := []byte(`123.456`)
    41  	var output int
    42  	metadata := types.NewTestMetadata()
    43  	err := Unmarshal(example, &output, &metadata)
    44  	require.NoError(t, err)
    45  	assert.Equal(t, 123, output)
    46  }
    47  
    48  func Test_Number_FloatWithExponent(t *testing.T) {
    49  	cases := []struct {
    50  		in  string
    51  		out float64
    52  	}{
    53  		{
    54  			in:  `123.456e10`,
    55  			out: 123.456e+10,
    56  		},
    57  		{
    58  			in:  `123e+1`,
    59  			out: 123e+1,
    60  		},
    61  		{
    62  			in:  `123e-2`,
    63  			out: 123e-2,
    64  		},
    65  	}
    66  	for _, test := range cases {
    67  		t.Run(test.in, func(t *testing.T) {
    68  			example := []byte(test.in)
    69  			var output float64
    70  			metadata := types.NewTestMetadata()
    71  			err := Unmarshal(example, &output, &metadata)
    72  			require.NoError(t, err)
    73  			assert.Equal(t, test.out, output)
    74  
    75  		})
    76  	}
    77  }
    78  
    79  func Test_Number_IntWithExponent(t *testing.T) {
    80  	cases := []struct {
    81  		in  string
    82  		out int64
    83  	}{
    84  		{
    85  			in:  `123e10`,
    86  			out: 123e+10,
    87  		},
    88  		{
    89  			in:  `123e+1`,
    90  			out: 123e+1,
    91  		},
    92  	}
    93  	for _, test := range cases {
    94  		t.Run(test.in, func(t *testing.T) {
    95  			example := []byte(test.in)
    96  			var output int64
    97  			metadata := types.NewTestMetadata()
    98  			err := Unmarshal(example, &output, &metadata)
    99  			require.NoError(t, err)
   100  			assert.Equal(t, test.out, output)
   101  
   102  		})
   103  	}
   104  }
   105  
   106  func Test_Number_Ints(t *testing.T) {
   107  	cases := []struct {
   108  		in  string
   109  		out int64
   110  		err bool
   111  	}{
   112  		{
   113  			in:  `123e10`,
   114  			out: 123e+10,
   115  		},
   116  		{
   117  			in:  `-1`,
   118  			out: -1,
   119  		},
   120  		{
   121  			in:  `1.0123`,
   122  			out: 1,
   123  		},
   124  		{
   125  			in:  `0`,
   126  			out: 0,
   127  		},
   128  		{
   129  			in:  `01`,
   130  			err: true,
   131  		},
   132  		{
   133  			in:  ``,
   134  			err: true,
   135  		},
   136  		{
   137  			in:  `+1`,
   138  			err: true,
   139  		},
   140  		{
   141  			in:  `e`,
   142  			err: true,
   143  		},
   144  
   145  		{
   146  			in:  `.123`,
   147  			err: true,
   148  		},
   149  
   150  		{
   151  			in:  `.`,
   152  			err: true,
   153  		},
   154  
   155  		{
   156  			in:  `00`,
   157  			err: true,
   158  		},
   159  		{
   160  			in:  `-`,
   161  			err: true,
   162  		},
   163  	}
   164  	for _, test := range cases {
   165  		t.Run(test.in, func(t *testing.T) {
   166  			example := []byte(test.in)
   167  			var output int64
   168  			metadata := types.NewTestMetadata()
   169  			err := Unmarshal(example, &output, &metadata)
   170  			if test.err {
   171  				require.Error(t, err)
   172  				return
   173  			}
   174  			require.NoError(t, err)
   175  			assert.Equal(t, test.out, output)
   176  		})
   177  	}
   178  }