* If this method returns <code>null</code> the <code>SmbAuthException</code> that triggered the authenticator check will simply be rethrown. The default implementation returns <code>null</code>.
     * @return the authentication credentials or null if none available
     */
    protected NtlmPasswordAuthentication getNtlmPasswordAuthentication() {
        return null;
    }

            protected SmbResource adapt(FileEntry e) {
                return mockResource1;
            }
        };

        // When/Then
        assertFalse(iterator.hasNext(), "Should not have next when advance returns null");
        // The iterator returns null when no elements, doesn't throw exception
        assertNull(iterator.next(), "Should return null when no next element");
    }

    /**

     * Splits the given string into an array of substrings based on the specified regular expression
     * and returns a stream of those substrings.
     *
     * @param value the string to be split; if {@code null}, the method returns an empty stream
     * @param regex the regular expression to use for splitting the string
     * @return a stream of substrings resulting from splitting the input string, or an empty stream if the input is {@code null}
     */

        return Sets.unmodifiableNavigableSet((NavigableSet<E>) collection);
      } else if (collection instanceof SortedSet) {
        return Collections.unmodifiableSortedSet((SortedSet<E>) collection);
      } else if (collection instanceof Set) {
        return Collections.unmodifiableSet((Set<E>) collection);
      } else if (collection instanceof List) {

// Targets - list all targets
func (list *TargetList) Targets() []Target {
	if list == nil {
		return []Target{}
	}

	list.RLock()
	defer list.RUnlock()

	targets := []Target{}
	for _, tgt := range list.targets {
		targets = append(targets, tgt)
	}

	return targets
}

// List - returns available target IDs.
func (list *TargetList) List() []TargetID {
	list.RLock()
	defer list.RUnlock()

				continue
			}
			select {
			case subCh <- entry:
			case <-doneCh:
				return nil
			}
		}
	}
	return sys.pubsub.Subscribe(madmin.LogMaskAll, subCh, doneCh, filter)
}

// Init if HTTPConsoleLoggerSys is valid, always returns nil right now
func (sys *HTTPConsoleLoggerSys) Init(_ context.Context) error {
	return nil
}

// Endpoint - dummy function for interface compatibility

            buffer[i] = (byte) (0xFF - i);
        }

        return buffer;
    }

    private byte[] createMockBuffer(byte infoLevel) {
        switch (infoLevel) {
        case FileInformation.FILE_BASIC_INFO:
            return createMockFileBasicInfoBuffer();
        case FileInformation.FILE_STANDARD_INFO:
            return createMockFileStandardInfoBuffer();
        case FileInformation.FILE_INTERNAL_INFO:

        if (canonicalProtocol != null) {
            return canonicalProtocol;
        }
        return protocol;
    }

    /**
     * Returns the {@link File} object of the Jar file indicated by the URL.
     *
     * @param fileUrl
     *            The URL of the Jar file. Must not be {@literal null}.
     * @return The {@link File} of the Jar file.
     */
    public static File toFile(final URL fileUrl) {

   * LegacyConverter does violate the assumptions we make elsewhere.
   */

  private @Nullable B unsafeDoForward(@Nullable A a) {
    return doForward(uncheckedCastNullableTToT(a));
  }

  private @Nullable A unsafeDoBackward(@Nullable B b) {
    return doBackward(uncheckedCastNullableTToT(b));
  }

  /**

	Inlined bool

	DataBlocks   int
	ParityBlocks int
}

// ExpiresStr returns a stringified version of Expires header in http.TimeFormat
func (o ObjectInfo) ExpiresStr() string {
	var expires string
	if !o.Expires.IsZero() {
		expires = o.Expires.UTC().Format(http.TimeFormat)
	}
	return expires
}

// ArchiveInfo returns any saved zip archive meta information.
// It will be decrypted if needed.