github.com/google/syzkaller@v0.0.0-20251211124644-a066d2bc4b02/pkg/coveragedb/time_period_test.go (about)

     1  // Copyright 2024 syzkaller project authors. All rights reserved.
     2  // Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
     3  
     4  package coveragedb
     5  
     6  import (
     7  	"testing"
     8  	"time"
     9  
    10  	"cloud.google.com/go/civil"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestDayPeriodOps(t *testing.T) {
    15  	ops := &DayPeriodOps{}
    16  	d := civil.Date{Year: 2024, Month: time.February, Day: 20}
    17  	goodPeriod := TimePeriod{DateTo: d, Days: 1}
    18  	badPeriod := TimePeriod{DateTo: d, Days: 2}
    19  
    20  	assert.Equal(t, "2024-02-20", ops.lastPeriodDate(d).String())
    21  
    22  	assert.True(t, ops.IsValidPeriod(goodPeriod))
    23  	assert.False(t, ops.IsValidPeriod(badPeriod))
    24  
    25  	assert.Equal(t, 1, ops.pointedPeriodDays(d))
    26  
    27  	periods, err := GenNPeriodsTill(2, d, DayPeriod)
    28  	assert.NoError(t, err)
    29  	assert.Equal(t,
    30  		[]TimePeriod{
    31  			{DateTo: civil.Date{Year: 2024, Month: time.February, Day: 19}, Days: 1, Type: DayPeriod},
    32  			{DateTo: civil.Date{Year: 2024, Month: time.February, Day: 20}, Days: 1, Type: DayPeriod}},
    33  		periods)
    34  }
    35  
    36  func TestMonthPeriodOps(t *testing.T) {
    37  	ops := &MonthPeriodOps{}
    38  	midMonthDate := civil.Date{Year: 2024, Month: time.February, Day: 20}
    39  	goodPeriod := TimePeriod{DateTo: midMonthDate, Days: 29}
    40  	goodPeriod.DateTo.Day = goodPeriod.Days
    41  	badPeriod1 := goodPeriod
    42  	badPeriod1.DateTo.Day--
    43  	badPeriod2 := goodPeriod
    44  	badPeriod2.Days--
    45  
    46  	assert.Equal(t, "2024-02-29", ops.lastPeriodDate(midMonthDate).String())
    47  
    48  	assert.True(t, ops.IsValidPeriod(goodPeriod))
    49  	assert.False(t, ops.IsValidPeriod(badPeriod1))
    50  	assert.False(t, ops.IsValidPeriod(badPeriod2))
    51  
    52  	assert.Equal(t, 29, ops.pointedPeriodDays(midMonthDate))
    53  
    54  	periods, err := GenNPeriodsTill(2, goodPeriod.DateTo, MonthPeriod)
    55  	assert.NoError(t, err)
    56  	assert.Equal(t,
    57  		[]TimePeriod{
    58  			{DateTo: civil.Date{Year: 2024, Month: time.January, Day: 31}, Days: 31, Type: MonthPeriod},
    59  			{DateTo: civil.Date{Year: 2024, Month: time.February, Day: 29}, Days: 29, Type: MonthPeriod}},
    60  		periods,
    61  	)
    62  }
    63  
    64  func TestQuarterPeriodOps(t *testing.T) {
    65  	ops := &QuarterPeriodOps{}
    66  	midQuarterDate := civil.Date{Year: 2024, Month: time.February, Day: 20}
    67  	goodPeriod := TimePeriod{DateTo: midQuarterDate, Days: 31 + 29 + 31}
    68  	goodPeriod.DateTo.Month = time.March
    69  	goodPeriod.DateTo.Day = 31
    70  	badPeriod1 := goodPeriod
    71  	badPeriod1.DateTo.Day--
    72  	badPeriod2 := goodPeriod
    73  	badPeriod2.Days--
    74  
    75  	assert.Equal(t, "2024-03-31", ops.lastPeriodDate(midQuarterDate).String())
    76  
    77  	assert.True(t, ops.IsValidPeriod(goodPeriod))
    78  	assert.False(t, ops.IsValidPeriod(badPeriod1))
    79  	assert.False(t, ops.IsValidPeriod(badPeriod2))
    80  
    81  	assert.Equal(t, 31+29+31, ops.pointedPeriodDays(midQuarterDate))
    82  
    83  	periods, err := GenNPeriodsTill(2, goodPeriod.DateTo, QuarterPeriod)
    84  	assert.NoError(t, err)
    85  	assert.Equal(t,
    86  		[]TimePeriod{
    87  			{DateTo: civil.Date{Year: 2023, Month: time.December, Day: 31}, Days: 31 + 30 + 31, Type: QuarterPeriod},
    88  			{DateTo: civil.Date{Year: 2024, Month: time.March, Day: 31}, Days: 31 + 29 + 31, Type: QuarterPeriod}},
    89  		periods,
    90  	)
    91  }
    92  
    93  func TestPeriodsToMerge(t *testing.T) {
    94  	sampleDays := []TimePeriod{
    95  		makeTimePeriod("2024-04-01", 1),
    96  		makeTimePeriod("2024-04-02", 1),
    97  		makeTimePeriod("2024-05-03", 1),
    98  		makeTimePeriod("2024-05-04", 1),
    99  		makeTimePeriod("2024-06-05", 1),
   100  		makeTimePeriod("2024-06-06", 1),
   101  	}
   102  	sampleRows := []int64{1, 2, 4, 8, 16, 32}
   103  
   104  	tests := []struct {
   105  		name          string
   106  		srcDates      []TimePeriod
   107  		srcRows       []int64
   108  		mergedPeriods []TimePeriod
   109  		mergedRows    []int64
   110  		ops           periodOps
   111  		expected      []TimePeriod
   112  	}{
   113  		{
   114  			name:     "days/all_merged",
   115  			srcDates: sampleDays,
   116  			srcRows:  sampleRows,
   117  			mergedPeriods: []TimePeriod{
   118  				makeTimePeriod("2024-04-01", 1),
   119  				makeTimePeriod("2024-04-02", 1),
   120  				makeTimePeriod("2024-05-03", 1),
   121  				makeTimePeriod("2024-05-04", 1),
   122  				makeTimePeriod("2024-06-05", 1),
   123  				makeTimePeriod("2024-06-06", 1),
   124  			},
   125  			mergedRows: []int64{1, 2, 4, 8, 16, 32},
   126  			ops:        &DayPeriodOps{},
   127  			expected:   []TimePeriod{},
   128  		},
   129  		{
   130  			name:     "days/some_not_merged",
   131  			srcDates: sampleDays,
   132  			srcRows:  sampleRows,
   133  			mergedPeriods: []TimePeriod{
   134  				makeTimePeriod("2024-04-01", 1),
   135  				makeTimePeriod("2024-05-03", 1),
   136  				makeTimePeriod("2024-05-04", 1),
   137  				makeTimePeriod("2024-06-06", 1),
   138  			},
   139  			mergedRows: []int64{1, 4, 8, 32},
   140  			ops:        &DayPeriodOps{},
   141  			expected: []TimePeriod{
   142  				makeTimePeriod("2024-06-05", 1),
   143  				makeTimePeriod("2024-04-02", 1),
   144  			},
   145  		},
   146  		{
   147  			name:     "days/some_partially_merged",
   148  			srcDates: sampleDays,
   149  			srcRows:  sampleRows,
   150  			mergedPeriods: []TimePeriod{
   151  				makeTimePeriod("2024-04-01", 1),
   152  				makeTimePeriod("2024-04-02", 1),
   153  				makeTimePeriod("2024-05-03", 1),
   154  				makeTimePeriod("2024-05-04", 1),
   155  				makeTimePeriod("2024-06-05", 1),
   156  				makeTimePeriod("2024-06-06", 1),
   157  			},
   158  			mergedRows: []int64{1, 2, 1, 8, 16, 1},
   159  			ops:        &DayPeriodOps{},
   160  			expected: []TimePeriod{
   161  				makeTimePeriod("2024-06-06", 1),
   162  				makeTimePeriod("2024-05-03", 1),
   163  			},
   164  		},
   165  		{
   166  			name:     "months/all_merged",
   167  			srcDates: sampleDays,
   168  			srcRows:  sampleRows,
   169  			mergedPeriods: []TimePeriod{
   170  				makeTimePeriod("2024-04-30", 30),
   171  				makeTimePeriod("2024-05-31", 31),
   172  				makeTimePeriod("2024-06-30", 30),
   173  			},
   174  			mergedRows: []int64{3, 12, 48},
   175  			ops:        &MonthPeriodOps{},
   176  			expected:   []TimePeriod{},
   177  		},
   178  		{
   179  			name:     "months/some_not_merged",
   180  			srcDates: sampleDays,
   181  			srcRows:  sampleRows,
   182  			mergedPeriods: []TimePeriod{
   183  				makeTimePeriod("2024-04-30", 30),
   184  				makeTimePeriod("2024-05-31", 31),
   185  			},
   186  			mergedRows: []int64{3, 12},
   187  			ops:        &MonthPeriodOps{},
   188  			expected: []TimePeriod{
   189  				makeTimePeriod("2024-06-30", 30),
   190  			},
   191  		},
   192  		{
   193  			name:     "months/some_partially_merged",
   194  			srcDates: sampleDays,
   195  			srcRows:  sampleRows,
   196  			mergedPeriods: []TimePeriod{
   197  				makeTimePeriod("2024-04-30", 30),
   198  				makeTimePeriod("2024-05-31", 31),
   199  				makeTimePeriod("2024-06-30", 30),
   200  			},
   201  			mergedRows: []int64{1, 12, 1},
   202  			ops:        &MonthPeriodOps{},
   203  			expected: []TimePeriod{
   204  				makeTimePeriod("2024-06-30", 30),
   205  				makeTimePeriod("2024-04-30", 30),
   206  			},
   207  		},
   208  
   209  		{
   210  			name:     "quarter/all_merged",
   211  			srcDates: sampleDays,
   212  			srcRows:  sampleRows,
   213  			mergedPeriods: []TimePeriod{
   214  				makeTimePeriod("2024-06-30", 30+31+30),
   215  			},
   216  			mergedRows: []int64{63},
   217  			ops:        &QuarterPeriodOps{},
   218  			expected:   []TimePeriod{},
   219  		},
   220  		{
   221  			name:          "quarter/not_merged",
   222  			srcDates:      sampleDays,
   223  			srcRows:       sampleRows,
   224  			mergedPeriods: []TimePeriod{},
   225  			mergedRows:    []int64{},
   226  			ops:           &QuarterPeriodOps{},
   227  			expected: []TimePeriod{
   228  				makeTimePeriod("2024-06-30", 30+31+30),
   229  			},
   230  		},
   231  		{
   232  			name:     "quarter/partially_merged",
   233  			srcDates: sampleDays,
   234  			srcRows:  sampleRows,
   235  			mergedPeriods: []TimePeriod{
   236  				makeTimePeriod("2024-06-30", 30+31+30),
   237  			},
   238  			mergedRows: []int64{60},
   239  			ops:        &QuarterPeriodOps{},
   240  			expected: []TimePeriod{
   241  				makeTimePeriod("2024-06-30", 30+31+30),
   242  			},
   243  		},
   244  		{
   245  			name:     "quarters/not_all_merged_with_invalid_periods",
   246  			srcDates: append(sampleDays, makeTimePeriod("2024-01-01", 1)),
   247  			srcRows:  append(sampleRows, 128),
   248  			mergedPeriods: []TimePeriod{
   249  				makeTimePeriod("2024-03-31", 31+29+31),
   250  				makeTimePeriod("2024-06-30", 30+31+30),
   251  				makeTimePeriod("2024-01-10", 30),
   252  				makeTimePeriod("2024-01-20", 1),
   253  			},
   254  			mergedRows: []int64{128, 60, 1, 1},
   255  			ops:        &QuarterPeriodOps{},
   256  			expected: []TimePeriod{
   257  				makeTimePeriod("2024-06-30", 30+31+30),
   258  			},
   259  		},
   260  	}
   261  	for _, test := range tests {
   262  		t.Run(test.name, func(t *testing.T) {
   263  			assert.Equal(t, len(test.srcRows), len(test.srcDates))
   264  			actual := PeriodsToMerge(test.srcDates, test.mergedPeriods, test.srcRows, test.mergedRows, test.ops)
   265  			assert.Equal(t, test.expected, actual)
   266  		})
   267  	}
   268  }
   269  
   270  func makeTimePeriod(s string, days int) TimePeriod {
   271  	d, err := civil.ParseDate(s)
   272  	if err != nil {
   273  		panic(err.Error())
   274  	}
   275  	return TimePeriod{DateTo: d, Days: days}
   276  }
   277  
   278  func TestAtMostNLatestPeriods(t *testing.T) {
   279  	sampleDays := []TimePeriod{
   280  		makeTimePeriod("2024-04-01", 1),
   281  		makeTimePeriod("2024-04-02", 1),
   282  		makeTimePeriod("2024-05-03", 1),
   283  		makeTimePeriod("2024-05-04", 1),
   284  		makeTimePeriod("2024-06-05", 1),
   285  		makeTimePeriod("2024-06-06", 1),
   286  	}
   287  	assert.Equal(t, []TimePeriod{makeTimePeriod("2024-06-06", 1)}, AtMostNLatestPeriods(sampleDays, 1))
   288  	assert.Equal(t, sampleDays, AtMostNLatestPeriods(sampleDays, 100))
   289  }
   290  
   291  func TestMakeTimePeriod(t *testing.T) {
   292  	tp, err := MakeTimePeriod(civil.Date{Year: 2024, Month: time.March, Day: 31}, QuarterPeriod)
   293  	assert.NoError(t, err)
   294  	assert.NotEqual(t, TimePeriod{}, tp)
   295  
   296  	tp, err = MakeTimePeriod(civil.Date{Year: 2024, Month: time.March, Day: 30}, QuarterPeriod)
   297  	assert.Error(t, err)
   298  	assert.Equal(t, TimePeriod{}, tp)
   299  }