github.com/GuanceCloud/cliutils@v1.1.21/pipeline/ptinput/funcs/fn_parse_int_test.go (about)

     1  // Unless explicitly stated otherwise all files in this repository are licensed
     2  // under the MIT License.
     3  // This product includes software developed at Guance Cloud (https://www.guance.com/).
     4  // Copyright 2021-present Guance, Inc.
     5  
     6  package funcs
     7  
     8  import (
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/GuanceCloud/cliutils/pipeline/ptinput"
    13  	"github.com/GuanceCloud/cliutils/point"
    14  	tu "github.com/GuanceCloud/cliutils/testutil"
    15  )
    16  
    17  func TestParseInt(t *testing.T) {
    18  	cases := []struct {
    19  		name, pl, in string
    20  		expected     interface{}
    21  		fail         bool
    22  		outkey       string
    23  	}{
    24  		{
    25  			name: "format",
    26  			pl: `a = 17
    27  			b = format_int(a, 16)
    28  			if b != "11" {
    29  				add_key(abc, b)
    30  				exit()
    31  			}
    32  			c = parse_int(b, 16)
    33  			if c != a {
    34  				add_key(abc, c)
    35  				exit()
    36  			} else {
    37  				add_key(abc, "ok")
    38  			}
    39  			`,
    40  			in:       `test`,
    41  			expected: "ok",
    42  			outkey:   "abc",
    43  		},
    44  		{
    45  			name: "parse",
    46  			pl: `a = "11" # 0x11
    47   			b = parse_int(a, 16)
    48  			if b != 17 {
    49  				add_key(abc, b)
    50  				exit()
    51  			}
    52  			c = format_int(b, 16)
    53  			if c != a {
    54  				add_key(abc, c)
    55  				exit()
    56  			} else {
    57  				add_key(abc, "ok")
    58  			}
    59  			`,
    60  			in:       `test`,
    61  			expected: "ok",
    62  			outkey:   "abc",
    63  		},
    64  		{
    65  			name: "spanid-format",
    66  			pl: `a = 7665324064912355185
    67  			b = format_int(a, 16)
    68  			if b != "6a60b39fd95aaf71" {
    69  				add_key(abc, b)
    70  				exit()
    71  			}
    72  			c = parse_int(b, 16)
    73  			if c != a {
    74  				add_key(abc, c)
    75  				exit()
    76  			} else {
    77  				add_key(abc, "ok")
    78  			}
    79  			`,
    80  			in:       `test`,
    81  			expected: "ok",
    82  			outkey:   "abc",
    83  		},
    84  		{
    85  			name: "spanid-format-all-in-one",
    86  			pl: `a = "7665324064912355185"
    87  			b = format_int(parse_int(a, 10), 16)
    88  			if b != "6a60b39fd95aaf71" {
    89  				add_key(abc, b)
    90  				exit()
    91  			} else {
    92  				add_key(abc, "ok")
    93  			}
    94  			`,
    95  			in:       `test`,
    96  			expected: "ok",
    97  			outkey:   "abc",
    98  		},
    99  		{
   100  			name: "parse",
   101  			pl: `a = "6a60b39fd95aaf71" 
   102   			b = parse_int(a, 16)
   103  			if b != 7665324064912355185 {
   104  				add_key(abc, b)
   105  				exit()
   106  			}
   107  			c = format_int(b, 16)
   108  			if c != a {
   109  				add_key(abc, c)
   110  			} else {
   111  				add_key(abc, "ok")
   112  			}
   113  			`,
   114  			in:       `test`,
   115  			expected: "ok",
   116  			outkey:   "abc",
   117  		},
   118  		{
   119  			name: "parsex",
   120  			pl: `a = "0x6a60b39fd95aaf71" 
   121   			b = parse_int(a, 0)
   122  			if b != 7665324064912355185 {
   123  				add_key(abc, b)
   124  				exit()
   125  			}
   126  			c = format_int(b, 16)
   127  			if "0x"+c != a {
   128  				add_key(abc, c)
   129  			} else {
   130  				add_key(abc, "ok")
   131  			}
   132  			`,
   133  			in:       `test`,
   134  			expected: "ok",
   135  			outkey:   "abc",
   136  		},
   137  	}
   138  
   139  	for idx, tc := range cases {
   140  		t.Run(tc.name, func(t *testing.T) {
   141  			runner, err := NewTestingRunner(tc.pl)
   142  			if err != nil {
   143  				if tc.fail {
   144  					t.Logf("[%d]expect error: %s", idx, err)
   145  				} else {
   146  					t.Errorf("[%d] failed: %s", idx, err)
   147  				}
   148  				return
   149  			}
   150  			pt := ptinput.NewPlPoint(
   151  				point.Logging, "test", nil, map[string]any{"message": tc.in}, time.Now())
   152  			errR := runScript(runner, pt)
   153  
   154  			if errR != nil {
   155  				t.Fatal(errR.Error())
   156  			}
   157  
   158  			v, _, _ := pt.Get(tc.outkey)
   159  			// tu.Equals(t, nil, err)
   160  			tu.Equals(t, tc.expected, v)
   161  			t.Logf("[%d] PASS", idx)
   162  		})
   163  	}
   164  }