go-hep.org/x/hep@v0.40.0/groot/rdict/type_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  package rdict_test
     6  
     7  import (
     8  	"reflect"
     9  	"testing"
    10  
    11  	"go-hep.org/x/hep/groot/rbase"
    12  	"go-hep.org/x/hep/groot/rbytes"
    13  	"go-hep.org/x/hep/groot/rcont"
    14  	"go-hep.org/x/hep/groot/rdict"
    15  	"go-hep.org/x/hep/groot/rmeta"
    16  	"go-hep.org/x/hep/groot/root"
    17  	"go-hep.org/x/hep/groot/rtypes"
    18  	"go-hep.org/x/hep/groot/rvers"
    19  )
    20  
    21  func TestTypeFromSI(t *testing.T) {
    22  	rdict.StreamerInfos.Add(rdict.NewCxxStreamerInfo("TypeFromSI_Pos1", 1, 0, []rbytes.StreamerElement{
    23  		&rdict.StreamerBasicType{
    24  			StreamerElement: rdict.Element{
    25  				Name:   *rbase.NewNamed("px", ""),
    26  				Type:   rmeta.Float32,
    27  				Size:   4,
    28  				MaxIdx: [5]int32{0, 0, 0, 0, 0},
    29  				EName:  "float32",
    30  			}.New(),
    31  		},
    32  		&rdict.StreamerBasicType{
    33  			StreamerElement: rdict.Element{
    34  				Name:   *rbase.NewNamed("py", ""),
    35  				Type:   rmeta.Float64,
    36  				Size:   8,
    37  				MaxIdx: [5]int32{0, 0, 0, 0, 0},
    38  				EName:  "float64",
    39  			}.New(),
    40  		},
    41  	}))
    42  
    43  	rdict.StreamerInfos.Add(rdict.NewCxxStreamerInfo("TypeFromSI_Pos2", 1, 0, []rbytes.StreamerElement{
    44  		&rdict.StreamerBasicType{
    45  			StreamerElement: rdict.Element{
    46  				Name:   *rbase.NewNamed("px", ""),
    47  				Type:   rmeta.Float32,
    48  				Size:   4,
    49  				MaxIdx: [5]int32{0, 0, 0, 0, 0},
    50  				EName:  "float32",
    51  			}.New(),
    52  		},
    53  		&rdict.StreamerBasicType{
    54  			StreamerElement: rdict.Element{
    55  				Name:   *rbase.NewNamed("py", ""),
    56  				Type:   rmeta.Float64,
    57  				Size:   8,
    58  				MaxIdx: [5]int32{0, 0, 0, 0, 0},
    59  				EName:  "float64",
    60  			}.New(),
    61  		},
    62  	}))
    63  	type TypeFromSI_Pos2 struct {
    64  		Px float32 `groot:"px"`
    65  		Py float64 `groot:"py"`
    66  	}
    67  	rtypes.Factory.Add("TypeFromSI_Pos2", func() reflect.Value {
    68  		return reflect.ValueOf(&TypeFromSI_Pos2{})
    69  	})
    70  
    71  	for _, tc := range []struct {
    72  		name string
    73  		si   rbytes.StreamerInfo
    74  		want reflect.Type
    75  	}{
    76  		{
    77  			name: "TObject",
    78  			si: func() rbytes.StreamerInfo {
    79  				const name = "TObject"
    80  				si, ok := rdict.StreamerInfos.Get(name, -1)
    81  				if !ok {
    82  					t.Fatalf("could not load streamer for %q", name)
    83  				}
    84  				return si
    85  			}(),
    86  			want: reflect.TypeFor[rbase.Object](),
    87  		},
    88  		{
    89  			name: "TString",
    90  			si: func() rbytes.StreamerInfo {
    91  				const name = "TString"
    92  				si, ok := rdict.StreamerInfos.Get(name, -1)
    93  				if !ok {
    94  					t.Fatalf("could not load streamer for %q", name)
    95  				}
    96  				return si
    97  			}(),
    98  			want: reflect.TypeFor[string](),
    99  		},
   100  		{
   101  			name: "TNamed",
   102  			si: func() rbytes.StreamerInfo {
   103  				const name = "TNamed"
   104  				si, ok := rdict.StreamerInfos.Get(name, -1)
   105  				if !ok {
   106  					t.Fatalf("could not load streamer for %q", name)
   107  				}
   108  				return si
   109  			}(),
   110  			want: reflect.TypeFor[rbase.Named](),
   111  		},
   112  		{
   113  			name: "TObjString",
   114  			si: func() rbytes.StreamerInfo {
   115  				const name = "TObjString"
   116  				si, ok := rdict.StreamerInfos.Get(name, -1)
   117  				if !ok {
   118  					t.Fatalf("could not load streamer for %q", name)
   119  				}
   120  				return si
   121  			}(),
   122  			want: reflect.TypeFor[rbase.ObjString](),
   123  		},
   124  		{
   125  			name: "TObjArray",
   126  			si: func() rbytes.StreamerInfo {
   127  				const name = "TObjArray"
   128  				si, ok := rdict.StreamerInfos.Get(name, -1)
   129  				if !ok {
   130  					t.Fatalf("could not load streamer for %q", name)
   131  				}
   132  				return si
   133  			}(),
   134  			want: reflect.TypeFor[rcont.ObjArray](),
   135  		},
   136  		{
   137  			name: "TArrayD",
   138  			si: func() rbytes.StreamerInfo {
   139  				const name = "TArrayD"
   140  				si, ok := rdict.StreamerInfos.Get(name, -1)
   141  				if !ok {
   142  					t.Fatalf("could not load streamer for %q", name)
   143  				}
   144  				return si
   145  			}(),
   146  			want: reflect.TypeFor[rcont.ArrayD](),
   147  		},
   148  		{
   149  			name: "MyArrayD",
   150  			si: rdict.NewCxxStreamerInfo("MyArrayD", 1, 0, []rbytes.StreamerElement{
   151  				&rdict.StreamerSTLstring{
   152  					StreamerSTL: *rdict.NewCxxStreamerSTL(
   153  						rdict.Element{
   154  							Name:  *rbase.NewNamed("Name", ""),
   155  							Type:  rmeta.Streamer,
   156  							Size:  32,
   157  							EName: "string",
   158  						}.New(),
   159  						rmeta.ESTLType(rmeta.STLstring),
   160  						rmeta.STLstring,
   161  					),
   162  				},
   163  				&rdict.StreamerObject{
   164  					StreamerElement: rdict.Element{
   165  						Name:  *rbase.NewNamed("Array", ""),
   166  						Type:  rmeta.Object,
   167  						Size:  40,
   168  						EName: "TArrayD",
   169  					}.New(),
   170  				},
   171  			}),
   172  			want: func() reflect.Type {
   173  				return reflect.TypeFor[struct {
   174  					ROOT_Name  string       `groot:"Name"`
   175  					ROOT_Array rcont.ArrayD `groot:"Array"`
   176  				}]()
   177  			}(),
   178  		},
   179  		{
   180  			name: "string-old-streamer-v2",
   181  			si:   rdict.NewCxxStreamerInfo("string", 2, 0, nil),
   182  			want: reflect.TypeFor[string](),
   183  		},
   184  		{
   185  			name: "vector<double>-old-streamer-v6",
   186  			si: rdict.NewCxxStreamerInfo("vector<double>", 6, 0, []rbytes.StreamerElement{
   187  				rdict.NewCxxStreamerSTL(rdict.Element{
   188  					Name:  *rbase.NewNamed("vector<double>", ""),
   189  					Type:  rmeta.Streamer,
   190  					Size:  24,
   191  					EName: "vector<double>",
   192  				}.New(), rmeta.STLvector, rmeta.Float64),
   193  			}),
   194  			want: reflect.TypeFor[[]float64](),
   195  		},
   196  		{
   197  			name: "pair<int,float>",
   198  			si: rdict.NewCxxStreamerInfo("pair<int,float>", 1, 0, []rbytes.StreamerElement{
   199  				&rdict.StreamerBasicType{
   200  					StreamerElement: rdict.Element{
   201  						Name:  *rbase.NewNamed("first", ""),
   202  						Type:  rmeta.Int32,
   203  						EName: "int32_t",
   204  					}.New(),
   205  				},
   206  				&rdict.StreamerBasicType{
   207  					StreamerElement: rdict.Element{
   208  						Name:  *rbase.NewNamed("second", ""),
   209  						Type:  rmeta.Float32,
   210  						EName: "float32_t",
   211  					}.New(),
   212  				},
   213  			}),
   214  			want: reflect.TypeFor[struct {
   215  				ROOT_first  int32   `groot:"first"`
   216  				ROOT_second float32 `groot:"second"`
   217  			}](),
   218  		},
   219  		{
   220  			name: "vector<int>",
   221  			si: rdict.NewCxxStreamerInfo("vector<int>", 1, 0, []rbytes.StreamerElement{
   222  				rdict.NewCxxStreamerSTL(rdict.Element{
   223  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   224  					Type:  rmeta.Streamer,
   225  					Size:  48,
   226  					EName: "vector<int>",
   227  				}.New(), rmeta.STLvector, rmeta.Object),
   228  			}),
   229  			want: reflect.TypeFor[[]int32](),
   230  		},
   231  		{
   232  			name: "list<int>",
   233  			si: rdict.NewCxxStreamerInfo("list<int>", 1, 0, []rbytes.StreamerElement{
   234  				rdict.NewCxxStreamerSTL(rdict.Element{
   235  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   236  					Type:  rmeta.Streamer,
   237  					Size:  48,
   238  					EName: "list<int>",
   239  				}.New(), rmeta.STLlist, rmeta.Object),
   240  			}),
   241  			want: reflect.TypeFor[[]int32](),
   242  		},
   243  		{
   244  			name: "deque<int>",
   245  			si: rdict.NewCxxStreamerInfo("deque<int>", 1, 0, []rbytes.StreamerElement{
   246  				rdict.NewCxxStreamerSTL(rdict.Element{
   247  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   248  					Type:  rmeta.Streamer,
   249  					Size:  48,
   250  					EName: "deque<int>",
   251  				}.New(), rmeta.STLdeque, rmeta.Object),
   252  			}),
   253  			want: reflect.TypeFor[[]int32](),
   254  		},
   255  		{
   256  			name: "set<int>",
   257  			si: rdict.NewCxxStreamerInfo("set<int>", 1, 0, []rbytes.StreamerElement{
   258  				rdict.NewCxxStreamerSTL(rdict.Element{
   259  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   260  					Type:  rmeta.Streamer,
   261  					Size:  48,
   262  					EName: "set<int>",
   263  				}.New(), rmeta.STLset, rmeta.Object),
   264  			}),
   265  			want: reflect.TypeFor[[]int32](),
   266  		},
   267  		{
   268  			name: "multiset<int>",
   269  			si: rdict.NewCxxStreamerInfo("multiset<int>", 1, 0, []rbytes.StreamerElement{
   270  				rdict.NewCxxStreamerSTL(rdict.Element{
   271  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   272  					Type:  rmeta.Streamer,
   273  					Size:  48,
   274  					EName: "set<int>",
   275  				}.New(), rmeta.STLmultiset, rmeta.Object),
   276  			}),
   277  			want: reflect.TypeFor[[]int32](),
   278  		},
   279  		{
   280  			name: "unordered_set<int>",
   281  			si: rdict.NewCxxStreamerInfo("unordered_set<int>", 1, 0, []rbytes.StreamerElement{
   282  				rdict.NewCxxStreamerSTL(rdict.Element{
   283  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   284  					Type:  rmeta.Streamer,
   285  					Size:  48,
   286  					EName: "unordered_set<int>",
   287  				}.New(), rmeta.STLunorderedset, rmeta.Object),
   288  			}),
   289  			want: reflect.TypeFor[[]int32](),
   290  		},
   291  		{
   292  			name: "unordered_multiset<int>",
   293  			si: rdict.NewCxxStreamerInfo("unordered_multiset<int>", 1, 0, []rbytes.StreamerElement{
   294  				rdict.NewCxxStreamerSTL(rdict.Element{
   295  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   296  					Type:  rmeta.Streamer,
   297  					Size:  48,
   298  					EName: "unordered_multiset<int>",
   299  				}.New(), rmeta.STLunorderedmultiset, rmeta.Object),
   300  			}),
   301  			want: reflect.TypeFor[[]int32](),
   302  		},
   303  		{
   304  			name: "map<int,float>",
   305  			si: rdict.NewCxxStreamerInfo("map<int,float>", 1, 0, []rbytes.StreamerElement{
   306  				rdict.NewCxxStreamerSTL(rdict.Element{
   307  					Name:  *rbase.NewNamed("This", "<pair<int,float>> Used to call the proper TStreamerInfo case"),
   308  					Type:  rmeta.Streamer,
   309  					Size:  48,
   310  					EName: "map<int,float>",
   311  				}.New(), rmeta.STLmap, rmeta.Object),
   312  			}),
   313  			want: reflect.TypeFor[map[int32]float32](),
   314  		},
   315  		{
   316  			name: "multimap<int,float>",
   317  			si: rdict.NewCxxStreamerInfo("multimap<int,float>", 1, 0, []rbytes.StreamerElement{
   318  				rdict.NewCxxStreamerSTL(rdict.Element{
   319  					Name:  *rbase.NewNamed("This", "<pair<int,float>> Used to call the proper TStreamerInfo case"),
   320  					Type:  rmeta.Streamer,
   321  					Size:  48,
   322  					EName: "multimap<int,float>",
   323  				}.New(), rmeta.STLmultimap, rmeta.Object),
   324  			}),
   325  			want: reflect.TypeFor[map[int32]float32](),
   326  		},
   327  		{
   328  			name: "unordered_map<int,float>",
   329  			si: rdict.NewCxxStreamerInfo("unordered_map<int,float>", 1, 0, []rbytes.StreamerElement{
   330  				rdict.NewCxxStreamerSTL(rdict.Element{
   331  					Name:  *rbase.NewNamed("This", "<pair<int,float>> Used to call the proper TStreamerInfo case"),
   332  					Type:  rmeta.Streamer,
   333  					Size:  48,
   334  					EName: "unordered_map<int,float>",
   335  				}.New(), rmeta.STLunorderedmap, rmeta.Object),
   336  			}),
   337  			want: reflect.TypeFor[map[int32]float32](),
   338  		},
   339  		{
   340  			name: "unordered_multimap<int,float>",
   341  			si: rdict.NewCxxStreamerInfo("unordered_multimap<int,float>", 1, 0, []rbytes.StreamerElement{
   342  				rdict.NewCxxStreamerSTL(rdict.Element{
   343  					Name:  *rbase.NewNamed("This", "<pair<int,float>> Used to call the proper TStreamerInfo case"),
   344  					Type:  rmeta.Streamer,
   345  					Size:  48,
   346  					EName: "unordered_multimap<int,float>",
   347  				}.New(), rmeta.STLunorderedmultimap, rmeta.Object),
   348  			}),
   349  			want: reflect.TypeFor[map[int32]float32](),
   350  		},
   351  		{
   352  			name: "map<int,string>",
   353  			si: rdict.NewCxxStreamerInfo("map<int,string>", 1, 0, []rbytes.StreamerElement{
   354  				rdict.NewCxxStreamerSTL(rdict.Element{
   355  					Name:  *rbase.NewNamed("This", "<pair<int,string>> Used to call the proper TStreamerInfo case"),
   356  					Type:  rmeta.Streamer,
   357  					Size:  48,
   358  					EName: "map<int,string>",
   359  				}.New(), rmeta.STLmap, rmeta.Object),
   360  			}),
   361  			want: reflect.TypeFor[map[int32]string](),
   362  		},
   363  		{
   364  			name: "map<int,TNamed>",
   365  			si: rdict.NewCxxStreamerInfo("map<int,TNamed>", 1, 0, []rbytes.StreamerElement{
   366  				rdict.NewCxxStreamerSTL(rdict.Element{
   367  					Name:  *rbase.NewNamed("This", "<pair<int,TNamed>> Used to call the proper TStreamerInfo case"),
   368  					Type:  rmeta.Streamer,
   369  					Size:  48,
   370  					EName: "map<int,TNamed>",
   371  				}.New(), rmeta.STLmap, rmeta.Object),
   372  			}),
   373  			want: reflect.TypeFor[map[int32]rbase.Named](),
   374  		},
   375  		{
   376  			name: "map<TNamed,int>",
   377  			si: rdict.NewCxxStreamerInfo("map<TNamed,int>", 1, 0, []rbytes.StreamerElement{
   378  				rdict.NewCxxStreamerSTL(rdict.Element{
   379  					Name:  *rbase.NewNamed("This", "<pair<TNamed,int>> Used to call the proper TStreamerInfo case"),
   380  					Type:  rmeta.Streamer,
   381  					Size:  48,
   382  					EName: "map<TNamed,int>",
   383  				}.New(), rmeta.STLmap, rmeta.Object),
   384  			}),
   385  			want: reflect.TypeFor[map[rbase.Named]int32](),
   386  		},
   387  		{
   388  			name: "map<int,vector<TNamed> >",
   389  			si: rdict.NewCxxStreamerInfo("map<int,vector<TNamed> >", 1, 0, []rbytes.StreamerElement{
   390  				rdict.NewCxxStreamerSTL(rdict.Element{
   391  					Name:  *rbase.NewNamed("This", "<pair<int,vector<TNamed> >> Used to call the proper TStreamerInfo case"),
   392  					Type:  rmeta.Streamer,
   393  					Size:  48,
   394  					EName: "map<int,vector<TNamed> >",
   395  				}.New(), rmeta.STLmap, rmeta.Object),
   396  			}),
   397  			want: reflect.TypeFor[map[int32][]rbase.Named](),
   398  		},
   399  		{
   400  			name: "map<int,vector<string> >",
   401  			si: rdict.NewCxxStreamerInfo("map<int,vector<string> >", 1, 0, []rbytes.StreamerElement{
   402  				rdict.NewCxxStreamerSTL(rdict.Element{
   403  					Name:  *rbase.NewNamed("This", "<pair<int,vector<string> >> Used to call the proper TStreamerInfo case"),
   404  					Type:  rmeta.Streamer,
   405  					Size:  48,
   406  					EName: "map<int,vector<string> >",
   407  				}.New(), rmeta.STLmap, rmeta.Object),
   408  			}),
   409  			want: reflect.TypeFor[map[int32][]string](),
   410  		},
   411  		{
   412  			name: "map<int,map<int,vector<string> > >",
   413  			si: rdict.NewCxxStreamerInfo("map<int,map<int,vector<string> > >", 1, 0, []rbytes.StreamerElement{
   414  				rdict.NewCxxStreamerSTL(rdict.Element{
   415  					Name:  *rbase.NewNamed("This", "<pair<int,map<int,vector<string> > >> Used to call the proper TStreamerInfo case"),
   416  					Type:  rmeta.Streamer,
   417  					Size:  48,
   418  					EName: "map<int,map<int,vector<string> > >",
   419  				}.New(), rmeta.STLmap, rmeta.Object),
   420  			}),
   421  			want: reflect.TypeFor[map[int32]map[int32][]string](),
   422  		},
   423  		{
   424  			name: "map<int,string>-with-pair-dict",
   425  			si: rdict.NewCxxStreamerInfo("MyEvent", 1, 0, []rbytes.StreamerElement{
   426  				rdict.NewCxxStreamerSTL(rdict.Element{
   427  					Name:  *rbase.NewNamed("mapI32Str", " (pair<int,string>)"),
   428  					Type:  rmeta.Streamer,
   429  					Size:  48,
   430  					EName: "map<int,string>",
   431  				}.New(), rmeta.STLmap, rmeta.Object),
   432  			}),
   433  			want: reflect.TypeFor[struct {
   434  				ROOT_mapI32Str map[int32]string `groot:"mapI32Str"`
   435  			}](),
   436  		},
   437  		{
   438  			name: "vector<TObject>",
   439  			si: rdict.NewCxxStreamerInfo("vector<TObject>", rvers.StreamerBaseSTL, 0, []rbytes.StreamerElement{
   440  				rdict.NewCxxStreamerSTL(rdict.Element{
   441  					Name:  *rbase.NewNamed("vector<TObject>", ""),
   442  					Type:  rmeta.Streamer,
   443  					Size:  24,
   444  					EName: "vector<TObject>",
   445  				}.New(), rmeta.STLvector, rmeta.TObject),
   446  			}),
   447  			want: reflect.TypeFor[[]rbase.Object](),
   448  		},
   449  		{
   450  			name: "vector<TNamed>",
   451  			si: rdict.NewCxxStreamerInfo("vector<TNamed>", rvers.StreamerBaseSTL, 0, []rbytes.StreamerElement{
   452  				rdict.NewCxxStreamerSTL(rdict.Element{
   453  					Name:  *rbase.NewNamed("vector<TNamed>", ""),
   454  					Type:  rmeta.Streamer,
   455  					Size:  24,
   456  					EName: "vector<TNamed>",
   457  				}.New(), rmeta.STLvector, rmeta.TNamed),
   458  			}),
   459  			want: reflect.TypeFor[[]rbase.Named](),
   460  		},
   461  		{
   462  			name: "vector<TObjString>",
   463  			si: rdict.NewCxxStreamerInfo("vector<TObjString>", rvers.StreamerBaseSTL, 0, []rbytes.StreamerElement{
   464  				rdict.NewCxxStreamerSTL(rdict.Element{
   465  					Name:  *rbase.NewNamed("vector<TObjString>", ""),
   466  					Type:  rmeta.Streamer,
   467  					Size:  24,
   468  					EName: "vector<TObjString>",
   469  				}.New(), rmeta.STLvector, rmeta.Object),
   470  			}),
   471  			want: reflect.TypeFor[[]rbase.ObjString](),
   472  		},
   473  		{
   474  			name: "bitset<256>",
   475  			si: rdict.NewCxxStreamerInfo("MyBitset", rvers.StreamerBaseSTL, 0, []rbytes.StreamerElement{
   476  				rdict.NewCxxStreamerSTL(rdict.Element{
   477  					Name:  *rbase.NewNamed("bs", ""),
   478  					Type:  rmeta.Streamer,
   479  					Size:  24,
   480  					EName: "bitset<256>",
   481  				}.New(), rmeta.STLbitset, 0),
   482  			}),
   483  			want: reflect.TypeFor[struct {
   484  				ROOT_bs []uint8 `groot:"bs"`
   485  			}](),
   486  		},
   487  		{
   488  			name: "vector<bitset<256> >",
   489  			si: rdict.NewCxxStreamerInfo("MyBitsets", rvers.StreamerBaseSTL, 0, []rbytes.StreamerElement{
   490  				rdict.NewCxxStreamerSTL(rdict.Element{
   491  					Name:  *rbase.NewNamed("bs", ""),
   492  					Type:  rmeta.Streamer,
   493  					Size:  24,
   494  					EName: "vector<bitset<256> >",
   495  				}.New(), rmeta.STLvector, 0),
   496  			}),
   497  			want: reflect.TypeFor[struct {
   498  				ROOT_bs [][]uint8 `groot:"bs"`
   499  			}](),
   500  		},
   501  		{
   502  			name: "event",
   503  			si: rdict.NewCxxStreamerInfo("event", 1, 0, []rbytes.StreamerElement{
   504  				rdict.NewStreamerBase(
   505  					rdict.Element{
   506  						Name:  *rbase.NewNamed("TObject", ""),
   507  						Type:  rmeta.Base,
   508  						EName: "BASE",
   509  					}.New(),
   510  					rvers.Named,
   511  				),
   512  				&rdict.StreamerBasicType{
   513  					StreamerElement: rdict.Element{
   514  						Name:  *rbase.NewNamed("b", ""),
   515  						Type:  rmeta.Bool,
   516  						EName: "bool",
   517  					}.New(),
   518  				},
   519  				&rdict.StreamerBasicType{
   520  					StreamerElement: rdict.Element{
   521  						Name:  *rbase.NewNamed("i8", ""),
   522  						Type:  rmeta.Int8,
   523  						EName: "int8_t",
   524  					}.New(),
   525  				},
   526  				&rdict.StreamerBasicType{
   527  					StreamerElement: rdict.Element{
   528  						Name:  *rbase.NewNamed("i16", ""),
   529  						Type:  rmeta.Int16,
   530  						EName: "int16_t",
   531  					}.New(),
   532  				},
   533  				&rdict.StreamerBasicType{
   534  					StreamerElement: rdict.Element{
   535  						Name:  *rbase.NewNamed("i32", ""),
   536  						Type:  rmeta.Int32,
   537  						EName: "int32_t",
   538  					}.New(),
   539  				},
   540  				&rdict.StreamerBasicType{
   541  					StreamerElement: rdict.Element{
   542  						Name:  *rbase.NewNamed("i64", ""),
   543  						Type:  rmeta.Int64,
   544  						EName: "int64_t",
   545  					}.New(),
   546  				},
   547  				&rdict.StreamerBasicType{
   548  					StreamerElement: rdict.Element{
   549  						Name:  *rbase.NewNamed("u8", ""),
   550  						Type:  rmeta.Uint8,
   551  						EName: "uint8_t",
   552  					}.New(),
   553  				},
   554  				&rdict.StreamerBasicType{
   555  					StreamerElement: rdict.Element{
   556  						Name:  *rbase.NewNamed("u16", ""),
   557  						Type:  rmeta.Uint16,
   558  						EName: "uint16_t",
   559  					}.New(),
   560  				},
   561  				&rdict.StreamerBasicType{
   562  					StreamerElement: rdict.Element{
   563  						Name:  *rbase.NewNamed("u32", ""),
   564  						Type:  rmeta.Uint32,
   565  						EName: "uint32_t",
   566  					}.New(),
   567  				},
   568  				&rdict.StreamerBasicType{
   569  					StreamerElement: rdict.Element{
   570  						Name:  *rbase.NewNamed("u64", ""),
   571  						Type:  rmeta.Uint64,
   572  						EName: "uint64_t",
   573  					}.New(),
   574  				},
   575  				&rdict.StreamerBasicType{
   576  					StreamerElement: rdict.Element{
   577  						Name:  *rbase.NewNamed("N", ""),
   578  						Type:  rmeta.Counter,
   579  						Size:  4,
   580  						EName: "int32_t",
   581  					}.New(),
   582  				},
   583  				&rdict.StreamerBasicType{
   584  					StreamerElement: rdict.Element{
   585  						Name:  *rbase.NewNamed("NN", ""),
   586  						Type:  rmeta.Counter,
   587  						Size:  8,
   588  						EName: "int64_t",
   589  					}.New(),
   590  				},
   591  				&rdict.StreamerBasicType{
   592  					StreamerElement: rdict.Element{
   593  						Name:  *rbase.NewNamed("bits", ""),
   594  						Type:  rmeta.Bits,
   595  						Size:  4,
   596  						EName: "Bits_t",
   597  					}.New(),
   598  				},
   599  				&rdict.StreamerBasicType{
   600  					StreamerElement: rdict.Element{
   601  						Name:  *rbase.NewNamed("f32", ""),
   602  						Type:  rmeta.Float32,
   603  						EName: "float32_t",
   604  					}.New(),
   605  				},
   606  				&rdict.StreamerBasicType{
   607  					StreamerElement: rdict.Element{
   608  						Name:  *rbase.NewNamed("f64", ""),
   609  						Type:  rmeta.Float64,
   610  						EName: "float64_t",
   611  					}.New(),
   612  				},
   613  				&rdict.StreamerBasicType{
   614  					StreamerElement: rdict.Element{
   615  						Name:  *rbase.NewNamed("f16", ""),
   616  						Type:  rmeta.Float16,
   617  						EName: "Float16_t",
   618  					}.New(),
   619  				},
   620  				&rdict.StreamerBasicType{
   621  					StreamerElement: rdict.Element{
   622  						Name:  *rbase.NewNamed("d32", ""),
   623  						Type:  rmeta.Double32,
   624  						EName: "Double32_t",
   625  					}.New(),
   626  				},
   627  				&rdict.StreamerBasicType{
   628  					StreamerElement: rdict.Element{
   629  						Name:  *rbase.NewNamed("str", ""),
   630  						Type:  rmeta.TString,
   631  						EName: "TString",
   632  					}.New(),
   633  				},
   634  				&rdict.StreamerBasicType{
   635  					StreamerElement: rdict.Element{
   636  						Name:  *rbase.NewNamed("cstr", ""),
   637  						Type:  rmeta.CharStar,
   638  						EName: "char*",
   639  					}.New(),
   640  				},
   641  
   642  				// arrays
   643  				&rdict.StreamerBasicType{
   644  					StreamerElement: rdict.Element{
   645  						Name:   *rbase.NewNamed("arrB", ""),
   646  						Type:   rmeta.OffsetL + rmeta.Bool,
   647  						Size:   3 * 1,
   648  						ArrLen: 3,
   649  						ArrDim: 1,
   650  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   651  						EName:  "bool*",
   652  					}.New(),
   653  				},
   654  				&rdict.StreamerBasicType{
   655  					StreamerElement: rdict.Element{
   656  						Name:   *rbase.NewNamed("arrI8", ""),
   657  						Type:   rmeta.OffsetL + rmeta.Int8,
   658  						Size:   3 * 1,
   659  						ArrLen: 3,
   660  						ArrDim: 1,
   661  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   662  						EName:  "int8_t*",
   663  					}.New(),
   664  				},
   665  				&rdict.StreamerBasicType{
   666  					StreamerElement: rdict.Element{
   667  						Name:   *rbase.NewNamed("arrI16", ""),
   668  						Type:   rmeta.OffsetL + rmeta.Int16,
   669  						Size:   3 * 2,
   670  						ArrLen: 3,
   671  						ArrDim: 1,
   672  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   673  						EName:  "int16_t*",
   674  					}.New(),
   675  				},
   676  				&rdict.StreamerBasicType{
   677  					StreamerElement: rdict.Element{
   678  						Name:   *rbase.NewNamed("arrI32", ""),
   679  						Type:   rmeta.OffsetL + rmeta.Int32,
   680  						Size:   3 * 4,
   681  						ArrLen: 3,
   682  						ArrDim: 1,
   683  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   684  						EName:  "int32_t*",
   685  					}.New(),
   686  				},
   687  				&rdict.StreamerBasicType{
   688  					StreamerElement: rdict.Element{
   689  						Name:   *rbase.NewNamed("arrI64", ""),
   690  						Type:   rmeta.OffsetL + rmeta.Int64,
   691  						Size:   3 * 8,
   692  						ArrLen: 3,
   693  						ArrDim: 1,
   694  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   695  						EName:  "int64_t*",
   696  					}.New(),
   697  				},
   698  				&rdict.StreamerBasicType{
   699  					StreamerElement: rdict.Element{
   700  						Name:   *rbase.NewNamed("arrU8", ""),
   701  						Type:   rmeta.OffsetL + rmeta.Uint8,
   702  						Size:   3 * 1,
   703  						ArrLen: 3,
   704  						ArrDim: 1,
   705  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   706  						EName:  "uint8_t*",
   707  					}.New(),
   708  				},
   709  				&rdict.StreamerBasicType{
   710  					StreamerElement: rdict.Element{
   711  						Name:   *rbase.NewNamed("arrU16", ""),
   712  						Type:   rmeta.OffsetL + rmeta.Uint16,
   713  						Size:   3 * 2,
   714  						ArrLen: 3,
   715  						ArrDim: 1,
   716  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   717  						EName:  "uint16_t*",
   718  					}.New(),
   719  				},
   720  				&rdict.StreamerBasicType{
   721  					StreamerElement: rdict.Element{
   722  						Name:   *rbase.NewNamed("arrU32", ""),
   723  						Type:   rmeta.OffsetL + rmeta.Uint32,
   724  						Size:   3 * 4,
   725  						ArrLen: 3,
   726  						ArrDim: 1,
   727  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   728  						EName:  "uint32_t*",
   729  					}.New(),
   730  				},
   731  				&rdict.StreamerBasicType{
   732  					StreamerElement: rdict.Element{
   733  						Name:   *rbase.NewNamed("arrU64", ""),
   734  						Type:   rmeta.OffsetL + rmeta.Uint64,
   735  						Size:   3 * 8,
   736  						ArrLen: 3,
   737  						ArrDim: 1,
   738  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   739  						EName:  "uint64_t*",
   740  					}.New(),
   741  				},
   742  				&rdict.StreamerBasicType{
   743  					StreamerElement: rdict.Element{
   744  						Name:   *rbase.NewNamed("arrF32", ""),
   745  						Type:   rmeta.OffsetL + rmeta.Float32,
   746  						Size:   3 * 4,
   747  						ArrLen: 3,
   748  						ArrDim: 1,
   749  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   750  						EName:  "float32_t*",
   751  					}.New(),
   752  				},
   753  				&rdict.StreamerBasicType{
   754  					StreamerElement: rdict.Element{
   755  						Name:   *rbase.NewNamed("arrF64", ""),
   756  						Type:   rmeta.OffsetL + rmeta.Float64,
   757  						Size:   3 * 8,
   758  						ArrLen: 3,
   759  						ArrDim: 1,
   760  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   761  						EName:  "float64_t*",
   762  					}.New(),
   763  				},
   764  				&rdict.StreamerBasicType{
   765  					StreamerElement: rdict.Element{
   766  						Name:   *rbase.NewNamed("arrF16", ""),
   767  						Type:   rmeta.OffsetL + rmeta.Float16,
   768  						Size:   3 * 4,
   769  						ArrLen: 3,
   770  						ArrDim: 1,
   771  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   772  						EName:  "Float16_t*",
   773  					}.New(),
   774  				},
   775  				&rdict.StreamerBasicType{
   776  					StreamerElement: rdict.Element{
   777  						Name:   *rbase.NewNamed("arrD32", ""),
   778  						Type:   rmeta.OffsetL + rmeta.Double32,
   779  						Size:   3 * 4,
   780  						ArrLen: 3,
   781  						ArrDim: 1,
   782  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   783  						EName:  "Double32_t*",
   784  					}.New(),
   785  				},
   786  				&rdict.StreamerBasicType{
   787  					StreamerElement: rdict.Element{
   788  						Name:   *rbase.NewNamed("arrStr", ""),
   789  						Type:   rmeta.OffsetL + rmeta.TString,
   790  						Size:   3 * 24,
   791  						ArrLen: 3,
   792  						ArrDim: 1,
   793  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   794  						EName:  "TString*",
   795  					}.New(),
   796  				},
   797  				&rdict.StreamerBasicType{
   798  					StreamerElement: rdict.Element{
   799  						Name:   *rbase.NewNamed("arrCstr", ""),
   800  						Type:   rmeta.OffsetL + rmeta.CharStar,
   801  						Size:   3 * 8,
   802  						ArrLen: 3,
   803  						ArrDim: 1,
   804  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   805  						EName:  "char**",
   806  					}.New(),
   807  				},
   808  				//	&rdict.StreamerBasicType{
   809  				//		StreamerElement: rdict.Element{
   810  				//			Name:   *rbase.NewNamed("arrN32", ""),
   811  				//			Type:   rmeta.OffsetL + rmeta.Counter,
   812  				//			Size:   3 * 4,
   813  				//			ArrLen: 3,
   814  				//			ArrDim: 1,
   815  				//		MaxIdx: [5]int32{1, 0, 0, 0, 0},
   816  				//			EName:  "Counter_t",
   817  				//		}.New(),
   818  				//	},
   819  				//	&rdict.StreamerBasicType{
   820  				//		StreamerElement: rdict.Element{
   821  				//			Name:   *rbase.NewNamed("arrN64", ""),
   822  				//			Type:   rmeta.OffsetL + rmeta.Counter,
   823  				//			Size:   3 * 8,
   824  				//			ArrLen: 3,
   825  				//			ArrDim: 1,
   826  				//		MaxIdx: [5]int32{1, 0, 0, 0, 0},
   827  				//			EName:  "Counter_t",
   828  				//		}.New(),
   829  				//	},
   830  
   831  				&rdict.StreamerObjectPointer{
   832  					StreamerElement: rdict.Element{
   833  						Name:   *rbase.NewNamed("arrTObj", ""),
   834  						Type:   rmeta.OffsetL + rmeta.TObject,
   835  						Size:   3 * 16,
   836  						ArrLen: 3,
   837  						ArrDim: 1,
   838  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   839  						EName:  "TObject*",
   840  					}.New(),
   841  				},
   842  
   843  				//	var-len arrays
   844  				rdict.NewStreamerBasicPointer(
   845  					rdict.Element{
   846  						Name:  *rbase.NewNamed("sliB", "[N]"),
   847  						Type:  rmeta.OffsetP + rmeta.Bool,
   848  						Size:  1,
   849  						EName: "bool*",
   850  					}.New(), 1, "N", "event",
   851  				),
   852  				rdict.NewStreamerBasicPointer(
   853  					rdict.Element{
   854  						Name:  *rbase.NewNamed("sliI8", "[N]"),
   855  						Type:  rmeta.OffsetP + rmeta.Int8,
   856  						Size:  1,
   857  						EName: "int8_t*",
   858  					}.New(), 1, "N", "event",
   859  				),
   860  				rdict.NewStreamerBasicPointer(
   861  					rdict.Element{
   862  						Name:  *rbase.NewNamed("sliI16", "[N]"),
   863  						Type:  rmeta.OffsetP + rmeta.Int16,
   864  						Size:  2,
   865  						EName: "int16_t*",
   866  					}.New(), 1, "N", "event",
   867  				),
   868  				rdict.NewStreamerBasicPointer(
   869  					rdict.Element{
   870  						Name:  *rbase.NewNamed("sliI32", "[N]"),
   871  						Type:  rmeta.OffsetP + rmeta.Int32,
   872  						Size:  4,
   873  						EName: "int32_t*",
   874  					}.New(), 1, "N", "event",
   875  				),
   876  				rdict.NewStreamerBasicPointer(
   877  					rdict.Element{
   878  						Name:  *rbase.NewNamed("sliI64", "[N]"),
   879  						Type:  rmeta.OffsetP + rmeta.Int64,
   880  						Size:  8,
   881  						EName: "int64_t*",
   882  					}.New(), 1, "N", "event",
   883  				),
   884  				rdict.NewStreamerBasicPointer(
   885  					rdict.Element{
   886  						Name:  *rbase.NewNamed("sliU8", "[N]"),
   887  						Type:  rmeta.OffsetP + rmeta.Uint8,
   888  						Size:  1,
   889  						EName: "uint8_t*",
   890  					}.New(), 1, "N", "event",
   891  				),
   892  				rdict.NewStreamerBasicPointer(
   893  					rdict.Element{
   894  						Name:  *rbase.NewNamed("sliU16", "[N]"),
   895  						Type:  rmeta.OffsetP + rmeta.Uint16,
   896  						Size:  2,
   897  						EName: "uint16_t*",
   898  					}.New(), 1, "N", "event",
   899  				),
   900  				rdict.NewStreamerBasicPointer(
   901  					rdict.Element{
   902  						Name:  *rbase.NewNamed("sliU32", "[N]"),
   903  						Type:  rmeta.OffsetP + rmeta.Uint32,
   904  						Size:  4,
   905  						EName: "uint32_t*",
   906  					}.New(), 1, "N", "event",
   907  				),
   908  				rdict.NewStreamerBasicPointer(
   909  					rdict.Element{
   910  						Name:  *rbase.NewNamed("sliU64", "[N]"),
   911  						Type:  rmeta.OffsetP + rmeta.Uint64,
   912  						Size:  8,
   913  						EName: "uint64_t*",
   914  					}.New(), 1, "N", "event",
   915  				),
   916  				rdict.NewStreamerBasicPointer(
   917  					rdict.Element{
   918  						Name:  *rbase.NewNamed("sliF32", "[N]"),
   919  						Type:  rmeta.OffsetP + rmeta.Float32,
   920  						Size:  4,
   921  						EName: "float32_t*",
   922  					}.New(), 1, "N", "event",
   923  				),
   924  				rdict.NewStreamerBasicPointer(
   925  					rdict.Element{
   926  						Name:  *rbase.NewNamed("sliF64", "[N]"),
   927  						Type:  rmeta.OffsetP + rmeta.Float64,
   928  						Size:  8,
   929  						EName: "float64_t*",
   930  					}.New(), 1, "N", "event",
   931  				),
   932  				rdict.NewStreamerBasicPointer(
   933  					rdict.Element{
   934  						Name:  *rbase.NewNamed("sliF16", "[N]"),
   935  						Type:  rmeta.OffsetP + rmeta.Float16,
   936  						Size:  4,
   937  						EName: "Float16_t*",
   938  					}.New(), 1, "N", "event",
   939  				),
   940  				rdict.NewStreamerBasicPointer(
   941  					rdict.Element{
   942  						Name:  *rbase.NewNamed("sliD32", "[N]"),
   943  						Type:  rmeta.OffsetP + rmeta.Double32,
   944  						Size:  8,
   945  						EName: "Double32_t*",
   946  					}.New(), 1, "N", "event",
   947  				),
   948  				rdict.NewStreamerLoop(
   949  					rdict.Element{
   950  						Name:  *rbase.NewNamed("sliStr", "[N]"),
   951  						Size:  4,
   952  						EName: "TString*",
   953  					}.New(), 1, "N", "event",
   954  				),
   955  				rdict.NewStreamerBasicPointer(
   956  					rdict.Element{
   957  						Name:  *rbase.NewNamed("sliCstr", "[N]"),
   958  						Type:  rmeta.OffsetP + rmeta.CharStar,
   959  						Size:  1,
   960  						EName: "char**",
   961  					}.New(), 1, "N", "event",
   962  				),
   963  
   964  				// std-vector
   965  				rdict.NewCxxStreamerSTL(rdict.Element{
   966  					Name:   *rbase.NewNamed("stdVecB", ""),
   967  					Type:   rmeta.Streamer,
   968  					Size:   24,
   969  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
   970  					EName:  "vector<bool>",
   971  				}.New(), rmeta.STLvector, rmeta.Bool),
   972  				rdict.NewCxxStreamerSTL(rdict.Element{
   973  					Name:   *rbase.NewNamed("stdVecI8", ""),
   974  					Type:   rmeta.Streamer,
   975  					Size:   24,
   976  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
   977  					EName:  "vector<int8_t>",
   978  				}.New(), rmeta.STLvector, rmeta.Int8),
   979  				rdict.NewCxxStreamerSTL(rdict.Element{
   980  					Name:   *rbase.NewNamed("stdVecI16", ""),
   981  					Type:   rmeta.Streamer,
   982  					Size:   24,
   983  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
   984  					EName:  "vector<int16_t>",
   985  				}.New(), rmeta.STLvector, rmeta.Int16),
   986  				rdict.NewCxxStreamerSTL(rdict.Element{
   987  					Name:   *rbase.NewNamed("stdVecI32", ""),
   988  					Type:   rmeta.Streamer,
   989  					Size:   24,
   990  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
   991  					EName:  "vector<int32_t>",
   992  				}.New(), rmeta.STLvector, rmeta.Int32),
   993  				rdict.NewCxxStreamerSTL(rdict.Element{
   994  					Name:   *rbase.NewNamed("stdVecI64", ""),
   995  					Type:   rmeta.Streamer,
   996  					Size:   24,
   997  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
   998  					EName:  "vector<int64_t>",
   999  				}.New(), rmeta.STLvector, rmeta.Int64),
  1000  				rdict.NewCxxStreamerSTL(rdict.Element{
  1001  					Name:   *rbase.NewNamed("stdVecU8", ""),
  1002  					Type:   rmeta.Streamer,
  1003  					Size:   24,
  1004  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1005  					EName:  "vector<uint8_t>",
  1006  				}.New(), rmeta.STLvector, rmeta.Uint8),
  1007  				rdict.NewCxxStreamerSTL(rdict.Element{
  1008  					Name:   *rbase.NewNamed("stdVecU16", ""),
  1009  					Type:   rmeta.Streamer,
  1010  					Size:   24,
  1011  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1012  					EName:  "vector<uint16_t>",
  1013  				}.New(), rmeta.STLvector, rmeta.Uint16),
  1014  				rdict.NewCxxStreamerSTL(rdict.Element{
  1015  					Name:   *rbase.NewNamed("stdVecU32", ""),
  1016  					Type:   rmeta.Streamer,
  1017  					Size:   24,
  1018  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1019  					EName:  "vector<uint32_t>",
  1020  				}.New(), rmeta.STLvector, rmeta.Uint32),
  1021  				rdict.NewCxxStreamerSTL(rdict.Element{
  1022  					Name:   *rbase.NewNamed("stdVecU64", ""),
  1023  					Type:   rmeta.Streamer,
  1024  					Size:   24,
  1025  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1026  					EName:  "vector<uint64_t>",
  1027  				}.New(), rmeta.STLvector, rmeta.Uint64),
  1028  				rdict.NewCxxStreamerSTL(rdict.Element{
  1029  					Name:   *rbase.NewNamed("stdVecF32", ""),
  1030  					Type:   rmeta.Streamer,
  1031  					Size:   24,
  1032  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1033  					EName:  "vector<float32_t>",
  1034  				}.New(), rmeta.STLvector, rmeta.Float32),
  1035  				rdict.NewCxxStreamerSTL(rdict.Element{
  1036  					Name:   *rbase.NewNamed("stdVecF64", ""),
  1037  					Type:   rmeta.Streamer,
  1038  					Size:   24,
  1039  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1040  					EName:  "vector<float64_t>",
  1041  				}.New(), rmeta.STLvector, rmeta.Float64),
  1042  				rdict.NewCxxStreamerSTL(rdict.Element{
  1043  					Name:   *rbase.NewNamed("stdVecF16", ""),
  1044  					Type:   rmeta.Streamer,
  1045  					Size:   24,
  1046  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1047  					EName:  "vector<Float16_t>",
  1048  				}.New(), rmeta.STLvector, rmeta.Float16),
  1049  				rdict.NewCxxStreamerSTL(rdict.Element{
  1050  					Name:   *rbase.NewNamed("stdVecD32", ""),
  1051  					Type:   rmeta.Streamer,
  1052  					Size:   24,
  1053  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1054  					EName:  "vector<Double32_t>",
  1055  				}.New(), rmeta.STLvector, rmeta.Double32),
  1056  				rdict.NewCxxStreamerSTL(rdict.Element{
  1057  					Name:   *rbase.NewNamed("stdVecStr", ""),
  1058  					Type:   rmeta.Streamer,
  1059  					Size:   24,
  1060  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1061  					EName:  "vector<string>",
  1062  				}.New(), rmeta.STLvector, rmeta.STLstring),
  1063  				rdict.NewCxxStreamerSTL(rdict.Element{
  1064  					Name:   *rbase.NewNamed("stdVecCstr", ""),
  1065  					Type:   rmeta.Streamer,
  1066  					Size:   24,
  1067  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1068  					EName:  "vector<char*>",
  1069  				}.New(), rmeta.STLvector, rmeta.CharStar),
  1070  				rdict.NewCxxStreamerSTL(rdict.Element{
  1071  					Name:   *rbase.NewNamed("stdVecNamed1", ""),
  1072  					Type:   rmeta.Streamer,
  1073  					Size:   24,
  1074  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1075  					EName:  "vector<TNamed>",
  1076  				}.New(), rmeta.STLvector, rmeta.Object),
  1077  				rdict.NewCxxStreamerSTL(rdict.Element{
  1078  					Name:   *rbase.NewNamed("stdVecNamed2", ""),
  1079  					Type:   rmeta.Streamer,
  1080  					Size:   24,
  1081  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1082  					EName:  "vector<TNamed>",
  1083  				}.New(), rmeta.STLvector, rmeta.TNamed),
  1084  
  1085  				// obj-ptr
  1086  				&rdict.StreamerObjectPointer{
  1087  					StreamerElement: rdict.Element{
  1088  						Name:  *rbase.NewNamed("ptrObj", ""),
  1089  						Type:  rmeta.ObjectP,
  1090  						Size:  8,
  1091  						EName: "TObject*",
  1092  					}.New(),
  1093  				},
  1094  				&rdict.StreamerObjectAnyPointer{
  1095  					StreamerElement: rdict.Element{
  1096  						Name:  *rbase.NewNamed("ptrPos1", ""),
  1097  						Type:  rmeta.AnyP,
  1098  						Size:  8,
  1099  						EName: "TypeFromSI_Pos1*",
  1100  					}.New(),
  1101  				},
  1102  				&rdict.StreamerObjectAnyPointer{
  1103  					StreamerElement: rdict.Element{
  1104  						Name:  *rbase.NewNamed("ptrPos2", ""),
  1105  						Type:  rmeta.AnyP,
  1106  						Size:  8,
  1107  						EName: "TypeFromSI_Pos2*",
  1108  					}.New(),
  1109  				},
  1110  				&rdict.StreamerObjectAnyPointer{
  1111  					StreamerElement: rdict.Element{
  1112  						Name:  *rbase.NewNamed("ptrArrF", ""),
  1113  						Type:  rmeta.AnyP,
  1114  						Size:  8,
  1115  						EName: "TArrayF*",
  1116  					}.New(),
  1117  				},
  1118  			}),
  1119  			want: reflect.TypeFor[struct {
  1120  				ROOT_TObject      rbase.Object     `groot:"TObject"`
  1121  				ROOT_b            bool             `groot:"b"`
  1122  				ROOT_i8           int8             `groot:"i8"`
  1123  				ROOT_i16          int16            `groot:"i16"`
  1124  				ROOT_i32          int32            `groot:"i32"`
  1125  				ROOT_i64          int64            `groot:"i64"`
  1126  				ROOT_u8           uint8            `groot:"u8"`
  1127  				ROOT_u16          uint16           `groot:"u16"`
  1128  				ROOT_u32          uint32           `groot:"u32"`
  1129  				ROOT_u64          uint64           `groot:"u64"`
  1130  				ROOT_N            int32            `groot:"N"`
  1131  				ROOT_NN           int64            `groot:"NN"`
  1132  				ROOT_bits         uint32           `groot:"bits"`
  1133  				ROOT_f32          float32          `groot:"f32"`
  1134  				ROOT_f64          float64          `groot:"f64"`
  1135  				ROOT_f16          root.Float16     `groot:"f16"`
  1136  				ROOT_d32          root.Double32    `groot:"d32"`
  1137  				ROOT_str          string           `groot:"str"`
  1138  				ROOT_cstr         string           `groot:"cstr"`
  1139  				ROOT_arrB         [3]bool          `groot:"arrB[3]"`
  1140  				ROOT_arrI8        [3]int8          `groot:"arrI8[3]"`
  1141  				ROOT_arrI16       [3]int16         `groot:"arrI16[3]"`
  1142  				ROOT_arrI32       [3]int32         `groot:"arrI32[3]"`
  1143  				ROOT_arrI64       [3]int64         `groot:"arrI64[3]"`
  1144  				ROOT_arrU8        [3]uint8         `groot:"arrU8[3]"`
  1145  				ROOT_arrU16       [3]uint16        `groot:"arrU16[3]"`
  1146  				ROOT_arrU32       [3]uint32        `groot:"arrU32[3]"`
  1147  				ROOT_arrU64       [3]uint64        `groot:"arrU64[3]"`
  1148  				ROOT_arrF32       [3]float32       `groot:"arrF32[3]"`
  1149  				ROOT_arrF64       [3]float64       `groot:"arrF64[3]"`
  1150  				ROOT_arrF16       [3]root.Float16  `groot:"arrF16[3]"`
  1151  				ROOT_arrD32       [3]root.Double32 `groot:"arrD32[3]"`
  1152  				ROOT_arrStr       [3]string        `groot:"arrStr[3]"`
  1153  				ROOT_arrCstr      [3]string        `groot:"arrCstr[3]"`
  1154  				ROOT_arrTObj      [3]rbase.Object  `groot:"arrTObj[3]"`
  1155  				ROOT_sliB         []bool           `groot:"sliB[N]"`
  1156  				ROOT_sliI8        []int8           `groot:"sliI8[N]"`
  1157  				ROOT_sliI16       []int16          `groot:"sliI16[N]"`
  1158  				ROOT_sliI32       []int32          `groot:"sliI32[N]"`
  1159  				ROOT_sliI64       []int64          `groot:"sliI64[N]"`
  1160  				ROOT_sliU8        []uint8          `groot:"sliU8[N]"`
  1161  				ROOT_sliU16       []uint16         `groot:"sliU16[N]"`
  1162  				ROOT_sliU32       []uint32         `groot:"sliU32[N]"`
  1163  				ROOT_sliU64       []uint64         `groot:"sliU64[N]"`
  1164  				ROOT_sliF32       []float32        `groot:"sliF32[N]"`
  1165  				ROOT_sliF64       []float64        `groot:"sliF64[N]"`
  1166  				ROOT_sliF16       []root.Float16   `groot:"sliF16[N]"`
  1167  				ROOT_sliD32       []root.Double32  `groot:"sliD32[N]"`
  1168  				ROOT_sliStr       []string         `groot:"sliStr[N]"`
  1169  				ROOT_sliCstr      []string         `groot:"sliCstr[N]"`
  1170  				ROOT_stdVecB      []bool           `groot:"stdVecB"`
  1171  				ROOT_stdVecI8     []int8           `groot:"stdVecI8"`
  1172  				ROOT_stdVecI16    []int16          `groot:"stdVecI16"`
  1173  				ROOT_stdVecI32    []int32          `groot:"stdVecI32"`
  1174  				ROOT_stdVecI64    []int64          `groot:"stdVecI64"`
  1175  				ROOT_stdVecU8     []uint8          `groot:"stdVecU8"`
  1176  				ROOT_stdVecU16    []uint16         `groot:"stdVecU16"`
  1177  				ROOT_stdVecU32    []uint32         `groot:"stdVecU32"`
  1178  				ROOT_stdVecU64    []uint64         `groot:"stdVecU64"`
  1179  				ROOT_stdVecF32    []float32        `groot:"stdVecF32"`
  1180  				ROOT_stdVecF64    []float64        `groot:"stdVecF64"`
  1181  				ROOT_stdVecF16    []root.Float16   `groot:"stdVecF16"`
  1182  				ROOT_stdVecD32    []root.Double32  `groot:"stdVecD32"`
  1183  				ROOT_stdVecStr    []string         `groot:"stdVecStr"`
  1184  				ROOT_stdVecCstr   []string         `groot:"stdVecCstr"`
  1185  				ROOT_stdVecNamed1 []rbase.Named    `groot:"stdVecNamed1"`
  1186  				ROOT_stdVecNamed2 []rbase.Named    `groot:"stdVecNamed2"`
  1187  				ROOT_ptrObj       *rbase.Object    `groot:"ptrObj"`
  1188  				ROOT_ptrPos1      *struct {
  1189  					ROOT_px float32 `groot:"px"`
  1190  					ROOT_py float64 `groot:"py"`
  1191  				} `groot:"ptrPos1"`
  1192  				ROOT_ptrPos2 *TypeFromSI_Pos2 `groot:"ptrPos2"`
  1193  				ROOT_ptrArrF *rcont.ArrayF    `groot:"ptrArrF"`
  1194  			}](),
  1195  		},
  1196  		{
  1197  			name: "event-ndim",
  1198  			si: rdict.NewCxxStreamerInfo("event", 1, 0, []rbytes.StreamerElement{
  1199  				// arrays
  1200  				&rdict.StreamerBasicType{
  1201  					StreamerElement: rdict.Element{
  1202  						Name:   *rbase.NewNamed("arrB", ""),
  1203  						Type:   rmeta.OffsetL + rmeta.Bool,
  1204  						Size:   2 * 3 * 4 * 5 * 1,
  1205  						ArrLen: 2 * 3 * 4 * 5,
  1206  						ArrDim: 4,
  1207  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1208  						EName:  "bool*",
  1209  					}.New(),
  1210  				},
  1211  				&rdict.StreamerBasicType{
  1212  					StreamerElement: rdict.Element{
  1213  						Name:   *rbase.NewNamed("arrI8", ""),
  1214  						Type:   rmeta.OffsetL + rmeta.Int8,
  1215  						Size:   2 * 3 * 4 * 5 * 1,
  1216  						ArrLen: 2 * 3 * 4 * 5,
  1217  						ArrDim: 4,
  1218  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1219  						EName:  "int8_t*",
  1220  					}.New(),
  1221  				},
  1222  				&rdict.StreamerBasicType{
  1223  					StreamerElement: rdict.Element{
  1224  						Name:   *rbase.NewNamed("arrI16", ""),
  1225  						Type:   rmeta.OffsetL + rmeta.Int16,
  1226  						Size:   2 * 3 * 4 * 5 * 2,
  1227  						ArrLen: 2 * 3 * 4 * 5,
  1228  						ArrDim: 4,
  1229  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1230  						EName:  "int16_t*",
  1231  					}.New(),
  1232  				},
  1233  				&rdict.StreamerBasicType{
  1234  					StreamerElement: rdict.Element{
  1235  						Name:   *rbase.NewNamed("arrI32", ""),
  1236  						Type:   rmeta.OffsetL + rmeta.Int32,
  1237  						Size:   2 * 3 * 4 * 5 * 4,
  1238  						ArrLen: 2 * 3 * 4 * 5,
  1239  						ArrDim: 4,
  1240  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1241  						EName:  "int32_t*",
  1242  					}.New(),
  1243  				},
  1244  				&rdict.StreamerBasicType{
  1245  					StreamerElement: rdict.Element{
  1246  						Name:   *rbase.NewNamed("arrI64", ""),
  1247  						Type:   rmeta.OffsetL + rmeta.Int64,
  1248  						Size:   2 * 3 * 4 * 5 * 8,
  1249  						ArrLen: 2 * 3 * 4 * 5,
  1250  						ArrDim: 4,
  1251  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1252  						EName:  "int64_t*",
  1253  					}.New(),
  1254  				},
  1255  				&rdict.StreamerBasicType{
  1256  					StreamerElement: rdict.Element{
  1257  						Name:   *rbase.NewNamed("arrU8", ""),
  1258  						Type:   rmeta.OffsetL + rmeta.Uint8,
  1259  						Size:   2 * 3 * 4 * 5 * 1,
  1260  						ArrLen: 2 * 3 * 4 * 5,
  1261  						ArrDim: 4,
  1262  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1263  						EName:  "uint8_t*",
  1264  					}.New(),
  1265  				},
  1266  				&rdict.StreamerBasicType{
  1267  					StreamerElement: rdict.Element{
  1268  						Name:   *rbase.NewNamed("arrU16", ""),
  1269  						Type:   rmeta.OffsetL + rmeta.Uint16,
  1270  						Size:   2 * 3 * 4 * 5 * 2,
  1271  						ArrLen: 2 * 3 * 4 * 5,
  1272  						ArrDim: 4,
  1273  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1274  						EName:  "uint16_t*",
  1275  					}.New(),
  1276  				},
  1277  				&rdict.StreamerBasicType{
  1278  					StreamerElement: rdict.Element{
  1279  						Name:   *rbase.NewNamed("arrU32", ""),
  1280  						Type:   rmeta.OffsetL + rmeta.Uint32,
  1281  						Size:   2 * 3 * 4 * 5 * 4,
  1282  						ArrLen: 2 * 3 * 4 * 5,
  1283  						ArrDim: 4,
  1284  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1285  						EName:  "uint32_t*",
  1286  					}.New(),
  1287  				},
  1288  				&rdict.StreamerBasicType{
  1289  					StreamerElement: rdict.Element{
  1290  						Name:   *rbase.NewNamed("arrU64", ""),
  1291  						Type:   rmeta.OffsetL + rmeta.Uint64,
  1292  						Size:   2 * 3 * 4 * 5 * 8,
  1293  						ArrLen: 2 * 3 * 4 * 5,
  1294  						ArrDim: 4,
  1295  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1296  						EName:  "uint64_t*",
  1297  					}.New(),
  1298  				},
  1299  				&rdict.StreamerBasicType{
  1300  					StreamerElement: rdict.Element{
  1301  						Name:   *rbase.NewNamed("arrF32", ""),
  1302  						Type:   rmeta.OffsetL + rmeta.Float32,
  1303  						Size:   2 * 3 * 4 * 5 * 4,
  1304  						ArrLen: 2 * 3 * 4 * 5,
  1305  						ArrDim: 4,
  1306  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1307  						EName:  "float32_t*",
  1308  					}.New(),
  1309  				},
  1310  				&rdict.StreamerBasicType{
  1311  					StreamerElement: rdict.Element{
  1312  						Name:   *rbase.NewNamed("arrF64", ""),
  1313  						Type:   rmeta.OffsetL + rmeta.Float64,
  1314  						Size:   2 * 3 * 4 * 5 * 8,
  1315  						ArrLen: 2 * 3 * 4 * 5,
  1316  						ArrDim: 4,
  1317  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1318  						EName:  "float64_t*",
  1319  					}.New(),
  1320  				},
  1321  				&rdict.StreamerBasicType{
  1322  					StreamerElement: rdict.Element{
  1323  						Name:   *rbase.NewNamed("arrF16", ""),
  1324  						Type:   rmeta.OffsetL + rmeta.Float16,
  1325  						Size:   2 * 3 * 4 * 5 * 4,
  1326  						ArrLen: 2 * 3 * 4 * 5,
  1327  						ArrDim: 4,
  1328  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1329  						EName:  "Float16_t*",
  1330  					}.New(),
  1331  				},
  1332  				&rdict.StreamerBasicType{
  1333  					StreamerElement: rdict.Element{
  1334  						Name:   *rbase.NewNamed("arrD32", ""),
  1335  						Type:   rmeta.OffsetL + rmeta.Double32,
  1336  						Size:   2 * 3 * 4 * 5 * 4,
  1337  						ArrLen: 2 * 3 * 4 * 5,
  1338  						ArrDim: 4,
  1339  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1340  						EName:  "Double32_t*",
  1341  					}.New(),
  1342  				},
  1343  				&rdict.StreamerBasicType{
  1344  					StreamerElement: rdict.Element{
  1345  						Name:   *rbase.NewNamed("arrStr", ""),
  1346  						Type:   rmeta.OffsetL + rmeta.TString,
  1347  						Size:   2 * 3 * 4 * 5 * 24,
  1348  						ArrLen: 2 * 3 * 4 * 5,
  1349  						ArrDim: 4,
  1350  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1351  						EName:  "TString*",
  1352  					}.New(),
  1353  				},
  1354  				&rdict.StreamerBasicType{
  1355  					StreamerElement: rdict.Element{
  1356  						Name:   *rbase.NewNamed("arrCstr", ""),
  1357  						Type:   rmeta.OffsetL + rmeta.CharStar,
  1358  						Size:   2 * 3 * 4 * 5 * 8,
  1359  						ArrLen: 2 * 3 * 4 * 5,
  1360  						ArrDim: 4,
  1361  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1362  						EName:  "char**",
  1363  					}.New(),
  1364  				},
  1365  			}),
  1366  			want: reflect.TypeFor[struct {
  1367  				ROOT_arrB    [2][3][4][5]bool          `groot:"arrB[2][3][4][5]"`
  1368  				ROOT_arrI8   [2][3][4][5]int8          `groot:"arrI8[2][3][4][5]"`
  1369  				ROOT_arrI16  [2][3][4][5]int16         `groot:"arrI16[2][3][4][5]"`
  1370  				ROOT_arrI32  [2][3][4][5]int32         `groot:"arrI32[2][3][4][5]"`
  1371  				ROOT_arrI64  [2][3][4][5]int64         `groot:"arrI64[2][3][4][5]"`
  1372  				ROOT_arrU8   [2][3][4][5]uint8         `groot:"arrU8[2][3][4][5]"`
  1373  				ROOT_arrU16  [2][3][4][5]uint16        `groot:"arrU16[2][3][4][5]"`
  1374  				ROOT_arrU32  [2][3][4][5]uint32        `groot:"arrU32[2][3][4][5]"`
  1375  				ROOT_arrU64  [2][3][4][5]uint64        `groot:"arrU64[2][3][4][5]"`
  1376  				ROOT_arrF32  [2][3][4][5]float32       `groot:"arrF32[2][3][4][5]"`
  1377  				ROOT_arrF64  [2][3][4][5]float64       `groot:"arrF64[2][3][4][5]"`
  1378  				ROOT_arrF16  [2][3][4][5]root.Float16  `groot:"arrF16[2][3][4][5]"`
  1379  				ROOT_arrD32  [2][3][4][5]root.Double32 `groot:"arrD32[2][3][4][5]"`
  1380  				ROOT_arrStr  [2][3][4][5]string        `groot:"arrStr[2][3][4][5]"`
  1381  				ROOT_arrCstr [2][3][4][5]string        `groot:"arrCstr[2][3][4][5]"`
  1382  			}](),
  1383  		},
  1384  	} {
  1385  		t.Run(tc.name, func(t *testing.T) {
  1386  			err := tc.si.BuildStreamers()
  1387  			if err != nil {
  1388  				t.Fatalf("could not build streamers: %+v", err)
  1389  			}
  1390  
  1391  			got, err := rdict.TypeFromSI(rdict.StreamerInfos, tc.si)
  1392  			if err != nil {
  1393  				t.Fatalf("could not load type: %+v", err)
  1394  			}
  1395  
  1396  			if got != tc.want {
  1397  				t.Fatalf("invalid Go type:\ngot= %T\nwant=%T",
  1398  					reflect.New(got).Elem().Interface(),
  1399  					reflect.New(tc.want).Elem().Interface(),
  1400  				)
  1401  			}
  1402  		})
  1403  	}
  1404  }