github.com/cloudwego/hertz@v0.9.3/internal/bytesconv/bytesconv_32_test.go (about)

     1  //go:build !amd64 && !arm64 && !ppc64
     2  // +build !amd64,!arm64,!ppc64
     3  
     4  /*
     5   * Copyright 2022 CloudWeGo Authors
     6   *
     7   * Licensed under the Apache License, Version 2.0 (the "License");
     8   * you may not use this file except in compliance with the License.
     9   * You may obtain a copy of the License at
    10   *
    11   *     http://www.apache.org/licenses/LICENSE-2.0
    12   *
    13   * Unless required by applicable law or agreed to in writing, software
    14   * distributed under the License is distributed on an "AS IS" BASIS,
    15   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    16   * See the License for the specific language governing permissions and
    17   * limitations under the License.
    18   *
    19   * The MIT License (MIT)
    20   *
    21   * Copyright (c) 2015-present Aliaksandr Valialkin, VertaMedia, Kirill Danshin, Erik Dubbelboer, FastHTTP Authors
    22   *
    23   * Permission is hereby granted, free of charge, to any person obtaining a copy
    24   * of this software and associated documentation files (the "Software"), to deal
    25   * in the Software without restriction, including without limitation the rights
    26   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    27   * copies of the Software, and to permit persons to whom the Software is
    28   * furnished to do so, subject to the following conditions:
    29   *
    30   * The above copyright notice and this permission notice shall be included in
    31   * all copies or substantial portions of the Software.
    32   *
    33   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    34   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    35   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    36   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    37   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    38   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    39   * THE SOFTWARE.
    40   *
    41   * This file may have been modified by CloudWeGo authors. All CloudWeGo
    42   * Modifications are Copyright 2022 CloudWeGo Authors.
    43   */
    44  
    45  package bytesconv
    46  
    47  import (
    48  	"fmt"
    49  	"testing"
    50  
    51  	"github.com/cloudwego/hertz/pkg/common/test/assert"
    52  )
    53  
    54  func TestWriteHexInt(t *testing.T) {
    55  	t.Parallel()
    56  
    57  	for _, v := range []struct {
    58  		s string
    59  		n int
    60  	}{
    61  		{"0", 0},
    62  		{"1", 1},
    63  		{"123", 0x123},
    64  		{"7fffffff", 0x7fffffff},
    65  	} {
    66  		testWriteHexInt(t, v.n, v.s)
    67  	}
    68  }
    69  
    70  func TestReadHexInt(t *testing.T) {
    71  	t.Parallel()
    72  
    73  	for _, v := range []struct {
    74  		s string
    75  		n int
    76  	}{
    77  		//errTooLargeHexNum "too large hex number"
    78  		//{"0123456789abcdef", -1},
    79  		{"0", 0},
    80  		{"fF", 0xff},
    81  		{"00abc", 0xabc},
    82  		{"7fffffff", 0x7fffffff},
    83  		{"000", 0},
    84  		{"1234ZZZ", 0x1234},
    85  	} {
    86  		testReadHexInt(t, v.s, v.n)
    87  	}
    88  }
    89  
    90  func TestParseUint(t *testing.T) {
    91  	t.Parallel()
    92  
    93  	for _, v := range []struct {
    94  		s string
    95  		i int
    96  	}{
    97  		{"0", 0},
    98  		{"123", 123},
    99  		{"123456789", 123456789},
   100  		{"2147483647", 2147483647},
   101  	} {
   102  		n, err := ParseUint(S2b(v.s))
   103  		if err != nil {
   104  			t.Errorf("unexpected error: %v. s=%q n=%v", err, v.s, n)
   105  		}
   106  		assert.DeepEqual(t, n, v.i)
   107  	}
   108  }
   109  
   110  func TestParseUintError(t *testing.T) {
   111  	t.Parallel()
   112  
   113  	for _, v := range []struct {
   114  		s string
   115  	}{
   116  		{""},
   117  		{"cloudwego123"},
   118  		{"1234.545"},
   119  		{"-2147483648"},
   120  		{"2147483648"},
   121  		{"4294967295"},
   122  	} {
   123  		n, err := ParseUint(S2b(v.s))
   124  		if err == nil {
   125  			t.Fatalf("Expecting error when parsing %q. obtained %d", v.s, n)
   126  		}
   127  		if n >= 0 {
   128  			t.Fatalf("Unexpected n=%d when parsing %q. Expected negative num", n, v.s)
   129  		}
   130  	}
   131  }
   132  
   133  func TestAppendUint(t *testing.T) {
   134  	t.Parallel()
   135  
   136  	for _, s := range []struct {
   137  		n int
   138  	}{
   139  		{0},
   140  		{123},
   141  		{0x7fffffff},
   142  	} {
   143  		expectedS := fmt.Sprintf("%d", s.n)
   144  		s := AppendUint(nil, s.n)
   145  		assert.DeepEqual(t, expectedS, B2s(s))
   146  	}
   147  }