github.com/matrixorigin/matrixone@v0.7.0/pkg/util/trace/config_test.go (about)

     1  // Copyright 2022 Matrix Origin
     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 trace
    16  
    17  import (
    18  	"github.com/stretchr/testify/assert"
    19  	"github.com/stretchr/testify/require"
    20  	"testing"
    21  )
    22  
    23  var _1TraceID TraceID = [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1}
    24  var _1SpanID SpanID = [8]byte{0, 0, 0, 0, 0, 0, 0, 1}
    25  
    26  func TestTraceID_IsZero(t *testing.T) {
    27  	tests := []struct {
    28  		name string
    29  		t    TraceID
    30  		want bool
    31  	}{
    32  		{
    33  			name: "normal",
    34  			t:    _1TraceID,
    35  			want: false,
    36  		},
    37  		{
    38  			name: "nil",
    39  			t:    NilTraceID,
    40  			want: true,
    41  		},
    42  	}
    43  	for _, tt := range tests {
    44  		t.Run(tt.name, func(t *testing.T) {
    45  			assert.Equalf(t, tt.want, tt.t.IsZero(), "IsZero()")
    46  		})
    47  	}
    48  }
    49  
    50  func TestSpanID_SetByUUID_IsZero(t *testing.T) {
    51  	type args struct {
    52  		id string
    53  	}
    54  	tests := []struct {
    55  		name     string
    56  		s        SpanID
    57  		args     args
    58  		wantZero bool
    59  	}{
    60  		{
    61  			name:     "normal",
    62  			args:     args{id: "node_uuid"},
    63  			wantZero: false,
    64  		},
    65  		{
    66  			name:     "short",
    67  			args:     args{id: "1234"},
    68  			wantZero: false,
    69  		},
    70  		{
    71  			name:     "nil",
    72  			args:     args{id: "00000000-0000-0000-0000-000000000000"},
    73  			wantZero: true,
    74  		},
    75  	}
    76  	for _, tt := range tests {
    77  		t.Run(tt.name, func(t *testing.T) {
    78  			tt.s.SetByUUID(tt.args.id)
    79  			t.Logf("SpanID: %s", tt.s.String())
    80  			require.Equal(t, tt.wantZero, tt.s.IsZero())
    81  		})
    82  	}
    83  }
    84  
    85  func TestSpanContext_IsEmpty(t *testing.T) {
    86  	type fields struct {
    87  		TraceID TraceID
    88  		SpanID  SpanID
    89  	}
    90  	tests := []struct {
    91  		name   string
    92  		fields fields
    93  		want   bool
    94  	}{
    95  		{
    96  			name: "normal",
    97  			fields: fields{
    98  				TraceID: _1TraceID,
    99  				SpanID:  _1SpanID,
   100  			},
   101  			want: false,
   102  		},
   103  		{
   104  			name: "nilTraceID",
   105  			fields: fields{
   106  				TraceID: NilTraceID,
   107  				SpanID:  _1SpanID,
   108  			},
   109  			want: false,
   110  		},
   111  		{
   112  			name: "nilSpanID",
   113  			fields: fields{
   114  				TraceID: _1TraceID,
   115  				SpanID:  NilSpanID,
   116  			},
   117  			want: false,
   118  		},
   119  		{
   120  			name: "nil",
   121  			fields: fields{
   122  				TraceID: NilTraceID,
   123  				SpanID:  NilSpanID,
   124  			},
   125  			want: true,
   126  		},
   127  	}
   128  	for _, tt := range tests {
   129  		t.Run(tt.name, func(t *testing.T) {
   130  			c := &SpanContext{
   131  				TraceID: tt.fields.TraceID,
   132  				SpanID:  tt.fields.SpanID,
   133  			}
   134  			assert.Equalf(t, tt.want, c.IsEmpty(), "IsEmpty()")
   135  		})
   136  	}
   137  }