github.com/mithrandie/csvq@v1.18.1/lib/query/aggregate_function_test.go (about)

     1  package query
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/mithrandie/csvq/lib/value"
     9  )
    10  
    11  type aggregateTests struct {
    12  	List   []value.Primary
    13  	Result value.Primary
    14  }
    15  
    16  var countTests = []aggregateTests{
    17  	{
    18  		List: []value.Primary{
    19  			value.NewInteger(2),
    20  			value.NewInteger(1),
    21  			value.NewInteger(1),
    22  			value.NewNull(),
    23  			value.NewInteger(4),
    24  			value.NewNull(),
    25  		},
    26  		Result: value.NewInteger(4),
    27  	},
    28  	{
    29  		List: []value.Primary{
    30  			value.NewNull(),
    31  		},
    32  		Result: value.NewInteger(0),
    33  	},
    34  }
    35  
    36  func TestCount(t *testing.T) {
    37  	for _, v := range countTests {
    38  		r := Count(v.List, TestTx.Flags)
    39  		if !reflect.DeepEqual(r, v.Result) {
    40  			t.Errorf("count list = %s: result = %s, want %s", v.List, r, v.Result)
    41  		}
    42  	}
    43  }
    44  
    45  var maxTests = []aggregateTests{
    46  	{
    47  		List: []value.Primary{
    48  			value.NewInteger(2),
    49  			value.NewInteger(1),
    50  			value.NewInteger(1),
    51  			value.NewNull(),
    52  			value.NewInteger(4),
    53  			value.NewNull(),
    54  		},
    55  		Result: value.NewInteger(4),
    56  	},
    57  	{
    58  		List: []value.Primary{
    59  			value.NewNull(),
    60  		},
    61  		Result: value.NewNull(),
    62  	},
    63  }
    64  
    65  func TestMax(t *testing.T) {
    66  	for _, v := range maxTests {
    67  		r := Max(v.List, TestTx.Flags)
    68  		if !reflect.DeepEqual(r, v.Result) {
    69  			t.Errorf("max list = %s: result = %s, want %s", v.List, r, v.Result)
    70  		}
    71  	}
    72  }
    73  
    74  var minTests = []aggregateTests{
    75  	{
    76  		List: []value.Primary{
    77  			value.NewInteger(2),
    78  			value.NewInteger(1),
    79  			value.NewInteger(1),
    80  			value.NewNull(),
    81  			value.NewInteger(4),
    82  			value.NewNull(),
    83  		},
    84  		Result: value.NewInteger(1),
    85  	},
    86  	{
    87  		List: []value.Primary{
    88  			value.NewNull(),
    89  		},
    90  		Result: value.NewNull(),
    91  	},
    92  }
    93  
    94  func TestMin(t *testing.T) {
    95  	for _, v := range minTests {
    96  		r := Min(v.List, TestTx.Flags)
    97  		if !reflect.DeepEqual(r, v.Result) {
    98  			t.Errorf("min list = %s: result = %s, want %s", v.List, r, v.Result)
    99  		}
   100  	}
   101  }
   102  
   103  var sumTests = []aggregateTests{
   104  	{
   105  		List: []value.Primary{
   106  			value.NewInteger(2),
   107  			value.NewInteger(1),
   108  			value.NewInteger(1),
   109  			value.NewNull(),
   110  			value.NewInteger(4),
   111  			value.NewNull(),
   112  		},
   113  		Result: value.NewFloat(8),
   114  	},
   115  	{
   116  		List: []value.Primary{
   117  			value.NewNull(),
   118  		},
   119  		Result: value.NewNull(),
   120  	},
   121  }
   122  
   123  func TestSum(t *testing.T) {
   124  	for _, v := range sumTests {
   125  		r := Sum(v.List, TestTx.Flags)
   126  		if !reflect.DeepEqual(r, v.Result) {
   127  			t.Errorf("sum list = %s: result = %s, want %s", v.List, r, v.Result)
   128  		}
   129  	}
   130  }
   131  
   132  var avgTests = []aggregateTests{
   133  	{
   134  		List: []value.Primary{
   135  			value.NewInteger(1),
   136  			value.NewInteger(1),
   137  			value.NewInteger(2),
   138  			value.NewNull(),
   139  			value.NewInteger(4),
   140  			value.NewNull(),
   141  		},
   142  		Result: value.NewFloat(2),
   143  	},
   144  	{
   145  		List: []value.Primary{
   146  			value.NewNull(),
   147  		},
   148  		Result: value.NewNull(),
   149  	},
   150  }
   151  
   152  func TestAvg(t *testing.T) {
   153  	for _, v := range avgTests {
   154  		r := Avg(v.List, TestTx.Flags)
   155  		if !reflect.DeepEqual(r, v.Result) {
   156  			t.Errorf("avg list = %s: result = %s, want %s", v.List, r, v.Result)
   157  		}
   158  	}
   159  }
   160  
   161  var stdEVTests = []aggregateTests{
   162  	{
   163  		List: []value.Primary{
   164  			value.NewInteger(1),
   165  			value.NewInteger(2),
   166  			value.NewInteger(3),
   167  			value.NewNull(),
   168  			value.NewInteger(4),
   169  			value.NewInteger(5),
   170  		},
   171  		Result: value.NewFloat(1.5811388300841898),
   172  	},
   173  	{
   174  		List: []value.Primary{
   175  			value.NewInteger(0),
   176  			value.NewInteger(0),
   177  		},
   178  		Result: value.NewFloat(0),
   179  	},
   180  	{
   181  		List: []value.Primary{
   182  			value.NewNull(),
   183  		},
   184  		Result: value.NewNull(),
   185  	},
   186  }
   187  
   188  func TestStdEV(t *testing.T) {
   189  	for _, v := range stdEVTests {
   190  		r := StdEV(v.List, TestTx.Flags)
   191  		if !reflect.DeepEqual(r, v.Result) {
   192  			t.Errorf("stdev list = %s: result = %s, want %s", v.List, r, v.Result)
   193  		}
   194  	}
   195  }
   196  
   197  var stdEVPTests = []aggregateTests{
   198  	{
   199  		List: []value.Primary{
   200  			value.NewInteger(1),
   201  			value.NewInteger(2),
   202  			value.NewInteger(3),
   203  			value.NewNull(),
   204  			value.NewInteger(4),
   205  			value.NewInteger(5),
   206  		},
   207  		Result: value.NewFloat(1.4142135623730951),
   208  	},
   209  	{
   210  		List: []value.Primary{
   211  			value.NewInteger(0),
   212  			value.NewInteger(0),
   213  		},
   214  		Result: value.NewFloat(0),
   215  	},
   216  	{
   217  		List: []value.Primary{
   218  			value.NewNull(),
   219  		},
   220  		Result: value.NewNull(),
   221  	},
   222  }
   223  
   224  func TestStdEVP(t *testing.T) {
   225  	for _, v := range stdEVPTests {
   226  		r := StdEVP(v.List, TestTx.Flags)
   227  		if !reflect.DeepEqual(r, v.Result) {
   228  			t.Errorf("stdevp list = %s: result = %s, want %s", v.List, r, v.Result)
   229  		}
   230  	}
   231  }
   232  
   233  var varTests = []aggregateTests{
   234  	{
   235  		List: []value.Primary{
   236  			value.NewInteger(1),
   237  			value.NewInteger(2),
   238  			value.NewInteger(3),
   239  			value.NewNull(),
   240  			value.NewInteger(4),
   241  			value.NewInteger(5),
   242  		},
   243  		Result: value.NewFloat(2.5),
   244  	},
   245  	{
   246  		List: []value.Primary{
   247  			value.NewInteger(0),
   248  			value.NewInteger(0),
   249  		},
   250  		Result: value.NewFloat(0),
   251  	},
   252  	{
   253  		List: []value.Primary{
   254  			value.NewNull(),
   255  		},
   256  		Result: value.NewNull(),
   257  	},
   258  }
   259  
   260  func TestVar(t *testing.T) {
   261  	for _, v := range varTests {
   262  		r := Var(v.List, TestTx.Flags)
   263  		if !reflect.DeepEqual(r, v.Result) {
   264  			t.Errorf("var list = %s: result = %s, want %s", v.List, r, v.Result)
   265  		}
   266  	}
   267  }
   268  
   269  var varPTests = []aggregateTests{
   270  	{
   271  		List: []value.Primary{
   272  			value.NewInteger(1),
   273  			value.NewInteger(2),
   274  			value.NewInteger(3),
   275  			value.NewNull(),
   276  			value.NewInteger(4),
   277  			value.NewInteger(5),
   278  		},
   279  		Result: value.NewFloat(2),
   280  	},
   281  	{
   282  		List: []value.Primary{
   283  			value.NewInteger(0),
   284  			value.NewInteger(0),
   285  		},
   286  		Result: value.NewFloat(0),
   287  	},
   288  	{
   289  		List: []value.Primary{
   290  			value.NewNull(),
   291  		},
   292  		Result: value.NewNull(),
   293  	},
   294  }
   295  
   296  func TestVarP(t *testing.T) {
   297  	for _, v := range varPTests {
   298  		r := VarP(v.List, TestTx.Flags)
   299  		if !reflect.DeepEqual(r, v.Result) {
   300  			t.Errorf("varp list = %s: result = %s, want %s", v.List, r, v.Result)
   301  		}
   302  	}
   303  }
   304  
   305  var medianTests = []aggregateTests{
   306  	{
   307  		List: []value.Primary{
   308  			value.NewInteger(1),
   309  			value.NewInteger(4),
   310  			value.NewInteger(6),
   311  			value.NewNull(),
   312  			value.NewInteger(1),
   313  			value.NewInteger(1),
   314  			value.NewInteger(2),
   315  			value.NewNull(),
   316  		},
   317  		Result: value.NewFloat(1.5),
   318  	},
   319  	{
   320  		List: []value.Primary{
   321  			value.NewInteger(1),
   322  			value.NewInteger(4),
   323  			value.NewInteger(6),
   324  			value.NewNull(),
   325  			value.NewInteger(1),
   326  			value.NewInteger(2),
   327  			value.NewNull(),
   328  		},
   329  		Result: value.NewFloat(2),
   330  	},
   331  	{
   332  		List: []value.Primary{
   333  			value.NewDatetime(time.Date(2012, 2, 3, 9, 18, 15, 0, GetTestLocation())),
   334  			value.NewDatetime(time.Date(2012, 2, 5, 9, 18, 15, 0, GetTestLocation())),
   335  		},
   336  		Result: value.NewFloat(float64(time.Date(2012, 2, 4, 9, 18, 15, 0, GetTestLocation()).UnixNano()) / 1e9),
   337  	},
   338  	{
   339  		List: []value.Primary{
   340  			value.NewNull(),
   341  		},
   342  		Result: value.NewNull(),
   343  	},
   344  }
   345  
   346  func TestMedian(t *testing.T) {
   347  	for _, v := range medianTests {
   348  		r := Median(v.List, TestTx.Flags)
   349  		if !reflect.DeepEqual(r, v.Result) {
   350  			t.Errorf("median list = %s: result = %s, want %s", v.List, r, v.Result)
   351  		}
   352  	}
   353  }
   354  
   355  var listAggTests = []struct {
   356  	List      []value.Primary
   357  	Separator string
   358  	Result    value.Primary
   359  }{
   360  	{
   361  		List: []value.Primary{
   362  			value.NewString("str1"),
   363  			value.NewString("str3"),
   364  			value.NewNull(),
   365  			value.NewString("str2"),
   366  			value.NewString("str1"),
   367  			value.NewString("str2"),
   368  		},
   369  		Separator: ",",
   370  		Result:    value.NewString("str1,str3,str2,str1,str2"),
   371  	},
   372  	{
   373  		List: []value.Primary{
   374  			value.NewNull(),
   375  		},
   376  		Separator: ",",
   377  		Result:    value.NewNull(),
   378  	},
   379  }
   380  
   381  func TestListAgg(t *testing.T) {
   382  	for _, v := range listAggTests {
   383  		r := ListAgg(v.List, v.Separator)
   384  		if !reflect.DeepEqual(r, v.Result) {
   385  			t.Errorf("Listagg list = %s: separator = %q, result = %s, want %s", v.List, v.Separator, r, v.Result)
   386  		}
   387  	}
   388  }
   389  
   390  var jsonAggTests = []struct {
   391  	List   []value.Primary
   392  	Result value.Primary
   393  }{
   394  	{
   395  		List:   []value.Primary{},
   396  		Result: value.NewNull(),
   397  	},
   398  	{
   399  		List: []value.Primary{
   400  			value.NewString("str3"),
   401  			value.NewNull(),
   402  			value.NewString("str2"),
   403  		},
   404  		Result: value.NewString("[\"str3\",null,\"str2\"]"),
   405  	},
   406  }
   407  
   408  func TestJsonAgg(t *testing.T) {
   409  	for _, v := range jsonAggTests {
   410  		r := JsonAgg(v.List)
   411  		if !reflect.DeepEqual(r, v.Result) {
   412  			t.Errorf("JsonAgg list = %s, result = %s, want %s", v.List, r, v.Result)
   413  		}
   414  	}
   415  }