String html = renderer.render(parser.parseReader(inputStream));
            outputStream.write(html);
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

import org.robolectric.shadows.ShadowLog

@RunWith(RobolectricTestRunner::class)
class AndroidLoggingTest {
  val clientBuilder =
    OkHttpClient.Builder().connectionSpecs(listOf(ConnectionSpec.CLEARTEXT)).dns {
      throw UnknownHostException("shortcircuit")
    }

  val request = Request("http://google.com/robots.txt".toHttpUrl())

  @Test
  fun testHttpLoggingInterceptor() {
    val interceptor =

        .post(jsonRequestBody)
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

  public static void main(String... args) throws Exception {
    new RequestBodyCompression().run();

     * Create a new durable handle reconnect context
     * @param fileId the 16-byte file ID from the previous open
     */
    public DurableHandleReconnect(byte[] fileId) {
        if (fileId.length != 16) {
            throw new IllegalArgumentException("File ID must be 16 bytes");
        }
        this.fileId = Arrays.copyOf(fileId, 16);
    }

    @Override
    public byte[] getName() {
        return CONTEXT_NAME_BYTES;
    }

        }
        final int start = bufferIndex;

        this.nextEntryOffset = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        if (this.nextEntryOffset % 4 != 0) {
            throw new SMBProtocolDecodingException("Non aligned nextEntryOffset");
        }

        this.action = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        try {
            this.securityDescriptor = new SecurityDescriptor();
            bufferIndex += this.securityDescriptor.decode(buffer, bufferIndex, len);
        } catch (final IOException ioe) {
            throw new RuntimeCIFSException(ioe.getMessage());
        }

        return bufferIndex - start;
    }

    @Override
    public String toString() {

        jcifs.SID[] sids = null;
        // Expect NullPointerException when passing a null array to the constructor
        assertThrows(NullPointerException.class, () -> new LsarSidArrayX(sids),
                "Should throw NullPointerException when sids array is null");
    }

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.api.services;

import org.apache.maven.api.annotations.Experimental;

/**
 * The Exception class throw by the {@link ProjectBuilder} service.
 *
 * @since 4.0.0
 */
@Experimental
public class ModelBuilderException extends MavenException {

    private final ModelBuilderResult result;

    /**

                    if ("toString".equals(method.getName())) {
                        return value;
                    }
                    throw new UnsupportedOperationException();
                });
    }

            });

            validateNonNull("scm", model.getScm(), () -> validateString("scm.url", model.getScm().getUrl()));
        }
        if (foundError) {
            throw new GradleException("Check failed for task '" + getPath() + "', see console log for details");
        }
    }

    private void logError(String element, String message) {
        foundError = true;