//
    /**
     * Copies from an input stream to an output stream.
     * <p>
     * Neither the input stream nor the output stream is closed.
     * </p>
     *
     * @param in the input stream (must not be {@literal null})
     * @param out the output stream (must not be {@literal null})
     * @return the number of bytes copied
     */

        }
    }

    /**
     * Copies the source Bean to a new instance of the destination Bean and returns it.
     *
     * @param <T> The type of the destination Bean.
     * @param src The source Bean. Must not be {@literal null}.
     * @param destClass The type of the destination Bean. Must not be {@literal null}.
     * @return The newly copied Bean.
     */

        assertEquals(dummyRus.length, unicodeStringTrue.length, "Length should be copied");
        assertEquals(dummyRus.maximum_length, unicodeStringTrue.maximum_length, "Maximum length should be copied");
        assertArrayEquals(dummyRus.buffer, unicodeStringTrue.buffer, "Buffer should be copied");
        assertTrue(unicodeStringTrue.zterm, "zterm should be true");

        // Test with zterm = false

     * If either or both arrays have a length of {@literal 0}, the other array is returned as is.
     * In any case, the returned array is the same instance as the argument array and is not copied.
     * </p>
     *
     * @param <T>
     *            the type of the array elements
     * @param a
     *            first array
     * @param b
     *            second array

        // In test environments, getSubject() may return null if JAAS is not configured
        // This is acceptable behavior - the test should focus on the cloning logic

        // Clone and verify basic fields copied
        JAASAuthenticator copy = (JAASAuthenticator) orig.clone();
        assertEquals(orig.getUsername(), copy.getUsername());
        assertEquals(orig.getUserDomain(), copy.getUserDomain());

        int result = response.readDataWireFormat(buffer, 10, testData.length);

        assertEquals(testData.length, result);
        // Verify data was copied to outputBuffer
        byte[] expectedData = new byte[testData.length];
        System.arraycopy(outputBuffer, 0, expectedData, 0, testData.length);
        assertArrayEquals(testData, expectedData);
    }

    }

    /**
     * Returns a {@link CopyOptions} with the specified prefix.
     * <p>
     * When a prefix is specified, only the properties from the source whose names start with the prefix will be copied.
     * Additionally, the prefix will be removed from the source property names to determine the target property names.
     * </p>
     *
     * @param prefix

     * the property names for the source and destination will be as follows:
     * </p>
     * <table border="1">
     * <caption>Copied JavaBeans Properties</caption>
     * <tr>
     * <th>JavaBeans Property Name</th>
     * <th>{@literal Map} Property Name</th>
     * </tr>
     * <tr>
     * <td>{@literal foo}</td>

        int dstIndex = 10;

        // Act
        int bytesWritten = trans.writeDataWireFormat(dst, dstIndex);

        // Assert
        assertEquals(TEST_LENGTH, bytesWritten);

        // Verify data is copied correctly
        byte[] copiedData = new byte[TEST_LENGTH];
        System.arraycopy(dst, dstIndex, copiedData, 0, TEST_LENGTH);
        assertArrayEquals(TEST_DATA, copiedData);
    }

    @Test

        assertEquals(len, enc.size(), "size() must equal provided length");
        assertEquals(len, written, "encode() must return number of bytes written");

        // Assert: copied region equals the source slice.
        for (int i = 0; i < len; i++) {
            assertEquals(src[off + i], dst[dstIndex + i], "Byte mismatch at " + i);
        }