* under the License.
 */
package org.apache.maven.model.interpolation;

import javax.inject.Inject;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Properties;

import org.apache.maven.model.Model;
import org.apache.maven.model.building.ModelBuildingRequest;

        String value3 = "c";
        settings.array().add(key, value1);
        settings.array().add(key, value2);
        settings.array().add(key, value3);
        assertEquals(3, settings.array().get(key).length);
        assertEquals(value1, settings.array().get(key)[0]);
        assertEquals(value2, settings.array().get(key)[1]);
        assertEquals(value3, settings.array().get(key)[2]);
    }

    @Test

    /** Array of fields to be included in standard search response */
    protected String[] responseFields;

    /** Array of fields to be included in scroll search response */
    protected String[] scrollResponseFields;

    /** Array of fields to be included in cache search response */
    protected String[] cacheResponseFields;

    /** Array of fields that can be highlighted in search results */

        result = NtlmMessage.readSecurityBuffer(data, 0);
        assertEquals(0, result.length, "Should return empty array for zero length buffer.");

        // Test with offset pointing to end of array (should result in empty array if length is 0)
        buffer.putShort(0, (short) 0);
        buffer.putShort(2, (short) 0);
        buffer.putInt(4, data.length);

  private static void assertIntact(MinMaxPriorityQueue<?> q) {
    if (!q.isIntact()) {
      fail("State " + Arrays.toString(q.toArray()));
    }
  }

  private static void assertIntactUsingSeed(long seed, MinMaxPriorityQueue<?> q) {
    if (!q.isIntact()) {
      fail("Using seed " + seed + ". State " + Arrays.toString(q.toArray()));
    }
  }

  private static void assertIntactUsingStartedWith(

        return new String(c);
    }

    /**
     * Converts a byte array to a hexadecimal string representation.
     *
     * @param src the source byte array to convert
     * @param srcIndex the starting index in the source array
     * @param size the number of bytes to convert from the source array
     * @return a hexadecimal string representation of the byte array
     */

package jcifs.internal.smb2.lock;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;

import java.util.Arrays;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

        // Verify num_sids
        assertEquals(0, lsarSidArrayX.num_sids, "num_sids should be 0 for an empty array");

        // Verify sids array
        assertNotNull(lsarSidArrayX.sids, "sids array should not be null for an empty array");
        assertEquals(0, lsarSidArrayX.sids.length, "sids array length should be 0 for an empty array");
    }

    @Test
    void testConstructorWithNullSIDArray() {
        jcifs.SID[] sids = null;

            }
        }

        return di - start;
    }

    /**
     * Decodes a UTF-8 encoded string from a byte array.
     *
     * @param src the source byte array
     * @param si the starting index in the source array
     * @param slim the limit index in the source array
     * @return the decoded String
     * @throws IOException if a decoding error occurs
     */

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.collect;

import static java.util.Arrays.asList;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.collect.TableCollectionTest.ColumnTests;
import java.util.Map;
import org.jspecify.annotations.NullUnmarked;