go-hep.org/x/hep@v0.38.1/groot/rtree/rfunc/rfunc_f64_gen_test.go (about)

     1  // Copyright ©2020 The go-hep Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Automatically generated. DO NOT EDIT.
     6  
     7  package rfunc
     8  
     9  import (
    10  	"reflect"
    11  	"testing"
    12  )
    13  
    14  func TestFuncI32ToF64(t *testing.T) {
    15  
    16  	rvars := make([]string, 1)
    17  	rvars[0] = "name-0"
    18  
    19  	fct := func(arg00 int32) float64 {
    20  		return 42
    21  	}
    22  
    23  	form := NewFuncI32ToF64(rvars, fct)
    24  
    25  	if got, want := form.RVars(), rvars; !reflect.DeepEqual(got, want) {
    26  		t.Fatalf("invalid rvars: got=%#v, want=%#v", got, want)
    27  	}
    28  
    29  	ptrs := make([]any, 1)
    30  	ptrs[0] = new(int32)
    31  
    32  	{
    33  		bad := make([]any, len(ptrs))
    34  		copy(bad, ptrs)
    35  		for i := len(ptrs) - 1; i >= 0; i-- {
    36  			bad[i] = any(nil)
    37  			err := form.Bind(bad)
    38  			if err == nil {
    39  				t.Fatalf("expected an error for empty iface")
    40  			}
    41  		}
    42  		bad = append(bad, any(nil))
    43  		err := form.Bind(bad)
    44  		if err == nil {
    45  			t.Fatalf("expected an error for invalid args length")
    46  		}
    47  	}
    48  
    49  	err := form.Bind(ptrs)
    50  	if err != nil {
    51  		t.Fatalf("could not bind formula: %+v", err)
    52  	}
    53  
    54  	got := form.Func().(func() float64)()
    55  	if got, want := got, float64(42); !reflect.DeepEqual(got, want) {
    56  		t.Fatalf("invalid output:\ngot= %v (%T)\nwant=%v (%T)", got, got, want, want)
    57  	}
    58  }
    59  
    60  func TestFuncF32ToF64(t *testing.T) {
    61  
    62  	rvars := make([]string, 1)
    63  	rvars[0] = "name-0"
    64  
    65  	fct := func(arg00 float32) float64 {
    66  		return 42
    67  	}
    68  
    69  	form := NewFuncF32ToF64(rvars, fct)
    70  
    71  	if got, want := form.RVars(), rvars; !reflect.DeepEqual(got, want) {
    72  		t.Fatalf("invalid rvars: got=%#v, want=%#v", got, want)
    73  	}
    74  
    75  	ptrs := make([]any, 1)
    76  	ptrs[0] = new(float32)
    77  
    78  	{
    79  		bad := make([]any, len(ptrs))
    80  		copy(bad, ptrs)
    81  		for i := len(ptrs) - 1; i >= 0; i-- {
    82  			bad[i] = any(nil)
    83  			err := form.Bind(bad)
    84  			if err == nil {
    85  				t.Fatalf("expected an error for empty iface")
    86  			}
    87  		}
    88  		bad = append(bad, any(nil))
    89  		err := form.Bind(bad)
    90  		if err == nil {
    91  			t.Fatalf("expected an error for invalid args length")
    92  		}
    93  	}
    94  
    95  	err := form.Bind(ptrs)
    96  	if err != nil {
    97  		t.Fatalf("could not bind formula: %+v", err)
    98  	}
    99  
   100  	got := form.Func().(func() float64)()
   101  	if got, want := got, float64(42); !reflect.DeepEqual(got, want) {
   102  		t.Fatalf("invalid output:\ngot= %v (%T)\nwant=%v (%T)", got, got, want, want)
   103  	}
   104  }
   105  
   106  func TestFuncToF64(t *testing.T) {
   107  
   108  	var rvars []string
   109  
   110  	fct := func() float64 {
   111  		return 42
   112  	}
   113  
   114  	form := NewFuncToF64(rvars, fct)
   115  
   116  	if got, want := form.RVars(), rvars; !reflect.DeepEqual(got, want) {
   117  		t.Fatalf("invalid rvars: got=%#v, want=%#v", got, want)
   118  	}
   119  
   120  	var ptrs []any
   121  
   122  	{
   123  		bad := make([]any, 1)
   124  		err := form.Bind(bad)
   125  		if err == nil {
   126  			t.Fatalf("expected an error for invalid args length")
   127  		}
   128  	}
   129  
   130  	err := form.Bind(ptrs)
   131  	if err != nil {
   132  		t.Fatalf("could not bind formula: %+v", err)
   133  	}
   134  
   135  	got := form.Func().(func() float64)()
   136  	if got, want := got, float64(42); !reflect.DeepEqual(got, want) {
   137  		t.Fatalf("invalid output:\ngot= %v (%T)\nwant=%v (%T)", got, got, want, want)
   138  	}
   139  }
   140  
   141  func TestFuncF64ToF64(t *testing.T) {
   142  
   143  	rvars := make([]string, 1)
   144  	rvars[0] = "name-0"
   145  
   146  	fct := func(arg00 float64) float64 {
   147  		return 42
   148  	}
   149  
   150  	form := NewFuncF64ToF64(rvars, fct)
   151  
   152  	if got, want := form.RVars(), rvars; !reflect.DeepEqual(got, want) {
   153  		t.Fatalf("invalid rvars: got=%#v, want=%#v", got, want)
   154  	}
   155  
   156  	ptrs := make([]any, 1)
   157  	ptrs[0] = new(float64)
   158  
   159  	{
   160  		bad := make([]any, len(ptrs))
   161  		copy(bad, ptrs)
   162  		for i := len(ptrs) - 1; i >= 0; i-- {
   163  			bad[i] = any(nil)
   164  			err := form.Bind(bad)
   165  			if err == nil {
   166  				t.Fatalf("expected an error for empty iface")
   167  			}
   168  		}
   169  		bad = append(bad, any(nil))
   170  		err := form.Bind(bad)
   171  		if err == nil {
   172  			t.Fatalf("expected an error for invalid args length")
   173  		}
   174  	}
   175  
   176  	err := form.Bind(ptrs)
   177  	if err != nil {
   178  		t.Fatalf("could not bind formula: %+v", err)
   179  	}
   180  
   181  	got := form.Func().(func() float64)()
   182  	if got, want := got, float64(42); !reflect.DeepEqual(got, want) {
   183  		t.Fatalf("invalid output:\ngot= %v (%T)\nwant=%v (%T)", got, got, want, want)
   184  	}
   185  }
   186  
   187  func TestFuncF64F64ToF64(t *testing.T) {
   188  
   189  	rvars := make([]string, 2)
   190  	rvars[0] = "name-0"
   191  	rvars[1] = "name-1"
   192  
   193  	fct := func(arg00 float64, arg01 float64) float64 {
   194  		return 42
   195  	}
   196  
   197  	form := NewFuncF64F64ToF64(rvars, fct)
   198  
   199  	if got, want := form.RVars(), rvars; !reflect.DeepEqual(got, want) {
   200  		t.Fatalf("invalid rvars: got=%#v, want=%#v", got, want)
   201  	}
   202  
   203  	ptrs := make([]any, 2)
   204  	ptrs[0] = new(float64)
   205  	ptrs[1] = new(float64)
   206  
   207  	{
   208  		bad := make([]any, len(ptrs))
   209  		copy(bad, ptrs)
   210  		for i := len(ptrs) - 1; i >= 0; i-- {
   211  			bad[i] = any(nil)
   212  			err := form.Bind(bad)
   213  			if err == nil {
   214  				t.Fatalf("expected an error for empty iface")
   215  			}
   216  		}
   217  		bad = append(bad, any(nil))
   218  		err := form.Bind(bad)
   219  		if err == nil {
   220  			t.Fatalf("expected an error for invalid args length")
   221  		}
   222  	}
   223  
   224  	err := form.Bind(ptrs)
   225  	if err != nil {
   226  		t.Fatalf("could not bind formula: %+v", err)
   227  	}
   228  
   229  	got := form.Func().(func() float64)()
   230  	if got, want := got, float64(42); !reflect.DeepEqual(got, want) {
   231  		t.Fatalf("invalid output:\ngot= %v (%T)\nwant=%v (%T)", got, got, want, want)
   232  	}
   233  }
   234  
   235  func TestFuncF64F64F64ToF64(t *testing.T) {
   236  
   237  	rvars := make([]string, 3)
   238  	rvars[0] = "name-0"
   239  	rvars[1] = "name-1"
   240  	rvars[2] = "name-2"
   241  
   242  	fct := func(arg00 float64, arg01 float64, arg02 float64) float64 {
   243  		return 42
   244  	}
   245  
   246  	form := NewFuncF64F64F64ToF64(rvars, fct)
   247  
   248  	if got, want := form.RVars(), rvars; !reflect.DeepEqual(got, want) {
   249  		t.Fatalf("invalid rvars: got=%#v, want=%#v", got, want)
   250  	}
   251  
   252  	ptrs := make([]any, 3)
   253  	ptrs[0] = new(float64)
   254  	ptrs[1] = new(float64)
   255  	ptrs[2] = new(float64)
   256  
   257  	{
   258  		bad := make([]any, len(ptrs))
   259  		copy(bad, ptrs)
   260  		for i := len(ptrs) - 1; i >= 0; i-- {
   261  			bad[i] = any(nil)
   262  			err := form.Bind(bad)
   263  			if err == nil {
   264  				t.Fatalf("expected an error for empty iface")
   265  			}
   266  		}
   267  		bad = append(bad, any(nil))
   268  		err := form.Bind(bad)
   269  		if err == nil {
   270  			t.Fatalf("expected an error for invalid args length")
   271  		}
   272  	}
   273  
   274  	err := form.Bind(ptrs)
   275  	if err != nil {
   276  		t.Fatalf("could not bind formula: %+v", err)
   277  	}
   278  
   279  	got := form.Func().(func() float64)()
   280  	if got, want := got, float64(42); !reflect.DeepEqual(got, want) {
   281  		t.Fatalf("invalid output:\ngot= %v (%T)\nwant=%v (%T)", got, got, want, want)
   282  	}
   283  }