1. Go to kibana home [http://localhost:5601/](http://localhost:5601/).
1. Click **Management**.
1. Click **Index Patterns**.
1. Click **Create index pattern** button
1. Input "fess\_log\*" to the textbox of **index pattern**.
1. Click **Next step**.
1. Set "requestedAt" to the **Time Filter field name**.
1. Click **Create index pattern**.
1. Click **Saved Objects**.
1. Click **Import** and select "fess\_log.ndjson" to import example settings.

    //                                         -------------
    /**
     * Create an access token.
     * @param form The create form.
     * @return The HTML response.
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse create(final CreateForm form) {
        verifyCrudMode(form.crudMode, CrudMode.CREATE, this::asListHtml);
        validate(form, messages -> {}, this::asEditHtml);

  private TestCallable firstCallable;

  @Override
  public void setUp() throws Exception {
    executor = newCachedThreadPool();
    serializer = ExecutionSequencer.create();
    firstFuture = SettableFuture.create();
    firstCallable = new TestCallable(firstFuture);
  }

  @Override
  public void tearDown() throws Exception {
    executor.shutdown();
  }

  public void testFromFluentFuture() {
    FluentFuture<String> f = FluentFuture.from(SettableFuture.create());
    assertThat(FluentFuture.from(f)).isSameInstanceAs(f);
  }

  public void testFromFluentFuturePassingAsNonFluent() {
    ListenableFuture<String> f = FluentFuture.from(SettableFuture.create());
    assertThat(FluentFuture.from(f)).isSameInstanceAs(f);
  }

///

## Create a Project { #create-a-project }

First, create a directory for your project.

What I normally do is that I create a directory named `code` inside my home/user directory.

And inside of that I create one directory per project.

<div class="termy">

```console
// Go to the home directory
$ cd
// Create a directory for all your code projects
$ mkdir code

        // Create a domain info with test data
        lsarpc.LsarDomainInfo domainInfo = new lsarpc.LsarDomainInfo();
        domainInfo.name = new rpc.unicode_string();
        domainInfo.name.length = 10;
        domainInfo.name.maximum_length = 20;
        domainInfo.name.buffer = new short[] { 'T', 'e', 's', 't', '1' };

        // Create a simple test SID
        domainInfo.sid = new rpc.sid_t();

class DfsReferralTest {

    /**
     * Test the constructor and the getData method.
     */
    @Test
    void testConstructorAndGetData() {
        // Create a mock DfsReferralData object
        DfsReferralData mockData = mock(DfsReferralData.class);

        // Create a DfsReferral instance with the mock data
        DfsReferral dfsReferral = new DfsReferral(mockData);

        // Verify that getData() returns the same mock data object

   * underlying data structure.
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      ArrayListMultimap<K, V> create() {
    return new ArrayListMultimap<>();
  }

  /**
   * Constructs an empty {@code ArrayListMultimap} with enough capacity to hold the specified
   * numbers of keys and values without resizing.
   *

To use `TestClient`, first install [`httpx`](https://www.python-httpx.org).

Make sure you create a [virtual environment](../virtual-environments.md), activate it, and then install it, for example:

```console
$ pip install httpx
```

///

Import `TestClient`.

Create a `TestClient` by passing your **FastAPI** application to it.

Create functions with a name that starts with `test_` (this is standard `pytest` conventions).

import (
	"testing"

	. "gorm.io/gorm/utils/tests"
)

func TestHasOneAssociation(t *testing.T) {
	user := *GetUser("hasone", Config{Account: true})

	if err := DB.Create(&user).Error; err != nil {
		t.Fatalf("errors happened when create: %v", err)
	}

	CheckUser(t, user, user)

	// Find
	var user2 User
	DB.Find(&user2, "id = ?", user.ID)
	DB.Model(&user2).Association("Account").Find(&user2.Account)