github.com/google/syzkaller@v0.0.0-20251211124644-a066d2bc4b02/pkg/cover/heatmap_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 cover
     5  
     6  import (
     7  	"testing"
     8  	"time"
     9  
    10  	"cloud.google.com/go/civil"
    11  	"github.com/google/syzkaller/pkg/coveragedb"
    12  	"github.com/stretchr/testify/assert"
    13  )
    14  
    15  func TestFilesCoverageToTemplateData(t *testing.T) {
    16  	tests := []struct {
    17  		name  string
    18  		input []*coveragedb.FileCoverageWithDetails
    19  		want  *templateHeatmap
    20  	}{
    21  		{
    22  			name:  "empty input",
    23  			input: []*coveragedb.FileCoverageWithDetails{},
    24  			want: &templateHeatmap{
    25  				Root: &templateHeatmapRow{
    26  					IsDir: true,
    27  				},
    28  			},
    29  		},
    30  		{
    31  			name: "single file",
    32  			input: []*coveragedb.FileCoverageWithDetails{
    33  				{
    34  					Filepath:     "file1",
    35  					Instrumented: 1,
    36  					Covered:      1,
    37  					TimePeriod:   makeTimePeriod(t, civil.Date{Year: 2024, Month: time.July, Day: 1}, coveragedb.DayPeriod),
    38  					Commit:       "commit1",
    39  				},
    40  			},
    41  			want: &templateHeatmap{
    42  				Root: &templateHeatmapRow{
    43  					Items: []*templateHeatmapRow{
    44  						{
    45  							Name:     "file1",
    46  							Coverage: []int64{100},
    47  							Covered:  []int64{1},
    48  							IsDir:    false,
    49  							Depth:    0,
    50  							Summary:  1,
    51  							Tooltips: []string{
    52  								"Instrumented:\t1 blocks\nCovered:\t1 blocks",
    53  							},
    54  							FileCoverageLink: []string{
    55  								"/coverage/file?dateto=2024-07-01&period=day&commit=commit1&filepath=file1"},
    56  						},
    57  					},
    58  					Name:     "",
    59  					Coverage: []int64{100},
    60  					Covered:  []int64{1},
    61  					IsDir:    true,
    62  					Depth:    0,
    63  					Summary:  1,
    64  					Tooltips: []string{
    65  						"Instrumented:\t1 blocks\nCovered:\t1 blocks",
    66  					},
    67  				},
    68  				Periods: []string{"2024-07-01(1)"},
    69  			},
    70  		},
    71  		{
    72  			name: "tree data",
    73  			input: []*coveragedb.FileCoverageWithDetails{
    74  				{
    75  					Filepath:     "dir/file2",
    76  					Instrumented: 1,
    77  					Covered:      0,
    78  					TimePeriod:   makeTimePeriod(t, civil.Date{Year: 2024, Month: time.July, Day: 2}, coveragedb.DayPeriod),
    79  					Commit:       "commit2",
    80  				},
    81  				{
    82  					Filepath:     "dir/file1",
    83  					Instrumented: 1,
    84  					Covered:      1,
    85  					TimePeriod:   makeTimePeriod(t, civil.Date{Year: 2024, Month: time.July, Day: 1}, coveragedb.DayPeriod),
    86  					Commit:       "commit1",
    87  				},
    88  			},
    89  			want: &templateHeatmap{
    90  				Root: &templateHeatmapRow{
    91  					Items: []*templateHeatmapRow{
    92  						{
    93  							Items: []*templateHeatmapRow{
    94  								{
    95  									Name:     "file1",
    96  									Coverage: []int64{100, 0},
    97  									Covered:  []int64{1, 0},
    98  									IsDir:    false,
    99  									Depth:    1,
   100  									Summary:  0,
   101  									Tooltips: []string{
   102  										"Instrumented:\t1 blocks\nCovered:\t1 blocks",
   103  										"Instrumented:\t0 blocks\nCovered:\t0 blocks",
   104  									},
   105  									FileCoverageLink: []string{
   106  										"/coverage/file?dateto=2024-07-01&period=day&commit=commit1&filepath=dir/file1",
   107  										"/coverage/file?dateto=2024-07-02&period=day&commit=commit2&filepath=dir/file1"},
   108  								},
   109  								{
   110  									Name:     "file2",
   111  									Coverage: []int64{0, 0},
   112  									Covered:  []int64{0, 0},
   113  									IsDir:    false,
   114  									Depth:    1,
   115  									Summary:  1,
   116  									Tooltips: []string{
   117  										"Instrumented:\t0 blocks\nCovered:\t0 blocks",
   118  										"Instrumented:\t1 blocks\nCovered:\t0 blocks",
   119  									},
   120  									FileCoverageLink: []string{
   121  										"/coverage/file?dateto=2024-07-01&period=day&commit=commit1&filepath=dir/file2",
   122  										"/coverage/file?dateto=2024-07-02&period=day&commit=commit2&filepath=dir/file2"},
   123  								},
   124  							},
   125  							Name:     "dir",
   126  							Coverage: []int64{100, 0},
   127  							Covered:  []int64{1, 0},
   128  							IsDir:    true,
   129  							Depth:    0,
   130  							Summary:  1,
   131  							Tooltips: []string{
   132  								"Instrumented:\t1 blocks\nCovered:\t1 blocks",
   133  								"Instrumented:\t1 blocks\nCovered:\t0 blocks",
   134  							},
   135  						},
   136  					},
   137  					Name:     "",
   138  					Coverage: []int64{100, 0},
   139  					Covered:  []int64{1, 0},
   140  					Summary:  1,
   141  					Tooltips: []string{
   142  						"Instrumented:\t1 blocks\nCovered:\t1 blocks",
   143  						"Instrumented:\t1 blocks\nCovered:\t0 blocks",
   144  					},
   145  					IsDir: true,
   146  				},
   147  				Periods: []string{"2024-07-01(1)", "2024-07-02(1)"},
   148  			},
   149  		},
   150  	}
   151  	for _, test := range tests {
   152  		t.Run(test.name, func(t *testing.T) {
   153  			got := FilesCoverageToTemplateData(test.input)
   154  			assert.EqualExportedValues(t, test.want, got)
   155  		})
   156  	}
   157  }
   158  
   159  // nolint: dupl
   160  func TestFormatResult(t *testing.T) {
   161  	tests := []struct {
   162  		name   string
   163  		sample *templateHeatmap
   164  		input  Format
   165  		want   *templateHeatmap
   166  	}{
   167  		{
   168  			name: "remove empty",
   169  			input: Format{
   170  				DropCoveredLines0: true,
   171  			},
   172  			sample: &templateHeatmap{
   173  				Root: &templateHeatmapRow{
   174  					Items: []*templateHeatmapRow{
   175  						{
   176  							Items: []*templateHeatmapRow{
   177  								{
   178  									Name:    "file1",
   179  									Covered: []int64{0, 0},
   180  									Depth:   1,
   181  								},
   182  								{
   183  									Name:    "file2",
   184  									Covered: []int64{1, 0},
   185  									Depth:   1,
   186  								},
   187  							},
   188  							Name:    "dir",
   189  							Covered: []int64{1, 0},
   190  							IsDir:   true,
   191  						},
   192  					},
   193  					Covered: []int64{1, 0},
   194  					IsDir:   true,
   195  				},
   196  			},
   197  			want: &templateHeatmap{
   198  				Root: &templateHeatmapRow{
   199  					Items: []*templateHeatmapRow{
   200  						{
   201  							Items: []*templateHeatmapRow{
   202  								{
   203  									Name:    "file2",
   204  									Covered: []int64{1, 0},
   205  									Depth:   1,
   206  								},
   207  							},
   208  							Name:    "dir",
   209  							Covered: []int64{1, 0},
   210  							IsDir:   true,
   211  						},
   212  					},
   213  					Covered: []int64{1, 0},
   214  					IsDir:   true,
   215  				},
   216  			},
   217  		},
   218  		{
   219  			name: "remove small lines drop",
   220  			input: Format{
   221  				FilterMinCoveredLinesDrop: 10,
   222  			},
   223  			sample: &templateHeatmap{
   224  				Root: &templateHeatmapRow{
   225  					Items: []*templateHeatmapRow{
   226  						{
   227  							Items: []*templateHeatmapRow{
   228  								{
   229  									Name:    "file1",
   230  									Covered: []int64{5, 0},
   231  									Depth:   1,
   232  								},
   233  								{
   234  									Name:    "file2",
   235  									Covered: []int64{10, 0},
   236  									Depth:   1,
   237  								},
   238  							},
   239  							Name:    "dir",
   240  							Covered: []int64{1, 1},
   241  							IsDir:   true,
   242  						},
   243  					},
   244  					Covered: []int64{1, 1},
   245  					IsDir:   true,
   246  				},
   247  			},
   248  			want: &templateHeatmap{
   249  				Root: &templateHeatmapRow{
   250  					Items: []*templateHeatmapRow{
   251  						{
   252  							Items: []*templateHeatmapRow{
   253  								{
   254  									Name:    "file2",
   255  									Covered: []int64{10, 0},
   256  									Depth:   1,
   257  								},
   258  							},
   259  							Name:    "dir",
   260  							Covered: []int64{1, 1},
   261  							IsDir:   true,
   262  						},
   263  					},
   264  					Covered: []int64{1, 1},
   265  					IsDir:   true,
   266  				},
   267  			},
   268  		},
   269  		{
   270  			name: "order by the lines drop",
   271  			input: Format{
   272  				OrderByCoveredLinesDrop: true,
   273  			},
   274  			sample: &templateHeatmap{
   275  				Root: &templateHeatmapRow{
   276  					Items: []*templateHeatmapRow{
   277  						{
   278  							Items: []*templateHeatmapRow{
   279  								{
   280  									Name:    "file1",
   281  									Covered: []int64{5, 0},
   282  									Depth:   1,
   283  								},
   284  								{
   285  									Name:    "file2",
   286  									Covered: []int64{10, 0},
   287  									Depth:   1,
   288  								},
   289  							},
   290  							Name:    "dir",
   291  							Covered: []int64{1, 1},
   292  							IsDir:   true,
   293  						},
   294  					},
   295  					Covered: []int64{1, 1},
   296  					IsDir:   true,
   297  				},
   298  			},
   299  			want: &templateHeatmap{
   300  				Root: &templateHeatmapRow{
   301  					Items: []*templateHeatmapRow{
   302  						{
   303  							Items: []*templateHeatmapRow{
   304  								{
   305  									Name:    "file2",
   306  									Covered: []int64{10, 0},
   307  									Depth:   1,
   308  									Summary: -10,
   309  								},
   310  								{
   311  									Name:    "file1",
   312  									Covered: []int64{5, 0},
   313  									Depth:   1,
   314  									Summary: -5,
   315  								},
   316  							},
   317  							Name:    "dir",
   318  							Covered: []int64{1, 1},
   319  							IsDir:   true,
   320  							Summary: -15,
   321  						},
   322  					},
   323  					Covered: []int64{1, 1},
   324  					IsDir:   true,
   325  					Summary: -15,
   326  				},
   327  			},
   328  		},
   329  	}
   330  	for _, test := range tests {
   331  		t.Run(test.name, func(t *testing.T) {
   332  			FormatResult(test.sample, test.input)
   333  			assert.Equal(t, test.want, test.sample)
   334  		})
   335  	}
   336  }
   337  
   338  func makeTimePeriod(t *testing.T, targetDate civil.Date, periodType string) coveragedb.TimePeriod {
   339  	tp, err := coveragedb.MakeTimePeriod(targetDate, periodType)
   340  	assert.NoError(t, err)
   341  	return tp
   342  }