public final int previousIndex() {
    return backingIterator().previousIndex();
  }

  @Override
  public void set(@ParametricNullness T element) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void add(@ParametricNullness T element) {
    throw new UnsupportedOperationException();
  }

  public final int previousIndex() {
    return backingIterator().previousIndex();
  }

  @Override
  public void set(@ParametricNullness T element) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void add(@ParametricNullness T element) {
    throw new UnsupportedOperationException();
  }

                        }
                    }
                    bw.write("\n");
                }
                bw.flush();
            } catch (IOException e) {
                throw new IORuntimeException(e);
            }
        }).execute()) {
            if (logger.isDebugEnabled()) {
                logger.debug("Bulk Response:\n{}", response.getContentAsString());
            }

    private static final int MINIMAL_BUFFER_SIZE = 32;

    private byte[] credentialType;


    public PacCredentialType ( byte[] data ) throws PACDecodingException {
        this.credentialType = data;
        if ( !isCredentialTypeCorrect() ) {
            throw new PACDecodingException("Invalid PAC credential type");
        }
    }


    public boolean isCredentialTypeCorrect () {

public class CloseableUtilTest {

    /**
     * @throws Exception
     */
    @Test
    public void testClose() throws Exception {
        final NotifyOutputStream out = new NotifyOutputStream();
        CloseableUtil.close(out);
        assertThat(out.getNotify(), is("closed"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testCloseNull() throws Exception {

         * the user calls remove().)
         */
        return iterator.hasNext() || iterable.iterator().hasNext();
      }

      @Override
      @ParametricNullness
      public T next() {
        if (!iterator.hasNext()) {
          iterator = iterable.iterator();
          if (!iterator.hasNext()) {
            throw new NoSuchElementException();
          }

        public DateFormat next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            final int style = STYLES[index++];
            return DateFormat.getDateInstance(style, locale);
        }

        @Override
        public void remove() {
            throw new ClUnsupportedOperationException("remove");
        }

    }

    /**

        return null;
    }

    @Override
    public Path getRootDirectory() {
        throw new IllegalStateException();
    }

    @Override
    public List<Project> getProjects() {
        return List.of();
    }

    @Override
    public Map<String, Object> getPluginContext(Project project) {
        throw new UnsupportedInStandaloneModeException();
    }

    static class Providers {

    switch (edgesConnecting.size()) {
      case 0:
        return null;
      case 1:
        return edgesConnecting.iterator().next();
      default:
        throw new IllegalArgumentException(String.format(MULTIPLE_EDGES_CONNECTING, nodeU, nodeV));
    }
  }

  @Override
  @CheckForNull
  public E edgeConnectingOrNull(EndpointPair<N> endpoints) {

    @Override
    public Object invoke(Object target, Method method, Object[] args) throws Throwable {
      assertTrue("setUp should have run", setUpRan.get());
      try {
        return method.invoke(map, args);
      } catch (InvocationTargetException e) {
        throw e.getCause();
      } catch (IllegalAccessException e) {
        throw newLinkageError(e);
      }
    }
  }