func (i *istiodContext) Report(c config.GroupVersionKind, m diag.Message) {
	msgs := i.messages[i.currentAnalyzer]
	if msgs == nil {
		msgs = &diag.Messages{}
		i.messages[i.currentAnalyzer] = msgs
	}
	msgs.Add(m)
}

func (i *istiodContext) SetAnalyzer(analyzerName string) {
	i.currentAnalyzer = analyzerName
}

func (i *istiodContext) GetMessages(analyzerNames ...string) diag.Messages {
	result := diag.Messages{}

     *
     * @throws MojoExecutionException if an unexpected problem occurs.
     * Throwing this exception causes a "BUILD ERROR" message to be displayed.
     * @throws MojoFailureException if an expected problem (such as a compilation failure) occurs.
     * Throwing this exception causes a "BUILD FAILURE" message to be displayed.
     */
    void execute() throws MojoExecutionException, MojoFailureException;

    /**

		{"nil pointer dereference #1", "", func() { _ = x == *p }},
		// TODO(mdempsky): Restore "nil pointer dereference" check. The Go
		// spec doesn't mandate an order for panics (or even panic
		// messages), but left-to-right is less confusing to users.
		{"nil pointer dereference #2", "", func() { _ = *l == r[0] }},
		{"nil pointer dereference #3", "", func() { _ = *l == any(r[0]) }},
	}

	for _, tc := range tests {

 * limitations under the License.
 */

package org.gradle.api.internal.tasks.compile.processing;

import javax.annotation.processing.Filer;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import java.util.Locale;
import java.util.Map;

 */
public interface DocLink extends Serializable {

    /**
     * The URL to the documentation page.
     */
    String getUrl();

    /**
     * A message that tells the user to consult the documentation.
     * There are currently 2 different messages used for this, hence this method.
     */
    String getConsultDocumentationMessage();

    }

    void assertFailureDescriptionOrCauseContains(String... messages) {
        try {
            messages.each { failureDescriptionContains(it) }
        } catch (AssertionError ignore) {
            messages.each { failureCauseContains(it) }
        }
    }

// be the result of hashing the input message using the given hash
// function. If hash is zero, hashed is signed directly. This isn't
// advisable except for interoperability.
//
// The random parameter is legacy and ignored, and it can be nil.
//
// This function is deterministic. Thus, if the set of possible
// messages is small, an attacker may be able to build a map from

    final Dispatch<InterHubMessage> queue = Mock()

    def "does nothing when no stateful messages received"() {
        when:
        initializer.onQueueAdded(queue)

        then:
        0 * queue._
    }

    def "discards message on end of stream received"() {
        given:
        def closed = new EndOfStream()

        initializer.onStatefulMessage(closed)

// license that can be found in the LICENSE file.

// This file implements support functions for error messages.

package types2

// lookupError returns a case-specific error when a lookup of selector sel in the
// given type fails but an object with alternative spelling (case folding) is found.
// If structLit is set, the error message is specifically for struct literal fields.

	OpDisconnectServerMux

	// OpMuxClientMsg contains a message to a client Mux
	OpMuxClientMsg

	// OpMuxServerMsg contains a message to a server Mux
	OpMuxServerMsg

	// OpUnblockSrvMux contains a message that a server mux is unblocked with one.
	// Only Stateful streams has flow control.
	OpUnblockSrvMux

	// OpUnblockClMux contains a message that a client mux is unblocked with one.