ContiguousSet.closedOpen(1, 1),
            ContiguousSet.closedOpen(Integer.MIN_VALUE, Integer.MIN_VALUE),
            ImmutableSortedSet.of(),
            ImmutableSet.of())
        .testEquals();
    // not testing hashCode for these because it takes forever to compute
    assertEquals(
        ContiguousSet.closed(Integer.MIN_VALUE, Integer.MAX_VALUE),
        ContiguousSet.create(Range.<Integer>all(), integers()));

      return domain.minValue();
    }

    @Override
    Comparable<?> greatestValueBelow(DiscreteDomain<Comparable<?>> domain) {
      throw new AssertionError();
    }

    @Override
    Cut<Comparable<?>> canonical(DiscreteDomain<Comparable<?>> domain) {
      try {
        return Cut.belowValue(domain.minValue());
      } catch (NoSuchElementException e) {

    log_id bigint NOT NULL
);

ALTER TABLE public.log_usage ALTER COLUMN log_id ADD GENERATED BY DEFAULT AS IDENTITY (
    SEQUENCE NAME public.log_usage_log_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1
);
	`).Error; err != nil {
		t.Fatalf("failed to create table, got error %v", err)
	}

	columns, err := DB.Migrator().ColumnTypes("log_usage")
	if err != nil {

    checkNotNull(range);
    checkNotNull(domain);
    Range<C> effectiveRange = range;
    try {
      if (!range.hasLowerBound()) {
        effectiveRange = effectiveRange.intersection(Range.atLeast(domain.minValue()));
      }
      if (!range.hasUpperBound()) {
        effectiveRange = effectiveRange.intersection(Range.atMost(domain.maxValue()));
      }
    } catch (NoSuchElementException e) {

        serverData.sflags2 = Integer.MIN_VALUE;
        serverData.smaxMpxCount = Integer.MIN_VALUE;
        serverData.maxBufferSize = Integer.MIN_VALUE;
        serverData.sessKey = Integer.MIN_VALUE;
        serverData.scapabilities = Integer.MIN_VALUE;

        assertEquals(Integer.MIN_VALUE, serverData.sflags2);
        assertEquals(Integer.MIN_VALUE, serverData.smaxMpxCount);

        void shouldHandleMinimumLongValues() {
            // Given
            TestAllocInfo allocInfo = new TestAllocInfo(Long.MIN_VALUE, Long.MIN_VALUE);

            // When & Then
            assertEquals(Long.MIN_VALUE, allocInfo.getCapacity());
            assertEquals(Long.MIN_VALUE, allocInfo.getFree());
        }

        @Test
        @DisplayName("Should calculate used space correctly")

    integralBuilder.addAll(Doubles.asList(0.0, -0.0, Double.MAX_VALUE, -Double.MAX_VALUE));
    // Add small multiples of MIN_VALUE and MIN_NORMAL
    for (int scale = 1; scale <= 4; scale++) {
      for (double d : Doubles.asList(Double.MIN_VALUE, Double.MIN_NORMAL)) {
        fractionalBuilder.add(d * scale).add(-d * scale);
      }
    }

        assertEquals(Integer.MAX_VALUE, problem.getLineNumber());

        // this case is not specified, might also return -1
        problem = new DefaultProblem(null, null, null, Integer.MIN_VALUE, -1, null);
        assertEquals(Integer.MIN_VALUE, problem.getLineNumber());
    }

    @Test
    void testGetColumnNumber() {
        DefaultProblem problem = new DefaultProblem(null, null, null, -1, -1, null);

   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  // We use this method only for cases in which we need to decompose to primitives.

        // Test boundary values for safe operations
        assertEquals(Integer.MAX_VALUE, validator.safeAdd(Integer.MAX_VALUE, 0));
        assertEquals(Integer.MIN_VALUE, validator.safeAdd(Integer.MIN_VALUE, 0));
        assertEquals(0, validator.safeMultiply(0, Integer.MAX_VALUE));
        assertEquals(1, validator.safeMultiply(1, 1));

        // Test exact buffer boundaries