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"));

    ++task_iter;
  }
  auto results = coord_agent->GetTaskState(task_vec);
  if (!results.ok()) {
    status->status = results.status();
    return;
  }
  auto* state_iter = static_cast<TF_Status*>(states);
  for (size_t i = 0; i < tasks.length; ++i) {
    const auto& result = (*results)[i];
    TF_Status s;
    TF_SetStatus(&s, static_cast<TF_Code>(result.error_code()),

        String longString1 = "a".repeat(1000);
        String longString2 = "b".repeat(1000);
        String result = StringUtil.join(",", longString1, longString2);
        assertEquals(2001, result.length()); // 1000 + 1 + 1000
        assertTrue(result.startsWith("aaa"));
        assertTrue(result.endsWith("bbb"));
        assertTrue(result.contains(","));
    }

    @Test
    @DisplayName("Should handle long delimiter")

	DB.Create(&namedUser)

	var result NamedUser
	DB.First(&result, "name1 = @name OR name2 = @name OR name3 = @name", sql.Named("name", "jinzhu2"))

	AssertEqual(t, result, namedUser)

	var result2 NamedUser
	DB.Where("name1 = @name OR name2 = @name OR name3 = @name", sql.Named("name", "jinzhu2")).First(&result2)

	AssertEqual(t, result2, namedUser)

	var result3 NamedUser

        assertNotNull(result);
        assertTrue(result.isPresent());
        assertEquals(Integer.valueOf(42), result.get());
    }

    @Test
    public void test_ofNullable_withNullInteger() {
        Integer testValue = null;
        OptionalEntity<Integer> result = OptionalUtil.ofNullable(testValue);

        assertNotNull(result);
        assertFalse(result.isPresent());

			clause.NamedExpr{SQL: result.SQL, Vars: result.Vars}.Build(stmt)
			if stmt.SQL.String() != result.Result {
				t.Errorf("generated SQL is not equal, expects %v, but got %v", result.Result, stmt.SQL.String())
			}

			if !reflect.DeepEqual(result.ExpectedVars, stmt.Vars) {
				t.Errorf("generated vars is not equal, expects %v, but got %v", result.ExpectedVars, stmt.Vars)
			}
		})
	}
}

        String result = popularWordHelper.getCacheKey(seed, tags, roles, fields, excludes);

        assertNotNull(result);
        assertTrue(result.contains("test_seed"));
        assertTrue(result.contains("tag1tag2"));
        assertTrue(result.contains("role1role2"));
        assertTrue(result.contains("field1field2"));
        assertTrue(result.contains("exclude1exclude2"));

        // Assert
        assertNotNull(result);
        assertTrue(result.contains("TransWaitNamedPipe"));
        assertTrue(result.contains("pipeName=null"));
    }

    @Test
    @DisplayName("toString with special characters in pipe name")
    void testToStringWithSpecialCharacters() {
        // Arrange
        String specialPipeName = "\\PIPE\\test$pipe#123";

        QueryContext context = new QueryContext("test", false);
        QueryBuilder result = booleanQueryCommand.execute(context, booleanQuery, 1.0f);

        assertNotNull(result);
        assertTrue(result instanceof BoolQueryBuilder);

        BoolQueryBuilder boolResult = (BoolQueryBuilder) result;
        assertTrue(boolResult.hasClauses());
    }

        setupVirtualHostHelper();

        Boolean result = invokeIsValidVirtualHostPath("");
        assertTrue("Empty path should be valid (default host)", result);
    }

    @Test
    public void test_isValidVirtualHostPath_nullPath() throws Exception {
        setupVirtualHostHelper();

        Boolean result = invokeIsValidVirtualHostPath(null);