assertThat(args.length, is(1));
        assertThat(args[0].getRawClass(), is(sameClass(String.class)));
        assertThat(args[0].getArguments(), is(nullValue()));
    }

    /**
     * @author koichik
     */
    public interface Hoge {

        /** */
        public static Map<String, Set<Integer>[]> foo = null;

        /**
         * @param arg1
         * @param arg2

type Granted struct {
	index   int
	lockUID string // Locked if set with UID string, unlocked if empty
}

func (g *Granted) isLocked() bool {
	return isLocked(g.lockUID)
}

func isLocked(uid string) bool {
	return len(uid) > 0
}

// NewDRWMutex - initializes a new dsync RW mutex.
func NewDRWMutex(clnt *Dsync, names ...string) *DRWMutex {
	restClnts, _ := clnt.GetLockers()

    public String protocolScheme;

    /**
     * The username for authentication.
     */
    @Required
    @Size(max = 100)
    public String username;

    /**
     * The password for authentication.
     */
    @Size(max = 100)
    public String password;

    /**
     * Additional parameters for the authentication.
     */
    @Size(max = 1000)
    public String parameters;

    /**

    protected String commandOutputEncoding = Charset.defaultCharset().displayName();

    /** Command array for user update operations. */
    protected String[] updateCommand;

    /** Command array for user deletion operations. */
    protected String[] deleteCommand;

    /** Array of target usernames for command execution. */
    protected String[] targetUsers;

    @Override

    /** createdBy */
    protected String createdBy;

    /** createdTime */
    protected Long createdTime;

    /** expiredTime */
    protected Long expiredTime;

    /** name */
    protected String name;

    /** parameter_name */
    protected String parameterName;

    /** permissions */
    protected String[] permissions;

    /** token */
    protected String token;

  private final ElementOrder<Integer> nodeOrder;
  private final ElementOrder<String> edgeOrder;

  private ImmutableNetwork.Builder<Integer, String> networkBuilder;

  public StandardImmutableDirectedNetworkTest(
      boolean allowsSelfLoops,
      boolean allowsParallelEdges,
      ElementOrder<Integer> nodeOrder,
      ElementOrder<String> edgeOrder) {
    this.allowsSelfLoops = allowsSelfLoops;

            }
            final String url = System.getenv("SCA_URL");
            final String token = System.getenv("SCA_TOKEN");
            project.getGradle().getTaskGraph().whenReady(graph -> {
                List<String> depGraphTasks = graph.getAllTasks()
                    .stream()
                    .filter(t -> t instanceof DependenciesGraphTask)

        });
    }

    @Override
    public int load() {
        final Map<String, Pair<Map<String, String>, List<Pair<Pattern, String>>>> relatedContentMap = new HashMap<>();
        getAvailableRelatedContentList().stream().forEach(entity -> {
            final String key = getHostKey(entity);
            Pair<Map<String, String>, List<Pair<Pattern, String>>> pair = relatedContentMap.get(key);
            if (pair == null) {

		if _, err := xnet.ParseHost(b.String()); err != nil {
			return err
		}
	}
	return nil
}

// Name returns the name of the target
func (h *Target) Name() string {
	return "minio-kafka-audit"
}

// Endpoint - return kafka target
func (h *Target) Endpoint() string {
	return "kafka"
}

// String - kafka string
func (h *Target) String() string {
	return "kafka"
}

     */
    public static void addInterface(final String name, final String syntax) {
        INTERFACES.put(name, syntax);
    }

    String proto;
    String server;
    String endpoint = null;
    HashMap options = null;
    UUID uuid = null;
    int major;
    int minor;

    DcerpcBinding(final String proto, final String server) {
        this.proto = proto;
        this.server = server;
    }