Mocking sophisticated classes like `OkHttpClient` is fragile and you
    shouldn’t do it. But if that’s how you want to live your life we won’t stand
    in your way!


## Version 3.0.1

_2016-01-14_

 *  Rollback OSGi support. This was causing library jars to include more classes
    than expected, which interfered with Gradle builds.


## Version 3.0.0

   * on arbitrary {@link Map} classes.
   *
   * <p>The {@code factory}-generated and {@code backingMap} classes determine the table iteration
   * order. However, the table's {@code row()} method returns instances of a different class than
   * {@code factory.get()} does.
   *
   * <p>Call this method only when the simpler factory methods in classes like {@link

      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>com.google.inject</groupId>
      <artifactId>guice</artifactId>
      <classifier>classes</classifier>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <scope>test</scope>

By default, MinIO shards the objects across N/2 data and N/2 parity drives. Though, you can use [storage classes](https://github.com/minio/minio/tree/master/docs/erasure/storage-class) to use a custom configuration. We recommend N/2 data and parity blocks, as it ensures the best protection from drive failures.

[Snapshot API Diffs][guava-snapshot-api-diffs] are also available.

Another easy way to get to the Javadoc is to open
[guava.dev/api](https://guava.dev/api). You can also jump right to a specific
class by appending the class name to guava.dev. For example,
[guava.dev/ImmutableList](https://guava.dev/ImmutableList)!

## Learn about Guava

-   Our users' guide, [Guava Explained]

    // fail and will need to be rewritten.

    Class<?> frqC = FinalizableReferenceQueue.class;
    Class<?> sepFrqC = sepLoader.loadClass(frqC.getName());
    assertThat(frqC).isNotSameInstanceAs(sepFrqC);
    // Check the assumptions above.

    // FRQ tries to load the Finalizer class (for the reference-collecting thread) in a few ways.
    // If the class is accessible to the system ClassLoader (ClassLoader.getSystemClassLoader())

            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
            // Expected when null listener is set
        }
    }

    // Test helper classes
    private static class TestScriptEngine implements ScriptEngine {
        private String lastScript;
        private Map<String, Object> lastParams;
        private final String prefix;

        public TestScriptEngine() {

        }
    }
}


abstract class DependencyAdditionRule @Inject constructor(
    private val coordinates: String
) : ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {
        context.details.allVariants {
            withDependencies {
                add(coordinates)
            }
        }
    }
}


abstract class DependencyRemovalByGroupRule @Inject constructor(

   * return Iterables.filter(classes, subtypeOf(Number.class));
   * }
   *
   * The code above returns an iterable containing {@code Number.class} and {@code Long.class}.
   *
   * <p><b>Discouraged:</b> Prefer using {@code clazz::isAssignableFrom} or {@code x ->
   * clazz.isAssignableFrom(x)}, but note that lambdas do not have human-readable {@link
   * #toString()} representations and are not serializable.
   *

 * based on include/exclude patterns. This service provides a clean API for plugins
 * to create path matchers without directly depending on implementation classes.
 * <p>
 * The path matchers created by this service support Maven's traditional include/exclude
 * pattern syntax, which is compatible with the behavior of Maven 3 plugins like
 * maven-compiler-plugin and maven-clean-plugin.