try {
      UnsignedInts.parseUnsignedInt("0", Character.MIN_RADIX - 1);
      fail();
    } catch (NumberFormatException expected) {
    } catch (IllegalArgumentException expected) {
      // Kotlin native, see above
    }

    try {
      UnsignedInts.parseUnsignedInt("0", Character.MAX_RADIX + 1);
      fail();
    } catch (NumberFormatException expected) {
    } catch (IllegalArgumentException expected) {

        client.setRequestListener(testListener);
        final String url = "http://test.com/";
        try {
            client.execute(RequestDataBuilder.newRequestData().get().url(url).build());
            fail();
        } catch (final MultipleCrawlingAccessException e) {
            // ok
            final Throwable[] causes = e.getCauses();
            assertEquals(5, causes.length);
        }

            lhaExtractor.getText(in, null);
            fail();
        } catch (MaxLengthExceededException e) {
            // pass
        }
        lhaExtractor.setMaxContentSize(-1);
    }

    public void test_getText_null() {
        try {
            lhaExtractor.getText(null, null);
            fail();
        } catch (final CrawlerSystemException e) {
            // NOP
        }

import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.Response
import okhttp3.TestUtil.assumeNotWindows
import okhttp3.testing.PlatformRule
import org.junit.jupiter.api.Assertions.fail
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension

@Suppress("ktlint:standard:max-line-length")
class LoggingEventListenerTest {

		}
	}

	// Tests hashing order to fail for when order is '-1'.
	if hashedOrder := hashOrder("This will fail", -1); hashedOrder != nil {
		t.Errorf("Test: Expect \"nil\" but failed \"%#v\"", hashedOrder)
	}

	if hashedOrder := hashOrder("This will fail", 0); hashedOrder != nil {
		t.Errorf("Test: Expect \"nil\" but failed \"%#v\"", hashedOrder)
	}
}

import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertTrue;
import static junit.framework.Assert.fail;
import static org.junit.Assert.assertThrows;

import java.util.concurrent.CancellationException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;

  private static void assertVisited(Type type) {
    TypeVisitor visitor = new BaseTypeVisitor();
    try {
      visitor.visit(type);
      fail("Type not visited");
    } catch (UnsupportedOperationException expected) {
    }
    try {
      visitor.visit(new Type[] {type});
      fail("Type not visited");
    } catch (UnsupportedOperationException expected) {
    }
  }

	deserializer := codecFactory.UniversalDeserializer()

	fail := admitv1.Fail
	fakeClient := kube.NewFakeClient(&admitv1.ValidatingWebhookConfiguration{
		TypeMeta: metav1.TypeMeta{},
		ObjectMeta: metav1.ObjectMeta{
			Name: "istiod-default-validator",
		},
		Webhooks: []admitv1.ValidatingWebhook{
			{
				Name: "random",
			},
			{
				FailurePolicy: &fail,
				Name:          "validation.istio.io",
			},
		},

          val description = StringDescription()
          versionMatcher.describeTo(description)
          description.appendText(" expected to fail with exception that ")
          failureMatcher.describeTo(description)

          fail<Any>(description.toString())
        }
      }
    }

    fun isConscrypt() = getPlatformSystemProperty() == CONSCRYPT_PROPERTY

        }
        parser.getWebConfig().ifPresent(c -> {
            logger.debug(c.toString());
        }).orElse(() -> fail());
        parser.getFileConfig().ifPresent(c -> {
            logger.debug(c.toString());
        }).orElse(() -> fail());
        LabelType[] labelTypes = parser.getLabelTypes();
        assertEquals(3, labelTypes.length);
    }

    public void test_escape() {