override fun closes(event: ConnectionEvent): Boolean = event is ConnectStart && call == event.call && route == event.route
  }

  data class ConnectEnd(
    override val timestampNs: Long,
    override val connection: Connection,
    val route: Route,
    val call: Call,
  ) : ConnectionEvent() {
    override fun closes(event: ConnectionEvent): Boolean = event is ConnectStart && call == event.call && route == event.route

    public GroupRepositoryMetadata(String groupId) {
        super(new Metadata());
        this.groupId = groupId;
    }

    @Override
    public boolean storedInGroupDirectory() {
        return true;
    }

    @Override
    public boolean storedInArtifactVersionDirectory() {
        return false;
    }

    @Override
    public String getGroupId() {
        return groupId;
    }

    /** Total number of pages calculated from record count and page size. */
    private int allPageCount;

    /** Flag indicating whether a previous page exists. */
    private boolean existPrePage;

    /** Flag indicating whether a next page exists. */
    private boolean existNextPage;

    /** List of page numbers for pagination navigation. */
    private List<Integer> pageNumberList;

    /** Number of records to display per page. */

    .default(DEFAULT_TIMEOUT)

  val followRedirects: Boolean by option("-L", "--location").help("Follow redirects").flag()

  val allowInsecure: Boolean by option("-k", "--insecure").help("Allow connections to SSL sites without certs").flag()

  val showHeaders: Boolean by option("-i", "--include").help("Include protocol headers in the output").flag()

  val showHttp2Frames: Boolean by option("--frames").help("Log HTTP/2 frames to STDERR").flag()

        }

        requestedArtifacts.add(artifact);
    }

    public Set<Artifact> getRequestedArtifacts() {
        return requestedArtifacts;
    }

    public boolean hasMissingArtifacts() {
        return missingArtifacts != null && !missingArtifacts.isEmpty();
    }

    public List<Artifact> getMissingArtifacts() {

 * Unicode string type wrapper
 *
 */
public class UnicodeString extends rpc.unicode_string {

    boolean zterm;

    /**
     * Constructs a UnicodeString with zero termination option.
     *
     * @param zterm
     *            whether the string should be zero terminated
     */
    public UnicodeString(final boolean zterm) {
        this.zterm = zterm;
    }

    /**

    private ConcreteNdrObject ndrObject;

    // A concrete implementation of NdrObject for testing purposes.
    private static class ConcreteNdrObject extends NdrObject {
        private boolean throwOnEncode = false;
        private boolean throwOnDecode = false;

        @Override
        public void encode(NdrBuffer dst) throws NdrException {
            if (throwOnEncode) {
                throw new NdrException("Failed to encode");

     */
    protected abstract boolean doDisconnect(boolean hard, boolean inUse) throws IOException;

    /**
     * Connect the transport
     *
     * @param timeout the maximum time to wait for the connection in milliseconds
     * @return whether the transport was connected
     * @throws TransportException if the connection fails
     */

    private Field field;

    private final BeanDesc beanDesc;

    private Constructor<?> stringConstructor;

    private Method valueOfMethod;

    private boolean readable = false;

    private boolean writable = false;

    private ParameterizedClassDesc parameterizedClassDesc;

    /**
     * Creates an instance of {@link PropertyDescImpl}.
     *
     * @param propertyName

            SmbResource notAFile = mock(SmbResource.class);

            // Act
            boolean result = (boolean) invokePrivate(wrapper, "accept", new Class<?>[] { SmbResource.class }, notAFile);

            // Assert
            assertFalse(result);
            verify(delegate, never()).accept(any());
        }