github.com/google/syzkaller@v0.0.0-20251211124644-a066d2bc4b02/syz-verifier/utils_test.go (about)

     1  // Copyright 2021 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  // TODO: switch syz-verifier to use syz-fuzzer.
     5  
     6  //go:build ignore
     7  
     8  package main
     9  
    10  import (
    11  	"testing"
    12  
    13  	"github.com/google/syzkaller/pkg/ipc"
    14  	"github.com/google/syzkaller/pkg/osutil"
    15  	"github.com/google/syzkaller/prog"
    16  )
    17  
    18  func createTestVerifier(t *testing.T) *Verifier {
    19  	target, err := prog.GetTarget("test", "64")
    20  	if err != nil {
    21  		t.Fatalf("failed to initialise test target: %v", err)
    22  	}
    23  	vrf := &Verifier{
    24  		target:      target,
    25  		choiceTable: target.DefaultChoiceTable(),
    26  		progIdx:     3,
    27  		reruns:      1,
    28  	}
    29  	vrf.resultsdir = makeTestResultDirectory(t)
    30  	vrf.stats = emptyTestStats()
    31  	vrf.srv, err = startRPCServer(vrf)
    32  	if err != nil {
    33  		t.Fatalf("failed to initialise RPC server: %v", err)
    34  	}
    35  	return vrf
    36  }
    37  
    38  func getTestProgram(t *testing.T) *prog.Prog {
    39  	p := "breaks_returns()\n" +
    40  		"minimize$0(0x1, 0x1)\n" +
    41  		"test$res0()\n"
    42  	target := prog.InitTargetTest(t, "test", "64")
    43  	prog, err := target.Deserialize([]byte(p), prog.Strict)
    44  	if err != nil {
    45  		t.Fatalf("failed to deserialise test program: %v", err)
    46  	}
    47  	return prog
    48  }
    49  
    50  func makeTestResultDirectory(t *testing.T) string {
    51  	return osutil.Abs(t.TempDir())
    52  }
    53  
    54  func makeExecResult(pool int, errnos []int, flags ...int) *ExecResult {
    55  	r := &ExecResult{Pool: pool, Info: ipc.ProgInfo{Calls: []ipc.CallInfo{}}}
    56  	for _, e := range errnos {
    57  		r.Info.Calls = append(r.Info.Calls, ipc.CallInfo{Errno: e})
    58  	}
    59  
    60  	for idx, f := range flags {
    61  		r.Info.Calls[idx].Flags = ipc.CallFlags(f)
    62  	}
    63  	return r
    64  }
    65  
    66  func makeExecResultCrashed(pool int) *ExecResult {
    67  	return &ExecResult{Pool: pool, Crashed: true}
    68  }
    69  
    70  func emptyTestStats() *Stats {
    71  	return (&Stats{
    72  		Calls: StatMapStringToCallStats{
    73  			mapStringToCallStats: mapStringToCallStats{
    74  				"breaks_returns": {Name: "breaks_returns", States: map[ReturnState]bool{}},
    75  				"minimize$0":     {Name: "minimize$0", States: map[ReturnState]bool{}},
    76  				"test$res0":      {Name: "test$res0", States: map[ReturnState]bool{}},
    77  			},
    78  		},
    79  	}).Init()
    80  }
    81  
    82  func makeCallStats(name string, occurrences, mismatches uint64, states map[ReturnState]bool) *CallStats {
    83  	return &CallStats{Name: name,
    84  		Occurrences: occurrences,
    85  		Mismatches:  mismatches,
    86  		States:      states}
    87  }
    88  
    89  func returnState(errno int, flags ...int) ReturnState {
    90  	rs := ReturnState{Errno: errno}
    91  	if flags != nil {
    92  		rs.Flags = ipc.CallFlags(flags[0])
    93  	}
    94  	return rs
    95  }
    96  
    97  func crashedReturnState() ReturnState {
    98  	return ReturnState{Crashed: true}
    99  }