super(domain != null ? domain : tc.getConfig().getDefaultDomain(),
                username != null ? username : tc.getConfig().getDefaultUsername() != null ? tc.getConfig().getDefaultUsername() : "GUEST",
                password != null ? password : tc.getConfig().getDefaultPassword() != null ? tc.getConfig().getDefaultPassword() : "",

				Columns: []clause.Column{{Name: "active"}},
				Values:  [][]interface{}{{true}},
			},
		},
	}

	for _, tc := range testCase {
		t.Run(tc.name, func(t *testing.T) {
			actual := ConvertMapToValuesForCreate(&gorm.Statement{}, tc.input)
			if !reflect.DeepEqual(actual, tc.expect) {
				t.Errorf("expect %v got %v", tc.expect, actual)
			}
		})
	}
}

func TestConvertSliceOfMapToValuesForCreate(t *testing.T) {

     *
     * @param host the hostname to resolve
     * @param tc the CIFS context
     * @return resolved name, null if not found
     */
    public synchronized NbtAddress getByName(final String host, final CIFSContext tc) {
        return getByName(new Name(tc.getConfig(), host, 0x20, null), tc);
    }

    synchronized NbtAddress getByName(final Name name, final CIFSContext tc) {
        NbtAddress result = null;

        try {

     * environment.
     *
     * @param tc
     *            context to use
     */
    public Type1Message(final CIFSContext tc) {
        this(tc, getDefaultFlags(tc), tc.getConfig().getDefaultDomain(), tc.getNameServiceClient().getLocalHost().getHostName());
    }

    /**
     * Creates a Type-1 message with the specified parameters.
     *
     * @param tc
     *            context to use
     * @param flags

    /**
     * Get transport connection
     *
     * @param tc
     *            context to use
     * @param address the server address
     * @param port the port number
     * @param exclusive
     *            whether to acquire an unshared connection
     * @return a transport connection to the target
     */
    SmbTransport getSmbTransport(CIFSContext tc, Address address, int port, boolean exclusive);

    /**

     */
    public NtlmPasswordAuthentication doAuthentication(final CIFSContext tc, final HttpServletRequest req, final HttpServletResponse resp,
            final byte[] challenge) throws IOException {
        return authenticate(tc, req, resp, challenge);
    }

    /**
     * Performs NTLM authentication for the servlet request.
     *
     * @param tc
     *            context to use
     *
     * @param req

     *
     * @param tc
     *            context to use
     * @return whether this address is in conflict with another address
     * @throws UnknownHostException
     *             if the host cannot be resolved to find out.
     */
    boolean isInConflict(CIFSContext tc) throws UnknownHostException;

    /**
     * Determines if this address is active.
     *
     * @param tc
     *            context to use

     * @throws GeneralSecurityException if a security error occurs during authentication
     */
    public SmbComSessionSetupAndX(final CIFSContext tc, final SmbComNegotiateResponse negotiated, final ServerMessageBlock andx,
            final Object cred) throws SmbException, GeneralSecurityException {
        super(tc.getConfig(), SMB_COM_SESSION_SETUP_ANDX, andx);
        this.negotiated = negotiated;

        this.overrideTimeout = overrideTimeout;
    }

    /**
     *
     * @return create response
     */
    @Override
    public T initResponse(final CIFSContext tc) {
        final T resp = createResponse(tc, this);
        if (resp == null) {
            return null;
        }
        resp.setDigest(getDigest());
        setResponse(resp);

        final ServerMessageBlock2 n = getNext();

     * @throws CIFSException if there is an error resolving the SIDs
     */
    void resolveSids(CIFSContext tc, String authorityServerName, SID[] sids) throws CIFSException;

    /**
     * Resolve part of an array of SIDs using a cache and at most one MSRPC request.
     *
     * @param tc the CIFS context to use
     * @param authorityServerName the server to use for SID resolution