github.com/bingoohuang/gg@v0.0.0-20240325092523-45da7dee9335/pkg/jsoni/value_tests/float_test.go (about)

     1  package test
     2  
     3  import (
     4  	"bytes"
     5  	"context"
     6  	"encoding/json"
     7  	"fmt"
     8  	"strconv"
     9  	"testing"
    10  
    11  	"github.com/bingoohuang/gg/pkg/jsoni"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  func Test_read_float(t *testing.T) {
    16  	inputs := []string{
    17  		`1.1`, `1000`, `9223372036854775807`, `12.3`, `-12.3`, `720368.54775807`, `720368.547758075`,
    18  		`1e1`, `1e+1`, `1e-1`, `1E1`, `1E+1`, `1E-1`, `-1e1`, `-1e+1`, `-1e-1`,
    19  	}
    20  	for _, input := range inputs {
    21  		// non-streaming
    22  		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
    23  			should := require.New(t)
    24  			iter := jsoni.ParseString(jsoni.ConfigDefault, input+",")
    25  			expected, err := strconv.ParseFloat(input, 32)
    26  			should.Nil(err)
    27  			should.Equal(float32(expected), iter.ReadFloat32())
    28  		})
    29  		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
    30  			should := require.New(t)
    31  			iter := jsoni.ParseString(jsoni.ConfigDefault, input+",")
    32  			expected, err := strconv.ParseFloat(input, 64)
    33  			should.Nil(err)
    34  			should.Equal(expected, iter.ReadFloat64())
    35  		})
    36  		// streaming
    37  		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
    38  			should := require.New(t)
    39  			iter := jsoni.Parse(jsoni.ConfigDefault, bytes.NewBufferString(input+","), 2)
    40  			expected, err := strconv.ParseFloat(input, 32)
    41  			should.Nil(err)
    42  			should.Equal(float32(expected), iter.ReadFloat32())
    43  		})
    44  		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
    45  			should := require.New(t)
    46  			iter := jsoni.Parse(jsoni.ConfigDefault, bytes.NewBufferString(input+","), 2)
    47  			val := float64(0)
    48  			err := json.Unmarshal([]byte(input), &val)
    49  			should.Nil(err)
    50  			should.Equal(val, iter.ReadFloat64())
    51  		})
    52  	}
    53  }
    54  
    55  func Test_write_float32(t *testing.T) {
    56  	vals := []float32{
    57  		0, 1, -1, 99, 0xff, 0xfff, 0xffff, 0xfffff, 0xffffff, 0x4ffffff, 0xfffffff,
    58  		-0x4ffffff, -0xfffffff, 1.2345, 1.23456, 1.234567, 1.001,
    59  	}
    60  	ctx := context.Background()
    61  	for _, val := range vals {
    62  		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
    63  			should := require.New(t)
    64  			buf := &bytes.Buffer{}
    65  			stream := jsoni.NewStream(jsoni.ConfigDefault, buf, 4096)
    66  			stream.WriteFloat32Lossy(val)
    67  			stream.Flush()
    68  			should.Nil(stream.Error)
    69  			output, err := json.Marshal(val)
    70  			should.Nil(err)
    71  			should.Equal(string(output), buf.String())
    72  		})
    73  		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
    74  			should := require.New(t)
    75  			buf := &bytes.Buffer{}
    76  			stream := jsoni.NewStream(jsoni.ConfigDefault, buf, 4096)
    77  			stream.WriteVal(ctx, val)
    78  			stream.Flush()
    79  			should.Nil(stream.Error)
    80  			output, err := json.Marshal(val)
    81  			should.Nil(err)
    82  			should.Equal(string(output), buf.String())
    83  		})
    84  	}
    85  	should := require.New(t)
    86  	buf := &bytes.Buffer{}
    87  	stream := jsoni.NewStream(jsoni.ConfigDefault, buf, 10)
    88  	stream.WriteRaw("abcdefg")
    89  	stream.WriteFloat32Lossy(1.123456)
    90  	stream.Flush()
    91  	should.Nil(stream.Error)
    92  	should.Equal("abcdefg1.123456", buf.String())
    93  
    94  	stream = jsoni.NewStream(jsoni.ConfigDefault, nil, 0)
    95  	stream.WriteFloat32(float32(0.0000001))
    96  	should.Equal("1e-07", string(stream.Buffer()))
    97  }
    98  
    99  func Test_write_float64(t *testing.T) {
   100  	ctx := context.Background()
   101  	vals := []float64{
   102  		0, 1, -1, 99, 0xff, 0xfff, 0xffff, 0xfffff, 0xffffff, 0x4ffffff, 0xfffffff,
   103  		-0x4ffffff, -0xfffffff, 1.2345, 1.23456, 1.234567, 1.001,
   104  	}
   105  	for _, val := range vals {
   106  		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
   107  			should := require.New(t)
   108  			buf := &bytes.Buffer{}
   109  			stream := jsoni.NewStream(jsoni.ConfigDefault, buf, 4096)
   110  			stream.WriteFloat64Lossy(val)
   111  			stream.Flush()
   112  			should.Nil(stream.Error)
   113  			should.Equal(strconv.FormatFloat(val, 'f', -1, 64), buf.String())
   114  		})
   115  		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
   116  			should := require.New(t)
   117  			buf := &bytes.Buffer{}
   118  			stream := jsoni.NewStream(jsoni.ConfigDefault, buf, 4096)
   119  			stream.WriteVal(ctx, val)
   120  			stream.Flush()
   121  			should.Nil(stream.Error)
   122  			should.Equal(strconv.FormatFloat(val, 'f', -1, 64), buf.String())
   123  		})
   124  	}
   125  	should := require.New(t)
   126  	buf := &bytes.Buffer{}
   127  	stream := jsoni.NewStream(jsoni.ConfigDefault, buf, 10)
   128  	stream.WriteRaw("abcdefg")
   129  	stream.WriteFloat64Lossy(1.123456)
   130  	stream.Flush()
   131  	should.Nil(stream.Error)
   132  	should.Equal("abcdefg1.123456", buf.String())
   133  
   134  	stream = jsoni.NewStream(jsoni.ConfigDefault, nil, 0)
   135  	stream.WriteFloat64(0.0000001)
   136  	should.Equal("1e-07", string(stream.Buffer()))
   137  }