/**
 * Implementation class of {@link BeanDesc}.
 *
 * @author higa
 */
public class BeanDescImpl implements BeanDesc {

    /** Empty object array */
    protected static final Object[] EMPTY_ARGS = new Object[0];

    /** Empty class array */
    protected static final Class<?>[] EMPTY_PARAM_TYPES = new Class<?>[0];

    /** The class of the bean */
    protected final Class<?> beanClass;

    } else {
      return new int[buckets];
    }
  }

  static void tableClear(Object table) {
    if (table instanceof byte[]) {
      Arrays.fill((byte[]) table, (byte) 0);
    } else if (table instanceof short[]) {
      Arrays.fill((short[]) table, (short) 0);
    } else {
      Arrays.fill((int[]) table, 0);
    }
  }

  /**
   * Returns {@code table[index]}, where {@code table} is actually a {@code byte[]}, {@code

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.Arrays;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

@DisplayName("Smb2LeaseKey Tests")
class Smb2LeaseKeyTest {

    @Test

            throw new IllegalArgumentException("Lease key must be 16 bytes, got " + key.length);
        }
        this.key = Arrays.copyOf(key, LEASE_KEY_SIZE);
    }

    /**
     * Get the lease key bytes
     *
     * @return copy of the 16-byte lease key
     */
    public byte[] getKey() {
        return Arrays.copyOf(key, LEASE_KEY_SIZE);
    }

    /**
     * Write the lease key to a buffer
     *

 */
public interface RestTestTransformByParentArray extends RestTestTransform<ArrayNode> {

    /**
     * Arrays are always the value in a key/value pair. Find a key with this name that has an array as the value to identify which Array(s)
     * to transform.
     * @return The name of key to find in the REST test that has a value that is an Array
     */
    String getKeyOfArrayToFind();

    }

    /**
     * Gets the array of supported authentication mechanisms
     * @return the mechanisms array
     */
    public ASN1ObjectIdentifier[] getMechanisms() {
        return this.mechanisms;
    }

    /**
     * Sets the array of supported authentication mechanisms
     * @param mechanisms the mechanisms to set
     */

                bytes[byteIndex++] = (byte) (0x80 | (c & 0x3F));
            }
        }

        return Arrays.copyOf(bytes, byteIndex);
    }

    /**
     * Convert byte array to char array (UTF-8)
     */
    private char[] bytesToChars(byte[] bytes) {
        if (bytes == null) {
            return null;
        }

        // Decode UTF-8

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for CompactLinkedHashSet.
 *
 * @author Dimitris Andreou
 */
@GwtIncompatible // java.util.Arrays#copyOf(Object[], int), java.lang.reflect.Array
@NullUnmarked

    }
  }

  /** Returns the {@code Class} object of arrays with {@code componentType}. */
  static Class<?> getArrayClass(Class<?> componentType) {
    // TODO(user): This is not the most efficient way to handle generic
    // arrays, but is there another way to extract the array class in a
    // non-hacky way (i.e. using String value class names- "[L...")?
    return Array.newInstance(componentType, 0).getClass();
  }

  /*

  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testCreateWithDuplicates_nullDuplicatesNotRejected() {
    E[] array = createArrayWithNullElement();
    array[0] = null;
    collection = getSubjectGenerator().create(array);

    List<E> expectedWithDuplicateRemoved = asList(array).subList(1, getNumElements());
    expectContents(expectedWithDuplicateRemoved);
  }