if (!expectedValues.containsKey(UNNECESSARY)) {
        assertWithMessage("Expected roundUnnecessaryShouldThrow call")
            .that(unnecessaryShouldThrow)
            .isTrue();
        assertThrows(
            "Expected ArithmeticException for roundToDouble(" + input + ", UNNECESSARY)",
            ArithmeticException.class,
            () -> BigDecimalMath.roundToDouble(input, UNNECESSARY));
      }
    }
  }

            .isEqualTo(expectation);
      }

      if (!expectedValues.containsKey(UNNECESSARY)) {
        assertWithMessage("Expected roundUnnecessaryShouldThrow call")
            .that(unnecessaryShouldThrow)
            .isTrue();
        assertThrows(
            ArithmeticException.class, () -> BigIntegerMath.roundToDouble(input, UNNECESSARY));
      }
    }
  }

  @J2ktIncompatible
  @GwtIncompatible

      if (!expectedValues.containsKey(UNNECESSARY)) {
        assertWithMessage("Expected roundUnnecessaryShouldThrow call")
            .that(unnecessaryShouldThrow)
            .isTrue();
        assertThrows(
            "Expected ArithmeticException for roundToDouble(" + input + ", UNNECESSARY)",
            ArithmeticException.class,
            () -> BigDecimalMath.roundToDouble(input, UNNECESSARY));
      }
    }
  }

        case UP:
          return roundArbitrarily;
        case UNNECESSARY:
          throw new ArithmeticException(x + " cannot be represented precisely as a double");
      }
    }
    X roundArbitrarilyAsX = toX(roundArbitrarily, RoundingMode.UNNECESSARY);
    int cmpXToRoundArbitrarily = x.compareTo(roundArbitrarilyAsX);
    switch (mode) {
      case UNNECESSARY:
        checkRoundingUnnecessary(cmpXToRoundArbitrarily == 0);

   * @throws ArithmeticException if {@code mode} is {@link RoundingMode#UNNECESSARY} and {@code x}
   *     is not a power of two
   */
  @SuppressWarnings("fallthrough")
  // TODO(kevinb): remove after this warning is disabled globally
  public static int log2(long x, RoundingMode mode) {
    checkPositive("x", x);
    switch (mode) {
      case UNNECESSARY:
        checkRoundingUnnecessary(isPowerOfTwo(x));
      // fall through

    // ImmutableMap.Builder maintains the order of the elements as inserted, so the map will have
    // whatever ordering the network's nodes do, so ImmutableSortedMap is unnecessary even if the
    // input nodes are sorted.
    ImmutableMap.Builder<N, NetworkConnections<N, E>> nodeConnections = ImmutableMap.builder();
    for (N node : network.nodes()) {

    }
}
```
This is unnecessary because this value is not calculated and cannot be changed.

#### Nested values

This is an inappropriate use of lazy types:

```groovy
interface NestedType {
    Property<String> getSomeProperty()
}
class Example {
    Property<NestedType> getNestedProperty()
}
```

            "Builds Gradle with the version of Gradle which is currently under development (twice)$descriptionSuffix"

        requirements {
            requiresNotSharedHost()
        }

    /*
     To avoid unnecessary rerun, what we do here is a bit complicated:

     1. Build a Gradle distribution with a fixed timestamp and hash it, but never use this distribution.

      Graph<N> graph) {
    // ImmutableMap.Builder maintains the order of the elements as inserted, so the map will have
    // whatever ordering the graph's nodes do, so ImmutableSortedMap is unnecessary even if the
    // input nodes are sorted.
    ImmutableMap.Builder<N, GraphConnections<N, Presence>> nodeConnections = ImmutableMap.builder();
    for (N node : graph.nodes()) {

      ValueGraph<N, V> graph) {
    // ImmutableMap.Builder maintains the order of the elements as inserted, so the map will have
    // whatever ordering the graph's nodes do, so ImmutableSortedMap is unnecessary even if the
    // input nodes are sorted.
    ImmutableMap.Builder<N, GraphConnections<N, V>> nodeConnections = ImmutableMap.builder();
    for (N node : graph.nodes()) {