if err == nil {
		return false
	}
	if e, ok := err.(*StorageError); ok {
		return e.Code == code
	}
	return false
}

// InvalidError is generated when an error caused by invalid API object occurs
// in the storage package.
type InvalidError struct {
	Errs field.ErrorList
}

func (e InvalidError) Error() string {
	return e.Errs.ToAggregate().Error()
}

    final String description;
    final List<String> causes;

    public AbstractFailure(String description, List<String> causes) {
        this.description = description;
        this.causes = causes;
    }

    @Override
    public void assertHasCause(String message) {
        if (!causes.contains(message)) {
            throw new AssertionFailedError(String.format("Expected cause '%s' not found in %s", message, causes));
        }

    private final TestFailureDetails details;

    private final List<TestFailure> causes;

    public DefaultTestFailure(Throwable rawFailure, TestFailureDetails details, List<TestFailure> causes) {
        this.rawFailure = rawFailure;
        this.details = details;
        this.causes = causes;
    }

    @Override
    public Throwable getRawFailure() {
        return rawFailure;
    }

    constructor(
        message: String,
        causes: List<Throwable>,
        summary: () -> String
    ) : super(
        { "$message\n${summary()}" },
        causes
    )

    internal
    constructor(
        causes: List<Throwable>,
        summary: () -> String
    ) : this(
        "Configuration cache problems found in this build.",
        causes,
        summary
    )
}

                causes.add(node);
            }
        });
        return causes;
    }

    public void accept(ExceptionContextVisitor contextVisitor) {
        Throwable cause = getCause();
        if (cause != null) {
            contextVisitor.visitCause(cause);
            visitCauses(cause, contextVisitor);
        }
        contextVisitor.endVisiting();
    }

			panic("these inputs caused a crash!")
		}
	})
}

func FuzzInt(f *testing.F) {
	f.Add(0)
	f.Fuzz(func(t *testing.T, a int) {
		if a != 0 {
			panic("this input caused a crash!")
		}
	})
}

func FuzzUint(f *testing.F) {
	f.Add(uint(0))
	f.Fuzz(func(t *testing.T, a uint) {
		if a != 0 {
			panic("this input caused a crash!")
		}
	})
}

    public List<? extends Failure> getCauses() {
        return causes;
    }

    public static DefaultFailure fromThrowable(Throwable t) {
        StringWriter out = new StringWriter();
        PrintWriter wrt = new PrintWriter(out);
        t.printStackTrace(wrt);
        Throwable cause = t.getCause();
        DefaultFailure causeFailure = cause != null && cause != t ? fromThrowable(cause) : null;

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//

    /**
     * Any file name change in the watched directory or subtree causes a change notification wait operation to return.
     * Changes include renaming, creating, or deleting a file.
     */
    public static final int FILE_NOTIFY_CHANGE_FILE_NAME = 0x00000001;

    /**
     * Any directory-name change in the watched directory or subtree causes a change notification wait operation to

public class MultipleBuildFailures extends DefaultMultiCauseException {
    public MultipleBuildFailures(Collection<? extends Throwable> causes) {
        super("Build completed with " + causes.size() + " failures.", causes);
    }

    public void replaceCauses(List<? extends Throwable> causes) {
        super.initCauses(causes);
    }