convert_test.go

Documentation: github.com/go-openapi/swag

     1  // Copyright 2015 go-swagger maintainers
     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  package swag
    16  
    17  import (
    18  	"math"
    19  	"strconv"
    20  	"testing"
    21  
    22  	"github.com/stretchr/testify/assert"
    23  	"github.com/stretchr/testify/require"
    24  )
    25  
    26  func errMsg(f string) string {
    27  	const (
    28  		expectedQuote = "expected '"
    29  		errSuffix     = "' to generate an error"
    30  	)
    31  
    32  	return expectedQuote + f + errSuffix
    33  }
    34  
    35  // These are really dumb tests
    36  
    37  func TestConvertBool(t *testing.T) {
    38  	for k := range evaluatesAsTrue {
    39  		r, err := ConvertBool(k)
    40  		require.NoError(t, err)
    41  		assert.True(t, r)
    42  	}
    43  	for _, k := range []string{"a", "", "0", "false", "unchecked"} {
    44  		r, err := ConvertBool(k)
    45  		require.NoError(t, err)
    46  		assert.False(t, r)
    47  	}
    48  }
    49  
    50  func TestConvertFloat32(t *testing.T) {
    51  	validFloats := []float32{1.0, -1, math.MaxFloat32, math.SmallestNonzeroFloat32, 0, 5.494430303}
    52  	invalidFloats := []string{"a", strconv.FormatFloat(math.MaxFloat64, 'f', -1, 64), "true"}
    53  
    54  	for _, f := range validFloats {
    55  		c, err := ConvertFloat32(FormatFloat32(f))
    56  		require.NoError(t, err)
    57  		assert.InDelta(t, f, c, 1e-6)
    58  	}
    59  	for _, f := range invalidFloats {
    60  		_, err := ConvertFloat32(f)
    61  		require.Error(t, err, errMsg(f))
    62  	}
    63  }
    64  
    65  func TestConvertFloat64(t *testing.T) {
    66  	validFloats := []float64{1.0, -1, float64(math.MaxFloat32), float64(math.SmallestNonzeroFloat32), math.MaxFloat64, math.SmallestNonzeroFloat64, 0, 5.494430303}
    67  	invalidFloats := []string{"a", "true"}
    68  
    69  	for _, f := range validFloats {
    70  		c, err := ConvertFloat64(FormatFloat64(f))
    71  		require.NoError(t, err)
    72  		assert.InDelta(t, f, c, 1e-6)
    73  	}
    74  	for _, f := range invalidFloats {
    75  		_, err := ConvertFloat64(f)
    76  		require.Error(t, err, errMsg(f))
    77  	}
    78  }
    79  
    80  func TestConvertInt8(t *testing.T) {
    81  	validInts := []int8{0, 1, -1, math.MaxInt8, math.MinInt8}
    82  	invalidInts := []string{"1.233", "a", "false", strconv.FormatInt(int64(math.MaxInt64), 10)}
    83  
    84  	for _, f := range validInts {
    85  		c, err := ConvertInt8(FormatInt8(f))
    86  		require.NoError(t, err)
    87  		assert.EqualValues(t, f, c)
    88  	}
    89  	for _, f := range invalidInts {
    90  		_, err := ConvertInt8(f)
    91  		require.Error(t, err, errMsg(f))
    92  	}
    93  }
    94  
    95  func TestConvertInt16(t *testing.T) {
    96  	validInts := []int16{0, 1, -1, math.MaxInt8, math.MinInt8, math.MaxInt16, math.MinInt16}
    97  	invalidInts := []string{"1.233", "a", "false", strconv.FormatInt(int64(math.MaxInt64), 10)}
    98  
    99  	for _, f := range validInts {
   100  		c, err := ConvertInt16(FormatInt16(f))
   101  		require.NoError(t, err)
   102  		assert.EqualValues(t, f, c)
   103  	}
   104  	for _, f := range invalidInts {
   105  		_, err := ConvertInt16(f)
   106  		require.Error(t, err, errMsg(f))
   107  	}
   108  }
   109  
   110  func TestConvertInt32(t *testing.T) {
   111  	validInts := []int32{0, 1, -1, math.MaxInt8, math.MinInt8, math.MaxInt16, math.MinInt16, math.MinInt32, math.MaxInt32}
   112  	invalidInts := []string{"1.233", "a", "false", strconv.FormatInt(int64(math.MaxInt64), 10)}
   113  
   114  	for _, f := range validInts {
   115  		c, err := ConvertInt32(FormatInt32(f))
   116  		require.NoError(t, err)
   117  		assert.EqualValues(t, f, c)
   118  	}
   119  	for _, f := range invalidInts {
   120  		_, err := ConvertInt32(f)
   121  		require.Error(t, err, errMsg(f))
   122  	}
   123  }
   124  
   125  func TestConvertInt64(t *testing.T) {
   126  	validInts := []int64{0, 1, -1, math.MaxInt8, math.MinInt8, math.MaxInt16, math.MinInt16, math.MinInt32, math.MaxInt32, math.MaxInt64, math.MinInt64}
   127  	invalidInts := []string{"1.233", "a", "false"}
   128  
   129  	for _, f := range validInts {
   130  		c, err := ConvertInt64(FormatInt64(f))
   131  		require.NoError(t, err)
   132  		assert.EqualValues(t, f, c)
   133  	}
   134  	for _, f := range invalidInts {
   135  		_, err := ConvertInt64(f)
   136  		require.Error(t, err, errMsg(f))
   137  	}
   138  }
   139  
   140  func TestConvertUint8(t *testing.T) {
   141  	validInts := []uint8{0, 1, math.MaxUint8}
   142  	invalidInts := []string{"1.233", "a", "false", strconv.FormatUint(math.MaxUint64, 10)}
   143  
   144  	for _, f := range validInts {
   145  		c, err := ConvertUint8(FormatUint8(f))
   146  		require.NoError(t, err)
   147  		assert.EqualValues(t, f, c)
   148  	}
   149  	for _, f := range invalidInts {
   150  		_, err := ConvertUint8(f)
   151  		require.Error(t, err, errMsg(f))
   152  	}
   153  }
   154  
   155  func TestConvertUint16(t *testing.T) {
   156  	validUints := []uint16{0, 1, math.MaxUint8, math.MaxUint16}
   157  	invalidUints := []string{"1.233", "a", "false", strconv.FormatUint(math.MaxUint64, 10)}
   158  
   159  	for _, f := range validUints {
   160  		c, err := ConvertUint16(FormatUint16(f))
   161  		require.NoError(t, err)
   162  		assert.EqualValues(t, f, c)
   163  	}
   164  	for _, f := range invalidUints {
   165  		_, err := ConvertUint16(f)
   166  		require.Error(t, err, errMsg(f))
   167  	}
   168  }
   169  
   170  func TestConvertUint32(t *testing.T) {
   171  	validUints := []uint32{0, 1, math.MaxUint8, math.MaxUint16, math.MaxUint32}
   172  	invalidUints := []string{"1.233", "a", "false", strconv.FormatUint(math.MaxUint64, 10)}
   173  
   174  	for _, f := range validUints {
   175  		c, err := ConvertUint32(FormatUint32(f))
   176  		require.NoError(t, err)
   177  		assert.EqualValues(t, f, c)
   178  	}
   179  	for _, f := range invalidUints {
   180  		_, err := ConvertUint32(f)
   181  		require.Error(t, err, errMsg(f))
   182  	}
   183  }
   184  
   185  func TestConvertUint64(t *testing.T) {
   186  	validUints := []uint64{0, 1, math.MaxUint8, math.MaxUint16, math.MaxUint32, math.MaxUint64}
   187  	invalidUints := []string{"1.233", "a", "false"}
   188  
   189  	for _, f := range validUints {
   190  		c, err := ConvertUint64(FormatUint64(f))
   191  		require.NoError(t, err)
   192  		assert.EqualValues(t, f, c)
   193  	}
   194  	for _, f := range invalidUints {
   195  		_, err := ConvertUint64(f)
   196  		require.Error(t, err, errMsg(f))
   197  	}
   198  }
   199  
   200  func TestIsFloat64AJSONInteger(t *testing.T) {
   201  	assert.False(t, IsFloat64AJSONInteger(math.Inf(1)))
   202  	assert.False(t, IsFloat64AJSONInteger(maxJSONFloat+1))
   203  
   204  	assert.False(t, IsFloat64AJSONInteger(minJSONFloat-1))
   205  	assert.True(t, IsFloat64AJSONInteger(1.0))
   206  	assert.True(t, IsFloat64AJSONInteger(maxJSONFloat))
   207  	assert.True(t, IsFloat64AJSONInteger(minJSONFloat))
   208  	assert.True(t, IsFloat64AJSONInteger(1/0.01*67.15000001))
   209  	assert.False(t, IsFloat64AJSONInteger(math.SmallestNonzeroFloat64))
   210  	assert.True(t, IsFloat64AJSONInteger(math.SmallestNonzeroFloat64/2))
   211  	assert.True(t, IsFloat64AJSONInteger(math.SmallestNonzeroFloat64/3))
   212  	assert.True(t, IsFloat64AJSONInteger(math.SmallestNonzeroFloat64/4))
   213  }
   214  
   215  func TestFormatBool(t *testing.T) {
   216  	assert.Equal(t, "true", FormatBool(true))
   217  	assert.Equal(t, "false", FormatBool(false))
   218  }
   219
View as plain text