advance(8);
        return val;
    }

    /* float */
    /* double */
    /**
     * Encodes a string in NDR format.
     *
     * @param s the string to encode
     */
    public void enc_ndr_string(final String s) {
        align(4);
        int i = this.index;
        final int len = s.length();
        Encdec.enc_uint32le(len + 1, this.buf, i);
        i += 4;

    void testGetSmbResourceWithValidURLs() throws CIFSException {
        // Test that these URLs can be created successfully
        String[] validUrls = { "smb://server/", "smb://server/share/", "smb://server/share/file.txt" };

        for (String validUrl : validUrls) {
            // When
            SmbResource resource = context.get(validUrl);

            // Then

import (
	"bytes"
	"encoding/binary"
	"encoding/hex"
	"errors"
	"fmt"
	"io"
	"os"
	"strings"
	"time"

	json "github.com/minio/colorjson"

	"github.com/klauspost/compress/zip"
	"github.com/tinylib/msgp/msgp"
)

func inspectToExportType(downloadPath string, datajson bool) error {
	decode := func(r io.Reader, file string) ([]byte, error) {
		b, e := io.ReadAll(r)
		if e != nil {
			return nil, e
		}

    return (T[]) Arrays.copyOfRange(array, 0, array.length);
  }

  // TODO: Consolidate different copies in one single place.
  static String format(String template, Object... args) {
    // start substituting the arguments into the '%s' placeholders
    StringBuilder builder = new StringBuilder(template.length() + 16 * args.length);
    int templateStart = 0;
    int i = 0;
    while (i < args.length) {

    @Override
    protected void doAction() {
      latch.countDown();
    }
  }

  private static class EnableWrites extends DelayedActionRunnable {
    private final BlockingQueue<String> queue;

    EnableWrites(BlockingQueue<String> queue, long tMinus) {
      super(tMinus);
      assertFalse(queue.isEmpty());
      assertFalse(queue.offer("shouldBeRejected"));
      this.queue = queue;
    }

    @Override

  public static Test suite() {
    return CollectionTestSuiteBuilder.using(
            new TestStringCollectionGenerator() {
              @Override
              public Collection<String> create(String[] elements) {
                // TODO: MinimalCollection should perhaps throw
                for (Object element : elements) {
                  if (element == null) {
                    throw new NullPointerException();

    helperField.setAccessible(true);
    assertThat(helperField.get(null).getClass().getSimpleName()).isEqualTo(expectedHelperClassName);
  }

  private static ClassLoader getClassLoader(Set<String> blocklist) {
    String concurrentPackage = SettableFuture.class.getPackage().getName();
    ClassLoader classLoader = AggregateFutureStateFallbackAtomicHelperTest.class.getClassLoader();

     * @param andx the next command in the AndX chain, or null
     */
    public SmbComTreeConnectAndX(final CIFSContext ctx, final ServerData server, final String path, final String service,
            final ServerMessageBlock andx) {
        super(ctx.getConfig(), SMB_COM_TREE_CONNECT_ANDX, andx);
        this.ctx = ctx;
        this.server = server;
        this.path = path;

import org.codehaus.plexus.configuration.PlexusConfiguration;
import org.codehaus.plexus.configuration.xml.XmlPlexusConfiguration;
import org.codehaus.plexus.util.xml.Xpp3Dom;

/**
 * <strong>Warning:</strong> This is an internal class that is only public for technical reasons, it is not part of the
 * public API. In particular, this class can be changed or deleted without prior notice.
 *
 */
@Named
@Singleton

    public Integer crudMode;

    /** URL expression pattern to match documents for boosting */
    @Required
    @Size(max = 10000)
    public String urlExpr;

    /** Boost expression to apply to matching documents */
    @Required
    @Size(max = 10000)
    public String boostExpr;

    /** Sort order for displaying boost configurations */
    @Required
    @Min(value = 0)
    @Max(value = 2147483647)