*/
    public FileNotifyInformationImpl(final byte[] buffer, final int bufferIndex, final int len) throws IOException {
        decode(buffer, bufferIndex, len);
    }

    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        if (len == 0) {
            // nothing to do
            return 0;
        }
        final int start = bufferIndex;

            this.transportContext = SingletonContext.getInstance();
        }
        return this.transportContext;
    }

    @Override
    protected void parseURL(final URL u, String spec, final int start, int limit) {
        final String host = u.getHost();
        String path, ref;
        int port;

        if (spec.equals("smb://")) {
            spec = "smb:////";
            limit += 2;

  private final OkHttpClient client = new OkHttpClient.Builder()
      .addInterceptor(new GzipRequestInterceptor())
      .build();
  private final Moshi moshi = new Moshi.Builder().build();
  private final JsonAdapter<Map<String, String>> mapJsonAdapter = moshi.adapter(
      Types.newParameterizedType(Map.class, String.class, String.class));

  public void run() throws Exception {

            private static final Predicate<PathType> DEFAULT_FILTER = new AlwaysTrueFilter();

            private final RequestType requestType;
            private final Project project;
            private final Artifact rootArtifact;
            private final DependencyCoordinates root;
            private final Collection<DependencyCoordinates> dependencies;

        exception.expectMessage(is("index=2"));
        final ArrayIterator<Integer> itr = new ArrayIterator<Integer>(new Integer[] { 1, 2 });
        itr.next();
        itr.next();
        itr.next();
    }

    /**
     *
     */
    @Test
    public void testHasNext() {
        final ArrayIterator<String> itr = new ArrayIterator<String>("A", "B");

     */
    @Test
    public void testToCalendar() throws Exception {
        final Date date = new Date();
        final Calendar cal = CalendarConversionUtil.toCalendar(date);
        assertEquals(date, cal.getTime());
    }

    /**
     *
     * @throws Exception
     */
    @Test
    public void testLocalize() throws Exception {
        final Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("JST"));

import java.lang.reflect.Method;

/**
 * Context for an exception thrown by a subscriber.
 *
 * @since 16.0
 */
public class SubscriberExceptionContext {
  private final EventBus eventBus;
  private final Object event;
  private final Object subscriber;
  private final Method subscriberMethod;

  /**
   * @param eventBus The {@link EventBus} that handled the event and the subscriber. Useful for

/**
 * An ordering that orders elements by applying an order to the result of a function on those
 * elements.
 */
@GwtCompatible
final class ByFunctionOrdering<F extends @Nullable Object, T extends @Nullable Object>
    extends Ordering<F> implements Serializable {
  final Function<F, ? extends T> function;
  final Ordering<T> ordering;

  ByFunctionOrdering(Function<F, ? extends T> function, Ordering<T> ordering) {

        this(model, logger);
        this.type = type;
    }

    @Override
    public final String getType() {
        return type != null ? type : model.getType();
    }

    @Override
    public final ToolchainModel getModel() {
        return model;
    }

    public final void addProvideToken(String type, RequirementMatcher matcher) {
        provides.put(type, matcher);
    }

 *
 * @author Louis Wasserman
 */
@GwtCompatible
class FilteredKeyMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMultimap<K, V> implements FilteredMultimap<K, V> {
  final Multimap<K, V> unfiltered;
  final Predicate<? super K> keyPredicate;

  FilteredKeyMultimap(Multimap<K, V> unfiltered, Predicate<? super K> keyPredicate) {
    this.unfiltered = checkNotNull(unfiltered);