@Override
  public TestContainerGenerator<T, E> getInnerGenerator() {
    return generator;
  }

  @Override
  public SampleElements<E> samples() {
    return generator.samples();
  }

  @Override
  public T create(Object... elements) {
    return generator.create(elements);
  }

  @Override
  public E[] createArray(int length) {
    return generator.createArray(length);
  }

  @Override

     *
     * @param o
     *            変換元のオブジェクト
     * @return 変換された{@link Calendar}
     */
    public static Calendar toCalendar(final Object o) {
        return toCalendar(o, null);
    }

    /**
     * {@link Calendar}に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @param pattern
     *            パターン文字列
     * @return 変換された{@link Calendar}
     */

        return consumerPom(session != null ? session.getUserProperties() : null);
    }

    private static boolean doGet(Properties userProperties, String key, boolean def) {
        return doGet(userProperties != null ? userProperties.get(key) : null, def);
    }

    private static boolean doGet(Map<String, ?> userProperties, String key, boolean def) {

 */
public interface SmbPipeHandleInternal extends SmbPipeHandle {

    /**
     * @return the pipe type
     */
    int getPipeType ();


    /**
     * @return session key of the underlying smb session
     * @throws CIFSException
     */
    byte[] getSessionKey () throws CIFSException;


    /**
     * 
     * @return this pipe's input stream
     * @throws SmbException
     */
    @Override

            return 0;
        }
        System.arraycopy( pipeData, pipeDataOff, dst, dstIndex, pipeDataLen );
        return pipeDataLen;
    }
    int readParametersWireFormat( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }
    int readDataWireFormat( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }
    public String toString() {

                 * though they may be.
                 */
            }
            return true;
        }
        return false;
    }


    /**
     * @return whether the hashes are externally supplied
     */
    public boolean areHashesExternal () {
        return this.hashesExternal;
    }


    /**
     * {@inheritDoc}
     *

      return standardContainsAll(collection);
    }

    @Override
    public boolean remove(Object object) {
      return standardRemove(object);
    }

    @Override
    public boolean removeAll(Collection<?> collection) {
      return standardRemoveAll(collection);
    }

    @Override
    public boolean retainAll(Collection<?> collection) {
      return standardRetainAll(collection);
    }

	if !colorize {
		return ""
	}

	prefix, ok := colorPrefixes[m.Type.Level()]
	if !ok {
		return ""
	}
	return prefix
}

func colorSuffix(colorize bool) string {
	if !colorize {
		return ""
	}
	return "\033[0m"
}

func IstioctlColorDefault(writer io.Writer) bool {
	if strings.EqualFold(termEnvVar.Get(), "dumb") {
		return false
	}

    }

    public long getAccessCount() {
        return accessCount.get();
    }

    public long incrementAndGetAccessCount() {
        return accessCount.incrementAndGet();
    }

    public long decrementAndGetAccessCount() {
        return accessCount.decrementAndGet();
    }

    public CrawlerStatus getStatus() {
        return status;
    }

        this.dialect = dialectId;
    }


    /**
     * @return the smb2
     */
    public final boolean isSMB2 () {
        return this.smb2;
    }


    /**
     * @return the dialect
     */
    public final int getDialect () {
        if ( !this.smb2 ) {
            throw new UnsupportedOperationException();
        }
        return this.dialect;
    }


    /**
     *