if (profileActivation != null) {
            Activation activation = new Activation();

            activation.setActiveByDefault(profileActivation.isActiveByDefault());

            activation.setJdk(profileActivation.getJdk());

            org.apache.maven.profiles.ActivationProperty profileProp = profileActivation.getProperty();

            if (profileProp != null) {

            }
        }
    }

    /**
     * Stops the process.
     */
    public synchronized void stop() {
        if (thread != null) {
            thread.interrupt();
            thread = null;
            if (logger.isDebugEnabled()) {
                logger.debug("TimeoutManager stopped.");
            }
        }
    }

    /**
     * Interrupts the thread and waits for it to terminate.
     *

    Map<C, V> row = safeGet(rowMap(), rowKey);
    return row != null && Maps.safeContainsKey(row, columnKey);
  }

  @Override
  public @Nullable V get(@Nullable Object rowKey, @Nullable Object columnKey) {
    Map<C, V> row = safeGet(rowMap(), rowKey);
    return (row == null) ? null : safeGet(row, columnKey);
  }

  @Override
  public boolean isEmpty() {
    return size() == 0;
  }

     *
     * @param key the key under which to store the session data, must not be {@code null}
     * @param oldValue the expected data currently associated with the key, may be {@code null}
     * @param newValue the data to associate with the key, may be {@code null} to remove the mapping
     * @return {@code true} if the key mapping was successfully updated from the old value to the new value,

        INTERFACES.put(name, syntax);
    }

    private final String proto;
    private Map<String, Object> options = null;
    private final String server;
    private String endpoint = null;
    private UUID uuid = null;
    private int major;
    private int minor;

    DcerpcBinding(final String proto, final String server) {
        this.proto = proto;
        this.server = server;

    }

    @Test
    @DisplayName("accept: rejects null input with meaningful NullPointerException")
    void accept_rejectsNullInput() {
        // Arrange: defensive filter that validates input
        SmbFileFilter filter = f -> {
            if (f == null) {
                throw new NullPointerException("file must not be null");
            }
            return true; // not reached in this test
        };

 * @author higa
 * @param <E> the element type
 */
public class SLinkedList<E> implements Cloneable, Externalizable {

    static final long serialVersionUID = 1L;

    private transient Entry header = new Entry(null, null, null);

    private transient int size = 0;

    /**
     * Creates an {@link SLinkedList}.
     */
    public SLinkedList() {
        header.next = header;
        header.previous = header;
    }

        return key != null ? leases.get(key) : null;
    }

    /**
     * Handle a lease break notification
     *
     * @param key lease key
     * @param newState new lease state
     */
    public void handleLeaseBreak(Smb2LeaseKey key, int newState) {
        LeaseEntry entry = leases.get(key);
        if (entry != null) {

    assertThrows(NullPointerException.class, () -> builder.add((String) null));
  }

  public void testBuilderAddAllHandlesNullsCorrectly() {
    {
      ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder();
      assertThrows(NullPointerException.class, () -> builder.addAll((Collection<String>) null));
    }

    {

        if (_conditionQuery != null) {
            QueryBuilder queryBuilder = _conditionQuery.getQuery();
            if (queryBuilder != null) {
                builder.setQuery(queryBuilder);
            }
            _conditionQuery.getFieldSortBuilderList().forEach(sort -> {
                builder.addSort(sort);
            });
        }

        if (_conditionAggregation != null) {