*
     * @param writer a writer object.
     * @param model a model object.
     * @throws IOException java.io.IOException if any.
     */
    public void write(Writer writer, Model model) throws IOException {
        try {
            delegate.write(writer, model.getDelegate());
        } catch (XMLStreamException e) {
            throw new IOException(e);
        }
    } // -- void write( Writer, Model )

    /**

   * @return all the constraints implicitly or explicitly required by the class or any of its
   *     superclasses.
   * @throws ConflictingRequirementsException if the requirements are mutually inconsistent.
   */
  public static TesterRequirements getTesterRequirements(Class<?> testerClass)
      throws ConflictingRequirementsException {
    synchronized (classTesterRequirementsCache) {

        } catch (XMLStreamException e) {
            throw new SettingsParseException(
                    e.getMessage(),
                    e.getLocation().getLineNumber(),
                    e.getLocation().getColumnNumber(),
                    e);
        }
    }

    @Override
    public Settings read(Reader input, Map<String, ?> options) throws IOException {

        public void encode ( NdrBuffer _dst ) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_referent(this.entry_path, 1);

            if ( this.entry_path != null ) {
                _dst = _dst.deferred;
                _dst.enc_ndr_string(this.entry_path);

            }
        }


        @Override
        public void decode ( NdrBuffer _src ) throws NdrException {
            _src.align(4);

    public LsaPolicyHandle ( DcerpcHandle handle, String server, int access ) throws IOException {
        this.handle = handle;
        if ( server == null ) {
            server = "\\\\";
        }
        MsrpcLsarOpenPolicy2 rpc = new MsrpcLsarOpenPolicy2(server, access, this);
        handle.sendrecv(rpc);
        if ( rpc.retval != 0 ) {
            throw new SmbException(rpc.retval, false);
        }
        this.opened = true;

    }
  }

  /**
   * @throws UnsupportedOperationException {@inheritDoc}
   * @throws ClassCastException {@inheritDoc}
   * @throws NullPointerException {@inheritDoc}
   * @throws IllegalArgumentException {@inheritDoc}
   */
  @CanIgnoreReturnValue // pushed down from class to method
  @Override
  public int drainTo(Collection<? super E> c) {
    if (c == null) throw new NullPointerException();

        throw new UnsupportedOperationException("Cannot get available versions in this test case");
    }

    public List<ArtifactVersion> retrieveAvailableVersionsFromDeploymentRepository(
            Artifact artifact, ArtifactRepository localRepository, ArtifactRepository remoteRepository)
            throws ArtifactMetadataRetrievalException {

    this.path = path;
  }

  @Override public ServerSocket createServerSocket() throws IOException {
    return new UnixDomainServerSocket();
  }

  @Override public ServerSocket createServerSocket(int port) throws IOException {
    return createServerSocket();
  }

  @Override public ServerSocket createServerSocket(int port, int backlog) throws IOException {
    return createServerSocket();
  }

        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_referent(entry_path, 1);

            if (entry_path != null) {
                _dst = _dst.deferred;
                _dst.enc_ndr_string(entry_path);

            }
        }
        public void decode(NdrBuffer _src) throws NdrException {
            _src.align(4);

        return ticket;
    }


    /**
     * @param principal
     * @return
     * @throws RealmException
     */
    protected static PrincipalName convertPrincipal ( KerberosPrincipal principal ) throws RealmException {
        PrincipalName principalName = new PrincipalName(
            principal.getName() + PrincipalName.NAME_REALM_SEPARATOR + principal.getRealm(),