github.com/wzzhu/tensor@v0.9.24/native/iterator_native_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  	. "github.com/wzzhu/tensor"
    10  )
    11  
    12  func Test_VectorB(t *testing.T) {
    13  	assert := assert.New(t)
    14  	var T *Dense
    15  	T = New(Of(Bool), WithShape(6))
    16  	it, err := VectorB(T)
    17  	if err != nil {
    18  		t.Fatal(err)
    19  	}
    20  
    21  	assert.Equal(6, len(it))
    22  }
    23  
    24  func Test_MatrixB(t *testing.T) {
    25  	assert := assert.New(t)
    26  	var T *Dense
    27  	T = New(Of(Bool), WithShape(2, 3))
    28  	it, err := MatrixB(T)
    29  	if err != nil {
    30  		t.Fatal(err)
    31  	}
    32  
    33  	assert.Equal(2, len(it))
    34  	assert.Equal(3, len(it[0]))
    35  }
    36  
    37  func Test_Tensor3B(t *testing.T) {
    38  	assert := assert.New(t)
    39  	var T *Dense
    40  	T = New(Of(Bool), WithShape(2, 3, 4))
    41  	it, err := Tensor3B(T)
    42  	if err != nil {
    43  		t.Fatal(err)
    44  	}
    45  
    46  	assert.Equal(2, len(it))
    47  	assert.Equal(3, len(it[0]))
    48  	assert.Equal(4, len(it[0][0]))
    49  }
    50  
    51  func Test_VectorI(t *testing.T) {
    52  	assert := assert.New(t)
    53  	var T *Dense
    54  	T = New(WithBacking(Range(Int, 0, 6)), WithShape(6))
    55  	it, err := VectorI(T)
    56  	if err != nil {
    57  		t.Fatal(err)
    58  	}
    59  
    60  	assert.Equal(6, len(it))
    61  }
    62  
    63  func Test_MatrixI(t *testing.T) {
    64  	assert := assert.New(t)
    65  	var T *Dense
    66  	T = New(WithBacking(Range(Int, 0, 6)), WithShape(2, 3))
    67  	it, err := MatrixI(T)
    68  	if err != nil {
    69  		t.Fatal(err)
    70  	}
    71  
    72  	assert.Equal(2, len(it))
    73  	assert.Equal(3, len(it[0]))
    74  }
    75  
    76  func Test_Tensor3I(t *testing.T) {
    77  	assert := assert.New(t)
    78  	var T *Dense
    79  	T = New(WithBacking(Range(Int, 0, 24)), WithShape(2, 3, 4))
    80  	it, err := Tensor3I(T)
    81  	if err != nil {
    82  		t.Fatal(err)
    83  	}
    84  
    85  	assert.Equal(2, len(it))
    86  	assert.Equal(3, len(it[0]))
    87  	assert.Equal(4, len(it[0][0]))
    88  }
    89  
    90  func Test_VectorI8(t *testing.T) {
    91  	assert := assert.New(t)
    92  	var T *Dense
    93  	T = New(WithBacking(Range(Int8, 0, 6)), WithShape(6))
    94  	it, err := VectorI8(T)
    95  	if err != nil {
    96  		t.Fatal(err)
    97  	}
    98  
    99  	assert.Equal(6, len(it))
   100  }
   101  
   102  func Test_MatrixI8(t *testing.T) {
   103  	assert := assert.New(t)
   104  	var T *Dense
   105  	T = New(WithBacking(Range(Int8, 0, 6)), WithShape(2, 3))
   106  	it, err := MatrixI8(T)
   107  	if err != nil {
   108  		t.Fatal(err)
   109  	}
   110  
   111  	assert.Equal(2, len(it))
   112  	assert.Equal(3, len(it[0]))
   113  }
   114  
   115  func Test_Tensor3I8(t *testing.T) {
   116  	assert := assert.New(t)
   117  	var T *Dense
   118  	T = New(WithBacking(Range(Int8, 0, 24)), WithShape(2, 3, 4))
   119  	it, err := Tensor3I8(T)
   120  	if err != nil {
   121  		t.Fatal(err)
   122  	}
   123  
   124  	assert.Equal(2, len(it))
   125  	assert.Equal(3, len(it[0]))
   126  	assert.Equal(4, len(it[0][0]))
   127  }
   128  
   129  func Test_VectorI16(t *testing.T) {
   130  	assert := assert.New(t)
   131  	var T *Dense
   132  	T = New(WithBacking(Range(Int16, 0, 6)), WithShape(6))
   133  	it, err := VectorI16(T)
   134  	if err != nil {
   135  		t.Fatal(err)
   136  	}
   137  
   138  	assert.Equal(6, len(it))
   139  }
   140  
   141  func Test_MatrixI16(t *testing.T) {
   142  	assert := assert.New(t)
   143  	var T *Dense
   144  	T = New(WithBacking(Range(Int16, 0, 6)), WithShape(2, 3))
   145  	it, err := MatrixI16(T)
   146  	if err != nil {
   147  		t.Fatal(err)
   148  	}
   149  
   150  	assert.Equal(2, len(it))
   151  	assert.Equal(3, len(it[0]))
   152  }
   153  
   154  func Test_Tensor3I16(t *testing.T) {
   155  	assert := assert.New(t)
   156  	var T *Dense
   157  	T = New(WithBacking(Range(Int16, 0, 24)), WithShape(2, 3, 4))
   158  	it, err := Tensor3I16(T)
   159  	if err != nil {
   160  		t.Fatal(err)
   161  	}
   162  
   163  	assert.Equal(2, len(it))
   164  	assert.Equal(3, len(it[0]))
   165  	assert.Equal(4, len(it[0][0]))
   166  }
   167  
   168  func Test_VectorI32(t *testing.T) {
   169  	assert := assert.New(t)
   170  	var T *Dense
   171  	T = New(WithBacking(Range(Int32, 0, 6)), WithShape(6))
   172  	it, err := VectorI32(T)
   173  	if err != nil {
   174  		t.Fatal(err)
   175  	}
   176  
   177  	assert.Equal(6, len(it))
   178  }
   179  
   180  func Test_MatrixI32(t *testing.T) {
   181  	assert := assert.New(t)
   182  	var T *Dense
   183  	T = New(WithBacking(Range(Int32, 0, 6)), WithShape(2, 3))
   184  	it, err := MatrixI32(T)
   185  	if err != nil {
   186  		t.Fatal(err)
   187  	}
   188  
   189  	assert.Equal(2, len(it))
   190  	assert.Equal(3, len(it[0]))
   191  }
   192  
   193  func Test_Tensor3I32(t *testing.T) {
   194  	assert := assert.New(t)
   195  	var T *Dense
   196  	T = New(WithBacking(Range(Int32, 0, 24)), WithShape(2, 3, 4))
   197  	it, err := Tensor3I32(T)
   198  	if err != nil {
   199  		t.Fatal(err)
   200  	}
   201  
   202  	assert.Equal(2, len(it))
   203  	assert.Equal(3, len(it[0]))
   204  	assert.Equal(4, len(it[0][0]))
   205  }
   206  
   207  func Test_VectorI64(t *testing.T) {
   208  	assert := assert.New(t)
   209  	var T *Dense
   210  	T = New(WithBacking(Range(Int64, 0, 6)), WithShape(6))
   211  	it, err := VectorI64(T)
   212  	if err != nil {
   213  		t.Fatal(err)
   214  	}
   215  
   216  	assert.Equal(6, len(it))
   217  }
   218  
   219  func Test_MatrixI64(t *testing.T) {
   220  	assert := assert.New(t)
   221  	var T *Dense
   222  	T = New(WithBacking(Range(Int64, 0, 6)), WithShape(2, 3))
   223  	it, err := MatrixI64(T)
   224  	if err != nil {
   225  		t.Fatal(err)
   226  	}
   227  
   228  	assert.Equal(2, len(it))
   229  	assert.Equal(3, len(it[0]))
   230  }
   231  
   232  func Test_Tensor3I64(t *testing.T) {
   233  	assert := assert.New(t)
   234  	var T *Dense
   235  	T = New(WithBacking(Range(Int64, 0, 24)), WithShape(2, 3, 4))
   236  	it, err := Tensor3I64(T)
   237  	if err != nil {
   238  		t.Fatal(err)
   239  	}
   240  
   241  	assert.Equal(2, len(it))
   242  	assert.Equal(3, len(it[0]))
   243  	assert.Equal(4, len(it[0][0]))
   244  }
   245  
   246  func Test_VectorU(t *testing.T) {
   247  	assert := assert.New(t)
   248  	var T *Dense
   249  	T = New(WithBacking(Range(Uint, 0, 6)), WithShape(6))
   250  	it, err := VectorU(T)
   251  	if err != nil {
   252  		t.Fatal(err)
   253  	}
   254  
   255  	assert.Equal(6, len(it))
   256  }
   257  
   258  func Test_MatrixU(t *testing.T) {
   259  	assert := assert.New(t)
   260  	var T *Dense
   261  	T = New(WithBacking(Range(Uint, 0, 6)), WithShape(2, 3))
   262  	it, err := MatrixU(T)
   263  	if err != nil {
   264  		t.Fatal(err)
   265  	}
   266  
   267  	assert.Equal(2, len(it))
   268  	assert.Equal(3, len(it[0]))
   269  }
   270  
   271  func Test_Tensor3U(t *testing.T) {
   272  	assert := assert.New(t)
   273  	var T *Dense
   274  	T = New(WithBacking(Range(Uint, 0, 24)), WithShape(2, 3, 4))
   275  	it, err := Tensor3U(T)
   276  	if err != nil {
   277  		t.Fatal(err)
   278  	}
   279  
   280  	assert.Equal(2, len(it))
   281  	assert.Equal(3, len(it[0]))
   282  	assert.Equal(4, len(it[0][0]))
   283  }
   284  
   285  func Test_VectorU8(t *testing.T) {
   286  	assert := assert.New(t)
   287  	var T *Dense
   288  	T = New(WithBacking(Range(Uint8, 0, 6)), WithShape(6))
   289  	it, err := VectorU8(T)
   290  	if err != nil {
   291  		t.Fatal(err)
   292  	}
   293  
   294  	assert.Equal(6, len(it))
   295  }
   296  
   297  func Test_MatrixU8(t *testing.T) {
   298  	assert := assert.New(t)
   299  	var T *Dense
   300  	T = New(WithBacking(Range(Uint8, 0, 6)), WithShape(2, 3))
   301  	it, err := MatrixU8(T)
   302  	if err != nil {
   303  		t.Fatal(err)
   304  	}
   305  
   306  	assert.Equal(2, len(it))
   307  	assert.Equal(3, len(it[0]))
   308  }
   309  
   310  func Test_Tensor3U8(t *testing.T) {
   311  	assert := assert.New(t)
   312  	var T *Dense
   313  	T = New(WithBacking(Range(Uint8, 0, 24)), WithShape(2, 3, 4))
   314  	it, err := Tensor3U8(T)
   315  	if err != nil {
   316  		t.Fatal(err)
   317  	}
   318  
   319  	assert.Equal(2, len(it))
   320  	assert.Equal(3, len(it[0]))
   321  	assert.Equal(4, len(it[0][0]))
   322  }
   323  
   324  func Test_VectorU16(t *testing.T) {
   325  	assert := assert.New(t)
   326  	var T *Dense
   327  	T = New(WithBacking(Range(Uint16, 0, 6)), WithShape(6))
   328  	it, err := VectorU16(T)
   329  	if err != nil {
   330  		t.Fatal(err)
   331  	}
   332  
   333  	assert.Equal(6, len(it))
   334  }
   335  
   336  func Test_MatrixU16(t *testing.T) {
   337  	assert := assert.New(t)
   338  	var T *Dense
   339  	T = New(WithBacking(Range(Uint16, 0, 6)), WithShape(2, 3))
   340  	it, err := MatrixU16(T)
   341  	if err != nil {
   342  		t.Fatal(err)
   343  	}
   344  
   345  	assert.Equal(2, len(it))
   346  	assert.Equal(3, len(it[0]))
   347  }
   348  
   349  func Test_Tensor3U16(t *testing.T) {
   350  	assert := assert.New(t)
   351  	var T *Dense
   352  	T = New(WithBacking(Range(Uint16, 0, 24)), WithShape(2, 3, 4))
   353  	it, err := Tensor3U16(T)
   354  	if err != nil {
   355  		t.Fatal(err)
   356  	}
   357  
   358  	assert.Equal(2, len(it))
   359  	assert.Equal(3, len(it[0]))
   360  	assert.Equal(4, len(it[0][0]))
   361  }
   362  
   363  func Test_VectorU32(t *testing.T) {
   364  	assert := assert.New(t)
   365  	var T *Dense
   366  	T = New(WithBacking(Range(Uint32, 0, 6)), WithShape(6))
   367  	it, err := VectorU32(T)
   368  	if err != nil {
   369  		t.Fatal(err)
   370  	}
   371  
   372  	assert.Equal(6, len(it))
   373  }
   374  
   375  func Test_MatrixU32(t *testing.T) {
   376  	assert := assert.New(t)
   377  	var T *Dense
   378  	T = New(WithBacking(Range(Uint32, 0, 6)), WithShape(2, 3))
   379  	it, err := MatrixU32(T)
   380  	if err != nil {
   381  		t.Fatal(err)
   382  	}
   383  
   384  	assert.Equal(2, len(it))
   385  	assert.Equal(3, len(it[0]))
   386  }
   387  
   388  func Test_Tensor3U32(t *testing.T) {
   389  	assert := assert.New(t)
   390  	var T *Dense
   391  	T = New(WithBacking(Range(Uint32, 0, 24)), WithShape(2, 3, 4))
   392  	it, err := Tensor3U32(T)
   393  	if err != nil {
   394  		t.Fatal(err)
   395  	}
   396  
   397  	assert.Equal(2, len(it))
   398  	assert.Equal(3, len(it[0]))
   399  	assert.Equal(4, len(it[0][0]))
   400  }
   401  
   402  func Test_VectorU64(t *testing.T) {
   403  	assert := assert.New(t)
   404  	var T *Dense
   405  	T = New(WithBacking(Range(Uint64, 0, 6)), WithShape(6))
   406  	it, err := VectorU64(T)
   407  	if err != nil {
   408  		t.Fatal(err)
   409  	}
   410  
   411  	assert.Equal(6, len(it))
   412  }
   413  
   414  func Test_MatrixU64(t *testing.T) {
   415  	assert := assert.New(t)
   416  	var T *Dense
   417  	T = New(WithBacking(Range(Uint64, 0, 6)), WithShape(2, 3))
   418  	it, err := MatrixU64(T)
   419  	if err != nil {
   420  		t.Fatal(err)
   421  	}
   422  
   423  	assert.Equal(2, len(it))
   424  	assert.Equal(3, len(it[0]))
   425  }
   426  
   427  func Test_Tensor3U64(t *testing.T) {
   428  	assert := assert.New(t)
   429  	var T *Dense
   430  	T = New(WithBacking(Range(Uint64, 0, 24)), WithShape(2, 3, 4))
   431  	it, err := Tensor3U64(T)
   432  	if err != nil {
   433  		t.Fatal(err)
   434  	}
   435  
   436  	assert.Equal(2, len(it))
   437  	assert.Equal(3, len(it[0]))
   438  	assert.Equal(4, len(it[0][0]))
   439  }
   440  
   441  func Test_VectorF32(t *testing.T) {
   442  	assert := assert.New(t)
   443  	var T *Dense
   444  	T = New(WithBacking(Range(Float32, 0, 6)), WithShape(6))
   445  	it, err := VectorF32(T)
   446  	if err != nil {
   447  		t.Fatal(err)
   448  	}
   449  
   450  	assert.Equal(6, len(it))
   451  }
   452  
   453  func Test_MatrixF32(t *testing.T) {
   454  	assert := assert.New(t)
   455  	var T *Dense
   456  	T = New(WithBacking(Range(Float32, 0, 6)), WithShape(2, 3))
   457  	it, err := MatrixF32(T)
   458  	if err != nil {
   459  		t.Fatal(err)
   460  	}
   461  
   462  	assert.Equal(2, len(it))
   463  	assert.Equal(3, len(it[0]))
   464  }
   465  
   466  func Test_Tensor3F32(t *testing.T) {
   467  	assert := assert.New(t)
   468  	var T *Dense
   469  	T = New(WithBacking(Range(Float32, 0, 24)), WithShape(2, 3, 4))
   470  	it, err := Tensor3F32(T)
   471  	if err != nil {
   472  		t.Fatal(err)
   473  	}
   474  
   475  	assert.Equal(2, len(it))
   476  	assert.Equal(3, len(it[0]))
   477  	assert.Equal(4, len(it[0][0]))
   478  }
   479  
   480  func Test_VectorF64(t *testing.T) {
   481  	assert := assert.New(t)
   482  	var T *Dense
   483  	T = New(WithBacking(Range(Float64, 0, 6)), WithShape(6))
   484  	it, err := VectorF64(T)
   485  	if err != nil {
   486  		t.Fatal(err)
   487  	}
   488  
   489  	assert.Equal(6, len(it))
   490  }
   491  
   492  func Test_MatrixF64(t *testing.T) {
   493  	assert := assert.New(t)
   494  	var T *Dense
   495  	T = New(WithBacking(Range(Float64, 0, 6)), WithShape(2, 3))
   496  	it, err := MatrixF64(T)
   497  	if err != nil {
   498  		t.Fatal(err)
   499  	}
   500  
   501  	assert.Equal(2, len(it))
   502  	assert.Equal(3, len(it[0]))
   503  }
   504  
   505  func Test_Tensor3F64(t *testing.T) {
   506  	assert := assert.New(t)
   507  	var T *Dense
   508  	T = New(WithBacking(Range(Float64, 0, 24)), WithShape(2, 3, 4))
   509  	it, err := Tensor3F64(T)
   510  	if err != nil {
   511  		t.Fatal(err)
   512  	}
   513  
   514  	assert.Equal(2, len(it))
   515  	assert.Equal(3, len(it[0]))
   516  	assert.Equal(4, len(it[0][0]))
   517  }
   518  
   519  func Test_VectorC64(t *testing.T) {
   520  	assert := assert.New(t)
   521  	var T *Dense
   522  	T = New(WithBacking(Range(Complex64, 0, 6)), WithShape(6))
   523  	it, err := VectorC64(T)
   524  	if err != nil {
   525  		t.Fatal(err)
   526  	}
   527  
   528  	assert.Equal(6, len(it))
   529  }
   530  
   531  func Test_MatrixC64(t *testing.T) {
   532  	assert := assert.New(t)
   533  	var T *Dense
   534  	T = New(WithBacking(Range(Complex64, 0, 6)), WithShape(2, 3))
   535  	it, err := MatrixC64(T)
   536  	if err != nil {
   537  		t.Fatal(err)
   538  	}
   539  
   540  	assert.Equal(2, len(it))
   541  	assert.Equal(3, len(it[0]))
   542  }
   543  
   544  func Test_Tensor3C64(t *testing.T) {
   545  	assert := assert.New(t)
   546  	var T *Dense
   547  	T = New(WithBacking(Range(Complex64, 0, 24)), WithShape(2, 3, 4))
   548  	it, err := Tensor3C64(T)
   549  	if err != nil {
   550  		t.Fatal(err)
   551  	}
   552  
   553  	assert.Equal(2, len(it))
   554  	assert.Equal(3, len(it[0]))
   555  	assert.Equal(4, len(it[0][0]))
   556  }
   557  
   558  func Test_VectorC128(t *testing.T) {
   559  	assert := assert.New(t)
   560  	var T *Dense
   561  	T = New(WithBacking(Range(Complex128, 0, 6)), WithShape(6))
   562  	it, err := VectorC128(T)
   563  	if err != nil {
   564  		t.Fatal(err)
   565  	}
   566  
   567  	assert.Equal(6, len(it))
   568  }
   569  
   570  func Test_MatrixC128(t *testing.T) {
   571  	assert := assert.New(t)
   572  	var T *Dense
   573  	T = New(WithBacking(Range(Complex128, 0, 6)), WithShape(2, 3))
   574  	it, err := MatrixC128(T)
   575  	if err != nil {
   576  		t.Fatal(err)
   577  	}
   578  
   579  	assert.Equal(2, len(it))
   580  	assert.Equal(3, len(it[0]))
   581  }
   582  
   583  func Test_Tensor3C128(t *testing.T) {
   584  	assert := assert.New(t)
   585  	var T *Dense
   586  	T = New(WithBacking(Range(Complex128, 0, 24)), WithShape(2, 3, 4))
   587  	it, err := Tensor3C128(T)
   588  	if err != nil {
   589  		t.Fatal(err)
   590  	}
   591  
   592  	assert.Equal(2, len(it))
   593  	assert.Equal(3, len(it[0]))
   594  	assert.Equal(4, len(it[0][0]))
   595  }
   596  
   597  func Test_VectorStr(t *testing.T) {
   598  	assert := assert.New(t)
   599  	var T *Dense
   600  	T = New(Of(String), WithShape(6))
   601  	it, err := VectorStr(T)
   602  	if err != nil {
   603  		t.Fatal(err)
   604  	}
   605  
   606  	assert.Equal(6, len(it))
   607  }
   608  
   609  func Test_MatrixStr(t *testing.T) {
   610  	assert := assert.New(t)
   611  	var T *Dense
   612  	T = New(Of(String), WithShape(2, 3))
   613  	it, err := MatrixStr(T)
   614  	if err != nil {
   615  		t.Fatal(err)
   616  	}
   617  
   618  	assert.Equal(2, len(it))
   619  	assert.Equal(3, len(it[0]))
   620  }
   621  
   622  func Test_Tensor3Str(t *testing.T) {
   623  	assert := assert.New(t)
   624  	var T *Dense
   625  	T = New(Of(String), WithShape(2, 3, 4))
   626  	it, err := Tensor3Str(T)
   627  	if err != nil {
   628  		t.Fatal(err)
   629  	}
   630  
   631  	assert.Equal(2, len(it))
   632  	assert.Equal(3, len(it[0]))
   633  	assert.Equal(4, len(it[0][0]))
   634  }