// When
        request = new Smb2NegotiateRequest(mockConfig, 0);

        // Then
        int caps = request.getCapabilities();
        int capCount = 0;
        if ((caps & Smb2Constants.SMB2_GLOBAL_CAP_DFS) != 0)
            capCount++;
        if ((caps & Smb2Constants.SMB2_GLOBAL_CAP_ENCRYPTION) != 0)
            capCount++;

        assertEquals(expectedCapabilityCount, capCount);
    }

        // When
        int caps = response.getCapabilities();

        // Then
        assertEquals(0x7F, caps);
    }

    @Test
    @DisplayName("Should return common capabilities")
    void testGetCommonCapabilities() throws Exception {
        // Given
        setPrivateField(response, "commonCapabilities", 0x3F);

        // When
        int caps = response.getCommonCapabilities();

    @ValueSource(ints = { -1, 0, 1, 1024 })
    void hasCapability_variousCaps(int cap) throws SmbException {
        when(transport.hasCapability(anyInt())).thenAnswer(inv -> ((int) inv.getArgument(0)) >= 0);

        boolean result = transport.hasCapability(cap);

        assertEquals(cap >= 0, result);
        verify(transport, times(1)).hasCapability(cap);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.SmbNegotiationResponse#haveCapabilitiy(int)
     */
    @Override
    public boolean haveCapabilitiy(final int cap) {
        return (this.commonCapabilities & cap) == cap;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.SmbNegotiationResponse#isDFSSupported()
     */
    @Override
    public boolean isDFSSupported() {

func (config *TierConfigMgr) Add(ctx context.Context, tier madmin.TierConfig, ignoreInUse bool) error {
	config.Lock()
	defer config.Unlock()

	// check if tier name is in all caps
	tierName := tier.Name
	if tierName != strings.ToUpper(tierName) {
		return errTierNameNotUppercase
	}

	// check if tier name already in use
	if _, exists := config.isTierNameInUse(tierName); exists {

    void testHaveCapabilityMultipleFlags() {
        // Arrange
        int cap1 = 0x00000001;
        int cap2 = 0x00000002;
        int cap3 = 0x00000004;
        when(negotiationResponse.haveCapabilitiy(cap1)).thenReturn(true);
        when(negotiationResponse.haveCapabilitiy(cap2)).thenReturn(false);
        when(negotiationResponse.haveCapabilitiy(cap3)).thenReturn(true);

        // Act & Assert

	buf := make([]byte, 1024)
	b.Write(buf[0:1])
	var cap0 int
	for i := 0; i < 5<<10; i++ {
		b.Write(buf)
		b.Read(buf)
		if i == 0 {
			cap0 = b.Cap()
		}
	}
	cap1 := b.Cap()
	// (*Buffer).grow allows for 2x capacity slop before sliding,
	// so set our error threshold at 3x.
	if cap1 > cap0*3 {
		t.Errorf("buffer cap = %d; too big (grew from %d)", cap1, cap0)
	}
}

            // Verify the request offset equals the skip value (2)
            ArgumentCaptor<Smb2ReadRequest> cap = ArgumentCaptor.forClass(Smb2ReadRequest.class);
            verify(mockTree).send(cap.capture(), any(RequestParam.class));
            Smb2ReadRequest req = cap.getValue();

            // Reflectively inspect the private 'offset' field to assert it used the advanced fp

// number c. The return value will be floating point type corresponding to
// the type of c.
func imag(c ComplexType) FloatType

// The clear built-in function clears maps and slices.
// For maps, clear deletes all entries, resulting in an empty map.
// For slices, clear sets all elements up to the length of the slice
// to the zero value of the respective element type. If the argument

          .put(ImmutableMap.class, ImmutableMap.of())
          .put(SortedMap.class, ImmutableSortedMap.of())
          .put(ImmutableSortedMap.class, ImmutableSortedMap.of())
          .put(NavigableMap.class, Maps.unmodifiableNavigableMap(Maps.newTreeMap()))
          .put(Multimap.class, ImmutableMultimap.of())
          .put(ImmutableMultimap.class, ImmutableMultimap.of())
          .put(ListMultimap.class, ImmutableListMultimap.of())