stmt := gorm.Statement{DB: db, Table: user.Table, Schema: user, Clauses: map[string]clause.Clause{}}
		clauses := []clause.Interface{clause.Select{}, clause.From{}, clause.Where{Exprs: []clause.Expression{clause.Eq{Column: clause.PrimaryColumn, Value: "1"}, clause.Gt{Column: "age", Value: 18}, clause.Or(clause.Neq{Column: "name", Value: "jinzhu"})}}}

		for _, clause := range clauses {
			stmt.AddClause(clause)
		}

			policy:             `{"expiration": "%s","conditions":[["eq", "$bucket", "` + bucketName + `"], ["starts-with", "$key", "test/"], ["eq", "$x-amz-algorithm", "AWS4-HMAC-SHA256"], ["eq", "$x-amz-date", "%s"], ["eq", "$x-amz-credential", "` + credentials.AccessKey + `/%s/us-east-1/s3/aws4_request"],["eq", "$x-amz-meta-uuid", "1234"],["eq", "$content-encoding", "gzip"]]}`,
		},
		// Success case, no multipart filename.
		{

        byte[] mic = new byte[] { 3 };
        // No exception means success
        doNothing().when(gssContext).verifyMIC(eq(mic), eq(0), eq(1), eq(data), eq(0), eq(2), any());

        assertDoesNotThrow(() -> ctx.verifyMIC(data, mic));
        verify(gssContext, times(1)).verifyMIC(eq(mic), eq(0), eq(1), eq(data), eq(0), eq(2), any());
    }

    @Test
    @DisplayName("verifyMIC wraps GSSException into CIFSException")

            jcifs.SID member = new SID("S-1-5-21-1000");
            jcifs.SID[] expected = new jcifs.SID[] { member };
            when(mockResolver.getGroupMemberSids(eq(mockCtx), eq("srv"), any(jcifs.SID.class), eq(512), eq(123))).thenReturn(expected);

            // Act
            jcifs.SID[] res = group.getGroupMemberSids("srv", mockCtx, 123);

            // Assert

    }

    @Test
    @DisplayName("send with multiple params returns the stubbed response")
    void send_withParams_returnsResponse() throws Exception {
        // Arrange
        when(tree.send(eq(request), eq(RequestParam.NO_TIMEOUT), eq(RequestParam.NO_RETRY))).thenReturn(response);

        // Act
        CommonServerMessageBlockResponse out = tree.send(request, RequestParam.NO_TIMEOUT, RequestParam.NO_RETRY);

        // Assert

        SmbFileHandleImpl sfd = mock(SmbFileHandleImpl.class);
        when(sfd.getInitialSize()).thenReturn(0L);
        when(src.openUnshared(eq(0), eq(SmbConstants.O_RDONLY), eq(SmbConstants.FILE_SHARE_READ), eq(SmbConstants.ATTR_NORMAL), eq(0)))
                .thenReturn(sfd);

        // openCopyTargetFile should be called by serverSideCopy, so dest.openUnshared must succeed

					Exprs: []clause.Expression{clause.Eq{clause.Column{Table: "user_info", Name: "user_id"}, clause.PrimaryColumn}},
				},
			},
			sql: "LEFT JOIN `user` ON `user_info`.`user_id` = `users`.`id`",
		},
		{
			name: "RIGHT JOIN",
			join: clause.Join{
				Type:  clause.RightJoin,
				Table: clause.Table{Name: "user"},
				ON: clause.Where{

        // Must use matchers for all arguments when using any matcher
        mockedStaticAuthData.when(() -> KerberosAuthData.parse(eq(1), eq(new byte[] { 0x01 }), any(Map.class)))
                .thenReturn(Collections.singletonList(mockAuthData1));
        mockedStaticAuthData.when(() -> KerberosAuthData.parse(eq(2), eq(new byte[] { 0x02 }), any(Map.class)))
                .thenReturn(Collections.singletonList(mockAuthData2));

        doThrow(new IllegalArgumentException("invalid share/service")).when(session).getSmbTree(eq(share), eq(service));

        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> session.getSmbTree(share, service));
        assertTrue(ex.getMessage().contains("invalid"));
        verify(session).getSmbTree(eq(share), eq(service));
    }

    // Edge: unknown service returns null per stub
    @Test

        int i, ch, st, eq;

        st = eq = 0;
        for (i = 0; i < in.length; i++) {
            ch = in[i];
            if (ch == '&') {
                if (eq > st) {
                    final String p = new String(in, st, eq - st);
                    if (p.equalsIgnoreCase(param)) {
                        eq++;
                        return new String(in, eq, i - eq);
                    }