gorgonia.org/tensor@v0.9.24/native/iterator_native2_test.go (about)

     1  // Code generated by genlib2. DO NOT EDIT.
     2  
     3  package native
     4  
     5  import (
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  	. "gorgonia.org/tensor"
    10  )
    11  
    12  func TestSelectB(t *testing.T) {
    13  	assert := assert.New(t)
    14  	var T *Dense
    15  	var err error
    16  	var x [][]bool
    17  	T = New(Of(Bool), WithShape(2, 3, 4, 5))
    18  	if x, err = SelectB(T, 1); err != nil {
    19  		t.Fatal(err)
    20  	}
    21  	assert.Equal(6, len(x))
    22  	assert.Equal(20, len(x[0]))
    23  
    24  	T = New(Of(Bool), WithShape(2, 3, 4, 5))
    25  	if x, err = SelectB(T, 0); err != nil {
    26  		t.Fatal(err)
    27  	}
    28  	assert.Equal(2, len(x))
    29  	assert.Equal(60, len(x[0]))
    30  
    31  	T = New(Of(Bool), WithShape(2, 3, 4, 5))
    32  	if x, err = SelectB(T, 3); err != nil {
    33  		t.Fatal(err)
    34  	}
    35  	assert.Equal(120, len(x))
    36  	assert.Equal(1, len(x[0]))
    37  
    38  	T = New(Of(Bool), WithShape(2, 3))
    39  	if x, err = SelectB(T, 0); err != nil {
    40  		t.Fatal(err)
    41  	}
    42  	assert.Equal(2, len(x))
    43  	assert.Equal(3, len(x[0]))
    44  
    45  	T = New(Of(Bool), WithShape(2, 3))
    46  	if x, err = SelectB(T, 1); err != nil {
    47  		t.Fatal(err)
    48  	}
    49  	assert.Equal(6, len(x))
    50  	assert.Equal(1, len(x[0]))
    51  
    52  	T = New(FromScalar(false))
    53  	if x, err = SelectB(T, 0); err != nil {
    54  		t.Fatal(err)
    55  	}
    56  	assert.Equal(1, len(x))
    57  	assert.Equal(1, len(x[0]))
    58  
    59  	if _, err = SelectB(T, 10); err == nil {
    60  		t.Fatal("Expected errors")
    61  	}
    62  }
    63  
    64  func TestSelectI(t *testing.T) {
    65  	assert := assert.New(t)
    66  	var T *Dense
    67  	var err error
    68  	var x [][]int
    69  	T = New(Of(Int), WithShape(2, 3, 4, 5))
    70  	if x, err = SelectI(T, 1); err != nil {
    71  		t.Fatal(err)
    72  	}
    73  	assert.Equal(6, len(x))
    74  	assert.Equal(20, len(x[0]))
    75  
    76  	T = New(Of(Int), WithShape(2, 3, 4, 5))
    77  	if x, err = SelectI(T, 0); err != nil {
    78  		t.Fatal(err)
    79  	}
    80  	assert.Equal(2, len(x))
    81  	assert.Equal(60, len(x[0]))
    82  
    83  	T = New(Of(Int), WithShape(2, 3, 4, 5))
    84  	if x, err = SelectI(T, 3); err != nil {
    85  		t.Fatal(err)
    86  	}
    87  	assert.Equal(120, len(x))
    88  	assert.Equal(1, len(x[0]))
    89  
    90  	T = New(Of(Int), WithShape(2, 3))
    91  	if x, err = SelectI(T, 0); err != nil {
    92  		t.Fatal(err)
    93  	}
    94  	assert.Equal(2, len(x))
    95  	assert.Equal(3, len(x[0]))
    96  
    97  	T = New(Of(Int), WithShape(2, 3))
    98  	if x, err = SelectI(T, 1); err != nil {
    99  		t.Fatal(err)
   100  	}
   101  	assert.Equal(6, len(x))
   102  	assert.Equal(1, len(x[0]))
   103  
   104  	T = New(FromScalar(int(0)))
   105  	if x, err = SelectI(T, 0); err != nil {
   106  		t.Fatal(err)
   107  	}
   108  	assert.Equal(1, len(x))
   109  	assert.Equal(1, len(x[0]))
   110  
   111  	if _, err = SelectI(T, 10); err == nil {
   112  		t.Fatal("Expected errors")
   113  	}
   114  }
   115  
   116  func TestSelectI8(t *testing.T) {
   117  	assert := assert.New(t)
   118  	var T *Dense
   119  	var err error
   120  	var x [][]int8
   121  	T = New(Of(Int8), WithShape(2, 3, 4, 5))
   122  	if x, err = SelectI8(T, 1); err != nil {
   123  		t.Fatal(err)
   124  	}
   125  	assert.Equal(6, len(x))
   126  	assert.Equal(20, len(x[0]))
   127  
   128  	T = New(Of(Int8), WithShape(2, 3, 4, 5))
   129  	if x, err = SelectI8(T, 0); err != nil {
   130  		t.Fatal(err)
   131  	}
   132  	assert.Equal(2, len(x))
   133  	assert.Equal(60, len(x[0]))
   134  
   135  	T = New(Of(Int8), WithShape(2, 3, 4, 5))
   136  	if x, err = SelectI8(T, 3); err != nil {
   137  		t.Fatal(err)
   138  	}
   139  	assert.Equal(120, len(x))
   140  	assert.Equal(1, len(x[0]))
   141  
   142  	T = New(Of(Int8), WithShape(2, 3))
   143  	if x, err = SelectI8(T, 0); err != nil {
   144  		t.Fatal(err)
   145  	}
   146  	assert.Equal(2, len(x))
   147  	assert.Equal(3, len(x[0]))
   148  
   149  	T = New(Of(Int8), WithShape(2, 3))
   150  	if x, err = SelectI8(T, 1); err != nil {
   151  		t.Fatal(err)
   152  	}
   153  	assert.Equal(6, len(x))
   154  	assert.Equal(1, len(x[0]))
   155  
   156  	T = New(FromScalar(int8(0)))
   157  	if x, err = SelectI8(T, 0); err != nil {
   158  		t.Fatal(err)
   159  	}
   160  	assert.Equal(1, len(x))
   161  	assert.Equal(1, len(x[0]))
   162  
   163  	if _, err = SelectI8(T, 10); err == nil {
   164  		t.Fatal("Expected errors")
   165  	}
   166  }
   167  
   168  func TestSelectI16(t *testing.T) {
   169  	assert := assert.New(t)
   170  	var T *Dense
   171  	var err error
   172  	var x [][]int16
   173  	T = New(Of(Int16), WithShape(2, 3, 4, 5))
   174  	if x, err = SelectI16(T, 1); err != nil {
   175  		t.Fatal(err)
   176  	}
   177  	assert.Equal(6, len(x))
   178  	assert.Equal(20, len(x[0]))
   179  
   180  	T = New(Of(Int16), WithShape(2, 3, 4, 5))
   181  	if x, err = SelectI16(T, 0); err != nil {
   182  		t.Fatal(err)
   183  	}
   184  	assert.Equal(2, len(x))
   185  	assert.Equal(60, len(x[0]))
   186  
   187  	T = New(Of(Int16), WithShape(2, 3, 4, 5))
   188  	if x, err = SelectI16(T, 3); err != nil {
   189  		t.Fatal(err)
   190  	}
   191  	assert.Equal(120, len(x))
   192  	assert.Equal(1, len(x[0]))
   193  
   194  	T = New(Of(Int16), WithShape(2, 3))
   195  	if x, err = SelectI16(T, 0); err != nil {
   196  		t.Fatal(err)
   197  	}
   198  	assert.Equal(2, len(x))
   199  	assert.Equal(3, len(x[0]))
   200  
   201  	T = New(Of(Int16), WithShape(2, 3))
   202  	if x, err = SelectI16(T, 1); err != nil {
   203  		t.Fatal(err)
   204  	}
   205  	assert.Equal(6, len(x))
   206  	assert.Equal(1, len(x[0]))
   207  
   208  	T = New(FromScalar(int16(0)))
   209  	if x, err = SelectI16(T, 0); err != nil {
   210  		t.Fatal(err)
   211  	}
   212  	assert.Equal(1, len(x))
   213  	assert.Equal(1, len(x[0]))
   214  
   215  	if _, err = SelectI16(T, 10); err == nil {
   216  		t.Fatal("Expected errors")
   217  	}
   218  }
   219  
   220  func TestSelectI32(t *testing.T) {
   221  	assert := assert.New(t)
   222  	var T *Dense
   223  	var err error
   224  	var x [][]int32
   225  	T = New(Of(Int32), WithShape(2, 3, 4, 5))
   226  	if x, err = SelectI32(T, 1); err != nil {
   227  		t.Fatal(err)
   228  	}
   229  	assert.Equal(6, len(x))
   230  	assert.Equal(20, len(x[0]))
   231  
   232  	T = New(Of(Int32), WithShape(2, 3, 4, 5))
   233  	if x, err = SelectI32(T, 0); err != nil {
   234  		t.Fatal(err)
   235  	}
   236  	assert.Equal(2, len(x))
   237  	assert.Equal(60, len(x[0]))
   238  
   239  	T = New(Of(Int32), WithShape(2, 3, 4, 5))
   240  	if x, err = SelectI32(T, 3); err != nil {
   241  		t.Fatal(err)
   242  	}
   243  	assert.Equal(120, len(x))
   244  	assert.Equal(1, len(x[0]))
   245  
   246  	T = New(Of(Int32), WithShape(2, 3))
   247  	if x, err = SelectI32(T, 0); err != nil {
   248  		t.Fatal(err)
   249  	}
   250  	assert.Equal(2, len(x))
   251  	assert.Equal(3, len(x[0]))
   252  
   253  	T = New(Of(Int32), WithShape(2, 3))
   254  	if x, err = SelectI32(T, 1); err != nil {
   255  		t.Fatal(err)
   256  	}
   257  	assert.Equal(6, len(x))
   258  	assert.Equal(1, len(x[0]))
   259  
   260  	T = New(FromScalar(int32(0)))
   261  	if x, err = SelectI32(T, 0); err != nil {
   262  		t.Fatal(err)
   263  	}
   264  	assert.Equal(1, len(x))
   265  	assert.Equal(1, len(x[0]))
   266  
   267  	if _, err = SelectI32(T, 10); err == nil {
   268  		t.Fatal("Expected errors")
   269  	}
   270  }
   271  
   272  func TestSelectI64(t *testing.T) {
   273  	assert := assert.New(t)
   274  	var T *Dense
   275  	var err error
   276  	var x [][]int64
   277  	T = New(Of(Int64), WithShape(2, 3, 4, 5))
   278  	if x, err = SelectI64(T, 1); err != nil {
   279  		t.Fatal(err)
   280  	}
   281  	assert.Equal(6, len(x))
   282  	assert.Equal(20, len(x[0]))
   283  
   284  	T = New(Of(Int64), WithShape(2, 3, 4, 5))
   285  	if x, err = SelectI64(T, 0); err != nil {
   286  		t.Fatal(err)
   287  	}
   288  	assert.Equal(2, len(x))
   289  	assert.Equal(60, len(x[0]))
   290  
   291  	T = New(Of(Int64), WithShape(2, 3, 4, 5))
   292  	if x, err = SelectI64(T, 3); err != nil {
   293  		t.Fatal(err)
   294  	}
   295  	assert.Equal(120, len(x))
   296  	assert.Equal(1, len(x[0]))
   297  
   298  	T = New(Of(Int64), WithShape(2, 3))
   299  	if x, err = SelectI64(T, 0); err != nil {
   300  		t.Fatal(err)
   301  	}
   302  	assert.Equal(2, len(x))
   303  	assert.Equal(3, len(x[0]))
   304  
   305  	T = New(Of(Int64), WithShape(2, 3))
   306  	if x, err = SelectI64(T, 1); err != nil {
   307  		t.Fatal(err)
   308  	}
   309  	assert.Equal(6, len(x))
   310  	assert.Equal(1, len(x[0]))
   311  
   312  	T = New(FromScalar(int64(0)))
   313  	if x, err = SelectI64(T, 0); err != nil {
   314  		t.Fatal(err)
   315  	}
   316  	assert.Equal(1, len(x))
   317  	assert.Equal(1, len(x[0]))
   318  
   319  	if _, err = SelectI64(T, 10); err == nil {
   320  		t.Fatal("Expected errors")
   321  	}
   322  }
   323  
   324  func TestSelectU(t *testing.T) {
   325  	assert := assert.New(t)
   326  	var T *Dense
   327  	var err error
   328  	var x [][]uint
   329  	T = New(Of(Uint), WithShape(2, 3, 4, 5))
   330  	if x, err = SelectU(T, 1); err != nil {
   331  		t.Fatal(err)
   332  	}
   333  	assert.Equal(6, len(x))
   334  	assert.Equal(20, len(x[0]))
   335  
   336  	T = New(Of(Uint), WithShape(2, 3, 4, 5))
   337  	if x, err = SelectU(T, 0); err != nil {
   338  		t.Fatal(err)
   339  	}
   340  	assert.Equal(2, len(x))
   341  	assert.Equal(60, len(x[0]))
   342  
   343  	T = New(Of(Uint), WithShape(2, 3, 4, 5))
   344  	if x, err = SelectU(T, 3); err != nil {
   345  		t.Fatal(err)
   346  	}
   347  	assert.Equal(120, len(x))
   348  	assert.Equal(1, len(x[0]))
   349  
   350  	T = New(Of(Uint), WithShape(2, 3))
   351  	if x, err = SelectU(T, 0); err != nil {
   352  		t.Fatal(err)
   353  	}
   354  	assert.Equal(2, len(x))
   355  	assert.Equal(3, len(x[0]))
   356  
   357  	T = New(Of(Uint), WithShape(2, 3))
   358  	if x, err = SelectU(T, 1); err != nil {
   359  		t.Fatal(err)
   360  	}
   361  	assert.Equal(6, len(x))
   362  	assert.Equal(1, len(x[0]))
   363  
   364  	T = New(FromScalar(uint(0)))
   365  	if x, err = SelectU(T, 0); err != nil {
   366  		t.Fatal(err)
   367  	}
   368  	assert.Equal(1, len(x))
   369  	assert.Equal(1, len(x[0]))
   370  
   371  	if _, err = SelectU(T, 10); err == nil {
   372  		t.Fatal("Expected errors")
   373  	}
   374  }
   375  
   376  func TestSelectU8(t *testing.T) {
   377  	assert := assert.New(t)
   378  	var T *Dense
   379  	var err error
   380  	var x [][]uint8
   381  	T = New(Of(Uint8), WithShape(2, 3, 4, 5))
   382  	if x, err = SelectU8(T, 1); err != nil {
   383  		t.Fatal(err)
   384  	}
   385  	assert.Equal(6, len(x))
   386  	assert.Equal(20, len(x[0]))
   387  
   388  	T = New(Of(Uint8), WithShape(2, 3, 4, 5))
   389  	if x, err = SelectU8(T, 0); err != nil {
   390  		t.Fatal(err)
   391  	}
   392  	assert.Equal(2, len(x))
   393  	assert.Equal(60, len(x[0]))
   394  
   395  	T = New(Of(Uint8), WithShape(2, 3, 4, 5))
   396  	if x, err = SelectU8(T, 3); err != nil {
   397  		t.Fatal(err)
   398  	}
   399  	assert.Equal(120, len(x))
   400  	assert.Equal(1, len(x[0]))
   401  
   402  	T = New(Of(Uint8), WithShape(2, 3))
   403  	if x, err = SelectU8(T, 0); err != nil {
   404  		t.Fatal(err)
   405  	}
   406  	assert.Equal(2, len(x))
   407  	assert.Equal(3, len(x[0]))
   408  
   409  	T = New(Of(Uint8), WithShape(2, 3))
   410  	if x, err = SelectU8(T, 1); err != nil {
   411  		t.Fatal(err)
   412  	}
   413  	assert.Equal(6, len(x))
   414  	assert.Equal(1, len(x[0]))
   415  
   416  	T = New(FromScalar(uint8(0)))
   417  	if x, err = SelectU8(T, 0); err != nil {
   418  		t.Fatal(err)
   419  	}
   420  	assert.Equal(1, len(x))
   421  	assert.Equal(1, len(x[0]))
   422  
   423  	if _, err = SelectU8(T, 10); err == nil {
   424  		t.Fatal("Expected errors")
   425  	}
   426  }
   427  
   428  func TestSelectU16(t *testing.T) {
   429  	assert := assert.New(t)
   430  	var T *Dense
   431  	var err error
   432  	var x [][]uint16
   433  	T = New(Of(Uint16), WithShape(2, 3, 4, 5))
   434  	if x, err = SelectU16(T, 1); err != nil {
   435  		t.Fatal(err)
   436  	}
   437  	assert.Equal(6, len(x))
   438  	assert.Equal(20, len(x[0]))
   439  
   440  	T = New(Of(Uint16), WithShape(2, 3, 4, 5))
   441  	if x, err = SelectU16(T, 0); err != nil {
   442  		t.Fatal(err)
   443  	}
   444  	assert.Equal(2, len(x))
   445  	assert.Equal(60, len(x[0]))
   446  
   447  	T = New(Of(Uint16), WithShape(2, 3, 4, 5))
   448  	if x, err = SelectU16(T, 3); err != nil {
   449  		t.Fatal(err)
   450  	}
   451  	assert.Equal(120, len(x))
   452  	assert.Equal(1, len(x[0]))
   453  
   454  	T = New(Of(Uint16), WithShape(2, 3))
   455  	if x, err = SelectU16(T, 0); err != nil {
   456  		t.Fatal(err)
   457  	}
   458  	assert.Equal(2, len(x))
   459  	assert.Equal(3, len(x[0]))
   460  
   461  	T = New(Of(Uint16), WithShape(2, 3))
   462  	if x, err = SelectU16(T, 1); err != nil {
   463  		t.Fatal(err)
   464  	}
   465  	assert.Equal(6, len(x))
   466  	assert.Equal(1, len(x[0]))
   467  
   468  	T = New(FromScalar(uint16(0)))
   469  	if x, err = SelectU16(T, 0); err != nil {
   470  		t.Fatal(err)
   471  	}
   472  	assert.Equal(1, len(x))
   473  	assert.Equal(1, len(x[0]))
   474  
   475  	if _, err = SelectU16(T, 10); err == nil {
   476  		t.Fatal("Expected errors")
   477  	}
   478  }
   479  
   480  func TestSelectU32(t *testing.T) {
   481  	assert := assert.New(t)
   482  	var T *Dense
   483  	var err error
   484  	var x [][]uint32
   485  	T = New(Of(Uint32), WithShape(2, 3, 4, 5))
   486  	if x, err = SelectU32(T, 1); err != nil {
   487  		t.Fatal(err)
   488  	}
   489  	assert.Equal(6, len(x))
   490  	assert.Equal(20, len(x[0]))
   491  
   492  	T = New(Of(Uint32), WithShape(2, 3, 4, 5))
   493  	if x, err = SelectU32(T, 0); err != nil {
   494  		t.Fatal(err)
   495  	}
   496  	assert.Equal(2, len(x))
   497  	assert.Equal(60, len(x[0]))
   498  
   499  	T = New(Of(Uint32), WithShape(2, 3, 4, 5))
   500  	if x, err = SelectU32(T, 3); err != nil {
   501  		t.Fatal(err)
   502  	}
   503  	assert.Equal(120, len(x))
   504  	assert.Equal(1, len(x[0]))
   505  
   506  	T = New(Of(Uint32), WithShape(2, 3))
   507  	if x, err = SelectU32(T, 0); err != nil {
   508  		t.Fatal(err)
   509  	}
   510  	assert.Equal(2, len(x))
   511  	assert.Equal(3, len(x[0]))
   512  
   513  	T = New(Of(Uint32), WithShape(2, 3))
   514  	if x, err = SelectU32(T, 1); err != nil {
   515  		t.Fatal(err)
   516  	}
   517  	assert.Equal(6, len(x))
   518  	assert.Equal(1, len(x[0]))
   519  
   520  	T = New(FromScalar(uint32(0)))
   521  	if x, err = SelectU32(T, 0); err != nil {
   522  		t.Fatal(err)
   523  	}
   524  	assert.Equal(1, len(x))
   525  	assert.Equal(1, len(x[0]))
   526  
   527  	if _, err = SelectU32(T, 10); err == nil {
   528  		t.Fatal("Expected errors")
   529  	}
   530  }
   531  
   532  func TestSelectU64(t *testing.T) {
   533  	assert := assert.New(t)
   534  	var T *Dense
   535  	var err error
   536  	var x [][]uint64
   537  	T = New(Of(Uint64), WithShape(2, 3, 4, 5))
   538  	if x, err = SelectU64(T, 1); err != nil {
   539  		t.Fatal(err)
   540  	}
   541  	assert.Equal(6, len(x))
   542  	assert.Equal(20, len(x[0]))
   543  
   544  	T = New(Of(Uint64), WithShape(2, 3, 4, 5))
   545  	if x, err = SelectU64(T, 0); err != nil {
   546  		t.Fatal(err)
   547  	}
   548  	assert.Equal(2, len(x))
   549  	assert.Equal(60, len(x[0]))
   550  
   551  	T = New(Of(Uint64), WithShape(2, 3, 4, 5))
   552  	if x, err = SelectU64(T, 3); err != nil {
   553  		t.Fatal(err)
   554  	}
   555  	assert.Equal(120, len(x))
   556  	assert.Equal(1, len(x[0]))
   557  
   558  	T = New(Of(Uint64), WithShape(2, 3))
   559  	if x, err = SelectU64(T, 0); err != nil {
   560  		t.Fatal(err)
   561  	}
   562  	assert.Equal(2, len(x))
   563  	assert.Equal(3, len(x[0]))
   564  
   565  	T = New(Of(Uint64), WithShape(2, 3))
   566  	if x, err = SelectU64(T, 1); err != nil {
   567  		t.Fatal(err)
   568  	}
   569  	assert.Equal(6, len(x))
   570  	assert.Equal(1, len(x[0]))
   571  
   572  	T = New(FromScalar(uint64(0)))
   573  	if x, err = SelectU64(T, 0); err != nil {
   574  		t.Fatal(err)
   575  	}
   576  	assert.Equal(1, len(x))
   577  	assert.Equal(1, len(x[0]))
   578  
   579  	if _, err = SelectU64(T, 10); err == nil {
   580  		t.Fatal("Expected errors")
   581  	}
   582  }
   583  
   584  func TestSelectF32(t *testing.T) {
   585  	assert := assert.New(t)
   586  	var T *Dense
   587  	var err error
   588  	var x [][]float32
   589  	T = New(Of(Float32), WithShape(2, 3, 4, 5))
   590  	if x, err = SelectF32(T, 1); err != nil {
   591  		t.Fatal(err)
   592  	}
   593  	assert.Equal(6, len(x))
   594  	assert.Equal(20, len(x[0]))
   595  
   596  	T = New(Of(Float32), WithShape(2, 3, 4, 5))
   597  	if x, err = SelectF32(T, 0); err != nil {
   598  		t.Fatal(err)
   599  	}
   600  	assert.Equal(2, len(x))
   601  	assert.Equal(60, len(x[0]))
   602  
   603  	T = New(Of(Float32), WithShape(2, 3, 4, 5))
   604  	if x, err = SelectF32(T, 3); err != nil {
   605  		t.Fatal(err)
   606  	}
   607  	assert.Equal(120, len(x))
   608  	assert.Equal(1, len(x[0]))
   609  
   610  	T = New(Of(Float32), WithShape(2, 3))
   611  	if x, err = SelectF32(T, 0); err != nil {
   612  		t.Fatal(err)
   613  	}
   614  	assert.Equal(2, len(x))
   615  	assert.Equal(3, len(x[0]))
   616  
   617  	T = New(Of(Float32), WithShape(2, 3))
   618  	if x, err = SelectF32(T, 1); err != nil {
   619  		t.Fatal(err)
   620  	}
   621  	assert.Equal(6, len(x))
   622  	assert.Equal(1, len(x[0]))
   623  
   624  	T = New(FromScalar(float32(0)))
   625  	if x, err = SelectF32(T, 0); err != nil {
   626  		t.Fatal(err)
   627  	}
   628  	assert.Equal(1, len(x))
   629  	assert.Equal(1, len(x[0]))
   630  
   631  	if _, err = SelectF32(T, 10); err == nil {
   632  		t.Fatal("Expected errors")
   633  	}
   634  }
   635  
   636  func TestSelectF64(t *testing.T) {
   637  	assert := assert.New(t)
   638  	var T *Dense
   639  	var err error
   640  	var x [][]float64
   641  	T = New(Of(Float64), WithShape(2, 3, 4, 5))
   642  	if x, err = SelectF64(T, 1); err != nil {
   643  		t.Fatal(err)
   644  	}
   645  	assert.Equal(6, len(x))
   646  	assert.Equal(20, len(x[0]))
   647  
   648  	T = New(Of(Float64), WithShape(2, 3, 4, 5))
   649  	if x, err = SelectF64(T, 0); err != nil {
   650  		t.Fatal(err)
   651  	}
   652  	assert.Equal(2, len(x))
   653  	assert.Equal(60, len(x[0]))
   654  
   655  	T = New(Of(Float64), WithShape(2, 3, 4, 5))
   656  	if x, err = SelectF64(T, 3); err != nil {
   657  		t.Fatal(err)
   658  	}
   659  	assert.Equal(120, len(x))
   660  	assert.Equal(1, len(x[0]))
   661  
   662  	T = New(Of(Float64), WithShape(2, 3))
   663  	if x, err = SelectF64(T, 0); err != nil {
   664  		t.Fatal(err)
   665  	}
   666  	assert.Equal(2, len(x))
   667  	assert.Equal(3, len(x[0]))
   668  
   669  	T = New(Of(Float64), WithShape(2, 3))
   670  	if x, err = SelectF64(T, 1); err != nil {
   671  		t.Fatal(err)
   672  	}
   673  	assert.Equal(6, len(x))
   674  	assert.Equal(1, len(x[0]))
   675  
   676  	T = New(FromScalar(float64(0)))
   677  	if x, err = SelectF64(T, 0); err != nil {
   678  		t.Fatal(err)
   679  	}
   680  	assert.Equal(1, len(x))
   681  	assert.Equal(1, len(x[0]))
   682  
   683  	if _, err = SelectF64(T, 10); err == nil {
   684  		t.Fatal("Expected errors")
   685  	}
   686  }
   687  
   688  func TestSelectC64(t *testing.T) {
   689  	assert := assert.New(t)
   690  	var T *Dense
   691  	var err error
   692  	var x [][]complex64
   693  	T = New(Of(Complex64), WithShape(2, 3, 4, 5))
   694  	if x, err = SelectC64(T, 1); err != nil {
   695  		t.Fatal(err)
   696  	}
   697  	assert.Equal(6, len(x))
   698  	assert.Equal(20, len(x[0]))
   699  
   700  	T = New(Of(Complex64), WithShape(2, 3, 4, 5))
   701  	if x, err = SelectC64(T, 0); err != nil {
   702  		t.Fatal(err)
   703  	}
   704  	assert.Equal(2, len(x))
   705  	assert.Equal(60, len(x[0]))
   706  
   707  	T = New(Of(Complex64), WithShape(2, 3, 4, 5))
   708  	if x, err = SelectC64(T, 3); err != nil {
   709  		t.Fatal(err)
   710  	}
   711  	assert.Equal(120, len(x))
   712  	assert.Equal(1, len(x[0]))
   713  
   714  	T = New(Of(Complex64), WithShape(2, 3))
   715  	if x, err = SelectC64(T, 0); err != nil {
   716  		t.Fatal(err)
   717  	}
   718  	assert.Equal(2, len(x))
   719  	assert.Equal(3, len(x[0]))
   720  
   721  	T = New(Of(Complex64), WithShape(2, 3))
   722  	if x, err = SelectC64(T, 1); err != nil {
   723  		t.Fatal(err)
   724  	}
   725  	assert.Equal(6, len(x))
   726  	assert.Equal(1, len(x[0]))
   727  
   728  	T = New(FromScalar(complex64(0)))
   729  	if x, err = SelectC64(T, 0); err != nil {
   730  		t.Fatal(err)
   731  	}
   732  	assert.Equal(1, len(x))
   733  	assert.Equal(1, len(x[0]))
   734  
   735  	if _, err = SelectC64(T, 10); err == nil {
   736  		t.Fatal("Expected errors")
   737  	}
   738  }
   739  
   740  func TestSelectC128(t *testing.T) {
   741  	assert := assert.New(t)
   742  	var T *Dense
   743  	var err error
   744  	var x [][]complex128
   745  	T = New(Of(Complex128), WithShape(2, 3, 4, 5))
   746  	if x, err = SelectC128(T, 1); err != nil {
   747  		t.Fatal(err)
   748  	}
   749  	assert.Equal(6, len(x))
   750  	assert.Equal(20, len(x[0]))
   751  
   752  	T = New(Of(Complex128), WithShape(2, 3, 4, 5))
   753  	if x, err = SelectC128(T, 0); err != nil {
   754  		t.Fatal(err)
   755  	}
   756  	assert.Equal(2, len(x))
   757  	assert.Equal(60, len(x[0]))
   758  
   759  	T = New(Of(Complex128), WithShape(2, 3, 4, 5))
   760  	if x, err = SelectC128(T, 3); err != nil {
   761  		t.Fatal(err)
   762  	}
   763  	assert.Equal(120, len(x))
   764  	assert.Equal(1, len(x[0]))
   765  
   766  	T = New(Of(Complex128), WithShape(2, 3))
   767  	if x, err = SelectC128(T, 0); err != nil {
   768  		t.Fatal(err)
   769  	}
   770  	assert.Equal(2, len(x))
   771  	assert.Equal(3, len(x[0]))
   772  
   773  	T = New(Of(Complex128), WithShape(2, 3))
   774  	if x, err = SelectC128(T, 1); err != nil {
   775  		t.Fatal(err)
   776  	}
   777  	assert.Equal(6, len(x))
   778  	assert.Equal(1, len(x[0]))
   779  
   780  	T = New(FromScalar(complex128(0)))
   781  	if x, err = SelectC128(T, 0); err != nil {
   782  		t.Fatal(err)
   783  	}
   784  	assert.Equal(1, len(x))
   785  	assert.Equal(1, len(x[0]))
   786  
   787  	if _, err = SelectC128(T, 10); err == nil {
   788  		t.Fatal("Expected errors")
   789  	}
   790  }
   791  
   792  func TestSelectStr(t *testing.T) {
   793  	assert := assert.New(t)
   794  	var T *Dense
   795  	var err error
   796  	var x [][]string
   797  	T = New(Of(String), WithShape(2, 3, 4, 5))
   798  	if x, err = SelectStr(T, 1); err != nil {
   799  		t.Fatal(err)
   800  	}
   801  	assert.Equal(6, len(x))
   802  	assert.Equal(20, len(x[0]))
   803  
   804  	T = New(Of(String), WithShape(2, 3, 4, 5))
   805  	if x, err = SelectStr(T, 0); err != nil {
   806  		t.Fatal(err)
   807  	}
   808  	assert.Equal(2, len(x))
   809  	assert.Equal(60, len(x[0]))
   810  
   811  	T = New(Of(String), WithShape(2, 3, 4, 5))
   812  	if x, err = SelectStr(T, 3); err != nil {
   813  		t.Fatal(err)
   814  	}
   815  	assert.Equal(120, len(x))
   816  	assert.Equal(1, len(x[0]))
   817  
   818  	T = New(Of(String), WithShape(2, 3))
   819  	if x, err = SelectStr(T, 0); err != nil {
   820  		t.Fatal(err)
   821  	}
   822  	assert.Equal(2, len(x))
   823  	assert.Equal(3, len(x[0]))
   824  
   825  	T = New(Of(String), WithShape(2, 3))
   826  	if x, err = SelectStr(T, 1); err != nil {
   827  		t.Fatal(err)
   828  	}
   829  	assert.Equal(6, len(x))
   830  	assert.Equal(1, len(x[0]))
   831  
   832  	T = New(FromScalar(""))
   833  	if x, err = SelectStr(T, 0); err != nil {
   834  		t.Fatal(err)
   835  	}
   836  	assert.Equal(1, len(x))
   837  	assert.Equal(1, len(x[0]))
   838  
   839  	if _, err = SelectStr(T, 10); err == nil {
   840  		t.Fatal("Expected errors")
   841  	}
   842  }