// Use reflection to access private method for testing
        Exception exception = assertThrows(Exception.class, () -> {
            java.lang.reflect.Method method =
                    MultiChannelManager.class.getDeclaredMethod("createChannelTransport", InetAddress.class, InetAddress.class);
            method.setAccessible(true);
            method.invoke(multiChannelManager, null, null);
        });

     * Test readParameterWordsWireFormat method.
     */
    @Test
    void testReadParameterWordsWireFormat() {
        smbComOpenAndX = new SmbComOpenAndX(fileName, access, 0, andx);
        byte[] buffer = new byte[0];
        int result = smbComOpenAndX.readParameterWordsWireFormat(buffer, 0);
        assertEquals(0, result);
    }

    /**
     * Test readBytesWireFormat method.
     */
    @Test

        assertTrue(mockResponse.isReceived());

        // Verify the method was called
        verify(mockResponse, times(2)).isReceived();
    }

    @Test
    void testReceived() {
        // Call the method
        mockResponse.received();

        // Verify that the method was called
        verify(mockResponse, times(1)).received();
    }

    @Test

<img src="/img/tutorial/generate-clients/image06.png">

In this case, you have:

* `ItemsService`
* `UsersService`

### Client Method Names { #client-method-names }

Right now, the generated method names like `createItemItemsPost` don't look very clean:

```TypeScript
ItemsService.createItemItemsPost({name: "Plumbus", price: 5})
```

    private static final ImmutableMap<String, Method> typeVariableMethods;

    static {
      ImmutableMap.Builder<String, Method> builder = ImmutableMap.builder();
      for (Method method : TypeVariableImpl.class.getMethods()) {
        if (method.getDeclaringClass().equals(TypeVariableImpl.class)) {
          try {
            method.setAccessible(true);
          } catch (AccessControlException e) {

   * rather than just the {@link RuntimeException} or {@link Error} that should be possible. (And in
   * fact the static type of {@link Throwable} is occasionally justified even for a method with no
   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a

   * rather than just the {@link RuntimeException} or {@link Error} that should be possible. (And in
   * fact the static type of {@link Throwable} is occasionally justified even for a method with no
   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a

        String url = "https://example.com";

        // Test that CurlRequest can be created with all HTTP methods
        for (Method method : Method.values()) {
            CurlRequest request = new CurlRequest(method, url);
            assertEquals(method, request.method());
        }
    }

    /**
     * Test for close() method.
     * Verifies that the close method can be called without throwing an exception.
     * @throws CIFSException
     */
    @Test
    void testClose() throws CIFSException {
        smbTreeHandle.close();
        // Verify that close() was called on the mock
        verify(smbTreeHandle).close();
    }

    /**
     * Test for close() method throwing CIFSException.

	tests := []struct {
		name   string
		method string
		path   string
		query  map[string]string
	}{
		{
			name:   "GET status",
			method: http.MethodGet,
			path:   kmsStatusPath,
		},
		{
			name:   "GET metrics",
			method: http.MethodGet,
			path:   kmsMetricsPath,
		},
		{
			name:   "GET apis",
			method: http.MethodGet,
			path:   kmsAPIsPath,
		},
		{