github.com/bobyang007/helper@v1.1.3/reflecth/op-unary_test.go (about)

     1  package reflecth
     2  
     3  import (
     4  	"github.com/bobyang007/helper/mathh"
     5  	"go/token"
     6  	"reflect"
     7  	"testing"
     8  )
     9  
    10  func TestUnaryOp(t *testing.T) {
    11  	type testElement struct {
    12  		op  token.Token
    13  		y   interface{}
    14  		r   interface{}
    15  		err bool
    16  	}
    17  
    18  	tests := []testElement{
    19  		{token.SUB, 1, -1, false},
    20  		{token.SUB, mathh.MinInt, mathh.MinInt, false}, // specific behaviour for MinInt
    21  		{token.SUB, float32(1), float32(-1), false},
    22  		{token.SUB, complex64(1 - 2i), complex64(-1 + 2i), false},
    23  		{token.SUB, "1", nil, true},
    24  		{token.XOR, int(-85), ^int(-85), false},
    25  		{token.XOR, int8(-85), ^int8(-85), false},
    26  		{token.XOR, int16(-85), ^int16(-85), false},
    27  		{token.XOR, int32(-85), ^int32(-85), false},
    28  		{token.XOR, int64(85), ^int64(85), false},
    29  		{token.XOR, uint(85), ^uint(85), false},
    30  		{token.XOR, uint8(85), ^uint8(85), false},
    31  		{token.XOR, uint16(85), ^uint16(85), false},
    32  		{token.XOR, uint32(85), ^uint32(85), false},
    33  		{token.XOR, uint64(85), ^uint64(85), false},
    34  		{token.XOR, float32(-85), nil, true},
    35  		{token.NOT, true, false, false},
    36  		{token.NOT, "1", nil, true},
    37  		{token.ADD, int8(-85), int8(-85), false},
    38  		{token.ADD, float32(85), float32(85), false},
    39  		{token.ADD, complex128(1.2 - 3.4i), complex128(1.2 - 3.4i), false},
    40  		{token.ADD, "-85", nil, true},
    41  		// Negative
    42  		{token.EQL, 1, nil, true},
    43  	}
    44  
    45  	for _, test := range tests {
    46  		r, err := UnaryOp(test.op, reflect.ValueOf(test.y))
    47  		if err != nil != test.err || (!test.err && (r.Interface() != test.r)) {
    48  			t.Errorf("%v %v: expect %v %v, got %v %v", test.op, test.y, test.r, test.err, r, err)
    49  		}
    50  	}
    51  }
    52  
    53  func TestUnaryOpAnd(t *testing.T) {
    54  	var a = 43
    55  
    56  	// addressable argument
    57  	r, err := UnaryOp(token.AND, reflect.ValueOf(&a).Elem())
    58  	if err != nil || r.Interface() != &a {
    59  		t.Error("error")
    60  	}
    61  
    62  	// not addressable argument
    63  	r, err = UnaryOp(token.AND, reflect.ValueOf(a))
    64  	if err != nil || *(r.Interface().(*int)) != a {
    65  		t.Error("error")
    66  	}
    67  }
    68  
    69  func TestUnaryOpArrow(t *testing.T) {
    70  	a := make(chan int, 10)
    71  	a <- 4
    72  	a <- 5
    73  	a <- 6
    74  	a <- 7
    75  
    76  	r, err := UnaryOp(token.ARROW, reflect.ValueOf(a))
    77  	if err != nil || r.Interface() != 4 {
    78  		t.Error("error")
    79  	}
    80  
    81  	r, err = UnaryOp(token.ARROW, reflect.ValueOf((<-chan int)(a)))
    82  	if err != nil || r.Interface() != 5 {
    83  		t.Error("error")
    84  	}
    85  
    86  	r, err = UnaryOp(token.ARROW, reflect.ValueOf((chan<- int)(a)))
    87  	if err == nil {
    88  		t.Error("error expected")
    89  	}
    90  
    91  	r, err = UnaryOp(token.ARROW, reflect.ValueOf(1))
    92  	if err == nil {
    93  		t.Error("error expected")
    94  	}
    95  }