/**
 * An SSLSocketFactory that delegates calls. Sockets created by the delegate are wrapped with ones
 * that will not accept the [TLS_FALLBACK_SCSV] cipher, thus bypassing server-side fallback
 * checks on platforms that support it. Unfortunately this wrapping will disable any
 * reflection-based calls to SSLSocket from Platform.
 */
class FallbackTestClientSocketFactory(
  delegate: SSLSocketFactory,
) : DelegatingSSLSocketFactory(delegate) {

    }

    private static class LineItr implements Iterator<String> {
        private final Iterator<String> delegate;
        private int lastLineNumber;

        LineItr(Iterator<String> delegate) {
            this.delegate = delegate;
        }

        @Override
        public boolean hasNext() {
            return delegate.hasNext();
        }

        @Override
        public String next() {
            lastLineNumber++;

        .addEqualityGroup(list2, wrap(list2))
        .testEquals();
  }

  private static <T> List<T> wrap(List<T> delegate) {
    return new ForwardingList<T>() {
      @Override
      protected List<T> delegate() {
        return delegate;
      }
    };
  }

        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

  private static <T> SortedMultiset<T> wrap(SortedMultiset<T> delegate) {
    return new ForwardingSortedMultiset<T>() {
      @Override
      protected SortedMultiset<T> delegate() {
        return delegate;
      }
    };
  }

        .addEqualityGroup(list2, wrap(list2))
        .testEquals();
  }

  private static <T> List<T> wrap(List<T> delegate) {
    return new ForwardingList<T>() {
      @Override
      protected List<T> delegate() {
        return delegate;
      }
    };
  }

    }

    private static class IndentingOutputStream extends OutputStream {

        public final byte[] indent;
        private final OutputStream delegate;

        IndentingOutputStream(OutputStream delegate, Object version) {
            this.delegate = delegate;
            indent = (" [" + version + "] ").getBytes(StandardCharsets.UTF_8);
        }

        @Override

        .addEqualityGroup(map2, wrap(map2))
        .testEquals();
  }

  private static <K, V> Multimap<K, V> wrap(Multimap<K, V> delegate) {
    return new ForwardingMultimap<K, V>() {
      @Override
      protected Multimap<K, V> delegate() {
        return delegate;
      }
    };
  }

        .addEqualityGroup(table2, wrap(table2))
        .testEquals();
  }

  private static <R, C, V> Table<R, C, V> wrap(Table<R, C, V> delegate) {
    return new ForwardingTable<R, C, V>() {
      @Override
      protected Table<R, C, V> delegate() {
        return delegate;
      }
    };
  }

    return tailMap(fromKey);
  }

  private ImmutableSortedMap<K, V> newView(SortedMap<K, V> delegate) {
    return newView(delegate, comparator);
  }

  private static <K, V> ImmutableSortedMap<K, V> newView(
      SortedMap<K, V> delegate, Comparator<? super K> comparator) {
    return new ImmutableSortedMap<K, V>(delegate, comparator);
  }

  /*

        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

  private static <T> SortedMultiset<T> wrap(SortedMultiset<T> delegate) {
    return new ForwardingSortedMultiset<T>() {
      @Override
      protected SortedMultiset<T> delegate() {
        return delegate;
      }
    };
  }