import jcifs.Configuration;
import jcifs.internal.smb1.ServerMessageBlock;

/**
 * SMB1 Delete Directory request message.
 *
 * This command is used to delete a directory on the server.
 * The directory must be empty before it can be deleted.
 */
public class SmbComDeleteDirectory extends ServerMessageBlock {

    /**
     * Creates a new SMB1 delete directory request.
     *
     * @param config the CIFS configuration

	"io"
	"net"
	"path/filepath"
	"strings"
	"sync"
	"testing"
)

// TestCopyUnixpacket tests that we can use bufio when copying
// across a unixpacket socket. This used to fail due to an unnecessary
// empty Write call that was interpreted as an EOF.
func TestCopyUnixpacket(t *testing.T) {
	tmpDir := t.TempDir()
	socket := filepath.Join(tmpDir, "unixsock")

	// Start a unixpacket server.
	addr := &net.UnixAddr{

			newMeta[strings.TrimPrefix(k, "X-Amz-Meta-")] = v
		} else {
			newMeta[k] = v
		}
	}
	return newMeta
}

// pathClean is like path.Clean but does not return "." for
// empty inputs, instead returns "empty" as is.
func pathClean(p string) string {
	cp := path.Clean(p)
	if cp == "." {
		return ""
	}
	return cp
}

func trimLeadingSlash(ep string) string {

        // Defaults to UNCLEAR when value is null
        assertEquals(ChatIntent.UNCLEAR, ChatIntent.fromValue(null));
    }

    @Test
    public void test_fromValue_empty() {
        // Defaults to UNCLEAR when value is empty or whitespace
        assertEquals(ChatIntent.UNCLEAR, ChatIntent.fromValue(""));
        assertEquals(ChatIntent.UNCLEAR, ChatIntent.fromValue("   "));
    }

    @Test
    public void test_fromValue_unknown() {

  /**
   * Creates a new, empty instance of the class under test.
   *
   * @return a new, empty map instance.
   * @throws UnsupportedOperationException if it's not possible to make an empty instance of the
   *     class under test.
   */
  protected abstract Map<K, V> makeEmptyMap() throws UnsupportedOperationException;

  /**
   * Creates a new, non-empty instance of the class under test.
   *

     *
     * @return the number of elements
     */
    public int size() {
        return size;
    }

    /**
     * Checks if the list is empty.
     *
     * @return true if the list is empty, false otherwise
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * Checks if an element is contained in the list.
     *

 */
@GwtCompatible
@SuppressWarnings("serial") // uses writeReplace(), not default serialization
final class RegularImmutableMultiset<E> extends ImmutableMultiset<E> {
  static final RegularImmutableMultiset<Object> EMPTY =
      new RegularImmutableMultiset<>(ObjectCountHashMap.create());

  final transient ObjectCountHashMap<E> contents;
  private final transient int size;

		} else if !test.atEOF && tok.ScanToken == scanner.EOF {
			t.Errorf("%d: %q: expected not EOF but at EOF", i, test.input)
		}
	}
}

type badExprTest struct {
	input string
	error string // Empty means no error.
}

var badExprTests = []badExprTest{
	{"0/0", "division by zero"},
	{"3/0", "division by zero"},
	{"(1<<63)/0", "divide of value with high bit set"},
	{"3%0", "modulo by zero"},

    for (int i = 0; i + 1 < asRanges.size(); i++) {
      Range<C> range1 = asRanges.get(i);
      Range<C> range2 = asRanges.get(i + 1);
      assertFalse(range1.isConnected(range2));
    }

    // test that there are no empty ranges
    for (Range<C> range : asRanges) {
      assertFalse(range.isEmpty());
    }

    // test that the RangeSet's span is the span of all the ranges
    Iterator<Range<C>> itr = rangeSet.asRanges().iterator();

        assertTrue(s.endsWith("]"), "expected suffix ] but got " + s);
        String inner = s.substring("SmbComLogoffAndX[".length(), s.length() - 1);
        assertFalse(inner.isEmpty(), "inner part of toString should not be empty");
    }

    @Test
    @DisplayName("constructor sets correct command value")
    void constructorSetsCorrectCommand() {
        SmbComLogoffAndX msg = new SmbComLogoffAndX(null);