},
                                "title": "Location",
                                "type": "array",
                            },
                            "msg": {"title": "Message", "type": "string"},
                            "type": {"title": "Error Type", "type": "string"},
                        },
                        "required": ["loc", "msg", "type"],

                                },
                                "title": "Location",
                                "type": "array",
                            },
                            "msg": {"title": "Message", "type": "string"},
                            "type": {"title": "Error Type", "type": "string"},
                        },
                        "required": ["loc", "msg", "type"],

      String... expectedMessages) {
    try {
      tester.testForwarding(interfaceType, wrapperFunction);
    } catch (AssertionFailedError expected) {
      for (String message : expectedMessages) {
        assertThat(expected).hasMessageThat().contains(message);
      }
      return;
    }
    fail("expected failure not reported");
  }

  private static class ForwardingRunnable implements Runnable {

                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
                                },
                            },
                            "msg": {"title": "Message", "type": "string"},
                            "type": {"title": "Error Type", "type": "string"},
                        },
                    },
                }
            },
        }

        StringBuilder buffer = new StringBuilder(256);
        buffer.append('\'').append(fieldName).append('\'');

        if (sourceHint != null) {
            buffer.append(" for ").append(sourceHint);
        }

        buffer.append(' ').append(message);

        problems.add(severity, buffer.toString(), -1, -1, null);
    }

			err = msgp.WrapError(err)
			return
		}
		(*z) = ChecksumAlgo(zb0001)
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z ChecksumAlgo) Msgsize() (s int) {
	s = msgp.Uint8Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *ErasureAlgo) DecodeMsg(dc *msgp.Reader) (err error) {
	{
		var zb0001 uint8

                    source.put("hostname", hostname);
                    source.put("level", event.getLevel());
                    source.put("loggerName", event.getLoggerName());
                    source.put("message", event.getMessage());
                    source.put("throwable", event.getThrowable() != null ? event.getThrowable() : "");
                    source.put("timestamp", event.getTimestamp());

import jcifs.internal.fscc.FileSystemInformation;
import jcifs.internal.smb1.trans.SmbComTransaction;
import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;

/**
 * Trans2 QueryFSInformation request message for querying file system information.
 * This class implements the TRANS2_QUERY_FS_INFORMATION transaction to retrieve
 * various file system attributes such as volume information, size, and capabilities.
 */

  }

  @Test
  fun hasBody() {
    val request = Request.Builder().url("http://example.com").build()
    val response =
      Response
        .Builder()
        .code(200)
        .message("OK")
        .request(request)
        .protocol(Protocol.HTTP_2)
        .build()
    assertTrue(hasBody(response))
  }

                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
                                },
                            },
                            "msg": {"title": "Message", "type": "string"},
                            "type": {"title": "Error Type", "type": "string"},
                            "input": {"title": "Input"},
                            "ctx": {"title": "Context", "type": "object"},