package org.codelibs.fess.util;

import org.codelibs.fess.unit.UnitFessTestCase;

public class ResourceUtilTest extends UnitFessTestCase {
    public void test_resolve() {
        String value;

        value = null;
        assertNull(ResourceUtil.resolve(value));

        value = "";
        assertEquals("", ResourceUtil.resolve(value));

        value = "a";
        assertEquals(value, ResourceUtil.resolve(value));

    private final DcerpcHandle handle;
    private boolean opened;


    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 ) {

        assertFalse(ModifierUtil.isAbstract(HashMap.class));
    }

    /**
     *
     */
    public static class Hoge {

        /**
         *
         */
        public static final String s = null;

        /**
         * @return 何か
         */
        public static String hoge() {
            return "aaa";
        }

        /**
         *
         */
        public String aaa;

        this.userProperties = userProperties;
        return this;
    }

    public Properties getUserProperties() {
        if (userProperties == null) {
            userProperties = new Properties();
        }

        return userProperties;
    }

    public Properties getExecutionProperties() {
        return executionProperties;
    }

                    "properties": {
                        "name": {"type": "string", "title": "Name"},
                        "description": {
                            "anyOf": [{"type": "string"}, {"type": "null"}],
                            "title": "Description",
                        },
                    },
                    "type": "object",
                    "required": ["name"],

    }

    @Override
    public Violation maybeViolation(final JApiCompatibility member) {

        if (shouldSkipViolationCheckFor(member) || getRepository().isSince(getCurrentVersion(), member)) {
            return null;
        }

        return acceptOrReject(member, Violation.error(member, SINCE_ERROR_MESSAGE + getCurrentVersion()));
    }

    private boolean shouldSkipViolationCheckFor(JApiCompatibility member) {

    public PooledObject<T> wrap(final T obj) {
        return new DefaultPooledObject<>(obj);
    }

    @Override
    public void destroyObject(final PooledObject<T> p) throws Exception {
        if (onDestroyListener != null) {
            onDestroyListener.onDestroy(p);
        }
    }

    public interface OnDestroyListener<T> {
        void onDestroy(PooledObject<T> p);
    }

    public String getComponentName() {

              public Collection<String> create(String[] elements) {
                // TODO: MinimalCollection should perhaps throw
                for (Object element : elements) {
                  if (element == null) {
                    throw new NullPointerException();
                  }
                }
                return MinimalCollection.of(elements);
              }
            })
        .named("MinimalCollection")

 */

package jcifs.smb1.dcerpc.ndr;

import java.io.IOException;

public class NdrException extends IOException {

    public static final String NO_NULL_REF = "ref pointer cannot be null";
    public static final String INVALID_CONFORMANCE = "invalid array conformance";

    public NdrException( String msg ) {
        super( msg );
    }

        assertEquals("xxx", s.getLocalRepository());

        s = s.withLocalRepository("yyy");
        assertEquals("yyy", s.getLocalRepository());

        s = s.withLocalRepository(null);
        assertNull(s.getLocalRepository());
    }