.build();

    assertThat(RANGE_SET_ONE.union(RANGE_SET_TWO)).isEqualTo(expected);
  }

  public void testIntersection() {
    RangeSet<Integer> expected =
        ImmutableRangeSet.<Integer>builder()
            .add(Range.closed(2, 3))
            .add(Range.open(6, 7))
            .add(Range.singleton(8))
            .build();

    // sanity check on construction of copyOfWrappedSet
    assertThat(wrappedSet).isEqualTo(copyOfWrappedSet);

    // test that setToTest is still valid
    assertThat(setToTest).isEqualTo(wrappedSet);
    assertThat(setToTest).isEqualTo(copyOfWrappedSet);

    // invalidate setToTest
    wrappedSet.remove(1);
    // sanity check on update of wrappedSet
    assertThat(wrappedSet).isNotEqualTo(copyOfWrappedSet);

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.maven.model.v4.MavenMerger;
import org.junit.jupiter.api.Test;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasItems;

class FileToRawModelMergerTest {

    /**
     * Ensures that all list-merge methods are overridden
     */
    @Test
    void testOverriddenMergeMethods() {

    assertThat(expected).hasCauseThat().isEqualTo(UNCHECKED_EXCEPTION);
  }

  public void testGetCheckedUntimed_executionExceptionError() throws TwoArgConstructorException {
    ExecutionError expected =
        assertThrows(
            ExecutionError.class,
            () -> getChecked(FAILED_FUTURE_ERROR, TwoArgConstructorException.class));
    assertThat(expected).hasCauseThat().isEqualTo(ERROR);
  }

      )

    val partAbc = parts.nextPart()!!
    assertThat(partAbc.headers).isEqualTo(headersOf("Content-ID", "abc"))
    assertThat(partAbc.body.readUtf8()).isEqualTo("abcd")

    val partEfg = parts.nextPart()!!
    assertThat(partEfg.headers).isEqualTo(headersOf("Content-ID", "efg"))
    assertThat(partEfg.body.readUtf8()).isEqualTo("efgh")

    assertThat(parts.nextPart()).isNull()
  }

      Throwable throwable, Class<? extends Throwable> clazz, Object[] params) {
    assertThat(throwable).isInstanceOf(clazz);
    if (params.length == 1) {
      assertThat(throwable).hasMessageThat().isNull();
    } else if (params.length == 2) {
      assertThat(throwable).hasMessageThat().isEmpty();
    } else {
      assertThat(throwable)
          .hasMessageThat()

        .build()
    assertThat(body.boundary).isEqualTo("123")
    assertThat(body.type).isEqualTo(MultipartBody.MIXED)
    assertThat(body.contentType().toString())
      .isEqualTo("multipart/mixed; boundary=123")
    assertThat(body.parts.size).isEqualTo(1)
    assertThat(body.contentLength()).isEqualTo(33L)
    val buffer = Buffer()
    body.writeTo(buffer)
    assertThat(body.contentLength()).isEqualTo(buffer.size)

    operator.write(0, buffer1, 5)
    assertThat(buffer1.readUtf8()).isEqualTo(", World")
    val buffer2 = Buffer().writeUtf8("icopter!")
    operator.write(3, buffer2, 7)
    assertThat(buffer2.readUtf8()).isEqualTo("!")
    assertThat<ByteString>(snapshot()).isEqualTo("Helicopter".encodeUtf8())
  }

  @Test
  fun readAndWrite() {
    val operator =
      FileOperator(

  public void testDecodeInt() {
    assertThat(UnsignedInts.decode("0xffffffff")).isEqualTo(0xffffffff);
    assertThat(UnsignedInts.decode("01234567")).isEqualTo(01234567); // octal
    assertThat(UnsignedInts.decode("#12345678")).isEqualTo(0x12345678);
    assertThat(UnsignedInts.decode("76543210")).isEqualTo(76543210);
    assertThat(UnsignedInts.decode("0x13579135")).isEqualTo(0x13579135);

            .build();

    addEdges(network);

    assertThat(network.edgeOrder())
        .isEqualTo(ElementOrder.sorted(Ordering.<String>natural().reverse()));
    assertThat(network.edges()).containsExactly("p", "i", "e").inOrder();
    assertThat(network.nodeOrder()).isEqualTo(unordered());
    assertThat(network.nodes()).containsExactly(4, 1, 3);
  }

  // Sorting of user-defined classes