Het zou ongeveer hetzelfde zijn als het typen van:

<div class="termy">

```console
$ C:\opt\custompython\bin\python
```

</div>

////

Deze informatie is handig wanneer je meer wilt weten over [virtuele omgevingen](virtual-environments.md){.internal-link target=_blank}.

## Conclusion

pkg syscall (windows-386), func CreateFileMapping(Handle, *SecurityAttributes, uint32, uint32, uint32, *uint16) (Handle, error)
pkg syscall (windows-386), func CreateIoCompletionPort(Handle, Handle, uint32, uint32) (Handle, error)
pkg syscall (windows-386), func CreatePipe(*Handle, *Handle, *SecurityAttributes, uint32) error

                        // Handle array type
                        attributes.put(name, parseArray(jsonParser));
                    } else if (jsonParser.getCurrentToken() == JsonToken.START_OBJECT) {
                        // Handle nested object type
                        attributes.put(name, parseObject(jsonParser));
                    } else {
                        // Handle primitive types (string, number, boolean, etc.)

 * under the License.
 */
package org.apache.maven.api.cache;

import org.apache.maven.api.annotations.Experimental;

/**
 * Factory interface for creating new RequestCache instances.
 * Implementations should handle the creation and configuration of cache instances
 * based on the current Maven session and environment.
 *
 * @since 4.0.0
 * @see RequestCache
 */
@Experimental
public interface RequestCacheFactory {

        assertSame(expectedInetAddress, inetAddress, "Should return configured InetAddress");
        assertNotNull(inetAddress, "InetAddress should not be null");
    }

    @Test
    @DisplayName("toInetAddress should handle UnknownHostException")
    void testToInetAddressWithException() throws UnknownHostException {
        // Given
        when(mockAddress.toInetAddress()).thenThrow(new UnknownHostException("Host not found"));

        // Then
        assertNotNull(ex);
        assertEquals(message, ex.getMessage());
        assertEquals(cause, ex.getCause());
    }

    @Test
    @DisplayName("Should handle null message and/or cause without throwing")
    void testNullInputs() {
        assertDoesNotThrow(() -> {
            SpnegoException ex1 = new SpnegoException((String) null);
            assertNotNull(ex1);

  val proxies: MutableList<Proxy> = mutableListOf()

  fun addProxy(proxy: Proxy): FakeProxySelector {
    proxies.add(proxy)
    return this
  }

  override fun select(uri: URI): List<Proxy> {
    // Don't handle 'socket' schemes, which the RI's Socket class may request (for SOCKS).
    return if (uri.scheme == "http" || uri.scheme == "https") proxies else listOf(Proxy.NO_PROXY)
  }

  override fun connectFailed(
    uri: URI,

        byte[] buffer = new byte[512];
        int written = trans2QueryPathInfo.writeParametersWireFormat(buffer, 0);

        // Should handle special characters properly
        assertTrue(written > specialPath.length());

        // Check information level
        int actualInfoLevel = SMBUtil.readInt2(buffer, 0);

 */
public class MsrpcLookupSids extends jcifs.dcerpc.msrpc.lsarpc.LsarLookupSids {

    /**
     * Creates a new request to lookup SIDs.
     *
     * @param policyHandle the LSA policy handle
     * @param sids the array of SIDs to lookup
     */
    public MsrpcLookupSids(final LsaPolicyHandle policyHandle, final jcifs.SID[] sids) {

Create a function to be run as the background task.

It is just a standard function that can receive parameters.

It can be an `async def` or normal `def` function, **FastAPI** will know how to handle it correctly.

In this case, the task function will write to a file (simulating sending an email).

And as the write operation doesn't use `async` and `await`, we define the function with normal `def`: