FessConfig mockConfig = new FessConfig.SimpleImpl();
        ComponentUtil.setFessConfig(mockConfig);

        FessConfig result1 = ComponentUtil.getFessConfig();
        FessConfig result2 = ComponentUtil.getFessConfig();

        assertSame(result1, result2);
        assertSame(mockConfig, result1);
    }

    public void test_register_and_getComponent() {
        String testInstance = "test_instance";

        // Call getSecurity multiple times - should return consistent results
        ACE[] result1 = msrpcShareGetInfo.getSecurity();
        ACE[] result2 = msrpcShareGetInfo.getSecurity();

        // Both should be null (no DACL)
        assertNull(result1);
        assertNull(result2);
    }

    @Test

        // First call should read the file
        NbtAddress result1 = lmhosts.getByName("TESTHOST", mockContext);
        assertNotNull(result1);

        // Second call should use cached data (file not modified)
        NbtAddress result2 = lmhosts.getByName("TESTHOST", mockContext);
        assertNotNull(result2);
        assertEquals(result1, result2);
    }

    @Test

        assertTrue(result.contains("TransWaitNamedPipeResponse["));
        assertTrue(result.endsWith("]"));
    }

    @Test
    @DisplayName("toString should include parent class information")
    void testToStringIncludesParentInfo() {
        // Act
        String result = response.toString();

        // Assert
        assertNotNull(result);
        assertTrue(result.contains("TransWaitNamedPipeResponse"));

	}

	for _, lang := range langs {
		var results []Language
		if err := DB.Find(&results, "code = ?", lang.Code).Error; err != nil {
			t.Errorf("no error should happen when find languages with code, but got %v", err)
		} else if len(results) != 1 {
			t.Errorf("should only find only 1 languages, but got %+v", langs)
		} else if results[0].Name != lang.Name {

        // Execute the job multiple times
        String result1 = purgeDocJob.execute();

        // Reset the flag
        deleteByQueryCalled = false;

        String result2 = purgeDocJob.execute();

        // Assert both executions were successful
        assertEquals("", result1);
        assertEquals("", result2);
        assertTrue(deleteByQueryCalled);
    }

			}
		}

		send := func(result healEntryResult) bool {
			select {
			case <-ctx.Done():
				if !contextCanceled(ctx) {
					healingLogIf(ctx, ctx.Err())
				}
				return false
			case results <- result:
				bgSeq.countScanned(madmin.HealItemObject)
				return true
			}
		}

		// Note: updates from healEntry to tracker must be sent on results channel.

            // Given
            when(transportPool.close()).thenReturn(false);

            // When
            boolean result1 = transportPool.close();
            boolean result2 = transportPool.close();

            // Then
            assertFalse(result1);
            assertFalse(result2);
            verify(transportPool, times(2)).close();
        }
    }

    @Nested

	user3 := User{Name: "ExecRawSqlUser3", Age: 20}
	DB.Save(&user1).Save(&user2).Save(&user3)

	type result struct {
		Name  string
		Email string
	}

	var results []result
	DB.Raw("SELECT name, age FROM users WHERE name = ? or name = ?", user2.Name, user3.Name).Scan(&results)
	if len(results) != 2 || results[0].Name != user2.Name || results[1].Name != user3.Name {
		t.Errorf("Raw with scan")
	}

	}
	constraints := user.ParseUniqueConstraints()

	results := map[string]schema.UniqueConstraint{
		"uni_user_uniques_name1": {
			Name:  "uni_user_uniques_name1",
			Field: &schema.Field{Name: "Name1", Unique: true},
		},
	}
	for k, result := range results {
		v, ok := constraints[k]
		if !ok {
			t.Errorf("Failed to found unique constraint %v from parsed constraints %+v", k, constraints)
		}