public WebAuthenticationCB acceptPK(String id) {
        assertObjectNotNull("id", id);
        BsWebAuthenticationCB cb = this;
        cb.query().docMeta().setId_Equal(id);
        return (WebAuthenticationCB) this;
    }

    @Override
    public void acceptPrimaryKeyMap(Map<String, ? extends Object> primaryKeyMap) {
        acceptPK((String) primaryKeyMap.get("_id"));
    }

        this.bufferCache = new BufferCacheImpl(this.config);
        this.transportPool = new SmbTransportPoolImpl();
        String defUser = config.getDefaultUsername();
        String defPassword = config.getDefaultPassword();
        String defDomain = config.getDefaultDomain();
        if ( defUser != null ) {
            this.defaultCredentials = new NtlmPasswordAuthenticator(defDomain, defUser, defPassword);

// Destination - destination in ReplicationConfiguration.
type Destination struct {
	XMLName      xml.Name `xml:"Destination" json:"Destination"`
	Bucket       string   `xml:"Bucket" json:"Bucket"`
	StorageClass string   `xml:"StorageClass" json:"StorageClass"`
	ARN          string
	// EncryptionConfiguration TODO: not needed for MinIO
}

func (d Destination) isValidStorageClass() bool {
	if d.StorageClass == "" {
		return true
	}

        assertThat(hoge.getKeyClassOfMap(), is(sameClass(String.class)));
        assertThat(hoge.getValueClassOfMap(), is(sameClass(Integer.class)));
    }

    /**
     *
     */
    @SuppressWarnings("unused")
    public static class MyBean {
        /** */
        public static final String HOGE = "hoge";

        private Class<?> aaa;

        private List<String> list;

  val webSocket: WebSocket?,
  val body: String?,
  val failure: IOException?,
) {
  fun assertRequestUrl(url: HttpUrl) =
    apply {
      assertThat(request.url).isEqualTo(url)
    }

  fun assertRequestMethod(method: String) =
    apply {
      assertThat(request.method).isEqualTo(method)
    }

  fun assertRequestHeader(
    name: String,
    vararg values: String,
  ) = apply {

                    return;
                }
            } else { /* Basic */
                String auth = new String( Base64.decode( msg.substring(6) ), "US-ASCII" );
                int index = auth.indexOf( ':' );
                String user = (index != -1) ? auth.substring(0, index) : auth;
                String password = (index != -1) ? auth.substring(index + 1) : "";
                index = user.indexOf('\\');

//      output tensor naming, but it the index is actually an input index)
struct EdgeSpec : public std::pair<string, string> {
  typedef std::pair<string, string> Base;

  // Inherit the set of constructors
  using Base::pair;

  string ToString() const { return strings::StrCat(first, "->", second); }
};

class CApiFunctionTest : public ::testing::Test {
 protected:
  CApiFunctionTest()

/**
 * @author ESFlute (using FreeGen)
 */
public class RelatedQuery extends BsRelatedQuery {

    private static final long serialVersionUID = 1L;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

@Experimental
@Documented
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface Config {

    Source source() default Source.USER_PROPERTIES;

    String type() default "java.lang.String";

    String defaultValue() default "";

    boolean readOnly() default false;

    enum Source {
        USER_PROPERTIES,
        MODEL
    }

    private File pomFile;

    public MavenExecutionException(String message, File pomFile) {
        super(message);
        this.pomFile = pomFile;
    }

    public MavenExecutionException(String message, File pomFile, ProjectBuildingException cause) {
        super(message, cause);
        this.pomFile = pomFile;
    }

    public MavenExecutionException(String message, Throwable cause) {
        super(message, cause);
    }