Request
        .Builder()
        .url(server.url("/"))
        .build()
    assertFailsWith<IllegalStateException> {
      client.newCall(request).execute()
    }.also { expected ->
      assertThat(expected.message).isEqualTo(
        "network interceptor $interceptor must call proceed() exactly once",
      )
    }
  }

  @Test
  fun networkInterceptorsCannotCallProceedMultipleTimes() {

            SMBProtocolDecodingException exception =
                    assertThrows(SMBProtocolDecodingException.class, () -> response.readBytesWireFormat(buffer, bufferIndex));
            assertEquals("Expected structureSize = 4", exception.getMessage());
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 2, 3, 5, 6, 8, 16, 100, 255, 1024, 4096, 65535 })

    clientListener.assertOpen()
    val reason = repeat('X', 124)
    assertFailsWith<IllegalArgumentException> {
      webSocket.close(1000, reason)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("reason.size() > 123: $reason")
    }
    webSocket.close(1000, null)
    serverListener.assertClosing(1000, "")
    server.close(1000, null)

    assertFailsWith<IOException> {
      client.newCall(request).execute()
    }.also { expected ->
      expected.assertSuppressed {
        val suppressed = it.single()
        assertThat(suppressed).isInstanceOf(IOException::class.java)
        assertThat(suppressed).isNotSameAs(expected)
      }
    }
  }

  /** Confirm suppressed exceptions that occur after connecting are returned. */

        collection.toArray(array));
  }

  private static void expectArrayContentsAnyOrder(Object[] expected, Object[] actual) {
    assertEqualIgnoringOrder(asList(expected), asList(actual));
  }

  private void expectArrayContentsInOrder(List<E> expected, Object[] actual) {
    assertEquals("toArray() ordered contents: ", expected, asList(actual));
  }

  /**

These stubs form an internally consistent data-set that is not expected to change. They are
used to test the individual components in the lifecycle with data that has expected characteristics
and can be asserted as desired.

You can change/extend these stubs, and tests should not be breaking too much, since most tests
assert using expected values from the stubs. Normally, when you try to use data from the stubs that

    assertThat(stats.loadExceptionCount()).isEqualTo(0);
    assertThat(stats.hitCount()).isEqualTo(0);

    ExecutionError expected = assertThrows(ExecutionError.class, () -> cache.get(new Object()));
    assertThat(expected).hasCauseThat().isSameInstanceAs(e);
    stats = cache.stats();
    assertThat(stats.missCount()).isEqualTo(1);
    assertThat(stats.loadSuccessCount()).isEqualTo(0);

		result := int64(p.expr())
		if result != test.output {
			t.Errorf("%d: %q evaluated to %d; expected %d", i, test.input, result, test.output)
		}
		tok := p.next()
		if test.atEOF && tok.ScanToken != scanner.EOF {
			t.Errorf("%d: %q: at EOF got %s", i, test.input, tok)
		} else if !test.atEOF && tok.ScanToken == scanner.EOF {
			t.Errorf("%d: %q: expected not EOF but at EOF", i, test.input)
		}
	}
}

type badExprTest struct {

              });
      fail("Expected NullPointerException or UnsupportedOperationException");
    } catch (NullPointerException | UnsupportedOperationException expected) {
    }
  }

  public void testMergeNullFunction() {
    try {
      getMap().merge(k0(), v3(), null);
      fail("Expected NullPointerException or UnsupportedOperationException");

		arn, err := ParseARN(testCase.s)
		expectErr := (err != nil)

		if expectErr != testCase.expectErr {
			t.Fatalf("test %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
		}

		if !testCase.expectErr {
			if *arn != *testCase.expectedARN {
				t.Fatalf("test %v: data: expected: %v, got: %v", i+1, testCase.expectedARN, arn)
			}
		}
	}