} // else no check necessary, all index values are valid
      L existing = locks.get(index);
      if (existing != null) {
        return existing;
      }
      L created = supplier.get();
      existing = locks.putIfAbsent(index, created);
      return MoreObjects.firstNonNull(existing, created);
    }

    @Override
    public int size() {
      return size;
    }
  }

    private final UUID guid;

    /**
     * Create a new random handle GUID
     */
    public HandleGuid() {
        this.guid = UUID.randomUUID();
    }

    /**
     * Create a handle GUID from existing bytes
     * @param bytes the 16-byte GUID data in little-endian format (SMB wire format)
     */
    public HandleGuid(byte[] bytes) {
        if (bytes.length != 16) {

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.web.admin.design;

/**
 * Form class for editing design files in the admin interface.
 * This form handles the editing of template and design files used
 * for customizing the search interface appearance and layout.
 */
public class EditForm {

    /**
     * Creates a new EditForm instance.

            final PathPattern pattern = new PathPattern(path);
            // Check if pattern already exists
            boolean exists = false;
            for (final PathPattern existing : allowedPaths) {
                if (existing.getPattern().equals(path)) {
                    exists = true;
                    break;
                }
            }
            if (!exists) {

        assertEquals(flags1, result, "Should return first occurrence");
    }

    /**
     * Test get method with non-existing type
     */
    @Test
    @DisplayName("Get should return null for non-existing type")
    void testGetNonExistingType() {
        List<AvPair> pairs = new LinkedList<>();
        pairs.add(new AvFlags(0x12345678));

        }

        // Check for existing connection
        if (!nonPooled && tc.getConfig().getSessionLimit() != 1) {
            final SmbTransportImpl existing = findConnection(tc, address, port, localAddr, localPort, hostName, forceSigning, false);
            if (existing != null) {
                return existing;
            }
        }

     * so that it may be included in the list of results. IOW we do
     * not want to create a new NbtAddress object for this particular
     * address from which the query is constructed, we want to populate
     * the data of the existing address that should be one of several
     * returned by the node status.
     */

    NodeStatusResponse(final Configuration cfg, final NbtAddress queryAddress) {
        super(cfg);

        assertTrue(tags.contains("existing"));
    }

    @Test
    public void testConcatValues() {
        // Test static concatValues method
        List<String> dest = new java.util.ArrayList<>();
        dest.add("existing");

        SuggestItem.concatValues(dest, "new1", "new2", "existing");

        assertEquals(3, dest.size());

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

/**
 * Tests relating to cache eviction: what does and doesn't count toward maximumSize, what happens
 * when maximumSize is reached, etc.
 *
 * @author mike nonemacher
 */
@NullUnmarked
public class CacheEvictionTest extends TestCase {

    }

    /**
     * Test hasRule with existing rule
     */
    public void test_hasRule_existing() {
        TestRule rule = new TestRule("rule1", true);

        ruleManager.addRule(rule);

        assertTrue(ruleManager.hasRule(rule));
    }

    /**
     * Test hasRule with non-existing rule
     */
    public void test_hasRule_nonExisting() {