github.com/jpoly1219/gambas@v0.2.2/generator_test.go (about)

     1  package gambas
     2  
     3  import (
     4  	"math/rand"
     5  	"testing"
     6  
     7  	"github.com/google/go-cmp/cmp"
     8  )
     9  
    10  func BenchmarkGeneratorCreateRangeIndex(b *testing.B) {
    11  	for i := 0; i < b.N; i++ {
    12  		CreateRangeIndex(1000)
    13  	}
    14  }
    15  
    16  func TestGeneratorCreateRangeIndex(t *testing.T) {
    17  	type createRangeIndexTest struct {
    18  		arg1     int
    19  		expected IndexData
    20  	}
    21  
    22  	createRangeIndexTests := []createRangeIndexTest{
    23  		{
    24  			5,
    25  			IndexData{
    26  				[]Index{
    27  					{0, []interface{}{0}},
    28  					{1, []interface{}{1}},
    29  					{2, []interface{}{2}},
    30  					{3, []interface{}{3}},
    31  					{4, []interface{}{4}},
    32  				},
    33  				[]string{""},
    34  			},
    35  		},
    36  		{
    37  			10,
    38  			IndexData{
    39  				[]Index{
    40  					{0, []interface{}{0}},
    41  					{1, []interface{}{1}},
    42  					{2, []interface{}{2}},
    43  					{3, []interface{}{3}},
    44  					{4, []interface{}{4}},
    45  					{5, []interface{}{5}},
    46  					{6, []interface{}{6}},
    47  					{7, []interface{}{7}},
    48  					{8, []interface{}{8}},
    49  					{9, []interface{}{9}},
    50  				},
    51  				[]string{""},
    52  			},
    53  		},
    54  		{
    55  			1,
    56  			IndexData{
    57  				[]Index{{0, []interface{}{0}}},
    58  				[]string{""},
    59  			},
    60  		},
    61  	}
    62  
    63  	for _, test := range createRangeIndexTests {
    64  		output := CreateRangeIndex(test.arg1)
    65  		if !cmp.Equal(output, test.expected, cmp.AllowUnexported(IndexData{}, Index{})) {
    66  			t.Fatalf("expected %v, got %v", test.expected, output)
    67  		}
    68  	}
    69  }
    70  
    71  func BenchmarkGeneratorNewSeries(b *testing.B) {
    72  	data := make([]interface{}, 1000)
    73  	for i := 0; i < 1000; i++ {
    74  		data[i] = rand.Intn(1000)
    75  	}
    76  	b.ResetTimer()
    77  
    78  	for i := 0; i < b.N; i++ {
    79  		NewSeries(data, "Data", nil)
    80  	}
    81  }
    82  
    83  func TestGeneratorNewSeries(t *testing.T) {
    84  	type newSeriesTest struct {
    85  		arg1     []interface{}
    86  		arg2     string
    87  		arg3     *IndexData
    88  		expected Series
    89  	}
    90  
    91  	newSeriesTests := []newSeriesTest{
    92  		{
    93  			[]interface{}{"alice", "bob", "charlie"},
    94  			"People",
    95  			&IndexData{
    96  				[]Index{{0, []interface{}{0}}, {1, []interface{}{1}}, {2, []interface{}{2}}},
    97  				[]string{""},
    98  			},
    99  			Series{
   100  				[]interface{}{"alice", "bob", "charlie"},
   101  				IndexData{
   102  					[]Index{{0, []interface{}{0}}, {1, []interface{}{1}}, {2, []interface{}{2}}},
   103  					[]string{""},
   104  				},
   105  				"People",
   106  				"string",
   107  			},
   108  		},
   109  		{
   110  			[]interface{}{"apple", "banana", "cherry"},
   111  			"Fruit",
   112  			&IndexData{
   113  				[]Index{{0, []interface{}{0}}, {1, []interface{}{1}}, {2, []interface{}{2}}},
   114  				[]string{""},
   115  			},
   116  			Series{
   117  				[]interface{}{"apple", "banana", "cherry"},
   118  				IndexData{
   119  					[]Index{{0, []interface{}{0}}, {1, []interface{}{1}}, {2, []interface{}{2}}},
   120  					[]string{""},
   121  				},
   122  				"Fruit",
   123  				"string",
   124  			},
   125  		},
   126  		{
   127  			[]interface{}{"apple", 2, "cherry"},
   128  			"Fruit",
   129  			&IndexData{
   130  				[]Index{{0, []interface{}{0}}, {1, []interface{}{1}}, {2, []interface{}{2}}},
   131  				[]string{""},
   132  			},
   133  			Series{
   134  				[]interface{}{"apple", "2", "cherry"},
   135  				IndexData{
   136  					[]Index{{0, []interface{}{0}}, {1, []interface{}{1}}, {2, []interface{}{2}}},
   137  					[]string{""},
   138  				},
   139  				"Fruit",
   140  				"string",
   141  			},
   142  		},
   143  		{
   144  			[]interface{}{"alice", "bob", "charlie"},
   145  			"People",
   146  			&IndexData{
   147  				[]Index{{0, []interface{}{0, "female"}}, {1, []interface{}{1, "male"}}, {2, []interface{}{2, "male"}}},
   148  				[]string{"id", "sex"},
   149  			},
   150  			Series{
   151  				[]interface{}{"alice", "bob", "charlie"},
   152  				IndexData{
   153  					[]Index{{0, []interface{}{0, "female"}}, {1, []interface{}{1, "male"}}, {2, []interface{}{2, "male"}}},
   154  					[]string{"id", "sex"},
   155  				},
   156  				"People",
   157  				"string",
   158  			},
   159  		},
   160  	}
   161  
   162  	for _, test := range newSeriesTests {
   163  		output, err := NewSeries(test.arg1, test.arg2, test.arg3)
   164  		if !cmp.Equal(output, test.expected, cmp.AllowUnexported(Series{}, IndexData{}, Index{})) || (!cmp.Equal(output, Series{}, cmp.AllowUnexported(Series{}, IndexData{}, Index{})) && err != nil) {
   165  			t.Fatalf("expected %v, got %v, error %v", test.expected, output, err)
   166  		}
   167  	}
   168  }
   169  
   170  func BenchmarkGeneratorNewDataFrame(b *testing.B) {
   171  	data := make([][]interface{}, 5)
   172  	for i := 0; i < 5; i++ {
   173  		d := make([]interface{}, 1000)
   174  		for j := 0; j < 1000; j++ {
   175  			d[i] = rand.Intn(1000)
   176  		}
   177  		data[i] = d
   178  	}
   179  	b.ResetTimer()
   180  
   181  	for i := 0; i < b.N; i++ {
   182  		NewDataFrame(data, []string{"col1", "col2", "col3", "col4", "col5"}, []string{"col1"})
   183  	}
   184  }
   185  
   186  func TestGeneratorNewDataFrame(t *testing.T) {
   187  	type newDataFrameTest struct {
   188  		arg1     [][]interface{}
   189  		arg2     []string
   190  		arg3     []string
   191  		expected DataFrame
   192  	}
   193  
   194  	newDataFrameTests := []newDataFrameTest{
   195  		{
   196  			[][]interface{}{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}},
   197  			[]string{"group a", "group b", "group c"},
   198  			[]string{"group a"},
   199  			DataFrame{
   200  				[]Series{
   201  					{
   202  						[]interface{}{1, 2, 3},
   203  						IndexData{
   204  							[]Index{{0, []interface{}{1}}, {1, []interface{}{2}}, {2, []interface{}{3}}},
   205  							[]string{"group a"},
   206  						},
   207  						"group a",
   208  						"int",
   209  					},
   210  					{
   211  						[]interface{}{4, 5, 6},
   212  						IndexData{
   213  							[]Index{{0, []interface{}{1}}, {1, []interface{}{2}}, {2, []interface{}{3}}},
   214  							[]string{"group a"},
   215  						},
   216  						"group b",
   217  						"int",
   218  					},
   219  					{
   220  						[]interface{}{7, 8, 9},
   221  						IndexData{
   222  							[]Index{{0, []interface{}{1}}, {1, []interface{}{2}}, {2, []interface{}{3}}},
   223  							[]string{"group a"},
   224  						},
   225  						"group c",
   226  						"int",
   227  					},
   228  				},
   229  				IndexData{
   230  					[]Index{{0, []interface{}{1}}, {1, []interface{}{2}}, {2, []interface{}{3}}},
   231  					[]string{"group a"},
   232  				},
   233  				[]string{"group a", "group b", "group c"},
   234  			},
   235  		},
   236  		{
   237  			[][]interface{}{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}},
   238  			[]string{"group a", "group b", "group c"},
   239  			[]string{"group a", "group c"},
   240  			DataFrame{
   241  				[]Series{
   242  					{
   243  						[]interface{}{1, 2, 3},
   244  						IndexData{
   245  							[]Index{{0, []interface{}{1, 7}}, {1, []interface{}{2, 8}}, {2, []interface{}{3, 9}}},
   246  							[]string{"group a", "group c"},
   247  						},
   248  						"group a",
   249  						"int",
   250  					},
   251  					{
   252  						[]interface{}{4, 5, 6},
   253  						IndexData{
   254  							[]Index{{0, []interface{}{1, 7}}, {1, []interface{}{2, 8}}, {2, []interface{}{3, 9}}},
   255  							[]string{"group a", "group c"},
   256  						},
   257  						"group b",
   258  						"int",
   259  					},
   260  					{
   261  						[]interface{}{7, 8, 9},
   262  						IndexData{
   263  							[]Index{{0, []interface{}{1, 7}}, {1, []interface{}{2, 8}}, {2, []interface{}{3, 9}}},
   264  							[]string{"group a", "group c"},
   265  						},
   266  						"group c",
   267  						"int",
   268  					},
   269  				},
   270  				IndexData{
   271  					[]Index{{0, []interface{}{1, 7}}, {1, []interface{}{2, 8}}, {2, []interface{}{3, 9}}},
   272  					[]string{"group a", "group c"},
   273  				},
   274  				[]string{"group a", "group b", "group c"},
   275  			},
   276  		},
   277  		{
   278  			[][]interface{}{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}},
   279  			[]string{"group a", "group b", "group c"},
   280  			nil,
   281  			DataFrame{
   282  				[]Series{
   283  					{
   284  						[]interface{}{1, 2, 3},
   285  						IndexData{
   286  							[]Index{{0, []interface{}{0}}, {1, []interface{}{1}}, {2, []interface{}{2}}},
   287  							[]string{""},
   288  						},
   289  						"group a",
   290  						"int",
   291  					},
   292  					{
   293  						[]interface{}{4, 5, 6},
   294  						IndexData{
   295  							[]Index{{0, []interface{}{0}}, {1, []interface{}{1}}, {2, []interface{}{2}}},
   296  							[]string{""},
   297  						},
   298  						"group b",
   299  						"int",
   300  					},
   301  					{
   302  						[]interface{}{7, 8, 9},
   303  						IndexData{
   304  							[]Index{{0, []interface{}{0}}, {1, []interface{}{1}}, {2, []interface{}{2}}},
   305  							[]string{""},
   306  						},
   307  						"group c",
   308  						"int",
   309  					},
   310  				},
   311  				IndexData{
   312  					[]Index{{0, []interface{}{0}}, {1, []interface{}{1}}, {2, []interface{}{2}}},
   313  					[]string{""},
   314  				},
   315  				[]string{"group a", "group b", "group c"},
   316  			},
   317  		},
   318  	}
   319  
   320  	for _, test := range newDataFrameTests {
   321  		output, err := NewDataFrame(test.arg1, test.arg2, test.arg3)
   322  		if !cmp.Equal(output, test.expected, cmp.AllowUnexported(DataFrame{}, Series{}, IndexData{}, Index{})) || err != nil {
   323  			t.Fatalf("expected %v, got %v, error %v", test.expected, output, err)
   324  		}
   325  	}
   326  }
   327  
   328  func BenchmarkNewIndexData(b *testing.B) {
   329  
   330  }
   331  
   332  func TestNewIndexData(t *testing.T) {
   333  	type newIndexDataTest struct {
   334  		arg1     [][]interface{}
   335  		arg2     []string
   336  		expected IndexData
   337  	}
   338  	newIndexDataTests := []newIndexDataTest{
   339  		{
   340  			[][]interface{}{{"a"}, {"b"}, {"c"}, {"d"}, {"e"}},
   341  			[]string{"key"},
   342  			IndexData{
   343  				[]Index{
   344  					{0, []interface{}{"a"}},
   345  					{1, []interface{}{"b"}},
   346  					{2, []interface{}{"c"}},
   347  					{3, []interface{}{"d"}},
   348  					{4, []interface{}{"e"}},
   349  				},
   350  				[]string{"key"},
   351  			},
   352  		},
   353  		{
   354  			[][]interface{}{{"a", "blue"}, {"b", "yellow"}, {"c", "yellow"}, {"d", "red"}, {"e", "blue"}},
   355  			[]string{"key", "color"},
   356  			IndexData{
   357  				[]Index{
   358  					{0, []interface{}{"a", "blue"}},
   359  					{1, []interface{}{"b", "yellow"}},
   360  					{2, []interface{}{"c", "yellow"}},
   361  					{3, []interface{}{"d", "red"}},
   362  					{4, []interface{}{"e", "blue"}},
   363  				},
   364  				[]string{"key", "color"},
   365  			},
   366  		},
   367  	}
   368  	for _, test := range newIndexDataTests {
   369  		output, err := NewIndexData(test.arg1, test.arg2)
   370  		if !cmp.Equal(output, test.expected, cmp.AllowUnexported(Series{}, IndexData{}, Index{})) || err != nil {
   371  			t.Fatalf("expected: %v, got: %v, err: %v", test.expected, output, err)
   372  		}
   373  	}
   374  }