public RandomAmountInputStream(InputStream in, Random random) {
    super(checkNotNull(in));
    this.random = checkNotNull(random);
  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    return super.read(b, off, random.nextInt(len) + 1);
  }

    return byteSource.wasStreamOpened();
  }

  @Override
  public boolean wasStreamClosed() {
    return byteSource.wasStreamClosed();
  }

  @Override
  public Reader openStream() throws IOException {
    return new InputStreamReader(byteSource.openStream(), UTF_8);
  }

 * under the License.
 */
package org.apache.maven.plugin;

import org.apache.maven.project.ProjectBuildingException;
import org.apache.maven.project.artifact.InvalidDependencyVersionException;

/**
 * Thrown when a plugin is not internally consistent.
 *
 */
public class InvalidPluginException extends Exception {
    public InvalidPluginException(String message, ProjectBuildingException e) {
        super(message, e);
    }

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.api.services;

/**
 * Exception thrown when toolchain factory operations fail.
 *
 * <p>This exception wraps errors that occur during toolchain creation or initialization.</p>
 */
public class ToolchainFactoryException extends MavenException {

              @Override
              public Collection<String> create(String[] elements) {
                // TODO: MinimalCollection should perhaps throw
                for (Object element : elements) {
                  if (element == null) {
                    throw new NullPointerException();
                  }
                }
                return MinimalCollection.of(elements);
              }
            })

import jcifs.internal.smb1.trans.SmbComTransaction;

class Trans2FindFirst2ResponseTest {

    private Trans2FindFirst2Response response;
    private Configuration config;

    @BeforeEach
    void setUp() throws Exception {
        MockitoAnnotations.openMocks(this);
        Properties props = new Properties();
        config = new PropertyConfiguration(props);
        response = new Trans2FindFirst2Response(config);
    }

 */
public final class PrintEventsNonConcurrent {
  private final OkHttpClient client = new OkHttpClient.Builder()
      .eventListener(new PrintingEventListener())
      .build();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();

    System.out.println("REQUEST 1 (new connection)");

        if (dup.add(values[0]) == false) {
            throw new IllegalArgumentException("Found duplicate term [" + values[0] + "] in user dictionary.");
        }
        return rule;
    }

    public static UserDictionary getUserDictionary(Environment env, Settings settings) {
        if (settings.get(USER_DICT_PATH_OPTION) != null && settings.get(USER_DICT_RULES_OPTION) != null) {
            throw new IllegalArgumentException(

   * {@code setCount()} to throw an exception, as checking the return value could produce an
   * incorrect error message like "setCount() should return the original count" instead of the
   * message passed to a later invocation of {@code fail()}, like "setCount should throw
   * UnsupportedOperationException."
   */
  abstract void setCountNoCheckReturnValue(E element, int count);

 * limitations under the License.
 */

package okhttp3.modules;

import okhttp3.Call;
import okhttp3.HttpUrl;

import java.io.IOException;

public class Main {
  public static void main(String[] args) throws IOException {
    Call call = OkHttpCaller.callOkHttp(HttpUrl.get("https://square.com/robots.txt"));

    System.out.println(call.execute().body().string());
  }