)

	msgs := diag.Messages{firstMsg, secondMsg}
	output, _ := Print(msgs, YAMLFormat, false)

	expectedOutput := `- code: B1
  documentationUrl: ` + url.ConfigAnalysis + `/b1/
  level: Error
  message: 'Explosion accident: the bubble is too big'
  origin: SoapBubble
- code: C1
  documentationUrl: ` + url.ConfigAnalysis + `/c1/
  level: Warning
  message: 'Collapse danger: the castle is too old'

// client and ignore messages sent to the server. The received messages are
// the exact bytes written to the stream. Zero byte messages are possible.
const binaryWebSocketProtocol = "binary.k8s.io"

// The WebSocket subprotocol "base64.binary.k8s.io" will only send messages to the
// client and ignore messages sent to the server. The received messages are

            description.appendText("was a ProjectBuildingResult with messages ");
            String messages = r.getProblems().stream()
                    .map(ModelProblem::getMessage)
                    .map(m -> "\"" + m + "\"" + System.lineSeparator())
                    .collect(joining(", "));
            description.appendText(messages);
        }
    }

 * a greeting. The greeting is composed of a message and a suffix. The message is compiled into a support
 * library. The suffix is compiled directly into the processor. This makes it easy to test different incremental
 * change scenarios. The message can also be provided with the -Amessage processor argument.
 */
@CompileStatic
class HelperProcessorFixture extends AnnotationProcessorFixture {
    String message = "greetings"
    boolean writeResources

                upgradeFromAll();

                saveInfo(messages -> messages.addSuccessStartedDataUpdate(GLOBAL));

                systemHelper.reloadConfiguration();
            } catch (final Exception e) {
                logger.warn("Failed to upgrade data.", e);
                saveError(messages -> messages.addErrorsFailedToUpgradeFrom(GLOBAL, VERSION_13_0, e.getLocalizedMessage()));
            }

   * messages.
   */
  open fun onOpen(
    webSocket: WebSocket,
    response: Response,
  ) {
  }

  /** Invoked when a text (type `0x1`) message has been received. */
  open fun onMessage(
    webSocket: WebSocket,
    text: String,
  ) {
  }

  /** Invoked when a binary (type `0x2`) message has been received. */
  open fun onMessage(

		return err
	}
	return c.RouteDiff()
}

// nonstrictResolver is an AnyResolver that ignores unknown proto messages
type nonstrictResolver struct{}

var envoyResolver nonstrictResolver

func (m *nonstrictResolver) Resolve(typeURL string) (legacyproto.Message, error) {
	// See https://github.com/golang/protobuf/issues/747#issuecomment-437463120
	mname := typeURL

        result.logLevel == LogLevel.LIFECYCLE
        result.message == MESSAGE
        result.throwable.getClass() == event.throwable.getClass()
        result.throwable.message == event.throwable.message
        result.throwable.stackTrace == event.throwable.stackTrace
        result.buildOperationId == new OperationIdentifier(42L)
    }

    def "can serialize LogEvent messages"() {
        when:

		json.Unmarshal([]byte(srv.messages[0]), &got[0])
		json.Unmarshal([]byte(srv.messages[1]), &got[1])
		if !reflect.DeepEqual(got, want) {
			t.Errorf("received log messages, got %v want %v", got, want)
		}
	}

	{
		t.Log("test sending log with specified time")

		// Clean up all the mssages, and log again. Check that buffer is cleaned up properly.
		srv.messages = make([]string, 0)

                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsFailedToUploadMappingFile(GLOBAL),
                        () -> redirectWith(getClass(), moreUrl("uploadpage/" + form.dictId)));
            }
            saveInfo(messages -> messages.addSuccessUploadMappingFile(GLOBAL));