Fuzzing for boolean checks?

I have a function that checks if a string is a valid representation of an hexadecimal number ('0xdEAdBEef' and that sort of strings.) Now I have a check on isHexaString(string) which returns a bool that is false when it's not. But running go -fuzz=Fuzz with a bunch of seeds and they the checks with errors, I am not getting anything meaningful (no panics). Does that mean my code (isHexaString) is okay?

func FuzzIsHexAddress(f *testing.F) {
	testcases := []string{
		"0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed",
		"5aaeb6053f3e94c9b9a09f33669435e7ef1beaed",
		"0X5aaeb6053f3e94c9b9a09f33669435e7ef1beaed",
		"0XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
		"0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
	}
	for _, tc := range testcases {
		f.Add(tc) // Use f.Add to provide a seed corpus
	}

	f.Fuzz(func(t *testing.T, orig string) {
		if result := isHexaString(orig); !result {
			t.Errorf("IsHexAddress(%s) == %v",
				orig, result)
		}
	})
} 

What's the best way to fuzz test this type of unit tests?

Oh and running on one package only triggers the whole unit tests to be ran (must be a behaviour of Go to want to run unit tests first?)

I don't think this fuzz test is correct. This condition result := isHexaString(orig); !result evaluates to true when orig is not a valid hex string. So you are basically saying "fail when the input string is not a hex string". But why the test should fail then? If orig was indeed not a hex string, your function yielded the correct result: false.

The point is that you are not in control of the fuzz input (it is fuzzed!), therefore you should not rely on the output of the function under test alone to determine a pass or fail.

The fuzz tutorial suggests the example of a string reverse function:

rev := Reverse(orig)
doubleRev := Reverse(rev)
if orig != doubleRev {
    t.Errorf("Before: %q, after: %q", orig, doubleRev)
}

In this particular case Reverse is supposed to be an involution, i.e. the reverse of itself. Your function isHexaString is not an involution, and it doesn't even have an inverse (it's only surjective) but you can check its output against a golden standard, e.g. some other function that is known to always correctly identify valid hex strings.

Or, you can keep using the condition result := isHexaString(orig); !result to find interesting edge cases that are not hex strings and include those into your non-fuzzed unit test.