@Test fun doesNotReadEntireSource() {
    val unlimitedSource =
      object : Source {
        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {
          sink.writeUtf8("a".repeat(byteCount.toInt()))
          return byteCount
        }

        override fun close() {
        }

        override fun timeout() = Timeout.NONE
      }

    /*
     * Padding from 40 into 64 bytes, same size as cache line. Might be beneficial to add a fourth
     * long here, to minimize chance of interference between consecutive locks, but I couldn't
     * observe any benefit from that.
     */
    long unused1;
    long unused2;
    long unused3;

    PaddedLock() {
      super(false);
    }
  }

    protected File workingDirectory = null;

    /** Maximum number of output lines to capture. */
    protected int maxOutputLine = 1000;

    /** Command execution timeout in milliseconds. */
    protected long executionTimeout = 30L * 1000L; // 30sec

    /** Character encoding for command output. */
    protected String commandOutputEncoding = Charset.defaultCharset().displayName();

 *
 * <p><b>Warning:</b> The methods of {@code ForwardingFuture} forward <b>indiscriminately</b> to the
 * methods of the delegate. For example, overriding {@link #get(long, TimeUnit)} alone <b>will
 * not</b> change the behavior of {@link #get()}, which can lead to unexpected behavior. In this
 * case, you should override {@code get()} as well.
 *

        assertTrue(result.contains("role1role2"));
        assertTrue(result.contains("field1field2"));
        assertTrue(result.contains("exclude1exclude2"));

        // Count separators
        long separatorCount = result.chars().filter(ch -> ch == '\n').count();
        assertEquals(4, separatorCount);
    }

    @Test
    public void test_getCacheKey_nullParameters() {
        String seed = "test_seed";

  fun value(index: Int): String = encodedValue(index).percentDecode(plusIsSpace = true)

  override fun contentType(): MediaType = CONTENT_TYPE

  override fun contentLength(): Long = writeOrCountBytes(null, true)

  @Throws(IOException::class)
  override fun writeTo(sink: BufferedSink) {
    writeOrCountBytes(sink, false)
  }

  /**

        }
    }

    @Test
    void testTimestampConsistency() {
        long beforeCreation = System.currentTimeMillis();
        WitnessNotification newNotification = new WitnessNotification(WitnessEventType.RESOURCE_CHANGE, "TestResource");
        long afterCreation = System.currentTimeMillis();

        assertTrue(newNotification.getTimestamp() >= beforeCreation);

    /** The job class to be executed by this scheduler */
    protected Class<? extends LaJob> jobClass = ScriptExecutorJob.class;

    /** The timestamp when the scheduler was last updated */
    protected long schedulerTime;

    @Override
    public void schedule(final LaCron cron) {
        schedulerTime = systemHelper.getCurrentTimeAsLong();
        scheduledJobService.start(cron);

  private final transient int size;

  @LazyInit private transient @Nullable ImmutableSet<E> elementSet;

  RegularImmutableMultiset(ObjectCountHashMap<E> contents) {
    this.contents = contents;
    long size = 0;
    for (int i = 0; i < contents.size(); i++) {
      size += contents.getValue(i);
    }
    this.size = Ints.saturatedCast(size);
  }

  @Override
  boolean isPartialView() {
    return false;

    @Size(max = 1000)
    public String updatedBy;

    /**
     * The timestamp when this access token was last updated.
     * Stored as a long value representing milliseconds since epoch.
     * Used for audit trail and concurrency control.
     */
    @ValidateTypeFailure
    public Long updatedTime;

    /**
     * The version number of the access token for optimistic locking.