### 3. Configure `mc` and create another user user1 with attached policy user1policy

```
mc alias set myminio-admin1 http://localhost:9000 admin1 admin123 --api s3v4

mc admin user add myminio-admin1 user1 user123
mc admin policy attach myminio-admin1 user1policy ~/user1policy.json
mc admin policy attach myminio-admin1 user1policy --user=user1
```

### 4. List of permissions defined for admin operations

```

### Index from Query Logs

```java
import org.codelibs.fess.suggest.index.contents.querylog.QueryLog;

// Add suggestions from search query logs
QueryLog queryLog = new QueryLog("user search query", "user123");
suggester.indexer().indexFromQueryLog(queryLog);
```

### Popular Words Analytics

```java
import org.codelibs.fess.suggest.request.popularwords.PopularWordsResponse;

        assertEquals("\\", InputValidator.normalizeSmbPath("\\"));
    }

    @ParameterizedTest
    @DisplayName("Test valid usernames")
    @ValueSource(strings = { "user", "user123", "user.name", "user-name", "user_name", "******@****.***" })
    void testValidUsernames(String username) {
        assertDoesNotThrow(() -> InputValidator.validateUsername(username));
    }

    @ParameterizedTest

	DB.Where(&User{Name: "find or create", Age: 33}).FirstOrCreate(&user2)
	if user1.ID != user2.ID || user2.Name != "find or create" || user2.ID == 0 || user2.Age != 33 {
		t.Errorf("user should be created with search value")
	}

	DB.FirstOrCreate(&user3, map[string]interface{}{"name": "find or create 2"})
	if user3.Name != "find or create 2" || user3.ID == 0 {
		t.Errorf("user should be created with inline search value")
	}

        User user1 = createTestUser("user1", "User One");
        User user2 = createTestUser("user2", "User Two");
        User user3 = createTestUser("user3", "User Three");

        chain.update(user1);
        chain.update(user2);
        chain.update(user3);

        assertEquals(3, chain.updateCalls.size());
        assertEquals(user1, chain.updateCalls.get(0));

		// user
		CheckUser(t, user, users2[idx])
		if users2[idx].Manager == nil {
			t.Fatalf("Failed to load Manager")
		}
		// manager
		CheckUser(t, *user.Manager, *users2[idx].Manager)
		// user pet
		if users2[idx].NamedPet == nil {
			t.Fatalf("Failed to load NamedPet")
		}
		CheckPet(t, *user.NamedPet, *users2[idx].NamedPet)
		// manager pet
		if users2[idx].Manager.NamedPet == nil {

    // Test load with multiple chains (chained loading)
    public void test_load_multipleChains() {
        User user = createTestUser("user0");
        User user1 = createTestUser("user1");
        User user2 = createTestUser("user2");
        User user3 = createTestUser("user3");

        TestAuthenticationChain chain1 = new TestAuthenticationChain();
        TestAuthenticationChain chain2 = new TestAuthenticationChain();

        // Normal authentication should be allowed
        assertTrue(rateLimiter.checkAttempt("user1", "192.168.1.1"), "First attempt should be allowed");

        // Record success
        rateLimiter.recordSuccess("user1", "192.168.1.1");

        // Should still be allowed
        assertTrue(rateLimiter.checkAttempt("user1", "192.168.1.1"), "After success should be allowed");
    }

    @Test

        FessUserNotFoundException exception2 = new FessUserNotFoundException("user2");

        assertNotSame(exception1, exception2);
        assertFalse(exception1.getMessage().equals(exception2.getMessage()));
        assertEquals("User is not found: user1", exception1.getMessage());
        assertEquals("User is not found: user2", exception2.getMessage());
    }

    @Test
    @DisplayName("Test statistics accumulation")
    void testStatisticsAccumulation() {
        logger.logAuthentication(true, "user1", "DOMAIN", "192.168.1.1");
        logger.logAuthentication(false, "user2", "DOMAIN", "192.168.1.2");
        logger.logFileAccess("WRITE", "/file.txt", true, "user1");

        Map<EventType, Long> stats = logger.getStatistics();