* @param h1 the first hour
         * @param m1 the first minute
         * @param h2 the second hour
         * @param m2 the second minute
         * @return positive if first time is earlier, 0 if equal, negative if later
         */
        protected int compareTime(final int h1, final int m1, final int h2, final int m2) {
            if (h1 < h2) {
                return 1;
            }
            if (h1 == h2) {

        // Test zero version
        EmptySearchLogEvent emptyEvent = new EmptySearchLogEvent();
        assertEquals(Long.valueOf(0L), emptyEvent.getVersionNo());

        // Test negative version
        event.setVersionNo(-1L);
        assertEquals(Long.valueOf(-1L), event.getVersionNo());

        // Test max version
        event.setVersionNo(Long.MAX_VALUE);

        // When
        request.setTid(tid);

        // Then
        verify(request, times(1)).setTid(tid);
    }

    @Test
    @DisplayName("Test setTid with negative value")
    void testSetTidWithNegativeValue() {
        // Given
        int tid = -1;
        doNothing().when(request).setTid(tid);

        // When
        request.setTid(tid);

        // Then

            throw new IllegalArgumentException("Success threshold must be at least 1");
        }
        if (timeoutMillis < 0) {
            throw new IllegalArgumentException("Timeout must be non-negative");
        }
    }

    /**
     * Execute a callable through the circuit breaker
     *
     * @param <T> return type
     * @param callable the callable to execute
     * @return the result

        assertEquals((byte) 0x00, buffer[1]);
        assertEquals((byte) 0x00, buffer[2]);
        assertEquals((byte) 0x00, buffer[3]);
    }

    @Test
    @DisplayName("Should handle negative FID values")
    void testNegativeFid() {
        // Arrange
        int negativeFid = -1;
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, negativeFid);

   *
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#limit} (same).
   *
   * @param maxSize the maximum number of elements in the returned fluent iterable
   * @throws IllegalArgumentException if {@code size} is negative
   */
  public final FluentIterable<E> limit(int maxSize) {
    return from(Iterables.limit(getDelegate(), maxSize));
  }

  /**
   * Determines whether this fluent iterable is empty.
   *

   *
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#limit} (same).
   *
   * @param maxSize the maximum number of elements in the returned fluent iterable
   * @throws IllegalArgumentException if {@code size} is negative
   */
  public final FluentIterable<E> limit(int maxSize) {
    return from(Iterables.limit(getDelegate(), maxSize));
  }

  /**
   * Determines whether this fluent iterable is empty.
   *

      }
    }
    return s;
  }

  /** Escapes the given Unicode code point in UTF-8. */
  @Override
  protected char @Nullable [] escape(int cp) {
    // We should never get negative values here but if we do it will throw an
    // IndexOutOfBoundsException, so at least it will get spotted.
    if (cp < safeOctets.length && safeOctets[cp]) {
      return null;
    } else if (cp == ' ' && plusForSpace) {

 *
 * @author Colin Decker
 */
final class SubscriberRegistry {

  /**
   * All registered subscribers, indexed by event type.
   *
   * <p>The {@link CopyOnWriteArraySet} values make it easy and relatively lightweight to get an
   * immutable snapshot of all current subscribers to an event without any locking.
   */
  private final ConcurrentMap<Class<?>, CopyOnWriteArraySet<Subscriber>> subscribers =

        )
        if (dateCharacter == !invert) return i
      }
      return limit
    }

    /**
     * Returns the positive value if [s] is positive, or [Long.MIN_VALUE] if it is either 0 or
     * negative. If the value is positive but out of range, this returns [Long.MAX_VALUE].
     *
     * @throws NumberFormatException if [s] is not an integer of any precision.
     */
    private fun parseMaxAge(s: String): Long {