/**
     * Checks if the transport supports the specified capability.
     *
     * @param cap the capability flag to check
     * @return whether the transport has the given capability
     * @throws SmbException if an error occurs checking capabilities
     */
    boolean hasCapability(int cap) throws SmbException;

    /**
     * Checks if the transport has been disconnected.
     *

// not be used after the arena is freed. Accessing the underlying storage of the
// slice after free may result in a fault, but this fault is also not guaranteed.
func MakeSlice[T any](a *Arena, len, cap int) []T {
	var sl []T
	runtime_arena_arena_Slice(a.a, &sl, cap)
	return sl[:len]
}

// Clone makes a shallow copy of the input value that is no longer bound to any
// arena it may have been allocated from, returning the copy. If it was not

    public void ensureDFSResolved() throws CIFSException {
        this.treeConnection.ensureDFSResolved(this.resourceLoc);
    }

    @Override
    public boolean hasCapability(final int cap) throws SmbException {
        return this.treeConnection.hasCapability(cap);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbTreeHandle#isConnected()
     */
    @Override
    public boolean isConnected() {

{"message": "Hello World"}
```

### Tài liệu tương tác API

Bây giờ tới <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.

Bạn sẽ thấy một tài liệu tương tác API (cung cấp bởi <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>):

![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)

				return
			}
		case "CmdLines":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "CmdLines")
				return
			}
			if cap(z.CmdLines) >= int(zb0002) {
				z.CmdLines = (z.CmdLines)[:zb0002]
			} else {
				z.CmdLines = make([]string, zb0002)
			}
			for za0001 := range z.CmdLines {
				z.CmdLines[za0001], err = dc.ReadString()

		}

		if tc, ok := r.Context().Value(mcontext.ContextTraceKey).(*mcontext.TraceCtxt); ok {
			tc.FuncName = "s3.MaxClients"
		}

		w.Header().Set("X-RateLimit-Limit", strconv.Itoa(cap(pool)))
		w.Header().Set("X-RateLimit-Remaining", strconv.Itoa(cap(pool)-len(pool)))

		ctx := r.Context()
		select {
		case pool <- struct{}{}:
			defer func() { <-pool }()
			globalHTTPStats.addRequestsInQueue(-1)

        @SuppressWarnings("unchecked")
        List<Map<String, Object>> resultList = (List<Map<String, Object>>) result;
        assertEquals(2, resultList.size());

        Map<String, Object> map1 = resultList.get(0);
        assertEquals("name1", map1.get("name"));

        Map<String, Object> map2 = resultList.get(1);
        assertEquals("name2", map2.get("name"));
    }

    public void test_register_entitySet() {

				update = false
				if isArrayKind {
					db.Statement.ReflectValue.Set(reflect.Zero(reflectValue.Type()))
				} else {
					// if the slice cap is externally initialized, the externally initialized slice is directly used here
					if reflectValue.Cap() == 0 {
						db.Statement.ReflectValue.Set(reflect.MakeSlice(reflectValue.Type(), 0, 20))
					} else {
						reflectValue.SetLen(0)

        // 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();

				return
			}
		case "EcDist":
			var zb0003 uint32
			zb0003, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "ErasureDist")
				return
			}
			if cap(z.ErasureDist) >= int(zb0003) {
				z.ErasureDist = (z.ErasureDist)[:zb0003]
			} else {
				z.ErasureDist = make([]uint8, zb0003)
			}
			for za0003 := range z.ErasureDist {