}))
                .status(ApiResult.Status.OK)
                .result());
    }

    /**
     * Create a new character mapping entry for the specified dictionary.
     *
     * @param dictId identifier of the dictionary
     * @param body create request payload
     * @return JSON response containing creation result and new entry ID
     */
    // POST /api/admin/dict/mapping/setting/{dictId}

    /**
     * Creates a new key match.
     *
     * @param form the create form
     * @return HTML response after creation
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse create(final CreateForm form) {
        verifyCrudMode(form.crudMode, CrudMode.CREATE);
        validate(form, messages -> {}, this::asEditHtml);
        verifyToken(this::asEditHtml);

        Smb2LeaseKey leaseKey = new Smb2LeaseKey();

        // Initially no cache entry
        assertNull(directoryLeaseManager.getCacheEntry(directoryPath));

        // Request a lease to create cache entry
        when(baseLeaseManager.requestLease(anyString(), anyInt())).thenReturn(leaseKey);
        directoryLeaseManager.requestDirectoryLease(directoryPath, DirectoryLeaseState.DIRECTORY_READ_HANDLE,

		ExampleStruct:    ExampleStruct{"name", "value1"},
		ExampleStructPtr: &ExampleStruct{"name", "value2"},
	}

	if err := DB.Create(&data).Error; err == nil {
		t.Errorf("Should failed to create data with invalid data")
	}

	data.Password = EncryptedData("pass1")
	if err := DB.Create(&data).Error; err != nil {
		t.Errorf("Should got no error when creating data, but got %v", err)
	}

func TestXLStorageReadAll(t *testing.T) {
	// create xlStorage test setup
	xlStorage, _, err := newXLStorageTestSetup(t)
	if err != nil {
		t.Fatalf("Unable to create xlStorage test setup, %s", err)
	}

	// Create files for the test cases.
	if err = xlStorage.MakeVol(t.Context(), "exists"); err != nil {
		t.Fatalf("Unable to create a volume \"exists\", %s", err)
	}

import jcifs.ResourceNameFilter;
import jcifs.SmbResource;
import jcifs.SmbResourceLocator;
import jcifs.internal.Request;
import jcifs.internal.smb2.create.Smb2CloseRequest;
import jcifs.internal.smb2.create.Smb2CreateRequest;
import jcifs.internal.smb2.create.Smb2CreateResponse;
import jcifs.internal.smb2.info.Smb2QueryDirectoryRequest;
import jcifs.internal.smb2.info.Smb2QueryDirectoryResponse;

</div>

And copy the output to the variable `SECRET_KEY` (don't use the one in the example).

Create a variable `ALGORITHM` with the algorithm used to sign the JWT token and set it to `"HS256"`.

Create a variable for the expiration of the token.

Define a Pydantic Model that will be used in the token endpoint for the response.

Create a utility function to generate a new access token.

    /**
     * Creates a new group.
     *
     * @param form the create form
     * @return HTML response after creation
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse create(final CreateForm form) {
        verifyCrudMode(form.crudMode, CrudMode.CREATE);
        validate(form, messages -> {}, this::asEditHtml);

    implements Serializable {
  public static <E extends Enum<E>> EnumMultiset<E> create(Class<E> type) {
    return new EnumMultiset<>(new EnumMap<E, Count>(type));
  }

  public static <E extends Enum<E>> EnumMultiset<E> create(Iterable<E> elements) {
    Iterator<E> iterator = elements.iterator();

the identity of a server. The converse is also possible. Here we create a server that authenticates
a client and a client that authenticates a server.

```java
// Create the root for client and server to trust. We could also use different roots for each!
HeldCertificate rootCertificate = new HeldCertificate.Builder()
    .certificateAuthority(0)
    .build();

// Create a server certificate and a server that uses it.