assertTrue(rangeSet.intersects(Range.greaterThan(2)));
    assertFalse(rangeSet.intersects(Range.greaterThan(7)));

    assertTrue(rangeSet.encloses(Range.closed(3, 4)));
    assertTrue(rangeSet.encloses(Range.closedOpen(1, 4)));
    assertTrue(rangeSet.encloses(Range.closedOpen(1, 5)));
    assertFalse(rangeSet.encloses(Range.greaterThan(2)));

    assertTrue(rangeSet.contains(3));

    testInvariants(rangeSet);
    assertThat(rangeSet.asRanges()).contains(Range.closed(1, 6));
    assertThat(rangeSet.complement().asRanges())
        .containsExactly(Range.lessThan(1), Range.greaterThan(6))
        .inOrder();
  }

  public void testIgnoresSmallerSharingLowerBound() {
    TreeRangeSet<Integer> rangeSet = TreeRangeSet.create();
    rangeSet.add(Range.closed(1, 6));

    Cut<Integer> a = Range.lessThan(0).lowerBound;
    Cut<Integer> b = Range.atLeast(0).lowerBound;
    Cut<Integer> c = Range.greaterThan(0).lowerBound;
    Cut<Integer> d = Range.atLeast(1).lowerBound;
    Cut<Integer> e = Range.greaterThan(1).lowerBound;
    Cut<Integer> f = Range.greaterThan(1).upperBound;

    testCompareToAndEquals(ImmutableList.of(a, b, c, d, e, f));
  }

  @SuppressWarnings("DistinctVarargsChecker")

			msg:  err.Error(),
		}
	}
	return nil
}

// BatchJobSizeFilter supports size based filters - LesserThan and GreaterThan
type BatchJobSizeFilter struct {
	line, col  int
	UpperBound BatchJobSize `yaml:"lessThan" json:"lessThan"`
	LowerBound BatchJobSize `yaml:"greaterThan" json:"greaterThan"`
}

// UnmarshalYAML - BatchJobSizeFilter extends unmarshal to extract line, column information

          value: image/* # match objects with 'content-type', all values starting with 'image/'
      size:
        lessThan: "10MiB" # match objects with size less than this value (e.g. 10MiB)
        greaterThan: 1MiB # match objects with size greater than this value (e.g. 1MiB)
      purge:
          # retainVersions: 0 # (default) delete all versions of the object. This option is the fastest.

        responseBodyEnd.bytesRead,
        responseBodyBytes,
      )
    } else {
      assertThat(listener.recordedEventTypes()).doesNotContain("ResponseBodyEnd")
    }
  }

  private fun greaterThan(value: Long): Matcher<Long?> {
    return object : BaseMatcher<Long?>() {
      override fun describeTo(description: Description?) {
        description!!.appendText("> $value")
      }

 * <tr><td>{@code [a..b)}  <td>{@code {x | a <= x < b}} <td>{@link Range#closedOpen closedOpen}
 * <tr><td>{@code (a..+∞)} <td>{@code {x | x > a}}      <td>{@link Range#greaterThan greaterThan}
 * <tr><td>{@code [a..+∞)} <td>{@code {x | x >= a}}     <td>{@link Range#atLeast atLeast}
 * <tr><td>{@code (-∞..b)} <td>{@code {x | x < b}}      <td>{@link Range#lessThan lessThan}

    assertThrows(
        IllegalArgumentException.class,
        () -> ContiguousSet.create(range, UNBOUNDED_THROWING_DOMAIN));
  }

  public void testCreate_noMax() {
    Range<Integer> range = Range.greaterThan(0);
    assertThrows(
        IllegalArgumentException.class,
        () -> ContiguousSet.create(range, UNBOUNDED_THROWING_DOMAIN));
  }

  public void testCreate_empty() {

    assertThrows(
        IllegalArgumentException.class,
        () -> ContiguousSet.create(range, UNBOUNDED_THROWING_DOMAIN));
  }

  public void testCreate_noMax() {
    Range<Integer> range = Range.greaterThan(0);
    assertThrows(
        IllegalArgumentException.class,
        () -> ContiguousSet.create(range, UNBOUNDED_THROWING_DOMAIN));
  }

  public void testCreate_empty() {

 * <tr><td>{@code [a..b)}  <td>{@code {x | a <= x < b}} <td>{@link Range#closedOpen closedOpen}
 * <tr><td>{@code (a..+∞)} <td>{@code {x | x > a}}      <td>{@link Range#greaterThan greaterThan}
 * <tr><td>{@code [a..+∞)} <td>{@code {x | x >= a}}     <td>{@link Range#atLeast atLeast}
 * <tr><td>{@code (-∞..b)} <td>{@code {x | x < b}}      <td>{@link Range#lessThan lessThan}