}

  /** Returns an int array of the specified size, filled with ABSENT. */
  private static int[] createFilledWithAbsent(int size) {
    int[] array = new int[size];
    Arrays.fill(array, ABSENT);
    return array;
  }

  /** Equivalent to {@code Arrays.copyOf(array, newSize)}, save that the new elements are ABSENT. */
  private static int[] expandAndFillWithAbsent(int[] array, int newSize) {

  }

  /** constructor creates array of given size with all elements zero */
  public void testConstructor() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int i = 0; i < SIZE; i++) {
      assertBitEquals(0.0, aa.get(i));
    }
  }

  /** constructor with null array throws NPE */
  public void testConstructor2NPE() {
    double[] a = null;

    public void test_ofValues() {
        String[] values = { "value1", "value2" };
        StreamUtil.stream(values[0], values[1]).of(s -> {
            Object[] array = s.toArray();
            for (int i = 0; i < 2; i++) {
                assertEquals(values[i], array[i]);
            }
        });
    }

    public void test_ofNull() {
        assertEquals(0, (int) StreamUtil.stream().get(s -> s.toArray().length));

  private InetAddresses() {}

  /**
   * Returns an {@link Inet4Address}, given a byte array representation of the IPv4 address.
   *
   * @param bytes byte array representing an IPv4 address (should be of length 4)
   * @return {@link Inet4Address} corresponding to the supplied byte array
   * @throws IllegalArgumentException if a valid {@link Inet4Address} can not be created
   */

        shareInfo2.remark = "Remark for Share2";

        // Create ShareInfoCtr1 with the shares
        srvsvc.ShareInfoCtr1 shareInfoCtr1 = new srvsvc.ShareInfoCtr1();
        shareInfoCtr1.count = 2;
        shareInfoCtr1.array = new srvsvc.ShareInfo1[] { shareInfo1, shareInfo2 };

        // Inject the ShareInfoCtr1 using reflection
        Field infoField = srvsvc.ShareEnumAll.class.getDeclaredField("info");
        infoField.setAccessible(true);

    }

    public void test_sizeOf_arrayVariations() {
        // Empty array
        assertEquals(0L, MemoryUtil.sizeOf(new String[0]));
        assertEquals(0L, MemoryUtil.sizeOf(new Object[0]));

        // Array with null elements
        assertEquals(0L, MemoryUtil.sizeOf(new String[] { null, null }));

        // Mixed content array
        assertEquals(84L, MemoryUtil.sizeOf(new Object[] { "test", 123, null }));

    }

    // Helper method to assert array equality
    private void assertArrayEquals(String[] expected, String[] actual) {
        if (expected == null && actual == null) {
            return;
        }
        assertNotNull("Expected array is null but actual is not", expected);
        assertNotNull("Actual array is null but expected is not", actual);
        assertEquals("Array lengths differ", expected.length, actual.length);

    }

    /**
     * Creates a byte array representing a Kerberos ticket for testing purposes.
     * @param version Kerberos version
     * @param realm Server realm
     * @param principalName Server principal name
     * @param encType Encryption type
     * @param encryptedData Encrypted data
     * @param unknownTag Optional unknown tag number to test error handling
     * @return A byte array representing the ticket

				<div class="modal-header">
					<h4 class="modal-title">
						<la:message key="labels.crud_title_delete" />
					</h4>
					<button type="button" class="close" data-dismiss="modal"
						aria-label="Close">
						<span aria-hidden="true">×</span>
					</button>
				</div>
				<div class="modal-body">
					<p>
						<la:message key="labels.crud_delete_confirmation" />
					</p>
				</div>

    override fun getAcceptedIssuers(): Array<X509Certificate> = delegate.acceptedIssuers

    override fun checkClientTrusted(
      chain: Array<X509Certificate>,
      authType: String,
    ) {
      calls.add("checkClientTrusted " + certificatesToString(chain))
    }

    override fun checkServerTrusted(
      chain: Array<X509Certificate>,
      authType: String,
    ) {