github.com/neohugo/neohugo@v0.123.8/common/hreflect/helpers_test.go (about)

     1  // Copyright 2019 The Hugo Authors. All rights reserved.
     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  // http://www.apache.org/licenses/LICENSE-2.0
     7  //
     8  // Unless required by applicable law or agreed to in writing, software
     9  // distributed under the License is distributed on an "AS IS" BASIS,
    10  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    11  // See the License for the specific language governing permissions and
    12  // limitations under the License.
    13  
    14  package hreflect
    15  
    16  import (
    17  	"context"
    18  	"reflect"
    19  	"testing"
    20  	"time"
    21  
    22  	qt "github.com/frankban/quicktest"
    23  )
    24  
    25  func TestIsTruthful(t *testing.T) {
    26  	c := qt.New(t)
    27  
    28  	c.Assert(IsTruthful(true), qt.Equals, true)
    29  	c.Assert(IsTruthful(false), qt.Equals, false)
    30  	c.Assert(IsTruthful(time.Now()), qt.Equals, true)
    31  	c.Assert(IsTruthful(time.Time{}), qt.Equals, false)
    32  }
    33  
    34  func TestGetMethodByName(t *testing.T) {
    35  	c := qt.New(t)
    36  	v := reflect.ValueOf(&testStruct{})
    37  	tp := v.Type()
    38  
    39  	c.Assert(GetMethodIndexByName(tp, "Method1"), qt.Equals, 0)
    40  	c.Assert(GetMethodIndexByName(tp, "Method3"), qt.Equals, 2)
    41  	c.Assert(GetMethodIndexByName(tp, "Foo"), qt.Equals, -1)
    42  }
    43  
    44  func TestIsContextType(t *testing.T) {
    45  	c := qt.New(t)
    46  	type k string
    47  	ctx := context.Background()
    48  	valueCtx := context.WithValue(ctx, k("key"), 32)
    49  	c.Assert(IsContextType(reflect.TypeOf(ctx)), qt.IsTrue)
    50  	c.Assert(IsContextType(reflect.TypeOf(valueCtx)), qt.IsTrue)
    51  }
    52  
    53  func BenchmarkIsContextType(b *testing.B) {
    54  	type k string
    55  	b.Run("value", func(b *testing.B) {
    56  		ctx := context.Background()
    57  		ctxs := make([]reflect.Type, b.N)
    58  		for i := 0; i < b.N; i++ {
    59  			ctxs[i] = reflect.TypeOf(context.WithValue(ctx, k("key"), i))
    60  		}
    61  
    62  		b.ResetTimer()
    63  		for i := 0; i < b.N; i++ {
    64  			if !IsContextType(ctxs[i]) {
    65  				b.Fatal("not context")
    66  			}
    67  		}
    68  	})
    69  
    70  	b.Run("background", func(b *testing.B) {
    71  		var ctxt reflect.Type = reflect.TypeOf(context.Background())
    72  		for i := 0; i < b.N; i++ {
    73  			if !IsContextType(ctxt) {
    74  				b.Fatal("not context")
    75  			}
    76  		}
    77  	})
    78  }
    79  
    80  func BenchmarkIsTruthFul(b *testing.B) {
    81  	v := reflect.ValueOf("Hugo")
    82  
    83  	b.ResetTimer()
    84  	for i := 0; i < b.N; i++ {
    85  		if !IsTruthfulValue(v) {
    86  			b.Fatal("not truthful")
    87  		}
    88  	}
    89  }
    90  
    91  type testStruct struct{}
    92  
    93  func (t *testStruct) Method1() string {
    94  	return "Hugo"
    95  }
    96  
    97  func (t *testStruct) Method2() string {
    98  	return "Hugo"
    99  }
   100  
   101  func (t *testStruct) Method3() string {
   102  	return "Hugo"
   103  }
   104  
   105  func (t *testStruct) Method4() string {
   106  	return "Hugo"
   107  }
   108  
   109  func (t *testStruct) Method5() string {
   110  	return "Hugo"
   111  }
   112  
   113  func BenchmarkGetMethodByName(b *testing.B) {
   114  	v := reflect.ValueOf(&testStruct{})
   115  	methods := []string{"Method1", "Method2", "Method3", "Method4", "Method5"}
   116  
   117  	b.ResetTimer()
   118  	for i := 0; i < b.N; i++ {
   119  		for _, method := range methods {
   120  			_ = GetMethodByName(v, method)
   121  		}
   122  	}
   123  }