if !globalCallhomeConfig.Enabled() {
			// Stop the processing as callhome got disabled
			return false
		}

		select {
		case <-ctx.Done():
			// indicates that we do not need to run callhome anymore
			return false
		case <-callhomeTimer.C:
			if !globalCallhomeConfig.Enabled() {
				// Stop the processing as callhome got disabled
				return false
			}

			performCallhome(ctx)

			// Reset the timer for next cycle.

    return forwardMultiset();
  }

  @Override
  public SortedMultiset<E> descendingMultiset() {
    return forwardMultiset();
  }

  @Override
  public @Nullable Entry<E> firstEntry() {
    return forwardMultiset().lastEntry();
  }

  @Override
  public @Nullable Entry<E> lastEntry() {
    return forwardMultiset().firstEntry();
  }

  abstract Iterator<Entry<E>> entryIterator();

     */
    private lsarpc() {
        // Utility class
    }

    /**
     * Returns the RPC syntax identifier for LSA RPC interface.
     *
     * @return the RPC syntax string
     */
    public static String getSyntax() {
        return "12345778-1234-abcd-ef00-0123456789ab:0.0";
    }

    /**
     * LSA Quality of Service information.
     */

            public boolean isLdapIgnoreNetbiosName() {
                return true;
            }

            @Override
            public boolean isLdapGroupNameWithUnderscores() {
                return false;
            }
        });
        LdapManager ldapManager = new LdapManager();
        ldapManager.init();

        // Edge cases that should return null
        assertNull(ldapManager.getSearchRoleName(null));

public interface SmbPipeHandle extends AutoCloseable {

    /**
     * Gets the pipe resource associated with this handle.
     *
     * @return the pipe
     */
    SmbPipeResource getPipe();

    /**
     * Gets the input stream for reading from this pipe.
     *
     * @return this pipe's input stream
     * @throws CIFSException if an error occurs getting the input stream
     */

        return data;
    }

    /**
     * Check if negotiation was successful
     *
     * @return true if successful
     */
    public boolean isSuccess() {
        return status == STATUS_SUCCESS;
    }

    // Getters and setters

    /**
     * Get the minimum SMB Direct protocol version
     *
     * @return minimum protocol version
     */

        this.type = type;
        return this;
    }

    /**
     * Gets the fragment size.
     *
     * @return the fragment size in characters
     */
    public int getFragmentSize() {
        return fragmentSize;
    }

    /**
     * Sets the fragment size with fluent interface.
     *
     * @param fragmentSize the fragment size in characters
     * @return this HighlightInfo instance for method chaining
     */

    return delegate().offerFirst(e);
  }

  @CanIgnoreReturnValue // TODO(cpovirk): Consider removing this?
  @Override
  public boolean offerLast(@ParametricNullness E e) {
    return delegate().offerLast(e);
  }

  @Override
  public @Nullable E peekFirst() {
    return delegate().peekFirst();
  }

  @Override
  public @Nullable E peekLast() {
    return delegate().peekLast();
  }

            this.session = session;
            return this;
        }

        @Nonnull
        public ArtifactDeployerRequestBuilder trace(RequestTrace trace) {
            this.trace = trace;
            return this;
        }

        @Nonnull
        public ArtifactDeployerRequestBuilder repository(RemoteRepository repository) {
            this.repository = repository;
            return this;
        }

    }

    final Map<String, Vertex> vertices = new LinkedHashMap<>();

    public Vertex getVertex(String id) {
        return vertices.get(id);
    }

    public Collection<Vertex> getVertices() {
        return vertices.values();
    }

    Vertex addVertex(String label) {
        return vertices.computeIfAbsent(label, Vertex::new);
    }

    void addEdge(Vertex from, Vertex to) throws CycleDetectedException {