assertSuppressed(
        new Suppression(c2, tryException, c2Exception),
        new Suppression(c1, tryException, c1Exception));
  }

  public void testErrors() throws IOException {
    Closer closer = new Closer(suppressor);

    Error c1Exception = new Error();
    Error c2Exception = new Error();
    Error c3Exception = new Error();

            _src.advance(1 * _nodes);

            if (this.node == null) {
                if (_nodes < 0 || _nodes > 0xFFFF) {
                    throw new NdrException(NdrException.INVALID_CONFORMANCE);
                }
                this.node = new byte[_nodes];
            }
            _src = _src.derive(_nodei);
            for (int _i = 0; _i < _nodes; _i++) {
                this.node[_i] = (byte) _src.dec_ndr_small();

        final Deferred<SuggestResponse> deferred = new Deferred<>();

        Thread th = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignore) {}
            deferred.resolve(new SuggestResponse("", 0, Collections.emptyList(), 0, null));
        });
        th.start();

        final CountDownLatch latch = new CountDownLatch(1);

                SuggestItem.Kind.DOCUMENT);

        String[][] readings2Query = new String[2][];
        readings2Query[0] = new String[] { "zenbun", "fuga" };
        readings2Query[1] = new String[] { "kensaku", "fuga" };
        String[] tags2Query = new String[] { "tag4" };

    AtomicDoubleArray aa = new AtomicDoubleArray(VALUES);
    assertEquals(Arrays.toString(VALUES), aa.toString());
    assertEquals("[]", new AtomicDoubleArray(0).toString());
    assertEquals("[]", new AtomicDoubleArray(new double[0]).toString());
  }

  /** compareAndSet treats +0.0 and -0.0 as distinct values */
  public void testDistinctZeros() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);

        final String[] loggerNames = loggerNamePrefix != null
                ? Arrays.stream(loggerNamePrefix.split(",")).map(String::trim).filter(s -> s.length() > 0).toArray(n -> new String[n])
                : new String[0];
        return new ErrorToWarnRewritePolicy(loggerNames);
    }

import okio.Okio;
import okio.Source;

public final class Progress {

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

    final ProgressListener progressListener = new ProgressListener() {
      boolean firstUpdate = true;

      @Override public void update(long bytesRead, long contentLength, boolean done) {

    public MavenExecutionPlan calculateExecutionPlan(MavenSession session, String... tasks) {
        return new MavenExecutionPlan(null, new DefaultLifecycles());
    }

    @Override
    public MavenExecutionPlan calculateExecutionPlan(MavenSession session, boolean setup, String... tasks) {
        return new MavenExecutionPlan(null, new DefaultLifecycles());
    }

    @Override
    public void execute(MavenSession session) {}

        final DictionaryManager dictionaryManager = new DictionaryManager();
        final SynonymCreator synonymCreator = new SynonymCreator();
        final SynonymFile synonymFile = (SynonymFile) synonymCreator.create(file1.getPath(), new Date());
        dictionaryManager.store(synonymFile, file1);
        final DictionaryFile<? extends DictionaryItem>[] synonymFiles = dictionaryManager.getDictionaryFiles();

 * <ul>
 *   <li>{@link #SuggestSettingsException(String)}: Constructs a new exception with the specified detail message.</li>
 *   <li>{@link #SuggestSettingsException(Throwable)}: Constructs a new exception with the specified cause.</li>
 *   <li>{@link #SuggestSettingsException(String, Throwable)}: Constructs a new exception with the specified detail message and cause.</li>
 * </ul>
 *
 * @see RuntimeException
 */