assertEquals(0, new BigDecimal("0.0000001").compareTo(BigDecimalConversionUtil.toBigDecimal(Double.valueOf(0.0000001D))));

        assertEquals(0, new BigDecimal("0.123").compareTo(BigDecimalConversionUtil.toBigDecimal(Double.valueOf(0.123D))));
        assertEquals(0, new BigDecimal("0.0123").compareTo(BigDecimalConversionUtil.toBigDecimal(Double.valueOf(0.0123D))));

    Set<Integer> set2 = newHashSet(2, 3);
    Set<Integer> union = union(set1, set2);
    assertThat(union).containsExactly(1, 2, 3);
    set1.add(0);
    assertThat(union).containsExactly(0, 1, 2, 3);
    set2.remove(3);
    assertThat(union).containsExactly(0, 1, 2);
  }

  public void testIntersection_isView() {
    Set<Integer> set1 = newHashSet(1, 2);
    Set<Integer> set2 = newHashSet(2, 3);

    ImmutableLongArray.of().forEach(i -> fail());
    ImmutableLongArray.of(0, 1, 3).subArray(1, 1).forEach(i -> fail());

    AtomicLong count = new AtomicLong(0);
    ImmutableLongArray.of(0, 1, 2, 3)
        .forEach(i -> assertThat(i).isEqualTo(count.getAndIncrement()));
    assertThat(count.get()).isEqualTo(4);
  }

  public void testStream() {
    ImmutableLongArray.of().stream().forEach(i -> fail());

    // separate above
    expected =
        assertThrows(
            IllegalArgumentException.class, () -> range.intersection(Range.closed(10, 12)));
    assertThat(expected).hasMessageThat().contains("connected");
  }

  public void testGap_overlapping() {
    Range<Integer> range = Range.closedOpen(3, 5);

        searchRenderData.setExecTime("");
        assertEquals("", searchRenderData.getExecTime());

        // Test with formatted time string
        searchRenderData.setExecTime("0.123 sec");
        assertEquals("0.123 sec", searchRenderData.getExecTime());
    }

    public void test_setAndGetPageSize() {
        // Test with zero
        searchRenderData.setPageSize(0);

    assertTrue(permutationSet.contains(newArrayList(2, 3, 1)));
    assertFalse(permutationSet.contains(newArrayList(1, 2)));
    assertFalse(permutationSet.contains(newArrayList(1, 1, 2, 3)));
    assertFalse(permutationSet.contains(newArrayList(1, 2, 3, 4)));
    assertFalse(permutationSet.contains(null));
  }

  public void testPermutationSetEmpty() {
    Collection<List<Integer>> permutationSet =

        in 5..7 -> {
          data.writeByte('\n'.code) // 'data' on a line of its own.
        }

        in 8..9 -> {
          id = source.readUtf8LineStrict().takeIf { it.isNotEmpty() }
        }

        in 10..12 -> {
          id = null // 'id' on a line of its own.
        }

        in 13..14 -> {
          type = source.readUtf8LineStrict().takeIf { it.isNotEmpty() }
        }

        in 15..17 -> {

    ImmutableDoubleArray.of().forEach(i -> fail());
    ImmutableDoubleArray.of(0, 1, 3).subArray(1, 1).forEach(i -> fail());

    AtomicInteger count = new AtomicInteger(0);
    ImmutableDoubleArray.of(0, 1, 2, 3)
        .forEach(i -> assertThat(i).isEqualTo((double) count.getAndIncrement()));
    assertThat(count.get()).isEqualTo(4);
  }

  public void testStream() {

    ImmutableIntArray.of().forEach(i -> fail());
    ImmutableIntArray.of(0, 1, 3).subArray(1, 1).forEach(i -> fail());

    AtomicInteger count = new AtomicInteger(0);
    ImmutableIntArray.of(0, 1, 2, 3).forEach(i -> assertThat(i).isEqualTo(count.getAndIncrement()));
    assertThat(count.get()).isEqualTo(4);
  }

  public void testStream() {
    ImmutableIntArray.of().stream().forEach(i -> fail());

    ImmutableDoubleArray.of().forEach(i -> fail());
    ImmutableDoubleArray.of(0, 1, 3).subArray(1, 1).forEach(i -> fail());

    AtomicInteger count = new AtomicInteger(0);
    ImmutableDoubleArray.of(0, 1, 2, 3)
        .forEach(i -> assertThat(i).isEqualTo((double) count.getAndIncrement()));
    assertThat(count.get()).isEqualTo(4);
  }

  public void testStream() {