if (content.length() <= bodyBudget) {
            return content + suffix;
        }
        if (bodyBudget <= 0) {
            return suffix;
        }
        return content.substring(0, bodyBudget) + truncMarker + suffix;
    }

    /**
     * Builds a summary string from source document titles and URLs.
     *

        assertNull(result);
    }

    @Test
    public void test_smartSummary_exactlyAtBudget() {
        // omitMarker = "\n...[omitted]...\n" (18 chars), suffix="" (no sources), bodyBudget = 500 - 0 - 18 = 482
        // Content of 482 chars is <= bodyBudget, so returned with suffix (empty) appended as-is
        final String content = "X".repeat(482);
        final ChatMessage msg = ChatMessage.assistantMessage(content);

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"testing"
)

func TestExtractPrefixAndSuffix(t *testing.T) {
	specs := []struct {
		path, prefix, suffix string
		expected             string
	}{
		{"config/iam/groups/foo.json", "config/iam/groups/", ".json", "foo"},
		{"config/iam/groups/./foo.json", "config/iam/groups/", ".json", "foo"},

            # This is a non-_an file, check if there's an _an version referenced
            # Insert _an before any version suffix or at the end of the stem
            stem = py_file.stem
            for suffix in ("_py39", "_py310"):
                if suffix in stem:
                    an_stem = stem.replace(suffix, f"_an{suffix}", 1)
                    break
            else:
                an_stem = f"{stem}_an"

            result.getOutput(),
            "Tests classes with suffix `IT` should extend org.elasticsearch.gradle.testkit.Integration but the following classes do not:",
            "  * org.elasticsearch.gradle.testkit.NamingConventionIT",
            "  * org.elasticsearch.gradle.testkit.NamingConventionMissmatchIT",

    // Test getLogName method
    @Test
    public void test_getLogName() {
        // Test without suffix
        execJob.logSuffix = "";
        assertEquals("prefix-test", execJob.testGetLogName("prefix"));

        // Test with suffix
        execJob.logSuffix = "suffix";
        assertEquals("prefix-test-suffix", execJob.testGetLogName("prefix"));

        // Test with different execute type

func (err ErrFilterNamePrefix) Error() string {
	return "more than one prefix in filter rule"
}

// ErrFilterNameSuffix - more than one suffix usage error.
type ErrFilterNameSuffix struct{}

func (err ErrFilterNameSuffix) Error() string {
	return "more than one suffix in filter rule"
}

// ErrInvalidFilterValue - invalid filter value error.
type ErrInvalidFilterValue struct {
	FilterValue string
}

// CutSuffix returns s without the provided ending suffix byte slice
// and reports whether it found the suffix.
// If s doesn't end with suffix, CutSuffix returns s, false.
// If suffix is the empty byte slice, CutSuffix returns s, true.
//
// CutSuffix returns slices of the original slice s, not copies.
func CutSuffix(s, suffix []byte) (before []byte, found bool) {
	if !HasSuffix(s, suffix) {
		return s, false
	}

    String refreshKey = "refresh";
    String suffix = "Suffix";

    CacheLoader<String, String> computeFunction =
        new CacheLoader<String, String>() {
          @Override
          public String load(String key) throws InterruptedException {
            getStartedSignal.countDown();
            letGetFinishSignal.await();
            return key + suffix;
          }
        };

      p--;
    }
    return a.subSequence(0, p).toString();
  }

  /**
   * Returns the longest string {@code suffix} such that {@code a.toString().endsWith(suffix) &&
   * b.toString().endsWith(suffix)}, taking care not to split surrogate pairs. If {@code a} and
   * {@code b} have no common suffix, returns the empty string.
   *
   * @since 11.0
   */
  public static String commonSuffix(CharSequence a, CharSequence b) {