@Param({"3", "30", "300"})
  int count;

  @Param({"0", "1", "16", "32", "100"})
  int componentLength;

  private Iterable<String> components;

  @BeforeExperiment
  @SuppressWarnings("InlineMeInliner") // String.repeat unavailable under Java 8
  void setUp() {
    String component = Strings.repeat("a", componentLength);
    String[] raw = new String[count];
    Arrays.fill(raw, component);

	QueueLength int

	// TotalMessages is the total number of messages sent in the lifetime of the target
	TotalMessages int64

	// FailedMessages should log message count that failed to send.
	FailedMessages int64

        sid = new SID(buf, bi);
        return size;
    }

    void appendCol(final StringBuffer sb, final String str, final int width) {
        sb.append(str);
        final int count = width - str.length();
        for (int i = 0; i < count; i++) {
            sb.append(' ');
        }
    }

    /**
     * Return a string represeting this ACE.
     * <p>

	filter := func(list []uint64) (commonCount uint64) {
		maxCnt := 0
		signatureMap := map[uint64]int{}
		for _, v := range list {
			signatureMap[v]++
		}
		for ops, count := range signatureMap {
			if maxCnt < count && commonCount < ops {
				maxCnt = count
				commonCount = ops
			}
		}
		if maxCnt < readQuorum {
			return 0
		}
		return commonCount
	}

	commonWrite = filter(writes)

<?xml version="1.0" encoding="UTF-8" ?>
<eef>
	<config Schema="2.0" EnterpriseVersion="'7.6.50'">
		<collections Count="3">
			<collection Name="fess">
				<bad_urls><![CDATA[
https://fess.codelibs.org/images/
              ]]></bad_urls>
				<good_urls><![CDATA[
https://fess.codelibs.org/
https://www.codelibs.org/
              ]]></good_urls>
				<prerequisite_results><![CDATA[
20
              ]]></prerequisite_results>

                    final BooleanFunction<Map<String, Object>> cursor) {
                long count = 0;
                for (final Map<String, Object> doc : documents) {
                    count++;
                    if (!cursor.apply(doc)) {
                        break;
                    }
                }
                return count;
            }
        };

package schema_test

import (
	"database/sql"
	"time"

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

type User struct {
	*gorm.Model
	Name      *string
	Age       *uint
	Birthday  *time.Time
	Account   *tests.Account
	Pets      []*tests.Pet
	Toys      []*tests.Toy `gorm:"polymorphic:Owner"`
	CompanyID *int
	Company   *tests.Company
	ManagerID *uint
	Manager   *User

                    java.util.function.BiFunction<org.opensearch.action.update.UpdateRequestBuilder, org.opensearch.search.SearchHit, org.opensearch.action.update.UpdateRequestBuilder> processor) {
                // Return a fixed count for testing
                return 3L;
            }
        };
        ComponentUtil.register(mockSearchEngineClient, "searchEngineClient");

        // Mock FessConfig

            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                SmbComWriteAndXResponse response = invocation.getArgument(1);
                response.count = 1;
                return null;
            }
        }).when(smbFile).send(any(SmbComWriteAndX.class), any(SmbComWriteAndXResponse.class));

        smbRandomAccessFile.write(42);

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * {@code ObjectCountHashMap} uses arrays to store key objects and count values. Comparing to using
 * a traditional {@code HashMap} implementation which stores keys and count values as map entries,
 * {@code ObjectCountHashMap} minimizes object allocation and reduces memory footprint.
 *