github.com/gnolang/gno@v0.0.0-20240520182011-228e9d0192ce/gnovm/tests/backup/assert0.gno (about)

     1  package main
     2  
     3  import (
     4  	"fmt"
     5  	"reflect"
     6  	"time"
     7  )
     8  
     9  type MyWriter interface {
    10  	Write(p []byte) (i int, err error)
    11  }
    12  
    13  type TestStruct struct{}
    14  
    15  func (t TestStruct) Write(p []byte) (n int, err error) {
    16  	return len(p), nil
    17  }
    18  
    19  func usesWriter(w MyWriter) {
    20  	n, _ := w.Write([]byte("hello world"))
    21  	fmt.Println(n)
    22  }
    23  
    24  type MyStringer interface {
    25  	String() string
    26  }
    27  
    28  func usesStringer(s MyStringer) {
    29  	fmt.Println(s.String())
    30  }
    31  
    32  func main() {
    33  	aType := reflect.TypeOf((*MyWriter)(nil)).Elem()
    34  
    35  	var t interface{}
    36  	t = TestStruct{}
    37  	var tw MyWriter
    38  	var ok bool
    39  	tw, ok = t.(MyWriter)
    40  	if !ok {
    41  		fmt.Println("TestStruct does not implement MyWriter")
    42  	} else {
    43  		fmt.Println("TestStruct implements MyWriter")
    44  		usesWriter(tw)
    45  	}
    46  	n, _ := t.(MyWriter).Write([]byte("hello world"))
    47  	fmt.Println(n)
    48  	bType := reflect.TypeOf(TestStruct{})
    49  	fmt.Println(aType.IsImplementedBy(bType))
    50  
    51  	t = 42
    52  	foo, ok := t.(MyWriter)
    53  	if !ok {
    54  		fmt.Println("42 does not implement MyWriter")
    55  	} else {
    56  		fmt.Println("42 implements MyWriter")
    57  	}
    58  	_ = foo
    59  
    60  	var tt interface{}
    61  	tt = time.Nanosecond
    62  	var myD MyStringer
    63  	myD, ok = tt.(MyStringer)
    64  	if !ok {
    65  		fmt.Println("time.Nanosecond does not implement MyStringer")
    66  	} else {
    67  		fmt.Println("time.Nanosecond implements MyStringer")
    68  		usesStringer(myD)
    69  	}
    70  	fmt.Println(tt.(MyStringer).String())
    71  	cType := reflect.TypeOf((*MyStringer)(nil)).Elem()
    72  	dType := reflect.TypeOf(time.Nanosecond)
    73  	fmt.Println(cType.IsImplementedBy(dType))
    74  
    75  	tt = 42
    76  	bar, ok := tt.(MyStringer)
    77  	if !ok {
    78  		fmt.Println("42 does not implement MyStringer")
    79  	} else {
    80  		fmt.Println("42 implements MyStringer")
    81  	}
    82  	_ = bar
    83  
    84  }
    85  
    86  // Output:
    87  // TestStruct implements MyWriter
    88  // 11
    89  // 11
    90  // true
    91  // 42 does not implement MyWriter
    92  // time.Nanosecond implements MyStringer
    93  // 1ns
    94  // 1ns
    95  // true
    96  // 42 does not implement MyStringer